动态规划问题总结

最新推荐文章于 2022-10-26 12:59:07 发布
最新推荐文章于 2022-10-26 12:59:07 发布
阅读量249 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_39373577/article/details/99754240

一、
鉴别：题目里有最优、最长、最大、最小、计数等字眼，要考虑是否是DP问题

二、解决思路
将原问题拆解成子问题

  1. 所有的动归问题基本都可以使用递归求解（想象斐波那契数列），寻找递推公式，这里的设计要考虑无效性，即如果我走了当前这一步，会造成什么后果（比如下一步不能走）。
  2. 但是利用递归会出现大量的冗余计算，这时要想着怎么优化问题——去冗余（一般问题都是离散的，这样把之前计算的结果保存到数组、二维数组、map等数据结构中，就可以防止重复计算）
  3. 递归是自顶向下计算，从n推到0，可以使用循环（自底向上）从0推到N设计，避免递归。

三、经典题

  • 斐波那契数列（上台阶）
  • 机器人在棋盘中的路径
#include <iostream>
#include <vector>
using namespace std;
int uniquePaths(int m, int n);
int main()
    {
        int a=2,b=4;
       int r= uniquePaths(a,b);
        cout<<r<<endl;
    }

int uniquePaths(int m, int n)
{
    int res[m][n];
    res[0][0]=1;
    for(int i=0;i<m;i++)
        res[i][0]=1;
    for(int i=1;i<n;i++)
    {
        res[0][i]=1;
    }
    for(int i=1;i<m;i++)
    {
        for(int j=1;j<n;j++)
        {
            res[i][j]=res[i-1][j]+res[i][j-1];
            if(j==1d&&i==1)
                res[i][j]=0;
        }
    }
    return res[m-1][n-1];
}
  • 排列组合
  • 01背包
#include<iostream>
using namespace std;


int main()
{
    int N,V;
    cin>>N>>V;
    int weight[N];
    int vaule[N];
    for(int i=1;i<=N;i++)
      cin>>weight[i]>>vaule[i];
    int f[N+1][V+1];
    for(int i=0;i<=N;i++)
    {
        for(int j=0;j<=V;j++)
        {
            f[i][j]=0;
        }
    }
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=V;j++)
        {
            f[i][j]=f[i-1][j];
            if(j>=weight[i])
            f[i][j]=max(f[i][j],f[i-1][j-weight[i]]+vaule[i]);
        }
        
    }
    cout<<f[N][V];
}
   //////空间复杂度N*V,时间复杂度N*V
   
/****************************************************************/
优化空间复杂度的办法，用一个一维数组存储状态 （通用解法，使用滚动数组）
#include<iostream>
using namespace std;


int main()
{
    int N,V;
    cin>>N>>V;
    int weight[N];
    int vaule[N];
    for(int i=1;i<=N;i++)
      cin>>weight[i]>>vaule[i];
    int f[V+1];
        for(int j=0;j<=V;j++)
        {
            f[j]=0;
        }
    
    for(int i=1;i<=N;i++)
    {
        for(int j=V;j>=weight[i];j--)
        {
            f[j]=max(f[j],f[j-weight[i]]+vaule[i]); ////改成一维数组
        }
        
    }
    cout<<f[V];
}
  • 完全背包问题（leedcode322）
    在这里插入图片描述
    完全背包问题有一个套路魔板
int main()
{
    int N,V;
    cin>>N>>V;
    int weight[N];
    int vaule[N];
    for(int i=1;i<=N;i++)
      cin>>weight[i]>>vaule[i];
    int f[V+1];
        for(int j=0;j<=V;j++)
        {
            f[j]=0;
        }
    
    for(int i=1;i<=N;i++)
    {
    /*******************************************************************************************
     ///主要的不同就在这里,就是01背包的起始范围反转一下,为什么这样做呢？原因是由于范围是从weight[i]~V,从小到
    ///到大运行，这样f[j-weight[i]（因为在j之前）在本次循环里就算过了，f[j-weight[i]]这个状态的意义是总数为j-weight[i]
    时，可能的最值，这里可能已经包含了若干个i物品，因为发f[j-weight]这个状态，是在第i次循环里面得到的。从而实现了
    一个i可以被取多次的条件。
    *************************************************************************************************/
        for(int j=weight[i];j<=V;j++) 
        {
            f[j]=max(f[j],f[j-weight[i]]+vaule[i]); ////改成一维数组
        }
        
    }
    cout<<f[V];
}

////复杂度较高的直观写法
 #include<iostream>
using namespace std;


