动态规划

动态规划

1、动态规划（英语：Dynamic programming，DP）是一种在数学、计算机科学和经济学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。 动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。
　　动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问题的解以得出原问题的解。 通常许多子问题非常相似，为此动态规划法试图仅仅解决每个子问题一次，从而减少计算量： 一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。 这种做法在重复子问题的数目关于输入的规模呈指数增长时特别有用。

2、动态规划问题满足三大重要性质
　　最优子结构性质：如果问题的最优解所包含的子问题的解也是最优的，我们就称该问题具有最优子结构性质（即满足最优化原理）。最优子结构性质为动态规划算法解决问题提供了重要线索。
　　子问题重叠性质：子问题重叠性质是指在用递归算法自顶向下对问题进行求解时，每次产生的子问题并不总是新问题，有些子问题会被重复计算多次。动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只计算一次，然后将其计算结果保存在一个表格中，当再次需要计算已经计算过的子问题时，只是在表格中简单地查看一下结果，从而获得较高的效率。
　　无后效性：将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态，它以前各阶段的状态无法直接影响它未来的决策，而只能通过当前的这个状态。换句话说，每个状态都是过去历史的一个完整总结。这就是无后向性，又称为无后效性。

3、求解的基本步骤
（1）求解的基本步骤
　　动态规划所处理的问题是一个多阶段决策问题，一般由初始状态开始，通过对中间阶段决策的选择，达到结束状态。这些决策形成了一个决策序列，同时确定了完成整个过程的一条活动路线(通常是求最优的活动路线)。

　　　　动态规划的设计都有着一定的模式，一般要经历以下几个步骤。
　　　 初始状态→│决策１│→│决策２│→…→│决策ｎ│→结束状态
　　　　　　上面的流程就是动态规划决策过程示意图
　　(1)划分阶段，确定子问题：按照问题的时间或空间特征，把问题分为若干个阶段。在划分阶段时，注意划分后的阶段一定要是有序的或者是可排序的，否则问题就无法求解。
　　(2)确定状态和状态变量：将问题发展到各个阶段时所处于的各种客观情况用不同的状态表示出来。当然，状态的选择要满足无后效性。也就是说一个状态下的“值”通常会是一个或多个子问题的解。
　　(3)确定决策并写出状态转移方程（由已知推未知）：因为决策和状态转移有着天然的联系，状态转移就是根据上一阶段的状态和决策来导出本阶段的状态。所以如果确定了决策，状态转移方程也就可写出。但事实上常常是反过来做，根据相邻两个阶段的状态之间的关系来确定决策方法和状态转移方程。
　　(4)寻找边界条件：给出的状态转移方程是一个递推式，需要一个递推的终止条件或边界条件。
　　一般，只要解决问题的阶段、状态和状态转移决策确定了，就可以写出状态转移方程（包括边界条件）。

（2）实际应用中可以按以下几个简化的步骤进行设计：
　　（1）分析最优解的性质，并刻画其结构特征。
　　（2）递归的定义最优解。
　　（3）以自底向上或自顶向下的记忆化方式（备忘录法）计算出最优值
　　（4）根据计算最优值时得到的信息，构造问题的最优解

（3）递归到动规的一般转化过程：
　　递归函数有n个参数，就定义一个n维数组，数组的下标是递归函数参数的取值范围，数组元素的值是递归函数的返回值，这样就可以从边界开始，逐步填充数组，相当于计算递归函数的逆过程。递推是递归的反向运算过程。
（4）动态规划性质浅谈
首先，动态规划和递推有些相似（尤其是线性动规），但是不同于递推的是：

递推求出的是数据，所以只是针对数据进行操作；而动态规划求出的是最优状态，所以必然也是针对状态的操作，而状态自然可以出现在最优解中，也可以不出现——这便是决策的特性（布尔性）。

其次，由于每个状态均可以由之前的状态演变形成，所以动态规划有可推导性，但同时，动态规划也有无后效性，即每个当前状态会且仅会决策出下一状态，而不直接对未来的所有状态负责，可以浅显的理解为——
现在决定未来，未来与过去无关。
4、数字三角形（poj）
问题描述：有一个由非负整数组成的三角形，第一行只有一个数，除了最下行之外每个数的左下方和右下方各有一个数，从第一行的数开始，每次可以往左下和右下走一格，直到走到最下行，把沿途经过的数全部加起来，如何才能使这个和最大？？

