思路：我的理解是不能出现连续两次偷窃，即
要么今晚不偷 dp[i] = dp[i-1];
要么今晚开干！ dp[i] = dp[i-2] + nums[i];

怎么初始化： 从公式可知，至少初始化前两晚。dp[0] = nums[0] dp[1] = nums[1]

	int rob(vector<int>& nums) {
        vector<int> dp(nums.size(), 0);
        if(nums.size() < 2) return nums[0];
        if(nums.size() == 2) return max(nums[0], nums[1]);

        dp[0] = nums[0];
        dp[1] = nums[1];

        for(int i = 2; i < nums.size(); i++) {
            int tmp = 0;
            for(int j = 0; j < i-1; j++)
                tmp = max(tmp, dp[j]);
            dp[i] = max(dp[i-1], tmp + nums[i]);
        }

        return dp[nums.size()-1];
    }

看了下题解，思路有所开阔。我之前的假设是
要么今晚不偷 dp[i] = dp[i-1];
要么今晚开干！ dp[i] = dp[i-2] + nums[i];
然后我在递推时发现dp[i-2]可以是i-2之前的最大的一次，因此每次循环都获取了一次最大值，但其实，我们可以直接给dp赋值时，就把这一步骤完成，例如dp[i]就是前i次的最大值
dp[0] = nums[0], dp[1] = max(nums[0], nums[1]);
这样我每次遍历dp[i]就是最大值，可以少一个 for 循环

	int rob(vector<int>& nums) {
        vector<int> dp(nums.size(), 0);
        if(nums.size() < 2) return nums[0];

        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);

        for(int i = 2; i < nums.size(); i++) {
            dp[i] = max(dp[i-1], dp[i-2] + nums[i]);
        }

        return dp[nums.size()-1];
    }

思路：和上一题一样，只是多了首尾不能相接。偷是一个累加的过程
那就有两种偷法：1. 第一天开始偷，最后一天不偷
2. 第二天开始偷，最后一天可以偷
剩下跟上一个一样

    int rob(vector<int>& nums) {
		if(nums.size() == 1) return nums[0];

		int res1 = robRange(nums, 0, nums.size() - 2);
		int res2 = robRange(nums, 1, nums.size() - 1);

		return max(res1, res2);
	}
	
    int robRange(const vector<int>& nums, int start, int end) {
		if(start == end) return nums[start];

		vector<int> dp(nums.size(), 0);
		dp[start] = nums[start];
		dp[start + 1] = max(nums[start], nums[start + 1]);

		for(int i = start + 2; i <= end; i++) {
			dp[i] = max(dp[i-2] + nums[i], dp[i-1]);	
		}
		return dp[end];
	}

记忆化递归：对于当前节点，有两个结果，一个是偷，并且下一次只能从孩子的孩子里偷；一个是当前不偷，从孩子节点里偷
即 dp[root] = dp[root->left ->children] + root->val;
dp[root] = dp[root->children]

	unordered_map<TreeNode* , int> umap; // 记录计算过的结果
public:
    int backtracking(TreeNode* root) {
        if(root == nullptr) return 0;

        if(umap[root]) {
            return umap[root];
        }

        if(root->left == nullptr && root->right == nullptr) {
            return root->val;
        }

        int tmpVal1 = root->val;
        if(root->left != nullptr) {
            tmpVal1 += backtracking(root->left->left);
            tmpVal1 += backtracking(root->left->right);
        }

        if(root->right != nullptr) {
            tmpVal1 += backtracking(root->right->left);
            tmpVal1 += backtracking(root->right->right);
        }

        int tmpVal2 = 0;
        tmpVal2 += backtracking(root->left);
        tmpVal2 += backtracking(root->right);

        umap[root] = max(tmpVal1, tmpVal2);

        return umap[root];
    }

    int rob(TreeNode* root) {
        return backtracking(root);
    }

二：动态规划
对于当前节点，存在偷或不偷两种情况；
所以dp数组（dp table）以及下标的含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。
若当前节点不偷， 则最大值为孩子节点偷与偷的最大值 dp[root, 0] = max(dp[root->left，0], dp[root->left，1]) + max(dp[root->right，0], dp[root->right，1])
若当前节点偷，那么孩子不能偷 dp[root, 1] = dp[root->left, 0] + dp[root->right, 0]
因为需要用到递归函数返回值，所以使用 后序遍历

	vector<int> robTree(TreeNode* root) {
        if(root == nullptr) return vector<int> {0, 0};

        vector<int> left = robTree(root->left);
        vector<int> right = robTree(root->right);

        int val1 = root->val + left[0] + right[0];
        int val2 = max(left[1], left[0]) + max(right[1], right[0]);

        // cout << val2 << " " << val1 << endl;
        return {val2, val1};
    }

    int rob(TreeNode* root) {
        // return backtracking(root);
        vector<int> res = robTree(root);
        return max(res[0], res[1]);
    }