int main()
{
    int N,V;
    cin>>N>>V;
    int weight[N];
    int vaule[N];
    for(int i=1;i<=N;i++)
        cin>>weight[i]>>vaule[i];
    int dp[V+1];
    
        for(int j=0;j<=V;j++)
            dp[j]=0;
    
    
    for(int i=1;i<=N;i++)
    {
        for(int j=V;j>=0;j--)  ///从后往前便利是为了变一维数组时，用到的是i-1时刻的状态
        {
            for(int k=0;k<=j/weight[i];k++)
            {
                dp[j] = max(dp[j], dp[j-weight[i]*k] + k*vaule[i]);
            }
        }
    }
    cout<< dp[V]<<endl;
    return 0;
}
  • 多重背包问题
    多重背包是限制单个物品个数的完全背包问题，其实就是在01背包上在套一个循环用来限制单个物体的取样次数。
#include<iostream>
using namespace std;
int main()
{
    int N,V;
    cin>>N>>V;
    int weight[N];int value[N];int count[N];
    for(int i=0;i<N;i++)
        cin>>weight[i]>>value[i]>>count[i];
    int dp[V+1];
    for(int i=0;i<V+1;i++)
        dp[i]=0;
    for(int i=0;i<N;i++)
    {
        for(int j=V;j>=0;j--)
        {
            for(int k=0;(k<=count[i])&&(k*weight[i]<=j);k++)
               dp[j]=max(dp[j],dp[j-k*weight[i]]+k*value[i]);  ////这里比01背包多加了一层循环，用来约束单个物体的取样次数问题
        }
    }
    cout<<dp[V];
    return 0;
}

优化解法（二进制优化）
多重背包的解法出现了三层循环，可以优化成两层循环，具体的优化思想是，每个物体可以取s次，可以把这s次当成一样的s个独立的物体，这样，多重背包问题就转化成了01背包问题，但是这里面有一个问题，就是将每个物体很多次这个事儿看成独立的物体，s的总次数如果比较多，就会出现较高的复杂度，于是使用取log的方式优化，举个例子，物体a可以选10次
那么现在把10拆分:
10=1+2+4 10-(1+2+4)=3 那么现在将10分成1,2,4,3这四组，我们可以发现，这四组，0~10都可以由这4个数通过某种方式组合得到，所以10次现在就等价于1,2,4,3次，这样就把原本需要拆分10次的问题变成了拆分4次，降低了时间消耗。

#include<iostream>
#include<vector>
using namespace std;
int main()
{
    struct Good
    {
        int w,v;
    };
    vector<Good> Goods;
    int N,V;
    cin>>N>>V;
    int dp[V+1];
    for(int i=0;i<V+1;i++)
      dp[i]=0;
    for(int i=0;i<N;i++)
    {
        int w,v,s;
        cin>>w>>v>>s;
        for(int k=1;k<=s;k*=2)
        {
            s-=k;
            Goods.push_back({w*k,v*k});
        }
        if(s>0)
            Goods.push_back({w*s,v*s});
    }
    for(auto i:Goods)
    {
        for(int j=V;j>=i.w;j--)
        {
            dp[j]=max(dp[j],dp[j-i.w]+i.v);
        }
        
    }
    cout<<dp[V];
    return 0;

}

优化解法2（单调队列解法） ///先放一放，去看看滑动窗口。。。

- 混合背包问题
第一类物品只能用1次
第二类物品可以用无限次
第三类物品可以用多次
混合背包问题其实就是01背包、完全背包、多重背包的组合题，只需要根据条件带入不同的情况就行了

时间复杂度较高的写法（主要是因为多重背包问题造成的，可以使用二进制优化）

#include<iostream>
using namespace std;
int main()
{
    int N,V;
    cin>>N>>V;
    int dp[V+1];
    /*struct Thing
    {
        int kind;
        int w;
        int V;
    };*/
    for(int i=0;i<V+1;i++)
        dp[i]=0;
    for(int i=0;i<N;i++)
    {
        int w,v,s;
        cin>>w>>v>>s;
        if(s==-1)
        {
            for(int j=V;j>=w;j--)
                dp[j]=max(dp[j],dp[j-w]+v);
        } 
        else if(s==0)
        {
            for(int j=w;j<=V;j++)
            {
                dp[j]=max(dp[j],dp[j-w]+v);
            }
        }
        else
            for(int j=V;j>=0;j--)
            {
                for(int k=0;k*w<=j&&k<=s;k++)
                    dp[j]=max(dp[j],dp[j-k*w]+k*v);
            }
    }
     cout<<dp[V];
        return 0;
}

二进制优化（把所有的数据放一个结构体里）

