LeetCode Substring相关题

3. （R）Longest Substring Without Repeating Characters

通过map记录字符出现的位置，如果发现不为0，说明已经出现过，这时候要删除左边无用点。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        map<char,int> mp;
        int maxlen=0,start=-1;
        //一个滑动窗口，start为左边界
        for(int i=0;i<s.length();i++)
        {
            if(mp.count(s[i])!=0)
                start=max(start,mp[s[i]]);//删除左边无用点
            mp[s[i]]=i;
            maxlen=max(maxlen,i-start);
        }
        return maxlen;
    }       
};

5. （R）Longest Palindromic Substring

利用回文的特点，从中间的字符开始，分奇偶两种情况。遍历每一个字符的时候都要做计算。

substr(int start,int len)函数是将 s从start起开始len长度的字符拷贝，返回值为string，比较好用。

class Solution {
public:
    string longestPalindrome(string s) {
        int start,end,pstart,pend;
        if(s.size()<=1)return s;
        string ret;
        for(int i=1;i<s.size();i++)
        {
            start=i-1;
            end=i;
            while(start<end && end<s.size() && start>=0 && s[start]==s[end])
            {
                start--;
                end++;
            }
            pstart=start+1;
            pend=end-1;
            int len=pend-pstart+1;
            if(len>ret.length())
                ret=s.substr(pstart,len);
            
            start=i-1;
            end=i+1;
            while(start<end && end<s.size() && start>=0 && s[start]==s[end])
            {
                start--;
                end++;
            }
            pstart=start+1;
            pend=end-1;
            len=pend-pstart+1;
            if(len>ret.length())
                ret=s.substr(pstart,len);
        }
        return ret;
    }
};

22. Generate Parentheses

题意：输入数字n，为括号的对数，求有多少种有效的排序。

思路：如果把所以的可能性列出来，再根据stack来检验是否有效未免太多可能，肯定要换一种想法。根据括号的特性，左括号的一定先出现，所以我们要保证左括号在右括号之前，详情见代码里两个if语句。

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> res;
        string str;
        g(res,str,n,n);
        return res;
    }
    void g(vector<string> &res,string str,int l,int r)
    {
        if(l==0&&r==0)
        {
            res.push_back(str);
            return;
        }
        if(l>0) g(res,str+'(',l-1,r);
        if(r>l)g(res,str+')',l,r-1);
    }
};

30. Substring with Concatenation of All Words

题意就是在给出的string中，找出包含words的连续子串，没有顺序要求。

思路：如果采用组合words的方式来找子串，那么words数目多了计算量将很大。遍历每一个s的字符，根据每个words长度来搜索，注意每个word的长度是相等的，所以不用修改n的值，利用两个hash表来处理是否找到，具体见代码。

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
          if(s.size()==0 || words.size()==0) return {};  
        vector<int> result;  
        unordered_map<string, int> hash;  
        for(auto val: words) hash[val]++;  
        int m = words.size(), n = words[0].size(), len = s.size();  
        if(len < m*n) return {};  
        for(int i = 0, j; i <= len - m*n; i++)  
        {  
            unordered_map<string, int> find;  
            for(j = i; j < i + m*n; j+= n)  
            {  
                string tem = s.substr(j, n);  
                find[tem]++;  
                if(!hash.count(tem) || find[tem] > hash[tem]) break;  
            } //如果find[tem]>hash[tem]说明出现了字典中不存在该子串或者同一word出现两次，停止

            if(j >= i+m*n) result.push_back(i);  //停止后如果长度大于word总长度，说明成立
        }  
        return result;  
    }
};