LeetCode——851.喧闹和富有

通过万岁！！！

• 题目：给定一个二维数组richer大小为(n*2)，其中n表示有n个人，每一行表示一个贫富差距。richer[i][0]的人是比richer[i][1]富有的。但是人有钱了，说话声音就大。quiet中存储了每个人的说话声音。我们最终的工作是返回一个数组ans，ans[i]表示比i这个人有钱，但是最安静的人是谁。
• 特别提醒：
  • 如果richer中没有说比i有钱的人，那么默认我自己最有钱，其实也就是返回我自己就可以。
  • 如果richer中是空的时候，那么我们直接将quiet排序后返回即可。

下面先说一种思路，但是这种时间复杂度太高了，这种时间复杂度直接无法通过。

• 思路：找到比i有钱的人，然后看看里面谁最安静。因为有钱是一种层级关系，A比B有钱，B比C有钱，则A一定比C又钱。我们就需要递归遍历。然后放到一个set中，这样就不会重复了。
• 技巧：
  • 主要是放在set中。

伪代码——主函数

如果richer是空的话，将quiet升序排列，然后返回。
定义当前的quiet的最小值quietMin
定义需要返会的数组。
for遍历有多少人，人数就是quiet的长度，因为每个人都给了音量
    初始化set集合
    调用函数找比i有钱的人，存在set中
    初始化最有钱和最安静的人是自己，这样如果集合是空，那么就返回自己。
    for遍历set集合
        如果音量小于当前最小值，则将ans的i改为当前这个集合中的值（也就是这个人是当前比我有钱的并且最安静的人），并且更新quietMin
最后return ans即可

伪代码——递归函数，主要是找比person有钱的人，存在set集合中

for遍历richer的行  
    如果richer[i][1] == person，表示richer[i][0]就是比person有钱的人，那就将这个人存在集合中，然后递归找比richer[i][0]还有钱的(深度遍历)。

java代码

class Solution {
    public int[] loudAndRich(int[][] richer, int[] quiet) {
        if (richer.length == 0) {
            Arrays.sort(quiet);
            return quiet;
        }
        int quietMin;
        int ans[] = new int[quiet.length];
        for (int i = 0; i < quiet.length; i++) {// 找比第i个人有钱的人
            HashSet<Integer> hashSet = new HashSet<>();
            getMoreRich(richer, i, hashSet);
            ans[i] = i;
            quietMin = quiet[i];
            for (Integer integer : hashSet) {
                if (quiet[integer] < quietMin) {
                    quietMin = quiet[integer];
                    ans[i] = integer;
                }
            }
        }
        return ans;
    }
    void getMoreRich(int[][] richer, int person, HashSet<Integer> hashSet) {
        for (int i = 0; i < richer.length; i++) {
            if (richer[i][1] == person) {
                hashSet.add(richer[i][0]);
                getMoreRich(richer, richer[i][0], hashSet);
            }
        }
    }
}

哎，但是上面的方法时间复杂度太高了。主要原因是我们每次都要找到比这个人有钱的人。而这个过程存在很多重复。
改良版：

• 我们可以定义一个map，用来记录我们是否遍历过这个人，或者说，我们是否遍历过比这个人高的。

伪代码

思路还是不变的，只不过我们定义一个map，查看是不是遍历过了
就是在递归的时候，判断是不是我们已经找过了，比person有钱的人。如果有的话，就返回这个set可以了。
否则的话，开始找，这里需要初始化一个内部的set，这个set最后返回，里面存储的就是比person有钱的人。
并且，这个过程也需要递归，递归的返回的set要和本层的set合并。

java代码

class Solution {
    Map<Integer, HashSet<Integer>> map = new HashMap<>();

    public int[] loudAndRich(int[][] richer, int[] quiet) {
        if (richer.length == 0) {
            Arrays.sort(quiet);
            return quiet;
        }
        int quietMin;
        int ans[] = new int[quiet.length];
        for (int i = 0; i < quiet.length; i++) {// 找比第i个人有钱的人
            HashSet<Integer> hashSet = getMoreRich(richer, i);
            ans[i] = i;
            quietMin = quiet[i];
            for (Integer integer : hashSet) {
                if (quiet[integer] < quietMin) {
                    quietMin = quiet[integer];
                    ans[i] = integer;
                }
            }
        }
        return ans;
    }

    HashSet<Integer> getMoreRich(int[][] richer, int person) {
        if (map.containsKey(person)) {// 直接合并两个集合
            return (HashSet<Integer>) map.get(person);
        }
        HashSet<Integer> hashSetCurr = new HashSet<>();
        for (int i = 0; i < richer.length; i++) {
            if (richer[i][1] == person) {
                hashSetCurr.add(richer[i][0]);
                HashSet<Integer> downHashSet = getMoreRich(richer, richer[i][0]);
                hashSetCurr.addAll(downHashSet);// 合并两个集合
            }
        }
        map.put(person, (HashSet<Integer>) hashSetCurr);
        return hashSetCurr;
    }
}

再升级一下，我们不使用集合，而是直接让递归返回的就是比person人有钱，并且安静的人，我们依旧放在map中。
java代码

class Solution {
    Map<Integer, Integer> map = new HashMap<>();// 比第key更有钱，并且更安静的人value
    int[][] richers;
    int[] quiets;

    public int[] loudAndRich(int[][] richer, int[] quiet) {
        if (richer.length == 0) {
            Arrays.sort(quiet);
            return quiet;
        }
        richers = richer;
        quiets = quiet;
        int ans[] = new int[quiet.length];
        for (int i = 0; i < quiet.length; i++) {// 找比第i个人有钱的人
            ans[i] = getMoreRich(i);
        }
        return ans;
    }


    Integer getMoreRich(int person) {
        if (map.containsKey(person)) {
            return map.get(person);
        }
        int quietMin = quiets[person];// 最安静值的先是自己
        int ans = person;// 最安静的人也是自己
        int temp;
        for (int i = 0; i < richers.length; i++) {
            if (richers[i][1] == person) {
                if (quiets[richers[i][1]] < quietMin) {
                    ans = richers[i][1];
                    quietMin = quiets[richers[i][1]];
                }
                temp = getMoreRich(richers[i][0]);// 比richers[i][0]更有钱的
                if (quiets[temp] < quietMin) {
                    ans = temp;
                    quietMin = quiets[temp];
                }
            }
        }
        map.put(person, ans);
        return ans;
    }
}

• 总结：速度有一点提升，因为少了一层集合的遍历，但是还是不快，应该是方法存在一定的问题。在这里只能喊一声通过万岁了。