动态规划问题

最新推荐文章于 2023-11-21 15:34:50 发布
最新推荐文章于 2023-11-21 15:34:50 发布
阅读量55 收藏
点赞数
分类专栏： dp 文章标签： 动态规划 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43219250/article/details/125842696
版权

01背包问题

特点： 每件物品最多用一次，可以不用

N件物品，容量为V的背包。每件物品只能用一次。

朴素做法：

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int f[N][N];
int v[N], w[N];
int n, m;
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            f[i][j] = f[i - 1][j];
            if (j >= v[i]) f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);
        }
    }

    cout << f[n][m] << endl;
}

优化后的代码：

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int f[N];
int v[N], w[N];
int n, m;
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ ) cin >> v[i] >> w[i];

    for (int i = 1; i <= n; i++) {
        for (int j = m; j >= v[i]; j--) {
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }

    cout << f[m] << endl;
}

完全背包问题

每件物品有无限多个

朴素做法

//会超时
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
int f[N][N];
int v[N],w[N];
int n,m;
int main()
{
    cin>>n>>m;
    for(int i = 1;i<=n;i++) cin>>v[i]>>w[i];
    
    for(int i = 1;i<=n;i++)
        for(int j = 0; j <= m;j++)
            for(int k=0;v[i]*k<=j;k++)
            f[i][j] = max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
    cout<<f[n][m]<<endl;
    
    
    return 0;
}

优化算法（对比0-1背包的朴素做法）

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
int f[N][N];
int v[N],w[N];
int n,m;
int main()
{
    cin>>n>>m;
    for(int i = 1;i<=n;i++) cin>>v[i]>>w[i];
    
    for(int i = 1;i<=n;i++)
        for(int j = 0; j <= m;j++)
        {
            f[i][j] = f[i-1][j];
            if(j>=v[i]) f[i][j] = max(f[i][j],f[i][j-v[i]]+w[i]);
        }
            
    cout<<f[n][m]<<endl;
    
    
    return 0;
}

对比：

0-1背包朴素   f[i][j] = max(f[i-1][j], f[i - 1][j - v[i]] + w[i]);//上一层:从大到小遍历
完全背包双循环 f[i][j] = max(f[i-1][j], f[i][j-v[i]]+w[i]);//本层：从小到大遍历

继续优化成一维

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
int f[N];
int v[N],w[N];
int n,m;
int main()
{
    cin>>n>>m;
    for(int i = 1;i<=n;i++) cin>>v[i]>>w[i];
    
    for(int i = 1;i<=n;i++)
        for(int j = v[i]; j <= m;j++)
        {
            f[j] = max(f[j],f[j-v[i]]+w[i]);
        }
            
    cout<<f[m]<<endl;
    
    
    return 0;
}

思考：为什么0-1背包是从大到小遍历体积，而完全背包是从小到大遍历体积？

从m往前不会重复，从前往后可以重复多个物品

多重背包问题

每件物品有s[i]件

朴素版本

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 110;
int f[N][N];
int v[N],w[N],s[N];
int n,m;
int main()
{
    cin>>n>>m;
    for(int i = 1;i<=n;i++) cin>>v[i]>>w[i]>>s[i];
    
    for(int i = 1;i<=n;i++)
        for(int j =0 ;j<=m;j++)
            for(int k=0;k<=s[i] && k*v[i]<=j;k++)
                f[i][j] = max(f[i][j],f[i-1][j-v[i]*k]+w[i]*k);
            
    cout<<f[n][m]<<endl;
    
    
    return 0;
}

二进制优化为0-1背包求解

#include <iostream>
#include <algorithm>

using namespace std;
const int N = 22010;
int f[N];
int v[N],w[N];
int n,m;
int main()
{
    cin>>n>>m;
    int a,b,s,cnt;
    //打包
    for(int i=1;i<=n;i++) 
    {
        cin>>a>>b>>s;
        int k=1;
        while(k<=s)
        {
            cnt++;
            v[cnt] = k*a;
            w[cnt] = k*b;
            s -= k;
            k *= 2;
        }
        if(s<k)
        {
            cnt++;
            v[cnt] = a*s;
            w[cnt] = b*s;
        }
    }
    
    n = cnt;//按包更新物品总数
    //0-1背包问题
    for(int i = 1;i<=n;i++)
        for(int j=m;j>=v[i];j--)
            f[j] = max(f[j],f[j-v[i]]+w[i]);
    
    cout<<f[m]<<endl;
    
    return 0;
}

分组背包问题

把物品分成N组，每组有若干个，每组中最多只能选择一个

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

int n, m;
int v[N][N], w[N][N], s[N];
int f[N];

