搜索+图+高质量例题详解

1.你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。
示例 2：

输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
输出：false
解释：总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。

1.深度优先搜索

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {

        List<List<Integer>> aj = new ArrayList<>();

        for(int i = 0;i < numCourses;i++) {

            aj.add(new ArrayList<>());
        }

        int[] isVisit = new int[numCourses];

        for(int[] cp : prerequisites) {

            aj.get(cp[1]).add(cp[0]);
        }

        for(int i = 0;i < numCourses;i++) {

            if(!dfs(aj,isVisit,i))
            return false;
        }

        return true;
    }


    public boolean dfs(List<List<Integer>> aj,int[] isVisit,int i) {

        //如果后面的元素为一，说明已经被赋值过了，也就是已经被学过了，这是不符合题意的
        if(isVisit[i] == 1)
        return false;
        //表示后面的课程已经被前面判断过没有问题，剪枝
        if(isVisit[i] == -1)
        return true;

        isVisit[i] = 1;

        for(int j : aj.get(i)) {

            if(!dfs(aj,isVisit,j))
            return false;
        }

        isVisit[i] = -1;
        return true;
    }
}

2.广度优先搜索

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {

        List<List<Integer>> res = new ArrayList<>();
        int[] arr = new int[numCourses];

        for(int i = 0;i < numCourses;i++) {

            res.add(new ArrayList<Integer>());

        }

        for(int[] p : prerequisites) {

            res.get(p[1]).add(p[0]);
            //只要arr[p[0]]不等于0，则表示它前面还有arr[p[0]]的课程要学
            arr[p[0]]++;
        }

            Queue<Integer> q = new LinkedList<>();

            for(int i = 0;i < numCourses;i++) {

                //先将先学的课程推入
                if(arr[i] == 0)
                q.offer(i);
            }

            int isVist = 0;
            while(!q.isEmpty()) {

                isVist++;
                int u = q.poll();
                for(int e : res.get(u)) {

                    arr[e]--;

                    //如果它前面没有课程需要学了，就将该课程推入
                    if(arr[e] == 0)
                    q.offer(e);
                }
            }

            return isVist == numCourses;
    }
}

2.

现在你总共有 numCourses 门课需要选，记为 0 到 numCourses - 1。给你一个数组 prerequisites ，其中 prerequisites[i] = [ai, bi] ，表示在选修课程 ai 前 必须 先选修 bi 。

例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示：[0,1] 。
返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序，你只要返回 任意一种 就可以了。如果不可能完成所有课程，返回 一个空数组 。

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]]
输出：[0,1]
解释：总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
示例 2：

输入：numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
输出：[0,2,1,3]
解释：总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。
示例 3：

输入：numCourses = 1, prerequisites = []
输出：[0]

1.广度优先搜索

class Solution {

    List<List<Integer>> res = new ArrayList<>();
    int[] isvisit;
    int[] arr;
    public int[] findOrder(int numCourses, int[][] prerequisites) {

        isvisit = new int[numCourses];
        arr = new int[numCourses];

        for(int i = 0;i < numCourses;i++) {

            res.add(new ArrayList<Integer>());
        }

        for(int[] cp : prerequisites) {

            res.get(cp[1]).add(cp[0]);
            isvisit[cp[0]]++;
        }

        Queue<Integer> q = new LinkedList<>();

        for(int i = 0;i < numCourses;i++) {

            if(isvisit[i] == 0) {
                q.offer(i);
                
            }
        }

        int count = 0;
        while(!q.isEmpty()) {

            count++;
            int u = q.poll();
            arr[count - 1] = u;

            for(int r : res.get(u)) {

                isvisit[r]--;

                if(isvisit[r] == 0)
                q.offer(r);
            }
        }

        if(count == numCourses)
        return arr;

        return new int[0];
    }
 
}

2.深度优先搜索

class Solution {

    List<List<Integer>> res = new ArrayList<>();
    boolean is = true;
    int[] arr;
    int[] isVisit;
    int index;
    public int[] findOrder(int numCourses, int[][] prerequisites) {

        arr = new int[numCourses];
        isVisit = new int[numCourses];
        index = numCourses - 1;

        for(int i = 0;i < numCourses;i++) {

            res.add(new ArrayList<Integer>());
        }

        for(int[] p : prerequisites) {

            res.get(p[1]).add(p[0]);
        }

        for(int i = 0;i < numCourses && is;i++) {

            if(isVisit[i] == 0) {
                dfs(i);
            }
        }

        if(!is)
        return new int[0];

        return arr;
    }

