Language: Java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;

import java.util.Map.Entry;
 
public class Main {
	static public class SegmentTree {		// 1-based DS, OOP
		
		int N; 			//the number of elements in the array as a power of 2 (i.e. after padding)
		int[] array, sTree, lazy;
		
		SegmentTree(int[] in)		
		{
			array = in; N = in.length - 1;
			sTree = new int[N<<1];		//no. of nodes = 2*N - 1, we add one to cross out index zero
			lazy = new int[N<<1];
			//build(1,1,N);
		}
		
		void build(int node, int b, int e)	// O(n)
		{
			if(b == e)					
				sTree[node] = array[b];
			else						
			{
				int mid = b + e >> 1;
				build(node<<1,b,mid);
				build(node<<1|1,mid+1,e);
				sTree[node] = sTree[node<<1]+sTree[node<<1|1];
			}
		}
		
		
		void update_point(int index, int val)			// O(log n)
		{
			index += N - 1;				
			sTree[index] += val;			
			while(index>1)				
			{
				index >>= 1;
				sTree[index] = sTree[index<<1] + sTree[index<<1|1];		
			}
		}
		
		
		void update_range(int i, int j, int val)		// O(log n) 
		{
			update_range(1,1,N,i,j,val);
		}
		
		void update_range(int node, int b, int e, int i, int j, int val)
		{
			if(i > e || j < b)		
				return;
			if(b >= i && e <= j)		
			{
				sTree[node] += (e-b+1)*val;			
				lazy[node] += val;				
			}							
			else		
			{
				int mid = b + e >> 1;
				propagate(node, b, mid, e);
				update_range(node<<1,b,mid,i,j,val);
				update_range(node<<1|1,mid+1,e,i,j,val);
				sTree[node] = sTree[node<<1] + sTree[node<<1|1];		
			}
			
		}
		void propagate(int node, int b, int mid, int e)		
		{
			lazy[node<<1] += lazy[node];
			lazy[node<<1|1] += lazy[node];
			sTree[node<<1] += (mid-b+1)*lazy[node];		
			sTree[node<<1|1] += (e-mid)*lazy[node];		
			lazy[node] = 0;
		}
		
		int query(int i, int j)
		{
			return query(1,1,N,i,j);
		}
		
		int query(int node, int b, int e, int i, int j)	// O(log n)
		{
			if(i>e || j <b)
				return 0;		
			if(b>= i && e <= j)
				return sTree[node];
			int mid = b + e >> 1;
			propagate(node, b, mid, e);
			int q1 = query(node<<1,b,mid,i,j);
			int q2 = query(node<<1|1,mid+1,e,i,j);
			return q1 + q2;	
					
		}
	}
	static int nodes=0;
	static int[]tin,tout,nod;
	static boolean[]v;
	static LinkedList<Integer>adj[];
	static void dfs(int i) {
		v[i]=true;
		nod[nodes]=i;
		tin[i]=++nodes;
		
		for(int j:adj[i]) {
			if(!v[j])dfs(j);
			
		}
		tout[i]=nodes;
	}
	public static void main(String[] args) throws IOException {
		MScanner sc = new MScanner(System.in);
		PrintWriter pw=new PrintWriter(System.out);
		int n = sc.nextInt();int q=sc.nextInt();
		adj=new LinkedList[n];v=new boolean[n];
		for(int i=0;i<n;i++)adj[i]=new LinkedList<Integer>();
		for(int i=0;i<n-1;i++) {
			int u=sc.nextInt()-1;int v=sc.nextInt()-1;
			adj[u].add(v);adj[v].add(u);
		}
		tin=new int[n];tout=new int[n];nod=new int[n];
		dfs(0);
		int N = 1; while(N < n) N <<= 1; //padding
		
		int[] in = new int[N + 1];
		for(int i = 1; i <= n; i++)
			in[i] = nod[i-1];
		SegmentTree st=new SegmentTree(in);
		while(q-->0) {
			int no=sc.nextInt()-1;int val=sc.nextInt();
			//System.out.println(tin[no]+" "+tout[no]+" "+val);
			st.update_range(tin[no], tout[no], val);
		}
		for(int i=1;i<=n;i++) {
			pw.print(st.query(i, i)+" ");
		}
		pw.flush();
 
	}
    static class MScanner {
		StringTokenizer st;
		BufferedReader br;
 
		public MScanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}
 
		public MScanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}
 
		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
 
		public String nextLine() throws IOException {
			return br.readLine();
		}
 
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
 
		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}
 
		public char nextChar() throws IOException {
			return next().charAt(0);
		}
 
		public Long nextLong() throws IOException {
			return Long.parseLong(next());
		}
 
		public boolean ready() throws IOException {
			return br.ready();
		}
 
		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}

Compiler output:
Main.java:105: error: cannot find symbol
	static LinkedList<Integer>adj[];
	       ^
  symbol:   class LinkedList
  location: class Main
Main.java:147: error: cannot find symbol
		StringTokenizer st;
		^
  symbol:   class StringTokenizer
  location: class MScanner
Main.java:121: error: cannot find symbol
		adj=new LinkedList[n];v=new boolean[n];
		        ^
  symbol:   class LinkedList
  location: class Main
Main.java:122: error: cannot find symbol
		for(int i=0;i<n;i++)adj[i]=new LinkedList<Integer>();
		                               ^
  symbol:   class LinkedList
  location: class Main
Main.java:160: error: cannot find symbol
				st = new StringTokenizer(br.readLine());
				         ^
  symbol:   class StringTokenizer
  location: class MScanner
5 errors