#include<iostream>
#include<vector>
using namespace std;
int main()
{
    int N,V;
    cin>>N>>V;
    int dp[V+1];
    struct Thing
    {
        int w;
        int v;
        int kind;
    };
    vector<Thing>Things;
    for(int i=0;i<V+1;i++)
        dp[i]=0;
    for(int i=0;i<N;i++)
    {
        int w,v,s;
        cin>>w>>v>>s;
        if(s==-1)
        {
            Things.push_back({w,v,s});
        }
        else if(s==0)
        {
            Things.push_back({w,v,s});
        }
        else
        {
            for(int k=1;k<=s;k*=2)
            {
                s-=k;
                Things.push_back({k*w,k*v,-1});
            }
            if(s>0)
                Things.push_back({s*w,s*v,-1});
        }
    }
    for(auto i:Things)
    {
        if(i.kind==-1)
        {
            for(int j=V;j>=i.w;j--)
                dp[j]=max(dp[j],dp[j-i.w]+i.v);
        }
        else
        {
            for(int j=i.w;j<=V;j++)
            {
                dp[j]=max(dp[j],dp[j-i.w]+i.v);
            }
        }
    }
     cout<<dp[V];
        return 0;
}
  • 二维背包问题
    一个物体不仅有体积，还有重量
    用一个二维数组保存状态dp[j][k]表示j体积，k重量下的最大值
#include<iostream>
using namespace std;
int main()
{
    int N,V,M;
    cin>>N>>V>>M;
    int dp[V+1][M+1];
    for(int i=0;i<V+1;i++)
    {
        for(int j=0;j<M+1;j++)
        dp[i][j]=0;
    }
    for(int i=0;i<N;i++)
    {
        int w,m,v; ///体积、重量、价值
        cin>>w>>m>>v;
        for(int j=V;j>=w;j--)
        {
            for(int k=M;k>=m;k--)
                dp[j][k]=max(dp[j][k],dp[j-w][k-m]+v);
        }
    }
    cout<<dp[V][M];
    return 0;

}
  • 分组背包问题

