基础dp学习

Clarence Liu

已于 2022-08-26 12:37:55 修改

阅读量324

点赞数

分类专栏： # DP 文章标签：算法 c++ 动态规划

于 2021-01-25 00:00:47 首次发布

本文链接：https://blog.csdn.net/roadtohacker/article/details/113093914

版权

DP 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

基础动态规划

引入
- 硬币找零问题
0-1背包
- 滚动数组
完全背包
- 滚动数组
多重背包

引入

有这样一个问题：楼梯有N阶，可以一步上1阶，也可以上2阶，问N阶楼梯有多少种走法
题目链接洛谷P1225

如果用搜索的方法，每次有两种方法，那么增长速度是指数级的，时间复杂度很大
那么可以这样考虑，如何才能走到第N阶楼梯呢？，只能从第N-1阶上1阶或者从第N-2阶上2阶得到，也就是说dp[N]=dp[N-1]+dp[N-2]，这其实是一种动态规划（Dynamic Programming，DP）的思想，把一个大问题分解成许多小问题，通过求解小问题得到大问题的解，所得到的方程就是动态规划的状态转移方程，那么对于这道题编写程序如下

这道题后面答案比较大，需要高精度处理，为了规避这个不必要的麻烦，使用python

n = int(input())
dp = list()
dp.append(0)
dp.append(1)
dp.append(2)
for i in range(3, n + 1):
    dp.append(dp[i - 1] + dp[i - 2])
print(dp[n])

通过上面的问题，我们对于动态规划有了初步的认识，接下来深入研究一下

硬币找零问题

这也是一种动态规划的问题，比如有N块钱，现在有5种不同面值的硬币，分别为1， 5， 10 ，25， 50，问找零方案有多少种
其实通过上面楼梯问题可以感觉到，硬币找零是一种变相的楼梯问题，可以通过递推得到答案，比如开始的时候是1块钱，那么1块钱只有一种方案，那么1块钱可以转移到2，6，11，26，51块钱，方案数都是相对于1块钱时+1，那么可以编写程序如下

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <stack>
#include <map>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int MAXN = 2e5+100;
int Data[MAXN];
int coins[5] = {1, 5, 10, 25, 50};
int dp[MAXN];
int main(){
    int n;
    cin>>n;
    dp[0] = 1;
    for(int i=0;i<5;i++){
        for(int j=coins[i];j<=n;j++){
            dp[j] += dp[j - coins[i]];
        }
    }
    cout<<dp[n];
    return 0;
}

hdu2069
这道题就是上个问题的加强版，现在加了一个条件，硬币数量现在有限，问方案数

再用上面的程序就是不对的，因为上面程序适用于硬币数量无限的情况，因为它太简略了，中间的信息都没有记录下来，现在使用一个二维数组来dp，第一维含义是钱数，第二维是硬币数，与上一程序区别是dp的过程中少一个硬币，数组第二维-1，打表

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <stack>
#include <map>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int MAXN = 2e5+100;
int Data[MAXN];
int coins[5] = {1, 5, 10, 25, 50};
int dp[1000][1000];
int main(){
    int n;
    dp[0][0] = 1;
    for(int i=0;i<5;i++){
        for(int j=1;j<=100;j++){
            for(int k=coins[i];k<=250;k++){
                dp[k][j] += dp[k - coins[i]][j - 1];
            }
        }
    }
    for(int i=0;i<=100;i++){
        for(int j=0;j<=250;j++){
            Data[j] += dp[j][i];
        }
    }
    while(cin>>n) cout<<Data[n]<<endl;
    return 0;
}

0-1背包

这是最经典的dp问题，每个物品有自身价值，物品有体积，背包有容积，每个物品最多只能选择一次，问最多装多少价值的物品。一般背包问题是对于可切分的物体而言的，这种问题用贪心求解，按单位价值排序；01背包指的是类似于吃自助餐的场景，肚子容量有限，自助餐只能一份一份吃，不能分开，这个时候就需要考虑怎么吃能使得吃到肚子里的东西价值最大
题目链接
这个问题是01背包模板题，使用二维数组dp记录价值，第一维表示装第几个商品，第二维表示背包容量，那么dp[i][j]等于多少取决于b[i]和j之间的关系，如果b[i]>j，那么只能放弃第i个商品，也就是dp[i][j]=dp[i-1][j]；否则，可以装第i个商品，也可以不装，如果装，dp[i][j]=dp[i-1][j-b[i]]+b[i]，意思是背包容量减小，价值增加，如果不装，那么和上一种情况相同

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <stack>
#include <map>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int MAXN = 2e5+100;
int Data[MAXN];
int dp[1005][1005];
int a[MAXN],b[MAXN];
int main(){
    int t,n,v;
    cin>>t;
    while(t--){
        cin>>n>>v;
        for(int i=1;i<=n;i++) cin>>a[i];
        for(int i=1;i<=n;i++) cin>>b[i];
        for(int i=1;i<=n;i++){
            for(int j=0;j<=v;j++){
                if(j < b[i]) dp[i][j] = dp[i-1][j];
                else{
                    dp[i][j] = max(dp[i-1][j], dp[i-1][j-b[i]]+a[i]);
                }
            }
        }
        cout<<dp[n][v]<<endl;
    }
    return 0;
}

骨头体积可能为0，j要从0开始

滚动数组