    public void dfs(int u) {

        isVisit[u] = 1;

        for(int i : res.get(u)) {

            if(isVisit[i] == 0) {

                dfs(i);
                if(!is) {
                    return;
                }
            }else if(isVisit[i] == 1){

                is = false;
                return;
            }
        }

        isVisit[u] = 2;
        arr[index--] = u;
    }
}

3.

树是一个无向图，其中任何两个顶点只通过一条路径连接。 换句话说，一个任何没有简单环路的连通图都是一棵树。

给你一棵包含 n 个节点的树，标记为 0 到 n - 1 。给定数字 n 和一个有 n - 1 条无向边的 edges 列表（每一个边都是一对标签），其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间存在一条无向边。

可选择树中任何一个节点作为根。当选择节点 x 作为根节点时，设结果树的高度为 h 。在所有可能的树中，具有最小高度的树（即，min(h)）被称为 最小高度树 。

请你找到所有的 最小高度树 并按 任意顺序 返回它们的根节点标签列表。

树的 高度 是指根节点和叶子节点之间最长向下路径上边的数量。

class Solution {
public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer> res = new ArrayList<>();
        /*如果只有一个节点，那么他就是最小高度树*/
        if (n == 1) {
            res.add(0);
            return res;
        }
        /*建立各个节点的出度表*/
        int[] degree = new int[n];
        /*建立图关系，在每个节点的list中存储相连节点*/
        List<List<Integer>> map = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            map.add(new ArrayList<>());
        }
        for (int[] edge : edges) {
            degree[edge[0]]++;
            degree[edge[1]]++;/*出度++*/
            map.get(edge[0]).add(edge[1]);/*添加相邻节点*/
            map.get(edge[1]).add(edge[0]);
        }
        /*建立队列*/
        Queue<Integer> queue = new LinkedList<>();
        /*把所有出度为1的节点，也就是叶子节点入队*/
        for (int i = 0; i < n; i++) {
            if (degree[i] == 1) queue.offer(i);
        }
        /*循环条件当然是经典的不空判断*/
        while (!queue.isEmpty()) {
            res = new ArrayList<>();/*这个地方注意，我们每层循环都要new一个新的结果集合，
            这样最后保存的就是最终的最小高度树了*/
            int size = queue.size();/*这是每一层的节点的数量*/
            for (int i = 0; i < size; i++) {
                int cur = queue.poll();
                res.add(cur);/*把当前节点加入结果集，不要有疑问，为什么当前只是叶子节点为什么要加入结果集呢?
                因为我们每次循环都会新建一个list，所以最后保存的就是最后一个状态下的叶子节点，
                这也是很多题解里面所说的剪掉叶子节点的部分，你可以想象一下图，每层遍历完，
                都会把该层（也就是叶子节点层）这一层从队列中移除掉，
                不就相当于把原来的图给剪掉一圈叶子节点，形成一个缩小的新的图吗*/
                List<Integer> neighbors = map.get(cur);
                /*这里就是经典的bfs了，把当前节点的相邻接点都拿出来，
                 * 把它们的出度都减1，因为当前节点已经不存在了，所以，
                 * 它的相邻节点们就有可能变成叶子节点*/
                for (int neighbor : neighbors) {
                    degree[neighbor]--;
                    if (degree[neighbor] == 1) {
                        /*如果是叶子节点我们就入队*/
                        queue.offer(neighbor);
                    }
                }
            }
        }
        return res;/*返回最后一次保存的list*/
    }
}

4.记忆化搜索

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

示例 1：

输入：coins = [1, 2, 5], amount = 11
输出：3 
解释：11 = 5 + 5 + 1
示例 2：

输入：coins = [2], amount = 3
输出：-1
示例 3：

输入：coins = [1], amount = 0
输出：0
 

class Solution {
    public int coinChange(int[] coins, int amount) {

        if(amount < 1)
        return 0;

        return dfs(coins,amount,new int[amount]);
    }

    public int dfs(int[] coins,int res,int[] count) {

        if(res < 0)
        return -1;

        if(res == 0)
        return 0;

        //记忆化搜索关键
        if(count[res - 1] != 0)
        return count[res - 1];

        int min = Integer.MAX_VALUE;

        for(int val : coins) {

            int a = dfs(coins,res - val,count);
            if(a >= 0 && a < min) {

                //加一是为了前面的那一步加上的金币数
                min = a + 1;
            }
        }

        count[res - 1] = (min == Integer.MAX_VALUE ? -1 : min);

        //count[]是下标从0开始的，count[res - 1]表示的是res钱需要的最少金币数
        return count[res - 1];
    }
}