动态规划概述

动态规划概述

动态规划的两个要求：

1.最优子结构

例：现有一座10级台阶的楼梯，我们要从下往上走，每次只能跨一步，一步可以往上走1级或者2级台阶，请问一共有多少种解法呢？

台阶数	1	2	3	4	5	6	7	8	9	10
走法数	1	2	3	5	8	13	21	34	55	89

可以发现，我们都可以通过前两个状态来推出当前状态

**最优子结构：**大问题的（最优）解可以由小问题的（最优）解来推出，在这个问题当中，大问题的f(n)的解可以由小问题f(n-2)和f(n-1)的解推出。注意：在问题拆解过程当中不能无限递归

2.无后效性

未来与过去无关，一旦得到了一个小问题的解，如何得到它的解的过程不会影响到大问题的求解。在上面这个问题种，我们只需要知道f(n-1)和f(n-2)的值，但是怎么得到它的已经不重要了。

动态规划的两个元素：

状态：

求解过程进行到了哪一步，可以理解为一个子问题。

转移：

从一个状态（小问题）的（最优）解推导出另一个状态（大问题）的（最优）解的过程。

最短路I

最优子结构：为了计算出从1号点到y号点最少花费的时间，我们可以计算出所有与y号点所连接的边，并且标记所有小于y的点x，从1号点到x号点所花费的最短时间，最后再推到y号点的情况。

无后效性：我们只关心每个点所花费的最短时间，不关心到底是怎么走到这个点的。

状态：f[i]表示从1到i所花费的最短时间

转移：假设已经知道了f[x]的值，并且存在一条从x到y的代价为z的边，那么可以推导出方程：f[y]=min(f[y],f[x]+z)

AC代码：

#include<iostream>
using namespace std;
const int N = 1010;
int a[N][N], f[N], n, m;//a数组存图

int main(void)
{
	cin >> n >> m;
	memset(a, 127, sizeof(a));//将a的每一条边都初始化为一个很大的值
	for (int i = 1; i <= m; i++)
	{
		int x, y, z;
		cin >> x >> y >> z;
		a[x][y] = min(a[x][y], z);//防止有重边
	}
	memset(f, 127, sizeof f);
	f[1] = 0;
	for (int i = 2; i <= n; i++)
	{
		for (int j = 1; j < i; j++)
		{
			if (f[j] < 1 << 30 && a[j][i] < 1 << 30)
				f[i] = min(f[i], f[j] + a[j][i]);
		}
	}
	cout << f[n];
	return 0;
}

最短路II

这里存在无限递归，因为每一次绕着1 2 4 3走一圈代价就会减少5，所以不能使用动态规划解决

最长上升子序列

最优子结构：为了计算a[i]以i结尾的最长上升子序列的长度，我们可以通过枚举所有小于i的位置j，我们可以先计算出以a[j]结尾的上升子序列，然后判断a[i]是否大于a[j]，如果a[i]>a[j]那么答案就是a[j]+1，反之答案就是a[j]。

无后效性：我们只关心以i这个位置结尾的最长上升子序列的长度，并不关心子序列是什么。

状态：用f[i]表示以i结尾的最长上升子序列的长度

转移：对于某个位置i，为了计算i，我们枚举子序列种所有小于i的元素j，满足j<i&&a[j]<a[i]可以得到状态转移方程：f[i]=max(f[i],f[i]+1)。

序号	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
a	13	14	17	12	7	8	19	23	52	11	6	9	15	520	1314	10
f	1	2	3	1	1	2	3	4	5	3	1	3	4	6	7	4

最后答案等于f[i]当中的最大值

AC代码：

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1010;
int n, a[N], f[N];

