动态规划（含0-1背包）

已于 2023-09-03 21:27:11 修改
阅读量148 收藏
点赞数
分类专栏： 算法 文章标签： 动态规划 算法
于 2019-07-03 09:53:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36091872/article/details/90610781
版权

文章目录

矩阵路径

64 最小路径和

https://leetcode-cn.com/problems/minimum-path-sum/

1处先判断j==0是因为如果判断先判断i==0时若j也为0，在dp[j]=dp[j-1];会出现数组越界。

class Solution {
    public int minPathSum(int[][] grid) {
        if(grid==null || grid.length==0)
            return 0;
        int m=grid.length;
        int n=grid[0].length;
        int dp[]=new int[n];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(j==0){//1
                    dp[j]=dp[j];
                }else if(i==0){
                    dp[j]=dp[j-1];
                }else{
                    dp[j]=Math.min(dp[j-1],dp[j]);
                }
                dp[j]=dp[j]+grid[i][j];
            }
        }
        return dp[n-1];
    }
}

62 不同路径

https://leetcode-cn.com/problems/unique-paths/
方法一：此处从1开始是因为当i为0或当j为0时为1

class Solution {
    public int uniquePaths(int m, int n) {
        int dp[]=new int[n]; Arrays.fill(dp, 1);
        Arrays.fill(dp, 1);
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                dp[j]=dp[j]+dp[j-1];
            }
        }
        return dp[n-1];
    }
}

方法二：可以看做是m+n-2次中选择m-1次往下。

class Solution {
    public int uniquePaths(int m, int n) {
        int S=m+n-2;
        int D=m-1;
        long result=1;
        for(int i=1;i<=D;i++){
            result=result*(S-D+i)/i;
        }
        return (int)result;
    }
}

数组区间

303 区域和检索 - 数组不可变

https://leetcode-cn.com/problems/range-sum-query-immutable/

class NumArray {
    int sums[];

    public NumArray(int[] nums) {
        sums=new int[nums.length+1];
        for(int i=0;i<nums.length;i++){
            sums[i+1]=sums[i]+nums[i];
        }
    }
    
    public int sumRange(int i, int j) {
        return sums[j+1]-sums[i];
    }
}

分割整数

343 整数拆分

https://leetcode-cn.com/problems/integer-break/
方法一：

class Solution {
    public int integerBreak(int n) {
        int dp[]=new int[n+1];
        dp[1]=1;
        for(int i=2;i<=n;i++){
            for(int j=1;j<=i-1;j++){
                dp[i]=Math.max(dp[i],Math.max(dp[i-j]*j,j*(i-j)));
            }
        }
        return dp[n];
    }
}

方法二：
根据题目设定的条件整数n的取值范围为： 2<=n<=58
分析一下：
当n=2时： n=1+1; result = 1*1=1
当n=3时： 可以拆分为: 1+2 或者 1+1+1，但是显然拆分为 1+2，所获得的乘积最大
当n=4时：可以拆分为： 1+3 或者 2+2，但是显然拆分为 2+2，所获得的乘积最大
当n=5时：可以拆分为：2+3，所获得乘积最大
当n=6时：可以拆分为：3+3，所获得乘积最大
当n=7时：可以拆分为：3+4，所获得乘积最大
当n=8时：可以拆分为：3+3+2，所获得乘积最大
当n=9时：可以拆分为：3+3+3，所获得乘积最大
当n=10时：可以拆分为：3+3+4，所获得乘积最大
通过观察上述内容，我们可以发现从n=5开始，拆分的结果都有数字3。
之后的数字，例如11，可以先拆出来1个3，然后再看余下的8如何拆分。

class Solution {
    public int integerBreak(int n) {
        if(n==1 || n==4)
            return n;
        if(n==2 || n==3)
            return n-1;
        int result=1;
        while(n>4){
            result*=3;
            n-=3;
        }
        return result*n;
    }
}

91. 解码方法

https://leetcode-cn.com/problems/decode-ways/

class Solution {
    public int numDecodings(String s) {
        if(s==null||s.length()==0||s.charAt(0)=='0')
            return 0;
        int dp[]=new int[s.length()+1];
        dp[0]= 1;
        for(int i=1;i<s.length();i++){
            int cur=s.charAt(i)-'0';
            int pre=s.charAt(i-1)-'0';
            if(cur==0){
                if(pre<1 || pre>2){
                    return 0;
                }
                dp[i]=i>=2?dp[i-2]:1;
            }else{
                if (pre==1 || pre==2 && cur<=6) {
                    dp[i] = i>=2?dp[i - 2]+dp[i-1]:2;
                }else{
                    dp[i]=dp[i-1];
                }                
            }
        }
        return dp[s.length()-1];
    }
}

