子序列&子串问题

1、最长公共子序列

s=abcde t=ace

子序列是不连续的，最长公共子串是连续的

输出：3

int common_longest_string(string& s,string& t){
    int s_len=s.size(),t_len=t.size();
    vector<vector<int> > dp(s_len+1,vector<int>(t_len+1));
    for(int i=0;i<s_len;i++){
        for(int j=0;j<t_len;j++){
            if(s[i]==t[j])
                dp[i+1][j+1]=dp[i][j]+1;
            else
                dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j]);
        }
    }
    return dp[s_len][t_len];
}

2、最长公共子串

abce abc

输出3

int common_longest_string(string& s,string& t){
    int s_len=s.size(),t_len=t.size();
    vector<vector<int> > dp(s_len+1,vector<int>(t_len+1));
    int res=0;
    for(int i=0;i<s_len;i++){
        for(int j=0;j<t_len;j++){
            if(s[i]!=t[j]){
                dp[i][j]=0;
            }else{
                if(i==0||j==0)
                    dp[i][j]=1;
                else
                    dp[i][j]=dp[i-1][j-1]+1;
                res=max(res,dp[i][j]);
            }
        }
    }
    return res;
}

3、最长递增子序列

[10,9,2,5,3,7,101,18]

输出：4  序列为[2,3,7,101]

时间复杂度:O(n^2)

int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(),1);
        int ans=1;
        for(int i=1;i<nums.size();i++){
            for(int j=0;j<i;j++){
                if(nums[i]>nums[j]){
                    dp[i]=max(dp[j]+1,dp[i]);
                }
            }
            ans=max(ans,dp[i]);
        }
        return ans;
    }

时间复杂度:O(nlogn)
设一个数组d，使得这个序列上升地慢，也就是将序列存入d数组中，将d数组的最后一个值最小，这样放进去的才比较多，比较长。

    int lengthOfLIS(vector<int>& nums) {
        int n=nums.size();
        if(n==0)
            return 0;
        vector<int> d(n+1, 0);
        d[1]=nums[0];
        int len=1;
        for(int i=1;i<nums.size();i++){
            if(nums[i]>d[len]){
                d[++len]=nums[i];     
            }else{
                int left=1,right=len,pos=0;
                while(left<=right){
                    int mid=(left+right)>>1;
                    if(d[mid]<nums[i]){
                        left=mid+1;
                        pos=mid;

                    }else{
                        right=mid-1;
                    }
                }
                d[pos+1]=nums[i];
            }
        }
        return len;
    }

 输出最长递增子序列

void LIS(vector<int>& arr) {
        int n=arr.size();
        vector<int> ans(n+1,0);
        int maxz=1;
        int pos;
        vector<int> dp(n,1);
        for(int i=1;i<n;i++){
            for(int j=0;j<i;j++){
                if(arr[i]>arr[j]){
                    dp[i]=max(dp[j]+1,dp[i]);
                    if(dp[i]>=maxz){
                        pos=i;
                        maxz=max(maxz,dp[i]);
                    }
                }
            }
        }
        cout<<"最大序列长度为"<<maxz<<endl;
        int dpm=maxz;
        ans[1]=arr[pos];
        int cnt=1;
        for(int i=pos-1;i>=0;i--){
            if(dp[i]==dpm-1){
                ans[++cnt]=arr[i];
                dpm=dp[i];
            }
        }
        reverse(ans.begin()+1, ans.begin()+cnt+1);
        cout<<"输出最长递增序列:"<<endl;
        for(int i=1;i<=cnt;i++)
            cout<<ans[i]<<" ";
        cout<<endl;
}

3、