Algorithm_DP

1. 矩阵DP（坐标）

triangle
unique path sum 二维DP

jump game 一维
climbing stairs 一维DP

2. 分割DP

如果限制了切割的字符串的个数（为k），那么就是二维；
f[i][j] = 前i个字符，切成j个单词，是否可行

如果没有限制
f[i] 表示前i个字符，能否完美切割

3. 区间DP

4. 两个序列的DP

例题：House Robber III

参考题解：answer

简单递归解法：

class Solution {
public:
    int rob(TreeNode* root) {
        if(root == NULL) return 0;
        int leftSum(0), rightSum(0);
        if(root->left){
            leftSum = rob(root->left->left) + rob(root->left->right);
        }
        if(root->right){
            rightSum = rob(root->right->left) + rob(root->right->right);
        }
        return max(rob(root->left) + rob(root->right), root->val + leftSum + rightSum);
    }
};

保存状态递归解法：

class Solution {
public:
    int rob(TreeNode* root) {
        map<TreeNode*, int> mymap;
        return robTree(root, mymap);
    }
    int robTree(TreeNode* root, map<TreeNode*, int>& mymap) {
        if(root == NULL) return 0;
        if(mymap.find(root) != mymap.end()) {
            //cout << mymap[root] << endl;;
            return mymap[root];
        }
        int leftSum(0), rightSum(0);
        if(root->left){
            leftSum = robTree(root->left->left, mymap) + robTree(root->left->right, mymap);
        }
        if(root->right){
            rightSum = robTree(root->right->left, mymap) + robTree(root->right->right, mymap);
        }
        int ret = max(robTree(root->left, mymap) + robTree(root->right, mymap), root->val + leftSum + rightSum);
        //cout << ret << endl;
        mymap.insert(pair<TreeNode*, int>(root, ret));
        return ret;
    }
};

每一个节点都有”rob”和”not rob”两种状态。返回数组中，第一个元素表示”not rob”状态，第二个元素表示”rob”状态

class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> ret = subRob(root);
        return max(ret[0], ret[1]);
    }

    vector<int> subRob(TreeNode* root) {
        if(root == NULL) return vector<int>(2, 0);

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

        vector<int> ret(2, 0);
        ret[0] = max(left[0], left[1]) + max(right[0], right[1]);
        ret[1] = root->val + left[0] + right[0];
        return ret;
    }
};