【算法】动态规划

动态规划的定义：
动态规划是运筹学的一个分支，是求解决策过程的最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程的优化问题时，提出了著名的最优化原理，把多阶段过程转化为一系列单阶段问题，利用各阶段之间的关系，逐个求解，创立了解决这类过程优化问题的新方法——动态规划。在各种算法中，我认为动态规划是较难掌握好的，主要难在模型的建立。
解题的一般步骤是：
1.找出最优解的性质，刻画其结构特征和最优子结构特征；
2.递归地定义最优值，刻画原问题解与子问题解间的关系；
3.以自底向上的方式计算出各个子问题、原问题的最优值，并避免子问题的重复计算；
4.根据计算最优值时得到的信息，构造最优解。
话不多说，我们来看几个具体的例子慢慢理解它：
1.矩阵连乘
给定n个可连乘的矩阵{A1, A2, …,An}，根据矩阵乘法结合律，可有多种不同计算次序，每种次序有不同的计算代价，也就是数乘次数。例如给定2个矩阵A[pi,pj]和B[pj,pk]，A×B为[pi,pk]矩阵，数乘次数为pi×pj×pk。将矩阵连乘积Ai…Aj简记为A[i:j] ，这里i≤j。考察计算A[i:j]的最优计算次序，设这个计算次序在矩阵Ak和Ak+1之间将矩阵链断开，i≤k<j，则A[i:j]的计算量=A[i:k]的计算量+A[k+1:j]的计算量+A[i:k]和A[k+1:j]相乘的计算量。计算A[i:j]的最优次序所包含的计算矩阵子链A[i:k]和A[k+1:j]的次序也是最优的。即矩阵连乘计算次序问题的最优解包含着其子问题的最优解，这种性质称为最优子结构性质，问题具有最优子结构性质是该问题可用动态规划算法求解的显著特征。POJ1651就是一道具有类似思想的题目。题目大意是给出N个数，每次从中抽出一个数(第一和最后一个不能抽)，该次的得分即为抽出的数与相邻两个数的乘积。一直这样将每次的得分累加直到只剩下首尾两个数为止，问最小得分。
AC代码：

#define maxn 105
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int dp[maxn][maxn],a[maxn]; 
 
int main()
{
    int n;
    cin>>n;
    int i,j,k,len;
    memset(dp,0,sizeof(dp)); 
    //len是设置步长,也就是j减i的值 
    for(i=0;i<n;i++) cin>>a[i];
    for(i=0;i<n-2;i++) dp[i][i+2]=a[i]*a[i+1]*a[i+2];
    //如果只有三个数就直接乘起来 
    for(len=3;len<n;len++)
    {
        for(i=0;i+len<n;i++)
        {	
			j=i+len;
            for(k=i+1;k<j;k++)
			{
				if(dp[i][j]==0) dp[i][j]=dp[i][k]+dp[k][j]+a[i]*a[k]*a[j];
			 	else dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]+a[i]*a[k]*a[j]);
            }
        }
    }
    cout<<dp[0][n-1]<<endl;
}

2.走金字塔
给定一个由n行数字组成的数字三角型，如图所示。设计一个算法，计算从三角形的顶至底的一条路径，使该路径经过的数字总和最大。路径上的每一步都只能往左下或右下走，给出这个最大和。
        7 
      3  8 
    8  1  0 
  2  7  4  4 
4  5  2  6  5
这个问题来源于POJ1163。对于这种问题，我们可以有正向和反向两种思考方式。正向思考这个问题，dp[i][j]表示从第一行第一列到第i行第j列最大的数字总和；反向思考这个问题，dp[i][j]表示从第i行第j列到最后一行最大的数字总和。反向思考的代码要简洁一些，在POJ上这两份代码所用时间都是32MS。当然我们还可以对空间再进行优化，这里就不再细说了。
AC代码：

#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int triangle[110][110],dp[110][110];
 
int main()
{
	int N;
	cin>>N;
	memset(dp,0,sizeof(dp));
	memset(triangle,0,sizeof(triangle));
	for(int i=1;i<=N;i++)
	{
		for(int j=1;j<=i;j++)
		{
			cin>>triangle[i][j];
		}
	}
	dp[1][1]=triangle[1][1];
	for(int i=2;i<=N;i++)
	{
		for(int j=1;j<=i;j++)
		{
			if(j!=1) dp[i][j]=max(dp[i][j],dp[i-1][j-1]+triangle[i][j]);
			if(j!=i) dp[i][j]=max(dp[i][j],dp[i-1][j]+triangle[i][j]);
		}
	}
	int max=-1;
	for(int i=1;i<=N;i++)
	{
		if(dp[N][i]>max) max=dp[N][i];
	}
	cout<<max<<endl;
}

#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int triangle[110][110],dp[110][110];
 
int main()
{
	int N;
	cin>>N;
	memset(dp,0,sizeof(dp));
	memset(triangle,0,sizeof(triangle));
	for(int i=1;i<=N;i++)
	{
		for(int j=1;j<=i;j++)
		{
			cin>>triangle[i][j];
		}
	}
	for(int i=1;i<=N;i++)
	{
		dp[N][i]=triangle[N][i];
	}
	for(int i=N-1;i>=1;i--)
	{
		for(int j=1;j<=i;j++)
		{
			dp[i][j]=max(dp[i+1][j]+triangle[i][j],dp[i+1][j+1]+triangle[i][j]);
		}
	}
	cout<<dp[1][1]<<endl;
}

转载来源：https://blog.csdn.net/qq_32400847/article/details/51148917

---