[Dynamic Programming] 198. House Robber

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.

Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.

Input: [1,2,3,1]
Output: 4
Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
             Total amount you can rob = 1 + 3 = 4.

Input: [2,7,9,3,1]
Output: 12
Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
             Total amount you can rob = 2 + 9 + 1 = 12.

1 Form bottom-up approach

/**
 * @param {number[]} nums
 * @return {number}
 */

var rob = function(nums) {
    // if there is nothing, return 0
    if (nums.length === 0) {
        return 0;
    }
    
    // if there is only one value, return itself
    if (nums.length === 1) {
        return nums[0];
    }
    
    // if there are two values, return the larger one
    if (nums.length === 2) {
        return Math.max(nums[0], nums[1]);
    }
    
    // if there are more than two values
    // copy the nums and preappend leading zero
    // to avoid extra if else check for sums[i - 3],
    // which can be out of index error
    let sums = [0].concat(nums);
    
    for (let i = 3; i < sums.length; i++) {
        sums[i] = Math.max(sums[i - 2] + sums[i], sums[i - 3] + sums[i]);
    }
    
    return Math.max(
        sums[sums.length - 1],
        sums[sums.length - 2]
    )
};

2. Recursive:

var rob = function(nums) {
    const helper = (nums, i, sums) => {
        // if there is nothing, return 0
        if (nums.length === 0) {
            return 0;
        }
        
        if (nums.length === 1) {
            return nums[0];
        }
        
        if (nums.length === 1) {
            return Math.max(nums[0], nums[1]);
        }

        // if there is only one value, return itself
        if (i === 0) {
            sums[0] = nums[0];
            return helper(nums, i+1, sums);
        }

        // if there are two values, return the larger one
        if (i === 1) {
            sums[1] = Math.max(nums[0], nums[1]);
            return helper(nums, i+1, sums);
        }
        
        if (i >= nums.length) {
            return Math.max(sums[sums.length - 1], sums[sums.length - 2]);
        }
        
        const step1 = sums[i-2] + nums[i];        
        const step2 = ( sums[i-3] || 0 ) + nums[i];
        
        const larger = Math.max(step1, step2);
        sums[i] = larger;
        
        return helper(nums, i+1, sums);
    };
    
    return helper(nums, 0, []);
}