寒假训练营 第十四节 动态规划（一）总结

动态规划
基本思想： 通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。
动态规划基本步骤：

• 找出最优解的性质，并刻划其结构特征。
• 递归地定义最优值。
• 以自底向上的方式计算出最优值。
• 根据计算最优值时得到的信息，构造最优解。

局限性：动态规划对于解决多阶段决策问题的效果是明显的，但是动态规划也有一定的局限性。首先，它没有统一的处理方法，必须根据问题的各种性质并结合一定的技巧来处理；另外当变量的维数增大时，总的计算量及存贮量急剧增大。因而，受计算机的存贮量及计算速度的限制，当今的计算机仍不能用动态规划方法来解决较大规模的问题，这就是“维数障碍”
动态规划详解

1、题目详情：洛谷U279551 数字三角形

给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。

        7
      3   8
    8   1   0
  2   7   4   4
4   5   2   6   5

输入格式

第一行包含整数 n，表示数字三角形的层数
接下来 n行，每行包含若干整数，其中第 i 行表示数字三角形第 i层包含的整数。

输出格式

输出一个整数，表示最大的路径数字和。

题意分析：
1、从题目上我们可以看出它是求一个数字金字塔，然后求最大路径，所以这个题目是求最大值。线性动态规划中的一个特点就说它的题目中会出现最值之类的字眼，所以这道题可以采用线性Dp来做。
2、把这个问题分成不同的子问题，然后挨个求解——分儿化之。
3、从上往下来分析的话，可能性就很多，那么我们可以考虑逆推。
4、具体做法思想：因为我们求的是最大值，那么我们从倒数第二行开始逐个计算其加上其左下方的结点或移动至其右下方的结点，留下最大的那个和，以此类推就能求出最大的路径长度

#include<iostream>
#include<cmath>
using namespace std;
int a[1005][1005]; 
int main(){
	int N;
	cin>>N;
	for(int i=1;i<=N;i++)
		for(int j=1;j<=i;j++)
			cin>>a[i][j];
	for(int i=N-1;i>0;i--)
		for(int j=1;j<=i;j++)
			a[i][j] += max(a[i+1][j],a[i+1][j+1]);
	cout<<a[1][1]<<endl;
	system("pause");
	return 0;
}

system(“pause”)意思就是让程序暂停一下，然后按任意键继续，初学的时候最多见于程序的末尾处，用于看运行结果，避免程序一闪而过。相同的我们还可以用getchar()，避免程序运行完直接结束而看不到运行结果。

2、题目详情：洛谷U279552 最长上升子序列

给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。

输入格式

第一行包含整数 N。
第二行包含 N个整数，表示完整序列。

输出格式

输出一个整数，表示最大长度。

题意分析：
1、首先我们应该先了解最长上升子序列是什么意思？？
最长上升子序列是指：从原序列中按顺序取出一些数字排在一起，这些数字是逐渐增大的。
2、我们可以定义两个数组，a数组表示我们输入的数据，dp数组表示以 a[i] 结尾的上升子序列的集合
3、具体做法思想：我们一个一个的数据来判断，首先我们要的是比当前数组元素小的，其次要的是当前数组之前的加上其本身能按顺序排列的最长长度，这个最长长度我们就用dp数组来存储，最后我们可以事先用一个变量来存储最终的答案（max函数比较出最大值）。

#include<bits/stdc++.h>
using namespace std;
const int N=1005; 
int a[N],dp[N];	// a：数据	dp：以 a[i] 结尾的上升子序列的集合 
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		dp[i]=1;
	}
	int ans=0;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=i;j++){
			if(a[j]<a[i])
				dp[i]=max(dp[i],dp[j]+1);
		}
		ans = max(ans,dp[i]);
	}
	cout<<ans<<endl;
	return 0;
}

关键字const用来定义常量，如果一个变量被const修饰，那么它的值就不能再被改变。
const修饰符有以下几个的优点：
1、预编译指令只是对值进行简单的替换，不能进行类型检查
2、可以保护被修饰的东西，防止意外修改，增强程序的健壮性
3、编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

3、题目详情：洛谷U279548 最长公共子序列

