Leetcode 115. 不同的子序列

 给定一个字符串 S 和一个字符串 T，计算在 S 的子序列中 T 出现的个数。
一个字符串的一个子序列是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，“ACE” 是 “ABCDE” 的一个子序列，而 “AEC” 不是）
题目数据保证答案符合 32 位带符号整数范围。
 思路1：对于这种给定两个字符串的问题，类似于编辑距离和求最大公共子串，都可以采用动态规划。我们都可以设 $dp[i][j]$,那么这个 $dp[i][j]$可以怎么表示，自然的，我们可以认为它表示的含义是S的前i个元素和T的前j个元素时，T在S中出现的个数。这样是可以的，但这种方法在状态压缩的时候也可以压缩，但不太好理解。但是好写（需要倒着遍历）
 思路2：而如果我们假设 $dp[i][j]$表示当t的前i个元素和s的前j个元素时，t在s中出现的个数。这种方法在状态压缩时比较好理解。但基本的，两种思路都是类似的。

1.1 思路1

 我们先给出状态转移方程：
 $dp[i][j]$表示当s的前i个元素和t的前j个元素时，t在s中出现的个数.
if(s[i-1]==t[j-1])   dp[i][j]=dp[i-1][j-1]+dp[i-1][j]
else          dp[i][j]=dp[i-1][j]
 那么，为什么状态转移方程是这样，这里假设s[i-1]==t[j-1]，有s=“qdewde”,t=“de”,所以dp[i][j]=dp[i-1][j-1]是容易想到的，那么为什么dp[i][j]还要加dp[i-1][j]，这是因为当s[i-1]==t[j-1]时，有两种处理办法，
 1、使用s[i-1]，则向后继续寻找s=“qdewd”,t=“d”（看"qdewd"中有几个“d”）;
 第二种情况时舍弃s[i-1]，则向后继续寻找s=“qdewd”,t=“de”（看"qdewd"中有几个“de”）;
所以我们画出状态转移矩阵是m+1行n+1列，m=S.size(),n=T.size()。
需要考虑空串的情况
  若 s 是空串，t 不是空串，t 在 s中出现次数为 0，dp[0][j] = 0
  若 t 是空串，t 在 s 中出现次数是 1（因为 s 可以是空串），就是把 s 中的字符都删掉dp[i][0] = 1

class Solution {
public:
	int numDistinct(string s, string t) {
		//dp[i][j]表示当s的前i个元素和t的前j个元素时，t在s中出现的个数
		/*
		if(s[i-1]==t[j-1])  dp[i][j]=dp[i-1][j-1]+dp[i-1][j]
		else   dp[i][j]=dp[i-1][j]
		*/
		int m = s.size();
		int n = t.size();
		vector<vector<long>>dp(m + 1, vector<long>(n + 1, 0));
		for (int i = 0; i < m + 1; i++)
		{
			dp[i][0] = 1;
		}
		for (int i = 1; i <= m; i++)
		{
			for (int j = 1; j <= n; j++)
			{
				if (s[i - 1] == t[j - 1])  dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
				else   dp[i][j] = dp[i - 1][j];

			}
		}
		return dp[m][n];
	}
};

1.2 状态压缩

 我们注意到，dp[i][j] 只与 dp[i - 1][j - 1] + dp[i - 1][j]有关，那么我么可以将dp数组从二维压缩到一维。因为dp数组是正向的改变的，所以压缩后倒着遍历即可。

class Solution {
public:
	int numDistinct(string s, string t) {
		int m = s.size();
		int n = t.size();
		vector<long>dp(n + 1, 0);
		dp[0] = 1;
		for (int i = 1; i <= m; i++)
		{
			for (int j = n; j >= 0; j--)
			{
                if(j==0)
                dp[j]=1;
				else if (s[i - 1] == t[j - 1])  dp[j] += dp[j - 1];
				else   dp[j] = dp[j];

			}
		}
		return dp[n];
	}
};

2.1 思路2

 $dp[i][j]$表示当t的前i个元素和s的前j个元素时，t在s中出现的个数。
if(s[i-1]==t[j-1])   dp[i][j]=dp[i-1][j-1]+dp[i][j-1]
else          dp[i][j]=dp[i][j-1]
转移矩阵如此下，n+1行m+1列( m = s.size(); n = t.size())

class Solution {
public:
	int numDistinct(string s, string t) {
		//dp[i][j]表示当t的前i个元素和s的前j个元素时，t在s中出现的个数
		/*
		if(s[i-1]==t[j-1])  dp[i][j]=dp[i-1][j-1]+dp[i][j-1]
		else   dp[i][j]=dp[i][j-1]
		需要考虑空串的情况
		若 s 是空串，t 不是空串，t 在 s中出现次数为 0，dp[0][j] = 0
		若 t 是空串，t 在 s 中出现次数是 1（因为 s 可以是空串），就是把 s 中的字符都删掉dp[0][i] = 1
		*/
		int m = s.size();
		int n = t.size();
		vector<vector<long>>dp(n + 1, vector<long>(m + 1, 0));
		for (int i = 0; i < m + 1; i++)
		{
			dp[0][i] = 1;
		}
		for (int i = 1; i <= n; i++)
		{
			for (int j = 1; j <= m; j++)
			{
				if (t[i - 1] == s[j - 1])  dp[i][j] = dp[i - 1][j - 1] + dp[i][j - 1];
				else   dp[i][j] = dp[i][j - 1];

			}
		}
		return dp[n][m];
	}
};

2.2 状态压缩

 这里由于dp[i][j]只和dp[i-1][j-1]，dp[i][j-1]有关，我们正向遍历的时候，只需要将第i-1行时的dp[i-1]保存下来（int tem = dp[j];），随后 dp[j] =dp[j-1]+ pre;

class Solution {
public:
	int numDistinct(string s, string t) {
		//dp[i][j]表示当t的前i个元素和s的前j个元素时，t在s中出现的个数
		/*
		if(s[i-1]==t[j-1])  dp[i][j]=dp[i-1][j-1]+dp[i][j-1]
		else   dp[i][j]=dp[i][j-1]
		*/
		int m = s.size();
		int n = t.size();
		vector<long>dp(m + 1, 1);
		dp[0] = 1;
		int pre = 1;
		for (int i = 1; i <= n; i++)
		{
			for (int j = 0; j < m + 1; ++j)
			{ 
				int tem = dp[j];
				if (j == 0) dp[j] = 0;
				else {
					if (s[j - 1] == t[i - 1]) dp[j] =dp[j-1]+ pre;
                    else dp[j] = dp[j - 1];
				}
				pre = tem;

			}
		}
		return dp[m];
	}
};