第5将 动态规划

最新推荐文章于 2024-06-03 11:54:57 发布
最新推荐文章于 2024-06-03 11:54:57 发布
阅读量86 收藏
点赞数
分类专栏： acwing算法基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsfhdhjs/article/details/114938314
版权
本文深入探讨动态规划在解决背包问题中的应用，包括01背包、完全背包、多重背包以及分组背包问题。同时，文章还详细介绍了线性DP，如数字三角形、最长上升子序列及其优化算法，以及最长公共子序列、最短编辑距离等经典问题。通过实例解析，帮助读者理解动态规划的策略和思路。
摘要由CSDN通过智能技术生成

背包问题

01背包问题

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


#include<iostream>
using namespace std;

const int maxn=1010;

int n,m;

int f[maxn],v[maxn],w[maxn];

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];

    return 0;
}

完全背包问题


#include<iostream>
using namespace std;

const int maxn=1111;

int f[maxn],w[maxn],v[maxn];

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++)      //区别于01背包，这里就是从小到大排列
        {
            f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }

    cout << f[m];

    return 0;

}

多重背包问题01


#include<iostream>
using namespace std;

const int maxn=111;

int n,m;

int f[maxn][maxn],v[maxn],w[maxn],s[maxn];

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] && j>=v[i]*k; k++)
                f[i][j]=max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);

    cout << f[n][m];

    return 0;

}

多重背包问题02


#include<iostream>
using namespace std;

const int N=12010;     //0<N<1000，0<s<2000,所以看下面的循环n*log2000就约等于12000
const int M=2010;            //M只用给f，所以最大体积就是f[M]

int n,m;

int f[M],w[N],v[N];

int main()
{
    cin >> n >> m;
    int cnt=0;              //cnt从0开始，相当于是将这些值全部分开
    for(int i=1; i<=n; i++)
    {
        int a,b,s;
        cin >> a >> b >> s;
        int k=1;
        while(k<=s)
        {
            cnt++;             //cnt表示
            v[cnt]=k*a;
            w[cnt]=k*b;
            s-=k;          //先是让s-=k，最后再更新k的值
            k*=2;
        }
        if(s>0)   //如果s还有剩余
        {
            cnt++;           //cnt还是++，进行一个分组
            v[cnt]=s*a;
            w[cnt]=s*b;
        }
    }



    n=cnt;        //将n更新为cnt

    //才用01背包的方法
    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];

    return 0;

}

分组背包问题


#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 ++ )               //和01背包的区别在于，这里 进行了一个分组
    {
        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 -- )          //这里j的值不是>=v[i]，而是j>=0，因为此时v[i][k]表示第i组，第k个
            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;       //m最后就是总体积

    return 0;
}

线性DP

数字三角形


#include<iostream>
using namespace std;

const int maxn=511;

int n;

int f[maxn][maxn];

int main()
{
    cin >> n;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=i; j++)
            cin >> f[i][j];

    for(int i=n-1; i>=1; i--)
        for(int j=1; j<=n; j++)
            f[i][j]+=max(f[i+1][j],f[i+1][j+1]);

    cout << f[1][1];

    return 0;
}

最长上升子序列

在这里插入图片描述


#include<iostream>
using namespace std;

const int maxn=1111;

int a[maxn],f[maxn];          //a表示给出的数组，f表示到达每个点的最长子序列

int main()
{
    int n;
    cin >> n;
    for(int i=1; i<=n; i++)
        cin >> a[i];
    for(int i=1; i<=n; i++)
    {
        f[i]=1;                     //先对每个点的长度初始化为1
        for(int j=1; j<i; j++)      //从头开始遍历，一直到i之前
            if(a[j]<a[i])               //如果a[j]<a[i]，则可以将第i个数放到序列中，则f[i]为f[j]+1
                f[i]=max(f[i],f[j]+1);
    }

    int res=-n;

    for(int i=1; i<=n; i++)          //最后找出所有点的最大长度即可
        res=max(res,f[i]);

    cout << res;

    return 0;
}

最长上升子序列2

思路分析

这道题本身是将数据范围给大了，所以要考虑简便算法

