4.图
4.1.被围绕的区域
思路：图中只有与边界上联通的O才不算是被X包围。因此本题就是从边界上的O开始递归，找与边界O联通的O，并标记为#（代表已遍历），最后图中剩下的O就是：被X包围的O。图中所有 '#' 则是与边界O联通的情况
class Solution {
public void solve(char[][] board) {
for (int i = 0; i < board.length; i++) {
for (int j = 0; j < board[0].length; j++) {
if (i == 0 || j == 0 || i == board.length - 1 || j == board[0].length - 1) {//如果当前点在边界
if (board[i][j] == 'O') {//当前点在边界，且当前点为O
dfs(board, i, j);
}
}
}
}
for (int i = 0; i < board.length; i++) {
for (int j = 0; j < board[0].length; j++) {
if (board[i][j] == 'O') {//说明当前点是不与边界O联通的O，说明当前O被X包围
board[i][j] = 'X';//赋值为X
}
if (board[i][j] == '#') {//说明当前位置是O，但是是与边界O联通的O
board[i][j] = 'O';//说明当前点不被X包围，重置为O
}
}
}
}
//该方法用于找到所有与边界O联通的O
public void dfs(char[][] board, int i, int j) {
if (i < 0 || i > board.length - 1 || j < 0 || j > board[0].length - 1//如果当前点越界
||
board[i][j] == 'X' || board[i][j] == '#' //或者当前点不为O ！
) return;//直接返回
board[i][j] = '#';//能到这一步说明当前点，是与边界O联通的O，标记为已遍历（防止死循环）
//找与当前位置相邻的、与边界O联通的O
dfs(board, i + 1, j);
dfs(board, i - 1, j);
dfs(board, i, j + 1);
dfs(board, i, j - 1);
}
}5.贪心
5.1项目利润问题
贪心的题目思路不太好写，最主要就是贪心的一种感觉。如果要严格的数学证明，太麻烦了
本题思路：本题就是一个局部最优解到全局最优解的题。每次都在已经解锁 (当前手上有的钱大于某个项目的花费，该项目就算是被解锁)了的项目中选一个利润最大的项目。这样最后得到的就是最大的最终资本。要注意的是，每次做完一次项目，手头上的钱就变为：之前的钱+本次项目的利润。因此，每次做项目之前，都要更新一下被解锁的项目！
代码实现：
class Solution {
public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
int[][] arr = new int[profits.length][2];
//数组第一个元素为当前项目的最小资金，第二个元素为利润
for (int i = 0; i < profits.length; i++) {
arr[i][0] = capital[i];
arr[i][1] = profits[i];
}
//用于存放每个项目花费的小根堆
PriorityQueue<int[]> capitalQ = new PriorityQueue<>(
new Comparator<int[]>() {
@Override
public int compare(int[] arr1, int[] arr2) {
return arr1[0] - arr2[0];
}
});
//存放已经解锁的每个项目的利润的大根堆（每次都要已经解锁了，切利润最大的项目）
PriorityQueue<int[]> profitsQ = new PriorityQueue<>(
new Comparator<int[]>() {
@Override
public int compare(int[] arr1, int[] arr2) {
return arr2[1] - arr1[1];
}
}
);
//全部项目都进入被锁的队列中
for (int i = 0; i < arr.length; i++) {
capitalQ.add(arr[i]);
}
for (int i = 0; i < k; i++) {//进行k轮
//如果资金w大于当前项目的花费且花费队列不为空，该项目被解锁
//这个while循环执行完以后，就会把当前所有能解锁的项目(当前手上的钱w > 项目花费 视为解锁)全部放入利润大根堆。
while (!capitalQ.isEmpty() && capitalQ.peek()[0] <= w) {
profitsQ.add(capitalQ.poll());//该项目被解锁，放入利润大根堆
}
if (profitsQ.isEmpty()) {//当我手上的钱不足以做接下来任何一个项目时，就会出现利润大根堆提前为空的情况
return w;//提前返回现在所有的钱
}
//每次都从利润大根堆找出利润最高的项目
w += profitsQ.poll()[1];
}
return w;
}
}6.递归回溯
6.1N皇后问题
class Solution {
public int totalNQueens(int n) {
if (n < 1) return 0;
//代表：第i行的皇后，放在了第record[i]列
int[] record = new int[n];
return process(0, record, n);
}
/**
* @param i 目前来到了第i行
* @param record 之前已经摆好皇后的位置(潜台词：前面的皇后位置都不冲突！)
* @param n 整体一共有多少行
*/
public int process(int i, int[] record, int n) {
if (i == n) {//递归结束,前n个皇后都已经摆放好了位置
return 1;//前n个皇后都已经摆好了位置，代表找到了一种摆法
}
int res = 0;
for (int j = 0; j < n; j++) {//当前在第i行，遍历第i行的所有列，判断是否合法摆放。j代表列
// 判断当前位置，是否可以摆放皇后
if (isValid(record, i, j)) {
record[i] = j;//当前位置可以摆放皇后
//递归摆放接下来皇后的位置
//当前行，尝试的所有位置做累加，就是当前情况(在record已经摆好的情况下，接下来所有合法情况的总数)
res += process(i + 1, record, n);
}
}
return res;
}
/**
* 判断第i行的第i列，是否可以摆放皇后(是否和之前的皇后位置冲突)
*
* @param record 之前已经摆放好皇后的位置
* @param i 第i行
* @param j 第i列
* @return true：可以摆放到当前位置，不冲突。false：位置冲突
*/
private boolean isValid(int[] record, int i, int j) {
for (int k = 0; k < i; k++) {//只有前k行皇后位置被摆放好，需要比较。遍历之前每个皇后的位置
if (
j == record[k]//如果和之前某个皇后同一列
|| //或者
Math.abs(record[k] - j) == Math.abs(i - k)//当前位置和之前某一个皇后位置在同一列(横坐标之差绝对值=纵坐标之差绝对值)
) {
return false;
}
}
return true;
}
}6.2经典汉诺塔问题
这类问题，只要把握住局部情况，每次的局部情况符合要求，整体情况就不会出错。
比如说：当前A中有i个盘
1.先把上面i-1个盘，从A经过C，移动到B。把第i个盘空出来（因为大盘不能叠在小盘上）。
2.现在第i个盘空出来了，可以直接从A移动到C。
3.最后把上面i-1个盘，从B经过A移动到C。
这样当A中有i个盘的情况就完成了。
如果我每次移动都遵守这个规律，每次要移动大盘的时候，就把上面的小盘全部移都，把大盘空出来，这次移动就保证了大盘一定不会叠着小盘，且大盘在小盘下。整体情况，就一定也会满足这个要求。
这类递归题目不好理解。对于尝试的时候，我们没必要想着全局情况是怎么样变化的。而是应该定义一个统一的标准，每次局部都满足这个情况。整体一定也满足！
总的来说，我们不应该想着全局如何变化。应该想在当前局部情况我们应该怎么样拆解问题，只要局部拆解问题对了，决策对了。整体也就对了。
还有一点要注意的就是，我们拆解问题，拆到最后一定有一个拆不了的情况。比如说本题就是，当A中只有一个盘的情况，就可以直接移动了。这就是递归的终止条件！
public void hanota(List<Integer> A, List<Integer> B, List<Integer> C) {
func(A.size(), A, B, C);
}
/**
* 当前A中有1~i个圆盘，把最下面一个圆盘，从A经过B，移动到C
*
* @param i 圆盘数量
* @param A 移动起始位置
* @param B 经过位置
* @param C 目标位置
*/
public void func(int i, List<Integer> A, List<Integer> B, List<Integer> C) {
if (i == 1) {//当A中只有一个元素了（一定是最小的），直接从A移动到C
C.add(A.remove(1));
}
//先把A上面i - 1个圆盘从A经过C移动到B。
func(A.size() - 1, A, C, B);
//再把第i个圆盘从A移动到C,因为此时i-1个圆盘全部在B，可以直接移动
C.add(A.remove(i));
//再把i - 1个圆盘从B移动回A
func(A.size() - 1, B, C, A);
}6.3.岛屿数量
本题借鉴了leetcode大佬的思路，讲的非常清晰！
. - 力扣（LeetCode）
class Solution {
public int numIslands(char[][] grid) {
int res = 0;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] == '1') {//如果当前位置是一个岛屿
dfs(grid, i, j);
res++;
}
}
}
return res;
}
public void dfs(char[][] grid, int r, int c) {//当前元素在第r行，第c列
if (!inArea(grid, r, c)) return;//如果当前位置越界了，直接返回
if (grid[r][c] != '1') return;//如果当前位置不是岛屿，直接返回
//能走到这，说明当前位置没遍历过，且是岛屿
grid[r][c] = '2';//当前位置标记为已遍历
// 访问上、下、左、右四个相邻结点
dfs(grid, r - 1, c);
dfs(grid, r + 1, c);
dfs(grid, r, c - 1);
dfs(grid, r, c + 1);
}
public boolean inArea(char[][] grid, int r, int c) {//判断当前位置是否越界,true 代表没越界
return r >= 0 && r < grid.length && c >= 0 && c < grid[0].length;
}
}6.4.岛屿最大面积
本题大致思路和上一题差不多。
class Solution {
public int maxAreaOfIsland(int[][] grid) {
int max = 0;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
max = Math.max(max, dfs(grid, i, j));
}
}
return max;
}
public int dfs(int[][] grid, int r, int c) {
if (!inArea(grid, r, c)) return 0;
if (grid[r][c] != 1) return 0;
grid[r][c] = 2; // 标记为已遍历
return 1 + dfs(grid, r, c - 1) +//当前岛屿的面积等于：当前位置就是一个岛屿面积为1 + 上下左右方岛屿面积之和
dfs(grid, r, c + 1) +
dfs(grid, r - 1, c) +
dfs(grid, r + 1, c);
}
public boolean inArea(int[][] grid, int r, int c) {
return r >= 0 && r < grid.length && c >= 0 && c < grid[0].length;
}
}6.5.岛屿周长
本题思路与上面类似，就是注意base case的判断
class Solution {
public int islandPerimeter(int[][] grid) {
int max = 0;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] == 1) return dfs(grid, i, j);
}
}
return 0;
}
public int dfs(int[][] grid, int r, int c) {
// 函数因为「坐标 (r, c) 超出网格范围」返回，对应一条越界的边
if (!inArea(grid, r, c)) {
return 1;
}
// 函数因为「当前格子是海洋格子」返回，对应一条与海洋相邻的边
if (grid[r][c] == 0) {
return 1;
}
// 函数因为「当前格子是已遍历的陆地格子」返回，和周长没关系
if (grid[r][c] != 1) {
return 0;
}
grid[r][c] = 2;
return dfs(grid, r, c - 1) +//当前岛屿的周长等于：上下左右方岛屿面积之和
dfs(grid, r, c + 1) +
dfs(grid, r - 1, c) +
dfs(grid, r + 1, c);
}
public boolean inArea(int[][] grid, int r, int c) {
return r >= 0 && r < grid.length && c >= 0 && c < grid[0].length;
}
}6.6.预测赢家(博弈)
public boolean predictTheWinner(int[] nums) {
// 返回我先手能获取的最大值，和后手获取的最大值
return a(nums, 0, nums.length - 1) >= b(nums, 0, nums.length - 1);
}
//来到当前位置，还剩第l个元素到第r个元素没有选，我先选
public int a(int[] arr, int l, int r) {
if (l == r) {//如果只剩一个元素了，还是我先选
return arr[l];
}
return Math.max(
arr[l] + b(arr, l + 1, r),//选了第l个元素，那么接下来我就是后手了
arr[r] + b(arr, l, r - 1)//选了第r个元素，接下来我也是后手 且选择元素范围也改变了
);
}
//来到当前位置，还剩第l个元素到第r个元素没有选，我后手
//注意：当前不是我拿，是对方先手在l到r范围上拿
public int b(int[] arr, int l, int r) {
if (l == r) {//当前最后只有最后一个元素，我还是后手，肯定就被对手选了
return 0;//返回0，没有元素选了
}
//注意：这里可能不好理解为什么是min
//这两种情况是：对手做完，我是后手情况，被迫接受的!所以就是最差情况min
//因为这是二人博弈，对手先手选的是最大的值，轮到后手的我，选的只会是最小的值。
//对手选的分多，我的分就少了。下回合轮到我先手也是同理，对手分就少了
return Math.min(//注意当前是我在等待对方先手在l到r范围上拿，我没得拿！
a(arr, l + 1, r),
a(arr, l, r - 1)
);
}7.动态规划
7.1.买卖股票的最佳时期1
思路：动态规划问题，最重要的就是找到问题的状态。把问题状态不重不漏的划分出来。对于本题：每日的股票持有最大价值可以分为两种情况。
1.第i天我手上有股票的最大价值：两种情况，1.和我昨天有股票的情况一样。2.昨天没有股票，买当天的股票。
2.第i天我手上没有股票的最大价值：两种情况，1.和我昨天没有股票的情况一样。2.昨天有股票，当天卖了股票。
要注意的是：这里只能买一次股票。注意和下一题比较区分。
class Solution {
public int maxProfit(int[] prices) {
//dp[i][0]:代表第i天有股票（之前就有股票/当天买入）的最大利润
//dp[i][1]:代表第i天没有股票（之前没有/当天卖了）的最大利润
int[][] dp = new int[prices.length][2];
dp[0][0] = -prices[0];
dp[0][1] = 0;
for(int i = 1; i < prices.length; i++){
//dp[i][0]:代表第i天有股票（之前就有股票/当天买入）的最大利润 = 前一天的股票价值/前天没有，当天买入的最大值
dp[i][0] = Math.max(dp[i-1][0],-prices[i]);
dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]+prices[i]);
}
return Math.max(dp[prices.length-1][0],dp[prices.length-1][1]);
}
}7.2.买卖股票的最佳时期2
大致思路和上一题差不多，但要区分这里可以进行多次股票买卖。
注意：这里的：dp[i-1][1]-prices[i] 就包含了多次买卖股票的情况。
class Solution {
public int maxProfit(int[] prices) {
//dp[i][0]:代表第i天有股票（之前就有股票/当天买入）的最大利润
//dp[i][1]:代表第i天没有股票（之前没有/当天卖了）的最大利润
int[][] dp = new int[prices.length][2];
dp[0][0] = -prices[0];
dp[0][1] = 0;
for(int i = 1; i < prices.length; i++){
//dp[i][0]:代表第i天有股票（之前就有股票/当天买入）的最大利润 = 前一天的股票价值/前天没有，当天买入的最大值
dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]-prices[i]);
dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]+prices[i]);
}
return Math.max(dp[prices.length-1][0],dp[prices.length-1][1]);
}
}7.3.买卖股票的最佳时期3
class Solution {
public int maxProfit(int[] prices) {
// dp[i][0]: 第一次有股票 = Math.max(前天就有，买今天的) 注意买第i天股票就是 -prices[i]
// dp[i][1]: 第一次卖完股票，不持有股票 = Math.max(前天没有，今天还有，当天卖)
// dp[i][2]: 第二次有股票 = Math.max(前天就有，在第一次买卖完没有股票的基础上，买入今天股票)
// dp[i][3]: 第二次卖完股票，不持有 = Math.max(前天就没有，今天是第二次有股票，当天卖)
int[][] dp = new int[prices.length][4];
dp[0][0] = -prices[0];
dp[0][1] = 0;
dp[0][2] = -prices[0];
dp[0][3] = 0;
for (int i = 1; i < prices.length; i++) {
dp[i][0] = Math.max(dp[i - 1][0], -prices[i]);
dp[i][1] = Math.max(dp[i - 1][1], dp[i][0] + prices[i]);
dp[i][2] = Math.max(dp[i - 1][2], dp[i][1] - prices[i]);
dp[i][3] = Math.max(dp[i - 1][3], dp[i][2] + prices[i]);
}
return dp[prices.length - 1][3];
}
}7.4.买卖股票的最佳时期4
7.5.买卖股票的最佳时期(含手续费)
7.6.买卖股票的最佳时期(含冷冻期)
7.7.打家劫舍
class Solution {
public int rob(int[] nums) {
if(nums.length == 1) return nums[0];
if(nums.length < 3) return Math.max(nums[0],nums[1]);
int[][] dp = new int[nums.length + 1][2];
dp[1][0] = nums[0];
dp[1][1] = 0;
dp[2][0] = nums[1];
dp[2][1] = nums[0];
for(int i = 3; i <= nums.length; i++){
//抢第i家能获取的最大金额
dp[i][0] = Math.max(dp[i - 2][0],dp[i -1][1]) + nums[i -1];
//不抢第i家
dp[i][1] = Math.max(dp[i - 1][0],dp[i - 1][1]);
}
return Math.max(dp[nums.length][0],dp[nums.length][1]);
}
}7.7.打家劫舍III (树形dp)
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int rob(TreeNode root) {
int[] process = process(root);
return Math.max(process[0],process[1]);
}
//返回数组有两个元素，第一个元素代表偷当前节点的最大值，第二个元素为不偷当前节点的最大值
public int[] process(TreeNode root) {
if (root == null) return new int[]{0, 0};
if (root.left == null && root.right == null) return new int[]{root.val, 0};
int[] left = process(root.left);
int[] right = process(root.right);
//偷当前节点最大值 = 当前节点的值 + 不偷左右孩子
int max1 = root.val + left[1] + right[1];
//不偷当前节点 = 偷/不偷左孩子价值更大的一个 + 偷/不偷右孩子价值更大的一个
int max2 = Math.max(left[1], left[0]) + Math.max(right[0], right[1]);
return new int[]{max1, max2};
}
}7.8.单词拆分
class Solution {
public boolean wordBreak(String s, List<String> wordDict) {
//把wordDict中的元素放到set集合中，方便后续判断有没有某个单词
Set<String> set = new HashSet<String>(wordDict);
//dp数组，dp[i] 代表字符串0到i，在不在set中，能不能被字典中的单词表示
boolean[] dp = new boolean[s.length() + 1];
dp[0] = true;
for(int i = 1; i <= s.length(); i++){//遍历字符串s
for(int j = 0; j < i; j++){//判断从字符串0到i的长度，能不能被字典中的单词表示
if(dp[j] && set.contains(s.substring(j, i))){//如果0到j能被表示，且j到i能被表示 (在字典中)
dp[i] = true;//则0到i也能被表示
break;
}
}
}
return dp[s.length()];
}
}7.9.零钱兑换(完全背包问题)
class Solution {
public int coinChange(int[] coins, int amount) {
// dp[i] 就代表凑齐 i 元所需要的硬币数量
int[] dp = new int[amount + 1];
Arrays.fill(dp, amount + 1);
dp[0] = 0;
for (int i = 1; i <= amount; i++) {
for (int j = 0; j < coins.length; j++) {
if (i >= coins[j]) {
//当前遍历到第j个硬币，一共凑齐了i元
//凑齐这i元最小硬币数：dp[i] 没有用当前硬币
//用了当前硬币才凑齐的i元所用的硬币数：dp[i - coins[j]] + 1(当前硬币的数量)
dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
}
}
}
return dp[amount] == amount + 1 ? -1 : dp[amount];
}
}7.10.骑士在棋盘上的概率(三维dp)
左神第p18大概一小时左右讲了类似题目
class Solution {
//用来代表每一对骑士的走法
int[][] dirs = new int[][]{{-1,-2},{-1,2},{1,-2},{1,2},{-2,1},{-2,-1},{2,1},{2,-1}};
public double knightProbability(int n, int k, int row, int column) {
//一个三维dp数组，z方向代表剩余步数
//x，y方向用来决定当前骑士的位置
//如果dp[][][] = 1 代表骑士在棋盘里的概率
double[][][] dp = new double[n][n][k + 1];
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
dp[i][j][0] = 1;//剩余步数为0，棋盘中的每一个点都代表在棋盘里
}
}
//每一层(z轴)都依赖于下一层的走法
for(int h = 1; h <= k; h++){
//遍历当前层的每一个点
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
for(int[] d : dirs){
//走完以后的位置
int nx = i + d[0], ny = j + d[1];
//如果越界了，就不进入概率计算
if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
//如果当前位置在棋盘里
dp[i][j][h] += dp[nx][ny][h - 1] / 8;
}
}
}
}
// 本题求从最下面一层的起始 x = row y = column 到达最上面一层合法区域的概率
// 和，求从最上面的 x = row y = column 出发，达到最下面一层的合法区域的概率 是相同的！
// 因此返回值为从最下面合法区域的任何一个点开始，到达最顶上 x = row y = column 的概率
return dp[row][column][k];
}
}8.滑动窗口和单调栈
1.滑动窗口最大值
注意：每次从队尾添加一个数进队列，一定要跟在比它大的元素后面。如果队尾元素不满足比当前添加元素大，就一直弹出。直到满足队尾元素比它大，或者队列弹空了。
原理：窗口中维持的信息是：有可能成为最大值的下标。每次添加一个值，已经在队列中且比当前元素小的元素就再也不可能成为最大值了。因为，那些数比当前元素小，且当前元素比它们更晚被淘汰 (更晚出队列，因为从左往右遍历的，如果窗口左边界也移动，当前元素一定比那些元素更晚淘汰！)
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
if (nums.length < k) {
int max = Integer.MIN_VALUE;
for (int num : nums) {
max = Math.max(num, max);
}
return new int[]{max};
}
int l = -1;//窗口左边界
int r = -1;//窗口右边界
int index = 0;
//存放答案的数组
int[] res = new int[nums.length - k + 1];
//双端队列，规则：队头元素始终是最大元素，队头到队尾由小到大
LinkedList<Integer> maxQ = new LinkedList<>();
while (++r < nums.length) {//当窗口还没遍历结束
//如果队尾还有元素，且队尾元素比当前元素小
while (!maxQ.isEmpty() && nums[maxQ.peekLast()] <= nums[r]) {
maxQ.pollLast();
}
//到了这里说明队列为空或者队尾元素比当前元素大
//当前元素入队尾
maxQ.addLast(r);
if (maxQ.peekFirst() == l) {//如果当前队头元素过期，出队
maxQ.pollFirst();
}
if (r - l == k) {
l++;
res[index++] = nums[maxQ.peekFirst()];
}
}
return res;
}
}2.每日温度
思路：维护一个由小到大的单调栈，栈顶元素最小。每次从栈顶加入一个数都要进行一次判断：
如果：加入的元素 <= 栈顶元素 满足单调性，直接入栈。
加入的元素 > 栈顶元素 栈顶元素弹出，一直弹到栈为空或者加入元素小于等于栈顶元素。
每次从栈顶弹出一次元素，对该元素进行计算。当前加入的元素，就是比栈顶弹出的元素大且离它最近的元素。
class Solution {
public int[] dailyTemperatures(int[] temperatures) {
//单调栈
LinkedList<Integer> stack = new LinkedList<>();
//用于保存结果，res[i] 就代表比temperatures[i] 大的右边最近一个元素距离i的位置
int[] res = new int[temperatures.length];
for (int i = 0; i < temperatures.length; i++) {
//当栈为空，或者栈顶元素比当前元素大
while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
Integer pop = stack.pop();
res[pop] = i - pop;
}
//能到这一步说明，栈为空/栈顶元素大于等于当前元素
stack.push(i);
}
return res;
}
}3.接雨水
思路：与上题略有不同的就是，本题还要找遍历当前值左侧最近且比当前值大的元素。就是栈中每个值下面一个元素。
class Solution {
public int trap(int[] height) {
int res = 0;
LinkedList<Integer> stack = new LinkedList<>();
for (int i = 0; i < height.length; i++) {
while (!stack.isEmpty() && height[i] > height[stack.peek()]) {
int pop = stack.pop();
Integer peek = stack.peek();
if (peek != null) {//peek == null 说明当前出栈的栈顶元素左边没有比它大的数
// 出栈元素pop对应雨水面积的高为 左右两个中较小的那个 - pop元素的高
int h = Math.min(height[i], height[peek]) - height[pop];
res += h * (i - peek - 1);
}
}
stack.push(i);
}
return res;
}
}4.长度最小子序列(滑动窗口)
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int res = Integer.MAX_VALUE;
int l = 0;//代表滑动窗口左边界
int r = 0;//代表滑动窗口右边界
int cnt = 0;//用于计算窗口中元素的和
while (r < nums.length) {
while (r < nums.length) {//不断右移r往窗口中加元素
cnt += nums[r];
if (cnt >= target) break;
r++;
}
while (l < r) {//不断缩小窗口
if (cnt - nums[l] >= target) {
cnt -= nums[l];
l++;
} else {
break;
}
}
//到了这一步，要不就是窗口中元素大于等于target，要不就是r遍历完
res = Math.min(res, r - l + 1);
r++;
}
return cnt >= target ? res : 0;
}
}
