滑动窗口法

0506刷题

LeetCode 209. 长度最小的子数组

LeetCode 209. 长度最小的子数组

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int left=0;
        int right=0;
        int sum=0;

        int result=INT_MAX;
        for(int right=0;right<nums.size();++right)
        {
            sum+=nums[right];
           
            while(sum>=target)
            {
                result=min(result,right-left+1);
                sum-=nums[left++];
            }
        }
        return result == INT_MAX ? 0 : result;
    }
};

采用滑动窗口法。

窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。(right++)

窗口的起始位置如何移动：如果当前窗口的值大于target了，窗口就要向前移动了（即left++）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针（while(right<nums.size())，窗口的起始位置设置为数组的起始位置就可以了。

也即：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int left=0;
        int right=0;
        int sum=0;

        int result=INT_MAX;
        while(right<nums.size())//------
        {
            sum+=nums[right++];//------
           
            while(sum>=target)
            {
                result=min(result,right-left);//------
                sum-=nums[left++];
            }
        }
        return result == INT_MAX ? 0 : result;
    }
};

LeetCode 904. 水果成篮

LeetCode 904. 水果成篮

由于手动计算umap中非零个数会超时：

    int countZero(unordered_map<int,int> umap)
    {
        int sum=0;
        for(int i=0;i<umap.size();++i)
        {
            if(umap[i]>0) sum++;
        }
        return sum;
    }

所以直接用一个整数sum统计非零个数。

自己的解法。

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        unordered_map<int,int> umap;//大小 次数
        int left=0;
        int right=0;
        int result=INT_MIN;
        int sum=0;

        while(right<fruits.size())
        {
            if(umap[fruits[right]]==0)
            {
                sum++;
            } 
            umap[fruits[right++]]++;
            
            while(sum>2)
            {
                if(umap[fruits[left]]==1) sum--;
                umap[fruits[left++]]--;
            }

            result=max(result,right-left);
        }
        return result;
    }
};

参考解法：

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        unordered_map<int, int> umap;
        int result = 0;
        int right=0;
        int left=0;
        while(right<fruits.size()) 
        {
            umap[fruits[right++]]++;
            while (umap.size() > 2) 
            {
                umap[fruits[left]]--;
                if (umap[fruits[left]] == 0) 
                {
                    umap.erase(fruits[left]);
                }
                left++;
            }
            result = max(result, right - left);
        }

        return result;
    }
};

注意在umap[fruits[left]] == 0的时候，得直接erase，因为是调用umap.size()计算umap的非零个数。

否则会报错

=================================================================
==42==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000000180 at pc 0x00000034dcc1 bp 0x7fffa62de830 sp 0x7fffa62de828
READ of size 4 at 0x602000000180 thread T0
    #3 0x7f85347560b2  (/lib/x86_64-linux-gnu/libc.so.6+0x270b2)
0x602000000180 is located 0 bytes to the right of 16-byte region [0x602000000170,0x602000000180)
allocated by thread T0 here:
    #6 0x7f85347560b2  (/lib/x86_64-linux-gnu/libc.so.6+0x270b2)
Shadow bytes around the buggy address:
  0x0c047fff7fe0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x0c047fff7ff0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x0c047fff8000: fa fa fd fa fa fa fd fa fa fa fd fa fa fa fd fa
  0x0c047fff8010: fa fa fd fd fa fa fd fd fa fa fd fd fa fa fd fa
  0x0c047fff8020: fa fa fd fa fa fa fd fa fa fa fd fa fa fa 00 00
=>0x0c047fff8030:[fa]fa 00 00 fa fa 00 00 fa fa 00 00 fa fa fa fa
  0x0c047fff8040: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c047fff8050: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c047fff8060: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c047fff8070: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c047fff8080: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
Shadow byte legend (one shadow byte represents 8 application bytes):
  Addressable:           00
  Partially addressable: 01 02 03 04 05 06 07 
  Heap left redzone:       fa
  Freed heap region:       fd
  Stack left redzone:      f1
  Stack mid redzone:       f2
  Stack right redzone:     f3
  Stack after return:      f5
  Stack use after scope:   f8
  Global redzone:          f9
  Global init order:       f6
  Poisoned by user:        f7
  Container overflow:      fc
  Array cookie:            ac
  Intra object redzone:    bb
  ASan internal:           fe
  Left alloca redzone:     ca
  Right alloca redzone:    cb
  Shadow gap:              cc
==42==ABORTING

LeetCode 76. 最小覆盖子串

LeetCode 76. 最小覆盖子串

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<char, int> umap;
        unordered_map<char, int> window;
        for (auto& c : t) umap[c]++;

        int sum = 0;
        int right = 0;
        int left = 0;
        int start = 0;
        int len = INT_MAX;
        string result = "";
        while (right < s.size())
        {
            ++window[s[right]];
            if (umap.count(s[right]) && umap[s[right]] == window[s[right]]) sum++;
            right++;

            while (sum == umap.size())
            {
                --window[s[left]];
                if (umap.count(s[left]) && window[s[left]] < umap[s[left]])
                {
                    sum--;
                }
                left++;

                if (len > right - left + 1)
                {
                    start = left;
                    len = right - left + 1;
                }
                result = s.substr(start - 1, len);
            }
        }
        return result;
    }
};

加一层if判断可以提高很大的效率

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<char, int> umap;
        unordered_map<char, int> window;
        for (auto& c : t) umap[c]++;

        int sum = 0;
        int right = 0;
        int left = 0;
        int start = 0;
        int len = INT_MAX;
        string result = "";
        while (right < s.size())
        {
            ++window[s[right]];
            if (umap.count(s[right])&&umap[s[right]]==window[s[right]]) sum++;
            right++;

            if (sum == umap.size())//-------new add
            {
                while (sum == umap.size())
                {
                    --window[s[left]];
                    if (umap.count(s[left]) && window[s[left]] < umap[s[left]])
                    {
                        sum--;
                    }
                    left++; 
                }
                if (len > right - left + 1)
                {
                    start = left;
                    len = right - left + 1;
                }

                result = s.substr(start-1, len);
            } 
        }
        return result;
    }
};

疑问：采用一个哈希表进行维护，为啥不对，流程基本都一样：

//wrong answer
class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<char, int> umap;
        // unordered_map<char, int> window;
        for (auto& c : t) umap[c]++;

        int sum = 0;
        int right = 0;
        int left = 0;
        int start = 0;
        int len = INT_MAX;
        string result = "";
        while (right < s.size())
        {
            // ++window[s[right]];
            if(umap.count(s[right])) umap[s[right]]--;
            if(umap[s[right]]==0) sum++;
            right++;

            while (sum == umap.size())
            {
                // --window[s[left]];
                if (umap.count(s[left]))
                {
                    umap[s[left++]]++;
                    sum--;
                }
                // left++;

                if (len > right - left + 1)
                {
                    start = left;
                    len = right - left + 1;
                }
                result = s.substr(start - 1, len);
            }
        }
        return result;
    }
};