HouseRobber 打家劫舍

这道题我在一年前写过,但是时间太长忘了。。。当时还刚学动态规划呢;经过两个小时左右的回忆、优化,我又想起来了,并且在原有基础上又扩展了一步。
首先从HouseRobber1开始,最原始的代码解决方案那肯定是:

private int dfs(int index, int[] nums) {
        if(index >= nums.length) return 0;

        int res = 0;
        for(int i = index; i < nums.length; i++) {
            res = Math.max(res, nums[i]+dfs(i+2, nums));
        } 
        return res;
    }
    public int rob(int[] nums) {
        return dfs(0, nums);
    }

其次是优化成记忆化搜索的过程:

private int dfs(int index, int[] nums, int[] dp) {
        if(index >= nums.length) return 0;

        if(dp[index] != 0) return dp[index];
        for(int i = index; i < nums.length; i++) {
            dp[index] = Math.max(dp[index], nums[i]+dfs(i+2, nums, dp));
        } 
        return dp[index];
    }
    public int rob(int[] nums) {
        return dfs(0, nums, new int[nums.length]);
    }

但是这有一个问题:如果你把dp初始化为0的话,那么一旦要是输入的数据也全为0,那么就起不到记忆化搜索的作用了,所以会超时。
HouseRobber 打家劫舍_第1张图片
所以这种问题一定要初始化成-1,再次运行:
HouseRobber 打家劫舍_第2张图片
它的效率是很快的,一般用动态规划时间复杂度是O(n^2)嘛,一般没有记忆化搜索快。
但是这道题可以以时间复杂度O(n)解决:

//时间复杂度O(n),空间复杂度O(n)
    public int rob(int[] nums) {
        int[] dp = new int[nums.length];

        //res是最终结果,tmp表示偷了第i家后,再偷i+2号家所能获取的最大值,dp[i]表示偷第i家所能得到的最大值。
        int res = -1, tmp = -1, n = dp.length;
        for(int i = n-1; i >= 0; i--) {
            dp[i] += nums[i];
            if(i + 2 < n) {
                if(i+2 == n-1) tmp = dp[n-1];
                else if(dp[i+2] > tmp) tmp = dp[i+2];
                dp[i] += tmp;
            }
            //System.out.println(dp[i]);
            if(res < dp[i]) res = dp[i];
        }
        return res;

思路正如注释所示,dp[i]表示偷这一家能获取的最大利益,那么偷第i家所得最多即为偷第i家+第i+2家以后的最大值家。这道题还可以直接用nums数组,不用额外的空间。

//时间复杂度O(n),空间复杂度O(1)
    public int rob(int[] nums) {
        //res是最终结果,tmp表示偷了第i家后,再偷i+2号家所能获取的最大值,dp[i]表示偷第i家所能得到的最大值。
        int res = -1, tmp = -1, n = nums.length;
        for(int i = n-1; i >= 0; i--) {
            if(i + 2 < n) {
                if(i+2 == n-1) tmp = nums[n-1];
                else if(nums[i+2] > tmp) tmp = nums[i+2];
                nums[i] += tmp;
            }
            if(res < nums[i]) res = nums[i];
        }
        return res;
    }

HouseRobber 打家劫舍_第3张图片

最后,houseRobber2的解题思路和1是一样的,就是0到n-2算一次,1到n-1.

private int[] dp;
    private int oneFalse(int[] nums) {
        int tmp = 0, res = 0, n = nums.length;
        for(int i = n-1; i > 0 ; i--) {
            dp[i] += nums[i];
            if(i+2 < n) {
                if(i+2 == n-1) tmp = dp[n-1];
                else if(tmp < dp[i+2]) tmp = dp[i+2];
                dp[i] += tmp;
            }
            if(res < dp[i]) res = dp[i];
        }
        return res;
    }
    private int oneTrue(int[] nums) {
        for(int i = 0; i < dp.length; i++) {
            dp[i] = 0;
        }

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

最初这个代码我是这么写的,我写的时候就发现这个写的太次了,完全应该抽出一个方法嘛。

private int find(int[] nums, int start, int end) {
        int tmp = 0, res = 0;
        for(int i = end; i >= start ; i--) {
            if(i+2 <= end) {
                if(i+2 == end) tmp = nums[i+2];
                else if(tmp < nums[i+2]) tmp = nums[i+2];
                nums[i] += tmp;
            }
            if(res < nums[i]) res = nums[i];
        }
        return res;
    }
    public int rob(int[] nums) {
        int n = nums.length;
        if(n == 1) return nums[0];
        //dp = new int[nums.length];
        //return Math.max(oneFalse(nums), oneTrue(nums));
        //因为java在方法中传递数组参数,当方法修改数组时,数组会改变,所以我又new了一个数组
        int[] tmp = new int[n];
        for(int i = 0; i < n; i++) {
            tmp[i] = nums[i];
        }
        return Math.max(find(nums, 0, n-2), find(tmp, 1, n-1));
    }

HouseRobber 打家劫舍_第4张图片
还得是在这个上面写,我能时常看一下,在leetcode上写,写完我就不看了,时间长了就忘。

你可能感兴趣的:(leetcode动态规划,java,算法,动态规划,leetcode)