打家劫舍I dp dfs ms

题目描述

你是一个专业的小偷，计划偷窃沿街的房屋。
每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，
如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

思路

思路一 DP

 * DP  找状态转换方程 假设有k间房屋
 * k=1,则max = getMoney(1);
 * k=2,则max = max(getMoney(1),getMoney(2))
 * k>2,则会有两种情况
 * 	1.取k,则不能取k-1，最大值就是前k-2个最大值+第k个的值
 *	 2.不取k,则最大值就是前k-1个房屋的最大值

代码

public class Solution {
    public static int rob(int[] nums) {
        if (nums.length == 0 || nums == null){
            return 0;
        } else if (nums.length == 1) {
            return nums[0];
        } else if (nums.length == 2) {
            return Math.max(nums[0],nums[1]);
        }else {
//            int[] dp = new int[nums.length];
//            dp[0] = nums[0];
//            dp[1] = Math.max(nums[0],nums[1]);
//            for (int i = 2; i< nums.length; i++){
//                dp[i] = Math.max(dp[i-2]+nums[i],dp[i-1]);
//            }
//            return dp[nums.length-1];
            //优化，每间房屋的最高金额只与前两间房屋的最高金额有关，故可以考虑使用滚动数组减少空间复杂度
            int first = nums[0],second = Math.max(nums[0],nums[1]);
            for (int i =  2; i < nums.length; i++){
                int temp = second;
                second = Math.max(first+ nums[i], second);
                first = temp;
            }
            return second;
        }
    }

    public static void main(String[] args) {
        int[] nums = {2,7,9,3,1,11,2,9,2,33,24,1,2,3,4,5,67,35,48};
        Long start = System.currentTimeMillis();
        System.out.println(Solution_DFS_MS.rob(nums));
        Long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
}

思路二 DFS

 * 对于第i个房间来讲只有两种状态，取和不取
 * 递归的返回值为从第i个房屋包括第i个开始所能盗窃的最大值
 * 递归的参数就是房屋位置i和第i-1个房屋是否被盗窃过的标记flag
 * 递归函数要做的就是根据第i-1个的状态来判断第i个是否可以取，而
 * 第i+1个及之后则进入下一层递归

代码

public class Solution_DFS {
    public static int rob(int[] nums){

        return dfs(nums,0,false);
    }
    private static int dfs(int[] nums,int i,boolean flag){
        //越界了那么这一个就不可以偷了
        if (i >= nums.length) return 0;
        //如果前一个偷过了下一个也不能偷了
        else if (flag) return dfs(nums,i+1,false);
        //前一个没被偷，这个可偷可不偷，取较大的一个
        else {
            return Math.max(dfs(nums,i+1,false),dfs(nums,i+1,true)+nums[i]);
        }

    }
}

思路三 DFS+MS（记忆化搜索）

* 用两个数组做缓存，分别记录取与不取第i个房屋的情况下，第i个房屋及之后能取到的最大值

代码

public class Solution_DFS_MS {
    static int[] st = new int[109];
    static int[] nst = new int[109];
    public static int rob(int[] nums){
        //st、nst初始化为-1，标识不取
        for (int i = 0;i<st.length;i++)
        {
            st[i] = -1;
            nst[i] = -1;
        }

        return dfs_ms(nums,0,false);
    }
    /*返回第i个房屋及之后能取到的最大值*/
    private static int dfs_ms(int[] nums,int i, boolean flag){
        if (i >= nums.length) {
            return 0;
        }else if(flag){
            //如果第i个被偷了，那么第i+1个就不能偷了
            if (nst[i+1] == -1)  nst[i+1] = dfs_ms(nums,i+1,false);
            return nst[i+1];
        }else {
            //如果第i个没被偷，那么第i+1可偷可不偷，取最大的情况
            if (st[i+1] == -1) st[i+1] = dfs_ms(nums,i+1,true);
            if (nst[i+1] == -1) nst[i+1] = dfs_ms(nums,i+1,false);
            return Math.max(st[i+1]+nums[i],nst[i+1]);
        }

    }
}