【js】-【动态规划】-笔记

1 如何优雅地找硬币

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

示例1：
输入: coins = [1, 2, 5], amount = 11
输出: 3
解释: 11 = 5 + 5 + 1

示例2：
输入: coins = [2], amount = 3
输出: -1

const coinChange = function(coins, amount) {
    # 用于保存每个目标总额对应的最小硬币个数
    const f = []

    f[0] = 0
    
    # 遍历 [1, amount] 这个区间的硬币总额
    for(let i=1;i<=amount;i++) {
        # 求的是最小值，我们预设为无穷大
        f[i] = Infinity
        // 循环遍历每个可用硬币的面额
        for(let j=0;j<coins.length;j++) {
            # 若硬币面额小于目标总额，则问题成立
            if(i-coins[j]>=0) {
                // 状态转移方程
                f[i] = Math.min(f[i],f[i-coins[j]]+1)
            }
        }
    }
    // 若目标总额对应的解为无穷大，则意味着没有一个符合条件的硬币总数来更新它，本题无解，返回-1
    if(f[amount]===Infinity) {
        return -1
    }
    // 若有解，直接返回解的内容
    return f[amount]
};

2 0-1背包问题

有 n 件物品，物品体积用一个名为 w 的数组存起来，物品的价值用一个名为 value 的数组存起来；每件物品的体积用 w[i] 来表示，每件物品的价值用 value[i] 来表示。现在有一个容量为 c 的背包，问你如何选取物品放入背包，才能使得背包内的物品总价值最大？
注意：每种物品都只有1件

# 入参是物品的个数和背包的容量上限，以及物品的重量和价值数组
function knapsack(n, c, w, value) {
    // dp是动态规划的状态保存数组
    const dp = (new Array(c+1)).fill(0)  
    
    # res 用来记录所有组合方案中的最大值
    let res = -Infinity
    for(let i=1;i<=n;i++) {
        for(let v=c;v>=w[i];v--) {
            // 写出状态转移方程
            dp[v] = Math.max(dp[v], dp[v-w[i]] + value[i])
            // 即时更新最大值
            if(dp[v] > res) {
                res = dp[v]
            }
        }
    }
    return res
}

3 最长上升子序列模型

题目描述：给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:
输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

var lengthOfLIS = function(nums) {
    if(!nums.length) return 0;
    # 初始化数组里面每一个索引位的状态值
    const dp= new Array(nums.length).fill(1);

    let res =1;
    for(let i=1;i<nums.length;i++){
        for(let j=0;j<i;j++){
       # 若遇到了一个比当前元素小的值，则意味着遇到了一个可以延长的上升子序列，故更新当前元素索引位对应的状态
            if(nums[j]<nums[i]) dp[i]=Math.max(dp[i],dp[j]+1);
        }
        res= Math.max(dp[i],res);
    }
    return res;
};

3.1 最长回文子串

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。

var longestPalindrome = function(s) {
    let n = s.length;
    let res = '';
    let dp = Array.from(new Array(n),() => new Array(n).fill(false));//初始化数组 
    for(let i = n-1;i >= 0;i--){//循环字符串
        for(let j = i;j < n;j++){
          //dp[i][j]表示子串i～j是否是回文子串
          //回文子串必须满足s[i]，s[j]相等。并且向外扩展一个字符也相等，即dp[i+1][j-1]也是回文子串
          //j - i < 2表示子串小于等于1也是回文串
            dp[i][j] = s[i] == s[j] && (j - i < 2 || dp[i+1][j-1]);
            if(dp[i][j] && j - i +1 > res.length){//当前回文子串比之前的大，更新最大长度
                res = s.substring(i,j+1);
            }
        }
    }
    return res;
};

4 不同路径的数目

牛客 BM67 不同路径的数目(一)
补充：定义二维数组的方式

let dp = Array.from(new Array(3), () => new Array(2).fill(1));
console.log(dp);
[[1, 1], [1, 1], [1, 1]]

let dp = new Array(3).fill(0).map(x=>Array(2).fill(1));
console.log(dp)
[[1, 1], [1, 1], [1, 1]]

Array.from (obj, mapFn)
obj指的是数组对象、类似数组对象或者是set对象，map指的是对数组中的元素进行处理的方法。

输入：2,1
返回值：1

输入：2,2
返回值：2

function uniquePaths( m ,  n ) {
    // write code here
    let dp= Array.from(new Array(m),()=>new Array(n).fill(1));
    for(let i=1;i<m;i++){
        for(let j=1;j<n;j++){
            dp[i][j]=dp[i][j-1]+dp[i-1][j];
        }
    }
    return dp[m-1][n-1];
}

5 BM68 矩阵的最小路径和

BM68 矩阵的最小路径和

function minPathSum( matrix ) {
    // write code here
    let x= matrix.length;
    let y=matrix[0].length;
    let dp= Array.from(new Array(x),()=>new Array(y).fill(0));
    dp[0][0]=matrix[0][0];
    //边界情况
    for(let i=1;i<x;i++){
        dp[i][0]=dp[i-1][0]+matrix[i][0];
    }
    for(let j=1;j<y;j++){
        dp[0][j]=dp[0][j-1]+matrix[0][j];
    }
    for(let i=1;i<x;i++){
        for(let j=1;j<y;j++){
            dp[i][j]=matrix[i][j]+Math.min(dp[i][j-1],dp[i-1][j]);
        }
    }
    return dp[x-1][y-1];
}

6 BM70 兑换零钱(一)

BM70 兑换零钱(一)

function minMoney( arr ,  aim ) {
    // write code here
    if(!arr||!arr.length) return -1;
    const dp= new Array(aim+1).fill(Infinity);
    dp[0]=0;
    for(const item of arr) {
        for(let i = item; i <= aim; i++) {
            dp[i] = Math.min(dp[i],dp[i - item] + 1);
        }
    }
    return dp[aim]==Infinity?-1:dp[aim];
}