76. Minimum Window Substring_missing -= need[c]

本文链接：https://blog.youkuaiyun.com/a1310368974/article/details/79332472

本文探讨了在字符串S中寻找包含字符串T所有字符的最短子串问题，并提供了一种O(n)复杂度的解决方案。该算法通过动态调整窗口大小来确保包含T的所有字符，同时记录并返回最短子串。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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 empty string "".

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

意思就是在S串中找到包含T串中所有字符的最短子串。

我的想法是找到每次遍历S中一个字符，保存每个T中字符在S中的最靠后的位置，如果新加入的字符和第一个字符相同，就计算一个最短长度。

然而令我没想到的是T中字符是可以重复的。所以我得方法失败。

这里有一个答案，看代码思想差不多是：

保存一个区间[i,j]，每次加入一个字符，如果区间包含T中所有的字符，就在不影响包含T中所有字符的条件情况下，从左边开始删除区间长度，计算长度和最短长度比较。基本和我的那个方法差不多相同，O（n)复杂度，只不过它的方法更好实现。

代码如下，上面是我的，下面的是抄的（python）

class Solution(object):
    def minWindow(self, s, t):
        flag,index,minlength,minflag=False,[-1]*len(t),0,True
        for i in range(len(s)):
            if s[i] in t:
                word=t.index(s[i])
                index[word]=i
                if minflag:
                    minindex=word
                if flag==False:
                    findflag=False
                    for each in index:
                        if each<0:
                            findflag=True
                            break
                    if findflag==False:
                        flag=True
                        mins,mine=min(index),i
                        minlength=mine-mins
                if flag==True:
                    if minindex==word:
                        j=min(index)
                        minindex=index.index(j)
                        if i-j<minlength:
                            mins,mine,minlength=j,i,i-j
        if flag:
            return s[mins:mine+1]
        else:
            return ""
        

S="ADOBG"
T="ADOBG"
ss=Solution()
print ss.minWindow(S,T)

def minWindow(self, s, t):
    need, missing = collections.Counter(t), len(t)
    i = I = J = 0
    for j, c in enumerate(s, 1):
        missing -= need[c] > 0
        need[c] -= 1
        if not missing:
            while i < j and need[s[i]] < 0:
                need[s[i]] += 1
                i += 1
            if not J or j - i <= J - I:
                I, J = i, j
    return s[I:J]