最长递增子序列

300 最长上升子序列

https://leetcode-cn.com/problems/longest-increasing-subsequence/
tails[i]：以i结尾的最长递增子序列。

class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums==null || nums.length==0){
            return 0;
        }
        int tails[]=new int[nums.length];
        tails[0]=nums[0];
        int len=1;
        for(int i=1;i<nums.length;i++){
            if(nums[i]>tails[len-1]){
                tails[len++]=nums[i];
            }else{
                int temp=findFirst(tails,len,nums[i]);
                tails[temp]=nums[i];
            }
        }
        return len;
    }
    
    //二分查找，第一个大于等于des的数组索引
    public int findFirst(int []nums,int len, int des){
        int l=0;
        int h=len-1;
        while(l<=h){
            int m=l+(h-l)/2;
            if(nums[m]>=des){
                h=m-1;
            }else{
                l=m+1;
            }
        }
        return l;
    }
}

376 摆动序列

https://leetcode-cn.com/problems/wiggle-subsequence/

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if(nums==null || nums.length==0)
            return 0;
        int up=1;
        int down=1;
        for(int i=1;i<nums.length;i++){
            if(nums[i]-nums[i-1]>0){
                up=down+1;
            }else if(nums[i]-nums[i-1]<0){
                down=up+1;
            }
        }
        return Math.max(down,up);
    }
}

0-1 背包

416 分割等和子集

https://leetcode-cn.com/problems/partition-equal-subset-sum/
可以看成一个背包大小为 sum/2 的 0-1 背包问题。dp[0]=true;//初始条件

class Solution {
    public boolean canPartition(int[] nums) {
        if(nums==null || nums.length==0)
            return false;
        int sum=0;
        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
        }
        if(sum%2!=0)
            return false;
        int des=sum/2;
        boolean dp[]=new boolean[des+1];
        dp[0]=true;//初始条件
        for(int num:nums){
            for(int i=des;i>=num;i--){//0-1 背包一个物品只能用一次,故从后往前，先计算dp[i]再计算 dp[i-num]
                dp[i]=dp[i] || dp[i-num];
            }
        }
        return dp[des];
    }
}

494 目标和

https://leetcode-cn.com/problems/target-sum/
该问题可以转换为 Subset Sum 问题，从而使用 0-1 背包的方法来求解。

可以将这组数看成两部分，P 和 N，其中 P 使用正号，N 使用负号，有以下推导：

  sum(P) - sum(N) = target
  sum(P) + sum(N) + sum(P) - sum(N) = target + sum(P) + sum(N)
  2 * sum(P) = target + sum(nums)

class Solution {
    public int findTargetSumWays(int[] nums, int S) {
        if(nums==null || nums.length==0)
            return 0;
        int sum=0;
        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
        }
        if (sum < S || (sum + S) % 2 == 1) {
            return 0;
        }
        int des=(S+sum)/2;
        int dp[]=new int[des+1];
        dp[0]=1;
        for(int num:nums){
            for(int i=des;i>=num;i--){
                dp[i]+=dp[i-num];
            }
        }
        return dp[des];
    }
}

474 一和零

https://leetcode-cn.com/problems/
这是一个多维费用的 0-1 背包问题，有两个背包大小，0 的数量和 1 的数量。

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        if(strs==null || strs.length==0)
            return 0;
        int dp[][]=new int[m+1][n+1];
        for(String str:strs){
            char ch[]=str.toCharArray();
            int count_0=0;
            int count_1=0;
            for(int i=0;i<ch.length;i++){
                if(ch[i]-'0'==0){
                    count_0++;
                }else if(ch[i]-'0'==1){
                    count_1++;
                }
            }
            for(int i=m;i>=count_0;i--){
                for(int j=n;j>=count_1;j--){
                    dp[i][j]=Math.max(dp[i][j],dp[i-count_0][j-count_1]+1);
                }
            }
        }
        return dp[m][n];
    }
}

322 零钱兑换

https://leetcode-cn.com/problems/coin-change/
方法一：因为硬币可以重复使用，因此这是一个完全背包问题。完全背包只需要将 0-1 背包中逆序遍历 dp 数组改为正序遍历即可。

