动态规划学习一——打家劫舍

动态规划

1.核心思想

将大问题划分为小问题进行解决，从而一步步获得获取最优解。经分解得到的子问题往往不是独立的，即下一个子阶段的求解是建立在上一个子阶段的解的基础上进一步求解的。

2.动态规划解题四步

1. 确定状态
2. 写出状态转移方程
3. 考虑初始化
4. 考虑输出

3.案例分析

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1：
输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。
提示：
0 <= nums.length <= 100
0 <= nums[i] <= 400

来源：力扣（LeetCode）

3.1解题思路

由题意知，小偷对于每一个房屋都有偷与不偷两种选择，且当前的选择是受上一次偷窃的房屋号影响的（因为不能偷窃相邻的房屋）。
假设当前小偷处于房屋 i ，有两种情况：
– 偷 了i 号房屋，则偷窃总金额 = 前 i-2 号房屋的最高偷窃金额 + i 号房屋的金额；
– 没偷 i 号房屋，则偷窃总金额 = 前 i-1 号房屋的最高偷窃金额。
最后取上述两种情况的最优解。

3.2结合动态规划解题四步走（设计一维状态变量）

• 确定状态
  dp[i]： 0 ~ i 号房屋能偷窃到的最高金额
  money[i]：i 号房屋的金额
• 写出状态转移方程
  dp[i] = Math.max( dp[i-2]+money[i], dp[i-1] )
• 考虑初始化
  由状态转移方程知，最小下标为i-2，所以应初始化 dp[0] 和 dp[1]，让 i 从2开始计算。
  – dp[0]：当只有0号房屋可以偷窃时，显然最高偷窃金额就是当前房屋的金额，即 = money[0]；
  – dp[1]：当0号和1号房屋都可以偷窃时，选取房屋金额最多的一个，即 = Math.max(money[0], money[1])。
• 确定输出
  dp[money.length -1]

var rob = function(money) {
     
    let len = money.length;
    if(len == 0) return 0;
    if(len == 1) return money[0];
    // 确定状态
    const dp = [];
    // 初始化
    dp[0] = money[0];
    dp[1] = Math.max(money[0], money[1]);
    // 使用动态转移方程
    for(let i=2; i<len; i++) {
     
        dp[i] = Math.max(dp[i-1], dp[i-2]+money[i]);
    }
    // 输出
    return dp[len-1];
};

3.3结合动态规划解题四步走（设计二维状态变量）

• 确定状态
  dp[i][0]： 不偷窃 i 号房屋的情况下，0 ~ i 号房屋能偷窃到的最高金额
  dp[i][1]： 偷窃 i 号房屋的情况下，0 ~ i 号房屋能偷窃到的最高金额
  money[i]：i 号房屋的金额
• 写出状态转移方程
  dp[i][0] = Math.max( dp[i-1][0], dp[i-1][1] )
  dp[i][1] = dp[i-1][0]+money[i]
• 考虑初始化
  由状态转移方程知，最小下标为i-1，所以应初始化 dp[0][0] 和 dp[0][1]，让 i 从1开始计算。
  – dp[0][0]：当只有0号房屋可以偷窃时，不偷窃 0 号房屋的最高偷窃金额就是0，即 = 0；
  – dp[0][1]：当只有0号房屋可以偷窃时，偷窃0号房屋的最高金额金额就是0号房屋的金额，即 = money[0])。
• 确定输出
  取 dp[money.length -1][0] 和 dp[money.length -1][1] 之间的最大值

var rob = function(money) {
     
    let len = money.length;
    if(len == 0) return 0;
    if(len == 1) return money[0];
    // 确定状态
    const dp = [];
    for(let i = 0; i<len; i++) {
     
        dp[i] = [];
    }
    // 初始化
    dp[0][0] = 0;
    dp[0][1] = money[0];
    // 使用状态转移方程
    for(let i=1; i<len; i++) {
     
        dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1]);
        dp[i][1] = dp[i-1][0] + money[i];
    }
    // 确定输出
    return Math.max(dp[len-1][0], dp[len-1][1]);
};

参考LeetCode题解：动态规划（经典问题，掌握如何消除后效性）