【leetcode】无重复字符的最长子串c++

题目描述：

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。

示例2:

输入: s = “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。

示例3:

输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

示例4:

输入: s = “”
输出: 0

提示：

0 <= s.length <= 5 * 104
s 由英文字母、数字、符号和空格组成

1.暴力法 代码：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int n=s.length();
        if(n==0)return 0;
        int maxlen=0;
        for(int i=0;i<n;i++){
            map<char,int> m;
            int flag=1;
            for(int j=i;j<i+maxlen&&j<n;j++){
                if(j==(i+maxlen)){
                    if(m[s[j]==0]){
                        if(j-i+1>maxlen)maxlen=j-i+1;
                    }
                    else if(m[s[j]]!=0){
                        if((j-1)-i+1>maxlen)maxlen=(j-1)-i+1;
                    }
                }
                if(m[s[j]]==0)m[s[j]]++;
                else if(m[s[j]]!=0){
                    if((j-1)-i+1>maxlen)maxlen=(j-1)-i+1;
                    flag=0;
                    break;
                }
            }
            if(flag==0)continue;
            else if(flag==1){
                for(int j=i+maxlen;j<n;j++){ 
                    if(j==n-1){
                        if(m[s[j]]==0&&j-i+1>maxlen)maxlen=j-i+1;	
                        else if(m[s[j]]!=0){
                            if((j-1)-i+1>maxlen)maxlen=(j-1)-i+1;
                        }
                        break;
                    }
                    if(m[s[j]]==0){
                        m[s[j]]++;
                        continue;
                    }
                    else if(m[s[j]]!=0){//在j处有重复或j已经是最后一个字符，结束
                        if((j-1)-i+1>maxlen){
                            maxlen=(j-1)-i+1;	
                        }
                        break;
                    }
                }
            }
        }
        if(maxlen==0)maxlen=1;
        return maxlen;
    }
};

用哈希map记录元素有无重复，遍历字符串找出最长不重复子串即可。

2.滑动窗口 代码：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int n=s.length();
        if(n==0)return 0;
        if(n==1)return 1;
        unordered_map<char,int> m;
        int index=0,maxlen=1;
        for(int i=0;i<n;i++){//i是子串开始下标
            if(i!=0){
                m.erase(s[i-1]); //移除前一个元素
            }
            while(index<n && m.count(s[index])==0){
                m.insert(pair<char,int>(s[index],1)); //添加下一个元素
                index++;
            }
            if((index-1)-i+1>maxlen)maxlen=(index-1)-i+1;
        }
        return maxlen;
    }
};

用滑动窗口模拟查找过程，外层for循环表示当前子串的起始位置，index表示当前子串的结束位置。

用unordered_map记录子串中字符，用count(a)?=0 判断元素a是否重复出现

每次循环以s[i]为子串的第一个元素，while循环向后查找，直到碰到重复元素结束，即找到以s[i]为起始元素的最长子串，for循环继续查找以s[i+1]开始的最长子串，注意要在map中删除s[i]；每次比较找到对子串的长度，更新maxlen即可。

3.动态规划 代码：

class Solution {
public:
    int solve(string s,int a,int b){
        for(int i=a;i<b;i++){
            if(s[i]==s[b])return -1;
        }
        return 1;
    }
    int lengthOfLongestSubstring(string s) {
        int n=s.length(),maxlen=1;
        if(n==0)return 0;
        if(n==1)return 1;
        //a[i][j]表示s[i]到s[j]是否有重复，1为不重复，0为重复
        int **a = new int *[n];  
        for(int i=0;i<n;++i)  
        {  
            a[i] = new int[n];  
        } 
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(i==j)a[i][j]=1;
                else a[i][j]=-1;
            }
        }
        for(int i=0;i<n-1;i++){
            if(i+maxlen-1+1>=n)break;
            for(int j=i+maxlen-1+1;j<n;j++){
                if(a[i][j]==-1){//检查第j位是否和前面的子字符串重复
                    cout<<"i="<<i<<" j="<<j<<" a[i][j]=-1"<<" ";
                    cout<<"solve()="<<solve(s,i,j)<<endl;
                    if(j==n-1){
                        if(solve(s,i,j)==1){
                            if(j-i+1>maxlen)maxlen=j-i+1;
                        }
                        else{
                            if(((j-1)-i+1)>maxlen)maxlen=j-1-i+1;
                        }
                    }
                    if(solve(s,i,j)==1){  //若不重复
                        a[i][j]=1;  //标记为i～j不重复
                    }
                    else if(solve(s,i,j)==-1){ //若重复
                        a[i][j]=0; //标记为i～j重复
                        if((j-1)-i+1>maxlen)maxlen=j-1-i+1; //更新maxlen
                        cout<<"!"<<maxlen<<endl;
                        break; //停止以i开头的不重复子串的查找
                    }
                }
                else if(a[i][j]==0)break; //前面已经记录了j位置重复了，停止查找
                else continue; //j位置不重复，继续向后查找
            }
        }
        // 首先回收低一级的动态数组.  
        for(int i=0; i<n; ++i)  
        {  
            delete[] a[i];  
        }  
        // 然后回收高一级的动态数组.  
        delete[] a;  
        return maxlen;
    }
};

用二维数组记录i～j这个子串是否符合要求，每次记录上一次的结果，不用重复判断；0 <= s.length <= 5 * 104，要声明a[50000][50000]，但是c++栈最大2M，直接声明二维数组会越界（最大可以开到a[900][900]，900900sizeof(int) / 1024 > 2），所以用new 动态在堆上分配。

但是new操作太慢了，会超时，参考一下方法即可。