【LeetCode热题100】打卡第12天：括号生成

括号生成

⛅前言

大家好，我是知识汲取者，欢迎来到我的LeetCode热题100刷题专栏！

精选 100 道力扣（LeetCode）上最热门的题目，适合初识算法与数据结构的新手和想要在短时间内高效提升的人，熟练掌握这 100 道题，你就已经具备了在代码世界通行的基本能力。在此专栏中，我们将会涵盖各种类型的算法题目，包括但不限于数组、链表、树、字典树、图、排序、搜索、动态规划等等，并会提供详细的解题思路以及Java代码实现。如果你也想刷题，不断提升自己，就请加入我们吧！QQ群号：827302436。我们共同监督打卡，一起学习，一起进步。

博客主页💖：知识汲取者的博客

LeetCode热题100专栏🚀：LeetCode热题100

Gitee地址📁：知识汲取者 (aghp) - Gitee.com

Github地址📁：Chinafrfq · GitHub

题目来源📢：LeetCode 热题 100 - 学习计划 - 力扣（LeetCode）全球极客挚爱的技术成长平台

PS：作者水平有限，如有错误或描述不当的地方，恳请及时告诉作者，作者将不胜感激

🔒题目

原题链接：22. 括号生成 - 力扣（LeetCode）

🔑题解

• 解法一：DFS+剪枝

  DFS应该是这题最容易想到的思路了，暴力思路我反而觉得超级麻烦。这题单纯使用DFS是无法解决的，还需要搭配剪枝，对于DFS我们只需要构建好它遍历的二叉树就应该能够理解了，下面是本体题解的图解

  

  其中红色虚线圈起来的都是被“剪枝”的，可以看到，如果n为2时，通过DFS+剪枝最终可以得到的有效括号为 “(())”和“()()”

  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * @author ghp
   * @title 有效的括号
   */
  public class Solution {
  
      public List<String> generateParenthesis(int n) {
          List<String> ans = new ArrayList<>(10);
          // 通过深搜得到所有符合条件的有效括号
          dfs(ans, "", 0, 0, n);
          return ans;
      }
  
      /**
       * 深度搜索所有符合条件的括号组合
       *
       * @param ans  存储有效括号
       * @param path 组合的括号
       * @param l    用于遍历左节点
       * @param r    用于遍历右节点
       * @param n    括号的对数
       */
      private void dfs(List<String> ans, String path, int l, int r, int n) {
          // 剪枝
          if (l > n || r > n || r > l) {
              // 左括号或右括号超过总数的一半（不可能组合成有小括号），直接结束搜索
              return;
          }
          // 递归终止条件（需要遍历 2*n 层，因为括号是成对的）
          if (path.length() == 2 * n) {
              // 已经遍历到最底层了，并且没有被剪枝，说明是有效括号
              ans.add(path.toString());
              return;
          }
          // 往左遍历
          dfs(ans, path + "(", l + 1, r, n);
          // 往右遍历
          dfs(ans, path + ")", l, r + 1, n);
      }
  }
  

  • 复杂度分析：

    • 时间复杂度：$O(\frac{4^n}{\sqrt{n}})$
    • 空间复杂度：$O(n)$

  其中 $n$ 为数组中元素的个数

  

  拓展：代码优化

  使用StringBuilder的append方法替代+进行字符串拼接：

  本来最先开始是打算使用StringBuilder去完成字符串的拼接的，因为+进行字符拼接时，底层其实是通过new应该StringBuilder然后调用StringBuilder的append方法实现的，所以说每次使用+进行一次拼接操作，就会重新创建一个StringBuilder对象。这样自然而然直接调用StringBuilder的append方法来实现字符串拼接，效率高而且还能节约内存。

  温馨提示：这里使用StringBuilder来实现字符拼接，需要注意有一个回溯的过程，因为方法传递的StringBuilder对象是同一个，所以需要有一个恢复现场的过程（这里我一开始就被坑了），而直接使用+不需要恢复现场，因为每一次拼接都会重新new一个StringBuilder对象

  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * @author ghp
   * @title 有效的括号
   */
  public class Solution {
  
      public List<String> generateParenthesis(int n) {
          List<String> ans = new ArrayList<>(10);
          // 通过深搜得到所有符合条件的有效括号
          dfs(ans, new StringBuilder(), 0, 0, n);
          return ans;
      }
  
      private void dfs(List<String> ans, StringBuilder path, int l, int r, int n) {
          // 剪枝
          if (l > n || r > n || r > l) {
              // 左括号或右括号超过总数的一半（不可能组合成有小括号），直接结束搜索
              return;
          }
          // 递归终止条件
          if (path.length() == 2 * n) {
              // 已经遍历到最底层了，并且没有被剪枝，说明是有效括号
              ans.add(path.toString());
              return;
          }
          // 往左遍历
          dfs(ans, path.append("("), l + 1, r, n);
          path.deleteCharAt(path.length()-1);
          // 往右遍历
          dfs(ans, path.append(")"), l, r + 1, n);
          path.deleteCharAt(path.length()-1);
  
      }
  }
  

  可以从提交结果上，明显看出+与append两者内存消耗的差距（不知道为什么执行时间为什么没有提升(・∀・(・∀・*)）

  

• 解法二：动态规划

  参考自这位大佬 递推，动态规划 - 括号生成 - 力扣（LeetCode）

  这题还是不太推荐使用动态规划，时间复杂度较高而且不太好理解（个人感觉，可能是我动态规划题目写得少吧w(ﾟДﾟ)w），并且效率也较低，还是推荐使用DFS+剪枝

  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  
  /**
   * @author ghp
   * @title 有效的括号
   */
  public class Solution {
      public List<String> generateParenthesis(int n) {
          List<List<String>> db = new ArrayList<>(n + 1);
          // 初始化
          db.add(Arrays.asList(""));
          db.add(Arrays.asList("()"));
          for (int i = 2; i <= n; i++) {
              List<String> temp = new ArrayList<>(10);
              for (int j = 0; j < i; j++) {
                  List<String> list1 = db.get(j);
                  List<String> list2 = db.get(i - 1 - j);
                  for (String s1 : list1) {
                      for (String s2 : list2) {
                          String str = "(" + s1 + ")" + s2;
                          temp.add(str);
                      }
                  }
              }
              db.add(temp);
          }
          return db.get(n);
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(n^3)$
  • 空间复杂度：$O(1)$

  其中 $n$ 为有效括号的数量

  

• 解法三：LeetCode官方解法

  class Solution {
      public List<String> generateParenthesis(int n) {
          List<String> ans = new ArrayList<String>();
          backtrack(ans, new StringBuilder(), 0, 0, n);
          return ans;
      }
  
      public void backtrack(List<String> ans, StringBuilder cur, int open, int close, int max) {
          if (cur.length() == max * 2) {
              ans.add(cur.toString());
              return;
          }
          if (open < max) {
              cur.append('(');
              backtrack(ans, cur, open + 1, close, max);
              cur.deleteCharAt(cur.length() - 1);
          }
          if (close < open) {
              cur.append(')');
              backtrack(ans, cur, open, close + 1, max);
              cur.deleteCharAt(cur.length() - 1);
          }
      }
  }
  
  作者：LeetCode-Solution
  链接：https://leetcode.cn/problems/generate-parentheses/solution/gua-hao-sheng-cheng-by-leetcode-solution/
  来源：力扣（LeetCode）
  著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
  

  复杂度分析：

  • 时间复杂度：$O(\frac{4^n}{\sqrt{n}})$
  • 空间复杂度：$O(n)$

  其中 $n$ 为有效括号的数量