华为OD 找城市

题目描述：

一张地图上有n个城市，城市和城市之间有且只有一条道路相连：要么直接相连，要么通过其它城市中转相连（可中转一次或多次）。城市与城市之间的道路都不会成环。

当切断通往某个城市 i 的所有道路后，地图上将分为多个连通的城市群，设该城市 i 的聚集度为 DPi（Degree of Polymerization）,  DPi = max(城市群1的城市个数， 城市群2的城市个数, ... 城市群m的城市个数)。

请找出地图上 DP 值最小的城市（即找到城市 j，使得 DPj = min(DP1, DP2 ... DPn) )

提示：如果有多个城市都满足条件，这些城市都要找出来（可能存在多个解）

提示：DPi 的计算，可以理解为已知一棵树，删除某个节点后，生成的多个子树，求解多个子树节点数的问题。

输入描述：

每个样例：第一行有一个整数N，表示有N个节点。1<=N<=1000

接下来的N-1行每行有两个整数x,y，表示城市x与城市y连接。1<=x, y<=N

输出描述：

输出城市的编号。如果有多个，按照编号升序输出。

示例1

输入：

5
1 2
2 3
3 4
4 5

输出：

3

说明：

输入表示的是如下地图：

1 - 2 - 3 - 4 - 5

对于城市3，切断通往3的所有道路后，形成2个城市群[（1,2）,（4,5）]，其聚集度分别都是2。DP3 = 2。 对于城市4，切断通往城市4的所有道路后， 形成2个城市群[ (1,2,3), (5) ]，DP4 = max（3, 1）= 3 。依次类推，切断其它城市的所有道路后，得到的DP都会大于2，因为城市3就是满足条件的城市，输出是3。

示例2

输入：

6
1 2
2 3
2 5
3 4
3 6

输出：

2 3

说明：

输入表示的是如下地图：

          6

           |

1 - 2 - 3 - 4

      |

     5

切断通往2的所有道路后，形成3个城市群[（1）,（5），（3,4,6）]，其聚集度分别都是1、1、3，因此DP2 = 3。

切断通往3的所有道路后，形成3个城市群[（1，2,5）,（4），（,6）]，其聚集度分别都是3、1、1，因此DP3 = 3。

切断其它城市的所有道路后，得到的DP都会大于3，因为城市2、3就是满足条件的城市，升序排列输出是2 3

代码 

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();//对数
        List<Tree> trees = new ArrayList<Tree>();
        Set<Integer> set = new HashSet<Integer>();
        for (int i = 0; i < n-1; i++) {
            int x = in.nextInt();
            int y = in.nextInt();
            trees.add(new Tree(x,y));
            set.add(x);
            set.add(y);
        }
        List<Integer> dp=new ArrayList<>();
        int dpMin=n;
        for(Integer x : set) {
            List<Tree> list = new ArrayList<>(trees);
            for(int i=0;i<list.size();i++) {
                if(list.get(i).x == x||list.get(i).y == x) {
                    list.remove(i);
                    i--;
                }
            }

            int d=f(list,set,x);
            if(d<dpMin){
                dpMin=d;
                dp.clear();
                dp.add(x);
            }else if(d==dpMin){

                dp.add(x);
            }

        }
        for(Integer x : dp) {
            System.out.print(x+" ");
        }
    }
    public static int f(List<Tree> list,Set<Integer> set,int x){
        List<Integer> list2=new ArrayList<>(set);
        list2.remove(Integer.valueOf(x));
        int sum=0;
        for(int i=0;i<list2.size();i++) {
            dn=0;
            int s=f2(list,list2.get(i));
            sum=Math.max(sum,s);
        }
        return sum;
    }
    public static int dn=0;
    public static int f2(List<Tree> list,int x){
       int res=1;
       for(Tree tree:list){
           if(tree.x==x){
               res+= f2(list,tree.y);
           }

       }
        return res;
    }
}
class Tree{
    int x;
    int y;

    public Tree() {
    }

    public Tree(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "tree{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}