动态规划

• 动态规划是算法设计中的一种思想
• 它将一个问题分为多个相互重叠的子问题，通过反复求解子问题来解决原来的问题（与分而治之不同，分而治之是将问题分解为相互独立的子问题）

场景一：斐波纳切数列

• 定义子问题：F(n) = F(n - 1) + F(n - 2)
• 反复执行：从 2 循环到 n，执行上述公式

leetcode 相关题目

leetcode-70.爬楼梯

/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function (n) {
    // 动态规划，斐波纳切数列
    if (n < 2) return 1;
    let step0 = 1;
    let step1 = 1;
    const dp = [1, 1];
    for (let i = 2; i <= n; i++) {
        const tmp = step0;
        step0 = step1;
        step1 = step1 + tmp;
    }
    return step1;
};

leetcode-198.打家劫舍

/**
 * @param {number[]} nums
 * @return {number}
 */
var rob = function (nums) {
    if (nums.length === 0) return 0;
    let step0 = 0;
    let step1 = nums[0];
    for (let i = 2; i <= nums.length; i++) {
        const tmp = step0;
        step0 = step1;
        step1 = Math.max(tmp + nums[i - 1], step1);
    }
    return step1;
};

leetcode-213.打家劫舍2

/**
 * @param {number[]} nums
 * @return {number}
 */
var rob = function (nums) {
    if (!nums.length) return 0;
    if (nums.length === 1) return nums[0];
    const a1 = nums.slice(1);
    const a2 = nums.slice(0, nums.length - 1);
    const dp1 = [0, a1[0]];
    const dp2 = [0, a2[0]];
    for (let i = 2; i <= a1.length; i++) {
        dp1[i] = Math.max(dp1[i - 2] + a1[i - 1], dp1[i - 1]);
        dp2[i] = Math.max(dp2[i - 2] + a2[i - 1], dp2[i - 1]);
    }
    return Math.max(dp1[dp1.length - 1], dp2[dp2.length - 1]);
};