滑动窗口（搬运）

固定窗口

int numOfSubarrays(int* arr, int arrSize, int k, int threshold)
{
    int sum = 0, ret = 0;
    threshold *= k;

    for(int i = 0; i < k; ++i) 
    {
        sum += arr[i];
    }

    if(sum >= threshold) ++ret;       
    
    for(int i = k; i < arrSize; ++i)
    {
        sum -= arr[i-k];              
        sum += arr[i];
        if(sum >= threshold) ++ ret;
    }

    return ret;                       
}

可变窗口

int lengthOfLongestSubstring(char * s){
    int n = strlen(s);
    int hash[256];
    int max = 0;
    int i = 0, j = -1;
    memset(hash, 0, sizeof(hash));      // (1)
    while(j < n - 1) {                  // (2)
        ++j;
        ++hash[ s[j] ];                 // (3)
        while( hash[ s[j] ] > 1 ) {     // (4)
            --hash[ s[i] ];
            ++i;
        }
        if(j - i + 1 > max) {           // (5)
            max = j - i + 1;
        }
    }
    return max;
}

可变窗口进阶

class Solution {
    struct T {
        int num;
        int group;

        T() {}
        T(int n, int g) : num(n), group(g) {}

        bool operator < (const T& o) {
            return num < o.num;
        }
    };

public:
    vector<int> smallestRange(vector<vector<int>>& nums) {
        int i, j, k;
        int n, group, min;
        vector<T> tt;
        int hash[3501];
        memset(hash, 0, sizeof(hash));             // (1)
        for(i = 0; i < nums.size(); ++i) {         
            for(j = 0; j < nums[i].size(); ++j) {
                tt.push_back( T(nums[i][j], i) );
            }
        }
        sort(tt.begin(), tt.end());                // (2)

        i = 0;
        j = -1;
        n = tt.size();
        group = 0;
        k = nums.size();
        min = 1000000000;
        vector<int> ret;
        while(j < n - 1) {                         // (3)
            ++j;
            if( hash[ tt[j].group ] == 0 ) {       // (4)
                ++group;
            }
            ++hash[ tt[j].group ];                 // (5)

            while(group >= k) {                    // (6)
                // [ tt[i].num,  tt[j].num ]
                // 
                int len = tt[j].num - tt[i].num;   
                if(len < min) {
                    min = len;
                    ret = {tt[i].num, tt[j].num};
                }

                -- hash [ tt[i].group ];
                if( hash [ tt[i].group ] == 0 ) {
                    --group;
                }
                ++i;
            }
        }

        return ret;
    }
};