打家劫舍问题（动态规划、递归，算法，java）

目录

问题：

示例1：

示例2：

 引用网上图片：

 代码实现：

此处我尝试了三种思路：

 运行结果：

个人思想，仅供参考。

---

问题：

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

示例1：

数组：int[] A={3,5,9,21};

运行结果：26

选择数据：5,21

示例2：

数组：int[] A={3,5,7,21,14,18};

运行结果：44

选择数据：5,21,18

 引用网上图片：

 代码实现：

此处我尝试了三种思路：

1、使用二维深度或更多维深度可得到近似最优解
2、使用暴力循环查找，次数足够可得到最优解
3、使用递归思想可以完美解决以上问题，且代码十分简便

package SF;
/*
* “打家劫舍”算法
* 在一个数组中挑选任意数组合（要求不能挑选相邻元素），使得这些数的和最大，求出最大值。
* */
public class DjjsSF {
    /*
    *1、使用二维深度或更多维深度可得到近似最优解
    *2、使用暴力循环查找，次数足够可得到最优解
    *3、使用递归思想可以完美解决以上问题，且代码十分简便
    * */
    public static void main(String[] args) {
        int[] A={65,4,45,32,75,23,14,35,41,16,19};
        System.out.println("暴力循环：");
        System.out.println(Search(A));
        System.out.println("深度查找(一维)：");
        System.out.println(Search1(A));
        System.out.println("递归思想：");
        System.out.println(Search2(A,A.length-1));
    }
    /*
    * 暴力循环
    * */
    public static int Search(int[] A){
        int sum1=0;
        int sum2=0;
        int sum=0;
        for (int i = 0; i < 1000; i++) {
            sum1=0;
            sum2=0;
            sum1=addIndex(A,sum1,0);
            sum2=addIndex(A,sum2,1);
            sum=Math.max(sum1,sum);
            sum=Math.max(sum2,sum);
        }
        return sum;
    }
    public static int addIndex(int[] A,int sum,int index)
    {
        if (index>=A.length){return sum;}
        sum+=A[index];
        int a=(int)(Math.random()*10);
        if (a>=5){
            index+=2;
            sum=addIndex(A,sum,index );
        }else {
            index+=3;
            sum=addIndex(A,sum,index);
        }
        return sum;
    }
    /*
    * 深度查找
    * 此处仅一维
    * */
    public static int Search1(int[]A){
        int sum=0;
        for (int i = 0; i < A.length-1; i+=2) {
            if (A[i]>A[i+1]){
                sum+=A[i];
            }else {
                sum+=A[i+1];
                i=i+1;
            }
        }
        return sum;
    }
    /*
    * 递归思想
    * */
    public static int Search2(int[] A,int index){
        if (A==null||index<0)return 0;
        if (index==0)return A[0];
        return Math.max(Search2(A,index-1),Search2(A,index-2)+A[index]);
    }

}

 运行结果：

暴力循环：
259
深度查找(一维)：
239
递归思想：
259

进程已结束,退出代码0

动态规划（提供）： 

从递归中我们可知转移方程为Math.max(Search2(A,index-1),Search2(A,index-2)+A[index]);

时间复杂度O（N），额外空间复杂度O（N）

实现代码如下：

    public int rob(int[] nums) {
        int[] dp = new int[nums.length + 2]; // dp[i] 表示 从i到结尾 在i位置的最大收益
        for(int i = nums.length - 1; i >= 0; i--){
            dp[i] = Math.max(nums[i] + dp[i + 2], dp[i + 1]);
        }
        return dp[0];
    }

个人思想，仅供参考。