力扣LeedCode动态规划专题中等题（八）

面试题 08.09. 括号

题目：

括号。设计一种算法，打印n对括号的所有合法的（例如，开闭一一对应）组合。

说明：解集不能包含重复的子集。

例如，给出 n = 3，生成结果为：

[
"((()))",
"(()())",
"(())()",
"()(())",
"()()()"
]

题解：

采用回溯的思想，边界条件是字符串temp的长度是n*2的时候终止，并返回。

把字符串temp追加到不定长数组vec后面

如果左括号少于n，则添加左括号

如果右括号少于左括号，则添加右括号

代码：

class Solution {
    vector<string> vec;
public:
    //采用回溯的思想，边界条件是字符串temp的长度是n*2的时候终止，并返回。
    void dfs(int l,int r,string temp,int n)
    {
        if(temp.length()==n*2)
        {
            vec.push_back(temp);//把字符串temp追加到不定长数组vec后面
        }
        if(l<n)//如果左括号少于n，则添加左括号
        dfs(l+1,r,temp+'(',n);
        if(r<l)//如果右括号少于左括号，则添加右括号
        {
            dfs(l,r+1,temp+')',n);
        }
    }
    vector<string> generateParenthesis(int n) {
        dfs(0,0,"",n);//dfs的初始条件
        return vec;//返回字符串不定长数组vec
    }
};

894. 所有可能的满二叉树

 题目：

满二叉树是一类二叉树，其中每个结点恰好有 0 或 2 个子结点。

返回包含 N 个结点的所有可能满二叉树的列表。 答案的每个元素都是一个可能树的根结点。

答案中每个树的每个结点都必须有 node.val=0。

你可以按任何顺序返回树的最终列表。

题解：

            //这里就是递归的精髓了，每次看到递归，就一头雾水

            //在这里，我们不用去关心左右子树是怎么递归形成的

            //我们可以仅仅去关心，这个函数，它实现的是什么功能

            //allPossibleFBT(i)返回了一个列表，它存放着当结点数为i时，所有满足条件的树的root的集合

            //我们可以认为，allPossibleFBT(i)存放着所有满足条件的左子树的集合

            //同样，allPossibleFBT(N-1-i)存放着所有满足条件的右子树的集合

            //这是由vector<TreeNode*> allPossibleFBT(int N)这个函数的定义所确定的

 代码：

/**
 * 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 {
    vector<TreeNode*> temp;
public:
    //得到一个列表，存放着所有满足条件的树的root
    vector<TreeNode*> allPossibleFBT(int N) {
        vector<TreeNode*> dp;

        //边界条件1:如果输入的是偶数，return一个空列表
        if(N & 1 == 0) return dp;
        //边界条件2:如果输入为1，那么结果就只有一个值为0的结点
        if(N == 1) {dp.push_back(new TreeNode(0));return dp;}

        //我们知道一共有N个结点，root占了1个结点，左子树可能有1，3，5，..，N-2个结点
        //对应的，右子树可能有N-2，..，5，3，1个结点
        //那么，我们可以用一个循环，找到所有可能的左右子树的可能的数量的情况，把root放进列表里
        for(int i=1;i<=N-2;i+=2){
            //这里就是递归的精髓了，每次看到递归，就一头雾水
            //在这里，我们不用去关心左右子树是怎么递归形成的
            //我们可以仅仅去关心，这个函数，它实现的是什么功能
            //allPossibleFBT(i)返回了一个列表，它存放着当结点数为i时，所有满足条件的树的root的集合
            //我们可以认为，allPossibleFBT(i)存放着所有满足条件的左子树的集合
            //同样，allPossibleFBT(N-1-i)存放着所有满足条件的右子树的集合
            //这是由vector<TreeNode*> allPossibleFBT(int N)这个函数的定义所确定的
            vector<TreeNode*> left = allPossibleFBT(i);
            vector<TreeNode*> right = allPossibleFBT(N-1-i);

            //接下来，就是左右子树的排列组合，当左子树为m时，右子树可能有right.size()个可能
            //所以一共有right.size() * left.size()种可能
            //我们把每一种排列，都放到我们所要的结果中
            for(int j=0;j<left.size();++j){
                for(int k=0;k<right.size();++k){
                    TreeNode *root = new TreeNode(0);
                    root->left = left[j];
                    root->right = right[k];
                    //对于左子树有i个结点，右子树有N-1-i个结点时，我们把所有可能的树push进入队列
                    dp.push_back(root);
                }
            }
        }
        //所以说，看到递归，我们可以屏蔽掉复杂的递归思考过程，而是单纯的把递归函数本身，看成一个封装完全
        //功能独立的一个函数。
        return dp;
    }
};

参考链接：https://leetcode-cn.com/problems/bracket-lcci

https://leetcode-cn.com/problems/bracket-lcci/solution/c-by-fanko/

https://leetcode-cn.com/problems/all-possible-full-binary-trees

 https://leetcode-cn.com/problems/all-possible-full-binary-trees/solution/cban-ben-fu-dai-wan-zheng-de-zhu-shi-by-fuckleetco/