int main(void)
{
	cin >> n;
	int res = -10;
	for (int i = 1; i <= n; i++) cin >> a[i];
	for (int i = 1; i <= n; i++)
	{
		f[i] = 1;//如果没有找到能够满足子序列的，那么它的f[i]值就是1，需要初始化一下
		for (int j = 1; j < i; j++)
		{
			if (a[j] < a[i])
			{
				f[i] = max(f[i], f[j] + 1);
				if (f[i] > res) res = f[i];
			}
		}
	}
	cout << res;
	return 0;
}

最长公共子序列

最优子结构：为了计算出a[i]和b[j]的最长公共子序列，可以从a[i-1]和a[j-1]来转移过来。

假如a[i]==a[j]那么我们可以从f[i-1][j-1]+1转移过来，就是考虑a的前i个元素和b的前j个元素

假如a[i]!=a[j]那么可以从f[i-1][j]和f[i][j-1]转移过来，就是考虑a的前i-1个元素和b的前j个元素以及a的前i个元素和b的前j-1个元素。

这时候可能就有人会有疑问，为什么不考虑f[i-1][j-1]的情况呢？

举一个例子：

a:	A	D	A	B	C	A	B	C	D
						i
b:	D	B	A	B	C	C	D	A	B
						j

如上面的这个表格，如果a[i]!=a[j]那么有没有i和j的元素，对前面的子串都是没有影响的。

串a是ADABCA和ADABC与DBABCC去比较都是一样的，所以f[i-1][j-1]的这种情况已经被包含在

f[i-1][j]和f[i][j-1]当中了。

无后续性：我们只在乎最长公共子序列的长度是多少，至于是哪些元素构成的我们并不在乎

状态：f[i][j]表示a以第i个位置结尾和b以第j个位置结尾的最长公共子序列是多少。

转移：如果a[i]==a[j]那么f[i][j]=f[i-1][j-1]+1。

​ 如果a[i]!=a[j]那么f[i][j]max(f[i-1][j],f[i][j-1])

AC代码：

#include<iostream>
using namespace std;
const int N = 1010;
int n, m, a[N], b[N], f[N][N];

int main(void)
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++) cin >> a[i];
	
	for (int i = 1; i <= m; i++) cin >> b[i];
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
		{
			f[i][j] = max(f[i - 1][j], f[i][j - 1]);
			if (a[i] == b[j]) f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);
		}
	}
	cout << f[n][m] << endl;
	return 0;
}

思考题：最长回文子串

状态：f[i][j]表示从i到j是否满足回文，如果f[i][j]要满足回文字符串的条件，我们可以从

f[i+1][j-1]推到过来，如果f[i+1][j-1]满足回文子串，那么只要str[i==str[j]，就可以判定

f[i][j]是回文字符串， 那么如何去得到f[i+1][j-1]的状态呢，我们可以通过不断改变字符串的长度，来判断不同长度字符串的所有情况是否满足是回文子串，比如我要看是否存在长度为4的回文字符串，那么就可以先去找长度为2的，最后判断边界是否相等(str[i]==str[j])即可。

转移：如果str[i]==str[j]那么 f[i][j]=f[i+1][j-1]，反之f[i][j]=false。

AC代码：

#include<iostream>
using namespace std;
const int N = 1010;

bool f[N][N];
int main(void)
{
	string str;
	cin >> str;
	int len = str.size();

	for (int i = 0; i <= len; i++)
	{
		f[i][i] = true;//将一个字符的全都初始化为true
	}

	int begin = 0,maxlen=-10010;

	for (int l = 2; l <= len; l++)//从长度为2开始计算状态，找到满足回文的子串
	{
		for (int i = 0; i < len; i++)
		{
			int j = l + i - 1;
			if (j >= len) break;

			if (str[i] != str[j]) f[i][j] = false;
			else
			{
				if (j - i < 3)
				{
					f[i][j] = true;
				}
				else
				{
					f[i][j] = f[i + 1][j - 1];
				}
			}
			if (f[i][j] && j - i + 1 > maxlen)
			{
				maxlen = j - i + 1;
				begin = i;
			}
		}
	}
	
	cout << str.substr(begin, maxlen);

	return 0;
}