(1)状态转移方程由来的分析
　　需要用抽象的方法思考问题：把当前的位置（i,j）看成一个状态，然后定义状态（i,j）的指标函数maxSum(i,j)为从格子（i，j）出发时能得到的最大和（包括（i，j）本身的值）。在这个状态定义下，原问题的解为maxSum(1,1).
从格子（i，j）出发有两种决策，往左下走或者往右下走，应选择maxSum(i+1,j),maxSum(i+1,j+1)中较大的那一个，即
maxSum(i,j)=maxSum(i,j)+max{maxSum(i+1,j),maxSum(i+1,j+1)}
（如：三角形的这题中，状态就有n(n+1)/2个，那么整个问题的时间复杂度就是状态数目乘以计算每个状态所需要的时间。）
(2)记忆化搜索：
　　各个数都是非负的，只需把所有d初始化为-1，即可通过判断得知它是否已经被计算过。
　　另外就是注意边界的处理。

(3)如果不用记忆化搜索，用递归为什么会超时呐？原因如下：

　　改进：那么就可以算出来一个MaxSum(r,j)就存起来，用的时候直接去调用，因为三角形的数字总数是n(n+1)/2，所以时间复杂度
就是O（n^2）。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

方法一：记忆化递归 #include<iostream> #include<algorithm> using namespace std; #define MAX 101 int D[MAX][MAX]; int n; int maxSum[MAX][MAX]; int MaxSum(int i,int j){ if (maxSum[i][j]!=-1) return maxSum[i][j]; if(i==n) maxSum[i][j]=D[i][j]; else{ maxSum[i][j]=max( MaxSum(i+1,j),MaxSum(i+1,j+1) )+D[i][j]; } return maxSum[i][j]; } int main(){ int i,j; cin>>n; for(i=1;i<=n;i++) for(j=1;j<=i;j++){ cin>>D[i][j]; maxSum[i][j]=-1; //给初始化一下，这样就能知道哪些值是已经算出来的，算出来的就可以直接用了 } cout<<MaxSum(1,1)<<endl; } 方法二：递推（由已知推未知） #include<iostream> #include<algorithm> using namespace std; #define MAX 101 int D[MAX][MAX]; int n; int maxSum[MAX][MAX]; int main(){ int i,j; cin>>n; for(i=1;i<=n;i++) for(j=1;j<=i;j++) cin>>D[i][j]; for(int i=1;i<=n;++i) maxSum[n][i]=D[n][i]; for(int i=n-1;i>=1;--i) for(int j=1;j<=i;++j) maxSum[i][j]=max(maxSum[i+1][j],maxSum[i+1][j+1])+D[i][j]; //用一个maxSum这个数组存一下D中两个较大元素的和，然后算到顶端，就得到最大的maxSum[1][1] cout<<maxSum[1][1]<<endl; }

　　其中在第二种递推方法中，可以用一个指针 指向D元素的第n行，然后用覆盖第n行的元素的方法来求得结果

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#include<iostream> #include<algorithm> using namespace std; #define MAX 101 int D[MAX][MAX]; int n; int* maxSum; int main(){ int i,j; cin>>n; for(i=1;i<=n;i++) for(j=1;j<=i;j++) cin>>D[i][j]; maxSum=D[n]; //maxSum指向了第n行 for(int i=n-1;i>=1;--i) for(int j=1;j<=i;++j) maxSum[j]=max(maxSum[j],maxSum[j+1])+D[i][j]; //现在就可以这样用，用maxSum[j]来指向第n行的第j个元素（始终是第n行，因为要覆盖第n行的相应元素） cout<<maxSum[1]<<endl; //因为j是从1开始记得，所以要输出maxSum[1]而不是maxSum[0] }

5、最长上升子序列LCS（百练2757）

上述两图中下面这种有n个子问题，即n个状态，也满足无后效性（可以写出转移方程）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

#include<iostream> #include<cstring> #include<algorithm> using namespace std; const int MAXN=1010; int a[MAXN]; int maxlen[MAXN]; int main(){ int N; cin>>N; for(int i=1;i<=N;++i){ cin>>a[i]; maxlen[i]=1; } for(int i=2;i<=N;++i){ //每次求以第i个数为终点的最长上升子序列的长度 for(int j=1;j<i;++j){ //观察以第j个数为终点的最长上升子序列的长度 if(a[i]>a[j]) maxlen[i]=max(maxlen[i],maxlen[j]+1); //因为maxlen[i]是时刻更新的，所以要求两者的较大的数 } } cout<< *max_element(maxlen+1,maxlen+N+1); max_element这个函数返回的是迭代器，所以要加*来输出其中的内容 return 0; //时间复杂度就是O(n^2) } tips:在编写代码时，忘记把maxlen[i]=1与cin>>a[i];写在一行，而放进循环体内，报错（因为在函数内定义的变量的作用域都是本函数体内，所以会出现i未被定义的现象） [Error] name lookup of 'i' changed for ISO 'for' scoping [-fpermissive]

