LeetCode 1034. 边界着色 / 689. 三个无重叠子数组的最大和（三个区间的滑动窗口，带回溯求具体值的动规） / 794. 有效的井字游戏
Posted Zephyr丶J
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了LeetCode 1034. 边界着色 / 689. 三个无重叠子数组的最大和（三个区间的滑动窗口，带回溯求具体值的动规） / 794. 有效的井字游戏相关的知识，希望对你有一定的参考价值。
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.刚开始给定的几个字符要满以上是关于LeetCode 1034. 边界着色 / 689. 三个无重叠子数组的最大和（三个区间的滑动窗口，带回溯求具体值的动规） / 794. 有效的井字游戏的主要内容，如果未能解决你的问题，请参考以下文章
[Leetcode]689.Maximum Sum of 3 Non-Overlapping Subarrays