博客

• 来源

LeetCode 198.打家劫舍



Grandyang博客

• 内容

  • 递归回溯法
    
    当选择了第i个数，则下一次选择的范围是第i+2和i+3个，利用这一点进行回溯尝试。
    
    但是这种方法带来的负面影响就是时间复杂度很高，空间复杂度也因为没有优化成尾递归而很大，很容易在数据大的情况下栈溢出。

  class Solution {
      public int rob(int[] nums) {
          return Math.max(func(nums, 0, 0), func(nums, 1, 0));
      }
      
      public int func(int[] nums, int index, int sum) {
          if (index >= nums.length) {
              return sum;
          }
          
          return Math.max(func(nums, index + 2, sum + nums[index]), func(nums, index + 3, sum + nums[index]));
      }
  }
  

  • 动态规划
    
    这道题的本质相当于在一列数组中取出一个或多个不相邻数，使其和最大。那么我们对于这类求极值的问题首先考虑动态规划Dynamic Programming来解，我们维护一个一位数组dp，其中dp[i]表示到i位置时不相邻数能形成的最大和，那么状态转移方程怎么写呢，我们先拿一个简单的例子来分析一下，比如说nums为{3, 2, 1, 5}，那么我们来看我们的dp数组应该是什么样的，首先dp[0]=3没啥疑问，再看dp[1]是多少呢，由于3比2大，所以我们抢第一个房子的3，当前房子的2不抢，所以dp[1]=3，那么再来看dp[2]，由于不能抢相邻的，所以我们可以用再前面的一个的dp值加上当前的房间值，和当前房间的前面一个dp值比较，取较大值当做当前dp值，所以我们可以得到状态转移方程dp[i] = max(num[i] + dp[i – 2], dp[i – 1]), 由此看出我们需要初始化dp[0]和dp[1]，其中dp[0]即为num[0]，dp[1]此时应该为max(num[0], num[1])

  class Solution {
      public int rob(int[] nums) {
          if (nums == null || 0 == nums.length) return 0;
          if (1 == nums.length) return nums[0];
          
          int[] dp = new int[nums.length];
          
          dp[0] = nums[0];
          dp[1] = Math.max(dp[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[dp.length - 1];
      }
  }
  

  • 动态规划优化版
    
    由上一种方法可以看出，动态规划中的dp数组并不是所有的值都会被后续用到，当判断第i个数的dp时，有用的只是i-1和i-2，所以此处优化，仅用两个变量循环保存就可以，可以将空间复杂度从o(n)降低到o(1)。

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