字符串处理相关题目

无重复字符的最长子串

    int lengthOfLongestSubstring(string s)
    {
        int len = s.size();
        if(len <= 1)
        return len;
        int MAX=INT_MIN;
        bool flag[256]={0};
        int begin=0,end=0;
        for(int i = 0;i<len;i++)
        {
            if(flag[s[i]])
            {
                while(s[begin] != s[i])
                {
                    flag[s[begin]] = false;
                    begin++;
                }
                begin++;
                end++;
            }
            else
            {
                flag[s[i]] = true;
                end++;
            }
            MAX = max(MAX,end-begin);
        }
        return MAX;
    }

最长回文子串 

    string longestPalindrome(string s)
    {
        int len = s.size();
        if(len < 2)
        return s;
        int MAX=1;
        int start = 0;
        vector<vector<bool>>dp(len,vector<bool>(len));
        for(int i=0;i<len;i++)
        dp[i][i]=true;
        for(int L=2;L<=len;L++)
        {
            for(int i=0;i<len;i++)
            {
                int j = L+i-1;
                if(j>=len)
                break;
                if(s[i]!=s[j])
                dp[i][j]=false;
                else
                {
                    if(j-i<3)
                    dp[i][j]=true;
                    else
                    dp[i][j] = dp[i+1][j-1];
                }
                if(dp[i][j] && j-i+1>MAX)
                {
                    start = i;
                    MAX = L;
                }
            }
        }
        return s.substr(start,MAX);
    }

正则表达式匹配 

    bool isMatch(string s, string p)
    {
        int len1 = s.size();
        int len2 = p.size();
        vector<vector<bool>>dp(len1+1,vector<bool>(len2+1));
        dp[0][0] = true;
        for(int i = 0;i<=len1;i++)
        {
            for(int j = 1;j<=len2;j++)
            {
                if(p[j-1] != '*')
                {
                    if(i>0 && (p[j-1] == s[i-1] || p[j-1] == '.'))
                    dp[i][j] = dp[i-1][j-1];
                }
                else
                {
                    if(j>=2)
                    {
                        dp[i][j] = dp[i][j] || dp[i][j-2];
                    }
                    if(i>=1 && j>=2 &&(s[i-1] == p[j-2] || p[j-2] == '.'))
                    dp[i][j] = dp[i][j] || dp[i-1][j];
                }
            }
        }
        return dp[len1][len2];
    }

最小覆盖子集

    string minWindow(string s, string t)
    {
        vector<int>need(128);
        int count = 0;
        for(char c:t)
        {
            need[c]++;
        }
        count = t.size();
        int l=0,r=0,start=0,size = INT_MAX;
        while(r<s.size())
        {
            char c = s[r];
            if(need[c]>0)
            {
                count--;
            }
            need[c]--;
            if(count == 0)
            {
                while(l<r && need[s[l]]<0)
                {
                    need[s[l++]]++;
                }
                if(r-l+1<size)
                {
                    size = r-l+1;
                    start = l;
                }
                need[s[l]]++;
                l++;
                count++;
            }
            r++;
        }
        return size == INT_MAX ? "" : s.substr(start,size);
    }