class Solution {
    public int coinChange(int[] coins, int amount) {
        if(coins==null || coins.length==0 ){
            return -1;
        }
        if(amount==0)
            return 0;
        int dp[]=new int[amount+1];
        for(int coin:coins){
            for(int i=coin;i<=amount;i++){
                if(i==coin){
                    dp[i]=1;
                }else if(dp[i]==0 && dp[i-coin]!=0){
                    dp[i]=dp[i-coin]+1;
                }else if(dp[i-coin]!=0){
                    dp[i]=Math.min(dp[i],dp[i-coin]+1);
                }
            }
        }
        return dp[amount]==0?-1:dp[amount];
    }
}

方法二：dfs+剪枝，比dp效果好

class Solution {
    public int coinChange(int[] coins, int amount) {
        Arrays.sort(coins);
        recursion(coins, amount, 0, coins.length - 1);
        return minCount == Integer.MAX_VALUE ? -1 : minCount;
    }
    int minCount = Integer.MAX_VALUE;
    /**
     * 1、按金额从大到小，从多到少（排序，用余数一步到位）
     * 2、count + amount / coins[index] >= minCount 预判低于最优解，终止递归（可以返回最优解，不过提升有限，意义不大）
     * 3、能整除即可返回
     */
    void recursion(int[] coins, int amount, int count, int index) {
        if (index < 0 || count + amount / coins[index] >= minCount) return;
        if (amount % coins[index] == 0) {
            minCount = Math.min(minCount, count + amount / coins[index]);
            return;
        }
        for (int i = amount / coins[index]; i >= 0; i--) {
            recursion(coins, amount - i * coins[index], count + i, index - 1);
        }
    }
}

类似完全背包问题还有 518 零钱兑换 II

139 单词拆分

https://leetcode-cn.com/problems/word-break/
dict 中的单词没有使用次数的限制，因此这是一个完全背包问题。该问题涉及到字典中单词的使用顺序，因此可理解为涉及顺序的完全背包问题。

dp[i]表示字符串s的前i个字符能否拆分成wordDict

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        // 可以类比于背包问题
        int n = s.length();
        // memo[i] 表示 s 中以 i - 1 结尾的字符串是否可被 wordDict 拆分
        boolean[] memo = new boolean[n + 1];
        memo[0] = true;
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < i; j++) {
                if (memo[j] && wordDict.contains(s.substring(j, i))) {
                    memo[i] = true;
                    break;
                }
            }
        }
        return memo[n];
    }
}

377 组合总和 Ⅳ

https://leetcode-cn.com/problems/combination-sum-iv/
顺序的完全背包。

class Solution {
    public int combinationSum4(int[] nums, int target) {
        if(nums==null||nums.length==0)
            return 0;
        int dp[]=new int[target+1];
        Arrays.sort(nums);
        dp[0]=1;
        for(int i=1;i<=target;i++){
            for(int num:nums){
                if(i>=num){
                    dp[i]=dp[i]+dp[i-num];
                }else{
                    break;
                }                
            }
        }
        return dp[target];
    }
}

股票交易

参考1

309 最佳买卖股票时机含冷冻期

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/
在这里插入图片描述

class Solution {
    public int maxProfit(int[] prices) {
        if(prices==null || prices.length==0)
            return 0;
        int len=prices.length;
        int s0[]=new int[len];
        int s1[]=new int[len];
        int s2[]=new int[len];
        s0[0]=0;
        s1[0]=-prices[0];
        s2[0] = 0;
        for(int i=1;i<prices.length;i++){
            s0[i]=Math.max(s0[i-1],s2[i-1]);
            s1[i]=Math.max(s1[i-1],s0[i-1]-prices[i]);
            s2[i]=s1[i-1]+prices[i];
        }
        return Math.max(s0[len-1],s2[len-1]);
    }
}

714 买卖股票的最佳时机含手续费

https://leetcode-cn.com/problems/coin-change/
在这里插入图片描述

class Solution {
    public int maxProfit(int[] prices, int fee) {
        if(prices==null||prices.length==0)
            return 0;
        int len=prices.length;
        int s0[]=new int[len];
        int s1[]=new int[len];
        s0[0]=0;
        s1[0]=-prices[0];
        for(int i=1;i<len;i++){
            s0[i]=Math.max(s0[i-1],s1[i-1]+prices[i]-fee);
            s1[i]=Math.max(s1[i-1],s0[i-1]-prices[i]);
        }
        return Math.max(s0[len-1],s1[len-1]);
    }
}

