class Solution:
def generateParenthesis(self, n: int) -> List[str]:
# 思路是根据左右括号剩余数量进行生成
# 剩余左括号小于剩余右括号时,可以加左或者加右
# 剩余左括号大于剩余右括号时,舍弃
def backtrack(cur,left,right,res):
if left==right==0:
res.append(cur)
return
if left>right:
return
if left>0:
backtrack(cur+'(',left-1,right,res)
if right>0:
backtrack(cur+')',left,right-1,res)
res=[]
backtrack('',n,n,res)
return res
思路:
- 首先注意索然我这里函数名是backtrack但是这种解法并不包含回溯
- 解题条件是,左右括号剩余的数量
- 跳出递归的条件是:左右括号都用完或者剩余的左大于剩余的右
- 剪枝条件已标红
- 然后就可以在
left>0
和right>0
的条件下,加入左右括号
广度优先遍历
为什么不推荐使用?广度优先与深度优先不同在哪?
- 广度优先遍历,得程序员自己编写结点类,显示使用队列这个数据结构。
- 深度优先遍历的时候,就可以直接使用系统栈,在递归方法执行完成的时候,系统栈顶就把我们所需要的状态信息直接弹出,而无须编写结点类和显示使用栈。
- 搜索几乎都是用深度优先遍历(回溯算法)。
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class Solution {
class Node {
/**
* 当前得到的字符串
*/
private String res;
/**
* 剩余左括号数量
*/
private int left;
/**
* 剩余右括号数量
*/
private int right;
public Node(String str, int left, int right) {
this.res = str;
this.left = left;
this.right = right;
}
}
public List<String> generateParenthesis(int n) {
List<String> res = new ArrayList<>();
if (n == 0) {
return res;
}
Queue<Node> queue = new LinkedList<>();
queue.offer(new Node("", n, n));
while (!queue.isEmpty()) {
Node curNode = queue.poll();
if (curNode.left == 0 && curNode.right == 0) {
res.add(curNode.res);
}
if (curNode.left > 0) {
queue.offer(new Node(curNode.res + "(", curNode.left - 1, curNode.right));
}
if (curNode.right > 0 && curNode.left < curNode.right) {
queue.offer(new Node(curNode.res + ")", curNode.left, curNode.right - 1));
}
}
return res;
}
}