我们怎样才能在括号上产生所有可能性？
N值给了我们，我们必须产生所有可能性。
示例：
1）如果N == 1，那么只有一种可能性（）。
2）如果N == 2，那么可能性是（（）），（）（）
3）如果N == 3，那么可能性是（（（））），（（））（），（）（）（），（）（（））......
注意：左右括号应匹配。我的意思是）（对于N == 1
是无效的我们可以使用递归方法解决这个问题吗？
答案 0 :(得分：4)
来自维基百科 -
Dyck字是由n个X和n个Y组成的字符串，这样字符串的初始段没有比X更多的Y（参见Dyck语言）。例如，以下是长度为6的Dyck单词：
XXXYYY XYXXYY XYXYXY XXYYXY XXYXYY.
将符号X重新解释为左括号，将Y重新解释为右括号，Cn计算包含正确匹配的n对括号的表达式的数量：
((())) ()(()) ()()() (())() (()())
另见http://www.acta.sapientia.ro/acta-info/C1-1/info1-9.pdf
摘要。提出了一种生成所有Dyck单词的新算法， 用于排名和取消Dyck单词。我们强调 在编码与加泰罗尼亚语相关的对象中使用Dyck单词的重要性 数字。作为排名算法中使用的公式的结果 我们可以得到第n个加泰罗尼亚数的递归公式。
答案 1 :(得分：3)
对于给定的N，我们始终必须以开放式支撑开始。现在考虑相应的右括号在哪里。它可以位于()()中间，也可以位于(()) N=2的末尾。
现在考虑N=3：
它可以在最后：(()())和((()))。
或者在中间：()(())和()()()，它位于第2位。然后它也可以位于第4位：(())()。
现在我们基本上可以结合这两种情况，通过实现闭合括号在末尾的情况与它在中间的情况相同，但是N = 0的所有可能性都添加到最后。
现在要解决它，你可以在开始和结束大括号之间找出n的所有可能性，同样你可以在结束大括号之后找出m的所有可能性。 （注意m+n+1 = N）然后您可以组合所有可能的组合，将它们附加到您的可能性列表中，然后转到结束括号的下一个可能位置。
请注意，对于这些类型的问题，一个容易犯的错误就是找到i和N-i的所有可能性并将它们组合起来，但N=3这样做会重复计算()()()或至少打印两次。
以下是一些解决问题的Python 2.x代码：
memoise = {}
memoise[0] = [""]
memoise[1] = ["()"]
def solve(N, doprint=True):
if N in memoise:
return memoise[N]
memoise[N] = []
for i in xrange(1,N+1):
between = solve(i-1, False)
after = solve(N-i, False)
for b in between:
for a in after:
memoise[N].append("("+b+")"+a)
if doprint:
for res in memoise[N]:
print res
return memoise[N]
答案 2 :(得分：2)
尝试谷歌加泰罗尼亚数字
答案 3 :(得分：1)
递归解决方案：
import java.util.Scanner;
public class Parentheses
{
static void ParCheck(int left,int right,String str)
{
if (left == 0 && right == 0)
{
System.out.println(str);
}
if (left > 0)
{
ParCheck(left-1, right+1 , str + "(");
}
if (right > 0)
{
ParCheck(left, right-1, str + ")");
}
}
public static void main(String[] args)
{
Scanner input=new Scanner(System.in);
System.out.println("Enter the number");
int num=input.nextInt();
String str="";
ParCheck(num,0,str);
}
}
答案 4 :(得分：1)
这里有一些代码，它本质上是JPvdMerwe代码的紧凑版本，除了它返回解决方案列表而不是打印它们。此代码适用于Python 2和Python 3。
from itertools import product
def solve(num, cache={0: ['']}):
if num not in cache:
cache[num] = ['(%s)%s' % t for i in range(1, num + 1)
for t in product(solve(i - 1), solve(num - i))]
return cache[num]
# Test
for num in range(1, 5):
print(num)
for s in solve(num):
print(s)
<强>输出
1
()
2
()()
(())
3
()()()
()(())
(())()
(()())
((()))
4
()()()()
()()(())
()(())()
()(()())
()((()))
(())()()
(())(())
(()())()
((()))()
(()()())
(()(()))
((())())
((()()))
(((())))
以下是一些函数，这些函数源自Ed Guiness链接的文章中给出的伪代码：Generating and ranking of Dyck words。那篇文章使用了基于1的索引，但我已将它们转换为符合Python的基于0的索引。
这些函数比上面的solve函数慢，但它们可能仍然有用。 pos_dyck_words的优势在于它纯粹是迭代的。 unrank是迭代的，但它调用递归辅助函数f; OTOH，f使用缓存，因此速度并不慢，而且它只缓存整数，它使用的内存少于solve的字符串缓存。 unrank的主要好处是它可以从索引号返回单个解决方案，而不必生成给定大小的所有解决方案。
此代码仅适用于Python 3。将它转换为Python 2使用很简单，你只需要实现自己的缓存方案而不是lru_cache。你做需要缓存，否则f除了最小的Dyck字长之外都是无法忍受的。
from itertools import product
from functools import lru_cache
# Generate all Dyck words of length 2*num, recursively
# fastest, but not lexicographically ordered
def solve(num, cache = {0: ['']}):
if num not in cache:
cache[num] = ['0%s1%s' % t for i in range(1, num + 1)
for t in product(solve(i - 1), solve(num - i))]
return cache[num]
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# A helper function for `unrank`
# f(i, j) gives the number of paths between (0,0) and (i, j) not crossing
# the diagonal x == y of the grid. Paths consist of horizontal and vertical
# segments only, no diagonals are permitted
@lru_cache(None)
def f(i, j):
if j == 0:
return 1
if j == 1:
return i
#if i < j:
#return 0
if i == j:
return f(i, i - 1)
# 1 < j < i <= n
return f(i - 1, j) + f(i, j - 1)
# Determine the position array of a Dyck word from its rank number,
# The position array gives the indices of the 1s in the word;
# the rank number is the word's index in the lexicographic sequence
# of all Dyck words of length 2n
# Very slow
def unrank(nr, n):
b = [-1]
for i in range(n):
b.append(1 + max(b[-1], 2 * i))
ni = n - i - 1
for j in range(n + i - b[-1], 0, -1):
delta = f(ni, j)
if nr < delta or b[-1] >= n + i:
break
nr -= delta
b[-1] += 1
return b[1:]
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Generate all Dyck word position arrays for words of length 2*n, iteratively
def pos_dyck_words(n):
b = list(range(1, 2 * n, 2))
while True:
yield b
for i in range(n - 2, -1, -1):
if b[i] < n + i:
b[i] += 1
for j in range(i + 1, n - 1):
b[j] = 1 + max(b[j - 1], 2 * j)
break
else:
break
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Convert a position array to a Dyck word
def pos_to_word(b, n, chars='01'):
c0, c1 = chars
word = [c0] * (2 * n)
for i in b:
word[i] = c1
return ''.join(word)
# Some tests
num = 4
print('num: {}, Catalan number: {}'.format(num, f(num, num)))
words = list(solve(num))
words.sort(reverse=True)
print(len(words))
for i, u in enumerate(pos_dyck_words(num)):
v = unrank(i, num)
w = words[i]
ok = u == v and pos_to_word(u, num) == w
print('{:2} {} {} {} {}'.format(i, u, v, w, ok))
print()
num = 10
print('num: {}, Catalan number: {}'.format(num, f(num, num)))
for i, u in enumerate(pos_dyck_words(num)):
v = unrank(i, num)
assert u == v, (i, u, v)
print('ok')
<强>输出
num: 4, Catalan number: 14
14
0 [1, 3, 5, 7] [1, 3, 5, 7] 01010101 True
1 [1, 3, 6, 7] [1, 3, 6, 7] 01010011 True
2 [1, 4, 5, 7] [1, 4, 5, 7] 01001101 True
3 [1, 4, 6, 7] [1, 4, 6, 7] 01001011 True
4 [1, 5, 6, 7] [1, 5, 6, 7] 01000111 True
5 [2, 3, 5, 7] [2, 3, 5, 7] 00110101 True
6 [2, 3, 6, 7] [2, 3, 6, 7] 00110011 True
7 [2, 4, 5, 7] [2, 4, 5, 7] 00101101 True
8 [2, 4, 6, 7] [2, 4, 6, 7] 00101011 True
9 [2, 5, 6, 7] [2, 5, 6, 7] 00100111 True
10 [3, 4, 5, 7] [3, 4, 5, 7] 00011101 True
11 [3, 4, 6, 7] [3, 4, 6, 7] 00011011 True
12 [3, 5, 6, 7] [3, 5, 6, 7] 00010111 True
13 [4, 5, 6, 7] [4, 5, 6, 7] 00001111 True
num: 10, Catalan number: 16796
ok
答案 5 :(得分：0)
我想出了以下算法，它不是OP所要求的递归算法，但鉴于其无敌效率，值得一提。
如Ed Guiness' post中所述，N对正确匹配的括号中的字符串代表Dyck单词。在另一个有用的表示形式中，括号(和)分别替换为1和0。因此，()()()变为101010。后者也可以看作是（十进制）数字42的二进制表示。总之，一些整数可以表示正确匹配的括号对的字符串。使用这种表示法，以下是生成Dyck作品的有效算法。
让integer是任何C / C ++（或者可能是C-family programming languages的成员）无符号整数类型，最长为64位。给定一个Dyck单词，以下代码将返回下一个相同大小的Dyck单词（如果存在）。
integer next_dyck_word(integer w) {
integer const a = w & -w;
integer const b = w + a;
integer c = w ^ b;
c = (c / a >> 2) + 1;
c = ((c * c - 1) & 0xaaaaaaaaaaaaaaaa) | b;
return c;
}
例如，如果w == 42（二进制形式的101010（即()()()），该函数将返回44（101100，()(())） 。可以迭代直到得到56（111000，((()))），这是N == 3的最大Dyck词。
上面，我提到了无敌效率，因为就单个戴克词的生成而言，该算法是O（1），无环和无分支的。但是，该实现仍有改进的空间。确实，如果我们可以使用在严格符合标准的C / C ++中不可用的一些汇编指令，则可以消除函数主体中相对昂贵的分隔c / a。
您可能会说。 “ 异议！我不想约束N <= 64 ”。好吧，我对此的回答是，如果您想生成所有Dyck作品，那么实际上，您所绑定的大小已经比64小得多。实际上，the number of Dyck works of size N与N一起阶乘增长，并且对于N == 64而言，生成它们的时间可能大于宇宙时代。 （我承认我这次没有计算，但这是这种性质的问题的一个相当普遍的轶事。）