字符串编码

583 两个字符串的删除操作

https://leetcode-cn.com/problems/delete-operation-for-two-strings/
可以转换为求两个字符串的最长公共子序列问题。

class Solution {
    public int minDistance(String word1, String word2) {
        
        int m=word1.length();
        int n=word2.length();
        int dp[][]=new int[m+1][n+1];
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(word1.charAt(i-1)==word2.charAt(j-1)){
                    dp[i][j]=dp[i-1][j-1]+1;
                }else{
                    dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        return m+n-2*dp[m][n];
    }
}

72 编辑距离

https://leetcode-cn.com/problems/edit-distance/
思想可参考：https://www.jianshu.com/p/a617d20162cf
假设序列S和T的长度分别为m和n, 两者的编辑距离表示为dp[m][n]. 则对序列进行操作时存在以下几种情况:

  • a, 当S和T的末尾字符相等时, 对末尾字符不需要进行上述定义操作中(亦即"编辑")的任何一个, 也就是不需要增加计数. 则满足条件: dp[m][n] = dp[m - 1][n - 1]
  • b, 当S和T的末尾字符不相等时, 则需要对两者之一的末尾进行编辑, 相应的计数会增加1.
  • b1, 对S的末尾进行修改, 以使之与T相等, 则此时dp[m][n] = dp[m - 1][n - 1] + 1
  • b2, 删除S末尾的元素, 使S与T相等, 则此时dp[m][n] = dp[m - 1][n] + 1
  • b3, 在S的末尾添加T的尾元素, 使S和T相等, 则此时S的长度变为m+1, 但是此时S和T的末尾元素已经相等, 只需要比较S的前m个元素与T的前n-1个元素, 所以满足dp[m][n] = dp[m][n - 1] + 1;
public int minDistance(String word1, String word2) {
    if (word1 == null || word2 == null) {
        return 0;
    }
    int m = word1.length(), n = word2.length();
    int[][] dp = new int[m + 1][n + 1];
    for (int i = 1; i <= m; i++) {
        dp[i][0] = i;
    }
    for (int i = 1; i <= n; i++) {
        dp[0][i] = i;
    }
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                dp[i][j] = dp[i - 1][j - 1];
            } else {
                dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i][j - 1], dp[i - 1][j])) + 1;
            }
        }
    }
    return dp[m][n];
}
qq_36091872
关注
专栏目录
动态规划算法之0-1背包问题
花开归矣的博客
03-15 7815
待续。。。 代码实现 package com.zzb.algorithm.dynamic; /** * 动态规划算法 * 应用实例：0-1背包问题（限制每个物品要么拿（1个），要么不拿（0个）） */ public class KnapsackProblem { public static void main(String[] args) { // 每个物品的重量 ...
494.目标和
路漫漫其修远兮
12-02 189
题目描述 给定一个非负整数数组，a1, a2, ..., an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。 返回可以使最终数组和为目标数 S 的所有添加符号的方法数。 示例 输入: nums: [1, 1, 1, 1, 1], S: 3 输出: 5 解释: -1+1+1+1+1 = 3 +1-1+...
动态规划之0-1背包问题（详解+分析+原码）
热门推荐
未见花闻的博客
05-08 4万+
本篇文章将介绍算法专题之动态规划中的背包问题，更准确的说是背包问题中最简单的一种类型，即0-1背包问题，就是给你一定容量的背包和若干物品，每种物品只能选一次，告诉你每件物品的价值和体积，求背包里面物品的最大总价值。
0-1背包问题（动态规划）
2301_79582459的博客
05-21 1873
0-1背包问题（动态规划）
动态规划解0-1背包问题（超详细理解）
fly_view的博客
08-10 1639
动态规划解0-1背包问题，超详细理解
动态规划0-1背包基本介绍
server643的博客
03-26 1187
动态规划(0-1背包) 0-1背包是动态规划很经典的题目，其经典问题往往能够引申出很多的应用。所以最近都在整理0-1背包的基本问题和解法，并且稍微简略描述其0-1背包的应用来灵活运用其知识。 1、0-1背包经典问题和分析 有n件物品和一个最多能背重量为w的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。 每件物品只能使用一次，求解将这些物品装入背包里物品价值总和最大。 物品 重量 价值 物品0 1 15 物品1 3 20 物品2 4 30 解法一：动态
动态规划-（0-1）背包问题
菜鸟的博客
10-29 1万+
下面我用容积代表重量（我是不会承认我看走眼了的。又懒得改。）0-1背包问题是动态规划背包问题系列的最基础的一个问题。相对理解起来较为简单。按书上来说，要证明一个问题是否可以使用动态规划思想，需要满足最优子结构的性质，那么什么是最优子结构的性质呢？书上给出的定义如下图看起来很拗口，其实就是不论过去状态和决策如何，对前面的决策所形成的状态而言，余下的诸决策必须构成最优策略。说白了就是一个最优策略的子策略也是必须是最优的，而所有子问题的局部最优解将导致整个问题的全局最优。
动态规划-----背包类问题（0-1背包与完全背包）详解
2302_79862386的博客
03-31 3976
背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。问题的名称来源于如何选择最合适的物品放置于给定背包中。相似问题经常出现在商业、组合数学，计算复杂性理论、密码学和应用数学等领域中。也可以将背包问题描述为决定性问题，即在总重量不超过W的前提下，总价值是否能达到V？它是在1978年由Merkle和Hellman提出的。
动态规划解0-1背包问题
weixin_49571787的博客
05-30 4343
动态规划解0-1背包问题 动态规划解0-1背包问题是一个十分典型案例，我从网上查询好多相关资料，但是大部分都深奥难懂，并不适合初学算法的小白，其中涉及的递推关系式、填表，以及最后的二维表简化为一维表的优化过程，好多都是一笔带过，所以，今天就尽我所能，来叙述一下对于0-1背包问题使用动态规划来求解。 要解决0-1背包问题，首先咱们要解决的是什么是动态规划。 动态规划 先说一说什么是动态规划。 动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题
动态规划法求解0-1背包问题实验报告.pdf
06-05
0-1背包问题是一个经典的优化问题，主要涉及动态规划算法的运用。在这个实验报告中，学生使用Java语言解决了一个0-1背包问题的实例。以下是关于这个问题和解决方案的详细解释。 一、问题描述： 0-1背包问题的核心是...
动态规划求0-1背包问题c++代码
09-10
提供0-1背包问题c++代码，实现功能如下： /**输入参数： * @param m 表示背包的最大容量 * @param n 表示商品个数 * @param a[] 每个商品的容量 * @param p[] 每个商品的价值 */ /**输出： 求最大商品value*/
PHP动态规划解决0-1背包问题实例分析
10-24
在0-1背包问题中，动态规划的基本思路是把问题划分为n个阶段，每个阶段对应一个物品，决策是在每个物品上做选择——装入或不装入背包。对于每个阶段和每种容量，计算能够得到的最大价值。 在PHP中实现动态规划解决0...
S2022026基于C语言的动态规划解决0-1背包课设.zip
09-20
基于C语言的动态规划解决0-1背包课设 项目评分(最低0分，满分5分) 难度系数:3分 工作量:5分 创新点:3分 界面美化:5分 使用技术 编译器:vscode 项目包含内容 (包含课设内容) 项目源码 运行效果视频地址：【基于...
动态规划解决0-1背包问题-0-1 knapsack problem.zip
03-10
动态规划是解决0-1背包问题的有效方法，尤其适用于C#编程语言。 动态规划是一种通过将复杂问题分解为子问题来求解的方法。对于0-1背包问题，我们可以构建一个二维数组dp，其中dp[i][w]表示在前i个物品中选取总重量...
【AGC005D】~K Perm Counting（计数抽象成图）
2301_77025310的博客
10-01 2802
注意到位置为id，权值为v ,不合法的情况，当且仅当 v = id+k或 v= id-k。dp(i,j,pd)表示考虑到第i号点， 连了j条边，是否有连接i 到 i-1号点。因此，我们把每一个位置和权值抽象成点 ，不合法的情况之间连一条边，可以构成二分图。由此可知，当选了n条边，就恰好n个位置不合法，限制条件是：连的边不能相邻，求出f(m) ，f(m)指代至少有m个位置不合法的方案数。由此总共有2n 个点 k 条链，链与链之间无边 互不干涉。把二分图展开成k条链，进行dp。简单的乘法原理罢了。
C++ | Leetcode C++题解之第514题自由之路
Ddddddd_158的博客
10-27 390
C++ | Leetcode C++题解之第514题自由之路
算法竞赛——02基本算法
最新发布
QD_Jason的博客
10-31 612
算法竞赛——02基本算法
数对的最大曼哈顿距离[ABC178E] Dist Max
2301_80882026的博客
10-30 287
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值