2019校招美团编程-图的遍历（JAVA）

第一行为节点数n，其他为n-1条边，判断1号结点出发的最短路径

输入：

4

1 2

1 3

3 4

输出：

4

解题思路：有的边走两遍，有的边只走一遍（最大深度的边只走一遍），所以最短路程 = 2*（n-1）-最大深度。

参考：

https://blog.csdn.net/whl_program/article/details/82470489

public class 图的遍历 {

       public static void main(String[] args) {

              Scanner sc = new Scanner(System.in);

              int n = sc.nextInt();

              int[] m = new int[100005];

              for (int i = 1; i < n; i++) {

                     int k = sc.nextInt();

                     int t = sc.nextInt();

                     m[t]=m[k]+1;//t的结点深度，并且默认t在k的下一层结点

              }

              int sum = 0;

              for(int i=1;i<=n;i++){

                     sum = Math.max(sum, m[i]);

              }

              System.out.println(2*(n-1)-sum);

              sc.close();

       }

}

个人觉得这思路虽然巧妙，但是必须默认输入的数据是从节点1往下的结构（如 1 2, 1 3, 3,4）。

4

1 2

1 3

3 4

结构如下：

      1

2         3

               4

输出：2*3-2=4

但是，当输入的数据是

4 
4 3
3 1
2 1

结构如下：

      4

          3

               1

                  2

输出：2*3-1=5

所以，个人觉得还是深度搜索更严谨。

https://blog.csdn.net/behboyhiex/article/details/82469281

参考此链接

public class main2 {

       static int ans = 0;

       public static void main(String[] args) {

              Scanner sc = new Scanner(System.in);

              int n = sc.nextInt();

              int[][] temp = new int[n + 1][n + 1];

              HashMap<Integer, HashSet<Integer>> map = new HashMap<>();

              // 建图

              for (int i = 1; i < n; i++) {

                     int k = sc.nextInt();

                     int v = sc.nextInt();

                     HashSet<Integer> value = map.getOrDefault(k, new HashSet<Integer>());

                     value.add(v);

                     map.put(k, value);

                     HashSet<Integer> key = map.getOrDefault(v, new HashSet<Integer>());

                     key.add(k);

                     map.put(v, key);

              }

              //参考别人算法，添加数据到数组

              for (int j = 1; j <= n; j++) {

                     Iterator<Integer> it = map.get(j).iterator();

                     int count = 0;

                     while (it.hasNext()) {

                            temp[j][count] = it.next();

                            count++;

                     }

              }

              dfs(1, 0, 0, temp);

              System.out.println(2 * n - 2 - ans);

       }

       private static void dfs(int x, int old, int w, int[][] temp) {

              for (int i = 0; i < temp[x].length; i++) {

                     if (temp[x][i] == 0) {

                            break;

                     }

                     if (temp[x][i] == old) {

                            continue;

                     }

                     dfs(temp[x][i], x, w + 1, temp);

              }

              ans = Math.max(ans, w);

       }

}