1.对于 3 1 2 1 8 5 6 对于8而言，可以插入到3后面，也可以插入到1后面，但是我们选择插入到1的后面，因为范围更大，所以插入到3的后面就多余了，对于朴素算法而言，我们需要将8插入到前面的所有比他小的值后面，然后找出最大长度
2.注意q[i] 表示长度是i的上升子序列最后一个数的最小值，q[i]是随着i的值递增的
3.对于a[i]而言，我们肯定是要将a[i]放到前面的一个最大长度，并且该最大长度的最后一个值要小于a[i]，要找长度i，所以找q[i]，所以我们采用2分的思路,在q[]中找出小于a[i]的最大值，此时找到的这个位置比如q[4],表示长度为4是之前的最大长度，并且长度为4的上升子序列中的最小值为q[4]，并且q[4]是小于a[i]的最大值，也就是q[5]的值>=a[i]，表示长度为5的上升子序列的最后一个值的最小值是>=a[i],由于q的属性，则q[5]=a[i]


#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int n;
int a[N];
int q[N];               //q存放的是，每种长度的上升子序列的结尾的值最小是多少，其实这里随着长度的增加，结尾的值也在递增，呈一个上升趋势

int main()
{
    scanf("%d", &n);        //输入n

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

    int len = 0;
    for (int i = 0; i < n; i ++ )
    {             //数字a[i]可以接到任何一个比自己小的值的后面，如果想要长度最大，则需要将a[i]接到比a[i]小的最大值的后面
        int l = 0, r = len;
        while (l < r)           //通过2分，找出小于a[i]的最大的数，这个二分也是在q中去寻找一个合适的长度，
        {
            int mid = l + r +1 >> 1;
            if (q[mid] < a[i]) l = mid;   //中间这个值q[mid]小于a[i]，现在要找到小于a[i]的最大值，所以从该值开始一直往后找，则让l=mid，正常的思路如果是要找后半部分，则需要l=mid+1,但是我们现在是l=mid，则mid=l+r+1>>1
            else r = mid-1;
        }
        len = max(len, r + 1);
        q[r + 1] = a[i];
    }


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

    return 0;
}

最长公共子序列

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述



#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);           //输入n,m
    scanf("%s%s", a + 1, b + 1);         //a,b均为字符串数组，其中加1表示从下标为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;
}

最短编辑距离

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

石子合并

在这里插入图片描述
在这里插入图片描述

整数划分

在这里插入图片描述

该问题可以看成容量为n的一个背包，一共有n个体积为1,2，3,4…n的物品，相当于是问将背包装满一共有多少种装法，并且每个物品可以有n中选择
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
体积升序排列
在这里插入图片描述


#include<iostream>
using namespace std;

const int maxn=1010;

const int mod=1e9+7;

int n;

int f[maxn];

int main()
{
    cin >> n;

    f[0]=1;

    for(int i=1; i<=n; i++)                  //相当于是从1到i，
        for(int j=i; j<=n; j++)                //此时体积也是从i到n
            f[j]=(f[j]+f[j-i])%mod;

    cout << f[n];

    return 0;

}

计数问题

在这里插入图片描述

计数问题

在这里插入图片描述
在这里插入图片描述


#include<iostream>
#include<vector>
using namespace std;

const int maxn=101010;

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;
    for(int i=0; i<x; i++)
        res*=10;
    return res;
}

int count(int n, int x)             //在n中，统计x出现的个数
{
    if (!n) return 0;           //如果n为0，直接返回0

    vector<int> num;                 //num存放n中每一位的个数

    while (n)             //其实这个num是逆着存放n的位数
    {
        num.push_back(n % 10);
        n /= 10;
    }
    n = num.size();

    int res = 0;                                                    //res表示每一位中出现的个数
    for (int i = n - 1 - !x; i >= 0; i -- )                //i应该是从倒数第一位开始的，如果要统计的数x为0，则从倒数第2位开始，i>=0
    {
        if (i < n - 1)          //如果i从倒数第2位开始，也就是正数第1位
        {
            res += get(num, n - 1, i + 1) * power10(i);     //
            if (!x) res -= power10(i);          //如果要统计的数为0，则少掉了10^i个
        }

        if (num[i] == x) res += get(num, i - 1, 0) + 1;         //如果当前位置上的这个数等于x，则后面一共有000~efg，共efg+1个
        else if (num[i] > x) res += power10(i);         //如果当前位置的数>x，则值为000--999，共10^i个
    }

    return res;
}

int main()
{
    int a, b;
    while (cin >> a >> b , a)           //输入a,b，其中a为0，则循环结束
    {
        if (a > b) swap(a, b);          //如果a>b，则交换，保证第1个数小，第2个数大

        for (int i = 0; i <= 9; i ++ )
            //注意是a-1
            cout << count(b, i) - count(a - 1, i) << ' ';             //统计a--b之间，0~9中所有数的个数，就是统计b中0~9所有数的个数再减去a中0~9中所有数的个数
        cout << endl;           //换行
    }

    return 0;
}

