规划兼职工作
题目描述
你打算利用空闲时间来做兼职工作赚些零花钱。
这里有 n 份兼职工作,每份工作预计从 startTime[i] 开始到 endTime[i] 结束,报酬为 profit[i]。
给你一份兼职工作表,包含开始时间 startTime,结束时间 endTime 和预计报酬 profit 三个数组,请你计算并返回可以获得的最大报酬。
注意,时间上出现重叠的 2 份工作不能同时进行。
如果你选择的工作在时间 X 结束,那么你可以立刻进行在时间 X 开始的下一份工作。
样例
样例输入
startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]
startTime = [1,2,3,4,6], endTime = [3,5,10,6,9], profit = [20,20,100,70,60]
startTime = [1,1,1], endTime = [2,3,4], profit = [5,6,4]
样例输出
120
解释:
我们选出第 1 份和第 4 份工作,
时间范围是 [1-3]+[3-6],共获得报酬 120 = 50 + 70。
150
解释:
我们选择第 1,4,5 份工作。
共获得报酬 150 = 20 + 70 + 60。
6
提示
- 1 < = s t a r t T i m e . l e n g t h = = e n d T i m e . l e n g t h = = p r o f i t . l e n g t h < = 5 ∗ 1 0 4 1 <= startTime.length == endTime.length == profit.length <= 5 * 10^4 1<=startTime.length==endTime.length==profit.length<=5∗104
- 1 < = s t a r t T i m e [ i ] < e n d T i m e [ i ] < = 1 0 9 1 <= startTime[i] < endTime[i] <= 10^9 1<=startTime[i]<endTime[i]<=109
- 1 < = p r o f i t [ i ] < = 1 0 4 1 <= profit[i] <= 10^4 1<=profit[i]<=104
思路
很明显的动态规划,总得大问题可以化为多个子问题。
有几个需要注意的点,time[i]的范围很大,大到不能直接开这么大的数组来进行存储dp数组。
看的题解学习到了新思路。把所有工作按照结束时间排序,可以只使用O(n)的空间存储dp数组。
代码实现
class Solution {
public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
int len = startTime.length;
var job = new int[len][];
for(int i = 0; i < len; i++) job[i] = new int[]{startTime[i], endTime[i], profit[i]};
Arrays.sort(job, (a, b) -> a[1] - b[1]);
// 只使O(n)的空间。
var dp = new int[len+1];
for(int i = 0; i < len; i++){
// 很厉害的思路,因为是按照结束时间排序,所以可是使用二分查找。
var j = binarySearch(job, i, job[i][0]);
dp[i+1] = Math.max(dp[i], dp[j] + job[i][2]);
}
return dp[len];
}
// 二分查找到 小于 target的 最大值,并返回其下标。
private int binarySearch(int[][] job, int right, int target){
int left = 0;
while(left < right){
int mid = left + (right - left) / 2;
if(job[mid][1] > target) right = mid;
else left = mid + 1;
}
return left;
}
}
礼盒的最大甜蜜度
题目描述
给你一个正整数数组 price ,其中 price[i] 表示第 i 类糖果的价格,另给你一个正整数 k 。
商店组合 k 类 不同 糖果打包成礼盒出售。礼盒的 甜蜜度 是礼盒中任意两种糖果 价格 绝对差的最小值。
返回礼盒的 最大 甜蜜度。
样例
样例输入
price = [13,5,1,8,21,2], k = 3
price = [1,3,1], k = 2
price = [7,7,7,7], k = 2
样例输出
8
解释:选出价格分别为 [13,5,21] 的三类糖果。
礼盒的甜蜜度为 min(|13 - 5|, |13 - 21|, |5 - 21|) = min(8, 8, 16) = 8 。
可以证明能够取得的最大甜蜜度就是 8 。
2
解释:选出价格分别为 [1,3] 的两类糖果。
礼盒的甜蜜度为 min(|1 - 3|) = min(2) = 2 。
可以证明能够取得的最大甜蜜度就是 2 。
0
解释:从现有的糖果中任选两类糖果,甜蜜度都会是 0 。
提示
- 1 < = p r i c e . l e n g t h < = 1 0 5 1 <= price.length <= 10^5 1<=price.length<=105
- 1 < = p r i c e [ i ] < = 1 0 9 1 <= price[i] <= 10^9 1<=price[i]<=109
- 2 < = k < = p r i c e . l e n g t h 2 <= k <= price.length 2<=k<=price.length
思路
这种最大中找最小,或最小中找最大,很容易是二分题目。有初始思路后,只需要证明答案区间具有单调性。
当前题目的单调性是甜蜜度越小,越有可能满足分为k类糖果。然后只需要找能满足分为k类糖果的最大甜蜜度。
代码实现
class Solution {
int[] price;
int k;
public int maximumTastiness(int[] price, int k) {
Arrays.sort(price);
this.price = price;
this.k = k;
int l = 0;
int r = price[price.length-1];
while(l <= r){
int mid = (r + l) / 2;
if(!check(mid)) r = mid - 1;
else l = mid + 1;
}
return r;
}
private boolean check(int x){
int ans = 1;
int max = price[0];
for(int i = 1; i < price.length; i++){
if(price[i] >= max + x){
max = price[i];
ans++;
}
}
return ans >= k;
}
}
最大的以 1 为边界的正方形
题目描述
给你一个由若干 0 和 1 组成的二维网格 grid,请你找出边界全部由 1 组成的最大 正方形 子网格,并返回该子网格中的元素数量。如果不存在,则返回 0。
样例
样例输入
grid = [[1,1,1],[1,0,1],[1,1,1]]
grid = [[1,1,0,0]]
样例输出
9
1
提示
- 1 <= grid.length <= 100
- 1 <= grid[0].length <= 100
- grid[i][j] 为 0 或 1
思路
还是区间求和,很容易想到前缀和,但又与一般前缀和不一样,因为是矩阵的原因。需要两个前缀和数组进行存储。
代码实现
class Solution {
public int largest1BorderedSquare(int[][] grid) {
int m = grid.length;
int n = grid[0].length;
int len = Math.min(n, m);
int[][] cs = new int[n+1][m+1], rs = new int[m+1][n+1];
for(int i = 0; i < m; i++)
for(int j = 0; j < n; j ++){
rs[i][j+1] = rs[i][j] + grid[i][j];
cs[j][i+1] = cs[j][i] + grid[i][j];
}
for(int k = len; k > 0; k--){
for(int i = 0; i <= m-k; i++){
for(int j = 0; j <= n-k; j++){
if(
rs[i][j+k] - rs[i][j] == k &&
cs[j][i+k] - cs[j][i] == k &&
rs[i+k-1][j + k] - rs[i+k-1][j] == k &&
cs[j+k-1][i + k] - cs[j+k-1][i] == k
)1
return k * k;
}
}
}
return 0;
}
}
矩阵中的前缀和还可以使用另一种方式,就是pre[i][j]的含义为matrix[i][j]的所有数之和,不过当前题目还是使用两个前缀和数组方便。