迭代字符串替换后可能产生的最短长度

Question

通过重复对输入序列应用替换，我将如何合理有效地找到可能的最短输出？我相信（如果我错了，请纠正我）在最坏的情况下这是指数时间，但由于下面的第二个约束，我不确定。天真的方法当然是。

我尝试编写朴素方法（对于所有可能的替换，对于所有有效位置，在该位置应用替换后递归输入的副本。返回所有有效递归和输入中最短的一个，并启用缓存捕获等效替换序列的函数），但它（不可行）很慢，我很确定这是一个算法问题，而不是实现。

有几件事可能会（或可能不会）有所作为：

• 令牌是枚举类型。
• 映射中每个条目的输出长度严格小于条目的输入。
• 我确实不需要完成了哪些替换以及在哪里完成了替换，只需要生成的序列。

因此，作为每个字符都是令牌的示例（为简单起见），如果我将替换映射为 aaba -> a、aaa -> ab 和 aba - > bb，我申请了 minimumString('aaaaa')，我想得到 'a'。

实际的方法签名大致如下：

List<Token> getMinimalAfterReplacements(List<Token> inputList, Map<List<Token>, List<Token>> replacements) {
    ?
}

有没有比暴力破解更好的方法？如果没有，是否有可以利用的 SAT 库或类似的库？当使用不同的令牌列表但使用相同的替换地图多次调用时，是否可以对地图进行任何预处理以使其更快？

Answer 1

下面的代码是一个 Python 版本，用于找到尽可能短的缩减。它是非递归的，但与朴素算法相距不远。在每一步中，它都会尝试所有可能的单个归约，从而获得一组字符串以用于下一步归约。

当存在像“aa”->“a”这样的“符号吃”规则时，一个有助于检查下一组字符串是否重复的优化。

另一个优化（未在下面的代码中实现）是将替换规则处理成一个有限自动机，该自动机通过输入字符串单次遍历找到所有可能的单次归约的位置。不过，这无助于主树搜索算法的指数性质。

class Replacer:
  def __init__(self, replacements):
    self.replacements = [[tuple(key), tuple(value)] for key, value in replacements.items()]

  def get_possible_replacements(self, input):
    "Return all possible variations where a single replacement was done to the input"
    result = []
    for replace_what, replace_with in self.replacements:
      #print replace_what, replace_with
      for p in range(1 + len(input) - len(replace_what)):
        if input[p : p + len(replace_what)] == replace_what:
          input_copy = list(input[:])
          input_copy[p : p + len(replace_what)] = replace_with
          result.append(tuple(input_copy))
    return result

  def get_minimum_sequence_list(self, input):
    "Return the shortest irreducible sequence that can be obtained from the given input"
    irreducible = []
    to_reduce = [tuple(input)]
    to_reduce_new = []
    step = 1
    while to_reduce:
      print "Reduction step", step, ", number of candidates to reduce:", len(to_reduce)
      step += 1
      for current_input in to_reduce:
        reductions = self.get_possible_replacements(current_input)
        if not reductions:
          irreducible.append(current_input)
        else:
          to_reduce_new += reductions
      to_reduce = set(to_reduce_new[:]) # This dramatically reduces the tree width by removing duplicates
      to_reduce_new = []

    irreducible_sorted = sorted(set(irreducible), key = lambda x: len(x))
    #print "".join(input), "could be reduced to any of", ["".join(x) for x in irreducible_sorted]
    return irreducible_sorted[0]

  def get_minimum_sequence(self, input):
    return "".join(self.get_minimum_sequence_list(list(input)))

input = "aaaaa"

replacements = {
  "aaba" : "a",
  "aaa" : "ab",
  "aba" : "bb",
}

replacer = Replacer(replacements)
replaced = replacer.get_minimum_sequence(input)
print "The shortest string", input, "could be reduced to is", replaced

Answer 2

只是一个可能减少分支的简单想法：使用类似的规则

ba -> c
ca -> b

和类似的字符串

aaabaacaa
   ^  ^

您可以进行两次替换，它们的顺序无关紧要。记忆化已经涵盖了这一点，但是，生成无用的字符串仍然存在相当大的开销。所以我建议以下规则：

在位置 p 上替换后，仅考虑位置 q 上的替换，这样

q + length(lhs_of_the_rule) > p

即，不会从先前替换的左侧开始或它们重叠。

---

作为一个简单的低级优化，我建议将List<Token> 替换为String 或（或封装的byte[] 或short[] 或其他）。较低的内存占用应该有助于缓存，您可以通过一个（或两个）字符串元素对数组进行索引，以找出适用于它的规则。