蒙德里安的梦想

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

最短Hamilton路径

在这里插入图片描述


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

using namespace std;

const int N = 20, M = 1 << N;     //注意N，M的设置

int n;
int w[N][N];      //这就是端点值
int f[M][N];

int main()
{
    cin >> n;
    for (int i = 0; i < n; i ++ )
        for (int j = 0; j < n; j ++ )
            cin >> w[i][j];         //输入端点值

    memset(f, 0x3f, sizeof f);      //因为要找最小值，所以对f进行初始化为最大
    f[1][0] = 0;        //注意这里f[1][0]设为0，注意这个初始值

    for (int i = 0; i < 1 << n; i ++ )          //i就是   邹精
        for (int j = 0; j < n; j ++ )       //j就是0~n
            if (i >> j & 1)         //i要把j收拾下哈
                for (int k = 0; k < n; k ++ )       //k也是从0--n
                    if (i >> k & 1)         //i把k也收拾一哈
                        f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);       //注意加括号

    cout << f[(1 << n) - 1][n - 1];

    return 0;
}

没有上司的舞会

在这里插入图片描述


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

using namespace std;

const int N = 6010;

int n;
int h[N], e[N], ne[N], idx;
int happy[N];
int f[N][2];
bool has_fa[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs(int u)
{
    f[u][1] = happy[u];         //对于选择节点u来说，其幸福指数为happy[u]

    for (int i = h[u]; i!=-1; i = ne[i])
    {
        int j = e[i];
        dfs(j);

        f[u][1] += f[j][0];         //u是j的父亲节点，选择u就不能选择j
        f[u][0] += max(f[j][0], f[j][1]);       //不选择u，则选择其孩子节点的最值
    }
}

int main()
{
    scanf("%d", &n);        //输入n个节点，输入每个人的幸福指数

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

    memset(h, -1, sizeof h);                //对h初始化

    for (int i = 0; i < n - 1; i ++ )
    {
        int a, b;
        scanf("%d%d", &a, &b);     //输入a,b节点

        add(b, a);          //b是a的父亲节点
        has_fa[a] = true;           //标记a有父亲节点
    }

    int root = 1;
    while (has_fa[root]) root ++ ;         //找到根节点

    dfs(root);      //深搜

    printf("%d\n", max(f[root][0], f[root][1]));

    return 0;
}

滑雪

在这里插入图片描述


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

using namespace std;

const int N = 310;

int n, m;
int g[N][N];
int f[N][N];

int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};   //左上右下

int dp(int x, int y)
{
    int &v = f[x][y];       //通过&v，后面对v的值的修改直接作用于f[x][y]
    if (v != -1) return v;              //如果v!=-1，表示之前已经访问过了

    v = 1;      //v的最小值为1，因为最起码从该点出发还能有一个点
    for (int i = 0; i < 4; i ++ )       //一共遍历4个方向
    {
        int a = x + dx[i], b = y + dy[i];
        if (a >= 1 && a <= n && b >= 1 && b <= m && g[x][y] > g[a][b])      //必须在范围内，且该点的高度大于下个点
            v = max(v, dp(a, b) + 1);       //通过递归的方式
    }

    return v;
}

