LeetCode 807. 保持城市天际线 / 630. 课程表 III(贪心+优先队列)/ 851. 喧闹和富有(拓扑排序)
Posted Zephyr丶J
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了LeetCode 807. 保持城市天际线 / 630. 课程表 III(贪心+优先队列)/ 851. 喧闹和富有(拓扑排序)相关的知识,希望对你有一定的参考价值。
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;
以上是关于LeetCode 807. 保持城市天际线 / 630. 课程表 III(贪心+优先队列)/ 851. 喧闹和富有(拓扑排序)的主要内容,如果未能解决你的问题,请参考以下文章
LeetCode 807. 保持城市天际线 / 630. 课程表 III(贪心+优先队列)/ 851. 喧闹和富有(拓扑排序)
解题报告Leecode 807. 保持城市天际线——Leecode每日刷题系列
解题报告Leecode 807. 保持城市天际线——Leecode每日刷题系列
LeetCode 541. 反转字符串 II / 701. 二叉搜索树中的插入操作 / 807. 保持城市天际线