6451. Find the Maximum Achievable Number
给你两个整数 num 和 t 。
如果整数 x 可以在执行下述操作不超过 t 次的情况下变为与 num 相等，则称其为 可达成数字 ：
- 每次操作将 x 的值增加或减少 1 ，同时可以选择将 num 的值增加或减少 1 。
返回所有可达成数字中的最大值。可以证明至少存在一个可达成数字。
测试样例：
输入：num = 4, t = 1
输出：6
解释：
最大可达成数字是 x = 6 ，执行下述操作可以使其等于 num ：
- x 减少 1 ，同时 num 增加 1 。此时，x = 5 且 num = 5 。
可以证明不存在大于 6 的可达成数字。
解答：很简单的数学题
class Solution {
public int theMaximumAchievableX(int num, int t) {
return 2 * t + num;
}
}6899. Maximum Number of Jumps to Reach the Last Index
给你一个下标从 0 开始、由 n 个整数组成的数组 nums 和一个整数 target 。
你的初始位置在下标 0 。在一步操作中，你可以从下标 i 跳跃到任意满足下述条件的下标 j ：
- 0 <= i < j < n
- -target <= nums[j] - nums[i] <= target
返回到达下标 n - 1 处所需的 最大跳跃次数 。
如果无法到达下标 n - 1 ，返回 -1 。
测试样例：
输入：nums = [1,3,6,4,1,2], target = 2
输出：2
解释：
要想以最大跳跃次数从下标 0 到下标 n - 1 ，可以按下述跳跃序列执行操作：
- 从下标 0 跳跃到下标 1 。
- 从下标 1 跳跃到下标 3 。
- 从下标 3 跳跃到下标 5 。
可以证明，从 0 到 n - 1 的所有方案中，不存在比 3 步更长的跳跃序列。因此，答案是 3 。
解答：从头到尾遍历，然后记录通过这个点跳跃时，能到达的节点与最大跳数。
class Solution {
public int maximumJumps(int[] nums, int target) {
int len = nums.length;
int[] mem = new int[len];
Arrays.fill(mem, -1);
mem[0] = 0;
for (int i = 0; i < len; ++i) {
if (mem[i] != -1) {
for (int j = i + 1; j < len; ++j) {
if (Math.abs(nums[j] - nums[i]) <= target) {
mem[j] = Math.max(mem[i] + 1, mem[j]);
}
}
}
}
return mem[len - 1];
}
}6912. Longest Non-decreasing Subarray From Two Arrays
给你两个下标从 0 开始的整数数组 nums1 和 nums2 ，长度均为 n 。
让我们定义另一个下标从 0 开始、长度为 n 的整数数组，nums3 。对于范围 [0, n - 1] 的每个下标 i ，你可以将 nums1[i] 或 nums2[i] 的值赋给 nums3[i] 。
你的任务是使用最优策略为 nums3 赋值，以最大化 nums3 中 最长非递减子数组 的长度。
以整数形式表示并返回 nums3 中 最长非递减 子数组的长度。
注意：子数组 是数组中的一个连续非空元素序列。
测试样例
输入：nums1 = [2,3,1], nums2 = [1,2,1]
输出：2
解释：
构造 nums3 的方法之一是： nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1]。从下标 0 开始到下标 1 结束，形成了一个长度为 2 的非递减子数组 [2,2] 。 可以证明 2 是可达到的最大长度。
解答：因为题目考的是连续递增子序列，那么记录一下之前的数值和最长连续子序列长度（如果当前数字比较小，那就是新的连续子序列开头，默认赋值1）。然后记录一下出现的最长长度。
class Solution {
public int maxNonDecreasingLength(int[] nums1, int[] nums2) {
int[] dp = {0,0}, last = {-1,-1};
int len = nums1.length, res = 0;
for (int i = 0; i < len; ++i) {
int[] nextLast = {nums1[i], nums2[i]}, nextDp = {1,1};
if (nextLast[0] >= last[0]) {
nextDp[0] = Math.max(nextDp[0], 1 + dp[0]);
}
if (nextLast[0] >= last[1]) {
nextDp[0] = Math.max(nextDp[0], 1 + dp[1]);
}
if (nextLast[1] >= last[0]) {
nextDp[1] = Math.max(nextDp[1], 1 + dp[0]);
}
if (nextLast[1] >= last[1]) {
nextDp[1] = Math.max(nextDp[1], 1 + dp[1]);
}
dp = nextDp;
last = nextLast;
for (int n : dp) {
res = Math.max(res, n);
}
}
return res;
}
}6919. Apply Operations to Make All Array Elements Equal to Zero
给你一个下标从 0 开始的整数数组 nums 和一个正整数 k 。
你可以对数组执行下述操作 任意次 ：
- 从数组中选出长度为 k 的 任一 子数组，并将子数组中每个元素都 减去 1 。
如果你可以使数组中的所有元素都等于 0 ，返回 true ；否则，返回 false 。
子数组是数组中的一个非空连续元素序列。
测试样例
输入：nums = [2,2,3,1,1,0], k = 3
输出：true
解释：可以执行下述操作：
- 选出子数组 [2,2,3] ，执行操作后，数组变为 nums = [1,1,2,1,1,0] 。
- 选出子数组 [2,1,1] ，执行操作后，数组变为 nums = [1,1,1,0,0,0] 。
- 选出子数组 [1,1,1] ，执行操作后，数组变为 nums = [0,0,0,0,0,0] 。
解答：这道题目有一点点脑筋急转弯。第一个数字，必然需要选第一个数字为开头的子序列，然后操作nums[0]次。由于这个时候nums[0]为0，nums[1]又变成开头，需要操作nums[1]次。依次类推就可以了。
class Solution {
public boolean checkArray(int[] nums, int k) {
int len = nums.length;
int[] preSum = new int[len + 1];
int sum = 0;
for (int i = 0; i < nums.length; ++i) {
sum += preSum[i];
if (nums[i] - sum < 0) {
return false;
}
if (nums[i] - sum != 0) {
if (i + k > len) {
return false;
} else if (i + k <= len) {
preSum[i + k] = sum - nums[i];
sum = nums[i];
}
}
}
return true;
}
}