JavaScript算法模式——动态规划和贪心算法
动态规划
动态规划(Dynamic Programming,DP)是一种将复杂问题分解成更小的子问题来解决的优化算法。下面有一些用动态规划来解决实际问题的算法:
最少硬币找零
给定一组硬币的面额,以及要找零的钱数,计算出符合找零钱数的最少硬币数量。例如,美国硬币面额有1、5、10、25这四种面额,如果要找36美分的零钱,则得出的最少硬币数应该是1个25美分、1个10美分和1个1美分共三个硬币。这个算法要解决的就是诸如此类的问题。我们来看看如何用动态规划的方式来解决。
对于每一种面额,我们都分别计算所需要的硬币数量。具体算法如下:
- 如果全部用1美分的硬币,一共需要36个硬币
- 如果用5美分的硬币,则需要7个5美分的硬币 + 1个1美分的硬币 = 8个硬币
- 如果用10美分的硬币,则需要3个10美分的硬币 + 1个5美分的硬币 + 1个1美分的硬币 = 5个硬币
- 如果用25美分的硬币,则需要1个25美分的硬币 + 1个10美分的硬币 + 1个1美分的硬币 = 3个硬币
对应的示意图如下:
方案4的硬币总数最少,因此为最优方案。
具体的代码实现如下:
function minCoinChange(coins, amount) {
let result = null;
if (!amount) return result; const makeChange = (index, value, min) => {
let coin = coins[index];
let newAmount = Math.floor(value / coin);
if (newAmount) min[coin] = newAmount;
if (value % coin !== 0) {
makeChange(--index, value - coin * newAmount, min);
}
}; const arr = [];
for (let i = 0; i < coins.length; i++) {
const cache = {};
makeChange(i, amount, cache);
arr.push(cache);
} console.log(arr);
let newMin = 0;
arr.forEach(item => {
let min = 0;
for (let v in item) min += item[v];
if (!newMin || min < newMin) {
newMin = min;
result = item;
}
});
return result;
}
函数minCoinChange()接收一组硬币的面额,以及要找零的钱数。我们将上面例子中的值传入:
const result = minCoinChange2([1, 5, 10, 25], 36);
console.log(result);
得到如下结果:
[
{ '': },
{ '': , '': },
{ '': , '': , '': },
{ '': , '': , '': }
]
{ '': , '': , '': }
上面的数组是我们在代码中打印出来的arr的值,用来展示四种不同面额的硬币作为找零硬币时,实际所需要的硬币种类和数量。最终,我们会计算arr数组中硬币总数最少的那个方案,作为minCoinChange()函数的输出。
当然在实际应用中,我们可以把硬币抽象成任何你需要的数字,这个算法能给出你满足结果的最小组合。
背包问题
背包问题是一个组合优化问题,它被描述为:给定一个具有固定容量的背包capacity,以及一组具有价值(value)和重量(weight)的物品,找出一个最优方案,使得装入背包的物品的总重量不超过capacity,且总价值最大。
假设我们有以下物品,且背包的总容量为5:
物品# | 重量 | 价值 |
1 | 2 | 3 |
2 | 3 | 4 |
3 | 4 | 5 |
我们用矩阵来解决这个问题。首先,我们把物品和背包的容量组成如下矩阵:
物品(i)/重量(w) | 0 | 1 | 2 | 3 | 4 | 5 |
0 | 0 | 0 | 0 | 0 | 0 | 0 |
1 (w=2, v=3) | 0 | 0 |
a: 3+[0][2-2]=3+0 b: [0][2]=0 max(3+0,0)=3 |
a: 3+[0][3-2]=3+0 b: [0][3]=0 max(3+0,0)=3 |
a: 3+[0][4-3]=3+0 b: [0][4]=0 max(3+0,0)=3 |
a: 3+[0][5-3]=3+0 b: [0][5]=0 max(3+0,0)=3 |
2 (w=3, v=4) | 0 | 0 | 3 |
a: 4+[1][3-3]=4+0 b: [1][3]=3 max(4+0,3)=4 |
a: 4+[1][4-3]=4+0 b: [1][4]=3 max(4+0,3)=4 |
a: 4+[1][5-3]=4+3 b: [1][5]=3 max(4+3,3)=7 |
3 (w=4, v=5) | 0 | 0 | 3 | 4 |
a: 5+[2][4-4]=5+0 b: [2][4]=4 max(5+0,4)=5 |
a: 5+[2][5-4]=5+0 b: [2][5]=7 max(5+0,7)=7 |
为了便于理解,我们将矩阵kS的第一列和第一行忽略(因为它们表示的是容量0和第0个物品)。然后,按照要求往矩阵的格子里填数。如果当前的格子能放下对应的物品,存在以下两种情况:
- a - 放入当前物品,然后剩余的重量再放入前一个物品
- b - 不放入当前物品,放入前一个物品
在上面的表格中,
- 当背包的重量为1时,没有物品能放入,所以都是0,这个很好理解。
- 当背包的重量为2时,物品1可以放入,那么存在两种情况:放入物品1(价值为3),剩余的重量(背包的重量2减去物品1的重量2,结果为0)再放入前一个物品;不放入物品1,放入前一个物品[0][2],价值为0。所以最大价值就是max(3, 0)=3。
- ......
- 当背包的重量为5时,放入物品2,两种情况:放入物品2(价值为4),剩余的重量(背包的重量5减去物品2的重量3,结果为2)再放入前一个物品,是[1][2],对应的价值是3;不放入物品2,,放入前一个物品[1][5],价值为3。所以最大价值就是max(4+3, 3)=7。
- ......
如果当前物品不能放入背包,则忽略它,用前一个值代替。我们可以按照上面描述的过程把剩余的格子都填满,这样表格中最后一个单元格里的值就是最优方案。
下面是具体的实现代码:
function knapSack(capacity, weights, values, n) {
const kS = []; // 将ks初始化为一个空的矩阵
for (let i = 0; i <= n; i++) {
kS[i] = [];
} for (let i = 0; i <= n; i++) {
for (let w = 0; w <= capacity; w++) {
// 忽略矩阵的第1列和第1行
if (i === 0 || w === 0) {
kS[i][w] = 0;
}
else if (weights[i - 1] <= w) {
const a = values[i - 1] + kS[i - 1][w - weights[i - 1]];
const b = kS[i - 1][w];
kS[i][w] = Math.max(a, b);
}
else {
kS[i][w] = kS[i - 1][w];
}
}
} console.log(kS);
}
对于const a,其价值分为两部分,第一部分就是它自己的价值(values[i - 1]),第二部分是用背包剩余的重量(w - weights[i - 1])装进前一个物品(kS[i - 1])。对于const b,就是找前一个能放入这个重量的物品(kS[i - 1][w])。然后取这两种情况下的最大值。
测试一下knapSack()函数,
const capacity = 5;
const weights = [2, 3, 4];
const values = [3, 4, 5];
knapSack(capacity, weights, values, weights.length);
下面是矩阵kS的输出结果:
[
[ , , , , , ],
[ , , , , , ],
[ , , , , , ],
[ , , , , , ]
]
最长公共子序列(LCS)
找出两个字符串序列的最长子序列的长度。所谓最长子序列,是指两个字符串序列中以相同顺序出现,但不要求连续的字符串序列。例如下面两个字符串:
字符串1:acbaed
字符串2:abcadf
则LCS为acad。
和背包问题的思路类似,我们用下面的表格来描述整个过程:
a | b | c | a | d | f | ||
0 | 0 | 0 | 0 | 0 | 0 | 0 | |
a | 0 | 1 | 1 | 1 | 1 | 1 | 1 |
c | 0 | 1 | 1 | 2 | 2 | 2 | 2 |
b | 0 | 1 | 2 | 2 | 2 | 2 | 2 |
a | 0 | 1 | 2 | 2 | 3 | 3 | 3 |
e | 0 | 1 | 2 | 2 | 3 | 3 | 3 |
d | 0 | 1 | 2 | 2 | 3 | 4 | 4 |
矩阵的第一行和第一列都被设置为0,剩余的部分,遵循下面两种情况:
- 如果wordX[i - 1]和wordY[j - 1]相等,则矩阵对应的单元格的值为单元格[i - 1][j - 1]的值加1。
- 如果wordX[i - 1]和wordY[j - 1]不相等,则找出单元格[i - 1][j]和单元格[i][j - 1]之间的最大值。
下面是具体的实现代码:
function lcs(wordX, wordY) {
const m = wordX.length;
const n = wordY.length;
const l = [];
for (let i = 0; i <= m; i++) {
l[i] = [];
for (let j = 0; j <= n; j++) {
l[i][j] = 0;
}
}
for (let i = 0; i <= m; i++) {
for (let j = 0; j <= n; j++) {
if (i === 0 || j === 0) {
l[i][j] = 0;
} else if (wordX[i - 1] === wordY[j - 1]) {
l[i][j] = l[i - 1][j - 1] + 1;
} else {
const a = l[i - 1][j];
const b = l[i][j - 1];
l[i][j] = Math.max(a, b);
}
}
}
console.log(l);
console.log(l[m][n]);
}
我们将矩阵打印出来,结果如下:
const wordX = ['a', 'c', 'b', 'a', 'e', 'd'];
const wordY = ['a', 'b', 'c', 'a', 'd', 'f'];
lcs(wordX, wordY);
[
[ , , , , , , ],
[ , , , , , , ],
[ , , , , , , ],
[ , , , , , , ],
[ , , , , , , ],
[ , , , , , , ],
[ , , , , , , ]
]
矩阵中最后一个单元格的值为LCS的长度。那如何计算出LCS的具体内容呢?我们可以设计一个相同的solution矩阵,用来做标记,如果wordX[i - 1]和wordY[j - 1]相等,则将solution矩阵中对应的值设置为'diagonal',即上面表格中背景为灰色的单元格。否则,根据[i][j]和[i - 1][j]是否相等标记为'top'或'left'。然后通过printSolution()方法来找出LCS的内容。修改之后的代码如下:
function printSolution(solution, wordX, m, n) {
let a = m;
let b = n;
let x = solution[a][b];
let answer = '';
while (x !== '0') {
if (solution[a][b] === 'diagonal') {
answer = wordX[a - 1] + answer;
a--;
b--;
} else if (solution[a][b] === 'left') {
b--;
} else if (solution[a][b] === 'top') {
a--;
}
x = solution[a][b];
}
return answer;
} function lcs(wordX, wordY) {
const m = wordX.length;
const n = wordY.length;
const l = [];
const solution = [];
for (let i = 0; i <= m; i++) {
l[i] = [];
solution[i] = [];
for (let j = 0; j <= n; j++) {
l[i][j] = 0;
solution[i][j] = '0';
}
}
for (let i = 0; i <= m; i++) {
for (let j = 0; j <= n; j++) {
if (i === 0 || j === 0) {
l[i][j] = 0;
} else if (wordX[i - 1] === wordY[j - 1]) {
l[i][j] = l[i - 1][j - 1] + 1;
solution[i][j] = 'diagonal';
} else {
const a = l[i - 1][j];
const b = l[i][j - 1];
l[i][j] = Math.max(a, b);
solution[i][j] = l[i][j] === l[i - 1][j] ? 'top' : 'left';
}
}
} return printSolution(solution, wordX, m, n);
}
测试结果:
const wordX = ['a', 'c', 'b', 'a', 'e', 'd'];
const wordY = ['a', 'b', 'c', 'a', 'd', 'f'];
console.log(lcs(wordX, wordY)); // acad
贪心算法
贪心算法遵循一种近似解决问题的技术,期盼通过每个阶段的局部最优选择,从而达到全局的最优。它不像动态规划算法那样计算更大的格局。
最少硬币找零
我们来看看如何用贪心算法解决前面提到过的最少硬币找零问题。
function minCoinChange(coins, amount) {
const change = [];
let total = 0;
for (let i = coins.length - 1; i >= 0; i--) {
const coin = coins[i];
while (total + coin <= amount) {
change.push(coin);
total += coin;
}
}
return change;
} const result = minCoinChange([1, 5, 10, 25], 36);
console.log(result); // [ 25, 10, 1 ]
前提是coins数组已经按从小到大排好序了,贪心算法从最大值开始尝试,如果该值不满足条件(要找零的钱数),则继续向下找,直到找到满足条件的所有值。以上算法并不能满足所有情况下找出最优方案,例如下面这种情况:
const result = minCoinChange([1, 2, 5, 9, 10], 18);
console.log(result); // [ 10, 5, 2, 1 ]
给出的结果[10, 5, 2, 1]并不是最优方案,最优方案应该是[9, 9]。
与动态规划相比,贪心算法更简单、效率更高。但是其结果并不总是最理想的。但是综合看来,它相对执行时间来说,输出一个可以接受的结果。
背包问题
物品# | 重量 | 价值 |
1 | 2 | 3 |
2 | 3 | 4 |
3 | 4 | 5 |
在动态规划的例子里,假定背包的容量为5,最佳方案是往背包里装入物品1和物品2,总价值为7。在贪心算法中,我们需要考虑分数的情况,假定背包的容量为6,装入物品1和物品2之后,剩余容量为1,可以装入1/4的物品3,总价值为3+4+0.25×5=8.25。我们来看看具体的实现代码:
function knapSack(capacity, weights, values) {
const n = values.length;
let load = 0;
let val = 0;
for (let i = 0; i < n && load < capacity; i++) {
if (weights[i] <= capacity - load) {
val += values[i];
load += weights[i];
console.log(`物品${i + 1},重量:${weights[i]},价值:${values[i]}`);
} else {
const r = (capacity - load) / weights[i];
val += r * values[i];
load += weights[i];
console.log(`物品${i + 1}的${r},重量:${r * weights[i]},价值:${val}`);
}
} return val;
}
从第一个物品开始遍历,如果总重量小于背包的容量,则继续迭代,装入物品。如果物品可以完整地装入背包,则将其价值和重量分别计入到变量val和load中,同时打印装入物品的信息。如果物品不能完整地装入背包,计算能够装入的比例r,然后将这个比例所对应的价值和重量分别计入到变量val和load中,同时打印物品的信息。最终输出总的价值val。下面是测试结果:
const capacity = 6;
const weights = [2, 3, 4];
const values = [3, 4, 5];
console.log(knapSack(capacity, weights, values));
物品1,重量:,价值:
物品2,重量:,价值:
物品3的0.,重量:,价值:8.25
8.25
在动态规划算法中,如果将背包的容量也设定为6,计算结果则为8。
最长公共子序列(LCS)
最后我们再来看看如何用贪心算法解决LCS的问题。下面的代码返回了两个给定数组中的LCS的长度:
function lcs(wordX, wordY, m = wordX.length, n = wordY.length) {
if (m === 0 || n === 0) {
return 0;
}
if (wordX[m - 1] === wordY[n - 1]) {
return 1 + lcs(wordX, wordY, m - 1, n - 1);
}
const a = lcs(wordX, wordY, m, n - 1);
const b = lcs(wordX, wordY, m - 1, n);
return a > b ? a : b;
} const wordX = ['a', 'c', 'b', 'a', 'e', 'd'];
const wordY = ['a', 'b', 'c', 'a', 'd', 'f'];
console.log(lcs(wordX, wordY)); //
JavaScript算法模式——动态规划和贪心算法的更多相关文章
- python常用算法(6)——贪心算法,欧几里得算法
1,贪心算法 贪心算法(又称贪婪算法)是指,在对问题求解时,总是做出在当前看来是最好的选择.也就是说,不从整体最优上加以考虑,他所做出的的时在某种意义上的局部最优解. 贪心算法并不保证会得到最优解,但 ...
- 『嗨威说』算法设计与分析 - 贪心算法思想小结(HDU 2088 Box of Bricks)
本文索引目录: 一.贪心算法的基本思想以及个人理解 二.汽车加油问题的贪心选择性质 三.一道贪心算法题点拨升华贪心思想 四.结对编程情况 一.贪心算法的基本思想以及个人理解: 1.1 基本概念: 首先 ...
- Java 算法(一)贪心算法
Java 算法(一)贪心算法 数据结构与算法目录(https://www.cnblogs.com/binarylei/p/10115867.html) 一.贪心算法 什么是贪心算法?是指在对问题进行求 ...
- 算法(C#版)动态规划和贪心算法
https://blog.csdn.net/kouzhuanjing1849/article/details/88954811
- 为什么我要放弃javaScript数据结构与算法(第十一章)—— 算法模式
本章将会学习递归.动态规划和贪心算法. 第十一章 算法模式 递归 递归是一种解决问题的方法,它解决问题的各个小部分,直到解决最初的大问题.递归通常涉及函数调用自身. 递归函数是像下面能够直接调用自身的 ...
- 二叉树遍历问题、时间空间复杂度、淘汰策略算法、lru数据结构、动态规划贪心算法
二叉树的前序遍历.中序遍历.后序遍历 前序遍历 遍历顺序规则为[根左右] ABCDEFGHK 中序遍历 遍历顺序规则为[左根右] BDCAEHGKF 后序遍历 遍历顺序规则为[左右根] DCBHKGF ...
- [算法导论]贪心算法(greedy algorithm)
转载请注明出处:http://www.cnblogs.com/StartoverX/p/4611544.html 贪心算法在每一步都做出当时看起来最佳的选择.也就是说,它总是做出局部最优的选择,寄希望 ...
- poj_1042 贪心算法
poj 1042 gone fishing 题目要求: 由有n个湖, 按照顺序排列,一个人从第一个湖向最后一个湖行进(方向只能从湖0到湖n-1),途中可以在湖中钓鱼.在每个湖中钓鱼时,开始的5分钟内可 ...
- 由Leetcode详解算法 之 动态规划(DP)
因为最近一段时间接触了一些Leetcode上的题目,发现许多题目的解题思路相似,从中其实可以了解某类算法的一些应用场景. 这个随笔系列就是我尝试的分析总结,希望也能给大家一些启发. 动态规划的基本概念 ...
随机推荐
- Vue 报错 listen EADDRINUSE :::8080
今天在重启vue项目的时候,发现报了错, listen EADDRINUSE :::8080错误提示 原因:因为另一个项目占用了8080端口,我直接在命令行npm run dev第二个项目,就给出了这 ...
- jquery的addClass、removeClass、toggleClass方法
1.addClass()添加类 1.1 用jquery为某一个元素添加类 $("div").addClass("active");//给div元素添加activ ...
- 【MySQL】Illegal mix of collations (utf8mb4_general_ci,IMPLICIT) and ...
线上遇到这个问题,详细信息如下: SQL state [HY000]; error code [1267]; Illegal mix of collations (utf8mb4_general_ci ...
- 【Android】java.lang.SecurityException: getDeviceId: Neither user 10065 nor current process has android.permission.READ_PHONE_STATE
RT, 异常信息如下: java.lang.SecurityException: getDeviceId: Neither user 10065 nor current process has and ...
- WeihanLi.Npoi 导出支持自定义列内容啦
WeihanLi.Npoi 导出支持自定义列内容啦 Intro 之前也有网友给提出过希望列合并或者自定义列内容的 issue 或请求,起初因为自己做 WeihanLi.Npoi 这个扩展的最初目的是导 ...
- memcached.c 源码分析
上文分析了memcached的autoconf过程以及configure, make过程,可以看到,memcached可执行文件是由memcached-memcached.o以及其他文件连接后编译出来 ...
- Dubbo里面线程池的拒绝策略
Dubbo里面线程池的拒绝策略 public class AbortPolicyWithReport extends ThreadPoolExecutor.AbortPolicy { protecte ...
- Unity的弱联网Json数据传输
注意事项: 关于dictionary转json的工程中遇到一点问题:要手动添加双引号. 关于json转dictionary:同样需要手动去掉双引号,否则添加到dictionary中的字符串会带有双引号 ...
- 从零开始实现ASP.NET Core MVC的插件式开发(四) - 插件安装
标题:从零开始实现ASP.NET Core MVC的插件式开发(四) - 插件安装 作者:Lamond Lu 地址:https://www.cnblogs.com/lwqlun/p/11260750. ...
- [趣学程序]java的常用类之String
java基础之常用类 String类 String表示字符串,所谓字符串,就是一连串的字符,是java中最常用的类之一. String是不可变类,一旦String对象被创建,包含在对象中的字符序列(内 ...