Algorithm 计算圆括号平衡的分布式算法

这是一个问题：“如何构建分布式算法来计算括号的平衡？”

通常，平衡算法从左到右扫描字符串形式，并使用堆栈确保开括号数始终>=闭括号数，最后是开括号数==闭括号数

---

如何使其分布？

我将应用map reduce算法，在该算法中，map函数将计算字符串的一部分，如果括号是平衡的，则返回一个空字符串，或者返回一个带有最后一个括号的字符串

---

然后reduce函数通过map函数连接两个返回字符串的结果，并再次计算它，返回与map相同的结果。在所有计算结束时，您将获得一个空字符串或一个包含不平衡括号的字符串。

您可以将该字符串分为多个块，并分别进行处理，前提是您可以并行读取和发送到其他机器。每个字符串需要两个数字

相对于字符串开头达到的最小嵌套深度

整个字符串嵌套深度的总增益或损失

使用这些值，您可以按如下方式计算多个块的串联值：

minNest = 0
totGain = 0
for p in chunkResults
  minNest = min(minNest, totGain + p.minNest)
  totGain += p.totGain
return new ChunkResult(minNest, totGain)

---

如果

totGain

和

minNest

的最终值为零，则括号将匹配。

我将尝试对@jonderry的答案进行更详细的解释。首先在Scala中编写代码

def parBalance(chars: Array[Char], chunkSize: Int): Boolean = {
    require(chunkSize > 0, "chunkSize must be greater than 0")

    def traverse(from: Int, until: Int): (Int, Int) = {
      var count = 0
      var stack = 0
      var nest = 0
      for (n <- from until until) {
        val cur = chars(c)
        if (cur == '(') {
          count += 1
          stack += 1
        }
        else if (cur == ')') {
          count -= 1
          if (stack > 0) stack -= 1
          else nest -= 1
        }
      }
      (nest, count)
    }

    def reduce(from: Int, until: Int): (Int, Int) = {
      val m = (until + from) / 2
      if (until - from <= chunkSize) {
        traverse(from, until)
      } else {
        parallel(reduce(from, m), reduce(m, until)) match {
          case ((minNestL, totGainL), (minNestR, totGainR)) => {
            ((minNestL min (minNestR + totGainL)), (totGainL + totGainR))
          }
        }
      }
    }

    reduce(0, chars.length) == (0,0)
}

def parBalance（字符：数组[Char]，chunkSize:Int）：布尔={
要求（chunkSize>0，“chunkSize必须大于0”）
def遍历（从：Int，直到：Int）：（Int，Int）={
变量计数=0
var stack=0
var-nest=0
对于（n0）堆栈-=1
else nest-=1
}
}
（鸟巢，伯爵）
}
def减少（从：Int，直到：Int）：（Int，Int）={
val m=（直到+从）/2
如果（直到-从）{
（（minNestL min（minNestR+totGainR）），（totGainR+totGainR））
}
}
}
}
减少（0，字符长度）=（0,0）
}

---

给定一个字符串，如果我们去掉平衡圆括号，剩下的将是形式

）（（（

，给n表示

的个数，

，给m表示

的个数（

，那么m>=0，n这个方法对于类似“（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（））））））））））的字符串（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（（或者类似。您只需要知道它是否是有效的匹配字符串，还是需要知道每个paren匹配的索引？后者则不那么直截了当。（我的解决方案是前者。）我想我只需要验证字符串。我认为如果minNest在循环期间低于零，则括号不匹配。@Keith，是的，我最初混淆了该测试。最小嵌套深度是否等于当前子字符串中不匹配右括号的数量？此外，minNest是否可以大于0？@DenTheMan，您可以从字符串开头到子字符串开头的不匹配左括号总数中减去该数字。@jonderry:我对您的解决方案不是100%清楚。你能描述一下完整的算法吗。