6、 最长公共子序列LIS （P1439）
题目描述
给出1-n的两个排列P1和P2，求它们的最长公共子序列。
输入格式
第一行是一个数n，
接下来两行，每行为n个数，为自然数1-n的一个排列。
输出格式
一个数，即最长公共子序列的长度
输入
5
3 2 1 4 5
1 2 3 4 5
输出
3

题解：看此题的数据范围，显然使用最长公共子序列的一般DP算法（时间复杂度为O(N^2)）肯定会超时，所以我们需要想别的方法。

考虑此题的另一个条件，两个序列都为1…n的一个排列，考虑特殊情况：

如果其中一个排列为(1,2,…,n)，另一个排列为(a1,a2,…,an)，那么对于两者的任意公共子序列(a[b1],a[b2],…,a[bk])，必有a[b1] < a[b2] < …< a[bk]，则两序列的最长公共子序列为排列(a1,a2,…,an)的最长上升子序列。

那么，对于两个一般的排列(a1,a2,…,an)和(b1,b2,…,bn)的最长公共子序列怎么求？

我们定义映射f(ai)=i，那么两个排列可以转换为(f(a1),f(a2),…,f(an))=(1,2,…,n)和(f(b1),f(b2),…,f(bn))，我们进行这样的转换之后，就把本题转换为求最长上升子序列的长度的题目了。
之后便可以用LIS的nlogn算法计算了。
总的时间复杂度为处理映射O(N)，求LIS长度为O(N log N)，总的时间复杂度为O(N log N)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

#include<cstdio> int n,top; int a[100005],dp[100005],f[100005]; int search(int x){ int l=1,r=top,mid; while(l<r){ mid=(l+r)>>1; if(dp[mid]<x) l=mid+1; else r=mid; } return l; } int main(){ scanf("%d",&n); for(int i=1;i<=n;i++) { scanf("%d",&a[i]); f[a[i]]=i; } for(int i=1;i<=n;i++) { scanf("%d",&a[i]); a[i]=f[a[i]]; } for(int i=1;i<=n;i++){ if(dp[top]<=a[i]) dp[++top]=a[i]; else dp[search(a[i])]=a[i]; } printf("%d",top); return 0; }

7、01背包问题(Charm Bracelet poj3624)：
Description
Bessie has gone to the mall’s jewelry store and spies a charm bracelet(镯子). Of course, she’d like to fill it with the best charms possible from the N (1 ≤ N ≤ 3,402) available charms. Each charm i in the supplied list has a weight Wi (1 ≤ Wi ≤ 400), a ‘desirability’ factor Di (1 ≤ Di ≤ 100), and can be used at most once. Bessie can only support a charm bracelet whose weight is no more than M (1 ≤ M ≤ 12,880).

Given that weight limit as a constraint（n. 限制; 限定; 约束; 严管） and a list of the charms with their weights and desirability rating, deduce（推论; 推断; 演绎;） the maximum possible sum of ratings.
Input

• Line 1: Two space-separated integers: N and M
• Lines 2..N+1: Line i+1 describes charm i with two space-separated integers: Wi and Di
  Output
• Line 1: A single integer that is the greatest sum of charm desirabilities that can be achieved given the weight constraints
  Sample Input
  4 6
  1 4
  2 6
  3 12
  2 7
  Sample Output
  23
  其中： 典型的动态规划题目，用一个数组记录背包各个重量的最优解，不断地更新直到穷尽所有可能性。
  dp[j]=max(dp[j] , dp[j-W[i]]+D[i]);

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

#include <iostream> #include<cmath> using namespace std; int main() { int N ,M; cin>>N>>M; int *W = new int[N+1]; int *D = new int[N+1]; W[0]=0; D[0]=0; for(int i=1;i<=N;i++) { cin>>W[i]>>D[i]; } int *dp = new int[M+1]; memset(*dp,0,M+1); //for(int i =0;i<=M;i++){ // dp[i]=0; //} for(int i =1;i<=N;i++) { for(int j=M;j>=W[i];j--){ //只有j>W[i]的时候才会有第二项 dp[j]=max(dp[j] , dp[j-W[i]]+D[i]); } } cout<<dp[M]<<endl; return 0; }

cankao : https://www.cnblogs.com/Archger/p/8451622.html
https://blog.csdn.net/linxilinxilinxi/article/details/83998710

旅行商问题
背包问题3.对于完全NP问题，目前并没有快速得到最优解的解决方案

• 面临NP完全问题，最佳的做法就是使用近似算法