拓扑排序的经典例题（也可以用深度优先搜索）

拓扑排序的经典例题

Leeocode 851. 喧闹和富有

有一组 n 个人作为实验对象，从 0 到 n - 1 编号，其中每个人都有不同数目的钱，以及不同程度的安静值（quietness）。为了方便起见，我们将编号为 x 的人简称为 "person x "。

给你一个数组 richer ，其中 richer[i] = [ai, bi] 表示 person ai 比 person bi 更有钱。另给你一个整数数组 quiet ，其中 quiet[i] 是 person i 的安静值。richer 中所给出的数据 逻辑自恰（也就是说，在 person x 比 person y 更有钱的同时，不会出现 person y 比 person x 更有钱的情况 ）。

现在，返回一个整数数组 answer 作为答案，其中 answer[x] = y 的前提是，在所有拥有的钱肯定不少于 person x 的人中，person y 是最安静的人（也就是安静值 quiet[y] 最小的人）。

示例 1：

输入：richer = [[1,0],[2,1],[3,1],[3,7],[4,3],[5,3],[6,3]], quiet = [3,2,5,4,6,1,7,0]
输出：[5,5,2,5,4,5,6,7]
解释： 
answer[0] = 5，
person 5 比 person 3 有更多的钱，person 3 比 person 1 有更多的钱，person 1 比 person 0 有更多的钱。
唯一较为安静（有较低的安静值 quiet[x]）的人是 person 7，
但是目前还不清楚他是否比 person 0 更有钱。
answer[7] = 7，
在所有拥有的钱肯定不少于 person 7 的人中（这可能包括 person 3，4，5，6 以及 7），
最安静（有较低安静值 quiet[x]）的人是 person 7。
其他的答案也可以用类似的推理来解释。

示例 2：

输入：richer = [], quiet = [0]
输出：[0]

方法一

题目分析

简单理解题目意思为：
richer = [[1,0],[2,1],[3,1],[3,7],[4,3],[5,3],[6,3]], quiet = [3,2,5,4,6,1,7,0]

比0有钱的有[1]
比1有钱的有[2, 3]
比3有钱的有[4, 5, 6]
比7有钱的有[3]

例如对于0来说，1，2，3，4，5，6都比他有钱，因此，要在自己外加六个人中找一个最低调的，也就是quiet最小的那一位

拓扑排序思想

把其中的人看作节点

容易想到的是通过构造这种 （更有钱关系）父子关系，来构成一个树，然后我们从上往下遍历即可

对于其中的任意一位，有很多个节点比这个节点有钱，这个节点也可能比很多节点有钱，因此情况是比较复杂的。

任意一个节点都要考虑，比其有钱的节点
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cadl8od4-1639642973044)(media/16395537588481/16395547132673.jpg)]
从这个图直观的可以看出1，2，3，4节点都没有父节点，因此他们的值就是本身就好啦

而5号节点，只受到1号节点的影响，因此把1号节点去除的同时，根据情况修改5号节点的值即可。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1dOsg74b-1639642973053)(media/16395537588481/16395550481701.jpg)]
因此我们不断寻常入度为0的点移除

但是每次移除的同时要考虑更新对后续节点的影响

循环直到所有节点都没移除了

思路小结

由简入繁，一层层剥洋葱，把最外层的剥开，里面的就变成和外面一样的结构了

复杂度分析

我们对richer访问了一遍，构造拓扑排序，构建了每个节点的相互依赖关系以及入度

接着我们从入度为0的逐个访问，虽然顺序变化多端，但是每个节点才被访问一次，因此

时间复杂度：O(n+m)，其中 n 是数组 quiet 的长度，m 是数组 richer 的长度。建图和拓扑排序的时间复杂度均为 O(n+m)。

空间复杂度：O(n+m)。我们需要 O(n+m) 的空间来记录图中所有的点和边。

Code

class Solution {

