【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过的节点就不是它的子节点了。

最后代码如下：

 1 import java.util.*;
 2 
 3 public class Solution {
 4     static class TreeNode{
 5         int value;
 6         int number;
 7         ArrayList<TreeNode> children;
 8         public TreeNode(int value,int number){
 9             this.value = value;
10             this.number = number;
11             children = new ArrayList<TreeNode>();
12         }
13     }
14     
15     private static int dfs(TreeNode root,boolean[] visited){
16         visited[root.number]=true;
17         for(TreeNode child:root.children){
18             if(!visited[child.number]){
19                 root.value += dfs(child, visited);
20             }
21         }
22         return root.value;
23     }
24     
25     public static void main(String[] args) {
26         Scanner in = new Scanner(System.in);
27         int n = in.nextInt();
28         TreeNode[] treeNodes = new TreeNode[n];
29         int W  = 0;
30         
31         for(int i = 0;i < n;i++)
32         {
33             int value = in.nextInt();
34             treeNodes[i]=new TreeNode(value,i);
35             W += value;
36         }
37         
38         for(int i = 0;i < n-1;i++){
39             int a = in.nextInt();
40             int b = in.nextInt();
41             treeNodes[a-1].children.add(treeNodes[b-1]);
42             treeNodes[b-1].children.add(treeNodes[a-1]);
43         }
44         
45         boolean[] visited = new boolean[n];
46         
47         dfs(treeNodes[0], visited);
48         int miniDif = Integer.MAX_VALUE;
49         
50         for(TreeNode t:treeNodes){
51             miniDif = Math.min(miniDif, Math.abs(W-2*t.value));
52         }
53         
54         System.out.println(miniDif);
55         
56         
57         
58     }
59 }

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

转载于:https://www.cnblogs.com/sunshineatnoon/p/3914990.html