int main()
{
    scanf("%d%d", &n, &m);          //输入n行，m列
    
    for (int i = 1; i <= n; i ++ )          //一共是n行，m列
        for (int j = 1; j <= m; j ++ )
            scanf("%d", &g[i][j]);      //g表示每个点的高度

    memset(f, -1, sizeof f);        //对f初始化，全部为-1

    int res = 0;            //res表示所经过的区域
    
    for (int i = 1; i <= n; i ++ )          //共n个点，
        for (int j = 1; j <= m; j ++ )
            res = max(res, dp(i, j));           //找出最大的通过的区域数

    printf("%d\n", res);        //输出

    return 0;
}
wsfhdhjs
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划算法详解
m0_54615144的博客
07-27 2万+
动态规划算法通常用于求解具有最优性质的问题 基本概念 动态规划过程是：每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划(DP)。 基本思想与策略 基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。...
动态规划专题——背包问题
⚡
02-13 4万+
详解四种背包：01背包、完全背包、多重背包、分组背包。
第九章动态规划——整数拆分
DDDDWJDDDD的博客
04-25 1472
动态规划解决整数拆分得到最大值问题，新手也能看懂！！！！
教你彻底学会动态规划——入门篇
常敲代码手不抖
08-11 38万+
动态规划相信大家都知道，动态规划算法也是新手在刚接触算法设计时很苦恼的问题，有时候觉得难以理解，但是真正理解之后，就会觉得动态规划其实并没有想象中那么难。网上也有很多关于讲解动态规划的文章，大多都是叙述概念，讲解原理，让人觉得晦涩难懂，即使一时间看懂了，发现当自己做题的时候又会觉得无所适从。我觉得，理解算法最重要的还是在于练习，只有通过自己练习，才可以更快地提升。话不多说，接下来，下面我就...
算法-动态规划 Dynamic Programming--从菜鸟到老鸟
热门推荐
有图有真相
07-15 46万+
前言最近在牛客网上做了几套公司的真题，发现有关动态规划（Dynamic Programming）算法的题目很多。相对于我来说，算法里面遇到的问题里面感觉最难的也就是动态规划（Dynamic Programming）算法了，于是花了好长时间，查找了相关的文献和资料准备彻底的理解动态规划（Dynamic Programming）算法。一是帮助自己总结知识点，二是也能够帮助他人更好的理解这个算法。后面的参
运筹学_5.动态规划
一去不复返的通信er
06-03 1333
动态规划
动态规划算法思想讲解
总裁余（余登武）博客
12-26 1085
动态规划（Dynamic Programming，简称DP）是一种解决问题的算法思想，它将一个大问题拆分成多个相互重叠的子问题，并且通过解决这些子问题来求解原始问题。
【动态规划】01背包问题（通俗易懂，超基础讲解）
Yngz_Miao的博客
08-24 43万+
问题描述 有n个物品，它们有各自的体积和价值，现有给定容量的背包，如何让背包里装入的物品具有最大的价值总和？ 为方便讲解和理解，下面讲述的例子均先用具体的数字代入，即：eg：number＝4，capacity＝8 i（物品编号） 1 2 3 4 w（体积） 2 3 4 5 v（价值） 3 4 5 6 总...
动态规划的时间复杂度优化
闻缺陷则喜何志丹
02-26 5005
优化动态规划的时间复杂度，主要有如下几种：
背包问题大全（动态规划）
weixin_45746505的博客
05-02 6万+
背包问题是动态规划非常重要的一类问题，它有很多变种，但题目万变不离其宗。我们需要抓住关键的解题思路。
动态规划入门第4、5课
08-06
本篇将深入探讨动态规划的两个实例：求解最长公共子串问题和取数游戏。 首先，我们来看第一个问题——求解两个小写字母组成的字符串的最长公共子串的长度。这个问题的核心在于定义状态和构建转移方程。我们可以用一...
运筹学第七章：动态规划.pdf
11-23
动态规划包含五个基本概念： 1. 阶段：问题被划分为一系列互相联系的时间或空间阶段。 2. 状态：每个阶段开始时的条件，由状态变量（如sk）表示，状态集合（Sk）定义了所有可能的状态。 3. 决策和策略：在给定状态下...
动态规划第1课PPTX
08-06
5. 动态规划的优势： 动态规划能够有效地处理重叠子问题和最优子结构，这使得它在解决复杂优化问题时表现出色。相比于贪心算法，动态规划允许回溯，因此在某些情况下可以找到全局最优解。 通过本课程的学习，我们...
最新2022信息学奥赛第5部分 动态规划
05-12
动态规划是一种在计算机科学中广泛使用的算法设计策略，特别是在解决最优化问题...文件“第5部分 动态规划(提高篇)”很可能是对动态规划的深入讲解，包含了更复杂的问题实例和解题策略，对提升动态规划技能有很大帮助。
第5.0讲-动态规划1
08-03
动态规划（Dynamic Programming，简称DP）是一种用于解决最优化问题的数学方法，它通过将复杂问题分解成更小的子问题来求解。这个概念由美国数学家理查德·贝尔曼在20世纪50年代提出，他于1957年发表的《Dynamic ...
2024.8.24.zip
08-25
2024.8.24.zip
中国移动实习项目-车票管理系统_ticket-management-system.zip
最新发布
08-25
中国移动实习项目-车票管理系统_ticket-management-system
ant-design-3.20.4.zip
08-25
ant-design，一套企业级 UI 设计语言和 React 组件库 提炼自企业级中后台产品的交互语言和视觉风格 开箱即用的高质量 React 组件
NOS量表（英文）.pdf
08-25
NOS量表（英文）.pdf
动态规划解题思路与实例解析
在“Humble Number”问题(HDOJ_1058)中，动态规划的应用则体现在寻找一个数的唯一质因数只能是2、3、5或7的情况。这里，动态规划可能涉及到构建一个状态表示当前数的最大质因数，通过递归或迭代的方式，更新这个状态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值