198.打家劫舍（dp 经典的动态规划入门题目）

leetcode每日一题：

分析题目：

解题思路：
   有两种情况：
      1. 偷第n个房子:那么相邻的房子就不能偷，即：偷第n-2个房子的最大金额+第n个房子的金额 
         dp[n] = dp[n - 2] + nums[n];
      2. 不偷第n个房子：即：偷第n-1个房子的最大金额
          dp[n] = dp[n - 1];
   因此得到状态转移方程：dp[i] = max(dp[i - 1],dp[i - 2] + nums[i]);

运行成功的代码：

class Solution {
    public int rob(int[] nums) {
        //错误原因：不相邻不代表一定是中间隔一个，也可能是两边
        // int sum = 0;
        // int max = 0;
        // for(int j = 0;j < nums.length; j++){
        //     sum += nums[j];
        //     for(int i = j + 2;i < nums.length;i += 2){
        //         sum += nums[i];
        //     }
        //     if(sum > max){
        //         max = sum;
        //     }
        //     sum = 0;
        // }
        // return max;
       /*解题思路：
           有两种情况：
             1. 偷第n个房子:那么相邻的房子就不能偷，即：偷第n-2个房子的最大金额+第n个房子的金额 
                 dp[n] = dp[n - 2] + nums[n];
             2. 不偷第n个房子：即：偷第n-1个房子的最大金额
                 dp[n] = dp[n - 1];
            因此得到状态转移方程：dp[i] = max(dp[i - 1],dp[i - 2] + nums[i]);
        */
       //获取输入的数组的长度
       int n = nums.length;
       
       if(n == 0){
           return 0;
       }
       if(n == 1){
           return nums[0];
       }
       //数组定义
       int[] dp = new int[n];
       /*dp数组的下标表示第几个房子,
         dp[n]数组的含义：偷第n个房子能获得的最大金额
       */
       dp[0] = 0;
       dp[1] = nums[0];
       dp[2] = Math.max(nums[0],nums[1]);
       if(n == 2){
           return dp[2]
       }
       //循环进行计算偷到第n个房间获取的最大金额
       for(int i = 2;i < n; i++){
           //Math.max(),返回两个参数中最大的值
           dp[i] = Math.max(dp[i - 1],(dp[i - 2]+nums[i]));
       }
       return dp[n - 1];
    }
}