95不同的二叉搜索树II

一、前言

分类：动态规划。

问题来源LeetCode 95 难度：中等。

问题链接：https://leetcode-cn.com/problems/unique-binary-search-trees-ii/

 

二、题目

给定一个整数 n，生成所有由 1 ... n 为节点所组成的 二叉搜索树 。

示例：

输入：3
输出：
[
  [1,null,3,2],
  [3,2,null,1],
  [3,1,null,null,2],
  [2,1,3],
  [1,null,2,null,3]
]
解释：
以上的输出对应以下 5 种不同结构的二叉搜索树：
   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

提示：

• 0 <= n <= 8

 

三、思路

这里提供两种解题方法：递归和非递归（动态规划）。

3.1 方法一：递归

1. [1，n]，n各节点，每一个都可以成为根节点，这个节点左边数组组成的树是它的左子树，右边数组组成的树是它的右子树；
2. 左右子树生成过程同步骤1；
3. 每一个左子树和每一个右子树和它们的根节点都能组成一颗二叉树。对于步骤1的根节点可以组成二叉树个数 = 左子树个数X 右子树个数。

 

3.2 方法二：非递归（动态规划）

1. 逐渐增加节点数量。dp[i]：记录的是1 ... i 为节点所组成的二叉搜索树；
2. 当增加到节点数量为 i 时，1 ... i 都可以作为树的根节点，设根节点为j，1... j-1为节点所组成的二叉搜索树为左树，j+1...i为节点所组成的二叉搜索树为右树。左子树为dp[j-1]，右子树在dp中是无法直接，由于节点数值是连续的，j+1...i 可以转为 1...i-j 再加一个偏移量j，在树进行拷贝时元素加上偏移量，右子树可以表示为dp[i-j]偏移量j。

递推公式：dp[i] += dp[j-1] * dp[i-j]，其中dp[i-j]偏移量是j，j范围是[1,i]。

 

四、编码实现

//==========================================================================
/*
* @file    : 95_GenerateTrees.h
* @blogs   : https://blog.csdn.net/nie2314550441/article/details/107212051
* @author  : niebingyu
* @date    : 2020/07/08
* @title   : 不同的二叉搜索树 II
* @purpose : 给定一个整数 n，生成所有由 1 ... n 为节点所组成的 二叉搜索树 。
*
* 示例：
* 输入：3
* 输出：
* [
*   [1,null,3,2],
*   [3,2,null,1],
*   [3,1,null,null,2],
*   [2,1,3],
*   [1,null,2,null,3]
* ]
* 解释：
* 以上的输出对应以下 5 种不同结构的二叉搜索树：
*   1        3     3      2      1
*    \       /     /      / \      \
*     3     2     1      1   3      2
*    /     /       \                 \
*   2     1         2                 3
*
* 提示：
* 0 <= n <= 8
*
*
* 来源：力扣（LeetCode）
* 难度：中等
* 链接：https://leetcode-cn.com/problems/unique-binary-search-trees-ii
*/
//==========================================================================
#pragma once
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

#define NAMESPACE_GENERATETREES namespace NAME_GENERATETREES {
#define NAMESPACE_GENERATETREESEND }
NAMESPACE_GENERATETREES

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_1 
{
public:
    vector<TreeNode*> generateTrees(int n) 
    {
        if(n == 0) return {};
        return helper(1, n);
    }

    vector<TreeNode*> helper(int start, int end) 
    {
        if(start > end) 
            return {nullptr};

        vector<TreeNode*> res;
        for(int i=start; i<=end; i++) 
        {
            auto left = helper(start, i - 1);
            auto right = helper(i + 1, end);
            for(auto a:left) 
            {
                for(auto b:right) 
                {
                    TreeNode* node = new TreeNode(i);
                    node->left = a;
                    node->right = b;
                    res.push_back(node);
                }
            }
        }

        return res;
    }
};

// 动态规划：非递归版本的拷贝树实现
// 递推公式：dp[i] += dp[j-1] * dp[i-j]，其中dp[i-j]偏移量是j，j范围是[1,i]。。结果需要进行拷贝。
class Solution_2 
{
public:
    vector<TreeNode*> generateTrees(int n) 
    {
        // 使用static变量，节省用例不同用例执行时的重复求解开销
        static vector<vector<TreeNode*>> dp(1, vector<TreeNode*>(1, NULL));
        int o_size = dp.size();
        if (n + 1 > dp.size())
            dp.resize(n + 1);

        for (int i = o_size; i <= n; i++)  // 升序求解
        {
            for (int j = 1; j <= i; j++)  // 遍历以不同的数的为根
            { 
                const auto &left = dp[j - 1];
                const auto &right = dp[i - j];
                auto &cc = dp[i];
                for (const auto left_ptr : left) // 遍历所有可能的左子树
                {
                    for (const auto right_ptr : right)  // 遍历所有可能的右子树
                    {
                        auto root = new TreeNode(j);
                        if (j > 1)
                            root->left = copyTree(left_ptr); // 拷贝左子树
                        if (i > j)
                            root->right = copyTree(right_ptr, j); // 拷贝右子树，并加上偏移值
                        cc.push_back(root);
                    }
                }
            }
        }

        if (n == 0)
            return {};

        return dp[n];
    }

	TreeNode *copyTree(TreeNode *root, int delta = 0) 
	{
        auto nroot = new TreeNode(root->val + delta);
        queue<TreeNode*> qt;
        queue<TreeNode*> qo;
        qo.push(root);
        qt.push(nroot);
        while (!qt.empty()) 
        {
            auto o_root = qo.front();
            qo.pop();
            auto t_root = qt.front();
            qt.pop();
            if (o_root->left) 
            {
                t_root->left = new TreeNode(o_root->left->val + delta);
                qo.push(o_root->left);
                qt.push(t_root->left);
            }
            if (o_root->right) 
            {
                t_root->right = new TreeNode(o_root->right->val + delta);
                qo.push(o_root->right);
                qt.push(t_root->right);
            }
        }
        return nroot;
    }
};

以下为测试代码//
// 测试 用例 START
void test(const char* testName, int n, int expect)
{
    Solution_1 s1;
	vector<TreeNode*> result1 = s1.generateTrees(n);

	Solution_2 s2;
	vector<TreeNode*> result2 = s2.generateTrees(n);

    if (expect == result1.size() && expect == result2.size()) // 简单校验一下
        cout << testName << ", solution passed." << endl;
    else
        cout << testName << ", solution failed. expect: "<< expect << ",result1.size: "<< result1.size() <<",result2.size:" << result2.size() << endl;
}

// 测试用例
void Test1()
{
    int n = 1;
    int expect = 1;
    
    test("Test1()", n, expect);
}

void Test2()
{
    int n = 2;
    int expect = 2;

    test("Test2()", n, expect);
}

void Test3()
{
    int n = 3;
    int expect = 5;

    test("Test3()", n, expect);
}

void Test4()
{
    int n = 4;
    int expect = 14;

    test("Test4()", n, expect);
}

NAMESPACE_GENERATETREESEND
// 测试 用例 END
//

void GenerateTrees_Test()
{
    NAME_GENERATETREES::Test1();
    NAME_GENERATETREES::Test2();
    NAME_GENERATETREES::Test3();
    NAME_GENERATETREES::Test4();
}

执行结果：