leetcode minimum-window-substring

最新推荐文章于 2020-08-17 07:22:22 发布
最新推荐文章于 2020-08-17 07:22:22 发布
阅读量95 收藏
点赞数
分类专栏： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/pynash123/article/details/84638676
版权
本文介绍了一种在字符串S中寻找包含字符串T所有字符的最短子串的算法，采用多种实现方式，包括使用map、multimap以及窗口法等，并通过实例展示了不同方法的效率对比。

摘要生成于 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 emtpy string"".
If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.

//a  aa这种不通过
class Solution {
public:
    string minWindow(string S, string T) 
    {
        string res;
        map<char, int> mmap;
        map<char, int>::iterator iter;
        if (T.size() == 0)
            return res;
        for (int i=0;i<T.size();i++)
        {
            mmap.insert(pair<char, int>(T[i], -1));
        }
        for (int i=S.size()-1;i>=0;i--)
        {
            if (mmap.find(S[i]) != mmap.end())
                mmap[S[i]] = i;
        }
        for (iter=mmap.begin();iter!=mmap.end();iter++)
        {
            if (-1 == iter->second)
                return res;
        }
        res = S;
        findmin(S,res, mmap);
        for (int i=0;i<S.size();i++)
        {
            if (mmap.find(S[i]) != mmap.end())
            {
                mmap[S[i]] = i;
                findmin(S,res, mmap);
            }
        }
        return res;
    }
    void findmin(string &S, string &res, map<char, int> &mmap)
    {
        map<char, int> :: iterator iter;
        int min = INT_MAX;
        int max = INT_MIN;
        for (iter=mmap.begin();iter!=mmap.end();iter++)
        {
            min = iter->second<min?iter->second:min;
            max = iter->second>max?iter->second:max;
            if (max-min +1 > res.size())
                return;
        }
        res = S.substr(min, max-min +1);
    }
};


//multimap代替map  
class Solution {
public:
    string minWindow(string S, string T) 
    {
        string res;
        multimap<char, int> mmap;
        multimap<char, int>::iterator iter;
        if (T.size() == 0)
            return res;
        for (int i=0;i<T.size();i++)
        {
            mmap.insert(pair<char, int>(T[i], INT_MAX));
        }
        for (int i=S.size()-1;i>=0;i--)
        {
            multimap<char, int>::iterator iter1 = mmap.find(S[i]);
            int count = mmap.count(S[i]);
            multimap<char, int>::iterator itertmp = iter1;
            if (count > 0)
            {
                while (count > 0)
                {
                    itertmp = itertmp->second > iter1->second?itertmp:iter1;
                    ++iter1;
                    --count;
                }
                itertmp->second = i;
            }
        }
        for (iter=mmap.begin();iter!=mmap.end();iter++)
        {
            if (INT_MAX == iter->second)
                return res;
        }
        res = S;
        findmin(S,res, mmap);
        for (int i=0;i<S.size();i++)
        {
            multimap<char, int>::iterator iter1 = mmap.find(S[i]);
            int count = mmap.count(S[i]);
            multimap<char, int>::iterator itertmp = iter1;
            if (count > 0)
            {
                while (count > 0)
                {
                    if (iter1->second == i)
                    {
                        itertmp = iter;
                        break;
                    }
                    itertmp = itertmp->second < iter1->second?itertmp:iter1;
                    ++iter1;
                    --count;
                }
                itertmp->second = i;
                findmin(S,res, mmap);
            }
        }
        return res;
    }
    void findmin(string &S, string &res, multimap<char, int> &mmap)
    {
        multimap<char, int> :: iterator iter;
        int min = INT_MAX;
        int max = INT_MIN;
        for (iter=mmap.begin();iter!=mmap.end();iter++)
        {
            min = iter->second<min?iter->second:min;
            max = iter->second>max?iter->second:max;
            if (max-min +1 > res.size())
                return;
        }
        res = S.substr(min, max-min +1);
    }
};



