动态规划（js版）

已于 2022-02-27 16:57:04 修改
阅读量5.4k 收藏 34
点赞数 12
分类专栏： 笔记 文章标签： 1024程序员节 动态规划 算法 leetcode javascript
于 2021-10-24 22:33:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46403734/article/details/120802026
版权

1. 动态规划算法介绍

理解动态规划 ~ 知乎好文
在这里插入图片描述
LeetCode简单的动态规划题：

LeetCode较难的动态规划题：

总结：

动态规划与其说是一个算法，不如说是一种方法论。
该方法论主要致力于将“合适”的问题拆分成三个子目标一一击破：

  • 1.建立状态转移方程
  • 2.缓存并复用以往结果
  • 3.按顺序从小往大算

2. “01背包”问题

概念：有N件物品和一个最多能装重量为W 的背包。第i件物品的重量是weight[i]，价值是value[i]。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

本案例视频链接 ~ 尚硅谷
在这里插入图片描述
分析：
在这里插入图片描述
在这里插入图片描述
图解分析：
在这里插入图片描述
案例分析：

1. 假如现在只有  吉他(G) ， 这时不管背包容量多大，只能放一个吉他1500(G) 
2. 假如有吉他和音响, 验证公式:v[1][1] =1500
	(1). i = 1, j = 1 
	(2). w[i] = w[1] = 1 j = 1   
	v[i][j]=max{v[i-1][j], v[i]+v[i-1][j-w[i]]} : 
	v[1][1] = max {v[0][1], v[1] + v[0][1-1]} = max{0, 1500 + 0} = 1500
3. 假如有吉他/音响/电脑, 验证公式:v[3][4] 
	(1). i = 3；j = 4
	(2). w[i] = w[3] =3  j = 4
	j = 4 >= w[i] = 3 => 4 >= 3
	v[3][4] = max {v[2][4], v[3] + v[2][1]} = max{3000, 2000+1500} = 2000+1500

归纳：

从表格的右下角开始回溯，如果发现前n个物品的最佳组合的价值和前n-1个物品最佳组合的价值一样，说明第n个物品没有被装入；否则，第n个物品被装入。

问题：背包容量为4时，能装入物品的最大价值是多少？

代码：第一种写法

const w = [1, 4, 3]; //物品重量
const value = [1500, 3000, 2000]; //物品的价值 
const m = 4; //背包容量
const n = 3; //物品的个数

// 二维数组：v[i][j] 表示在前i个物品中能够装入容量为j的背包中的最大价值
let v = new Array(n + 1).fill(0).map(() => new Array(m + 1).fill(0));

// i控制行，j控制列
for (let i = 1; i <= n; i++) { // 先遍历物品
    for (let j = 1; j <= m; j++) { // 后遍历背包容量
    	// 这里使用w[i - 1]是避免跳过第一个物品，同理else中的语句也是一样的
        if (w[i - 1] > j) {
            v[i][j] = v[i - 1][j];
        } else {
            v[i][j] = Math.max(v[i - 1][j], value[i - 1] + v[i - 1][j - w[i - 1]]);
        }
    }
}

// for (let j = 1; j <= m; j++) { //先遍历背包容量
//     for (let i = 1; i <= n; i++) { //后遍历物品
//         if (w[i - 1] > j) {
//             v[i][j] = v[i - 1][j];
//         } else {
//             v[i][j] = Math.max(v[i - 1][j], value[i - 1] + v[i - 1][j - w[i - 1]]);
//         }
//     }
// }
console.log(v[n][m]); //3500
// 二维数组v的结果如下：
// [
//     [0, 0, 0, 0, 0],
//     [0, 1500, 1500, 1500, 1500],
//     [0, 1500, 1500, 1500, 3000],
//     [0, 1500, 1500, 2000, 3500]
// ]

// 复杂度分析
// 时间复杂度：O(m*n)
// 空间复杂度：O(m*n)

问题：为何既可以先遍历物品，也可以先遍历背包的容量呢？（为何for循环遍历次序可以不同？）

答：由递推公式可以看出，v[i][j] 是靠 v[i-1][j] 和 v[i - 1][j - w[i-1]] 推导出来的，v[i-1][j] 和 v[i - 1][j - w[i-1]] 都位于 v[i][j] 的左上角方向（包括正上方向），即先打印行或者列，都不影响 v[i][j] 公式的推导。

代码：第二种写法【原理与第一种一样，只不过初始化的过程略有调整】

