DP算法1

最新推荐文章于 2024-07-24 20:44:05 发布
最新推荐文章于 2024-07-24 20:44:05 发布
阅读量700 收藏
点赞数
分类专栏： 蓝桥杯学习 高级算法学习 文章标签： 算法 蓝桥杯 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42336835/article/details/123786301
版权

DP1

01背包

在这里插入图片描述

  • 0，1背包定义：有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
    动态规划是不断决策求最优解的过程，
    「0-1 背包」即是不断对第 i 个物品的做出决策，
    「0-1」正好代表不选与选两种决定。
    状态f[i][j]定义：第 i个物品，背包容量 j（体积为j） 下的最优解（最大价值）：
    当前的状态依赖于之前的状态，可以理解为从初始状态f[0][0] = 0开始决策，有 N 件物品，则需要 N 次决 策，每一次对第 i 件物品的决策，状态f[i][j]不断由之前的状态更新而来。

在这里插入图片描述
1.简单版
1）当前背包容量够，可以选，因此需要决策选与不选第 i 个物品：

选：f[i][j] = f[i - 1][j - v[i]] + w[i]。
不选：f[i][j] = f[i - 1][j] 。
进行max操作
2）当前的背包容量j<v(i):
没得选了，容量不够
f[i][j] = f[i - 1][j]
f(i,j)是一个数，代表一种属性，需要从不同的题目中去确定
状态表示：也就是状态转移方程。
代码

package 背包问题;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class 背包01二维2 {
    //状态
    static int N = 1010;
    static int[][] f = new int[N][N];
    static int[] v = new int[N];
    static int[] w = new int[N];

    //接收数据
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String[] nm = reader.readLine().split(" ");
        int n = Integer.valueOf(nm[0]);
        int m = Integer.valueOf(nm[1]);
        for(int i=1;i<=n;i++){
            String[] vw = reader.readLine().split(" ");
            v[i] = Integer.valueOf(vw[0]);
            w[i] = Integer.valueOf(vw[1]);
        }

        for(int i=1;i<=n;i++){
            for(int j=0;j<=m;j++){
                if(j<v[i]) f[i][j] = f[i-1][j];
                else {
                    f[i][j] = Math.max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
                }
            }
        }
        System.out.println(f[n][m]);
    }
}

在这里插入图片描述
第二种：简化版
因为状态一直用的上一次的状态，所以可以进行将j换成状态值
但是需要进行判断，如果状态值不合适就不需要更新

package 背包问题;

import java.util.Scanner;

public class 背包01一维2 {
    static int N = 1010;
    static int[] f = new int[N];
    static int[] v = new int[N];
    static int[] w = new int[N];

    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        for(int i=1;i<=n;i++){
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        for(int i=1;i<=n;i++){
            for(int j=m;j>=v[i];j--){
                f[j] = Math.max(f[j],f[j-v[i]]+w[i]);
            }
        }
        System.out.println(f[m]);
    }
}

完全背包：每个物体有无限个

问题：有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。
第 i 种物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值

简答暴力法
在这里插入图片描述
不选i，选k个i

package 背包问题;

import java.util.Scanner;

public class 完全背包二维02 {
    static int N =1010;
    static int[][] f = new int[N][N];//选择前i个品的
    static int[] v = new int[N];
    static int[] w = new int[N];

    //二维结构，状态，体积，价值
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        for(int i=1;i<=n;i++){
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        
        for(int i=1;i<=n;i++){
            for(int j=0;j<=m;j++){//选择不同的k
                for(int k=0;k*v[i]<=j;k++){//j是当前的容量，必须容量够用才可以
                    f[i][j] = Math.max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
                }
            }
        }
        System.out.println(f[n][m]);
    }
}

在这里插入图片描述
化简：
状态化简：

代码

package 背包问题;

import java.util.Scanner;

public class 完全背包一点5维 {
    //根据
    //f[i][j] =    Max(f[i-1][j],f[i-1][j-v]+w,f[i-1][j-2v]+2w+...)
    //f[i][j-v] =  Max(          f[i-1][j-v],  f[i-1][j-v-v]+w+....)
    //f[i][j] = max(f[i-1][j],f[i][j-v])
    // 当前的状态可以根据这层的状态进行改变。
    static int N = 1010;
    static int[][] f = new int[N][N];
    static int[] v = new int[N];
    static int[] w = new int[N];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        for(int i=1;i<=n;i++){
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        //1.
        for(int i=1;i<=n;i++){
            for(int j=0;j<=m;j++){
                for(int k=0;k*v[i]<=j;k++){
                    f[i][j] = Math.max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
                }
            }
        }
        //2.化简的后的状态。
        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] = Math.max(f[i][j],f[i][j-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]>=0) f[i][j] = Math.max(f[i][j],f[i][j-v[i]]+w[i]);
            }
        }
        /*s上面的代码特别像01背吧
        for(int i=1;i<=n;i++){
            for(int j= v[i];j<=m;j++){
                f[j] = Math.max(f[j],f[j-v[i]]+w[i]);
            }
        }
        */
        System.out.println(f[n][m]);
    }
}

