观后笔记
以下是读三叶大佬文章的笔记。
题目:
1004. 最大连续1的个数 III
难度中等
给定一个由若干 0 和 1 组成的数组 A，我们最多可以将 K 个值从 0 变成 1 。
返回仅包含 1 的最长（连续）子数组的长度。
示例 1：
输入：A = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出：6
解释：
[1,1,1,0,0,1,1,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 6。
示例 2：
输入：A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
输出：10
解释：
[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 10。
提示：
1 <= A.length <= 200000 <= K <= A.lengthA[i]为0或1
题目是给一个数组，全是1和0，要求给出不超过K次将0变成1的最长连续1数组。
这题目也可以解读为：给一个全是0和1的数组，求出不超过K个0的最长连续子序列的长度。
这里一开始的动态规划那里i & 1我看不懂，还有那个三元运算符也有点晕：dp[i][j]表示[i,j]最长的包含不超过K个0的连续1序列。
class Solution {
public int longestOnes(int[] nums, int k) {
int n = nums.length;
//
int[][] f = new int[2][k + 1];
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= k; j++) {
if (nums[i - 1] == 1) {
f[i & 1][j] = f[(i - 1) & 1][j] + 1;
} else {
f[i & 1][j] = j == 0 ? 0 : f[(i - 1) & 1][j - 1] + 1;
}
ans = Math.max(ans, f[i & 1][j]);
}
}
return ans;
}
}
问了别人，说是i & 1可以判断奇偶，
这样相当于数组永远只储存当前和上一个的状态 节省空间
啊，，好吧。不过还是TLE超时了。
双指针是真的妙~利用右指针判断当前维护区间（左右指针）的0是否超出K个（长度-1的个数> k，1的个数就是区间和），一旦超出就左指针移，否则到达nums.length之前都是右指针移。
class Solution {
public int longestOnes(int[] nums, int k) {
//双指针，当指针区间包含不超过K个0时，右指针右移；当指针区间包含的0超过K时，左指针右移。这期间记录指针区间最大程度即为答案。
//简称：在作死边缘疯狂试探
//区间0不超过K个：right-left+1 - tot <= k 。tot是区间和，因为数组只有0和1，tot就是区间1的个数。
int max = 0;
int len = nums.length;
int tot = 0;
int right = 0,left = 0;
while(right < len){
tot+=nums[right];
if(right-left+1-tot <= k){
right++;
}
else{
tot -= nums[left];
left++;
}
max = max > right-left+1 ? max : right-left+1;
// System.out.println(max);
}
return max-1; //这里的-1我有点困惑，但是不减的话又过不去。。。
}
}
- 二分的运用：
题目：
778. 水位上升的泳池中游泳
难度困难
在一个 N x N 的坐标方格 grid 中，每一个方格的值 grid[i][j] 表示在位置 (i,j) 的平台高度。
现在开始下雨了。当时间为 t 时，此时雨水导致水池中任意位置的水位为 t 。你可以从一个平台游向四周相邻的任意一个平台，但是前提是此时水位必须同时淹没这两个平台。假定你可以瞬间移动无限距离，也就是默认在方格内部游动是不耗时的。当然，在你游泳的时候你必须待在坐标方格里面。
你从坐标方格的左上平台 (0，0) 出发。最少耗时多久你才能到达坐标方格的右下平台 (N-1, N-1)？
示例 1:
输入: [[0,2],[1,3]]
输出: 3
解释:
时间为0时，你位于坐标方格的位置为 (0, 0)。
此时你不能游向任意方向，因为四个相邻方向平台的高度都大于当前时间为 0 时的水位。
等时间到达 3 时，你才可以游向平台 (1, 1). 因为此时的水位是 3，坐标方格中的平台没有比水位 3 更高的，所以你可以游向坐标方格中的任意位置
示例2:
输入: [[0,1,2,3,4],[24,23,22,21,5],[12,13,14,15,16],[11,17,18,19,20],[10,9,8,7,6]]
输出: 16
解释:
0 1 2 3 4
24 23 22 21 5
12 13 14 15 16
11 17 18 19 20
10 9 8 7 6
最终的路线用加粗进行了标记。
我们必须等到时间为 16，此时才能保证平台 (0, 0) 和 (4, 4) 是连通的
提示:
2 <= N <= 50.grid[i][j]是[0, ..., N*N - 1]的排列。
这道困难题用二分竟然如此明了，只要题目给出了数据范围，就可以根据范围进行二分，然后思索如何写check函数（确定是不是那个分界点，也就是mid）即可。
check就是检查是否能在给定的mid时间内到达右下角那个终点。
这道题最困惑我的就是那个time，题解里直接“定格时间”，从初始状态开始判断<=time就为合法可移动位置。
check函数的方法是dfs，利用队列记录四个方位的值，然后对队列这些元素一个一个进行dfs。
class Solution {
int[][] dirs = new int[][]{{0,1},{0,-1},{1,0},{-1,0}};
public int swimInWater(int[][] grid) {
int n = grid.length;
int left = 0,right = n*n;
while(left < right){
int medium = (left+right)/2;
if(check(grid,medium)){
right = medium;
}
else{
left = medium+1;
}
}
return right;
}
//检查是否能在规定时间/步数内从左上角到达右下角
boolean check(int[][] grid,int time){
int n = grid.length;
Deque<int[]> queue = new ArrayDeque<>();//存储这次和下次坐标,同一个时刻队伍里只会存一个，而int[]表示坐标就只需要2个位子
boolean[][] visited = new boolean[n][n];//不能原路返回（这跟只能往下往右走没关系）
queue.push(new int[]{0,0});
visited[0][0] = true;
while(!queue.isEmpty()){
int[] from = queue.poll();
int x = from[0],y = from[1];
if(x==n-1 && y==n-1) return true;
for(int i = 0;i < 4;i++){
int newX = x + dirs[i][0],newY = y + dirs[i][1];
int[] to = new int[]{newX,newY};
if(inArea(n,newX,newY) && visited[newX][newY] == false && canMove(grid,from,to,time)){
queue.push(to);
visited[newX][newY] = true;
}
}
}
return false;
}
//判断x,y是否合法
boolean inArea(int n,int x,int y){
return x >= 0 && y >= 0 && x < n && y < n;
}
//判断所给时间是否足够
boolean canMove(int[][] grid,int[] from,int[] to,int time){
return time >= Math.max(grid[from[0]][from[1]],grid[to[0]][to[1]]);
}
}
这题还有并查集的做法，但是三叶的文章需要先看另一篇专门讲并查集的文章：
- 并查集：
【综合笔试题】难度 3/5，为啥是图论不是 DP，两者是什么关系？
题目：
浙公网安备 33010602011771号