动态规划模板总结

动态规划:

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

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

试用情况:

  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]
  • 16
    点赞
  • 75
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值