Minimum Window Substring LT76

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).

Example:

Input: S = "ADOBECODEBANC", T = "ABC"
Output: "BANC"

Note:

• If there is no such window in S that covers all characters in T, return the empty string "".
• If there is such window, you are guaranteed that there will always be only one unique minimum window in S.

Idea 1. Sliding window with two pointers. The right pointer to expand the window while fixing the left window and the left pointer to shrink the given window while fixing the right window. At any time only one of these pointer move and the other remains fixed. 经典的滑动窗口的方法， 用左右2各点滑动形成的窗口中找寻符合条件的窗口。这题麻烦的地方是如何快速的判断符合条件的窗口(letterSeen == T.length)，包含T的所有字母的最小窗口, 包含T的所有字母的窗口字母个数和T至少一样长。T中可能有重复字母，需要用map来记下每个字母出现的个数。

如何update letterSeen?

　　++letterSeen if window[right] <= letterT[right] after ++window[right]

　　--letterSeen if window[left] < letterT[left] after --window[left]

Time complexity: O(S + T), in the worst case each element is visited twice, once by right pointer, once by the left pointer. (exactly loop time 2 * S + T)

Space complexity: O(T + S), depends on the dictionary size

1.a.建立2个map, 第一个letterT用来记下T中字母出现个数，第二个window记录滑动窗口中字母出现的个数, 判断窗口中出现的字母是不是符合条件的，比如s = "aab", t = "ab", letterT['a' - 'A'] = 1,  当right = 0, window['a'-'A'] = 1 <= 2, T中的字母扫了一个，letterSeen = 1; 当right = 1, window['a'-'A'] = 2 > letterT['a' - 'A']， 扫到的比T中还多，算是多余的，就不能加letterSeen, letterSeen = 1; 当right = 2，window['b'-'A'] = 1 <= letter['b'-'A'], letterSeen = 2 == T.length, "aab"是第一个符合条件的窗口；再固定右边活动左边来找是不是还有更小的，window['a'-'A'] = 1, letterSeen == T.length, "ab"符合条件; 继续右滑，window['a'-'A'] = 0 < T['a' - 'A'], letterSeen = 1 不符合条件。

++letterSeen if window[c-'A'] <= T[c-'A']

Note.

　　window[c-'A']用作字母为key的map很方便

滑动左边不要忘记 ++left

 class Solution {
     public String minWindow(String s, String t) {
         int[] letterT = new int[256];
         for(int i = 0; i < t.length(); ++i) {
             ++letterT[t.charAt(i) - 'A'];
         }

         int[] window = new int[256];
         int start = -1;
         int letterSeen = 0;
         int minLen = Integer.MAX_VALUE;
         for(int left = 0, right = 0; right < s.length(); ++right) {
             int keyRight = s.charAt(right) - 'A';
             ++window[keyRight];
             if(window[keyRight] <= letterT[keyRight]) {
                 ++letterSeen;
                 while(letterSeen == t.length()) {
                     if(right - left + 1 < minLen) {
                         minLen = right - left + 1;
                         start = left;
                     }
                     int keyLeft = s.charAt(left) - 'A';
                     --window[keyLeft];
                     if(window[keyLeft] < letterT[keyLeft]) {
                         --letterSeen;
                     }
                     ++left;
                 }
             }
         }

         if(start == -1) {
             return "";
         }
         return s.substring(start, start + minLen);
     }
 }

python

 class Solution:
     def minWindow(self, s: str, t: str) -> str:
         letterT = collections.Counter(t)

         window = collections.defaultdict(int)
         left = 0
         letterSeen = 0
         start = -1
         minLen = len(s) + 1
         for right in range(len(s)):

             window[s[right]] += 1
             if window[s[right]] <= letterT[s[right]]:
                 letterSeen += 1
                 while letterSeen == len(t):
                     if right - left + 1 < minLen:
                         start = left;
                         minLen = right - left + 1

                     window[s[left]] -= 1
                     if window[s[left]] < letterT[s[left]]:
                         letterSeen -= 1

                     left += 1

         if start == -1:
             return ""

         return s[start: start + minLen]

2.b 只需要一个map letterT, 用右滑动来减字母个数，左滑动来加字母个数，如果左边也扫到尾部，正好左右抵消还原原来的map.

 class Solution {
     public String minWindow(String s, String t) {
         int[] letterT = new int[256];

         for(int i = 0; i < t.length(); ++i) {
             ++letterT[t.charAt(i) - 'A'];
         }

         int lettersSeen = 0;
         int minLen = Integer.MAX_VALUE;
         int start = -1;
         for(int left = 0, right = 0; right < s.length(); ++right) {
             --letterT[s.charAt(right) - 'A'];
             if(letterT[s.charAt(right) - 'A'] >= 0) {
                 ++lettersSeen;

                 while(lettersSeen == t.length()) {
                     if(right - left + 1 < minLen) {
                         minLen = right - left + 1;
                         start = left;
                     }
                     ++letterT[s.charAt(left) - 'A'];
                     if(letterT[s.charAt(left) - 'A'] > 0) {
                         --lettersSeen;
                     }
                     ++left;
                 }
             }
         }

         if(start == -1) {
             return "";
         }
         return s.substring(start, start + minLen);
     }
 }

python:

 class Solution:
     def minWindow(self, s: str, t: str) -> str:
         letterT = collections.Counter(t)

         lettersSeen = 0
         start = -1
         minLen = len(s) + 1
         left = 0
         for right in range(len(s)):
             if s[right] in letterT:
                 letterT[s[right]] -= 1
                 if letterT[s[right]] >= 0:
                     lettersSeen += 1

                     while lettersSeen == len(t):
                         if right - left + 1 < minLen:
                             minLen = right - left + 1
                             start = left

                         if s[left] in letterT:
                             letterT[s[left]] += 1

                             if letterT[s[left]] > 0:
                                 lettersSeen -= 1

                         left += 1

         if start == -1:
             return ""

         return s[start: start+minLen]