【HackerRank】Cut the tree

题目链接：Cut the tree

题解：题目要求求一条边，去掉这条边后得到的两棵树的节点和差的绝对值最小。

暴力求解会超时。

如果我们可以求出以每个节点为根的子树的节点之和，那么当我们去掉一条边(a,b)的时候，其中的一棵树必是以a或者b为根的子树，那么我们就可以知道生成的两棵树的节点之和了。所以，当我们得到以每个节点为根的子树节点和这个信息后（把这个信息存储在TreeNode的value变量中），通过遍历每个节点（每个节点为根的子树必然为某次cut得到的子树之一，例如下图中，2为根的子树对应切割边(1,2)得到的树，而5为根的子树对应切割边(1,5)得到的树），求出最小的W-2*root.value即为所求（W是所有节点的值得和）。

树节点的数据结构定义如下：

static class TreeNode{
    int value;
    int number;
    ArrayList<TreeNode> children;
    public TreeNode(int value,int number){
        this.value = value;
        this.number = number;
        children = new ArrayList<TreeNode>();
    }
}

value表示该顶点对应的值，number表示顶点的编号，children表示子节点的列表(这里指表示连接关系，也有可能children里面其实存放了父节点，不过可以用接下来的visited数组避免访问到父节点)。

然后从树的任意一个节点开始dfs，把它的value值依次加上各个child为root的子树节点值，就得到以它为root的子树的节点值得和了。而它的child为root的子树节点和就用递归的方法求。上面说了，每次读入一条边(a,b)的时候，即把b加入到a的children集合里面，也把a加入到b的children集合里面。那么在dfs的时候，怎么知道谁是父节点，谁是子节点呢？就用一个visited数组，因为在dfs过程中，父节点一定先被访问，所以在一个节点的children集合里面，已经被visited过的节点就不是它的子节点了。

最后代码如下：

import java.util.*;

public class Solution {
    static class TreeNode{
        int value;
        int number;
        ArrayList<TreeNode> children;
        public TreeNode(int value,int number){
            this.value = value;
            this.number = number;
            children = new ArrayList<TreeNode>();
        }
    }
    
    private static int dfs(TreeNode root,boolean[] visited){
        visited[root.number]=true;
        for(TreeNode child:root.children){
            if(!visited[child.number]){
                root.value += dfs(child, visited);
            }
        }
        return root.value;
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        TreeNode[] treeNodes = new TreeNode[n];
        int W  = 0;
        
        for(int i = 0;i < n;i++)
        {
            int value = in.nextInt();
            treeNodes[i]=new TreeNode(value,i);
            W += value;
        }
        
        for(int i = 0;i < n-1;i++){
            int a = in.nextInt();
            int b = in.nextInt();
            treeNodes[a-1].children.add(treeNodes[b-1]);
            treeNodes[b-1].children.add(treeNodes[a-1]);
        }
        
        boolean[] visited = new boolean[n];
        
        dfs(treeNodes[0], visited);
        int miniDif = Integer.MAX_VALUE;
        
        for(TreeNode t:treeNodes){
            miniDif = Math.min(miniDif, Math.abs(W-2*t.value));
        }
        
        System.out.println(miniDif);
        
        
        
    }
}

 另外要积累的一点是java中nested class和inner class的区别，见stackoverflow上面的详细解答，所以上述代码中第4行要把TreeNode声明为nested class，否则它只能通过类Solution调用。