插排树

链接：https://www.nowcoder.com/acm/contest/157/D
来源：牛客网
 

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 32768K，其他语言65536K
64bit IO Format: %lld

题目描述

一年一度的山东省oi夏令营又开始了，每到这个季节，山东的oier们都会欢聚这里，一起学（tuí）习（feì）。当然，为了能更加愉快地学（tuí）习（feì），就少不了要自带电脑，用电便开始成了一种问题，于是便有一种神奇的数据结构诞生了！这就是山东省oi专用数据结构——插排树（如图）

 

小K为了能更好的学（tuí）习（feì），所以他想尽量的往后做，所以现在请你帮帮他，他最远可以离讲台多远。

已知插排树的根节点在讲台上，有且仅有一个根节点（根节点入度为0），最远距离即所有插排的长度，小K电脑线的长度忽略不计

 

本题良心大样例下载地址： https://kench.co/tree.zip

输入描述:

第一行一个整数n表示有n个节点
然后n-1行，每行三个整数a,b,c，表示插排a是接在插排b上的，插排a的长度为c

输出描述:

一个整数n表示最远距离

 

示例1

输入

9
2 1 2
3 1 2
4 1 1
5 2 3
6 2 1
7 3 1
8 3 4
9 7 5

输出

8

说明

1=>3=>7=>9

 

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.InputStream;

class Node {
	ArrayList<Integer> list = new ArrayList<Integer>();
	int sum=0;
}

public class Main {
	
    public static void main(String[] args) throws FileNotFoundException {
//    	File file1 = new File("C:/Users/hasee/Desktop/tree.in");
//    	File file2 = new File("C:/Users/hasee/Desktop/2.txt");
//    	InputStream inputStream = new FileInputStream(file1);
//    	OutputStream outputStream = new FileOutputStream(file2);
    	InputStream inputStream = System.in;
    	OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
    
    static class TaskA {
    	
    	static ArrayList<String> list;
    	
        public void solve(int testNumber, InputReader in, PrintWriter out) {
        	
        	int a=in.nextInt();
            Node x[] = new Node[a+1];
            for(int n=0;n<=a;n++){
            	x[n] = new Node();
            }
            for(int n=1;n<a;n++){
            	int a1=in.nextInt();
            	int a2=in.nextInt();
            	int k=in.nextInt();
            	x[a2].list.add(a1);
            	x[a1].sum=k;
            }
            Queue<Node> t = new LinkedList<Node>(); 
            for(int n=1;n<=a;n++){
            	if(x[n].sum==0){
            		t.add(x[n]);
            		break;
            	}
            }
            int max=0;
            int num=0;
            while(!t.isEmpty()){
            	num++;
            	Node node = t.poll();
            	
            	if(node.sum>max)max=node.sum;
            	for(int n=0;n<node.list.size();n++){
            		x[node.list.get(n)].sum+=node.sum;	
            		t.add(x[node.list.get(n)]);
            		//System.out.println(node.list.get(n)+" "+t.size());
            	}
            }
            //System.out.println(num);
            System.out.println(max);
        	
        }
        

        
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        
        public double nextDouble() {
        	return Double.parseDouble(next());
        }

    }
}