//优化
class Solution {
public:
    string minWindow(string S, string T) 
    {
        string res;
        multimap<char, int> mmap;
        if (T.size() == 0)
            return res;
        for (int i=0;i<T.size();i++)
            mmap.insert(pair<char, int>(T[i], INT_MIN));
        for (int i=0;i<S.size();i++)
        {
            multimap<char, int>::iterator iter1 = mmap.find(S[i]);
            int count = mmap.count(S[i]);
            multimap<char, int>::iterator itertmp = iter1;
            if (count > 0)
            {
                while (count > 0)
                {
                    itertmp = itertmp->second < iter1->second?itertmp:iter1;
                    ++iter1;
                    --count;
                }
                itertmp->second = i;
                findmin(S,res, mmap);//这里复杂度较高
            }
        }
        return res;
    }
    void findmin(string &S, string &res, multimap<char, int> &mmap)
    {
        multimap<char, int> :: iterator iter;
        int min = INT_MAX;
        int max = INT_MIN;
        for (iter=mmap.begin();iter!=mmap.end();iter++)
        {
            if (iter->second == INT_MIN)
                return;
            min = iter->second<min?iter->second:min;
            max = iter->second>max?iter->second:max;
            if (max-min +1 > res.size() && res.size()>0)
                return;
        }
        res = S.substr(min, max-min +1);
    }
};





//网上的答案  窗口法
class Solution {
public:
    string minWindow(string S, string T) {
        int begin = 0;
        int end = 0;
        int minbegin = 0;
        int minend = 0;
        int minSize = INT_MAX;
        vector<int> needFind(128, 0);
        vector<int> Found(128, 0);
        for(int i = 0; i < T.size(); i ++)
            needFind[T[i]] ++;
        Found[S[0]] ++;
        int count = T.size();
        if(needFind[S[0]] >= Found[S[0]])
            count --;
        while(true)
        {
            if(count == 0)
            {//shrink begin
                while(Found[S[begin]] > needFind[S[begin]])
                {
                    Found[S[begin]] --;
                    begin ++;
                }
                int size = end-begin+1;
                if(size < minSize)
                {
                    minbegin = begin;
                    minend = end;
                    minSize = size;
                }
            }
            if(end < S.size())
            {
                end ++;
                Found[S[end]] ++;
                if(needFind[S[end]] >= Found[S[end]])
                    count --;
            }
            else
                break;
        }
        if(minSize != INT_MAX)
            return S.substr(minbegin, minSize);
        else
            return "";
    }
};

//网上的答案  窗口法  优化
class Solution {
public:
    string minWindow(string S, string T) {
        int begin = 0;
        int minbegin = 0;
        int minend = 0;
        int minSize = INT_MAX;
        int count = T.size();
        vector<int> needFind(128, 0);//字符串默认只有0-128  也可以用map代替
        vector<int> Found(128, 0);
        for(int i = 0; i < T.size(); i ++)
            needFind[T[i]] ++;
        for (int end=0;end<S.size();end++)
        {
            Found[S[end]] ++;
            if(needFind[S[end]] >= Found[S[end]])
                count --;
            //开始滑动
            if(count == 0)
            {
                while(Found[S[begin]] > needFind[S[begin]])
                {
                    Found[S[begin]] --;
                    begin ++;
                }
                int size = end-begin+1;
                if(size < minSize)
                {
                    minbegin = begin;
                    minend = end;
                    minSize = size;
                }
            }   
        }
        return minSize != INT_MAX ? S.substr(minbegin, minSize) : "";
    }
};

测试

#include<iostream>
#include<map>
#include<string>
#include<limits.h>
using namespace std;


