Force buckle 209 Minimum length subarray

Given a containing  n  An array of positive integers and a positive integer target .

Find the sum of the array ≥ target The smallest length of Continuous subarray  [numsl, numsl+1, ..., numsr-1, numsr] , And return its length . If there is no sub array that meets the conditions , return 0 .

source ： Power button （LeetCode）
link ：https://leetcode.cn/problems/minimum-size-subarray-sum
Copyright belongs to the network . For commercial reprint, please contact the official authority , Non-commercial reprint please indicate the source .

Method ： The sliding window （ Variable window size ） 

class Solution {
public:
    /* Violence solution ： Not recommended , The time complexity is O(n^2), The force buckle will not pass , Time limit exceeded 
     Time complexity ：O(n^2)  Spatial complexity ：O(1)*/
    /*
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX; // Final result , The shortest continuous subarray 
        int subLength = 0;      // The sum of the values of the subsequence currently traversed 
        int size = nums.size();
        for(int i = 0; i < size; ++i) {  // Set subsequence int sum = 0;
            for(int j = i; j < size; ++j) { // Set the end point of subsequence to j
                sum += nums[j];
                if(sum >= target) {  // Update once the conditions are met result Size 
                    subLength = j - i + 1;
                    result  = result < subLength ? result : subLength;
                    break; // The current shortest subsequence has been found , So direct break
                }
            }
        }
        // If result Not assigned , It indicates that there is no continuous subsequence that satisfies the condition , return 0
        return result == INT32_MAX ? 0 : result; 
    }
    */
    
    /* Recommended solution ： The sliding window */
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX;  // The result returned , The initial value is set to the maximum value , It will be updated continuously later 
        int subLength = 0;       // The length of the continuous subsequence that meets the return condition currently traversed , The length of the sliding window 
        int size = nums.size();  // The size of the given array 
        int i = 0;               // The starting position of the sliding window 
        int sum = 0;             // The sum of the sequence currently traversed , The sum of the sliding window values 
        for(int j = 0; j < size; ++j) {
            sum += nums[j];
            // Be sure to use while Out of commission if, Each update i( The starting position ), It is necessary to constantly compare whether the subsequence meets the conditions 
            while(sum >= target) {
                subLength = j - i + 1; // Take the length of the subsequence 
                result = result < subLength ? result : subLength;
                sum -= nums[i++]; // The essence of sliding windows , Constantly changing i The starting position 
            }
        }
        // If result Not assigned , It indicates that there is no continuous subsequence that satisfies the condition , return 0
        return result == INT32_MAX ? 0 : result;
        // Time complexity ：O(n)  Spatial complexity ：O(1)
    }
};