807. 保持城市天际线

2021.12.13 每日一题

题目描述

给你一座由 n x n 个街区组成的城市，每个街区都包含一座立方体建筑。给你一个下标从 0 开始的 n x n 整数矩阵 grid ，其中 grid[r][c] 表示坐落于 r 行 c 列的建筑物的 高度 。

城市的 天际线 是从远处观察城市时，所有建筑物形成的外部轮廓。从东、南、西、北四个主要方向观测到的 天际线 可能不同。

我们被允许为 任意数量的建筑物 的高度增加 任意增量（不同建筑物的增量可能不同） 。 高度为 0 的建筑物的高度也可以增加。然而，增加的建筑物高度 不能影响 从任何主要方向观察城市得到的 天际线 。

在 不改变 从任何主要方向观测到的城市 天际线 的前提下，返回建筑物可以增加的 最大高度增量总和 。

示例 1：

输入：grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
输出：35
解释：建筑物的高度如上图中心所示。
用红色绘制从不同方向观看得到的天际线。
在不影响天际线的情况下，增加建筑物的高度：
gridNew = [ [8, 4, 8, 7],
[7, 4, 7, 7],
[9, 4, 8, 7],
[3, 3, 3, 3] ]

示例 2：

输入：grid = [[0,0,0],[0,0,0],[0,0,0]]
输出：0
解释：增加任何建筑物的高度都会导致天际线的变化。

提示：

n == grid.length
n == grid[r].length
2 <= n <= 50
0 <= grid[r][c] <= 100

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

思路

class Solution {
    public int maxIncreaseKeepingSkyline(int[][] grid) {
        //每一个位置的最大高度就是横竖两个方向最低的高度
        //因为那是天际线
        int n = grid.length;
        int[] col = new int[n];
        int[] row = new int[n];
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                col[i] = Math.max(col[i], grid[i][j]);
                row[j] = Math.max(row[j], grid[i][j]);
            }
        }
        int res = 0;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                int temp = Math.min(col[i], row[j]);
                res += temp - grid[i][j];
            }
        }
        return res;
    }
}

630. 课程表 III

2021.12.14 每日一题

题目描述

这里有 n 门不同的在线课程，按从 1 到 n 编号。给你一个数组 courses ，其中 courses[i] = [durationi, lastDayi] 表示第 i 门课将会 持续 上 durationi 天课，并且必须在不晚于 lastDayi 的时候完成。

你的学期从第 1 天开始。且不能同时修读两门及两门以上的课程。

返回你最多可以修读的课程数目。

示例 1：

输入：courses = [[100, 200], [200, 1300], [1000, 1250], [2000, 3200]]
输出：3
解释：
这里一共有 4 门课程，但是你最多可以修 3 门：
首先，修第 1 门课，耗费 100 天，在第 100 天完成，在第 101 天开始下门课。
第二，修第 3 门课，耗费 1000 天，在第 1100 天完成，在第 1101 天开始下门课程。
第三，修第 2 门课，耗时 200 天，在第 1300 天完成。
第 4 门课现在不能修，因为将会在第 3300 天完成它，这已经超出了关闭日期。

示例 2：

输入：courses = [[1,2]]
输出：1

示例 3：

输入：courses = [[3,2],[4,3]]
输出：0

提示:

1 <= courses.length <= 10^4
1 <= durationi, lastDayi <= 10^4

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

思路

class Solution {
    public int scheduleCourse(int[][] courses) {
        //范围是10的4次，应该是个拓扑排序我觉得
        //按照截止日期排序还是按照花费时间排序呢
        //如果按照截止日期排序的话，每次取出来是截止日期最早的，但是不是时间最短的，这样会有问题吗
        //应该是会有问题的，比如后面有几个时间很短的，就不能被完成
        
        //首先明确第一点，两门课程，有截止时间d1<=d2，那么先完成课程1再完成课程2肯定比反过来是更优的
        //这是必然呢，因为想一下，如果能先学习后面的，再学习前面的，那么肯定可以先学习前面的，再学习后面的，而反过来就不一定了

        //所以将所有课程按照截止时间排序，依次选出课程
        //如果当前选出了一个最优的课程序列，k1,k2..kn,判断下一个课程是否可以加入这个序列
        //如果这个课程满足截止时间的要求，那么可以加入，并且因为之前序列是最优的，所以加入也是最优的
        //如果这个课程不满足截止时间的要求，那么就看这个课程能否替换原来序列的课程
        //如果原来序列中的课程时间都比这个课程短，那么不能替换；如果有一个比这个长，那么就可以进行替换

        int n = courses.length;
        //按照截止时间排序
        Arrays.sort(courses, (a, b) -> (a[1] - b[1]));
        //用一个优先队列记录目前序列中的课程所需时间，替换堆顶的课程
        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> (b - a));
        int time = 0;
        for(int i = 0; i < n; i++){
            int temptime = time + courses[i][0];
            //如果可以加入，那么插入最后
            if(temptime <= courses[i][1]){
                pq.offer(courses[i][0]);
                time = temptime;
            }else{
                //如果不可以，那么替换
                if(!pq.isEmpty() && pq.peek() > courses[i][0]){
                    int t = pq.poll();
                    pq.offer(courses[i][0]);
                    time = time - t + courses[i][0];
                }
            }
        }
        return pq.size();

    }
}

851. 喧闹和富有

2021.12.15 每日一题

题目描述

有一组 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]

提示：

n == quiet.length
1 <= n <= 500
0 <= quiet[i] < n
quiet 的所有值 互不相同
0 <= richer.length <= n * (n - 1) / 2
0 <= ai, bi < n
ai != bi
richer 中的所有数对 互不相同
对 richer 的观察在逻辑上是一致的

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

思路

这样写竟然超时了，相当于一个拓扑排序
因为是计算每个人的时候，都进行了一次图的遍历，其实做了很多无用功，应该是在一次遍历的时候，如果遇到了能计算的，就直接计算出结果，后面就不用再遍历一次这个值了
这样应该能快很多，想想怎么写

class Solution {
    public int[] loudAndRich(int[][] richer, int[] quiet) {
        //两个比较的维度，一个是富有，一个是安静
        //需要先将两个维度进行排序，对于安静值，比如说查一群人中安静值最小的人，
        //首先得找到这群人，然后直接在quiet数组中比较这群人的安静值就行了
        //那么怎么找这群人呢，就是根据richer给出的关系，可以构建一幅图，然后根据这幅图的关系来查找答案
        //怎么构造这幅图比较方便呢，因为是单向的，所以可以构建一个二维数组
        //g[i][j]为true表示i比j有钱，或者就直接遍历richer数组
        //比如判断0位置，那么

        int n = quiet.length;
        int l = richer.length;

        //统计比key直接富有的人
        Map<Integer, List<Integer>> map = new HashMap<>();
        for(int i = 0; i < l; i++){
            int rich = richer[i][0];
            int poor = richer[i][1];
            List<Integer> list = map.getOrDefault(poor, new ArrayList<>());
            list.add(rich);
            map.put(poor, list);
        }

        int[] res = new int[n];
        for(int i = 0; i < n; i++){
            //如果没有这个人的关系
            if(!map.containsKey(i)){
                res[i] = i;
                continue;
            }
            List<Integer> list = map.get(i);
            Queue<Integer> queue = new LinkedList<>();
            for(int p : list){
                queue.add(p);
            }
            int min = quiet[i];    //最小的安静值
            int minp = i;
            while(!queue.isEmpty()){
                //当前人
                int p = queue.poll();
                //如果比当前富有的人的安静值小于当前人的安静值，那么替换
                if(quiet[p] < min){
                    min = quiet[p];
                    minp = p;
                }
                List<Integer> temp = map.getOrDefault(p, new ArrayList<>());
                for(int peo : temp){
                    queue.add(peo);
                }
            }
            res[i] = minp;
        }
        return res;
    }
}

改成递归形式，做一次处理，过了

class Solution {
    Map<Integer, List<Integer>> map;
    int[] quiet;
    int[] res;
    public int[] loudAndRich(int[][] richer, int[] quiet) {
        //两个比较的维度，一个是富有，一个是安静
        //需要先将两个维度进行排序，对于安静值，比如说查一群人中安静值最小的人，
        //首先得找到这群人，然后直接在quiet数组中比较这群人的安静值就行了
        //那么怎么找这群人呢，就是根据richer给出的关系，可以构建一幅图，然后根据这幅图的关系来查找答案
        //怎么构造这幅图比较方便呢，因为是单向的，所以可以构建一个二维数组
        //g[i][j]为true表示i比j有钱，或者就直接遍历richer数组
        //比如判断0位置，那么
        this.quiet = quiet;
        int n = quiet.length;
        int l = richer.length;

        //统计比key直接富有的人
        map = new HashMap<>();
        for(int i = 0; i < l; i++){
            int rich = richer[i][0];
            int poor = richer[i][1];
            List<Integer> list = map.getOrDefault(poor, new ArrayList<>());
            list.add(rich);
            map.put(poor, list);
        }

        res = new int[n];
        Arrays.fill(res, -1);
        for(int i = 0; i < n; i++){
            if(res[i] == -1)
                backtracking(i);
        }
        return res;
    }

    public int backtracking(int i){
        //如果没有这个人的关系
        if(!map.containsKey(i)){
            res[i] = i;
            return i;
        }
        int min = quiet[i];
        int minp = i;
        List<Integer> list = map.get(i);
        for(int p : list){
            //如果这个人已经得到了结果了
            int temp = -1;
            if(res[p] != -1){
                temp = res[p];
            //否则递归
            }else
                temp = backtracking(p);
            
            if(quiet[temp] < min){
                min = quiet[temp];
                minp = temp;
            }
        }
        res[i] = minp;
        return minp;
    }
}

将图反过来，可以用拓扑排序一次遍历完成

class Solution {
    public int[] loudAndRich(int[][] richer, int[] quiet) {
        //写一下一次的拓扑排序
        int n = quiet.length;
        int l = richer.length;
        boolean[][] g = new boolean[n][n];  //富有指向贫穷
        int[] inDeg = new int[n];   //入度
        for(int i = 0; i < l; i++){
            g[richer[i][0]][richer[i][1]] = true;
            inDeg[richer[i][1]]++;
        }
        Queue<Integer> queue = new LinkedList<>();
        int[] res = new int[n];
        for(int i = 0; i < n; i++){
            res[i] = i;
            if(inDeg[i] == 0)
                queue.add(i);
        }

        while(!queue.isEmpty()){
            int top = queue.poll();
            //遍历所有比它贫穷的人
            for(int i = 0; i < n; i++){
                if(g[top][i]){
                    //如果当前富有的这个人的安静值比穷的人安静值小，那么更改
                    if(quiet[res[top]] < quiet[res[i]])
                        res[i] = res[top];
                    //这个人的入度减1
                    inDeg[i]--;
                    if(inDeg[i] == 0)
                        queue.add(i);
                }
            }
        }
        return res;

    }
}