动态规划问题几种经典例题

动态规划问题实际就是记录之前的一些重复的子问题，以避免重复问题的方法，是一种以空间换时间的方法

1.最长递增子序列：

给定一个数字序列A及序列的长度n，请返回最长上升子序列的长度。

测试样例：

[2,1,4,3,1,5,6],7

返回：4

解析：利用一个矩阵dp[i]来存储每个元素所在的最长递增序列，然后在寻找最大值

最长子序列应为 1，4，5，6 长度为4

class AscentSequence {
public:
	int findLongest(vector<int> A, int n) {
		// write code here
		vector<int> dp(n, 1);
		int max_length = 0;
		for (int i = 1; i < n; i++)
		{
			for (int j = 0; j < i; j++)
			{
				if (A[i] > A[j])
				{
					dp[i] = max(dp[i], dp[j] + 1);
				}
			}
		}
		for (int i = 0; i < n; i++)
		{
			if (dp[i] > max_length)
			{
				max_length = dp[i];
			}
		}
		return max_length;
	}
};

2.最长公共子序列

给定两个字符串A和B，同时给定两个串的长度n和m，请返回最长公共子序列的长度。保证两串长度均小于等于300。

测试样例：

"1A2C3D4B56",10,"B1D23CA45B6A",12

返回：6

解析：注意是连续子序列，而不是连续子串

用一个dp矩阵，两个字符串一个横对应，一个纵对应

dp[i][j]表示字符串A和字符串B的最长公共子序列的长度

如果A[i]==B[j] dp[i+1][j+1]=dp[i][j]+1;

A[i] !=B[j] dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j]);

最后返回dp[n][m]

class LCS {
public:
    int findLCS(string A, int n, string B, int m)
    {
        // write code here
        vector<vector<int>>dp(n+1,vector<int>(m+1,0));
        for(int i=0;i<n;++i)
        {
          for(int j=0;j<m;++j)
          {
              if(A[i]==B[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[n][m];
    }
};

3.最长公共子串

给定两个字符串A和B，同时给定两串的长度n和m。

测试样例：

"1AB2345CD",9,"12345EF",7

返回：4

解析：最长公共子串而不是最长子序列，说明是连续的

因此这道题的处理和最长子序列的差别也就存在于如何确定连续？

与寻找最长子序列的不同是，我们不再单纯的赋1，因为在矩阵完成之后，我们仍要去寻找连续1最长的，很麻烦

因此我们直接对左上角的值加1，就会得到一个最大的值

class LongestSubstring {
public:
	int findLongest(string A, int n, string B, int m)
	{
		// write code here
		int Alength = A.size();
		int Blength = B.size();
		int max_length = 0;
		vector<vector<int>> dp(Alength, vector<int>(Blength, 0));
		for (int i = 1; i <= n; i++)
		{
			for (int j = 1; j <= m; j++)
			{
				if (A[i - 1] == B[j - 1])
				{
					dp[i][j] = dp[i - 1][j - 1] + 1;
				}
				max_length = max(max_length, dp[i][j]);
			}
		}
		return max_length;
	}
};