分组背包问题是把物体分成若干组，每一组里只能选一个物体
比如当前循环到了第i组，需要从第i组中挑出一个物体
for(int a=0;a<第i组的物体个数;a++)
{
for(j=V;j>a这个物体的体积;j++) ////这里能体现出同一组物体之间的互斥关系
dp[j]=max{dp[j],dp[j-a的体积]+a的价值
}

#include<iostream>
using namespace std;
int main()
{
    int N,V;
    cin>>N>>V;
    int dp[V+1];
    for(int i=0;i<V+1;i++)
        dp[i]=0;
    int weight[101]{0};
    int value[101]{0};
    for(int i=0;i<N;i++)
    {
        int a; ///某组有几个物品
        cin>>a;
        for(int j=0;j<a;j++)
        {
           cin>>weight[j]>>value[j];
        }
        for(int k=V;k>=0;k--)
        {
            for(int r=0;r<a;r++)
            {
                if(weight[r]<=k)
                 dp[k]=max(dp[k],dp[k-weight[r]]+value[r]);
            }
               
        }
    }
    cout<<dp[V];
    return 0;
}
  • 背包问题求方案数
    最优选择一共有多少种不同的方案
#include<iostream>
using namespace std;
int main()
{
    int mod=100000007;
    int N,V;
    cin>>N>>V;
    int f[V+1];  
 /*****************************************************************************
注意这里与01背包的区别，01背包的f数组表示体积小于等于j时的最大价值，但是j并不一定全用了，比如体积是10的时候最大价值是5，但是可能在体积是9的时候最大价值就已经是5了，体积是10的时候的最大价值
其实和体积为9的时候是一样的。那么，如何让数组f[j]表示的是正好体积是j的时候的方案数呢？在初始化f[j]
数组的时候，如果f[0]等于0，其他的都初始化为负无穷，这样所有的状态都是从f[0]转换过来的，这样就可以
了。
如果像01背包那样，需要把f[0]数组全部初始化为0
************************************************************************************/
    int g[V+1]; ///开一个g数组，表示最大价值正好是j时，总的方案数是多少
    for(int i=0;i<V+1;i++)
    {
        f[i]=INT32_MIN;
        g[i]=0;
    }
    g[0]=1;
    for(int i=0;i<N;i++)
    {
        int w,v;
        cin>>w>>v;
        for(int j=V;j>=w;j--)
        {
            int t=max(f[j],f[j-w]+v);
            int s=0;
            if(t==f[j]) s=s+g[j];
            if(t==f[j-w]+v) s=s+g[j-w]; ////看t是从哪个状态转移过来的
            if(s>=mod) s-=mod;
            f[j]=t;
            g[j]=s;
        }
    }
    int maxv=0;
    for(int i=0;i<=V;i++)
    {
        maxv=max(maxv,f[i]);  ///找出最优的方案
    }
    int res=0;
    for(int i=0;i<=V;i++)
    {
        if(f[i]==maxv)
        {
            res+=g[i];     ////统计最优方案的方案种数
            if(res>=mod)res-=mod;
        }
    }
    cout<<res;
    return 0;
}
  • 求背包问题的一个具体方案（输出字典排序最小的一个）
#include <iostream>
using namespace std;
int main() {
    int N, V;
    cin >> N >> V;
    int w[N + 1];
    w[0] = 0;
    int v[N + 1];
    v[0] = 0;
    int dp[N + 2][V + 2];
    for (int i = 0; i < N + 2; i++) {
        for (int j = 0; j < V + 2; j++)
            dp[i][j] = 0;
    }
    for (int i = 1; i < N + 1; i++) {
        cin >> w[i] >> v[i];
    }
////从第N个物品开始取，直到取到第一个物体，为什么这么取呢，因为我们想要字典排序最小的输出，所以比
如我们需要先确定第一个物体要不要选，如果要选，把他输出出来，而不是先找第N个物体要不要选。
    for (int i = N; i >=1; i--) {
        for (int j = 0; j <= V; j++) {
            dp[i][j] = dp[i+1][j];
            if (j >= w[i])
                dp[i][j] = max(dp[i][j], dp[i+1][j - w[i]] + v[i]);
        }
    }
    int vol=V;
    for(int i=1;i<=N;i++) 
    {
        if(vol>=w[i]&&dp[i][vol]==dp[i+1][vol-w[i]]+v[i])
        {
            cout<<i<<" ";
            vol-=w[i];
        }
    }
    return 0;
}
书生落拓
关注
直击高频编程考点：动态规划经典算法题总结
张彦峰的博客
04-20 4万+
动态规划基本理解分析以及应用举例，同时给出高频笔试考题解法分析和代码展示验证（最大子序和、最长上升子序列、最长公共子序列、最大子数组乘积、分割整数的最大乘积、最长有效括号、不同路径、最小路径和、最大矩形、0-1背包问题、编辑距离、单词拆分、爬楼梯、打家劫舍、强盗抢劫环形街区、股票买卖问题、最佳买卖股票时机含冷冻期、找零钱的最少硬币数、从起点到终点的最小路径数等）
各种动态规划问题(DP)的整理和归纳，超详细的！千万不要只看一眼哦
12-12
各种动态规划问题(DP)的整理和归纳，超详细的！千万不要只看一眼哦，不下，是你的损失！至少下载下来看看是否是超详细和完整！里面有树形DP，状态压缩DP，插头DP，经典的背包问题等，超完整的！
Note: 动态规划问题总结
琉璃的博客
05-07 262
动态规划不是一个具体的算法，而是一种思想。 这种思想具体的就是 从局部最优解采用一定策略推导出全局最优解，从子问题的答案中一步步推出整个问题的答案。 解决动态规划问题通常采用四个步骤： 问题拆解（找到问题的子问题） 状态定义（使当前状态就是当前问题的解） 写出递推方程（之前相邻子问题的答案推出当前状态的答案） 代码实现 通过几个题目去理解动态规划和这四个步骤。 三角形最小路径和问题 ...
C++之动态规划问题汇总
最新发布
03-05
### C++ 动态规划问题汇总 #### 一、引言 动态规划（Dynamic Programming，简称 DP）是一种解决多阶段决策过程最优化问题的方法。它适用于具有重叠子问题和最优子结构特性的问题。本篇文章主要针对 LeetCode 中一些...
常见动态规划问题总结
05-17
1.三角形找一条从顶到底的最小路径 2.最大子数组和 3.回文最小划分次数 4.最佳时间买卖股票 5. 判断字符串s3是否由s1,s2交叉存取组成 6.给定一个矩形表格，求从顶到底的最小和 7.使两个字符串相等，最小的编辑次数 ...
动态规划法求解0-1背包问题实验报告.pdf
06-05
总结来说，动态规划法求解0-1背包问题的关键在于构建正确的状态转移方程，并通过填表的方式逐步计算出所有子问题的最大价值。这种思想不仅可以应用于背包问题，还可以广泛应用于其他优化问题，如最长公共子序列、...
动态规划问题总结（部分）
weixin_51525912的博客
04-03 288
动态规划相关问题一、最长公共子序列二、子集和问题三、线性动态规划利润 一、最长公共子序列 1、最长公共子序列的定义： 一个序列T，如果分别是两个或两个以上的序列的子序列，且是符合条件最长的，则称T为已知序列的最长公共子序列。*（注：子序列为字符串中不一定连续但先后顺序一致的n个字符）* 2、解决最长公共序列问题采用的是填表的方法 用dp[i][j] 表示X m和Yn 的最长公共子序列的长度，dp[m][n] 就是答案。分三种情况 （1）0 （i= 0，j = 0，X，Y序列有一个空序列）
动态规划问题总结【学习中】
Leonuoa7的博客
05-28 408
动态规划的问题总结，包括例题和解法。例题来源Leetcode和Lintcode
动态规划问题小结
imuzimjh的博客
04-23 111
一.背包问题 有三种硬币，面值分别为2,5,7元，现有一本书为27元，问最少用几枚硬币可以买下这本书？并输出所使用的硬币 思路： 凑出x块钱所需硬币数量为f[x]=min{f[x-2],f[x-5],f[x-7]} #include<bits/stdc++.h> using namespace std; int t=0; int coin[10],a[27]={0}; int f[27];//凑成x块钱需要的硬币数 void fun(int m){ coin[0]=2,coin
经典动态规划问题总结
zjwson的博客
08-16 749
动态规划引入 首先我们以一个最基本的例子来分析——菲波那切数列。 我们都知道，菲波那切数列的递推公式f(n) = f(n-1)+f(n-2) （这里我就说明一般情况，不列举边界条件了），很简单，如果我们用递归的方法来求解f(n)，两三行代码就出来了。那么我们深入分析一下这样有什么问题？ f(2) = f(1) + f(0); f(3) = f(2) + f(1); f(4) = f(
动态规划问题个人总结
一名渣程序员的无厘头记录
09-19 415
参考： http://www.hawstein.com/posts/dp-novice-to-advanced.html http://blog.youkuaiyun.com/a45872055555/article/details/29224177参考文章给出的内容很详细了，我仅为个人学习理解写下该文，详细内容可查看参考文章。 动态规划：从新手到专家动态规划（ Dynamic Programming，简
动态规划——系列问题总结（持续更新）
weixin_30533797的博客
03-19 233
一、理解动态规划 下面先总结一下我从上述两位知乎网友的回答中收获的心得： 把问题描述的更”IT“一些，也就是用更接近数学和计算机的语言来把原来的实际问题抽象化，这样很有利于我们用更清晰的思路去解决问题 在上述进一步抽象的问题描述中找准状态和状态之间的转化关系 关于上面说的几种算法思想的区分，这里引用一下上述知乎网友@王勐的回答： 每个阶段只有一个状态—>递推（例...
动态规划总结
qq_43808588的博客
09-19 235
动态规划的的四个解题步骤是： 定义子问题 写出子问题的递推关系 确定 DP 数组的计算顺序 空间优化（可选） 1、重点还是状态转移矩阵的问题。找出转移矩阵，矩阵的含义就是题目要求的含义。找出dp[i]与dp[i-1].dp[i-2]等前态的关系。或者二维数组 稍微接触过一点动态规划的朋友都知道动态规划有一个“子问题”的定义。什么是子问题？子问题是和原问题相似，但规模较小的问题。例如这道小偷问题，原问题是“从全部房子中能偷到的最大金额”，将问题的规模缩小，子问题就是“从 kk 个房子中能偷到的最大金
动态规划的一些思考和总结
m0_57225567的博客
10-26 610
学习《labuladong的算法秘籍》中的动态规划部分产生的一些思考和总结，分为核心思想、经典问题和背包问题三部分来展开。
leetcode 系列之-动态规划题型总结
weixin_39802680的博客
09-09 926
动态规划问题一般性总结 动态规划题目通常用于解决计数类问题。常见有线性DP，区间DP，背包问题等。解决背包问题通常要明白下面几点。 属性：Max / Min /数量 动态规划问题最终通常让求解某一问题的最大值，最小值，数量。出现这几个字段，我们就要考虑是否应用动态规划能够解决该问题。 比如说： 最大连续子序列和，最长不下降子序列。 状态表示： 解决动态规划问题的一个关键点就是 状态表示，状态表示根据问题而变化，最终能求出问题的最优解。状态表示的本质就是记录子问题的解，来避免下次遇到相同子问题重复计算。比
LeetCode挑战：力码动态规划问题汇总
在给出的日期和题目列表中，很多问题都可以运用动态规划的方法来解决。 3. **算法题目与难度等级**: 在标题中提到了“猜单词leetcode”，这可能是对Leetcode的一种戏称，暗指在Leetcode上解决算法题目有时像是在猜...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值