1. Toy模板网首页
  2. > Toy博客

【滑动窗口、矩阵】算法例题

7月前 作者：玖柒_lin 分类：Toy博客 阅读(65) 违法举报

这篇具有很好参考价值的文章主要介绍了【滑动窗口、矩阵】算法例题。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

 三、滑动窗口

30. 长度最小的子数组 ②

31. 无重复字符的最长子串 ②

32. 串联所有单词的子串 ③

33. 最小覆盖子串 ③

四、矩阵

34. 有效的数独 ②

35. 螺旋矩阵 ②

36. 旋转图像 ②

37. 矩阵置零 ②

38. 生命游戏 ②

 三、滑动窗口

30. 长度最小的子数组 ②

 给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3]
 是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

提示：

  • 1 <= target <= 109
  • 1 <= nums.length <= 105
  • 1 <= nums[i] <= 105

力扣题解：. - 力扣（LeetCode）

方法1：时间超时（通过15/18）

    public int minSubArrayLen(int target, int[] nums) {
        int min = nums.length + 1;
        for (int i = 0; i < nums.length; i++) {
            int sum = 0;
            int left = i;
            sum += nums[left];
            int right = i + 1;
            while (right < nums.length && sum < target){
                sum += nums[right];
                right++;
            }
            if (sum >= target && min > right - left){
                min = right - left;
            }
        }
        return min == nums.length + 1? 0 : min;
    }

方法2：(0ms)

    public int minSubArrayLen(int target, int[] nums) {
        int l = 0, r = 0;
        int n = nums.length;
        int sum = 0;

        while(r < n && sum < target)
            sum += nums[r++];

        if(r == n)
            if (sum < target)
                return 0;
            else{
                while(sum > target)
                    sum -= nums[l++];
            }

        while(r < n){
            if(sum < target) sum += nums[r++];
            sum -= nums[l++];
        }
        if(sum < target) return r-l+1;
        return r -l;
    }

方法3：

    public int minSubArrayLen(int target, int[] nums) {
        int lo = 0, hi = 0, sum = 0, min = Integer.MAX_VALUE;
        while (hi < nums.length) {
            sum += nums[hi++];
            while (sum >= target) {
                min = Math.min(min, hi - lo);
                sum -= nums[lo++];
            }
        }
        return min == Integer.MAX_VALUE ? 0 : min;
    }

 方法4：（2ms）

    public int minSubArrayLen(int target, int[] nums) {
         int left = 0;
        int res = Integer.MAX_VALUE;
        int add = 0;
         for (int right = 0; right < nums.length; right++) {
            add += nums[right];
            while (add >= target) {
                res = Math.min(res, right - left + 1);
                add -= nums[left];
                ++left;
            }
        }
        return res > nums.length ? 0 : res;
    }

31. 无重复字符的最长子串 ②

 给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

提示：

  • 0 <= s.length <= 5 * 104
  • s 由英文字母、数字、符号和空格组成

方法1：（7ms）

    public static int lengthOfLongestSubstring(String s) {
        TreeSet<Integer> set = new TreeSet<>();
        if (s.length() == 0){
            return 0;
        }else if (s.length() == 1){
            return 1;
        }else {
            int left = 0;
            int right = 1;
            while (right < s.length()){
                String substring = s.substring(left, right);
                if (substring.contains(s.charAt(right) + "")){
                    set.add(right - left);
                    left = s.indexOf(s.charAt(right), left) + 1;
                }else {
                    if (right == s.length() - 1) {
                        set.add(right - left + 1);
                        break;
                    }
                }
                right++;
            }
            return set.last();
        }
    }

方法2：（滑动窗口  5ms）

    public int lengthOfLongestSubstring(String s) {
        if (s.length()==0) return 0;
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        int max = 0;
        int left = 0;
        for(int i = 0; i < s.length(); i ++){
            if(map.containsKey(s.charAt(i))){
                left = Math.max(left,map.get(s.charAt(i)) + 1);
            }
            map.put(s.charAt(i),i);
            max = Math.max(max,i-left+1);
        }
        return max;
        
    }

作者：powcai
链接：https://leetcode.cn/problems/longest-substring-without-repeating-characters/solutions/3982/hua-dong-chuang-kou-by-powcai/

32. 串联所有单词的子串 ③

33. 最小覆盖子串 ③

四、矩阵

34. 有效的数独 ②

 请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。

  1. 数字 1-9 在每一行只能出现一次。
  2. 数字 1-9 在每一列只能出现一次。
  3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

注意：

  • 一个有效的数独（部分已被填充）不一定是可解的。
  • 只需要根据以上规则，验证已经填入的数字是否有效即可。
  • 空白格用 '.' 表示。

示例 1：

矩阵滑动窗口,算法,矩阵,leetcode

输入：board = 
[["5","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
输出：true

示例 2：

输入：board = 
[["8","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
输出：false
解释：除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。

提示：

  • board.length == 9
  • board[i].length == 9
  • board[i][j] 是一位数字（1-9）或者 '.'

方法1：

矩阵滑动窗口,算法,矩阵,leetcode

    public static boolean isValidSudoku(char[][] board) {
        String[] rows = new String[9];
        String[] columns = new String[9];
        String[] areas = new String[9];
        for (int i = 0; i < 9; i++) {
            if (rows[i] == null){
                rows[i] = "a";
            }

            for (int j = 0; j < 9; j++) {
                if (columns[j] == null){
                    columns[j] = "a";
                }
                if (rows[i].contains(board[i][j] + "")){
                    return false;
                }else if (board[i][j] != '.' && !rows[i].contains(board[i][j] + "")){
                    rows[i] += board[i][j];
                }
                if (columns[j].contains(board[i][j] + "")){
                    return false;
                }else if (board[i][j] != '.' && !columns[j].contains(board[i][j] + "")){
                    columns[j] += board[i][j];
                }
                int row = i / 3; // 0 1 2
                int column = j / 3; //0 1 2
                int area = row * 3 + column;
                if (areas[area] == null){
                    areas[area] = "a";
                }
                if (areas[area].contains(board[i][j] + "")){
                    return false;
                }else  if (board[i][j] != '.' && !areas[area].contains(board[i][j] + "")){
                    areas[area] += board[i][j];
                }
            }
        }
        return true;
    }

方法2：（0ms）

    public boolean isValidSudoku(char[][] board) {
        short[] rows = new short[9];
        short[] cols = new short[9];
        short[] squares = new short[9];
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (board[i][j] != '.') {
                    short value = (short)(1 << (board[i][j] - '0'));
                    int boxNum = i / 3 * 3 + j / 3;
                    if ((rows[i] & value) != 0 || (cols[j] & value) != 0 || (squares[boxNum] & value) != 0) {
                        return false;
                    }
                    rows[i] |= value;
                    cols[j] |= value;
                    squares[boxNum] |= value;
                }
            }
        }
        return true;
    }

方法3：（1ms）

    public boolean isValidSudoku(char[][] board) {
        int[] rows = new int[9];
        int[] cols = new int[9];
        int[] subboxes = new int[9];
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                char c = board[i][j];
                if (c != '.') {
                    int x = (1 << (c - '1'));
                    if ((rows[i] & x) != 0) {
                        return false;
                    } else {
                        rows[i] |= x;
                    }
                    if ((cols[j] & x) != 0) {
                        return false;
                    } else {
                        cols[j] |= x;
                    }
                    if ((subboxes[i / 3 * 3 + j / 3] & x) != 0) {
                        return false;
                    } else {
                        subboxes[i / 3 * 3 + j / 3] |= x;
                    }
                }
            }
        }
        return true;
    }

方法4：（2ms）

    public boolean isValidSudoku(char[][] board) {            
        int[][] row = new int[9][9]; // 行
        int[][] columns = new int[9][9]; // 列
        int[][][] a = new int[3][3][9];
        for (int i = 0; i < 9; i++) {
            Set<Character> set = new HashSet<>();
            for (int j = 0; j < 9; j++) {
                char c = board[i][j];
                if (c != '.') {
                    row[i][c - 49]++;
                    columns[j][c - 49]++;
                    a[i / 3][j / 3][c - 49]++;
                    if (row[i][c - 49] > 1 || columns[j][c - 49] > 1 || a[i / 3][j / 3][c - 49] > 1) {
                        return false;
                    }
                }

            }
        }
        return true;
    }

35. 螺旋矩阵 ②

 给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

示例 1：

矩阵滑动窗口,算法,矩阵,leetcode

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

示例 2：

矩阵滑动窗口,算法,矩阵,leetcode

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

提示：

  • m == matrix.length
  • n == matrix[i].length
  • 1 <= m, n <= 10
  • -100 <= matrix[i][j] <= 100

方法1：（0ms）

    public static List<Integer> spiralOrder(int[][] matrix) {
        int[][] path = new int[matrix.length][matrix[0].length];
        int step = 0;
        ArrayList<Integer> list = new ArrayList<>();
        int row = 0;
        int col = 0;
        int direct = 0;
        while (step < matrix.length * matrix[0].length){
            list.add(matrix[row][col]);
            path[row][col] = 1;
            if (direct == 0){
                col++;
                if (col == matrix[0].length || path[row][col] == 1){
                    direct = 1;
                    col--;
                    row++;
                }
            }else if (direct == 1){
                row++;
                if (row == matrix.length || path[row][col] == 1){
                    direct = 2;
                    row--;
                    col--;
                }
            }else if (direct == 2){
                col--;
                if (col == -1 || path[row][col] == 1){
                    direct = 3;
                    col++;
                    row--;
                }
            }else {
                row--;
                if (row == 0 || path[row][col] == 1){
                    direct = 0;
                    row++;
                    col++;
                }
            }
            step++;
        }
        return list;
    }

方法2：（0ms）

   public List<Integer> spiralOrder(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        List<Integer> res = new ArrayList<>();
        int u = 0, d = m - 1, l = 0, r = n - 1;
        while (true) {
            for (int i = l; i <= r; i ++) res.add(matrix[u][i]);
            if (++u > d) break;
            for (int i = u; i <= d; i ++) res.add(matrix[i][r]);
            if (--r < l) break;
            for (int i = r; i >= l; i --) res.add(matrix[d][i]);
            if (--d < u) break;
            for (int i = d; i  >= u; i --) res.add(matrix[i][l]);
            if (++l > r) break;
        }
        return res; 
    }

36. 旋转图像 ②

 给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

示例 1：

矩阵滑动窗口,算法,矩阵,leetcode

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]

示例 2：

矩阵滑动窗口,算法,矩阵,leetcode

输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]

提示：

  • n == matrix.length == matrix[i].length
  • 1 <= n <= 20
  • -1000 <= matrix[i][j] <= 1000

方法1：（0ms）

    public static void rotate(int[][] matrix) {
        int n = matrix.length;
        int row = 0;
        int col = n - 1;
        int index = 0;
        while (row < col){
            while (row + index < col) {
                int leftUp = matrix[row][row + index];
                int rightUp = matrix[row + index][col];
                int rightDown = matrix[col][col - index];
                int leftDown = matrix[col - index][row];
                matrix[row][row + index] = leftDown;
                matrix[row + index][col] = leftUp;
                matrix[col][col - index] = rightUp;
                matrix[col - index][row] = rightDown;
                index++;
            }
            index = 0;
            row++;
            col--;
        }

    }

37. 矩阵置零 ②

 给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。

示例 1：

矩阵滑动窗口,算法,矩阵,leetcode

输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]
输出：[[1,0,1],[0,0,0],[1,0,1]]

示例 2：

矩阵滑动窗口,算法,矩阵,leetcode

输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]

提示：

  • m == matrix.length
  • n == matrix[0].length
  • 1 <= m, n <= 200
  • -231 <= matrix[i][j] <= 231 - 1

进阶：

  • 一个直观的解决方案是使用  O(mn) 的额外空间，但这并不是一个好的解决方案。
  • 一个简单的改进方案是使用 O(m + n) 的额外空间，但这仍然不是最好的解决方案。
  • 你能想出一个仅使用常量空间的解决方案吗？

方法1：