const w = [1, 4, 3]; //物品重量
const value = [1500, 3000, 2000]; //物品的价值 
const m = 4; //背包容量
const n = 3; //物品的个数
let v = new Array(n).fill(0).map(() => new Array(m + 1).fill(0));

// 初始化
for (let j = w[0]; j <= m; j++) {
    v[0][j] = value[0];
}

for (let i = 1; i < n; i++) { //先遍历物品
    for (let j = 0; j <= m; j++) { //后遍历背包容量
        // 初始化时，第一个物品已经安排上了(第一行打印完成)，故不需要w[i-1]了
        if (w[i] > j) {
            v[i][j] = v[i - 1][j];
        } else {
            v[i][j] = Math.max(v[i - 1][j], value[i] + v[i - 1][j - w[i]]);
        }
    }
}

// for (let j = 0; j <= m; j++) { //先遍历背包容量
//     for (let i = 1; i < n; i++) { //后遍历物品
//         if (w[i] > j) {
//             v[i][j] = v[i - 1][j];
//         } else {
//             v[i][j] = Math.max(v[i - 1][j], value[i] + v[i - 1][j - w[i]]);
//         }
//     }
// }
console.log(v);
// 二维数组v的结果如下：
// [
//     [0, 1500, 1500, 1500, 1500],
//     [0, 1500, 1500, 1500, 3000],
//     [0, 1500, 1500, 2000, 3500]
// ]

优化代码：将空间复杂度降为O(n)。

二维数组变一维数组： 在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。

const w = [1, 3, 4];
const value = [15, 20, 30];
const n = 4; //背包最大容量
const m = w.length; //物品的个数
let dp = new Array(n + 1).fill(0);

for (var i = 1; i <= m; i++) {
    for (var j = n; j >= w[i - 1]; j--) {
        dp[j] = Math.max(dp[j], dp[j - w[i - 1]] + value[i - 1]);
        // dp[j]: 未放当前物品---> 因为是倒序的，初始化的时候空
        // dp[j - w[i - 1]：剩余背包容量所能装入物品的最大价值
    	// value[i - 1]当前物品的价值
    }
}
console.log(dp);//[ 0, 15, 15, 20, 35 ]

注意要点：

  1. 内层循环倒序遍历（且注意判断条件：j >= w[i - 1]）

原因：倒叙遍历是为了保证物品 i 只被放入一次！一旦正序遍历了，那么物品就会被重复加入多次！

  1. 为何能变为一维数组

原因：实际上是把dp[i - 1]那一层拷贝到dp[i]上。

LeetCode中 “01背包” 题型汇总：

3. “完全背包”问题

概念：有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，价值是value[i]。每件物品都有无限个（也就是可以放入背包多次），求解将哪些物品装入背包里物品价值总和最大。

完全背包和01背包问题唯一不同的地方就是，每种物品有无限件。
代码：

const w = [1, 3, 4];
const value = [15, 20, 30];
const n = 4; //背包最大容量
const m = w.length; //物品的个数
let dp = new Array(m + 1).fill(0).map(v => new Array(n + 1).fill(0));

for (var i = 1; i <= m; i++) {
    for (var j = 1; j <= n; j++) {
        for (var k = 0; k <= j / w[i - 1]; k++) {
            if (w[i - 1] > j) {
                dp[i][j] = dp[i - 1][j];
            } else {
                dp[i][j] = Math.max(dp[i - 1][j], k * value[i - 1] + dp[i][j - k * w[i - 1]]);
            }
        }

    }
}
console.log(dp);
// [
//     [0, 0, 0, 0, 0],
//     [0, 15, 30, 45, 60],
//     [0, 15, 30, 45, 60],
//     [0, 15, 30, 45, 60]
// ]

优化代码：将空间复杂度降为O(n)。二维数组变一维数组

视频链接：完全背包问题

  • 第一种写法：
const w = [1, 3, 4];
const value = [15, 20, 30];
const n = 4; //背包最大容量
const m = w.length; //物品的个数
let dp = new Array(n + 1).fill(0);

for (var i = 1; i <= m; i++) {
    for (var j = n; j >= w[i - 1]; j--) {
        for (var k = 0; k <= j / w[i - 1]; k++) {
            dp[j] = Math.max(dp[j], dp[j - k * w[i - 1]] + k * value[i - 1]);
        }
    }
}
console.log(dp);
//[0, 15, 30, 45, 60]
  • 第二种写法（推荐）
const w = [1, 3, 4];
const value = [15, 20, 30];
const n = 4; //背包最大容量
const m = w.length; //物品的个数
let dp = new Array(n + 1).fill(0);

