[LeetCode] Minimum Window Substring 散列映射問題

題目：

---

 

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

For example,
S = "ADOBECODEBANC"
T = "ABC"

Minimum window is "BANC".

Note:
If there is no such window in S that covers all characters in T, return the emtpy string "".

If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.

 

Hide Tags

  Hash Table Two Pointers String

---

     在字符串 S 中查找最小的窗口，使窗口中全部包含字符串T 中的字符，（不按順序），需要注意的地方：

• T 中的字符可以重復，窗口需要重復包含。
• 測試 實驗中的是SCII字符 ，所以可以用128位數組代替 hash table。
• leetcode  c++ 中不能用 hash_map。

思路：

1. 使用一個映射int need（hash table 或者 128位數組） 存儲T中個字符需要的個數，因為需求可能為負，所以用int。
2. 使用一個映射bool exitst（hash table 或者 128位數組） 存儲T中個字符是否存在，使用hashtable 也構造這個，因為find 是遍歷查找的。
3. 用一個var 記錄窗口中符合T 中char 的個數。
4. 用下表start、last 標記窗口位置，start 指向窗口內第一個char，last 指向窗口外右邊第一個char（包括結尾）。
5. 每次循環加入或刪除（記錄一個flag）一個字符，如果不存在便繼續循環。
6. 通過判斷加入刪除flag進行操作，更新need 表，更新var， 如果等於T 的長度，更新返回記錄。
7. 循環結束判斷能否查找。

 下面是我寫的，需要的時間復雜度為O(length(S))，即O(n)，空間復雜度為O(length(T))：

#include <string>
#include <hash_map>
#include <iostream>
#include <map>
using namespace std;
using namespace __gnu_cxx;

class Solution {
public:
    string minWindow(string S, string T) {
        int numS = S.length(),numT = T.length();
        if(numS<1||numT<1)    return "";
        int WinStart=0,WinLast=0,WinCount =0,retStart,leng=INT_MAX;
        hash_map<char, int > need;
        hash_map<char, bool > exist;
        for(int i =0;i<numT;i++){
            need[T[i]]++;
            exist[T[i]] = true;
        }

        bool addorminus;
        char curchar;
        while(WinStart<=numS-numT){
            if(WinCount!=numT&&WinLast<numS){
                addorminus = true;
                curchar = S[WinLast++];
            }
            else{
                addorminus = false;
                curchar = S[WinStart++];
            }
            if(!exist[curchar]) continue;
            if(addorminus){
                if(need[curchar]>0)  WinCount++;
                need[curchar]--;
                if(WinCount==numT&&leng>WinLast - WinStart){
                    retStart = WinStart;
                    leng = WinLast - WinStart;
                }
            }
            else{
                if(WinCount==numT&&leng>WinLast - WinStart+1){
                    retStart = WinStart-1;
                    leng = WinLast - WinStart+1;
                }
                need[curchar] ++;
                if(need[curchar]>0)  WinCount--;
            }
        }
        if(leng==INT_MAX)
            return "";
        return S.substr(retStart,leng);
    }
};

int main()
{
    string s = "1A123BAC1";
    string t = "AABC";
    Solution sol;

    string ret = sol.minWindow(s,t);
    cout<<ret<<endl;
    return 0;
}

 

 leetcode 討論里面有另外一個實現，也是O(n)，實現類似，不同的是循環內是通過判斷窗口中已經有T中字符的個數來進行 add or delete，我寫的是通過目標操作字符來進行，邏輯上沒有ta寫的方便。

 https://oj.leetcode.com/discuss/10337/accepted-o-n-solution

 

 

class Solution {
public:
    string minWindow(string S, string T) {
        if (S.empty() || T.empty())
        {
            return "";
        }
        int count = T.size();
        int require[128] = {0};
        bool chSet[128] = {false};
        for (int i = 0; i < count; ++i)
        {
            require[T[i]]++;
            chSet[T[i]] = true;
        }
        int i = -1;
        int j = 0;
        int minLen = INT_MAX;
        int minIdx = 0;
        while (i < (int)S.size() && j < (int)S.size())
        {
            if (count)
            {
                i++;
                require[S[i]]--;
                if (chSet[S[i]] && require[S[i]] >= 0)
                {
                    count--;
                }
            }
            else
            {
                if (minLen > i - j + 1)
                {
                    minLen = i - j + 1;
                    minIdx = j;
                }
                require[S[j]]++;
                if (chSet[S[j]] && require[S[j]] > 0)
                {
                    count++;
                }
                j++;
            }
        }
        if (minLen == INT_MAX)
        {
            return "";
        }
        return S.substr(minIdx, minLen);
    }
};