class Solution {
public:
    string minWindow(string S, string T) 
    {
        string res;
        map<char, int> mmap;
        map<char, int>::iterator iter;
        if (T.size() == 0)
            return res;
        for (int i=0;i<T.size();i++)
        {
            mmap.insert(pair<char, int>(T[i], -1));
        }
        for (int i=S.size()-1;i>=0;i--)
        {
            if (mmap.find(S[i]) != mmap.end())
                mmap[S[i]] = i;
        }
        for (iter=mmap.begin();iter!=mmap.end();iter++)
        {
            if (-1 == iter->second)
                return res;
        }
        res = S;
        findmin(S,res, mmap);
        for (int i=0;i<S.size();i++)
        {
            if (mmap.find(S[i]) != mmap.end())
            {
                mmap[S[i]] = i;
                findmin(S,res, mmap);
            }
        }
        return res;
    }
    void findmin(string &S, string &res, map<char, int> &mmap)
    {
        map<char, int> :: iterator iter;
        int min = INT_MAX;
        int max = INT_MIN;
        for (iter=mmap.begin();iter!=mmap.end();iter++)
        {
            min = iter->second<min?iter->second:min;
            max = iter->second>max?iter->second:max;
            if (max-min +1 > res.size())
                return;
        }
        res = S.substr(min, max-min +1);
    }
};

class Solution1 {
public:
    string minWindow(string S, string T) 
    {
        string res;
        multimap<char, int> mmap;
        multimap<char, int>::iterator iter;
        if (T.size() == 0)
            return res;
        for (int i=0;i<T.size();i++)
        {
            mmap.insert(pair<char, int>(T[i], INT_MAX));
        }
        for (int i=S.size()-1;i>=0;i--)
        {
            multimap<char, int>::iterator iter1 = mmap.find(S[i]);
            int count = mmap.count(S[i]);
            multimap<char, int>::iterator itertmp = iter1;
            if (count > 0)
            {
                while (count > 0)
                {
                    itertmp = itertmp->second > iter1->second?itertmp:iter1;
                    ++iter1;
                    --count;
                }
                itertmp->second = i;
            }
        }
        for (iter=mmap.begin();iter!=mmap.end();iter++)
        {
            if (INT_MAX == iter->second)
                return res;
        }
        res = S;
        findmin(S,res, mmap);
        for (int i=0;i<S.size();i++)
        {
            multimap<char, int>::iterator iter1 = mmap.find(S[i]);
            int count = mmap.count(S[i]);
            multimap<char, int>::iterator itertmp = iter1;
            if (count > 0)
            {
                while (count > 0)
                {
                    if (iter1->second == i)
                    {
                        itertmp = iter;
                        break;
                    }
                    itertmp = itertmp->second < iter1->second?itertmp:iter1;
                    ++iter1;
                    --count;
                }
                itertmp->second = i;
                findmin(S,res, mmap);
            }
        }
        return res;
    }
    void findmin(string &S, string &res, multimap<char, int> &mmap)
    {
        multimap<char, int> :: iterator iter;
        int min = INT_MAX;
        int max = INT_MIN;
        for (iter=mmap.begin();iter!=mmap.end();iter++)
        {
            min = iter->second<min?iter->second:min;
            max = iter->second>max?iter->second:max;
            if (max-min +1 > res.size())
                return;
        }
        for (iter=mmap.begin();iter!=mmap.end();iter++)
        {
            cout<<iter->first<<" "<<iter->second<< " ";
        }
        cout<<endl;
        res = S.substr(min, max-min +1);
    }
};

class Solution2 {
public:
    string minWindow(string S, string T) 
    {
        string res;
        multimap<char, int> mmap;
        if (T.size() == 0)
            return res;
        for (int i=0;i<T.size();i++)
            mmap.insert(pair<char, int>(T[i], INT_MIN));
        for (int i=0;i<S.size();i++)
        {
            multimap<char, int>::iterator iter1 = mmap.find(S[i]);
            int count = mmap.count(S[i]);
            multimap<char, int>::iterator itertmp = iter1;
            if (count > 0)
            {
                while (count > 0)
                {
                    itertmp = itertmp->second < iter1->second?itertmp:iter1;
                    ++iter1;
                    --count;
                }
                itertmp->second = i;
                findmin(S,res, mmap);
            }
        }
        return res;
    }
    void findmin(string &S, string &res, multimap<char, int> &mmap)
    {
        multimap<char, int> :: iterator iter;
        int min = INT_MAX;
        int max = INT_MIN;
        for (iter=mmap.begin();iter!=mmap.end();iter++)
        {
            if (iter->second == INT_MIN)
                return;
            min = iter->second<min?iter->second:min;
            max = iter->second>max?iter->second:max;
            if (max-min +1 > res.size() && res.size()>0)
                return;
        }
        res = S.substr(min, max-min +1);
    }
};



