LeetCode198 打家劫舍

题目

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

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

 示例 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 <= nums.length <= 100 
 0 <= nums[i] <= 400

方法

动态规划

用dp数组保存每个节点上的最大金额，在当前节点上要么选要么不选，因此第n个节点的最大金额为：dp[n] = max(dp[n-2]+nums[n],dp[n-1]),即选和不选的情况的最大值

时间复杂度：O(n)
空间复杂度：O(n)

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        if(n<1){
            return 0;
        }else if(n==1){
            return nums[0];
        }
        int[] dp = new int[n];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0],nums[1]);
        for(int i=2;i<n;i++){
            dp[i] = Math.max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[n-1];
    }
}

动态规划-进阶版

有第一种代码可知，我们只需两个记录当前节点的前两个节点即可，因此无需采用数组存储，直接定义2个变量记录当前节点的前两个节点，降低空间复杂度

时间复杂度：O(n)
空间复杂度：O(1)

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        if(n<1){
            return 0;
        }else if(n==1){
            return nums[0];
        }
        int dp0 = nums[0];
        int dp1 = Math.max(nums[0],nums[1]);
        int dp2 = dp1;
        for(int i=2;i<n;i++){
            dp2 = Math.max(dp0+nums[i],dp1);
            dp0 = dp1;
            dp1 = dp2;
        }
        return dp2;
    }
}

输出路径

先找到dp数组中最大值出现的第一个位置，说明此位置是被选的
然后减去当前nums的数，如果为0说明没有选别的，如果大于0则继续往前找差值所在的第一个位置

import java.util.Arrays;

public class dp {
    public int[] rob(int[] nums){
        int n = nums.length;
        int[] index = new int[n];
        int[] dp = new int[n];
        if(n == 1) {
            dp[0] = nums[0];
            return dp;
        }
        else if(n == 2) {
            dp[0] = Math.max(nums[0], nums[1]);
            return dp;
        }
        else{
            dp[0] = nums[0];
            dp[1] = Math.max(nums[0], nums[1]);
            for(int i = 2; i < n; i++){
                dp[i] = Math.max(dp[i-2] + nums[i], dp[i-1]);
            }
            return dp;
        }
    }
    public int[] getIndexArray(int[] nums){
        int[] dp = new int[nums.length];
        int[] index = new int[nums.length];
        int i = 0;
        dp = rob(nums);
        int ind = Arrays.binarySearch(dp, dp[nums.length - 1]);
        index[i] = ind + 1;
        while(dp[ind] > nums[ind]){
            ind = Arrays.binarySearch(dp, dp[ind] - nums[ind]);
            index[++i] = ind + 1;
        }
        return index;
    }

    public static void main(String[] args) {
        int[] nums = {1, 4, 1, 2, 5, 6, 3, 4, 10};
        int[] index = new int[nums.length];
        dp dp = new dp();
        index = dp.getIndexArray(nums);
        for(int i = nums.length - 1; i >= 0; i--){
            System.out.println(index[i]);
        }
    }
}