    public int[] loudAndRich(int[][] richer, int[] quiet) {
        //用来存储最小的people
        int[] ans=new int[quiet.length];
        //创建入度，其实创建一维数组就好啦，更新的时候用ans，不用额外保存最小的了
        int[][] indegree=new int[quiet.length][3];//入度 当前下标 最小值
        //创建边和点的映射关系
        //在数据量小的情况，例如本题，可以直接创建ArrayList<Integer>[]数组
        HashMap<Integer,ArrayList<Integer>> map=new HashMap<>();
        for (int i = 0; i < indegree.length; i++) {
            indegree[i][1]=i;
            indegree[i][2]=i;
        }
        //建立队列，入度为0的点进入队列
        Queue<int[]> queue=new LinkedList<>();
        for (int i = 0; i < richer.length; i++) {
            indegree[richer[i][1]][0]++;
            if(map.containsKey(richer[i][0])){
                map.get(richer[i][0]).add(richer[i][1]);
            }else {
                map.put(richer[i][0],new ArrayList<>());
                map.get(richer[i][0]).add(richer[i][1]);
            }
        }
        for (int i = 0; i < indegree.length; i++) {
            if(indegree[i][0]==0){
                queue.add(indegree[i]);
            }
        }
        //System.out.println(queue);
        while (!queue.isEmpty()){
            int[] temp=queue.poll();
            ans[temp[1]]=temp[2];
            if(map.containsKey(temp[1])){
                ArrayList<Integer> list=map.get(temp[1]);
                for (int i = 0; i < list.size(); i++) {
                    if(quiet[temp[2]]<=quiet[indegree[list.get(i)][2]]){
                         //System.out.println(temp[2]);
                        indegree[list.get(i)][2]=temp[2];
                    }
                    if(--indegree[list.get(i)][0]==0){
                        queue.add(indegree[list.get(i)]);
                    }
                }
            }
        }
        return ans;
    }
}

深度优先搜索

我们从一个点开始，看看周围更有钱的节点，找到更有钱的节点声音最小的那一个即可

Note：重点是我们要去对计算的进行保存，这样就不用重复计算了

例如我们遍历3节点，路径为3->5->7->11->18

那么我们不仅仅得到3节点最好的情况，也能得到5，7，11，18节点最好的情况

2->3->5->7->11->18接着遍历2节点的时候

发现3已经找到最好的情况了，那么就不用继续深入下去了

重点和难点是如何保存这最好的情况

我们创建一个辅助数组dp =new int[quiet.length];

1. 如果一个节点没有父节点，那么dp[i]=i
2. 本身被访问过，即if(dp[cur]!=-1){return ;}
3. 如果一个节点有多个父节点
   1. 如果父节点被访问了那就直接比较
   2. 如果父节点没被访问继续BfsMin(父节点)

for (int i = 0; i < list.size(); i++) {
        if(dp[list.get(i)]==-1){
            BfsMin(list.get(i));//去寻找父亲节点最好的情况
        }
           
        if(quiet[dp[cur]]>quiet[dp[list.get(i)]]){
            dp[cur]=dp[list.get(i)];
        }
}

代码编写

class Solution {
     HashMap<Integer, ArrayList<Integer>> map;
    int[]quiet;
    int[] dp;
    public int[] loudAndRich(int[][] richer, int[] quiet) {
        map=new HashMap<>();
        this.quiet=quiet;
        dp =new int[quiet.length];
        for (int i = 0; i < dp.length; i++) {
            dp[i]=-1;
        }
        for (int i = 0; i < richer.length; i++) {
            if(map.containsKey(richer[i][1])){
                map.get(richer[i][1]).add(richer[i][0]);
            }else {
                map.put(richer[i][1],new ArrayList<>());
                map.get(richer[i][1]).add(richer[i][0]);
            }
        }
        for (int i = 0; i < quiet.length; i++) {
            BfsMin(i);
        }
        return dp;
    }
    public void BfsMin(int cur){
        //System.out.println(cur);
        if(dp[cur]!=-1){
            return ;
        }
        if(!map.containsKey(cur)){
            dp[cur]=cur;
            return ;
        }
        
        ArrayList<Integer> list=map.get(cur);
        dp[cur]=cur;
        for (int i = 0; i < list.size(); i++) {
            BfsMin(list.get(i));
            if(quiet[dp[cur]]>quiet[dp[list.get(i)]]){
                dp[cur]=dp[list.get(i)];
            }
        }
    }
}