int main()
{
    cin >> n >> m;

    for (int i = 1; i <= n; i ++ )
    {
        cin >> s[i];
        for (int j = 0; j < s[i]; j ++ )
            cin >> v[i][j] >> w[i][j];
    }

    for (int i = 1; i <= n; i ++ )
        for (int j = m; j >= 0; j -- )
            for (int k = 0; k < s[i]; k ++ )
                if (v[i][k] <= j)
                    f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);

    cout << f[m] << endl;

    return 0;
}

线性dp

  1. 数字三角形
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 510;
int n;
int a[N][N],f[N][N];
int INF = 1e9;

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
            scanf("%d",&a[i][j]);
    
    for(int i = 0;i<=n;i++) //每行多初始化一个
        for(int j=0;j<=i+1;j++)
            f[i][j] = -INF;
    
    f[1][1] = a[1][1];
    
    for(int i=2;i<=n;i++) 
        for(int j=1;j<=i;j++)
            f[i][j] = max(f[i-1][j-1]+a[i][j],f[i-1][j]+a[i][j]);
    
    int res = -INF;
    for(int i=1;i<=n;i++)
        res = max(res,f[n][i]);
    
    printf("%d",res);
    
    
    return 0;
}

AcWing 895. 最长上升子序列

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n;
int a[N], f[N];

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &a[i]);

    for (int i = 1; i <= n; i ++ )
    {
        f[i] = 1; // 只有a[i]一个数
        for (int j = 1; j < i; j ++ )
            if (a[j] < a[i])
                f[i] = max(f[i], f[j] + 1);
    }

    int res = 0;
    for (int i = 1; i <= n; i ++ ) res = max(res, f[i]);

    printf("%d\n", res);

    return 0;
}

AcWing 896. 最长上升子序列 II（偏贪心）

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int n;
int a[N];//存储输入
int q[N];//存储每个长度结尾的最小值

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);

    int len = 0;
    for (int i = 0; i < n; i ++ )
    {
        int l = 0, r = len;
        while (l < r)
        {
            int mid = l + r + 1 >> 1;
            if (q[mid] < a[i]) l = mid;
            else r = mid - 1;
        }
        len = max(len, r + 1);//接a[i]后长度加1
        q[r + 1] = a[i];
    }

    printf("%d\n", len);

    return 0;
}

AcWing 897. 最长公共子序列

image-20220708103437545

00 包含在01和10中

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
char a[N], b[N];
int f[N][N];

int main()
{
    scanf("%d%d", &n, &m);
    scanf("%s%s", a + 1, b + 1);

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
        {
            f[i][j] = max(f[i - 1][j], f[i][j - 1]);
            if (a[i] == b[j]) f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);
        }

    printf("%d\n", f[n][m]);

    return 0;
}

AcWing 902. 最短编辑距离

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
char a[N], b[N];
int f[N][N];

int main()
{
    scanf("%d%s", &n, a + 1);//下标从1开始 因为有i-1 
    scanf("%d%s", &m, b + 1);

    for (int i = 0; i <= m; i ++ ) f[0][i] = i;
    for (int i = 0; i <= n; i ++ ) f[i][0] = i;

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
        {
            f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
            if (a[i] == b[j]) f[i][j] = min(f[i][j], f[i - 1][j - 1]);
            else f[i][j] = min(f[i][j], f[i - 1][j - 1] + 1);
        }

    printf("%d\n", f[n][m]);

    return 0;
}

AcWing 899. 编辑距离(应用上一题目)

#include <iostream>
#include <algorithm>
#include <string.h>

using namespace std;

const int N = 15, M = 1010; 

int n, m;
int f[N][N];   
char str[M][N];

int edit_distance(char a[], char b[])
{ 
    int la = strlen(a + 1), lb = strlen(b + 1);

    for (int i = 0; i <= lb; i ++ ) f[0][i] = i;
    for (int i = 0; i <= la; i ++ ) f[i][0] = i;

    for (int i = 1; i <= la; i ++ )
        for (int j = 1; j <= lb; j ++ )
        {
            f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
            f[i][j] = min(f[i][j], f[i - 1][j - 1] + (a[i] != b[j]));
        }

    return f[la][lb];
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i ++ ) scanf("%s", str[i] + 1);

    while (m -- )
    {
        char s[N];
        int limit;
        scanf("%s%d", s + 1, &limit);

        int res = 0;
        for (int i = 0; i < n; i ++ )
            if (edit_distance(str[i], s) <= limit)
                res ++ ;

        printf("%d\n", res);
    }

    return 0;
}

区间dp

AcWing 282. 石子合并

image-20220708111517145

用到前缀和

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AQlRGXxf-1658110437969)(…/…/AppData/Roaming/Typora/typora-user-images/image-20220708111309646.png)]

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 310;

