Question

我必须找出有效括号的数量.Parenthesis有两种类型<body>。使用X和Y数[] ,()构造有效序列的方法有多少。对于此问题，我们认为[] ,()无效，([]) 有没有比递归更好的解决方案。

() can't hold [].

Answer 1

因为方括号不能在圆括号内，所以在每次出现方括号之前，每个圆括号序列必须完整（即打开的减号括号的数量减少到零）。

  1      012    1      0  
()[(())()][[()()]((()))]()
10 121010   1010 123210 10

这实际上意味着方括号将圆括号分成单独的独立序列：

   1   0   1   2   1   0
...[...]...[...[...]...]...

其中圆括号的完整序列可以放在方括号之间的任何位置。

如Paul Hankin所述，Catalan Number给出了一种括号中有效序列的数量。这将为您提供方括号的有效序列数，以及要插入方括号之间某处的任意数量圆括号的有效序列数。

不幸的是，找出圆括号可以分布到方括号之间的不同位置的方式是分区问题，解决这个问题的逻辑方法是递归。因此，这种思路可以导致算法，但不能避免递归。

然而，查找分区所需的递归数量远小于加泰罗尼亚语数字（例如，20有627个分区，但20的加泰罗尼亚语数字是6,564,120,420），因此这种方法比递归枚举每个有效序列要快得多

这是一个简单的例子来演示这是如何工作的：

X = 2，Y = 3

方括号的有效序列：

CatalanNumber（2）= 2
1. [ ] [ ]  
2. [ [ ] ]

圆括号的位置：

2×X + 1 = 5
1[2]3[4]5
1[2[3]4]5

圆括号的分区：

p（Y）= 3
3
2,1
1,1,1

分区的排列：

分区：3（部件数量：1）
→5 = 5

3,0,0,0,0  0,3,0,0,0  0,0,3,0,0  0,0,0,3,0  0,0,0,0,3

分区：2,1（部件数量：2）
→5×4 = 20

2,1,0,0,0  2,0,1,0,0  2,0,0,1,0  2,0,0,0,1  
1,2,0,0,0  0,2,1,0,0  0,2,0,1,0  0,2,0,0,1  
1,0,2,0,0  0,1,2,0,0  0,0,2,1,0  0,0,2,0,1  
1,0,0,2,0  0,1,0,2,0  0,0,1,2,0  0,0,0,2,1  
1,0,0,0,2  0,1,0,0,2  0,0,1,0,2  0,0,0,1,2

分区：1,1,1（部件数量：3，相同：3）
→（5×4×3）/（1×2×3）= 10

1,1,1,0,0  1,1,0,1,0  1,1,0,0,1  
1,0,1,1,0  1,0,1,0,1  1,0,0,1,1  
0,1,1,1,0  0,1,1,0,1  0,1,0,1,1  0,0,1,1,1

圆括号的有效序列：

CatalanNumber（3）= 5
1. ()()()
2. ()(())
3. (())()
4. (()())
5. ((()))
CatalanNumber（2）= 2
1. ()()
2. (())
CatalanNumber（1）= 1
1. ()
CatalanNumber（0）= 1
1. 

每个分区的有效序列：

3,0,0,0,0  5 x 1 x 1 x 1 x 1  =  5
2,1,0,0,0  2 x 1 x 1 x 1 x 1  =  2
1,1,1,0,0  1 x 1 x 1 x 1 x 1  =  1

有效序列的总数：

方括号：2
圆括号：75
 5 x 5 = 25  
20 x 2 = 40  
10 x 1 = 10  
总计：2×75 = 150

Answer 2

对于任何给定的分组，自封闭圆括号和给定方括号排列的组合，我们可以使用多集合组合来确定排列的数量：

n + k - 1 choose k, where k is the smaller of the number of self-enclosed parenthetical groups and the total number of square brackets, and n is the larger of the two + 1.

方括号的数量是第n个加泰罗尼亚数字。

生成括号组的一种方法是分配越来越多的组，并计算每个分区的不同排列的数量（X - 分配的组的数量）乘以部分的总和 - 作为nth -Catalan。例如：

X = 4
Counts for each grouping:

1 group: Cat 3
2 groups: Cat 2 * 2 + 1 // partitions [2,0] * 2 and [1,1]
3 groups: 3 // partition [1,0,0] * 3
4 groups: 1 // partition [0,0,0,0]

我还没有想到避免分区的方法，并且有兴趣学习。

有效括号的数量

2 个答案: