【LeetCode热题100】打卡第42天：滑动窗口最大值&搜索二维矩阵II

【LeetCode热题100】打卡第42天：滑动窗口最大值&搜索二维矩阵II

⛅前言

大家好，我是知识汲取者，欢迎来到我的LeetCode热题100刷题专栏！

精选 100 道力扣（LeetCode）上最热门的题目，适合初识算法与数据结构的新手和想要在短时间内高效提升的人，熟练掌握这 100 道题，你就已经具备了在代码世界通行的基本能力。在此专栏中，我们将会涵盖各种类型的算法题目，包括但不限于数组、链表、树、字典树、图、排序、搜索、动态规划等等，并会提供详细的解题思路以及Java代码实现。如果你也想刷题，不断提升自己，就请加入我们吧！QQ群号：827302436。我们共同监督打卡，一起学习，一起进步。
博客主页：知识汲取者的博客
LeetCode热题100专栏：LeetCode热题100

Gitee地址：知识汲取者 (aghp) - Gitee.com

题目来源：LeetCode 热题 100 - 学习计划 - 力扣（LeetCode）全球极客挚爱的技术成长平台

PS：作者水平有限，如有错误或描述不当的地方，恳请及时告诉作者，作者将不胜感激

滑动窗口最大值

题目

原题链接：239.滑动窗口最大值

题解

