1034. 边界着色
2021.12.7 每日一题
题目描述
给你一个大小为 m x n 的整数矩阵 grid ,表示一个网格。另给你三个整数 row、col 和 color 。网格中的每个值表示该位置处的网格块的颜色。
当两个网格块的颜色相同,而且在四个方向中任意一个方向上相邻时,它们属于同一 连通分量 。
连通分量的边界 是指连通分量中的所有与不在分量中的网格块相邻(四个方向上)的所有网格块,或者在网格的边界上(第一行/列或最后一行/列)的所有网格块。
请你使用指定颜色 color 为所有包含网格块 grid[row][col] 的 连通分量的边界 进行着色,并返回最终的网格 grid 。
示例 1:
输入:grid = [[1,1],[1,2]], row = 0, col = 0, color = 3
输出:[[3,3],[3,2]]
示例 2:
输入:grid = [[1,2,2],[2,3,2]], row = 0, col = 1, color = 3
输出:[[1,3,3],[2,3,3]]
示例 3:
输入:grid = [[1,1,1],[1,1,1],[1,1,1]], row = 1, col = 1, color = 2
输出:[[2,2,2],[2,1,2],[2,2,2]]
提示:
m == grid.length
n == grid[i].length
1 <= m, n <= 50
1 <= grid[i][j], color <= 1000
0 <= row < m
0 <= col < n
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/coloring-a-border
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路
bfs
class Solution {
int[][] direction = {{0,1},{0,-1},{1,0},{-1,0}};
public int[][] colorBorder(int[][] grid, int row, int col, int color) {
//就是一个dfs或者bfs吧,找到是边界的或者周围有不在分量中的网格块,就着色
int m = grid.length;
int n = grid[0].length;
int baseColor = grid[row][col];
Queue<int[]> queue = new LinkedList<>();
boolean[][] visited = new boolean[m][n];
queue.offer(new int[]{row, col});
visited[row][col] = true;
Set<String> set = new HashSet();
set.add(row + "+" + col);
while(!queue.isEmpty()){
int[] top = queue.poll();
//如果在边界的话
if(top[0] == 0 || top[0] == m - 1 || top[1] == 0 || top[1] == n - 1)
grid[top[0]][top[1]] = color;
for(int i = 0; i < 4; i++){
int nr = top[0] + direction[i][0];
int nc = top[1] + direction[i][1];
if(nr < 0 || nr >= m || nc < 0 || nc >= n)
continue;
//如果这个位置遍历过同时这个位置的颜色不是所给颜色,那么当前位置可以涂色
if(visited[nr][nc] && !set.contains(nr + "+" + nc)){
grid[top[0]][top[1]] = color;
continue;
}
if(visited[nr][nc])
continue;
visited[nr][nc] = true;
if(grid[nr][nc] == baseColor){
queue.offer(new int[]{nr, nc});
set.add(nr + "+" + nc);
}
//如果不是所给颜色
else
grid[top[0]][top[1]] = color;
}
}
return grid;
}
}
689. 三个无重叠子数组的最大和
2021.12.8 每日一题
题目描述
给你一个整数数组 nums 和一个整数 k ,找出三个长度为 k 、互不重叠、且 3 * k 项的和最大的子数组,并返回这三个子数组。
以下标的数组形式返回结果,数组中的每一项分别指示每个子数组的起始位置(下标从 0 开始)。如果有多个结果,返回字典序最小的一个。
示例 1:
输入:nums = [1,2,1,2,6,7,5,1], k = 2
输出:[0,3,5]
解释:子数组 [1, 2], [2, 6], [7, 5] 对应的起始下标为 [0, 3, 5]。
也可以取 [2, 1], 但是结果 [1, 3, 5] 在字典序上更大。
示例 2:
输入:nums = [1,2,1,2,1,2,1,2,1], k = 2
输出:[0,2,4]
提示:
1 <= nums.length <= 2 * 10^4
1 <= nums[i] < 2^16
1 <= k <= floor(nums.length / 3)
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/maximum-sum-of-3-non-overlapping-subarrays
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路
三个区间滑动窗口,学到了
class Solution {
public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
//首先肯定要计算出所有k长度子数组的和
//如果是两个子数组,怎么滑动
//首先维护两个窗口,然后在向右滑动的过程中,记录第一个窗口的最大值,
//同时记录当前第二个窗口和第一个窗口最大值的和,这样可以保证和是最大的
//如果是三个子数组,那么先维护三个窗口,然后开始滑动,同时维护前两个窗口的最大值
//自己写一下试试
int[] res = new int[3];
int l = nums.length;
int sum1 = 0, max1 = 0, max1idx1 = 0;
int sum2 = 0, max12 = 0, max12idx1 = 0, max12idx2 = 0;
int sum3 = 0, max123 = 0;
for(int i = 2 * k; i < l; i++){
sum1 += nums[i - 2 * k];
sum2 += nums[i - k];
sum3 += nums[i];
//如果三个区间满了,那么就开始判断
if(i >= 3 * k - 1){
//第一个区间最大
if(sum1 > max1){
max1 = sum1;
max1idx1 = i - 3 * k + 1;
}
//前两个区间最大
if(max1 + sum2 > max12){
max12 = max1 + sum2;
max12idx1 = max1idx1;
max12idx2 = i - 2 * k + 1;
}
if(max12 + sum3 > max123){
max123 = max12 + sum3;
res[0] = max12idx1;
res[1] = max12idx2;
res[2] = i - k + 1;
}
sum1 -= nums[i - 3 * k + 1];
sum2 -= nums[i - 2 * k + 1];
sum3 -= nums[i - k + 1];
}
}
return res;
}
}
动态规划求解最大值,然后回溯得到三个区间的下标
回溯求字典序最小,两个思路,一个是反序dp,一个是反转数组
反转数组:
class Solution {
public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
//写一下动态规划的
//dp[i][j]表示前i个数,分成j个子数组的最大和
//dp[i][j] = Math.max(dp[i - 1][j], dp[i - k][j - 1] + 当前子数组)
//主要问题是动规能计算出最大值,但是怎么知道是哪三个数组呢
//又得学了,三叶姐给出两个思路
//要求出三个数组的开始下标就需要回溯得到
//因为这样动态规划,回溯的话只能得到字典序最大的下标
//所以需要特殊处理,两种方案,第一种是反序dp,第二种的反转数组
//先写个反转数组的
int l = nums.length;
reverse(nums);
//先写个前缀和,方便计算区间值
long[] presum = new long[l + 1];
for(int i = 0; i < l; i++){
presum[i + 1] = presum[i] + nums[i];
}
long[][] dp = new long[l + 1][4];
for(int i = k; i <= l; i++){
for(int j = 1; j <= 3; j++){
dp[i][j] = Math.max(dp[i - 1][j], dp[i - k][j - 1] + presum[i] - presum[i - k]);
}
}
//得到这么一个结果
//回溯
int[] res = new int[3];
int i = l;
int j = 3;
int idx = 0;
while(j > 0){
//如果前者大于后者,那么说明是从前者转移来的,所以i--
if(dp[i - 1][j] > dp[i - k][j - 1] + presum[i] - presum[i - k]){
i--;
//如果是后者,那么说明包含这个i的区间被选择了,所以可以更新res
}else{
j--;
res[idx++] = l - i;
i -= k;
}
}
return res;
}
public void reverse(int[] nums){
int l = 0;
int r = nums.length - 1;
while(l < r){
int t = nums[l];
nums[l] = nums[r];
nums[r] = t;
l++;
r--;
}
}
}
反序dp,也就是从后往前算,这样做是为了在回溯的时候就能先得到字典序小的下标
需要注意的是各种下标的值
class Solution {
public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
//写一下动态规划的
//dp[i][j]表示前i个数,分成j个子数组的最大和
//dp[i][j] = Math.max(dp[i - 1][j], dp[i - k][j - 1] + 当前子数组)
//主要问题是动规能计算出最大值,但是怎么知道是哪三个数组呢
//又得学了,三叶姐给出两个思路
//要求出三个数组的开始下标就需要回溯得到
//因为这样动态规划,回溯的话只能得到字典序最大的下标
//所以需要特殊处理,两种方案,第一种是反序dp,第二种的反转数组
//反序dp
int l = nums.length;
//先写个前缀和,方便计算区间值
long[] presum = new long[l + 1];
for(int i = 0; i < l; i++){
presum[i + 1] = presum[i] + nums[i];
}
long[][] dp = new long[l + 2][4];
//反序dp
//也就是dp[i][j] = Math.max(dp[i + 1][j], dp[i + k][j - 1] + 当前子数组)
for(int i = l - k + 1; i >= 1; i--){
for(int j = 1; j <= 3; j++){
dp[i][j] = Math.max(dp[i + 1][j], dp[i + k][j - 1] + presum[i + k - 1] - presum[i - 1]);
}
}
//得到这么一个结果
//回溯
int[] res = new int[3];
int i = 1;
int j = 3;
int idx = 0;
while(j > 0){
//如果前者大于后者,那么说明是从前者转移来的,所以i--
if(dp[i + 1][j] > dp[i + k][j - 1] + presum[i + k - 1] - presum[i - 1]){
i++;
//如果是后者,那么说明包含这个i的区间被选择了,所以可以更新res
}else{
j--;
res[idx++] = i - 1;
i += k;
}
}
return res;
}
}
或者不用反序,也不用反转数组;相等的时候取前面的值就行了
class Solution {
public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
//写一下动态规划的
//dp[i][j]表示前i个数,分成j个子数组的最大和
//dp[i][j] = Math.max(dp[i - 1][j], dp[i - k][j - 1] + 当前子数组)
//主要问题是动规能计算出最大值,但是怎么知道是哪三个数组呢
//又得学了,三叶姐给出两个思路
//要求出三个数组的开始下标就需要回溯得到
//因为这样动态规划,回溯的话只能得到字典序最大的下标
//所以需要特殊处理,两种方案,第一种是反序dp,第二种的反转数组
//直接往前递推
int l = nums.length;
//先写个前缀和,方便计算区间值
long[] presum = new long[l + 1];
for(int i = 0; i < l; i++){
presum[i + 1] = presum[i] + nums[i];
}
long[][] dp = new long[l + 1][4];
for(int i = k; i <= l; i++){
for(int j = 1; j <= 3; j++){
dp[i][j] = Math.max(dp[i - 1][j], dp[i - k][j - 1] + presum[i] - presum[i - k]);
}
}
//得到这么一个结果
//回溯
int[] res = new int[3];
int i = l;
int j = 3;
int idx = 2;
while(j > 0){
//如果前者大于后者,那么说明是从前者转移来的,所以i--
if(dp[i - 1][j] >= dp[i - k][j - 1] + presum[i] - presum[i - k]){
i--;
//如果是后者,那么说明包含这个i的区间被选择了,所以可以更新res
}else{
j--;
res[idx--] = i - k;
i -= k;
}
}
return res;
}
}
794. 有效的井字游戏
2021.12.9 每日一题
题目描述
用字符串数组作为井字游戏的游戏板 board。当且仅当在井字游戏过程中,玩家有可能将字符放置成游戏板所显示的状态时,才返回 true。
该游戏板是一个 3 x 3 数组,由字符 " ",“X” 和 “O” 组成。字符 " " 代表一个空位。
以下是井字游戏的规则:
玩家轮流将字符放入空位(" ")中。
第一个玩家总是放字符 “X”,且第二个玩家总是放字符 “O”。
“X” 和 “O” 只允许放置在空位中,不允许对已放有字符的位置进行填充。
当有 3 个相同(且非空)的字符填充任何行、列或对角线时,游戏结束。
当所有位置非空时,也算为游戏结束。
如果游戏结束,玩家不允许再放置字符。
示例 1:
输入: board = ["O ", " ", " "]
输出: false
解释: 第一个玩家总是放置“X”。
示例 2:
输入: board = [“XOX”, " X ", " "]
输出: false
解释: 玩家应该是轮流放置的。
示例 3:
输入: board = [“XXX”, " ", “OOO”]
输出: false
示例 4:
输入: board = [“XOX”, “O O”, “XOX”]
输出: true
说明:
游戏板 board 是长度为 3 的字符串数组,其中每个字符串 board[i] 的长度为 3。
board[i][j] 是集合 {" ", “X”, “O”} 中的一个字符。
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/valid-tic-tac-toe-state
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路
改了半天,终于改出来一版正确的代码
然后改完发现,其实只需要判断哪些不满足条件就可以了,因为填满了,也返回true
所以只需要记录刚开始填充的X和O是否是不合理的,如果不合理的话,就返回false
如果合理的话,那么后面不管怎么填,无非是成线提前结束或者最后填满了还没成线,都会返回true
class Solution {
public boolean validTicTacToe(String[] board) {
//首先这个题要好好弄懂题意,根据所给的例子,以及自己的测试
//1.刚开始给定的几个字符要满足规则,也就是先放X再放O,第一个放X,如果不满足,直接false
//2.刚开始放置的位置如果连成线了,是不行的,必须是新放置的和原来放置的连线才可以
//3.不是两个人进行博弈,而是尽可能去连成线就行了
//看了答案,结合出错的示例,发现,不是开始放置的字符不算,而是如果开始放置的字符已经出现了满足条件的情况
//那么是合理的,但是如果同时O也相连,那么就不可能,比如第三个例子
//所以看刚开始的情况,如果O出现了相连,那么O的数目和X数目相同,并且X不能相连
//如果X出现了相连,那么X的数目要比O多一个
int x = 0;
int o = 0;
for(int i = 0; i < 3; i++){
String s = board[i];
for(int j = 0; j < 3; j++){
if(s.charAt(j) == 'X')
x++;
else if(s.charAt(j) == 'O')
o++;
}
}
int black = 9 - x - o;
//如果刚开始放置的不满足条件,false
if(o > x || x > o + 1)
return false;
boolean x3 = false; //刚开始相连的情况
boolean o3 = false; //刚开始相连的情况
boolean res = false; //可行不可行
//此时x和o还可以放置几个
int xl = 5 - x;
int ol = 4 - o;
//首先看行
for(int i = 0; i < 3; i++){
String s = board[i];
int tx = 0;
int to = 0;
for(int j = 0; j < 3; j++){
if(s.charAt(j) == 'X')
tx++;
else if(s.charAt(j) == 'O')
to++;
}
//如果是混杂的,那么不行
if(tx != 0 && to != 0)
continue;
else if(tx == 3)
x3 = true;
else if(to == 3)
o3 = true;
else if(tx != 0 && xl >= 3 - tx)
res = true;
else if(to != 0 && ol >= 3 - to)
res = true;
else if(tx == 0 && to == 0 && xl >= 3)
res = true;
}
//看列
for(int i = 0; i < 3; i++){
int tx = 0;
int to = 0;
for(int j = 0; j < 3; j++){
String s = board[j];
if(s.charAt(i) == 'X')
tx++;
else if(s.charAt(i) == 'O')
to++;
}
//如果是混杂的,那么不行
if(tx != 0 && to != 0)
continue;
else if(tx == 3)
x3 = true;
else if(to == 3)
o3 = true;
else if(tx != 0 && xl >= 3 - tx)
res = true;
else if(to != 0 && ol >= 3 - to)
res = true;
else if(tx == 0 && to == 0 && xl >= 3)
res = true;
}
//正对角线
int tx = 0;
int to = 0;
for(int i = 0; i < 3; i++){
if(board[i].charAt(i) == 'X')
tx++;
else if(board[i].charAt(i) == 'O')
to++;
}
//如果是混杂的,那么不行
if(tx != 0 && to != 0){
}
else if(tx == 3)
x3 = true;
else if(to == 3)
o3 = true;
else if(tx != 0 && xl >= 3 - tx)
res = true;
else if(to != 0 && ol >= 3 - to)
res = true;
else if(tx == 0 && to == 0 && xl >= 3)
res = true;
//反对角线
tx = 0;
to = 0;
for(int i = 0; i < 3; i++){
if(board[i].charAt(2 - i) == 'X')
tx++;
else if(board[i].charAt(2 - i) == 'O')
to++;
}
//如果是混杂的,那么不行
if(tx != 0 && to != 0){
}
else if(tx == 3)
x3 = true;
else if(to == 3)
o3 = true;
else if(tx != 0 && xl >= 3 - tx)
res = true;
else if(to != 0 && ol >= 3 - to)
res = true;
else if(tx == 0 && to == 0 && xl >= 3)
res = true;
//如果都为true,不可能
if(x3 && o3)`在这里插入代码片`
return false;
//如果o为true,那么初始x数量必须和o相同
else if(o3 && x != o)
return false;
else if(x3 && x != o + 1)
return false;
else if(o3 || x3)
return true;
if(res)
return true;
return true;
}
}
所以删去多余的代码
题解多是把循环去掉,因为字符串长度只有3,所以代码看起来会更简洁
class Solution {
public boolean validTicTacToe(String[] board) {
//首先这个题要好好弄懂题意,根据所给的例子,以及自己的测试
//1.刚开始给定的几个字符要满足规则,也就是先放X再放O,第一个放X,如果不满足,直接false
//2.刚开始放置的位置如果连成线了,是不行的,必须是新放置的和原来放置的连线才可以
//3.不是两个人进行博弈,而是尽可能去连成线就行了
//4.如果填满了,那么就是游戏结束,也是true
//看了答案,结合出错的示例,发现,不是开始放置的字符不算,而是如果开始放置的字符已经出现了满足条件的情况
//那么是合理的,但是如果同时O也相连,那么就不可能,比如第三个例子
//所以看刚开始的情况,如果O出现了相连,那么O的数目和X数目相同,并且X不能相连
//如果X出现了相连,那么X的数目要比O多一个
int x = 0;
int o = 0;
for(int i = 0; i < 3; i++){
String s = board[i];
for(int j = 0; j < 3; j++){
if(s.charAt(j) == 'X')
x++;
else if(s.charAt(j) == 'O')
o++;
}
}
//如果刚开始放置的不满足条件,false
if(o > x || x > o + 1)
return false;
boolean x3 = false; //刚开始相连的情况
boolean o3 = false; //刚开始相连的情况
//首先看行
for(int i = 0; i < 3; i++){
String s = board[i];
int tx = 0;
int to = 0;
for(int j = 0; j < 3; j++){
if(s.charAt(j) == 'X')
tx++;
else if(s.charAt(j) == 'O')
to++;
}
if(tx == 3)
x3 = true;
else if(to == 3)
o3 = true;
}
//看列
for(int i = 0; i < 3; i++){
int tx = 0;
int to = 0;
for(int j = 0; j < 3; j++){
String s = board[j];
if(s.charAt(i) == 'X')
tx++;
else if(s.charAt(i) == 'O')
to++;
}
if(tx == 3)
x3 = true;
else if(to == 3)
o3 = true;
}
//正对角线
int tx = 0;
int to = 0;
for(int i = 0; i < 3; i++){
if(board[i].charAt(i) == 'X')
tx++;
else if(board[i].charAt(i) == 'O')
to++;
}
if(tx == 3)
x3 = true;
else if(to == 3)
o3 = true;
//反对角线
tx = 0;
to = 0;
for(int i = 0; i < 3; i++){
if(board[i].charAt(2 - i) == 'X')
tx++;
else if(board[i].charAt(2 - i) == 'O')
to++;
}
if(tx == 3)
x3 = true;
else if(to == 3)
o3 = true;
//如果都为true,不可能
if(x3 && o3)
return false;
//如果o为true,那么初始x数量必须和o相同
else if(o3 && x != o)
return false;
//如果x为true,那么初始o比x少一个
else if(x3 && x != o + 1)
return false;
//剩余情况下,不是填满就是能连成线,所以true
return true;
}
}