多重背包1：有限个，会我们有多少个

有 N 种物品和一个容量是 V 的背包。
第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。
有拿的件数要求。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值
f[][]
v[]
w[]
s[]

暴力解：

package 背包问题;

import java.util.Scanner;

public class 多重背包问题01 {
    //有 N 种物品和一个容量是 V 的背包。
    //第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。
    //暴力：
    static int N = 110;
    static int[][] f = new int[N][N];
    static int[] v = new int[N];
    static int[] w = new int[N];
    static int[] s = new int[N];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        for(int i=1;i<=n;i++){
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
            s[i] = sc.nextInt();
        }
        //开始
        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] = Math.max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
                }
            }
        }
        System.out.println(f[n][m]);
    }


}

1.与完全背包的思考一样，选i和不选i，进行比较，为什么俄密友f(i-1,j)因为，当k为0时，就整好为在这里插入图片描述

多重背包2:二进制优化

二进制优化多重背包


 分组背包里面：每组最多有一个。体积，价值，大小

如果仍然不是很能理解的话，取

这样一个例子
:要求在一堆苹果选出n个苹果。我们传统的思维是一个一个地去选，选够n个苹果就停止。这样选择的次数就是n次

二进制优化思维就是：
现在给出一堆苹果和10个箱子，选出n个苹果
。将这一堆苹果分别按照
1,2,4,8,16,32，64，128，256，512分到10个箱子里，
那么由于任何一个数字x ∈[1,1024）
例如：
1就是第一个箱子
3:第一个加第三个
7:第一个+第二个+第三个
1023：1+2+3+4+5+6+7+8+9+10
都可以从这10个箱子里的苹果数量表示出来，但是这样选择的次数就是 ≤10次 。

这样利用二进制优化，时间复杂度就从O(n^3)降到O(n^2logS),从4*10^9降到了2*10^7。

在这里插入图片描述
代码：

package 背包问题;
import java.util.Scanner;
public class 多重背包问题二进制01 {
    //0<N≤1000
    //0<V≤2000
    //0<vi,wi,si≤2000
    static int N =12100;
    static int M = 2010;
    static int[] v =  new int[N];
    static int[] w = new int[N];
    static int[][] f = new int[M][M];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();//物品
        int m = sc.nextInt();//容量V
        //分组类别
        int cnt = 0;
        for(int i=1;i<=n;i++){
            int va = sc.nextInt();//体积
            int wb = sc.nextInt();//价值
            int s = sc.nextInt();//个数
            //s的临界值箱子
            int k=1;
            while (k<=s){
                cnt++;
                v[cnt] = va*k;
                w[cnt] = wb*k;
                s = s-k;//个数减少按照2进制
                k = k*2;//这边的个数再扩大-k= 64,单上一步剩余的s已经是剩下的个数
            }
            //不满足条件则，说明剩下的是一组
            if(s>0){
                cnt++;
                v[cnt] = va*s;//s个总共的体积
                w[cnt] = wb*s;//s个总共的价值
            }
        }
        //组合操作
        n = cnt;
        for(int i=1;i<=n;i++){
            for(int j=0;j<=m;j++){
                if(j<v[i]) f[i][j] = f[i-1][j];
                else {
                    f[i][j] = Math.max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
                }
            }
        }
        System.out.println(f[n][m]);
    }
}

不选择第i组的第一个物品：
f(i-1,j)
选择第i组的第k个物品
f(i-1,j-v(i,k))+w[i,k];

分组背包问题

在这里插入图片描述
代码：

package 背包问题;

import java.util.Scanner;

public class 分组背包2 {
    static int N = 1001;
    static int[][] f = new int[N][N];
    static int[][] v = new int[N][N];
    static int[][] w = new int[N][N];
    static int[] s = new int[N];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        for(int i=1;i<=n;i++){
            s[i] = sc.nextInt();
            for(int j=0;j<s[i];j++){
                v[i][j]=sc.nextInt();
                w[i][j] = sc.nextInt();
            }
        }

        //
        for(int i=1;i<=n;i++){
            for(int j=0;j<=m;j++){
                f[i][j] = f[i-1][j];
                for(int k=0;k<=s[i];k++){
                    if(j>=v[i][k]) f[i][j] = Math.max(f[i][j],f[i-1][j-v[i][k]]+w[i][k]);
                }
            }
        }
        System.out.println(f[n][m]);
    }
}
魔法少女啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划算法（DP）
那什
06-05 5万+
    校招笔试面试前，大家一般都会先去牛客网上刷刷题，《剑指offer》，《leetcode》走起来，然后初次入手，发现很多不会，不会到什么程度呢，连个想法都没有，于是就去讨论区看答案，然后java大神，c++大神会给出花式解答，他们喜欢在答案前加一句，简单的dp算法，递归就可以解决，巴拉巴拉。说的还是很详细的，然而代码并不能看懂，毕竟    人生苦短，我用python下面就先给大家举一些详细的...
