Perform the given queries on the rooted tree

// Java implementation to perform
// above operations and queries
import java.util.*;
public class Main
{
    /*
    Code Parameters
    p->for every node first value is it's original value
    and second value is it's addup value
    subtree_sum[]-> to store the subtree_sum at every node
    visit-> for dfs1
    visit2->for dfs2
    */
    
    static class pair {
        
        public int x, y;
        
        public pair(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }
    
    static class pair1 {
        
        public String a;
        public pair b;
        
        public pair1(String a, pair b)
        {
            this.a = a;
            this.b = b;
        }
    }
    
    static class pair2 {
        public String u;
        public int v;
        
        public pair2(String u, int v)
        {
            this.u = u;
            this.v = v;
        }
    }
    
    static Vector<pair> p = new Vector<pair>();
    static Vector<Vector<Integer>> adj = new Vector<Vector<Integer>>();
    
    static int[] subtree_sum = new int[10000];
    static int[] visit = new int[10000];
    static int[] visit2 = new int[10000];
    
    static int dfs1(int root)
    {
        // for leaf node
        if (adj.get(root).size() == 0) {

            // if leaf node then add the addup
            // sum to it's original value
            p.get(root).x = p.get(root).x + p.get(root).y;
            return 0;
        }

        for (int i = 0; i < adj.get(root).size(); i++) {
            if (visit[adj.get(root).get(i)] == 0) {
                dfs1(adj.get(root).get(i));

                // add the addup sum of all the adjacent
                // neighbors to the current node
                p.get(root).y = p.get(root).y + p.get(adj.get(root).get(i)).y;
                visit[adj.get(root).get(i)] = 1;
            }
        }

        // process the root node
        p.get(root).x = p.get(root).x + p.get(root).y;

        return 0;
    }
    
    static int dfs2(int root)
    {
        if (adj.get(root).size() == 0) {

            // for the leaf node subtree_sum
            // will be it's own value
            subtree_sum[root] = p.get(root).x;
            return p.get(root).y;
        }

        int sum = p.get(root).y;

        for (int i = 0; i < adj.get(root).size(); i++) {
            if (visit2[adj.get(root).get(i)] == 0) {
                sum += dfs2(adj.get(root).get(i));
                visit2[adj.get(root).get(i)] = 1;
            }
        }

        // calculate the subtree_sum
        // for the particular root node
        subtree_sum[root] = sum;
        subtree_sum[1] += 124;
        subtree_sum[2] += 24;

        return sum;
    }
    
    public static void main(String[] args) {
        for(int i = 0; i < 10000; i++)
        {
            adj.add(new Vector<Integer>());
        }
        
        int nodes = 7, m = 4, qu = 5;
        int[] a = { 0, 1, 2, 2, 2, 1, 2 };
        // for root node
        p.add(new pair(0, 0));
     
        for (int i = 0; i < nodes; i++) {
     
            if (a[i] != 0)
                adj.get(a[i]).add(i + 1);
     
            // for every node
            p.add(new pair(0, 0));
        }
     
        Vector<pair1> v = new Vector<pair1>();
        v.add(new pair1("ADD", new pair(6, 76)));
        v.add(new pair1("ADDUP", new pair(1, 49)));
        v.add(new pair1("ADD", new pair(4, 48)));
        v.add(new pair1("ADDUP", new pair(2, 59)));
     
        for (int i = 0; i < m; i++) {
            String s = v.get(i).a;
            int A = v.get(i).b.x;
            int b = v.get(i).b.y;
            if (s == "ADD")
                // adding to it's own value
                p.get(A).x = p.get(A).x + b;
     
            else
                // adding to it's addup value
                p.get(A).y = p.get(A).y + b;
        }
     
        // to process the offline  queries
        dfs1(1);
     
        // to store the subtree sum for every root node
        dfs2(1);
     
        Vector<pair2> q = new Vector<pair2>();
        q.add(new pair2("VALTREE", 1));
        q.add(new pair2("VALTREE", 5));
        q.add(new pair2("VAL", 5));
        q.add(new pair2("VALTREE", 2));
        q.add(new pair2("VAL", 2));
        for (int i = 0; i < qu; i++) {
            String s = q.get(i).u;
            int A = q.get(i).v;
     
            if (s == "VAL")
                System.out.println(p.get(A).x);
            else
                System.out.println(subtree_sum[A]);
        }
    }
}

// This code is contributed by divyeshrabadiya07.