for (var i = 1; i <= m; i++) {
    for (var j = w[i - 1]; j <= n; j++) {
        dp[j] = Math.max(dp[j], dp[j - w[i - 1]] + value[i - 1]);
    }
}
console.log(dp);
//[0, 15, 30, 45, 60]

第二种写法注意要点：

  • 内层循环变为正向遍历
  • 递推方程式与01完全背包一致

LeetCode中 “完全背包” 题型汇总：

总结：

求装满背包有几种方法，递归公式都是一样的，递推公式一般为：dp[j] += dp[j - nums[i]]; 但关键在于遍历顺序不同！

  • 如果求组合数就是外层for循环遍历物品，内层for遍历背包。

  • 如果求排列数就是外层for遍历背包，内层for循环遍历物品。

4. “打家劫舍”系列

5. “股票”系列【大多可用“贪心”思维】

6. “子序列”系列

以下标黄题目思路基本一致：

7. “跳跃游戏”系列【可用“贪心”思维】

巨人张
关注
  • 12
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
js 实现动态规划
mushroomLNL的博客
04-09 1809
js实现动态规划 , 优化时间 , 优化空间 详情见小灰的算法之旅 , 以下是我个人的见解 题目: 很久很久以前，有一位国王拥有5座金矿，每座金矿的黄金储量不同， 需要参与挖掘的工人人数也不同。例如有的金矿储量是500kg黄金，需 要5个工人来挖掘；有的金矿储量是200kg黄金，需要3个工人来挖 掘…… 如果参与挖矿的工人的总数是10。每座金矿要么全挖，要么不挖，不能 派出一半人挖取一半的金矿。要求用程序求出，要想得到尽可能多的黄金，应该选择挖取哪几座金矿？ 一开始的思路: 首先我们想到的是 : 求出每个
JavaScript算法之动态规划
weixin_43183219的博客
03-03 1024
JavaScript动态规划，斐波那契数，泰波那序契列
js 高级算法 - 动态规划
weixin_30463341的博客
05-23 289
主要是看了《数据结构与算法》有所感悟，虽然这本书被挺多人诟病的，说这有漏洞那有漏洞，但并不妨碍我们从中学习知识。 其实像在我们前端的开发中，用到的高级算法并不多，大部分情况if语句，for语句，swith语句等等，就可以解决了。稍微复杂的，可能会想到用递归去的解决。 但要注意的是递归写起来简洁，但实际上执行的效率并不高。 我们再看看动态规划的算法： 动态规划解决方案从底部开始解决...
JavaScript数据结构与算法：动态规划
追风Programer的博客
03-20 1029
动态规划（Dynamic Programming）是一种将一个问题分解成多个子问题，从而简化问题，提升效率的算法思想。它可以应用于各种算法领域，如最短路径问题、背包问题、字符串匹配问题等。在JavaScript中，动态规划可以用于优化算法性能，提高程序效率。动态规划的核心思想是将大问题分解成小问题，通过解决子问题来解决大问题。这种思想有时被称为“分治法”。重叠子问题和最优子结构。重叠子问题指的是在求解一个问题时，需要多次计算同样的子问题。最优子结构指的是问题的最优解可以由子问题的最优解递归得出。
javascript动态规划
BigDaddy233333的博客
11-24 366
其实像在我们前端的开发中，用到的高级算法并不多，大部分情况if语句，for语句，swith语句等等，就可以解决了。稍微复杂的，可能会想到用递归去的解决。 但要注意的是递归写起来简洁，但实际上执行的效率并不高。 我们再看看动态规划的算法： 动态规划解决方案从底部开始解决问题， 将所有小问题解决掉， 然后合并成一个整体解决方案， 从而解决掉整个大问题 。 实例举例  （计算斐波那契数列）  ...
JavaScript实现背包问题动态规划
03-29
JavaScript实现背包问题动态规划
JavaScript程序设计高级算法之动态规划实例分析
10-18
在JavaScript编程中，动态规划的应用可以帮助优化代码性能，尤其是在处理大数据量或者需要高效计算的场景。 在JavaScript中实现动态规划，通常涉及以下几个关键点： 1. **定义状态**：首先要明确问题的状态，即...
基于javascript实现的使用动态规划完成瀑布流算法
最新发布
04-18
动态规划 瀑布流布局是前端领域中一个很常见的需求，由于图片的高度是不一致的，所以在多列布局中默认布局下很难获得满意的排列。 我们的需求是，图片高度不规律的情况下，在两列布局中，让左右两侧的图片总高度尽...
leetcode刷题之动态规划
11-13
leetcode刷题之动态规划 动态规划是leetcode刷题中的一种常见的算法思想，它通过将问题分解成小问题，解决小问题，然后将小问题的答案组合起来，解决原来的问题。动态规划的核心思想是将问题分解成小问题，然后将小...
javascript-leetcode面试题解动态规划问题之第494题-题解.zip
03-16
此题解通过JavaScript实现，展示了如何运用动态规划解决LeetCode上的实际问题。通过学习和实践这类问题，开发者可以提升解决复杂问题的能力，这对于准备求职面试至关重要。在实际的面试中，类似的问题可能要求在时间...
动态规划——JavaScript
zg0601的博客
12-09 423
动态规划——JavaScript实现
JS算法之动态规划
weixin_52884694的博客
10-10 1630
❝ 如果不能避免被剥削的命运，就要提高自己被剥削的价值。 ❞ 大家好，我是「柒八九」。 今天，我们继续探索JS算法相关的知识点。我们来谈谈关于「动态规划」的相关知识点和具体的算法。 如果，想了解其他数据结构的算法介绍，可以参考我们已经发布的文章。如下是算法系列的往期文章。 文章list 整数常规排序算法数组字符串链表栈队列二叉树回溯法 好了，天不早了，干点正事哇。 你能所学到的知识点 ❝ 动态规划基础知识单序列问题双序列问题矩阵路径问题背包问题 ❞ 动态规划基础知识 运用动态规划解决问题的第一步是识
动态规划法（JavaScript）
Han_Zhou_Z的博客
01-03 599
一、动态规划 动态规划(简称DP)的思想是把一个大的问题进行拆分，细分成一个个小的子问题，且能够从这些小的子问题的解当中推导出原问题的解。 二、性质 1、最优子结构性：既所拆分的子问题的解是最优解 2、无后效性：即子问题的解一旦确定，就不再改变，不受在这之后、包含它的更大的问题的求解决策略影响。 3、子问题重叠性质：既在求解的过程当中，每次产生的子问题并不总是新问题，有些子问题会被重复计算多次。动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只计算一次，然后将其计算结果保存在一个表格中，
JavaScript 算法 -- 动态规划
Sun_blog
10-09 207
动态规划 动态规划是算法设计中的一种方法。 它将一个问题分解为相互重叠的子问题，通过反复求解子问题，来解决原问题。 动态规划与分而治之的区别 动态规划的子问题是相互重叠的； 分而治之的子问题是相互独立的； 例题一：爬楼梯
动态规划算法JS实现
weixin_29005819的博客
12-21 416
综述 使用JS实现动态规划的算法 其实算法无所谓具体语言，而是思想的体现 我们就拿0-1背包来讲述动态规划 保证代码复制下来可直接运行结果 案例引入 在一个夜黑风高的晚上，你做了一个梦，然后，你开始笑了起来 原来是来到了上古神地，你手拿一个蛇皮袋，虽然大，但是有限重的，装多了会破的 你发现桌台上一共有三种物品，他们分别有重量和相应的价值 你想的是尽量把这个袋子装满，装满什么意思呢，就是装到极限重量，然后带回现代上交给国家，由此你获得美誉。 基本思路 总体思路： 先 选择神器 ，在依照 蛇皮袋的容量
JavaScript 算法系列---动态规划
大笨儿钟的博客
12-24 308
很久之前接触过这样一道题目，总共有十层阶梯，从1层开始往上爬，每次可以上1层或者2层，问到10层总共有多少种方法? 思路：这个问题就是动态规划的一个经典例子，所谓动态规划，就是把复杂的问题进行拆解，拆解成一个个子问题，而这类问题最后非常适合使用递归来解决。诸如这道题目，可以记到某层阶梯的走法为F(n)，那么到10层阶梯就是F(10)。 那么F(10)等于什么呢，这里进行假设，如果只差最后一次就可以...
js算法设计思想之“动态规划”
weixin_41643133的博客
02-09 869
动态规划是算法设计中一种方法 它讲一个问题分解为相互重叠的子问题，通过反复求解子问题，来解决原来的问题 解决实例-斐波那契数列问题 leetcode:70 爬楼梯 解题思路 爬到第n阶可以在第n-1阶爬1个台阶，或在第n-2阶爬2个阶梯 F(n) = F(n-1)+F(n-2) 使用动态规划 解题步骤 定义子问题：F(n) = F(n-1)+F(n-2) 反复执行：从2循环到n，执行上述公式 代码 // n：第n阶台阶 var climbStairs = function(n) { .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值