经典动态规划子串与子序列问题一

这篇我将完整列出所有经典动态规划子串子序列的所有案例以及多种解法

1.最长公共子序列问题（LCS）

一个字符串S，去掉零个或者多个元素所剩下的子串称为S的子序列。最长公共子序列就是寻找两个给定序列的子序列，该子序列在两个序列中以相同的顺序出现，但是不必要是连续的。
例如序列X=ABCBDAB，Y=BDCABA。序列BCA是X和Y的一个公共子序列，但是不是X和Y的最长公共子序列，子序列BCBA是X和Y的一个LCS，序列BDAB也是。
寻找LCS的一种方法是枚举X所有的子序列，然后注意检查是否是Y的子序列，并随时记录发现的最长子序列。假设X有m个元素，则X有2^m个子序列，指数级的时间，对长序列不实际。
使用动态规划求解这个问题，先寻找最优子结构。设X=<x1,x2,…,xm>和Y=<y1,y2,…,yn>为两个序列，LCS(X,Y)表示X和Y的一个最长公共子序列，可以看出
如果xm=yn，则LCS ( X,Y ) = xm + LCS ( Xm-1,Yn-1 )。
如果xm!=yn，则LCS( X,Y )= max{ LCS ( Xm-1, Y ), LCS ( X, Yn-1 ) }
LCS问题也具有重叠子问题性质：为找出X和Y的一个LCS，可能需要找X和Yn-1的一个LCS以及Xm-1和Y的一个LCS。但这两个子问题都包含着找Xm-1和Yn-1的一个LCS，等等.
DP最终处理的还是数值（极值做最优解），找到了最优值，就找到了最优方案；为了找到最长的LCS，我们定义dp[i][j]记录序列LCS的长度，合法状态的初始值为当序列X的长度为0或Y的长度为0，公共子序列LCS长度为0，即dp[i][j]=0，所以用i和j分别表示序列X的长度和序列Y的长度，状态转移方程为
dp[i][j] = 0 如果i=0或j=0
dp[i][j] = dp[i-1][j-1] + 1 如果X[i-1] = Y[i-1]
dp[i][j] = max{ dp[i-1][j], dp[i][j-1] } 如果X[i-1] != Y[i-1]
具体的代码如下：

class Solution {
public:
	int LCS(string& s1, string& s2)
	{
		int m = s1.size();
		int n = s2.size();
		if (m == 0 || n == 0)
			return 0;
		int res = 0;
		vector<vector<int>>dp(m + 1, vector<int>(n + 1, 0));
		for (int i = 1; i <= m; i++)
			for (int j = 1; j <= n; j++)
			{
				if (s1[i - 1] == s2[j - 1])
					dp[i][j] = dp[i - 1][j - 1] + 1;
				else
				{
					dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
				}
			}
		return dp[m][n];
	}
};

上述代码的dp[i] [j] 考虑的是字符串s1 [0, i) 和 s2[0, j)， 注意右边是不包含 这是我的个人习惯见谅。

2.最长递增子序列（LIS）

最长递增子序列又叫做最长上升子序列；子序列，正如LCS一样，元素不一定要求连续。本节讨论实现三种常见方法，主要是练手。
题：求一个一维数组arr[i]中的最长递增子序列的长度，如在序列1，-1，2，-3，4，-5，6，-7中，最长递增子序列长度为4，可以是1，2，4，6，也可以是-1，2，4，6。

方法1：
我们依然从后往前考虑， 第i个元素之前的最长递增子序列的长度要么是1（单独成一个序列），要么就是第i-1个元素之前的最长递增子序列加1，可以有状态方程：
LIS[i] = max{1,LIS[k]+1}，其中，对于任意的k<=i-1，arr[i] > arr[k]，这样arr[i]才能在arr[k]的基础上构成一个新的递增子序列。
代码如下：

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

方法2：
第二种方法非常有意思， 我们可以先通过排序，排过序的新序列（下面我叫它为s2， 原序列为s1）和元序列有什么关系呢，其实可以仔细考虑下，那么会发现s2和s1是不是可以转换成最长公共子序列的问题，也就是第一个问题。仔细想一下确实如此，最长递增子序列必然是排序后的最长子序列，所以问题得以解决：排序 + LCS
代码如下：

