/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
//遞歸程序就是結構演繹，有點像dp，只要定義好每一次遞歸過程完成的是同一個目標，就能保證所有遞歸結束之後完成的效果是最終的目標
    int rob_naive(TreeNode* root) {//
 
 返回當前節點開始的能夠rob的最大值。
        if(root == NULL) return 0;//當前節點為空 0
        int val = 0;
        if(root -> left)//左孩子不空
            val += rob(root -> left -> left) + rob(root -> left -> right); //rob當前root 和 root 的孩子的孩子的能rob到的最大值。這裏並不是rob孩子的孩子，而是孩子的孩子能rob的最大值就像這個遞歸結構每一次完成的目標一樣。
        if(root -> right)
            val 
 
+= rob(root -> right -> left) + rob(root -> right -> right);
        return max(val + root -> val, rob(root -> left) + rob(root -> right));
        //返回 rob(root, root‘s children ‘s children   or   root‘s children)
    }
    //看上面的方案(1330 ms)：每一次我們都考慮了 root.left.left & root.left.right & root.right.left & root.right.right
                                    
 
// root.left & root.right 這裏在遞歸計算的時候還是會算到上面計算過的值。
                                    //所以給出一個考慮一步之後的優化記憶搜索。
    int rob(TreeNode* root){
        unordered_map<TreeNode*, int>mp;
        return robMemeryDFS(root, mp);
    }
    //考慮一步的記憶化搜索(16 ms): 快了接近100倍
    int robMemeryDFS(TreeNode* root, unordered_map<TreeNode*, int>&mp){
        if(root == NULL) return 0;
        if(mp[root]) return mp[root];
        int val = 0;
        if(root -> left)//左孩子不空
            val += robMemeryDFS(root -> left -> left, mp) + robMemeryDFS(root -> left -> right, mp);
        if(root -> right)
            val += robMemeryDFS(root -> right -> left, mp) + robMemeryDFS(root -> right -> right, mp);
        mp[root] = max(val + root -> val, robMemeryDFS(root -> left, mp) + robMemeryDFS(root -> right, mp));
        return mp[root];
    }
};

附加一道 同樣使用記憶化搜索的題目 329. Longest Increasing Path in a Matrix

class Solution {
public:
    int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}}, n, m;
    int dfs(int x, int y, vector<vector<int>>& matrix, vector<vector<int>>&steps){
        if(steps[x][y]) return steps[x][y];
        int maxSteps = 0; // record the longest path steps from (x, y)
        for(int i = 0; i < 4; i ++){
            int nx = dir[i][0] + x, ny = dir[i][1] + y, tmp = 0;
            if(nx >= 0 && ny >= 0 && nx < n && ny < m && matrix[nx][ny] > matrix[x][y]){
                maxSteps = max(maxSteps, dfs(nx, ny, matrix, steps));
            }
        }
        steps[x][y] = maxSteps + 1; // + 1 for cur(x, y)
        return steps[x][y];
    }
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if(matrix.size() == 0) return 0;
        n = matrix.size(), m = matrix[0].size();
        int ans = 0;
        vector<vector<int>>steps(n, vector<int>(m, 0));
        for(int i = 0; i < n; i ++)
            for(int j = 0; j < m; j ++)
                ans = max(ans, dfs(i, j, matrix, steps));
        return ans;
    }
};

【LeetCode 337 & 329. memorization DFS】House Robber III