华为OD机试真题【树上逃离】

1、题目描述

【树上逃离】
给定一棵树，这个树有n个节点，节点编号从0开始依次递增，0固定为根节点。在这棵树上有一个小猴子，初始时该猴子位于根节点(0号) 上，小猴子一次可以沿着树上的边从一个节点挪到另一个节点，但这棵树上有一些节点设置有障碍物，如果某个节点上设置了障碍物，小猴子就不能通过连接该节点的边挪动到该节点上。
问小猴子是否能跑到树的叶子节点(叶子节点定义为只有一条边连接的节点)，如果可以，请输出小猴子跑到叶子节点的最短路径(通过的边最少)，否则输出字符串NULL。
【输入描述】
第一行给出数字n，表示这个树有n个节点,节点编号从O开始依次递增.0固定为根节点,1<=n<10000第二行给出数字edge，表示接下来有edge行,每行是一条边接下来的edge行是边: x y,表示x和y节点有一条边连接
边信息结束后接下来的一行给出数字block，表示接下来有block行,每行是一个障碍物
接下来的block行是障碍物: x,表示节点x上存在障碍物

【样例1】
输入:
4
3
0 1
0 2
0 3
2
2
3
输出：0->1
解释: n=4, edge=[IO,1],[O,2],[O,3]], block=[2,3]表示一个有4个节点、3条边的树,其中节点2和节点3上有障碍物,小猴子能从0到达叶了节点1(节点1只有一条边[O,1]和它连接，因此是叶子节点),即可以跑出这个树，所以输出为O->1。

【样例2】
输入:
7
60 1
0 3
12
34
15
56
1
4
输出: 0->1->2
解释:节点4上有障碍物，因此O-3-4这条路不通，节点2和节点6都是叶子节点，但0->1->2比O->1->5->6路径短(通过的边最少)，因此输出为O->1->2.

【样例3】
输入:
2
10 1
1
1
输出: NULL
解释:节点1是叶子节点，但存在障碍物，因此小猴子无法到达叶子节点，输出NULL

2、解题思路

先用map存储每个节点对应的子节点，从0开始依次选择子节点，回溯遍历路径，直到子节点没有子节点为止，即为叶子节点。

3、参考代码

java">import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

/**
 * @Author
 * @Date 2023/5/6 23:47
 */
public class 树上逃离 {

    public static List<List<Integer>> result = new ArrayList<>();
    public static List<Integer> res = new ArrayList<>();

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = in.nextInt();
            int edge = in.nextInt();
            Map<Integer, List<Integer>> listMap = new HashMap<>();
            for (int i = 0; i < edge; i++) {
                int x = in.nextInt();
                int y = in.nextInt();
                if (listMap.containsKey(x)) {
                    listMap.get(x).add(y);
                } else {
                    List<Integer> list = new ArrayList<>();
                    list.add(y);
                    listMap.put(x, list);
                }
            }

            int block = in.nextInt();
            Set<Integer> set = new HashSet<>();
            for (int i = 0; i < block; i++) {
                set.add(in.nextInt());
            }

            res.clear();
            result.clear();
            List<Integer> path = new ArrayList<>();
            path.add(0);
            dfs(listMap, set, 0, path);
            System.out.println(result);
            System.out.println(res);

            if (result.isEmpty()) {
                System.out.println("NULL");
            } else {
                for (int i = 0; i < res.size(); i++) {
                    System.out.print(res.get(i));
                    if (i != res.size() - 1) {
                        System.out.print("->");
                    }
                }
                System.out.println();
            }


        }
    }

    public static void dfs(Map<Integer, List<Integer>> listMap, Set<Integer> set, int root, List<Integer> path) {
        if (set.contains(root)) {
            return;
        }
        // 当该节点没有连接节点时则为叶子节点
        if (!listMap.containsKey(root)) {
            result.add(new ArrayList<>(path));
            if (!res.isEmpty() && res.size() > path.size()) {
                res.clear();
                res.addAll(new ArrayList<>(path));
                return;
            }
            if (res.isEmpty()) {
                res.addAll(new ArrayList<>(path));
            }
            return;
        }
        List<Integer> list = listMap.get(root);
        for (int i = 0; i < list.size(); i++) {
            path.add(list.get(i));
            dfs(listMap, set, list.get(i), path);
            path.remove(path.size() - 1);
        }
    }
}