子序列问题，回文子串、子序列

WWF_666

已于 2022-04-02 00:18:43 修改

阅读量159

点赞数

分类专栏：刷题文章标签：算法 leetcode c++

于 2022-03-31 23:28:52 首次发布

本文链接：https://blog.csdn.net/wwf_5450/article/details/123886672

版权

刷题专栏收录该内容

15 篇文章 0 订阅

订阅专栏

300. 最长递增子序列

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

674. 最长连续递增序列

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int n=nums.size();
        if(n<=1) return n;
        int ans=0;
        int cnt=1;
        for(int i=0;i<n-1;++i){
            if(nums[i]<nums[i+1]) cnt++;
            else cnt=1;
            if(cnt>ans) ans=cnt;
        }
        return ans;
    }
};

718. 最长重复子数组

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int n=nums1.size();
        int m=nums2.size();
        vector<vector<int>> dp(n+1,vector<int>(m+1,0));
        int ans=0;
        for(int i=1;i<=n;++i){
            for(int j=1;j<=m;++j){
                if(nums1[i-1]==nums2[j-1]) dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1);
                if(dp[i][j]>ans) ans=dp[i][j];
            }
        }
        return ans;
    }
};

1143. 最长公共子序列

1035. 不相交的线

//dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]
class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int n=text1.size();
        int m=text2.size();
        vector<vector<int>> dp(n+1,vector<int>(m+1,0));
        int ans=0;
        for(int i=1;i<=n;++i){
            for(int j=1;j<=m;++j){
                if(text1[i-1]==text2[j-1]) dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1);
                else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                if(dp[i][j]>ans) ans=dp[i][j];
            }
        }
        return ans;
    }
};

53. 最大子数组和

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
		int n=nums.size();
		vector<int> dp(n,nums[0]);
		int ans=nums[0];
		for(int i=1;i<n;++i){
			dp[i]=max(dp[i-1]+nums[i],nums[i]);
			if(dp[i]>ans) ans=dp[i];
		}
		return ans;
    }
};

greedy

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
		int res=INT_MIN;
		int count=0;
		for(int i=0;i<nums.size();i++){
			count+=nums[i];
			if(count>res) res=count;
			if(count<0) count=0;
		}
		return res;
    }
};

392. 判断子序列

//dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]
class Solution {
public:
    bool isSubsequence(string s, string t) {
		int n=s.size();
		int m=t.size();
		vector<vector<int>> dp(n+1,vector<int>(m+1,0));
		for(int i=1;i<=n;++i){
			for(int j=1;j<=m;++j){
				if(s[i-1]==t[j-1]) dp[i][j]=dp[i-1][j-1]+1;
				else dp[i][j]=dp[i][j-1];
			}
		}
		if(dp[n][m]==n) return 1;
		return 0;
    }
};

115. 不同的子序列

//dp[i][j]表示以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]
class Solution {
public:
    int numDistinct(string s, string t) {
		int n=s.size();
		int m=t.size();
		vector<vector<uint64_t>> dp(n+1,vector<uint64_t>(m+1));
		for(int i=0;i<=n;++i){
			//以下标i-1结尾的s中出现空字符串的个数为1 
			dp[i][0]=1; 
		}
		for(int j=1;j<=m;++j){
			//空字符串s出现以下标j-1结尾的字符串个数为0
			dp[0][j]=0; 
		}
		dp[0][0]=1;//空字符串出现空字符串次数为1 
		for(int i=1;i<=n;++i){
			for(int j=1;j<=m;++j){
				if(s[i-1]==t[j-1]){
					//相等则继承前面的次数加上该长度的t在之前就出现过的次数 
					dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
				}
				else{
					//dp[i][j]保留以j-1结尾的t在前面就出现过的次数 
					dp[i][j]=dp[i-1][j];
				}
			}
		}
		return dp[n][m]; 
    }
};

583. 两个字符串的删除操作

套用最长公共子序列

