刷题记录-20211215

 我的思路：

1、对于每一个person, 遍历richer数组。对于数对（a，person），有a>b。则递归寻找数对（x，a），x>a，a>person，则有x>person。

2、通过第一步找出所有大于person的人，找出其中quiet最小的即为answer[person]的正解。

class Solution {
    public int[] loudAndRich(int[][] richer, int[] quiet) {
        int[] result = new int[quiet.length];
        for(int i =0;i < quiet.length;i++)
        {
            List<Integer> list = new ArrayList();
            recurrence(richer,i,list);
            int quietest = quiet[i];
            int idx = i;
            for(int j = 0;j < list.size();j++)
            {
                if(quiet[list.get(j)] < quietest)
                {
                    quietest = quiet[list.get(j)];
                    idx = list.get(j);
                }
            }
            result[i] = idx;
        }
        return result;
    }

    public void recurrence(int[][] richer,int person,List<Integer> list)
    {
        for(int i = 0;i < richer.length;i++)
        {
            if(richer[i][1] == person)
            {
                list.add(richer[i][0]);
                recurrence(richer,richer[i][0],list);
            }
        }
    }
}

最终我的写法超出时间限制了。下面把官方解题的dfs贴出来。

class Solution {
    public int[] loudAndRich(int[][] richer, int[] quiet) {
        int n = quiet.length;
        List<Integer>[] g = new List[n];
        for (int i = 0; i < n; ++i) {
            g[i] = new ArrayList<Integer>();
        }
        for (int[] r : richer) {
            g[r[1]].add(r[0]);
        }

        int[] ans = new int[n];
        Arrays.fill(ans, -1);
        for (int i = 0; i < n; ++i) {
            dfs(i, quiet, g, ans);
        }
        return ans;
    }

    public void dfs(int x, int[] quiet, List<Integer>[] g, int[] ans) {
        if (ans[x] != -1) {
            return;
        }
        ans[x] = x;
        for (int y : g[x]) {
            dfs(y, quiet, g, ans);
            if (quiet[ans[y]] < quiet[ans[x]]) {
                ans[x] = ans[y];
            }
        }
    }
}

经过对比发现，我的代码需要每次去筛选出list里面最小quiet值的编号。参考官方解题思路后，经过修改如下：

class Solution {
    public int[] loudAndRich(int[][] richer, int[] quiet) {
        int[] result = new int[quiet.length];
        for(int i = 0;i < quiet.length;i++)
        {
            result[i] = i;
        }
        for(int i =0;i < quiet.length;i++)
        {
            recurrence(richer,i,result,quiet);
        }
        return result;
    }

    public void recurrence(int[][] richer,int person,int[] result,int[] quiet)
    {
        for(int i = 0;i < richer.length;i++)
        {
            if(richer[i][1] == person)
            {
                recurrence(richer,richer[i][0],result,quiet);
                if(quiet[result[person] ] > quiet[result[richer[i][0]]])
                {
                    result[person] = result[richer[i][0]];
                }
            }
        }
    }
}

结果还是超时。不砍掉重复操作的话还是通过不了。没得办法了。