int n;
int s[N];//前缀和
int f[N][N];

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &s[i]);

    for (int i = 1; i <= n; i ++ ) s[i] += s[i - 1];

    for (int len = 2; len <= n; len ++ )//长度
        for (int i = 1; i + len - 1 <= n; i ++ )//起点
        {
            int l = i, r = i + len - 1;
            f[l][r] = 1e8;
            for (int k = l; k < r; k ++ )
                f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);
        }

    printf("%d\n", f[1][n]);
    return 0;
}

核心代码

    for (int len = 2; len <= n; len ++ )//枚举长度
        for (int i = 1; i + len - 1 <= n; i ++ )//枚举起点
        {
            int l = i, r = i + len - 1;
            f[l][r] = 1e8;
            for (int k = l; k < r; k ++ )
                f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);

计数类dp

AcWing 900. 整数划分

image-20220716103453269 
看成背包体积为n ,物品体积1~n,物品无限多个，恰好装满背包的方案数
完全背包问题

完全背包解法

状态表示：
f[i][j]表示只从1~i中选，且总和等于j的方案数
状态转移方程:
f[i][j] = f[i - 1][j] + f[i][j - i];

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010, mod = 1e9 + 7;

int n;
int f[N];

int main()
{
    cin >> n;

    f[0] = 1;
    for (int i = 1; i <= n; i ++ )
        for (int j = i; j <= n; j ++ )
            f[j] = (f[j] + f[j - i]) % mod;

    cout << f[n] << endl;

    return 0;
}

其他解法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jEWmAFzj-1658110437970)(…/…/AppData/Roaming/Typora/typora-user-images/image-20220716160953719.png)]

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010, mod = 1e9 + 7;

int n;
int f[N][N];

int main()
{
    cin >> n;

    f[1][1] = 1;
    for (int i = 2; i <= n; i ++ )
        for (int j = 1; j <= i; j ++ )
            f[i][j] = (f[i - 1][j - 1] + f[i - j][j]) % mod;

    int res = 0;
    for (int i = 1; i <= n; i ++ ) res = (res + f[n][i]) % mod;

    cout << res << endl;

    return 0;
}

数位统计DP(翻车呜呜呜)

分情况讨论

AcWing 338. 计数问题

前缀和思想 转化

image-20220716163353091 image-20220718091711088 
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 10;

/*

001~abc-1, 999

abc
    1. num[i] < x, 0
    2. num[i] == x, 0~efg
    3. num[i] > x, 0~999

*/

int get(vector<int> num, int l, int r)
{
    int res = 0;
    for (int i = l; i >= r; i -- ) res = res * 10 + num[i];
    return res;
}

int power10(int x)
{
    int res = 1;
    while (x -- ) res *= 10;
    return res;
}

int count(int n, int x)
{
    if (!n) return 0;

    vector<int> num;
    while (n)
    {
        num.push_back(n % 10);
        n /= 10;
    }
    n = num.size();

    int res = 0;
    for (int i = n - 1 - !x; i >= 0; i -- )
    {
        if (i < n - 1)
        {
            res += get(num, n - 1, i + 1) * power10(i);
            if (!x) res -= power10(i);
        }

        if (num[i] == x) res += get(num, i - 1, 0) + 1;
        else if (num[i] > x) res += power10(i);
    }

    return res;
}

int main()
{
    int a, b;
    while (cin >> a >> b , a)
    {
        if (a > b) swap(a, b);

        for (int i = 0; i <= 9; i ++ )
            cout << count(b, i) - count(a - 1, i) << ' ';
        cout << endl;
    }

    return 0;
}

状态压缩DP

朴素算法

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 12, M = 1 << N;

int n, m;
long long f[N][M];
bool st[M];

int main()
{
    while (cin >> n >> m, n || m)
    {
        for (int i = 0; i < 1 << n; i ++ )
        {
            int cnt = 0;
            st[i] = true;
            for (int j = 0; j < n; j ++ )
                if (i >> j & 1)
                {
                    if (cnt & 1) st[i] = false;
                    cnt = 0;
                }
                else cnt ++ ;
            if (cnt & 1) st[i] = false;
        }

        memset(f, 0, sizeof f);
        f[0][0] = 1;
        for (int i = 1; i <= m; i ++ )
            for (int j = 0; j < 1 << n; j ++ )
                for (int k = 0; k < 1 << n; k ++ )
                    if ((j & k) == 0 && st[j | k])
                        f[i][j] += f[i - 1][k];

        cout << f[m][0] << endl;
    }
    return 0;
}

