算法刷题记录2

 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)
        );
    }

6.7.数组总和

    public List<List<Integer>> res;
    public int target;

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        this.target = target;
        res = new ArrayList<>();
        dfs(candidates, 0, new ArrayList<>(), 0);
        return res;
    }

    public void dfs(int[] candidates, int cur, List<Integer> list, int sum) {
        if (sum >= target) {
            if (sum == target) {
                //注意这里必须用copyOf复制一个相同的list对象,不然后面回溯的时候,会把list对象里面的值清空
                res.add(List.copyOf(list));
            }
            return;
        }
        //当前list集合中的元素和sum 小于 target,还可以继续加元素
        for (int i = cur; i < candidates.length; i++) {
            list.add(candidates[i]);
            sum += candidates[i];
            dfs(candidates, i, list, sum);
            //回溯
            list.remove(list.size() - 1);
            sum -= candidates[i];
        }
    }

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;
    }
}

  • 29
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值