LeetCode-Minimum Window Substring

最新推荐文章于 2015-03-07 23:45:17 发布

原创最新推荐文章于 2015-03-07 23:45:17 发布 · 471 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode #IT面试 #OJ #算法

leetCode 专栏收录该内容

123 篇文章

订阅专栏

本文介绍了一种寻找字符串S中最短子串的有效算法，该子串包含字符串T的所有字符。通过双指针技术和状态标记实现了高效查找，并详细展示了其实现过程。

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

class Solution {
public:
    string minWindow(string S, string T) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        //两个指针，当右指针扫描至包含所有T中字母时，收缩左指针
        vector<int> flag(128, 0);
        int tLen = 0;
        for (size_t i = 0; i < T.length(); ++i)
        {
            ++flag[T[i]];
            ++tLen;
        }
        vector<int> curFlag(128, 0);
        int curBeg = -1;
        int curLen = 0;
        int beg = -1;
        int end = -2;
        for (size_t i = 0; i < S.length(); ++i)
        {
            if (flag[S[i]] > 0)
            {
                ++curFlag[S[i]];
                if (flag[S[i]] >= curFlag[S[i]])
                {
                    ++curLen;    
                }
                if (curBeg < 0)
                {
                    curBeg = i;
                }
                if (curLen == tLen)
                {
                    for (;curBeg < i; ++curBeg)
                    {
                        char index = S[curBeg];
                        if (flag[index] > 0)
                        {
                            if (curFlag[index] > flag[index])
                            {
                                --curFlag[index];
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                    if (i - curBeg < end - beg)
                    {
                        beg = curBeg;
                        end = i;
                    }
                }
            }
        }
        if (beg == -1)
        {
            return "";
        }
        else
        {
            return S.substr(beg, end - beg + 1);
        }
    }
};