力扣 | 动态规划 | 动态规划在树的应用

文章目录

[一、96. 不同的二叉搜索树](#一、96. 不同的二叉搜索树)
[二、95. 不同的二叉搜索树 II](#二、95. 不同的二叉搜索树 II)
[三、337. 打家劫舍 III](#三、337. 打家劫舍 III)

一、96. 不同的二叉搜索树

LeetCode：96. 不同的二叉搜索树

只求个数实际上比较简单，定义dp[i]表示结点个数为i的二叉搜索树的种树。（其实和记忆化搜索+dfs差不多）

那么有 d p [ i ] = ∑ k = 0 i − 1 d p [ i − k − 1 ] ∗ d p [ k ] dp[i] = \sum_{k=0}^{i - 1}{dp[i-k-1]*dp[k]} dp[i]=∑k=0i−1dp[i−k−1]∗dp[k]，即枚举左右子树的所有情况，个数的乘积就是这种情况的个数。

cpp 复制代码

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n + 1, 0);
        dp[0] = 1, dp[1] = 1;

        for(int i = 2; i <= n; ++ i){
            for(int k = 0; k < i; ++ k){
                dp[i] += dp[k] * dp[i - k - 1];
            }
        }
        return dp[n];
    }
};

二、95. 不同的二叉搜索树 II

LeetCode：95. 不同的二叉搜索树 II

这个题和之前的唯一区别就是这里维护一个真实的数，而不仅仅是个数。我们仍然可以使用相同的方法，只是这里是创建树，并且要关注值。

并且我们需要特别注意，dp[0]表示空树，空树并不是dp[0] = {}而是dp[0]={nullptr}，原因是空树为nullptr，而不是没有元素。相当于∅和{∅}的区别

以下是一种动态规划的写法，不像官解的回溯解法那么难理解：

我们将之前的dp[i] += dp[k] * dp[i - k - 1]改为了addTree(dp[i], dp[k], dp[i - k - 1], k)，从只关注个数到需要创建所有情况。注意这个参数k一定是需要的，因为这代表左子树的个数，而dp[k]表示的是左子树的所有可能情况。

cpp 复制代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<TreeNode*> generateTrees(int n) {
        vector<vector<TreeNode *>> dp(n + 1);//dp[i]表示结点个数为i 的所有可能情况
        dp[0] = {nullptr};
        dp[1] = {new TreeNode(1)};

        for(int i = 2; i <= n; ++ i){
            for(int k = 0; k < i; ++ k){//k表示左边有多少个，i - k - 1是右边的个数，右边以及根的大小从k + 1开始
                addTree(dp[i], dp[k], dp[i - k - 1], k);//将dp[k] - root - dp[i - k - 1]创建 加入到dp[i]
            }
        }

        return dp[n];
    }
private:
    void addTree(vector<TreeNode *> & total, vector<TreeNode *> & left, vector<TreeNode *> & right, int k){//将这种情况下的所有可能树连接起来
        for(int i = 0; i < left.size(); ++ i){
            for(int j = 0; j < right.size(); ++ j){
                TreeNode * root = new TreeNode(k + 1);
                root->left = createTree(left[i], 0);
                root->right = createTree(right[j], k + 1);
                total.emplace_back(root);
            }
        }
        return;
    }
    TreeNode * createTree(TreeNode * root, int bias){//创建树，加上偏置
        if(!root) return nullptr;
        TreeNode * cur = new TreeNode(root->val + bias);
        cur->left = createTree(root->left, bias);
        cur->right = createTree(root->right, bias);

        return cur;
    }
};

三、337. 打家劫舍 III

LeetCode：337. 打家劫舍 III

很明显这是一个动态规划题，树形dp，如何定义？

定义 dp[i]为以i为根的树的最高金额？

那么，i可以被偷，也可以不被偷：

dp[i] = max(儿子的最高金额，孙子的最高金额 + i的金额） //这样就可以确保不报警的情况下，拿到最高金额

并且，我们认为dp[i]就是对的最高金额，通过状态转移就能保证，每个都是最高金额。

cpp 复制代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    unordered_map<TreeNode *, int> dp;
    int rob(TreeNode* root) {
        Getans(root);

        return dp[root];
    }
private:
    void Getans(TreeNode * root){
        if(!root) return;
        Getans(root->left);
        Getans(root->right);
        int ans = root->val;
        ans = max(ans, dp[root->left] + dp[root->right]);

        int temp = root->val;
        if(root->left){
            temp += dp[root->left->left] + dp[root->left->right];
        }
        if(root->right){
            temp += dp[root->right->left] + dp[root->right->right];
        }

        dp[root] = max(temp, ans);
        return;
    }
};