leetcode[198, 70]

198 打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

示例 1:

输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
  偷窃到的最高金额 = 1 + 3 = 4 。
示例 2:

输入: [2,7,9,3,1]
输出: 12
解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
  偷窃到的最高金额 = 2 + 9 + 1 = 12 。

解法1

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

这个是经典的动态规划问题

动态规划方程：dp[n] = MAX( dp[n-1], dp[n-2] + num )

由于不可以在相邻的房屋闯入，所以在当前位置 n 房屋可盗窃的最大值，要么就是 n-1 房屋可盗窃的最大值，要么就是 n-2 房屋可盗窃的最大值加上当前房屋的值，二者之间取最大值.

举例来说：

1 号房间可盗窃最大值为 33 即为 dp[1]=3，

2 号房间可盗窃最大值为 44 即为 dp[2]=4，

3 号房间自身的值为 22 即为 num=2，那么 dp[3] = MAX( dp[2], dp[1] + num ) = MAX(4, 3+2) = 5，3 号房间可盗窃最大值为 55

时间复杂度：O(n)

i = 2时， dp[2] ：

i = 3时， dp[3] ：

i = 4时， dp[4] ：

解法2

/**
 * @param {number[]} nums
 * @return {number}
 */
var rob = function(nums) {
    var oddSum =0, evenSum = 0;
    
    for(var i = 0; i<nums.length; i++) {
        if(i%2 == 0) {
            evenSum += nums[i]
            evenSum = Math.max(oddSum, evenSum)
        } else {
            oddSum += nums[i]
            oddSum = Math.max(oddSum, evenSum)
        }
        
    }
    
    return Math.max(oddSum, evenSum)
};


![clipboard.png](/img/bVbvTSV)


![clipboard.png](/img/bVbvTWE)

70 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。

1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

解法一 ：暴力递归

（超时警告）

var climbStairs = function(n) {
    if(n < 3)  {
        return n
    } else {
        return climbStairs(n-1) + climbStairs(n-2)
    }
};

解法2: 优化解法1， 实现一个记忆功能

递归果然是又慢又吃内存 = =， 简单优化一下， 减少点计算次数， 虽然还是慢， 好在能通过了：

/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function(n) {
    
    let cache = {}
    
    function _fn(n) {
    
        if(cache[n])  return cache[n]
        
        if(n < 3) return n
        
        let prev = _fn(n - 1);
        cache[n - 1] = prev;
        
        let next = _fn(n - 2);
        cache[n - 2] = next;
        
        return prev + next;
    }
    return _fn(n)
};

解法3： 动态规划

/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function(n) {
    var dp = [];
        dp[0] = 0
        dp[1] = 1
        dp[2] = 2
    
    for(var i = 3; i <= n; i++ ) {
        dp[i] = dp[i-1] + dp[i-2]
    }
    
    return dp[n]
};

https://www.zhihu.com/questio...

https://leetcode-cn.com/probl...