动态规划——最长公共子序列

当 S1i==S2j 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1i 这个值，最长公共子序列长度加 1，即 dp[i][j] = dp[i-1][j-1] + 1。

当 S1i != S2j 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，或者 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，取它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。

class Solution{
private:
	string s1,s2;
	vector<vector<int>> dp;
public:
	int longestCommonSubsequence(string text1,string text2){
		s1 = text1;
		s2 = text2;
		dp = vector<vector<int>>(s1.size()+1,vector<int>(s2.size()+1,-1);
		
		return dfs(s1.size(),s2.size());
	}

	int dfs(int a, int b){
	//base  case
		if(a==0 || b==0)	return 0;
		if(dp[a][b]!=-1)	return dp[a][b];
	//dp[a][b]初始化取两者最大
		dp[a][b] = max(dfs(a-1,b),dfs(a,b-1));
	//进行动态规划，状态转移
		if(s1[a-1] = s2[b-1]){
			dp[a][b] = max(dfs(a-1,b-1)+1, dp[a][b]);
		}
			return dp[a][b];
	}
};

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