每天一道题-2(打家劫舍的3道题)

打家劫舍三道题

打家劫舍 打家劫舍II 打家劫舍III

这三道题的区别在于原始数据结构的不同，如果具体来说就是分别是数组、环形-数组、二叉树的这样的三种结构。因此对于三种结构要有一定的不同的处理。

本质是相同的，就是每个结点的两种状态选择或者未选择，然后进行一个累加处理。

1. 在打家劫舍第一题，就是一个数组的结构来存放每家的金额，每家存在打劫，没被打劫两种状态，进行循环处理。

   class Solution {
       public int rob(int[] nums) {
   		int len = nums.length;
   		// 开辟一个数组来存放每个家的状态
   		int[] dp = new int[len];
   		dp[0] = nums[0];
   		if (len == 1) {
   			return nums[0];
   		}
           // 每个状态的遍历
   		dp[1] = Math.max(nums[0], nums[1]);
   		for (int i = 2; i < len; i++) {
   			dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
   		}
   		return dp[len - 1];
       }
   }
   

   进行优化一下，其实我们只要前两个结点的状态，然后在新结点处理。类似爬楼梯的问题，只用存前两个状态。

   class Solution {
       public int rob(int[] nums) {
           int len = nums.length;
           if (len == 1) {
               return nums[0];
           }
           int preMax = nums[0];
           int curMax = Math.max(nums[1], nums[0]);
           for (int i = 2; i < len; i++) {
               int tem = curMax;
               curMax = Math.max(tem, preMax + nums[i]);
               preMax = tem;
           }
           return curMax;
       }
   }
   

2. 这个环形-数组的数据结构在于开头和结尾的地方的处理它们只能二选一。

   Class Solution {
       public int rob(int[] nums) {
           int len = nums.length;
           if (len == 1) {
               return nums[0];
           } else if (len == 2) {
               return Math.max(nums[0], nums[1]);
           }
           return Math.max(robRange(nums, 0, len - 1), robRange(nums, 1, len));
       }
       private int robRange(int[] nums, int start, int end) {
           int preMax = nums[start];
           int curMax = Math.max(nums[start], nums[start+1]);
           for (int i = start + 2; i < end; i ++) {
               int tem = curMax;
               curMax = Math.max(tem, preMax + nums[i]);
               preMax = tem;
           }
           return curMax;
       }
   }
   

3. 在二叉树的这个结构，首先我们肯定是要采取分治的方法的结构来遍历整个的二叉树结构，在这个过程中就要进行数据的处理。可以采用Hash表来存放每个结点的可能。

   class Solution {
   	Map<TreeNode, Integer> f = new HashMap<>();
   	Map<TreeNode, Integer> g = new HashMap<>();
       public int rob(TreeNode root) {
   		dfs(root);
           return Math.max(f.get(root), g.get(root));
       }
       private void dfs(TreeNode node) {
       	if (node == null) {
               return ;
           }
           dfs(node.left);
           dfs(node.right);
           f.put(node, node.val + g.getOrDefault(node.left, 0) + g.getOrDefault(node.right, 0));
           g.put(node, Math.max(f.getOrDefault(node.left, 0), g.getOrDefault(node.left, 0))
                + Math.max(f.getOrDefault(node.right, 0), g.getOrDefault(node.right, 0)));
       }
   }
   

   但是通过上面的程序，我们可以看出它其实还是只需要子结点，而不是需要所有结点的可能值都记录下来。

   Class Solution {
       public int rob(TreeNode root) {
           int[] ans = dfs(root);
           return Math.max(ans[0], ans[1]);
       }
       private int[] dfs(TreeNode node) {
           if (node == null) {
               return new int[]{0, 0};
           }
           int[] l = dfs(node.left);
           int[] r = dfs(node.right);
           int unselect = Math.max(l[0], l[1]) + Math.max(r[0], r[1]);
           int select = node.val + l[0] + r[0];
           // 新建一个数组存放一个结点的两种可能
           return new int[]{unselect, select};
       }
   }