• 解法一：递减队列

  所谓的递减队列就是队头到队尾的元素按照从大到小的顺序进行排序的

  算法的核心步骤：

  1. 添加元素，要保障单调队列中的元素是递减的，由于添加元素是在队尾进行的，所以要求队列中其他元素都要比它大
  2. 移除元素，由于移除元素是在队头进行的，如果当前元素是最大值，需要移除单调队列的队头元素（队头元素就是当前最大值）

  对于这种题目我现在也不是一开始就没有思路了，一下就想到肯定要使用 递减队列 ，但是目前实现起来还是有一点困难，经过不断的debug调试，然后再不断优化代码的语句和逻辑判断，最终还是实现了，现在我就来说说我实现的思路吧：我们①首先需要构建两个队列，一个队列（可以是普通队列）用于存储滑动窗口中的元素，一个队列（只能是双端队列）用于记录当前窗口最大值，②这个双端队中的元素是递减的，这样能够保障队尾元素总是当前最大元素，我们要获取当前最大元素，只需要获取队尾元素即可③移除元素时，如果发现移除的元素是当前最大值，需要移除双端队列的队尾元素，这里不罗嗦了，直接画图吧

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m8f6nOFf-1690024629049)(https://gitee.com/aghp/typora-img/raw/master/csdn/202307221916698.gif)]

  本题可以参考：【LeetCode热题100】打卡第35天：最小栈

  import java.util.Deque;
  import java.util.LinkedList;
  
  /**
   * @author ghp
   * @title
   */
  public class Solution {
      public int[] maxSlidingWindow(int[] nums, int k) {
          int[] ans = new int[nums.length - k + 1];
          DescQueue queue = new DescQueue();
          // 初始化窗口
          for (int i = 0; i < k; i++) {
              queue.add(nums[i]);
          }
          int j = 0;
          ans[j++] = queue.getMax();
          // 向右滑动窗口
          for (int i = k; i < nums.length; i++) {
              queue.remove();
              queue.add(nums[i]);
              ans[j++] = queue.getMax();
          }
          return ans;
      }
  }
  
  class DescQueue {
      private Deque<Integer> queue;
      private Deque<Integer> maxQueue;
  
      public DescQueue() {
          this.queue = new LinkedList<>();
          this.maxQueue = new LinkedList<>();
      }
  
      /**
       * 新增元素到队列尾部
       *
       * @param val
       */
      public void add(int val) {
          queue.offer(val);
          while (!maxQueue.isEmpty() && maxQueue.peekLast() < val) {
              // 新增元素大于maxQueue队尾元素，不符合递减队列的要求
              // 需要移除队尾元素，直到maxQueue符合递减队列为止
              maxQueue.pollLast();
          }
          // 新增元素大于等于队尾元素，符合递增队列，直接添加到队尾
          maxQueue.offer(val);
      }
  
      /**
       * 移除队列头部元素
       */
      public void remove() {
          int val = queue.poll();
          if (val == maxQueue.peek()) {
              // 移除的队头元素是当前最大值，则需要更新maxQueue
              maxQueue.poll();
          }
      }
  
      /**
       * 获取当前队列中最大元素
       *
       * @return
       */
      public int getMax() {
          // maxQueue的头部元素即为当前最大值，直接返回即可
          return maxQueue.peek();
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(n)$
  • 空间复杂度：$O(n)$

  其中 $n$ 为数组中元素的个数

  这里需要了解一下队列的几个常用API，不要搞混了，队列是队尾进队头出，队尾操作有：offer、pollLast、peekLast、getLast；队头操作有：poll、peek、element、getFirst

  代码优化：空间优化

  前面我们使用了两个队列，一个队列存储窗口中的元素，一个队列记录当前最大值，我们可以发现对于本题，我们其实可以发现我们只需要知道当前窗口中的最大值即可，并不需要去记录当前窗口中所有的元素，所以这里我们可以对上面的代码进行一个改造，从而省略一个队列的开销，从而一定程度降低空间复杂度，那么我们该如何实现呢，这里给出主要思路：

  1. 添加元素，要保障单调队列中的元素是递减的，由于添加元素是在队尾进行的，所以要求队列中其他元素都要比它大
  2. 移除元素，我们不必像之前一样直接移除左边界元素，但是我们队列中存储的数组的索引，我们可以换一种思路，只有当最大值被移除时，才更新递减队列（DescQueue）

  总的思路还是和上一题大差不差的，空间复杂度没有降低，但是减少了内存占用

  备注：优化参考LeetCode官方题解

  import java.util.Deque;
  import java.util.LinkedList;
  
  /**
   * @author ghp
   * @title
   */
  public class Solution {
      public int[] maxSlidingWindow(int[] nums, int k) {
          int[] ans = new int[nums.length - k + 1];
          DescQueue queue = new DescQueue();
          // 初始化窗口
          for (int i = 0; i < k; i++) {
              queue.add(nums, i);
          }
          ans[0] = nums[queue.getMax()];
          // 向右滑动窗口
          for (int i = k; i < nums.length; i++) {
              queue.remove(i - k);
              queue.add(nums, i);
              ans[i - k + 1] = nums[queue.getMax()];
          }
          return ans;
      }
  }
  
  class DescQueue {
      private Deque<Integer> maxQueue;
  
      public DescQueue() {
          this.maxQueue = new LinkedList<>();
      }
  
      /**
       * 新增元素到队列尾部
       *
       * @param arr
       * @param i
       */
      public void add(int[] arr, int i) {
          while (!maxQueue.isEmpty() && arr[i] > arr[maxQueue.peekLast()]) {
              // 新增元素大于maxQueue队尾元素，不符合递减队列的要求
              // 需要移除队尾元素，直到maxQueue符合递减队列为止
              maxQueue.pollLast();
          }
          // 新增元素大于等于队尾元素，符合递增队列，直接添加到队尾
          maxQueue.offer(i);
      }
  
      /**
       * 移除队列头部元素
       */
      public void remove(int i) {
          while (!maxQueue.isEmpty() && maxQueue.peek() <= i) {
              // 队头元素的索引已经超出了左边界，直接移除（队头元素已过期）
              maxQueue.poll();
          }
      }
  
      /**
       * 获取当前队列中最大元素
       *
       * @return
       */
      public int getMax() {
          // maxQueue的头部元素即为当前最大值，直接返回即可
          return maxQueue.peek();
      }
  }
  

• 解法二：优先队列

  优先队列可能比前面的单调队列还要简单很多，思路也超级简单，这里就简单讲解一下：

  1. 构造优先队列（这一步是核心步骤），我们创建一个优先队列，队列中的元素是一个数组，数组的第一个元素是添加的nums数组的值，第二个元素是nums数组值对应的索引
  2. 添加元素，直接添加即可，优先队列底层会通过维护一个大根堆实现降序排序，即队头元素到队尾元素的值从大到小排序

  其实说白了优先队列本质也是一个单调队列思想，只是这个单调对了不需要我们自己维护，相较于解法一，本方法就简单太多了

  import java.util.PriorityQueue;
  
  /**
   * @author ghp
   * @title
   */
  public class Solution {
      public int[] maxSlidingWindow(int[] nums, int k) {
          int[] ans = new int[nums.length - k + 1];
          // 创建一个优先队列，并且根据数组第一个元素进行降序排列，第一个元素是值，第二个元素是索引
          PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> b[0] - a[0]);
          // 初始化窗口
          for (int i = 0; i < k; i++) {
              pq.offer(new int[]{nums[i], i});
          }
          int j = 0;
          ans[j++] = pq.peek()[0];
          // 向右滑动窗口
          for (int i = k; i < nums.length; i++) {
              while (!pq.isEmpty() && pq.peek()[1] <= i - k) {
                  // 队头元素的索引已经超出了左边界，直接移除（队头元素已过期）
                  pq.poll();
              }
              pq.offer(new int[]{nums[i], i});
              ans[j++] = pq.peek()[0];
          }
  
          return ans;
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(n)$
  • 空间复杂度：$O(nlogk)$

  其中 $n$ 为数组中元素的个数，$k$是窗口的大小

搜索二维矩阵II

题目

原题链接：240.搜索二维矩阵II

题解

• 解法一：暴力枚举（能过）

  class Solution {
      public boolean searchMatrix(int[][] matrix, int target) {
          for (int[] row : matrix) {
              for (int element : row) {
                  if (element == target) {
                      return true;
                  }
              }
          }
          return false;
      }
  }
  

  复杂度分析

  • 时间复杂度：$O(mn)$
  • 空间复杂度：$O(1)$

  其中m是行，n是列

• 解法二：二分查找

  二分查找的简单应用，这里就不展开讲了，唯一需要注意的就是边界问题，对于边界问题的判断，实在不会判断的，有两种选择，一种是直接举例列出边界条件，一种是记口诀，像这种经典的算法，一般都有前辈总结的口诀，但是我还是比较推荐使用距离列出边界条件，记忆口诀这个东西太死了，失去了算法本身的意义，算法不是为了死记硬背，而是在于理解

  此外和这个题目相似的题还有很多，可以直接搜索关键词：二分查找

  /**
   * @author ghp
   * @title
   */
  class Solution {
      public boolean searchMatrix(int[][] matrix, int target) {
          int row = matrix.length;
          for (int i = 0; i < row; i++) {
              Integer result = binarySearch(matrix[i], target);
              if (result != null) {
                  return true;
              }
          }
          return false;
      }
  
      private Integer binarySearch(int[] arr, int target) {
          int l = 0, r = arr.length-1;
          while (l <= r) {
              int mid = (r - l) / 2 + l;
              if (target == arr[mid]) {
                  return mid;
              } else if (target < arr[mid]) {
                  r = mid - 1;
              } else {
                  l = mid + 1;
              }
          }
          return null;
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(mlogn)$
  • 空间复杂度：$O(1)$

  其中 $n$ 为数组中元素的个数

• 解法三：Z字形查找

  这个解法来自LeetCode官网，真TM强，没想到啊啊啊啊

  核心思路：充分利用层与层之间的排序关系，从右上角开始，不断比较当前坐标的值和目标值，缩小搜索范围，每一次比较都能缩小一行或一列的数据

  PS：能画一个动图就好了，我相信大家一看就懂（大家脑补一下吧，画图太费时间了），这个解法理解起来并不难，就是想不到啊

  class Solution {
      public boolean searchMatrix(int[][] matrix, int target) {
          int m = matrix.length, n = matrix[0].length;
          int row = 0, col = n - 1;
          while (row < m && col >= 0) {
              if (matrix[row][col] == target) {
                  return true;
              }
              if (matrix[row][col] > target) {
                  // 目标值比当前坐标值要小，则向左逼近
                  --col;
              } else {
                  // 目标值比当前坐标值要大，则向下逼近
                  ++row;
              }
          }
          return false;
      }
  }
  

  复杂度分析

  • 时间复杂度：$O(m+n)$，每次都会缩小一行或一列的数据，所以最坏情况，时间复杂度是$O(m+n)$，也就是目标值在左下角
  • 空间复杂度：$O(1)$

  其中m是行，n是列