int main()
{
    Solution2 s;
    cout<<s.minWindow("ADOBECODEBANCBA", "ABBC")<<endl;
}
LeetCode-minimum-window-substring
六月二十七的博客
04-05 269
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: I...
LeetCode--minimum-window-substring
wl_ss的博客
01-04 223
题目描述 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
leetcode — minimum-window-substring
lack的专栏
02-28 123
import java.util.HashMap; import java.util.Map; /** * * Source : https://oj.leetcode.com/problems/minimum-window-substring/ * * * Given a string S and a string T, find the minimum window in S wh
leetcode--Minimum Window Substring
weixin_30896763的博客
08-20 135
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". ...
leetcode -- Minimum Window Substring
09-04 94
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". ...
leetcode python minimum-window-substring
clearsunshinel的博客
06-11 225
准备次饭minimum-window-substring题意思路python实现 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 examp...
LeetCode 76. Minimum Window Substring
温迪今天刷题了吗
08-17 272
LeetCode 76. Minimum Window Substring (hard) 主要知识点：sliding window；优先级：5
leetcode: minimum-window-substring
chenglan9265的博客
08-11 133
题目描述: 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 =...
LeetCode--Minimum Window Substring
Never-guess的博客
10-11 440
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:
c语言-leetcode题解之0076-minimum-window-substring.zip
09-13
本文档标题提到了“c语言-leetcode题解之0076-minimum-window-substring.zip”，其中“0076”很可能指的是LeetCode网站中的第76号问题，即“最小覆盖子串”问题。这是一个典型的字符串处理问题，要求找出一个字符串...
python-leetcode题解之076-Minimum-Window-Substring
08-28
python python_leetcode题解之076_Minimum_Window_Substring
js-leetcode题解之76-minimum-window-substring.js
最新发布
10-27
在本文中，我们将深入探讨JavaScript编程语言解决LeetCode题库中的一道经典算法题目——76题“最小覆盖子串”（minimum window substring）。本题要求在给定的字符串S中找到涵盖T中所有字符的最短子串。如果不存在...
leetcode76-LeetCode76_MinimumWindowSubstring:LeetCode76_MinimumWindowSu
06-30
由于压缩包子文件的文件名称列表只给出了 "LeetCode76_MinimumWindowSubstring-master"，我们可以假设这是一个开源项目或代码仓库的主分支名，通常这样的命名表示这是LeetCode第76题的解决方案，并且使用了Master...
leetcode分类-leetcode:leetcode
06-30
leetcode 分类 Leetcode Introduction 本文旨在将leetcode的题型分类 Pattern: Sliding window 滑动窗口类型的题目经常是用来执行数组或是链表上某个区间（窗口）上的操作。比如找最长的全为1的子数组长度。滑动窗口...
leetcode:链表中环的入口结点
pynash123的博客
08-16 736
题目： //给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } }; */ 思路: 快慢指针，快指针每次前进两个长度，慢指针每次前进一个长度，若存在环，则一定会在环内相遇。 假设起点到环入...
leetcode surrounded-regions
pynash123的博客
04-07 524
Given a 2D board containing’X’and’O’, capture all regions surrounded by’X’. A region is captured by flipping all’O’s into’X’s in that surrounded region . For example, X X X X X O O X X X O X X O X X A...
leetcode candy
pynash123的博客
04-07 193
There are N children standing in a line. Each child is assigned a rating value. You are giving candies to these children subjected to the following requirements: Each child must have at least one cand...
leetcode rotate-list
pynash123的博客
04-07 180
Given a list, rotate the list to the right by k places, where k is non-negative. For example: Given 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULLand k =2, return4-&gt;5-&gt;1-&gt;2-&gt;3-&gt;NULL. /** * Definit...
leetcode work_break
pynash123的博客
04-07 162
Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words. For example, given s =“leetcode”, dict =[“leet”, “code...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值