class Solution {
public:
	int LISII(vector<int>& nums)
	{
		int m = nums.size();
		if (m == 0)
			return 0;
		vector<int> _copy;
		_copy.assign(nums.begin(), nums.end());
		sort(_copy.begin(), _copy.end());
		vector<vector<int>> dp(m + 1, vector<int>(m + 1, 0));
		for(int i = 1; i <= m;i++)
			for (int j = 1; j <= m; j++)
			{
				if (nums[i - 1] == _copy[j - 1])
					dp[i][j] = dp[i - 1][j - 1] + 1;
				else
				{
					dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
				}
			}
		return dp[m][m];
	}
};

方法3：
这个方法稍微难以理解，但是却做到了时间复杂度O（nlogn）, 是一个非常了不起的算法，下面我会仔细讲解一下算法的过程。
假设存在一个序列d[1…9] = 2 1 5 3 6 4 8 9 7，可以看出来它的LIS长度为5。
下面一步一步试着找出它。

我们定义一个序列B，然后令 i = 1 to 9 逐个考察这个序列。
此外，我们用一个变量Len来记录现在最长算到多少了

首先，把d[1]有序地放到B里，令B[1] = 2，就是说当只有1一个数字2的时候，长度为1的LIS的最小末尾是2。这时Len=1

然后，把d[2]有序地放到B里，令B[1] = 1，就是说长度为1的LIS的最小末尾是1，d[1]=2已经没用了，很容易理解吧。这时Len=1

接着，d[3] = 5，d[3]>B[1]，所以令B[1+1]=B[2]=d[3]=5，就是说长度为2的LIS的最小末尾是5，很容易理解吧。这时候B[1…2] = 1, 5，Len＝2

再来，d[4] = 3，它正好加在1,5之间，放在1的位置显然不合适，因为1小于3，长度为1的LIS最小末尾应该是1，这样很容易推知，长度为2的LIS最小末尾是3，于是可以把5淘汰掉，这时候B[1…2] = 1, 3，Len = 2

继续，d[5] = 6，它在3后面，因为B[2] = 3, 而6在3后面，于是很容易可以推知B[3] = 6, 这时B[1…3] = 1, 3, 6，还是很容易理解吧？ Len = 3 了噢。

第6个, d[6] = 4，你看它在3和6之间，于是我们就可以把6替换掉，得到B[3] = 4。B[1…3] = 1, 3, 4， Len继续等于3

第7个, d[7] = 8，它很大，比4大，嗯。于是B[4] = 8。Len变成4了

第8个, d[8] = 9，得到B[5] = 9，嗯。Len继续增大，到5了。

最后一个, d[9] = 7，它在B[3] = 4和B[4] = 8之间，所以我们知道，最新的B[4] =7，B[1…5] = 1, 3, 4, 7, 9，Len = 5。

于是我们知道了LIS的长度为5。
但是注意的是这个 1 3 4 7 9不是最长递增子序列， 它存储的是对应长度的LIS的最小末尾。为什么说这个算法的时间复杂度是O（nlogn）相信大家已经看出来了，在有序数组B中插入可以用到二分法。因此做到了logn的时间复杂度，就是这么神奇。
代码如下：

class Solution {
public:
	int LISIII(vector<int>& nums)
	{
		int m = nums.size();
		vector<int> maxLen(m + 1, 0);
		int len = 1;
		maxLen[1] = nums[0];
		for (int i = 1; i < m; i++)
		{
			if (nums[i] > maxLen[len])
				maxLen[++len] = nums[i];
			else
			{
				int p = FindPoint(maxLen, 1, len, nums[i]);
				maxLen[p] = nums[i];
			}
		}
		return len;
	}
private:
	int FindPoint(vector<int>& nums, int start, int end, int res)
	{
		int mid = start + (end - start) / 2;
		if (nums[mid] > res)
		{
			if (mid == start)
				return mid;
			else
			{
				if (nums[mid - 1] <= res)
					return mid;
				else
					FindPoint(nums, start, mid - 1, res);
			}
		}
		else
			FindPoint(nums, mid + 1, end, res);
	}
};