动态规划模板总结

动态规划：

通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。

动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。

试用情况：

1. 最优子结构性质。如果问题的最优解所包含的子问题的解也是最优的，我们就称该问题具有最优子结构性质（即满足最优化原理）。最优子结构性质为动态规划算法解决问题提供了重要线索。
2. 无后效性。即子问题的解一旦确定，就不再改变，不受在这之后、包含它的更大的问题的求解决策影响。
3. 子问题重叠性质。子问题重叠性质是指在用递归算法自顶向下对问题进行求解时，每次产生的子问题并不总是新问题，有些子问题会被重复计算多次。动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只计算一次，然后将其计算结果保存在一个表格中，当再次需要计算已经计算过的子问题时，只是在表格中简单地查看一下结果，从而获得较高的效率。

具体还是要根据具体问题分析

一，01背包

有N件物品和一个容量为V的背包。第i件物品的重量是w[i]，价值是c[i]。求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。

关键是找出状态方程组，可知为dp[i][j]=max(dp[i-1][ j ],dp[i-1][j-w[i] ]+c[i])，所以可以写出代码

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int dp[3405][13000],c[3405],w[3405];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i)
        scanf("%d%d",&w[i],&c[i]);
    memset(dp,0,sizeof(dp));
    for(int i=1;i<=n;++i)
    {
        for(int j=1;j<=m;++j)
        {
            if(j<w[i])
                dp[i][j]=dp[i-1][j];
            else
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+c[i]);
        }
    }
    printf("%d\n",dp[n][m]);
    return 0;
}

然而可不可以优化一下呢，答案是可以的，可以考虑将其换成一维数组，即

dp[ j ]=max(dp[ j ],dp[ j-w[i] ]+c[i] );

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int dp[13000],c[3405],w[3405];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i)
        scanf("%d%d",&w[i],&c[i]);
    memset(dp,0,sizeof(dp));
    for(int i=1;i<=n;++i)
    {
        for(int j=m;j>=w[i];--j)
        {
                dp[j]=max(dp[j],dp[j-w[i]]+c[i]);
        }
    }
    printf("%d\n",dp[m]);
    return 0;
}

这样就可以简化算法了。

附加：

01背包计数

    dp[0] = 1;
    for(int i = 1; i <= n; ++i)
    {
        for(int j = sum; j >= a[i]; --j)
        {
            dp[j] = (dp[j] + dp[j - a[i]]);
        }
    }

完全背包计数

    dp[0] = 1;
    for(int i = 1; i <= n; ++i)
    {
        for(int j = a[i]; j <= sum; ++j)
        {
            dp[j] = (dp[j] + dp[j - a[i]]);
        }
    }

 

二：最长公共子序列

给定两个字符串，寻找这两个字串之间的最长公共子序列。

可知其状态方程为

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<math.h>
using namespace std;
int dp[1001][1001];
int main()
{
    string a,b;
    cin>>a>>b;
    memset(dp,0,sizeof(dp));   //初始化0
    for(int i=1;i<=a.length();++i)
    {
        for(int j=1;j<=b.length();++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.length()][b.length()];
    return 0;
}

但此方程无法求出序列，需要另设一个数组c[ i ][ j ],这样就可以记录dp数组的值来源，然后就可以回溯找到序列

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<math.h>
using namespace std;
const int maxn=1002;
int dp[maxn][maxn],c[maxn][maxn];
string a,b;
void LCS( )
{
    for(int i=1;i<=a.length();++i)
    {
        for(int j=1;j<=b.length();++j)
        {
            if(a[i-1]==b[j-1])
            {
                dp[i][j]=dp[i-1][j-1]+1;
                c[i][j]=1;
            }
            else if(dp[i][j-1]>=dp[i-1][j])
            {
                dp[i][j]=dp[i][j-1];
                c[i][j]=2;
            }
            else
            {
                dp[i][j]=dp[i-1][j];
                c[i][j]=3;
            }
        }
    }
}
void print(int i,int j)
{
    if(i==0 || j==0)
        return;
    if(c[i][j]==1)
    {
        print(i-1,j-1);
        cout<<a[i-1];
    }
    else if(c[i][j]==2)