class Solution {
public:
    int minDistance(string word1, string word2) {
        int n=word1.size();
        int m=word2.size();
        vector<vector<int>> dp(n+1,vector<int>(m+1,0));
        int ans=0;
        for(int i=1;i<=n;++i){
            for(int j=1;j<=m;++j){
                if(word1[i-1]==word2[j-1]) dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1);
                else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                if(dp[i][j]>ans) ans=dp[i][j];
            }
        }
        return n+m-2*ans;
    }
};

直接dp

//dp[i][j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。
class Solution {
public:
    int minDistance(string word1, string word2) {
        int n=word1.size();
		int m=word2.size();
		vector<vector<int>> dp(n+1,vector<int>(m+1));
		for(int i=0;i<=n;++i){
			dp[i][0]=i;
		}
		for(int j=0;j<=m;++j){
			dp[0][j]=j;
		}
		for(int i=1;i<=n;++i){
			for(int j=1;j<=m;++j){
				if(word1[i-1]==word2[j-1]){
					dp[i][j]=dp[i-1][j-1];
				}
				else{
					dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1);
				}
			}
		}
		return dp[n][m];
    }
};

72. 编辑距离

//dp[i][j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最短编辑距离为dp[i][j]。
class Solution {
public:
    int minDistance(string word1, string word2) {
		int n=word1.size();
		int m=word2.size();
		vector<vector<int>> dp(n+1,vector<int>(m+1));
		for(int i=0;i<=n;++i){
			dp[i][0]=i;
		} 
		for(int j=0;j<=m;++j){
			dp[0][j]=j;
		}
		for(int i=1;i<=n;++i){
			for(int j=1;j<=m;++j){
				//如果相同，则不用操作，最小编辑次数即为上一次的 
				if(word1[i-1]==word2[j-1]){
					dp[i][j]=dp[i-1][j-1];
				}
				//不相同，则进行插入、删除、替换3种操作 
				else{
					dp[i][j]=min({
						dp[i-1][j]+1,//word1添加,即插入操作 
						dp[i][j-1]+1,//word2添加,相当于word1的删除 
						dp[i-1][j-1]+1//word1替换,即前面+一个替换元素的操作 
					});
				} 
			}
		}
		return dp[n][m]; 
    }
};

647. 回文子串

class Solution {
public:
    int countSubstrings(string s) {
    	int n=s.size();
		vector<vector<bool>> dp(n,vector<bool>(n,0));
		int num=0;
		for(int i=n-1;i>=0;--i){
			for(int j=i;j<n;++j){
				if(s[i]==s[j]&&(j-i<=1)||dp[i+1][j-1])){
					dp[i][j]=1;
					num++;
				}
			}
		}
		return num;
    }
};

双指针法

class Solution {
public:
	int center(string& s,int i,int j){
		int res=0;
		while(i>=0&&j<s.size()&&s[i]==s[j]){
			i--;j++;res++;
		}
		return res;
	}
    int countSubstrings(string s) {
    	int num;
    	for(int i=0;i<s.size();++i){
    		num+=center(s,i,i);
    		num+=center(s,i,i+1);
		}
		return num;
    }
};

516. 最长回文子序列

//dp[i][j]为范围i到j的子串中最长回文子序列的长度 
class Solution {
public:
    int longestPalindromeSubseq(string s) {
		int n=s.size();
		vector<vector<int>> dp(n,vector<int>(n,0));
		for(int i=0;i<n;++i) dp[i][i]=1;
		for(int i=n-1;i>=0;--i){
			for(int j=i+1;j<n;++j){
				if(s[i]==s[j]) dp[i][j]=dp[i+1][j-1]+2;
				else dp[i][j]=max(dp[i+1][j],dp[i][j-1]); 
			}
		}
		return dp[0][n-1];
    }
};

5. 最长回文子串

WWF_666

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
子序列问题，回文子串、子序列

300. 最长递增子序列class Solution {public: int lengthOfLIS(vector<int>& nums) { int n=nums.size(); if(n<=1) return n; vector<int> dp(n,1); int res=0; for(int i=0;i<n;++i){ for(int j=0
复制链接

扫一扫