这样使用数组是很占空间的，想办法优化空间复杂度，发现dp过程中是根据二维dp数组上一行推导下一行的，而且是从左往右，所以考虑使用一维数组，在推导的时候从后往前推导防止错误覆盖(如果正序相当于每一件物品可以选择多次)，将上一题改成滚动数组如下

int dp[1005];
int a[MAXN],b[MAXN];
int main(){
    int t,n,v;
    cin>>t;
    while(t--){
        cin>>n>>v;
        memset(dp, 0, sizeof dp);
        for(int i=1;i<=n;i++) cin>>a[i];
        for(int i=1;i<=n;i++) cin>>b[i];
        for(int i=1;i<=n;i++){
            for(int j=v;j>=b[i];j--){
                dp[j] = max(dp[j], dp[j - b[i]] + a[i]);
            }
        }
        cout<<dp[v]<<endl;
    }
    return 0;
}

完全背包

此问题和 $0 - 1$ 背包的区别在于物品可以选择无限次，那么我们可以通过枚举第 $i$ 件物品有多少件，即 $dp[i][j]=max_{k=0}^{\infty}(dp[i-1][j-k\times w_i]+v_i\times k)$
实际上 $d p [i] [j]$ 只需要从 $dp[i-1][j-w_i]$ 转移过来即可，可以发现和 $0 - 1$ 背包类似，有 $dp[i][j]=max_{k=0}^{\infty}(dp[i-1][j-w_i]+v_i)$
https://www.luogu.com.cn/problem/P1616

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main(){
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  int n, m;
  cin >> n >> m;
  vector<pair<int, ll> > a(m + 1);
  for(int i=1;i<=m;i++){
    cin >> a[i].first >> a[i].second;
  }
  vector<vector<ll> > dp(m + 1, vector<ll>(n + 1));
  for(int i=1;i<=m;i++){
    for(int j=0;j<=n;j++){
      dp[i][j] = dp[i - 1][j];// 注意这里必须要继承上一个状态
      if(a[i].first <= j){
        dp[i][j] = max(dp[i - 1][j], dp[i][j - a[i].first] + a[i].second);
      }
    }
  }
  cout << dp[m][n] << '\n';
  return 0;
}

滚动数组

因为转移是从此物品的第 $k - 1$ 个转移过来的，物品可以多次选择，所以需要正序枚举

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main(){
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  int n, m;
  cin >> n >> m;
  vector<pair<int, ll> > a(m + 1);
  for(int i=1;i<=m;i++){
    cin >> a[i].first >> a[i].second;
  }
  vector<ll> dp(n + 1);
  for(int i=1;i<=m;i++){
    for(int j=a[i].first;j<=n;j++){
      dp[j] = max(dp[j - a[i].first] + a[i].second, dp[j]);
    }
  }
  cout << dp[n] << '\n';
  return 0;
}

多重背包

https://www.acwing.com/problem/content/4/

这个问题和 $0 - 1$ 背包的区别是物品分类，每一类物品最多有若干个，其余相同。如果数据范围很小，可以直接转化为 $0 - 1$ 背包。就是把若干个相同物品当作独立的。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main(){
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  int n, V;
  cin >> n >> V;
  vector<int> s(n + 1), v(n + 1), w(n + 1);
  for(int i=1;i<=n;i++){
    cin >> v[i] >> w[i] >> s[i];
  }
  vector<vector<int> > dp(n + 1, vector<int>(V + 1));
  for(int i=1;i<=n;i++){
    for(int j=0;j<=V;j++){
      for(int k=0;k<=s[i] && j >= v[i] * k;k++){
        dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i] * k] + k * w[i]);
      }
    }
  }
  cout << dp[n][V];
  return 0;
}

二进制优化的思路是我们把每一个物品分成 $1,2,4,8,...2^k$ 这样若干份，使得枚举的 $k$ 大大减少，达到 $O (nV l o g k)$ ，这种思路的原理在于任何一个 $> 1$ 的自然数都能够拆成 $2$ 的幂次的形式。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main(){
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  int n, V;
  cin >> n >> V;
  vector<int> v, w;
  vector<int> dp(V + 1);
  for(int i=1;i<=n;i++){
    int a, b, c;
    cin >> a >> b >> c;
    int cnt = 1;
    while(cnt <= c){
      v.push_back(a * cnt);
      w.push_back(b * cnt);
      c -= cnt;
      cnt <<= 1;
    }
    if(c > 0){
      v.push_back(a * c);
      w.push_back(b * c);
    }
  }
  for(int i=0;i<(int)v.size();i++){
    for(int j=V;j>=v[i];j--){
      dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
    }
  }
  cout << dp[V] << '\n';
  return 0;
}

Clarence Liu

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
基础dp学习

基础动态规划引入硬币找零问题01背包问题引入有这样一个问题：楼梯有N阶，可以一步上1阶，也可以上2阶，问N阶楼梯有多少种走法题目链接洛谷P1225如果用搜索的方法，每次有两种方法，那么增长速度是指数级的，时间复杂度很大那么可以这样考虑，如何才能走到第N阶楼梯呢？，只能从第N-1阶上1阶或者从第N-2阶上2阶得到，也就是说dp[N]=dp[N-1]+dp[N-2]，这其实是一种动态规划（Dynamic Programming，DP）的思想，把一个大问题分解成许多小问题，通过求解小问题得到大问题的
复制链接

扫一扫