矩阵滑动窗口,算法,矩阵,leetcode

    public void setZeroes(int[][] matrix) {
        TreeSet<Integer> rowSet = new TreeSet<>();
        TreeSet<Integer> columnSet = new TreeSet<>();
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                if (matrix[i][j] == 0){
                    rowSet.add(i);
                    columnSet.add(j);
                }
            }
        }
        for (int i = 0; i < matrix.length; i++) {
            if (rowSet.contains(i)){
                Arrays.fill(matrix[i], 0);
            }
        }
        for (int i = 0; i < matrix[0].length; i++) {
            if (columnSet.contains(i)){
                for (int j = 0; j < matrix.length; j++) {
                    matrix[j][i] = 0;
                }
            }
        }
    }

方法2：

    public void setZeroes(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        // 统计行列是否需要置为0 空间复杂度 O(m+n)
        boolean[] zeroRow = new boolean[m];
        boolean[] zeroCol = new boolean[n];
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(matrix[i][j] == 0){
                    zeroRow[i] = true;
                    zeroCol[j] = true;
                }
            }
        }

        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(zeroRow[i] || zeroCol[j]) {
                    matrix[i][j] = 0;
                }
            }
        }
    }

38. 生命游戏 ②

 根据 百度百科 ， 生命游戏 ，简称为 生命 ，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。

给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态： 1 即为 活细胞 （live），或 0 即为 死细胞 （dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律：

  1. 如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
  2. 如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
  3. 如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
  4. 如果死细胞周围正好有三个活细胞，则该位置死细胞复活；

下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。给你 m x n 网格面板 board 的当前状态，返回下一个状态。

示例 1：

矩阵滑动窗口,算法,矩阵,leetcode

输入：board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]
输出：[[0,0,0],[1,0,1],[0,1,1],[0,1,0]]

示例 2：

矩阵滑动窗口,算法,矩阵,leetcode

输入：board = [[1,1],[1,0]]
输出：[[1,1],[1,1]]

提示：

  • m == board.length
  • n == board[i].length
  • 1 <= m, n <= 25
  • board[i][j] 为 0 或 1

进阶：

  • 你可以使用原地算法解决本题吗？请注意，面板上所有格子需要同时被更新：你不能先更新某些格子，然后使用它们的更新后的值再更新其他格子。
  • 本题中，我们使用二维数组来表示面板。原则上，面板是无限的，但当活细胞侵占了面板边界时会造成问题。你将如何解决这些问题？

方法1：（0ms）文章来源地址https://www.toymoban.com/news/detail-851160.html

    public static void gameOfLife(int[][] board) {
        int[][] map = new int[board.length][board[0].length];
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                int row = Math.max(i - 1, 0);
                int col = Math.max(j - 1, 0);
                int src = board[i][j];
                int count = 0;
                while (row < board.length && col < board[0].length){
                    count += board[row][col];
                    col++;
                    if (col == j + 2 || col == board[0].length){
                        row++;
                        col = Math.max(j - 1, 0);
                    }
                    if (row == i + 2 || row == board.length){
                        break;
                    }
                }
                count -= src;
                if (src == 1 && count == 1) {
                    map[i][j] = 0;
                }else if (src == 1 && (count == 2 || count == 3)){
                    map[i][j] = 1;
                }else if (src == 1 && count > 3){
                    map[i][j] = 0;
                }else if (src == 0 && count == 3){
                    map[i][j] = 1;
                }
            }
        }
//        board = map;
//        for (int[] ints : board) {
//            System.out.println(Arrays.toString(ints));
//        }
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                board[i][j] = map[i][j];
            }
        }
    }