DP.rar_dp算法
09-23
DP算法的核心思想是将原问题分解成若干个子问题，并存储子问题的解，避免重复计算，以达到优化求解效率的目的。在流水作业问题中，我们通常要处理的任务是安排一系列任务在多个处理器上执行，以最小化完成所有任务的...
DP问题之01背包如此简单
qq_52416556的博客
04-29 3715
看完这篇文章，学会人生中第一个背包问题
动态规划(DP)算法初识
0117
08-09 8195
先用大白话来说一下几种经典算法大概的意思： 贪心算法：我就一次机会，为了达到目的，其他的我啥也不考虑 回溯算法：我有无数次机会，还能怕我有达不到目的的时候？ 动态规划算法：我能随意在任何时候进行存档读档，用最华丽的方法走到终点。 接下来的几篇文章可能都会围绕dp来说，从白话和较多篇幅去解释dp算法的内在 简述 动态规划求解出最优策略的原理是因为显著的降低了时间复杂度，提高了代码的运行效率，但动...
动态规划（DP）算法
libosbo的博客
04-23 4万+
动态规划是运筹学的一个分支，是求解决策过程最优化的数学方法。利用各个阶段之间的关系，逐个求解，最终求得全局最优解，需要确认原问题与子问题、动态规划状态、边界状态、边界状态结值、状态转移方程。一、爬楼梯leetcode70:You are climbing a stair case. It takes n steps to reach to the top.Each time you can eit...
DP算法（Dynamic Programming,俗称动态规划）是最经典算法之一
zh123456zh789的博客
02-16 1万+
DP算法（Dynamic Programming,俗称动态规划）是最经典算法之一.本笔记以耳熟能详的数塔问题为引子,深入讨论01背包的解决方法. 　　首先,如下图所示,要求从顶层走到底层,若每一步只能走到相邻的结点,则经过的结点的数字之和最大是多少？ 　　这个问题,对于任意一个结点,直接选择数字大的子结点显然是不行的.以9为例,如果选择15,当前和24>21,但是15的两个子结
c语言dp算法,通过leetcode学算法——动态规划（dp）
weixin_42509914的博客
05-21 2177
先贴问题：Delete Operation for Two StringsGiven two words word1 and word2, find the minimum number of steps required to make word1 and word2 the same, where in each step you can delete one character in eit...
dp.rar_dp算法
09-22
例如，在解决0-1背包问题时，我们需要定义一个二维数组dp[i][w]表示前i个物品中选取总重量不超过w的情况下的最大价值，然后通过比较放入第i个物品和不放入第i个物品两种情况，更新dp数组。 此外，理解动态规划与...
DP.rar_c++dp算法实现
09-14
标题“DP.rar_c++dp算法实现”表明这是一个关于使用C++语言实现动态规划算法的压缩文件，可能包含了多个实例或者案例，用于演示和学习DP算法的不同应用场景。 描述中提到“动态规划算法的编程实现，重在思想吧，...
【算法之动态规划（一）】动态规划（DP）详解
cangchen的专栏
04-14 3万+
一、基本概念 动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，提出了著名的最优化原理(principle of optimality)，把多阶段过程
DP算法入门1
计科菜鸟的天地.
03-06 1106
典型例题：Max Sum：http://acm.hdu.edu.cn/showproblem.php?pid=1003 这是DP的经典之一，欲求出一个最优的结果，但不暴力地去枚举。 如一个序列：6,-1,5,4,-7 求它的连续最大段就是：6 + (-1) + 5 + 4 = 14. 用DP的方法只要一重的循环就可以把这道题搞定： 每一次的计算对前一次结果不会有影响，这是DP的特点。 这
dp算法总结
08-02 6056
01背包 给你n种物品每种物品有一件和一个容量为m的背包 然后给你每种物品的体积和价值 求背包所能容下的最大价值 样例输入 3 8 4 3 3 2 2 1 样例输出 5 程序代码： #include&lt;stdio.h&gt; #include&lt;string.h&gt; #include&lt;algorithm&gt; using namespace std; int v...
【DP专辑】ACM动态规划总结
热门推荐
Rprop
01-01 6万+
动态规划一直是ACM竞赛中的重点，同时又是难点，因为该算法时间效率高，代码量少，多元性强，主要考察思维能力、建模抽象能力、灵活度。
算法-KMP字符串匹配
xx_xb的博客
07-23 163
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 385
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 642
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 733
二叉搜索树向左或向右指明方向，不用遍历整个树。
2024.7.19 刷题总结
TheJustice_的博客
07-19 303
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 529
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
DP算法python
08-19
DP算法是指动态规划算法，它是一种将复杂问题分解成较小子问题并逐步求解的算法。在给定问题中，动态规划算法通过将问题分解为子问题来减少计算量，并使用备忘录或表格来存储已解决的子问题的结果，以避免重复计算。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值