Question

我最近遇到了一个问题，就是找到有效parantheses的所有可能子序列，其中括号由-x x之类的数字描述，其中＆＃39; -x＆＃39;表示开放和＆＃39; x＆＃39;代表关闭和 -x s x也代表一个有效的括号，其中＆＃39;是一个有效的括号。

ex-例如，＆＃34; -1 -2 2 -3 -4 4 3 1＆＃34;是一个平衡的括号对序列，但是＆＃34; -1 -2 1 2＆＃34;不是和 -1 -2 9 2 -3 -4 3 4 8 8 1给出12

我正在尝试，但我无法想出这个问题的递归关系。任何帮助都会受到赞赏。谢谢。

Answer 1

def findPairsOfParentheis（collection）：

count = 0
flag = False
othercount = 0
for i in collection:

    if i.startswith('-'):
        if flag:
            othercount += 1 
            continue
        else:
            othercount += 1
            flag = True
    else:
        if flag:
            if othercount > 1:
                othercount -= 1
                count += 1
            else:
                othercount = 0
                flag = False
                count += 1
        else:
            continue


return count

＃代码是python，它打印括号对的数量，希望这有帮助

Answer 2

任何有效的平衡括号序列都有一个唯一的最短平衡前缀（可能是整个序列）。该前缀的格式必须为( S )，其中S是一个平衡序列。此外，原始序列的其余部分必须是空的或平衡序列。因此，任何平衡序列都可以写成：

S = ( S₁ ) S₂

其中S₁和S₂都是较短的平衡序列。

这导致了一个简单的递归生成器。它还证明长度为2k的有效括号序列的数量是索引k的加泰罗尼亚数（使用加泰罗尼亚数字的标准递归关系，如果没有乳胶，这里很难输入）。

在数字形式中，您需要使用：

S = -1 S₁' 1 S₂'

其中S₁'中的索引通过递增1从S₁获得，S₂'通过递增S₂中的最大索引从S₁'获得（这是S₁长度的一半以上。）

Answer 3

看看这个问题：

Finding all combinations of well-formed brackets

它不是您问题的解决方案，也不是最佳解决方案，但如果您了解它，您也可以解决您的问题。

Answer 4

您可以使用两个堆栈，negStack和posStack; negStack初始化为所有负括号，顺序为-1，posStack为空。每当您从negStack弹出一个负括号时，您将其正对应推到posStack。

在每次递归通话中，您可以从negStack弹出（假设它非空）并推送到postStack，或者您可以从posStack弹出（假设它＆＃39; s非空）。这意味着您的递归方法看起来像

void recurrence(Stack negStack, Stack posStack) {
  // first recursive call: pop from negStack
  int neg = negStack.pop();
  posStack.push(-1 * neg);
  recurrence(negStack, posStack);

  // restore stacks
  posStack.pop();
  negStack.push(neg);

  // second recursive call: pop from posStack
  int pos = posStack.pop();
  recurrence(negStack, posStack);

  // restore stacks
  posStack.push(pos);
}

我省略了检查以查看negStack或posStack是否为空，以及存储和打印结果的代码等（例如，您可以使用另一个堆栈来存储括号＆＃39;运行总计，然后在negStack和posStack为空时打印堆栈内容。

算法 - 所有有效的括号子序列

4 个答案: