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];//否则递归}elsetemp = 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];//这个人的入度减1inDeg[i]--;if(inDeg[i] == 0)queue.add(i);}}}return res;}
}

LeetCode 807. 保持城市天际线 / 630. 课程表 III（贪心+优先队列）/ 851. 喧闹和富有（拓扑排序）相关推荐

Java实现 LeetCode 807 保持城市天际线（暴力）
807. 保持城市天际线在二维数组grid中,grid[i][j]代表位于某处的建筑物的高度. 我们被允许增加任何数量(不同建筑物的数量可能不同)的建筑物的高度. 高度 0 也被认为是建筑物. 最后 ...
天际线java_Java实现 LeetCode 807 保持城市天际线（暴力）
807. 保持城市天际线在二维数组grid中,grid[i][j]代表位于某处的建筑物的高度. 我们被允许增加任何数量(不同建筑物的数量可能不同)的建筑物的高度. 高度 0 也被认为是建筑物. 最后 ...
LeetCode 807. 保持城市天际线
文章目录 1. 题目 2. 解题 1. 题目在二维数组grid中,grid[i][j]代表位于某处的建筑物的高度. 我们被允许增加任何数量(不同建筑物的数量可能不同)的建筑物的高度. 高度 0 也被 ...
LeetCode 807 保持城市天际线
在二维数组grid中,grid[i][j]代表位于某处的建筑物的高度. 我们被允许增加任何数量(不同建筑物的数量可能不同)的建筑物的高度. 高度 0 也被认为是建筑物. 最后,从新数组的所有四个方向( ...
LeetCode - 807. 保持城市天际线 - Java
文章目录题目要求分析解题先获得这个街区组成的城市的行数将这个城市看成一个 n*n 正方体,题目的例子的图形也是这么看的.而且还是二维数组.我们要做的是创建 2个数组,分别是 ro ...
LeetCode：807. 保持城市天际线————中等
题目 807. 保持城市天际线在二维数组grid中,grid[i][j]代表位于某处的建筑物的高度. 我们被允许增加任何数量(不同建筑物的数量可能不同)的建筑物的高度. 高度 0 也被认为是建筑物. ...
807. 保持城市天际线
链接:807. 保持城市天际线题解: class Solution { public:int maxIncreaseKeepingSkyline(vector<vector<int> ...
807.保持城市天际线
题目描述给你一座由 n x n 个街区组成的城市,每个街区都包含一座立方体建筑.给你一个下标从 0 开始的 n x n 整数矩阵 grid ,其中 grid[r][c] 表示坐落于 r 行 c 列的 ...
LeetCode 207. Course Schedule--有向图找环--面试算法题--DFS递归，拓扑排序迭代--Python
题目地址:Course Schedule - LeetCode There are a total of n courses you have to take, labeled from 0 to n ...

LeetCode 807. 保持城市天际线 / 630. 课程表 III（贪心+优先队列）/ 851. 喧闹和富有（拓扑排序）

807. 保持城市天际线

题目描述

思路

630. 课程表 III

题目描述

思路

851. 喧闹和富有

题目描述

思路

LeetCode 807. 保持城市天际线 / 630. 课程表 III（贪心+优先队列）/ 851. 喧闹和富有（拓扑排序）相关推荐

最新文章

热门文章