t main()
{
while (cin >> n >> m, n || m)
{
for (int i = 0; i < 1 << n; i ++ )
{
int cnt = 0;
st[i] = true;
for (int j = 0; j < n; j ++ )
if (i >> j & 1)
{
if (cnt & 1) st[i] = false;
cnt = 0;
}
else cnt ++ ;
if (cnt & 1) st[i] = false;
}

    memset(f, 0, sizeof f);
    f[0][0] = 1;
    for (int i = 1; i <= m; i ++ )
        for (int j = 0; j < 1 << n; j ++ )
            for (int k = 0; k < 1 << n; k ++ )
                if ((j & k) == 0 && st[j | k])
                    f[i][j] += f[i - 1][k];

    cout << f[m][0] << endl;
}
return 0;

}
工具人来了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
动态规划问题经典例题
dddddrrrzz的博客
02-23 7830
DP（Dynamic Programming）定义： 动态规划是分治思想的延伸，通俗一点来说就是大事化小，小事化无的艺术。在将大问题化解为小问题的分治过程中，保存对这些小问题已经处理好的结果，并供后面处理更大规模的问题时直接使用这些结果。 动态规划具备了以下三个特点： 把原来的问题分解成了几个相似的子问题。 所有的子问题都只需要解决一次。 储存子问题的解 动态规划的本质，是对问题状态的定义和状态转移方程的定义(状态以及状态
详解多种动态规划问题，看完必会动态规划
NZXHJ的博客
10-24 7153
如何解决动态规划问题？看完本文总结的解题模板，看完必会动态规划解题
【数据结构与算法】之动态规划经典问题
小新要变强的博客
11-11 5660
本文将对【数据结构与算法】动态规划经典问题相关介绍 ，具体将对最长递增子序列问题，找零钱问题，0-1背包问题相关动态规划算法问题进行详尽介绍~
动态规划-各种题型及思路整理（自用笔记，大神绕道）
关注网络安全、云原生安全
01-07 9671
简介： 动态规划(dynamic programming，简称dp)，是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。（没办法，其实算法就是数学，毕竟数学是基础学科，由数学支撑的学科太多太多） 分类： 动态规划一般可分为线性动规，区域动规，树形动规，背包动规四类。 举例： 线性动规：拦截导弹，合唱队形，挖地雷，建学校，剑客决斗等； 区...
C++动态规划问题大合集
01-21
本资源"01背包问题动态规划"聚焦于C++在解决经典动态规划问题上的应用，特别是01背包问题。 01背包问题是一个经典的计算机科学优化问题，其基本设定如下：我们有一个容量为W的背包，以及n个物品，每个物品都有一个...
01背包问题 动态规划问题.zip
01-21
背包问题是一个很经典而且讨论很广泛的算法问题了，0-1背包问题和部分背包问题解决方法背后其实隐藏了两种比较常见的算法解决思路，动态规划和贪婪算法。 二、问题描述 假设我们有n件物品，分别编号为1, 2...n。其中...
几个经典的动态规划问题
10-24
根据给定文件的信息，本文将深入探讨几个经典的动态规划问题，并详细分析其解题思路、动态规划方程以及具体的实现代码。动态规划是一种强大的算法设计技术，尤其适用于那些具有重叠子问题和最优子结构的问题。 ### ...
01背包动态规划问题.txt
01-21
01背包问题动态规划
常见动态规划问题总结
05-17
1.三角形找一条从顶到底的最小路径 2.最大子数组和 3.回文最小划分次数 4.最佳时间买卖股票 5. 判断字符串s3是否由s1,s2交叉存取组成 6.给定一个矩形表格，求从顶到底的最小和 7.使两个字符串相等，最小的编辑次数 ...
C++之动态规划问题汇总
最新发布
03-05
leetcode常见动态规划问题整理，包括解答和思路以及一些模式化的代码结构~
Matlab求解动态规划问题
06-30
总的来说，Matlab作为一款强大的科学计算工具，其灵活的编程环境使得动态规划问题的求解变得简单易行。通过对每个阶段的最优决策进行迭代计算，可以找到整个生产计划的最优解，从而实现成本最小化。在实际应用中，...
动态规划十大经典问题
红衣女妖仙的博客
11-21 1218
动态规划十大经典问题 数塔取数问题、矩阵取数问题、最大连续子段和、最长递增子序列、最长公共子序列、最长公共子串、最短编辑距离、背包问题、正整数分组、股票买卖问题。
动态规划经典问题整理
alim2012的博客
09-15 4242
史上最全最丰富的“最长公共子序列”、“最长公共子串”问题的解法与思路 https://blog.csdn.net/wangdd_199326/article/details/76464333 动态规划-----两个字符串交叉组成第三个字符 https://blog.csdn.net/smallfish_love/article/details/52277838 动态规划解决01背包问题 ..................
经典动态规划问题
技术记录
10-17 372
经典动态规划问题
动态规划问题详解：经典实例与解题关键
"常见动态规划问题的总结，包括10个经典题目，涉及寻找三角形最小路径、最大子数组和、回文最小划分次数、最佳股票买卖时机、字符串交叉存取判断、矩阵最小和计算、字符串最小编辑距离、数字解码方式、不同子序列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

工具人来了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值