给定两个长度分别为 N和 M的字符串 A和 B，求既是 A的子序列又是 B的子序列的字符串长度最长是多少。

输入格式

第一行包含两个整数 N 和 M。
第二行包含一个长度为 N 的字符串，表示字符串 A。
第三行包含一个长度为 M 的字符串，表示字符串 B。
字符串均由小写字母构成。

输出格式

输出一个整数，表示最大长度。

最长公共子序列（LCS）是一个在一个序列集合中（通常为两个序列）用来查找所有序列中最长子序列的问题。一个数列 ，如果分别是两个或多个已知数列的子序列，且是所有符合此条件序列中最长的，则称为已知序列的最长公共子序列。
最长公共子序列（LCS）是一个在一个序列集合中（通常为两个序列）用来查找所有序列中最长子序列的问题。这与查找最长公共子串的问题不同的地方是：子序列不需要在原序列中占用连续的位置。而最长公共子串（要求连续）和最长公共子序列是不同的。
动态规划的一个计算两个序列的最长公共子序列的方法如下：
以两个序列 X、Y 为例子：
设有二维数组f[i,j] 表示 X 的 i 位和 Y 的 j 位之前的最长公共子序列的长度，则有：
f[1][1] = same(1,1)；
f[i,j] = max{f[i-1][j -1] + same(i,j),f[i-1,j],f[i,j-1]}；
其中，same(a,b)当 X 的第 a 位与 Y 的第 b 位相同时为“1”，否则为“0”。
此时，二维数组中最大的数便是 X 和 Y 的最长公共子序列的长度，依据该数组回溯，便可找出最长公共子序列。
该算法的空间、时间复杂度均为O(n^2)，经过优化后，空间复杂度可为O(n)。
动态规划 最长公共子序列 过程图解

#include<bits/stdc++.h>
using namespace std;
int dp[1005][1005];
int main(){
	int n,m;
	cin>>n>>m;
	string a,b;
	cin>>a>>b;
	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;
			else	
				dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
	cout<<dp[a.size()][b.size()];
	return 0;
}

注释：其实本道题也算是一个最长公共子序列的模板题，上面这个代码可以套用其它求最长公共子序列的题目。

4、题目详情：洛谷U279553 最短编辑距离

给定两个字符串 A 和 B，现在要将 A经过若干操作变为 B，可进行的操作有：

1：删除–将字符串 A 中的某个字符删除。
2：插入–在字符串 A 的某个位置插入某个字符。
3：替换–将字符串 A 中的某个字符替换为另一个字符。

现在请你求出，将 A变为 B至少需要进行多少次操作。

输入格式

第一行包含整数 n，表示字符串 A的长度。
第二行包含一个长度为 n的字符串 A。
第三行包含整数 m，表示字符串 B的长度。
第四行包含一个长度为 m的字符串 B。
字符串中均只包含大小写字母。

输出格式

输出一个整数，表示最少操作次数。

题意分析：
我们可以用f[i][j]表示将 a[1 ~ i] 这个字符串 变成 b[1 ~ j] 的所有操作方的最短集合。
如何计算集合f[i][j]呢？？？
f[i][j]一定是从一下三种方法变成的, 我们只需求出这三种取min
1、删除： f[i-1][j]+1
2、插入： f[i][j-1]+1
3、改变： f[i-1][j-1]+1
(1) a[i] == b[j] 不用改
(2) a[i] != b[j] 改
注：边界：f[i][0] = i, f[0, i] = i;

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int f[N][N];
char a[N], b[N];
int main(){
	int n, m;
	cin >> n >> a + 1 >> m >> b + 1;
	for (int i = 0; i <= n; i ++ ) 
		f[i][0] = i;
	for (int i = 0; i <= m; i ++ ) 
		f[0][i] = i;
	for (int i = 1; i <= n; i ++ )
		for (int j = 1; j <= m; j ++ ){
			f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
			if (a[i] == b[j]) 
				f[i][j] = min(f[i - 1][j - 1], f[i][j]);
			else 
				f[i][j] = min(f[i - 1][j - 1] + 1, f[i][j]);
		}
	cout << f[n][m] << endl;
	return 0;
}