​力扣解法汇总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]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/loud-and-rich
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路：

有一点栈的思想，每个位置都构建一个PersonNode节点（这个对象节点是为了方便理解），分别包含位置，安静值，以及比他更富有的节点的集合。

首先根据位置构建PersonNode的Map，key为index位置。

其次遍历richer，比如1比2富有，则把1节点加到2的richerLPersons上。

最后，遍历personMap，取每个personNode节点，如果节点的richerPersons>0，则遍历richerPersons节点寻找最小值进行比较，递归下去。这样getMinQuiet方法返回的就是入参personNode中安静值最小的。

单纯的这样写完，时间超时了，所以我们要加个缓存。每个节点对应的最小值其实是固定的，一旦算出来，加入到map中缓存，就无须重复运算了。

代码：

 Map<Integer, PersonNode> minQuietMap = new HashMap<>();

    public int[] loudAndRich(int[][] richer, int[] quiet) {
        Map<Integer, PersonNode> personNodeMap = new HashMap<>();
        for (int i = 0; i < quiet.length; i++) {
            personNodeMap.put(i, new PersonNode(i, quiet[i]));
        }

        //构建完整的richer
        for (int[] itemRicher : richer) {
            //            ints[0]比ints[1]更富有
            PersonNode personNode = personNodeMap.get(itemRicher[1]);
            personNode.richerPersons.add(personNodeMap.get(itemRicher[0]));
        }
        int[] result = new int[quiet.length];
        for (int i = 0; i < quiet.length; i++) {
            PersonNode personNode = personNodeMap.get(i);
            PersonNode minQuiet = getMinQuiet(personNode);
            result[i] = minQuiet.index;
        }
        return result;
    }

    private PersonNode getMinQuiet(PersonNode personNode) {
        PersonNode personNode1 = minQuietMap.get(personNode.index);
        if (personNode1 != null) {
            return personNode1;
        }
        PersonNode minNode = personNode;
        for (PersonNode node : personNode.richerPersons) {
            if (node.richerPersons.size() > 0) {
                node = getMinQuiet(node);
            }
            minNode = node.quiet < minNode.quiet ? node : minNode;
        }
        minQuietMap.put(personNode.index, minNode);
        return minNode;
    }


    static class PersonNode {
        public int index = 0;
        public int quiet = 0;
        public List<PersonNode> richerPersons = new ArrayList<>();

        PersonNode(int index, int quiet) {
            this.index = index;
            this.quiet = quiet;
        }
    }