LeetCode852. 山脉数组的峰顶索引 / 374. 猜数字大小 / 278. 第一个错误的版本 / 第 54 场双周赛 / 第 245 场周赛
852. 山脉数组的峰顶索引
2021.6.15每日一题
题目描述
符合下列属性的数组 arr 称为 山脉数组 ：
arr.length >= 3
存在 i（0 < i < arr.length - 1）使得：
arr[0] < arr[1] < ... arr[i-1] < arr[i]
arr[i] > arr[i+1] > ... > arr[arr.length - 1]
给你由整数组成的山脉数组 arr ，返回任何满足 arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1] 的下标 i 。
示例 1：
输入：arr = [0,1,0]
输出：1
示例 2：
输入：arr = [0,2,1,0]
输出：1
示例 3：
输入：arr = [0,10,5,2]
输出：1
示例 4：
输入：arr = [3,4,5,1]
输出：2
示例 5：
输入：arr = [24,69,100,99,79,78,67,36,26,19]
输出：2
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/peak-index-in-a-mountain-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
已经连续第三天是一道简单的二分查找了，咋回事，说好的动规呢？？？
二分第一种写法，（向上取整）
class Solution {
public int peakIndexInMountainArray(int[] arr) {
//怎么突然连续三天变成二分查找了
int l = arr.length;
int left = 1;
int right = l - 1;
while(left < right){
int mid = (right - left + 1) / 2 + left;
if(arr[mid] < arr[mid - 1]){
right = mid - 1;
}else{
left = mid;
}
}
return left;
}
}
374. 猜数字大小
2021.6.14每日一题
题目描述
猜数字游戏的规则如下：
每轮游戏，我都会从 1 到 n 随机选择一个数字。 请你猜选出的是哪个数字。
如果你猜错了，我会告诉你，你猜测的数字比我选出的数字是大了还是小了。
你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果，返回值一共有 3 种可能的情况（-1，1 或 0）：
-1：我选出的数字比你猜的数字小 pick < num
1：我选出的数字比你猜的数字大 pick > num
0：我选出的数字和你猜的数字一样。恭喜！你猜对了！pick == num
返回我选出的数字。
示例 1：
输入：n = 10, pick = 6
输出：6
示例 2：
输入：n = 1, pick = 1
输出：1
示例 3：
输入：n = 2, pick = 1
输出：1
示例 4：
输入：n = 2, pick = 2
输出：2
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/guess-number-higher-or-lower
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
二分第二种写法
public class Solution extends GuessGame {
public int guessNumber(int n) {
int left = 1;
int right = n;
while(left <= right){
int mid = (right - left) / 2 + left;
if(guess(mid) == 0){
return mid;
}else if(guess(mid) == 1)
left = mid + 1;
else
right = mid - 1;
}
return left;
}
}
278. 第一个错误的版本
2021.6.13每日一题
题目描述
你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
示例:
给定 n = 5，并且 version = 4 是第一个错误的版本。
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/first-bad-version
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
第一个二分查找的写法（向下取整）
public class Solution extends VersionControl {
public int firstBadVersion(int n) {
int left = 1;
int right = n;
while(left < right){
int mid = left + (right - left) / 2;
boolean x = isBadVersion(mid);
if(!x)
left = mid + 1;
if(x){
right = mid;
}
}
return left;
}
}
第 54 场双周赛
1893. 检查是否区域内所有整数都被覆盖
t题目描述
给你一个二维整数数组 ranges 和两个整数 left 和 right 。每个 ranges[i] = [starti, endi] 表示一个从 starti 到 endi 的 闭区间 。
如果闭区间 [left, right] 内每个整数都被 ranges 中 至少一个 区间覆盖，那么请你返回 true ，否则返回 false 。
已知区间 ranges[i] = [starti, endi] ，如果整数 x 满足 starti <= x <= endi ，那么我们称整数x 被覆盖了。
示例 1：
输入：ranges = [[1,2],[3,4],[5,6]], left = 2, right = 5
输出：true
解释：2 到 5 的每个整数都被覆盖了：
- 2 被第一个区间覆盖。
- 3 和 4 被第二个区间覆盖。
- 5 被第三个区间覆盖。
示例 2：
输入：ranges = [[1,10],[10,20]], left = 21, right = 21
输出：false
解释：21 没有被任何一个区间覆盖。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/check-if-all-the-integers-in-a-range-are-covered
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
当时想到的就是排序，然后遍历，所有区间，找对应的值
但是刚开始我加了这么一句话，导致直接提交了三次都过不了，哭死！唉
if(left < ranges[0][0] || right > ranges[l - 1][1]) return false;
最后过的代码：
class Solution {
public boolean isCovered(int[][] ranges, int left, int right) {
Arrays.sort(ranges, new Comparator<int[]>(){
public int compare(int[] x, int[] y){
return x[1] == y[1] ? x[0] - y[0] : x[1] - y[1];
}
});
//或者用正则表达式
//Arrays.sort(ranges, (x, y) ->{
// return x[0] == y[0] ? x[1] - y[1] : x[0] - y[0];
//});
int index = 0;
int l = ranges.length;
while(left <= right){
if(left >= ranges[index][0] && left <= ranges[index][1])
left++;
else
index++;
if(index >= l)
break;
}
if(left > right)
return true;
else
return false;
}
}
说实话，题解的差分数组，没大看懂…
1894. 找到需要补充粉笔的学生编号
题目描述
一个班级里有 n 个学生，编号为 0 到 n - 1 。每个学生会依次回答问题，编号为 0 的学生先回答，然后是编号为 1 的学生，以此类推，直到编号为 n - 1 的学生，然后老师会重复这个过程，重新从编号为 0 的学生开始回答问题。
给你一个长度为 n 且下标从 0 开始的整数数组 chalk 和一个整数 k 。一开始粉笔盒里总共有 k 支粉笔。当编号为 i 的学生回答问题时，他会消耗 chalk[i] 支粉笔。如果剩余粉笔数量 严格小于 chalk[i] ，那么学生 i 需要 补充 粉笔。
请你返回需要 补充 粉笔的学生 编号 。
示例 1：
输入：chalk = [5,1,5], k = 22
输出：0
解释：学生消耗粉笔情况如下：
- 编号为 0 的学生使用 5 支粉笔，然后 k = 17 。
- 编号为 1 的学生使用 1 支粉笔，然后 k = 16 。
- 编号为 2 的学生使用 5 支粉笔，然后 k = 11 。
- 编号为 0 的学生使用 5 支粉笔，然后 k = 6 。
- 编号为 1 的学生使用 1 支粉笔，然后 k = 5 。
- 编号为 2 的学生使用 5 支粉笔，然后 k = 0 。
编号为 0 的学生没有足够的粉笔，所以他需要补充粉笔。
示例 2：
输入：chalk = [3,4,1,2], k = 25
输出：1
解释：学生消耗粉笔情况如下：
- 编号为 0 的学生使用 3 支粉笔，然后 k = 22 。
- 编号为 1 的学生使用 4 支粉笔，然后 k = 18 。
- 编号为 2 的学生使用 1 支粉笔，然后 k = 17 。
- 编号为 3 的学生使用 2 支粉笔，然后 k = 15 。
- 编号为 0 的学生使用 3 支粉笔，然后 k = 12 。
- 编号为 1 的学生使用 4 支粉笔，然后 k = 8 。
- 编号为 2 的学生使用 1 支粉笔，然后 k = 7 。
- 编号为 3 的学生使用 2 支粉笔，然后 k = 5 。
- 编号为 0 的学生使用 3 支粉笔，然后 k = 2 。
编号为 1 的学生没有足够的粉笔，所以他需要补充粉笔。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-the-student-that-will-replace-the-chalk
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
这个题感觉比第一个题还简单，需要注意的就是用long防止溢出
class Solution {
public int chalkReplacer(int[] chalk, int k) {
int l = chalk.length;
int index = 0;
long sum = 0;
for(int i = 0; i < l; i++){
sum += chalk[i];
}
k = (int)((long)k % sum);
while(k >= chalk[index]){
k -= chalk[index];
index = index + 1;
}
return index;
}
}
1895. 最大的幻方
题目描述
一个 k x k 的 幻方 指的是一个 k x k 填满整数的方格阵，且每一行、每一列以及两条对角线的和 全部相等 。幻方中的整数 不需要互不相同 。显然，每个 1 x 1 的方格都是一个幻方。
给你一个 m x n 的整数矩阵 grid ，请你返回矩阵中 最大幻方 的 尺寸 （即边长 k）。
示例 1：
输入：grid = [[7,1,4,5,6],[2,5,1,6,4],[1,5,4,3,2],[1,2,7,3,4]]
输出：3
解释：最大幻方尺寸为 3 。
每一行，每一列以及两条对角线的和都等于 12 。
- 每一行的和：5+1+6 = 5+4+3 = 2+7+3 = 12
- 每一列的和：5+5+2 = 1+4+7 = 6+3+3 = 12
- 对角线的和：5+4+3 = 6+4+2 = 12
示例 2：
输入：grid = [[5,1,3,1],[9,3,3,1],[1,3,3,8]]
输出：2
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/largest-magic-square
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
做了几次周赛了，我发现第三道题很喜欢出这种矩阵题…好像每次都有一道矩阵题
然后就是有思路，但是写不对…
我看了下数据范围，本来想处理每一行每一列的前缀和来着，后面觉得写的太麻烦，看了下数据范围，觉得暴力也能过，直接暴力吧，但是代码还是一直有问题，debug一下，看看问题出在哪里
当时代码：
class Solution {
int[][] grid;
int m;
int n;
public int largestMagicSquare(int[][] grid) {
//想了一会，觉得还不如之间遍历了
this.grid = grid;
int max = 1;
int len = m < n ? m : n;
//int[][] col = new int[m + 1][n + 1];
//int[][] row = new int[m + 1][n + 1];
//for(int i )
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
for(int k = max; k <= len; k++){
if(k == 1)
continue;
//这里应该写成>
if(i + k >= m || j + k >= n)
break;
if(judge(i, j, k))
max = Math.max(k, max);
}
}
}
return max;
}
public boolean judge(int i, int j, int k){
int value = 0;
//第i行的和
for(int y = j; y < j + k; y++){
value += grid[i][y];
}
//判断行和
for(int x = i + 1; x < i + k; x++){
int cur = 0;
for(int y = j; y < j + k; y++){
cur += grid[x][y];
}
if(cur != value)
return false;
}
for(int x = j; x < j + k; x++){
int cur = 0;
for(int y = i; y < i + k; y++){
cur += grid[y][x];
}
if(cur != value)
return false;
}
//对角线
int cox = 0;
for(int x = 0; x < k; x++){
cox += grid[i + x][j + x];
}
if(cox != value)
return false;
cox = 0;
for(int x = 0; x < k; x++){
//这里是i+k-1-x
cox += grid[i + k - x][j + x];
}
if(cox != value)
return false;
return true;
}
}
debug了一下，立马发现了问题，然后提交立马AC了…题解里也就是多处理了个前缀和…
说实话，挺难受的，每次都和做出第三道题插肩而过
改了以后的代码：
class Solution {
int[][] grid;
public int largestMagicSquare(int[][] grid) {
//想了一会，觉得还不如之间遍历了
this.grid = grid;
int m = grid.length;
int n = grid[0].length;
int max = 1;
int len = m < n ? m : n;
//int[][] col = new int[m + 1][n + 1];
//int[][] row = new int[m + 1][n + 1];
//for(int i )
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
for(int k = max; k <= len; k++){
if(k == 1)
continue;
if(i + k > m || j + k > n)
break;
if(judge(i, j, k))
max = Math.max(k, max);
}
}
}
return max;
}
public boolean judge(int i, int j, int k){
int value = 0;
//第i行的和
for(int y = j; y < j + k; y++){
value += grid[i][y];
}
//判断行和
for(int x = i + 1; x < i + k; x++){
int cur = 0;
for(int y = j; y < j + k; y++){
cur += grid[x][y];
}
if(cur != value)
return false;
}
for(int x = j; x < j + k; x++){
int cur = 0;
for(int y = i; y < i + k; y++){
cur += grid[y][x];
}
if(cur != value)
return false;
}
//对角线
int cox = 0;
for(int x = 0; x < k; x++){
cox += grid[i + x][j + x];
}
if(cox != value)
return false;
cox = 0;
for(int x = 0; x < k; x++){
cox += grid[i + k - 1 - x][j + x];
}
if(cox != value)
return false;
return true;
}
}
1896. 反转表达式值的最少操作次数
题目描述
给你一个 有效的 布尔表达式，用字符串 expression 表示。这个字符串包含字符 '1'，'0'，'&'（按位 与 运算），'|'（按位 或 运算），'(' 和 ')' 。
比方说，"()1|1" 和 "(1)&()" 不是有效 布尔表达式。而 "1"， "(((1))|(0))" 和 "1|(0&(1))" 是 有效 布尔表达式。
你的目标是将布尔表达式的 值 反转 （也就是将 0 变为 1 ，或者将 1 变为 0），请你返回达成目标需要的 最少操作 次数。
比方说，如果表达式 expression = "1|1|(0&0)&1" ，它的 值 为 1|1|(0&0)&1 = 1|1|0&1 = 1|0&1 = 1&1 = 1 。我们想要执行操作将 新的 表达式的值变成 0 。
可执行的 操作 如下：
将一个 '1' 变成一个 '0' 。
将一个 '0' 变成一个 '1' 。
将一个 '&' 变成一个 '|' 。
将一个 '|' 变成一个 '&' 。
注意：'&' 的 运算优先级 与 '|' 相同 。计算表达式时，括号优先级 最高 ，然后按照 从左到右 的顺序运算。
示例 1：
输入：expression = "1&(0|1)"
输出：1
解释：我们可以将 "1&(0|1)" 变成 "1&(0&1)" ，执行的操作为将一个 '|' 变成一个 '&' ，执行了 1 次操作。
新表达式的值为 0 。
示例 2：
输入：expression = "(0&0)&(0&0&0)"
输出：3
解释：我们可以将 "(0&0)&(0&0&0)" 变成 "(0|1)|(0&0&0)" ，执行了 3 次操作。
新表达式的值为 1 。
示例 3：
输入：expression = "(0|(1|0&1))"
输出：1
解释：我们可以将 "(0|(1|0&1))" 变成 "(0|(0|0&1))" ，执行了 1 次操作。
新表达式的值为 0 。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-cost-to-change-the-final-value-of-expression
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
当时没时间了，就看了个题，估计是动态规划
直接看注释吧，这题，我估计还得练个几百道才能在竞赛时间内做出来
class Solution {
//用一个二元组(x,y), 其中x表示将对应表达式的值变为 0，需要的最少操作次数，y 表示将对应表达式的值变为 1，需要的最少操作次数
Stack<int[]> num = new Stack<>(); //数字栈
Stack<Character> ops = new Stack<>(); //符号栈
public int minOperationsToFlip(String expression) {
for (int i = 0; i < expression.length(); i++) {
//当前字符
char c = expression.charAt(i);
//如果是数字
if (Character.isDigit(c)) {
//如果是0，那么
if (c == '0')
num.add(new int[]{0, 1});
else
num.add(new int[]{1, 0});
//如果是左括号
} else if (c == '(') {
ops.add('(');
//如果是右括号，进行计算
} else if (c == ')') {
while (ops.peek() != '(')
eval();
ops.pop();
//如果是符号&或者|，进行计算
} else {
while (!ops.isEmpty() && ops.peek() != '(')
eval();
ops.add(c);
}
}
while (!ops.isEmpty())
eval();
return Math.max(num.peek()[0], num.peek()[1]);
}
public void eval() {
//弹出当前运算符
int op = ops.pop();
//弹出栈顶的两个二元组
int[] b = num.pop();
int[] a = num.pop();
//如果是&，那么该怎么转移呢，只有1与1才是1
//所以s[0] = min{a[0] + b[0], a[0] + b[1], a[1] + b[0]}
//s[1] = a[1] + b[1]
//但是，还可以考虑将&转变成|，此时只需要一边为1就可以
//s[1] = min{s[1], a[1] + b[0] + 1, a[0] + b[1] + 1}
if (op == '&') {
int[] s0 = new int[]{b[0] + a[0], b[1] + a[0], b[0] + a[1]};
int[] s1 = new int[]{b[1] + a[1], b[1] + a[0] + 1, b[0] + a[1] + 1};
num.add(new int[]{get_min(s0), get_min(s1)});
//如果是|，那么该怎么转移呢，只有0|0才是0
//所以s[0] = a[0] + b[0]
//s[1] = min{a[1] + b[1], a[0] + b[1], a[1] + b[0]}
//但是，还可以考虑将|转变成&，此时只需要一边为0就可以
//s[0] = min{s[0], a[1] + b[0] + 1, a[0] + b[1] + 1}
} else {
int[] s0 = new int[]{b[0] + a[0], b[1] + a[0] + 1, b[0] + a[1] + 1};
int[] s1 = new int[]{b[1] + a[1], b[1] + a[0], b[0] + a[1]};
num.add(new int[]{get_min(s0), get_min(s1)});
}
}
private int get_min(int[] num) {
int min = Integer.MAX_VALUE;
for (int i = 0; i < num.length; i++) {
min = Math.min(min, num[i]);
}
return min;
}
}
第245场周赛
1897. 重新分配字符使所有字符串都相等
题目描述
给你一个字符串数组 words（下标 从 0 开始 计数）。
在一步操作中，需先选出两个 不同 下标 i 和 j，其中 words[i] 是一个非空字符串，接着将 words[i] 中的 任一 字符移动到 words[j] 中的 任一 位置上。
如果执行任意步操作可以使 words 中的每个字符串都相等，返回 true ；否则，返回 false 。
示例 1：
输入：words = ["abc","aabc","bc"]
输出：true
解释：将 words[1] 中的第一个 'a' 移动到 words[2] 的最前面。
使 words[1] = "abc" 且 words[2] = "abc" 。
所有字符串都等于 "abc" ，所以返回 true 。
示例 2：
输入：words = ["ab","a"]
输出：false
解释：执行操作无法使所有字符串都相等。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/redistribute-characters-to-make-all-strings-equal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
这个题做的时候，也出现了点小问题，脑子里想的是每个字符出现次数应该是数组长度的倍数，写的时候就去判断每个字符出现次数是否相同了。。。导致提交了三次才过
class Solution {
public boolean makeEqual(String[] words) {
//统计字符个数相同
int l = words.length;
if(l == 1)
return true;
int[] count = new int[26];
for(int i = 0; i < l; i++){
String s = words[i];
for(int j = 0; j < s.length(); j++){
count[s.charAt(j) - 'a']++;
}
}
for(int i = 0; i < 26; i++){
if(count[i] != 0 && count[i] % l != 0)
return false;
}
return true;
}
}
1898. 可移除字符的最大数目
题目描述
给你两个字符串 s 和 p ，其中 p 是 s 的一个 子序列 。同时，给你一个元素 互不相同 且下标 从 0 开始 计数的整数数组 removable ，该数组是 s 中下标的一个子集（s 的下标也 从 0 开始 计数）。
请你找出一个整数 k（0 <= k <= removable.length），选出 removable 中的 前 k 个下标，然后从 s 中移除这些下标对应的 k 个字符。整数 k 需满足：在执行完上述步骤后， p 仍然是 s 的一个 子序列 。更正式的解释是，对于每个 0 <= i < k ，先标记出位于 s[removable[i]] 的字符，接着移除所有标记过的字符，然后检查 p 是否仍然是 s 的一个子序列。
返回你可以找出的 最大 k ，满足在移除字符后 p 仍然是 s 的一个子序列。
字符串的一个 子序列 是一个由原字符串生成的新字符串，生成过程中可能会移除原字符串中的一些字符（也可能不移除）但不改变剩余字符之间的相对顺序。
示例 1：
输入：s = "abcacb", p = "ab", removable = [3,1,0]
输出：2
解释：在移除下标 3 和 1 对应的字符后，"abcacb" 变成 "accb" 。
"ab" 是 "accb" 的一个子序列。
如果移除下标 3、1 和 0 对应的字符后，"abcacb" 变成 "ccb" ，那么 "ab" 就不再是 s 的一个子序列。
因此，最大的 k 是 2 。
示例 2：
输入：s = "abcbddddd", p = "abcd", removable = [3,2,1,4,5,6]
输出：1
解释：在移除下标 3 对应的字符后，"abcbddddd" 变成 "abcddddd" 。
"abcd" 是 "abcddddd" 的一个子序列。
示例 3：
输入：s = "abcab", p = "abc", removable = [0,1,2,3,4]
输出：0
解释：如果移除数组 removable 的第一个下标，"abc" 就不再是 s 的一个子序列。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-number-of-removable-characters
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
这个题，没想出来好吧，遍历还需要复杂度是n2，过不了
比赛结束第一时间看这道题，发现大佬们用的都是二分，瞬间明悟了，感觉没做出来实在不应该
class Solution {
public int maximumRemovals(String s, String p, int[] removable) {
//为什么能用二分查找呢，因为如果在removable数组中选择在s删除了前k个下标对应的字符，
//p仍然是s的子串的话，那么删除前k-1个下标，p肯定也是s的子序列
//因此具备二分性，可以用二分查找来降低复杂度
//首先需要写一个如何判断是子序列
//然后用每次删除对应的元素后的s，去匹配p
int l = removable.length;
int left = 0;
int right = l; //（要取到最后一个下标，需要是l）
while(left < right){
int mid = (right - left) / 2 + left;
StringBuffer sb = new StringBuffer(s);
//把该删除的字符删除掉
for(int i = 0; i <= mid; i++){
//注意：这里不能直接用deleteCharAt，而是替换
sb.setCharAt(removable[i], ' ');
}
if(check(sb.toString(), p)){
left = mid + 1;
}else
right = mid;
}
return left;
}
public boolean check(String s, String p){
int ls = s.length();
int lp = p.length();
int i = 0;
int j = 0;
while(i < ls && j < lp){
if(s.charAt(i) == p.charAt(j))
j++;
i++;
}
return j == lp;
}
}
1899. 合并若干三元组以形成目标三元组
题目描述
三元组 是一个由三个整数组成的数组。给你一个二维整数数组 triplets ，其中 triplets[i] = [ai, bi, ci] 表示第 i 个 三元组 。同时，给你一个整数数组 target = [x, y, z] ，表示你想要得到的 三元组 。
为了得到 target ，你需要对 triplets 执行下面的操作 任意次（可能 零 次）：
选出两个下标（下标 从 0 开始 计数）i 和 j（i != j），并 更新 triplets[j] 为 [max(ai, aj), max(bi, bj), max(ci, cj)] 。
例如，triplets[i] = [2, 5, 3] 且 triplets[j] = [1, 7, 5]，triplets[j] 将会更新为 [max(2, 1), max(5, 7), max(3, 5)] = [2, 7, 5] 。
如果通过以上操作我们可以使得目标 三元组 target 成为 triplets 的一个 元素 ，则返回 true ；否则，返回 false 。
示例 1：
输入：triplets = [[2,5,3],[1,8,4],[1,7,5]], target = [2,7,5]
输出：true
解释：执行下述操作：
- 选择第一个和最后一个三元组 [[2,5,3],[1,8,4],[1,7,5]] 。更新最后一个三元组为 [max(2,1), max(5,7), max(3,5)] = [2,7,5] 。triplets = [[2,5,3],[1,8,4],[2,7,5]]
目标三元组 [2,7,5] 现在是 triplets 的一个元素。
示例 2：
输入：triplets = [[1,3,4],[2,5,8]], target = [2,5,8]
输出：true
解释：目标三元组 [2,5,8] 已经是 triplets 的一个元素。
示例 3：
输入：triplets = [[2,5,3],[2,3,4],[1,2,5],[5,2,3]], target = [5,5,5]
输出：true
解释：执行下述操作：
- 选择第一个和第三个三元组 [[2,5,3],[2,3,4],[1,2,5],[5,2,3]] 。更新第三个三元组为 [max(2,1), max(5,2), max(3,5)] = [2,5,5] 。triplets = [[2,5,3],[2,3,4],[2,5,5],[5,2,3]] 。
- 选择第三个和第四个三元组 [[2,5,3],[2,3,4],[2,5,5],[5,2,3]] 。更新第四个三元组为 [max(2,5), max(5,2), max(5,3)] = [5,5,5] 。triplets = [[2,5,3],[2,3,4],[2,5,5],[5,5,5]] 。
目标三元组 [5,5,5] 现在是 triplets 的一个元素。
示例 4：
输入：triplets = [[3,4,5],[4,5,6]], target = [3,2,5]
输出：false
解释：无法得到 [3,2,5] ，因为 triplets 不含 2 。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-triplets-to-form-target-triplet
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
这个题做出来了，怎么想的呢，就是每次都是比较两个数组取较大值，因此必须得有三个数组（可以两个或者一个），三元组中一个元素等于target数组中对应的元素，其他两个小于target中对应元素
如果存在这样的“三个”数组，就可以形成target
class Solution {
public boolean mergeTriplets(int[][] triplets, int[] target) {
//想想，从左到右遍历，如果有一个包含目标数，并且后面
int l = triplets.length;
boolean flag1 = false;
boolean flag2 = false;
boolean flag3 = false;
for(int i = 0; i < l; i++){
if(triplets[i][0] == target[0] && triplets[i][1] <= target[1] && triplets[i][2] <= target[2])
flag1 = true;
if(triplets[i][1] == target[1] && triplets[i][0] <= target[0] && triplets[i][2] <= target[2])
flag2 = true;
if(triplets[i][2] == target[2] && triplets[i][0] <= target[0] && triplets[i][1] <= target[1])
flag3 = true;
}
if(flag1 && flag2 && flag3)
return true;
else
return false;
}
}
1900. 最佳运动员的比拼回合
题目描述
n 名运动员参与一场锦标赛，所有运动员站成一排，并根据 最开始的 站位从 1 到 n 编号（运动员 1 是这一排中的第一个运动员，运动员 2 是第二个运动员，依此类推）。
锦标赛由多个回合组成（从回合 1 开始）。每一回合中，这一排从前往后数的第 i 名运动员需要与从后往前数的第 i 名运动员比拼，获胜者将会进入下一回合。如果当前回合中运动员数目为奇数，那么中间那位运动员将轮空晋级下一回合。
例如，当前回合中，运动员 1, 2, 4, 6, 7 站成一排
运动员 1 需要和运动员 7 比拼
运动员 2 需要和运动员 6 比拼
运动员 4 轮空晋级下一回合
每回合结束后，获胜者将会基于最开始分配给他们的原始顺序（升序）重新排成一排。
编号为 firstPlayer 和 secondPlayer 的运动员是本场锦标赛中的最佳运动员。在他们开始比拼之前，完全可以战胜任何其他运动员。而任意两个其他运动员进行比拼时，其中任意一个都有获胜的可能，因此你可以 裁定 谁是这一回合的获胜者。
给你三个整数 n、firstPlayer 和 secondPlayer 。返回一个由两个值组成的整数数组，分别表示两位最佳运动员在本场锦标赛中比拼的 最早 回合数和 最晚 回合数。
示例 1：
输入：n = 11, firstPlayer = 2, secondPlayer = 4
输出：[3,4]
解释：
一种能够产生最早回合数的情景是：
回合 1：1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
回合 2：2, 3, 4, 5, 6, 11
回合 3：2, 3, 4
一种能够产生最晚回合数的情景是：
回合 1：1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
回合 2：1, 2, 3, 4, 5, 6
回合 3：1, 2, 4
回合 4：2, 4
示例 2：
输入：n = 5, firstPlayer = 1, secondPlayer = 5
输出：[1,1]
解释：两名最佳运动员 1 和 5 将会在回合 1 进行比拼。
不存在使他们在其他回合进行比拼的可能。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/the-earliest-and-latest-rounds-where-players-compete
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
看注释吧，不太好理解
还可以用记忆化搜索进行优化，也就是用dp[n][f][s][2]将，当前n个人，并且两个最佳运动员位置在f和s，最少回合数和最多回合数
class Solution {
//首先明确，如果f+s == n+1 ，就说明两个人相遇了
//f 对称的位置是 f' = n + 1 - f；s对称的位置是s' = n + 1 - s
//而考虑两个最佳运动员的位置，因为两个最佳运动员的位置可以互换，并不会影响最后的结果，
//所以，只考虑 f 离左边的距离小于 s 离右边的距离 的情况
public int[] earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
if (firstPlayer + secondPlayer == n + 1){
return new int[]{1,1};
}
//如果f 离左边的距离大于 s 离右边的距离了，那么就将这两个人的相对位置进行互换，不影响结果
if (firstPlayer > n + 1 - secondPlayer){
return earliestAndLatest(n, n + 1 - secondPlayer, n + 1 - firstPlayer);
}
int m = (n + 1) >> 1; //中间位置，也就是下一轮剩下的人数，向上取整
int min = n, max = 0;
//如果两个运动员都在同一侧（或者s在中间），f 左边有f−1个运动员，那么进行一轮比赛以后，可能留下 0~f-1 个人，所以fx的位置就可能是1到f
//f到s之间有s - f - 1个运动员，结束以后，可能剩下0~s-f-1个运动员，所以sx的位置，就是 fx + 1 ~ s- f- 1 + fx + 1
//遍历所有可能出现的情况，最早回合数就是取最小值，最晚回合数就是取最大值
if (secondPlayer <= m){
for (int f = 1; f <= firstPlayer; f++) {
for (int s = f + 1; s <= secondPlayer - firstPlayer + f; s++) {
int[] el = earliestAndLatest(m, f, s);
min = Math.min(el[0], min);
max = Math.max(el[1], max);
}
}
//如果f和s在两侧，s的对称位置就是s' = n + 1 - s
//与上一种情况同理，f左边情况一样
//f到s'出现的人数也与上一种情况一样，
//s'到s出现的人数，因为是对称的，所以不论怎么比，都是出现m - s' - 1个人（即一半人）
//所以下一轮s的位置sx，就是在上一种情况的基础上（以s'为s的情况下），再加上中间出现的人数，也就是m - s' - 1，再加1
//就有下面这种转移方程
}else {
int _s = n + 1 - secondPlayer;
for (int f = 1; f <= firstPlayer; f++) {
for (int s = f + 1; s <= _s - firstPlayer + f ; s++) {
int[] el = earliestAndLatest(m, f, s + m - _s);
min = Math.min(el[0],min);
max = Math.max(el[1],max);
}
}
}
//最后的结果，加上当前轮次
return new int[]{min + 1, max + 1};
}
}
记忆化搜索的代码：
class Solution{
int[][][][] earliest = new int[28][28][28][2];
public int[] earliestAndLatest(int n, int fp, int sp) {
if (earliest[n][fp][sp][0] != 0) return earliest[n][fp][sp];
if (sp == n-fp+1) {
earliest[n][fp][sp][0] = earliest[n][fp][sp][1] = 1;
return earliest[n][fp][sp];
}
solveEar(n ,fp, sp, 1, new boolean[n+1]);
return earliest[n][fp][sp];
}
public void solveEar(int n, int fp, int sp, int index, boolean[] se) {
int s = n-index+1;
if (index >= s) {
if (index == n-index+1) se[index] = true;
int nfp = 0, nsp = 0;
for (int i = 1; i <= n; i++) {
if (i <= fp && se[i]) nfp++;
if (i <= sp && se[i]) nsp++;
}
int[] ints = earliestAndLatest(n / 2 + (n % 2), nfp, nsp);
if (earliest[n][fp][sp][0] == 0 || earliest[n][fp][sp][0] > ints[0]+1)
earliest[n][fp][sp][0] = ints[0]+1;
if (earliest[n][fp][sp][1] == 0 || earliest[n][fp][sp][1] < ints[1]+1)
earliest[n][fp][sp][1] = ints[1]+1;
return;
}
if (s != fp && s != sp) {
se[index] = true; se[s] = false;
solveEar(n, fp, sp, index+1, se);
}
if (index != sp && index != fp) {
se[index] = false; se[s] = true;
solveEar(n, fp, sp, index+1, se);
}
}
}
作者：god_like
链接：https://leetcode-cn.com/problems/the-earliest-and-latest-rounds-where-players-compete/solution/ji-yi-hua-sou-suo-by-god_like-ftpd/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
小结
这周两个周赛，周六晚上的还好，周日是真没太想做，但是想着做了一个另一个不做，那积分不是拿不到了么，有点亏哈哈，所以还是坚持着把周日的也做了，虽然做了半个来小时做不出来剩下的就算了，但这也算一种精神上的进步吧哈哈
这两次周赛怎么说呢，好像还是没有什么进步，第三道题依旧是思路拉满，但是代码一写就有小毛病，而且第一道题还会错好几次。挺难受的，其实看了一下，两道题如果不错按我的速度做出来不错的话，1000名之内还是没问题的，第三道再认真一点，可能也能做出来
至于最后一道题呢，每次基本上都是动规了，各种各样的动规，想起来确实费脑筋。今天偶然看到一个帖子，做了二百道题，什么周赛只能过两道什么什么的，我一想我已经刷了将近500道了，然后还是过两道的水平…瞬间有点小难受，可能还是自己太菜了，还要加油啊
总结完毕，又得搞课题了，-_-