滑动窗口 sliding window

From : https://www.educative.io/courses/grokking-the-coding-interview

Maximum Sum Subarray of Size K (easy)

1. problem statement

Given an array of positive numbers and a positive number ‘k’, find the maximum sum of any contiguous subarray of size ‘k’.

 

2. example

Input: [2, 1, 5, 1, 3, 2], k=3 

Output: 9

Explanation: Subarray with maximum sum is [5, 1, 3].

 

Input: [2, 3, 4, 1, 5], k=2 

Output: 7

Explanation: Subarray with maximum sum is [3, 4].

3. brute force 穷举算法

Calculate the sum of all ‘k’ sized subarrays of the given array, to find the subarray with the highest sum. We can start from every index of the given array and add the next ‘k’ elements to find the sum of the subarray.

class MaxSumSubArrayOfSizeK {
  public static int findMaxSumSubArray(int k, int[] arr) {
    int maxSum = 0, windowSum;
    for (int i = 0; i <= arr.length - k; i++) {// for each index, we iterate the whole array
      windowSum = 0;
      for (int j = i; j < i + k; j++) {
        windowSum += arr[j];
      }// this for loop will calculate the windowSum that starts from index j.
      maxSum = Math.max(maxSum, windowSum);//finish one starting index, update our maxSum
    }

    return maxSum;
  }

time complexity: O(N∗K), where ‘N’ is the total number of elements in the given array

space complexity: O(1)

4. sliding window 滑动窗口

Main idea:

• Consider each subarray as a Sliding Window of size ‘k’. To calculate the sum of the next subarray, we need to slide the window ahead by one element.
• This approach will save us from re-calculating the sum of the overlapping part of the sliding window.

Steps:

1. Subtract the element going out of the sliding window i.e., subtract the first element of the window.
2. Add the new element getting included in the sliding window i.e., the element coming right after the end of the window

class MaxSumSubArrayOfSizeK {
  public static int findMaxSumSubArray(int k, int[] arr) {
    int windowSum = 0, maxSum = 0;
    int Start = 0;
    for (int End = 0; End < arr.length; End++) {
      windowSum += arr[End]; // add the next element
      // slide the window, we don't need to slide if we've not hit the required window size of 'k'
      if (End >= k - 1) {
        maxSum = Math.max(maxSum, windowSum);
        windowSum -= arr[Start]; // subtract the element going out
        Start++; // slide the window ahead
      }
    }

    return maxSum;
  }

• Time: O(N)
• Space: O(1) comstant space

  ---

Smallest Subarray with a given sum (easy)

1. problem statment

Given an array of positive numbers and a positive number ‘S,’ find the length of the smallest contiguous subarray whose sum is greater than or equal to ‘S’. Return 0 if no such subarray exists.

2. example

Input: [2, 1, 5, 2, 3, 2], S=7 

Output: 2

Explanation: The smallest subarray with a sum great than or equal to '7' is [5, 2].

3. Sliding window

This problem follows the Sliding Window pattern, but the sliding window size is not fixed

1. First, we will add-up elements from the beginning of the array until their sum becomes greater than or equal to ‘S.’
2. These elements will constitute our sliding window. We are asked to find the smallest such window having a sum greater than or equal to ‘S.’ We will remember the length of this window as the smallest window so far.
3. After this, we will keep adding one element in the sliding window (i.e., slide the window ahead) in a stepwise fashion.
4. In each step, we will also try to shrink the window from the beginning. We will shrink the window until the window’s sum is smaller than ‘S’ again. This is needed as we intend to find the smallest window. This shrinking will also happen in multiple steps; in each step, we will do two things:
   • Check if the current window length is the smallest so far, and if so, remember its length.
   • Subtract the first element of the window from the running sum to shrink the sliding window.

     class MinSizeSubArraySum {
       public static int findMinSubArray(int S, int[] arr) {
         int windowSum = 0, minLength = Integer.MAX_VALUE;
         int Start = 0;
         for (int End = 0; End < arr.length; End++) {
           windowSum += arr[End]; // add the next element
           // shrink the window as small as possible until the 'windowSum' is smaller than 'S'
           while (windowSum >= S) {
             minLength = Math.min(minLength, End - Start + 1);
             windowSum -= arr[Start]; // subtract the element going out
             Start++; // slide the window ahead
           }
         }
     
         return minLength == Integer.MAX_VALUE ? 0 : minLength;
       }

     • Time: O(N)
     • Space: O(1) comstant space