到了这里，关于【滑动窗口、矩阵】算法例题的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 算法刷题记录-双指针/滑动窗口(LeetCode)

    算法刷题记录-双指针/滑动窗口(LeetCode)

    思路 根据题目描述，我们可以知道，如果要将某个单词定义为可扩张（stretchy），需要满足如下两个条件： 所以，我们在实现的时候，可以通过两个指针p1和p2，分别指向s和word，分别统计连续的相同字符数量c1和c2，然后再通过上述的两个条件进行判断，即：如果 则表示该单

    2024年02月09日
    浏览(41)
  • 【算法|滑动窗口No.1】leetcode209. 长度最小的子数组

    【算法|滑动窗口No.1】leetcode209. 长度最小的子数组

    个人主页：兜里有颗棉花糖 欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 兜里有颗棉花糖 原创 收录于专栏【手撕算法系列专栏】【LeetCode】 🍔本专栏旨在提高自己算法能力的同时，记录一下自己的学习过程，希望对大家有所帮助 🍓希望我们一起努力、成长，共同进步。

    2024年02月08日
    浏览(41)

  • 【双指针】滑动窗口经典例题 力扣

    无重复的最长子串LC3 中等 题目链接 给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。 代码： 找到字符串中所有子母异位词LC438 中等 题目链接 给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序

    2024年02月07日
    浏览(44)

  • python - leetcode - 424. 替换后的最长重复字符【经典题解 - 贪心滑动窗口算法】

    描述： 给你一个字符串 s 和一个整数 k 。你可以选择字符串中的任一字符，并将其更改为任何其他大写英文字符。该操作最多可执行 k 次。 在执行上述操作后，返回包含相同字母的最长子字符串的长度。 示例 1： 示例 2： 提示： 1 = s.length = 105 s 仅由大写英文字母组成 0 =

    2024年02月16日
    浏览(47)

  • 255.【华为OD机试】最小矩阵宽度（滑动窗口算法-Java&Python&C++&JS实现）

    🚀点击这里可直接跳转到本专栏，可查阅顶置最新的华为OD机试宝典~ 本专栏所有题目均包含优质解题思路，高质量解题代码(JavaPythonC++JS分别实现)，详细代码讲解，助你深入学习，深度掌握！

    2024年03月13日
    浏览(62)
  • 【map】【滑动窗口】【优先队列】LeetCode480滑动窗口中位数

    【map】【滑动窗口】【优先队列】LeetCode480滑动窗口中位数

    动态规划 多源路径 字典树 LeetCode2977:转换字符串的最小成本 C++算法：滑动窗口总结 map 优先队列 中位数是有序序列最中间的那个数。如果序列的长度是偶数，则没有最中间的数；此时中位数是最中间的两个数的平均数。 例如： [2,3,4]，中位数是 3 [2,3]，中位数是 (2 + 3) / 2 =

    2024年02月03日
    浏览(42)

  • leetcode—滑动窗口

    给定一个字符串  s  ，请你找出其中不含有重复字符的  最长子串  的长度。 示例 1: 滑动窗口 使用两个指针 表示字符串中某个子串的左右边界【i， right】 在每一步的操作中，将左指针i 向右移动一位，表示开始枚举下一个字符作为起始位置，然后不断的向右移动右指针（

    2024年01月17日
    浏览(48)
  • leetcode：滑动窗口

    leetcode：滑动窗口

    目录 1.定长滑动窗口 1.1 几乎唯一子数组的最大和(使用map来计数) 1.2 长度为k子数组中的最大和 2.不定长滑动窗口 2.1 最多k个重复元素的最长子数组 2.2 绝对差不超过限制的最长连续子数组(multiset） 2.3 将x减到0的最小操作数(正难则反 逆向思维) 2.4 统计最大元素出现至少k次的

    2024年02月02日
    浏览(40)
  • 【leetcode C++】滑动窗口

    【leetcode C++】滑动窗口

    给定一个含有 n 个正整数的数组和一个正整数 target 。 找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度 。 如果不存在符合条件的子数组，返回 0 。 . - 力扣（LeetCode） 画图 和 文字 分析 先说说有关滑动窗口的知识 滑动窗

    2024年04月09日
    浏览(53)
  • LeetCode239.滑动窗口最大值

    LeetCode239.滑动窗口最大值

    看到这道题我就有印象， 我在剑指offer里面做过这道题，我记得当时用的是优先队列，然后我脑子里一下子就有了想法，拿优先队列作为窗口，每往右移动一步，把左边的数remove掉，把右边的数add进来，然后把队头，也就是窗口中最大的元素放入答案数组，然后就写出了如下

    2024年02月11日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包