具有重叠的字符串连接的高效算法

Question

我们需要通过连接来组合数据库中的 3 列。但是，这 3 列可能包含重叠部分，并且这些部分不应重复。例如，

  "a" + "b" + "c" => "abc"
  "abcde" + "defgh" + "ghlmn" => "abcdefghlmn"
  "abcdede" + "dedefgh" + "" => "abcdedefgh"
  "abcde" + "d" + "ghlmn" => "abcdedghlmn"
  "abcdef" + "" + "defghl" => "abcdefghl"

我们当前的算法非常慢，因为它使用蛮力来识别 2 个字符串之间的重叠部分。有谁知道一种有效的算法来做到这一点？

假设我们有 2 个字符串 A 和 B。算法需要找到最长的公共子字符串 S，以便 A 以 S 结尾，B 以 S 开头。

附上我们当前在 Java 中的蛮力实现以供参考，

public static String concat(String s1, String s2) {
    if (s1 == null)
        return s2;
    if (s2 == null)
        return s1;
    int len = Math.min(s1.length(), s2.length());

    // Find the index for the end of overlapping part
    int index = -1;
    for (int i = len; i > 0; i--) {
        String substring = s2.substring(0, i);
        if (s1.endsWith(substring)) {
            index = i;
            break;
        }
    }
    StringBuilder sb = new StringBuilder(s1);
    if (index < 0) 
        sb.append(s2);
    else if (index <= s2.length())
        sb.append(s2.substring(index));
    return sb.toString();
}

Answer 1

这是一个 Java 实现，它在 O(min(N,M)) 操作 ~ O(N) 中找到长度为 N 和 M 的两个字符串之间的最大重叠。

我和@sepp2k:s 有同样的想法，现在删除了答案，并进一步研究了它。似乎工作正常。这个想法是遍历第一个字符串并在找到与第二个字符串的开头匹配的内容后开始跟踪。发现如果假匹配和真匹配重叠，您可能需要同时进行多个跟踪。最后，您选择最长的轨道。

我还没有计算出绝对最坏的情况，比赛之间的重叠最大，但我不认为它会失控，因为我认为你不能重叠任意多场比赛。通常您一次只跟踪一两个匹配项：一旦出现不匹配，候选对象就会被删除。

static class Candidate {
    int matchLen = 0;
}

private String overlapOnce(@NotNull final String a, @NotNull final String b) {
    final int maxOverlap = Math.min(a.length(), b.length());
    final Collection<Candidate> candidates = new LinkedList<>();
    for (int i = a.length() - maxOverlap; i < a.length(); ++i) {
        if (a.charAt(i) == b.charAt(0)) {
            candidates.add(new Candidate());
        }
        for (final Iterator<Candidate> it = candidates.iterator(); it.hasNext(); ) {
            final Candidate candidate = it.next();
            if (a.charAt(i) == b.charAt(candidate.matchLen)) {
                //advance
                ++candidate.matchLen;
            } else {
                //not matching anymore, remove
                it.remove();
            }
        }

    }
    final int matchLen = candidates.isEmpty() ? 0 :
            candidates.stream().map(c -> c.matchLen).max(Comparator.comparingInt(l -> l)).get();
    return a + b.substring(matchLen);
}

private String overlapOnce(@NotNull final String... strings) {
    return Arrays.stream(strings).reduce("", this::overlapOnce);
}

还有一些测试：

@Test
public void testOverlapOnce() throws Exception {
    assertEquals("", overlapOnce("", ""));
    assertEquals("ab", overlapOnce("a", "b"));
    assertEquals("abc", overlapOnce("ab", "bc"));
    assertEquals("abcdefghqabcdefghi", overlapOnce("abcdefgh", "efghqabcdefghi"));
    assertEquals("aaaaaabaaaaaa", overlapOnce("aaaaaab", "baaaaaa"));
    assertEquals("ccc", overlapOnce("ccc", "ccc"));
    assertEquals("abcabc", overlapOnce("abcabc", "abcabc"));

    /**
     *  "a" + "b" + "c" => "abc"
     "abcde" + "defgh" + "ghlmn" => "abcdefghlmn"
     "abcdede" + "dedefgh" + "" => "abcdedefgh"
     "abcde" + "d" + "ghlmn" => "abcdedghlmn"
     "abcdef" + "" + "defghl" => "abcdefghl"
     */
    assertEquals("abc", overlapOnce("a", "b", "c"));
    assertEquals("abcdefghlmn", overlapOnce("abcde", "defgh", "ghlmn"));
    assertEquals("abcdedefgh", overlapOnce("abcdede", "dedefgh"));
    assertEquals("abcdedghlmn", overlapOnce("abcde", "d", "ghlmn"));
    assertEquals("abcdefghl", overlapOnce("abcdef", "", "defghl"));


    // Consider str1=abXabXabXac and str2=XabXac. Your approach will output abXabXabXacXabXac because by
    // resetting j=0, it goes to far back.
    assertEquals("abXabXabXac", overlapOnce("abXabXabXac", "XabXac"));

    // Try to trick algo with an earlier false match overlapping with the real match
    //  - match first "aba" and miss that the last "a" is the start of the
    // real match
    assertEquals("ababa--", overlapOnce("ababa", "aba--"));
}

Answer 2

大多数其他答案都集中在常数因子优化上，但也可以渐近地做得更好。看看你的算法：它是 O(N^2)。这似乎是一个可以比这更快解决的问题！

考虑Knuth Morris Pratt。它跟踪我们迄今为止匹配的最大子字符串数量。这意味着它知道有多少 S1 在 S2 结束时匹配，这就是我们正在寻找的值！只需修改算法以继续而不是在早期匹配子字符串时返回，并让它返回匹配的数量而不是最后的 0。

这给了你一个 O(n) 算法。不错！

    int OverlappedStringLength(string s1, string s2) {
        //Trim s1 so it isn't longer than s2
        if (s1.Length > s2.Length) s1 = s1.Substring(s1.Length - s2.Length);

        int[] T = ComputeBackTrackTable(s2); //O(n)

        int m = 0;
        int i = 0;
        while (m + i < s1.Length) {
            if (s2[i] == s1[m + i]) {
                i += 1;
                //<-- removed the return case here, because |s1| <= |s2|
            } else {
                m += i - T[i];
                if (i > 0) i = T[i];
            }
        }

        return i; //<-- changed the return here to return characters matched
    }

    int[] ComputeBackTrackTable(string s) {
        var T = new int[s.Length];
        int cnd = 0;
        T[0] = -1;
        T[1] = 0;
        int pos = 2;
        while (pos < s.Length) {
            if (s[pos - 1] == s[cnd]) {
                T[pos] = cnd + 1;
                pos += 1;
                cnd += 1;
            } else if (cnd > 0) {
                cnd = T[cnd];
            } else {
                T[pos] = 0;
                pos += 1;
            }
        }

        return T;
    }

OverlappedStringLength("abcdef", "defghl") 返回 3

Answer 3

这是一个 perl -pseudo oneliner：

$_ = s1.s2;

s/([\S]+)\1/\1/;

perl 正则表达式非常有效，您可以查看它们使用的算法，但它们肯定实现了某种类型的 FSM 等，因此您会得到非常好的 O(..) 结果。

Answer 4

这个问题似乎是最长公共子序列问题的变体，可以通过动态规划来解决。

http://www.algorithmist.com/index.php/Longest_Common_Subsequence

Answer 5

我正在努力使这个 C# 尽可能易于阅读。

    public static string Concatenate(string s1, string s2)
    {
        if (string.IsNullOrEmpty(s1)) return s2;
        if (string.IsNullOrEmpty(s2)) return s1;
        if (s1.Contains(s2)) return s1;
        if (s2.Contains(s1)) return s2;

        char endChar = s1.ToCharArray().Last();
        char startChar = s2.ToCharArray().First();

        int s1FirstIndexOfStartChar = s1.IndexOf(startChar);
        int overlapLength = s1.Length - s1FirstIndexOfStartChar;

        while (overlapLength >= 0 && s1FirstIndexOfStartChar >=0)
        {
            if (CheckOverlap(s1, s2, overlapLength))
            {
                return s1 + s2.Substring(overlapLength);
            }

            s1FirstIndexOfStartChar = 
                s1.IndexOf(startChar, s1FirstIndexOfStartChar);
            overlapLength = s1.Length - s1FirstIndexOfStartChar;

        }

        return s1 + s2;
    }

    private static bool CheckOverlap(string s1, string s2, int overlapLength)
    {
        if (overlapLength <= 0)
            return false;

        if (s1.Substring(s1.Length - overlapLength) == 
            s2.Substring(0, overlapLength))
            return true;

        return false;            
    }

编辑：我看到这与 jerryjvl 的解决方案几乎相同。唯一的区别是这将适用于“abcde”、“d”的情况。

Answer 6

这里有一个 Python 解决方案。它应该更快，因为不需要一直在内存中构建子字符串。这项工作在 _concat 函数中完成，该函数连接两个字符串。 concat 函数是连接任意数量的字符串的助手。

def concat(*args):
    result = ''
    for arg in args:
        result = _concat(result, arg)
    return result

def _concat(a, b):
    la = len(a)
    lb = len(b)
    for i in range(la):
        j = i
        k = 0
        while j < la and k < lb and a[j] == b[k]:
            j += 1
            k += 1
        if j == la:
            n = k
            break
    else:
        n = 0
    return a + b[n:]

if __name__ == '__main__':
    assert concat('a', 'b', 'c') == 'abc'
    assert concat('abcde', 'defgh', 'ghlmn') == 'abcdefghlmn'
    assert concat('abcdede', 'dedefgh', '') == 'abcdedefgh'
    assert concat('abcde', 'd', 'ghlmn') == 'abcdedghlmn'
    assert concat('abcdef', '', 'defghl') == 'abcdefghl'

Answer 7

我认为这会很快：

你有两个字符串，string1 和 string2。通过 string1 向后（从右到左）查看 string2 的第一个字符。一旦你有了那个位置，确定是否有重叠。如果没有，您需要继续搜索。如果有，您需要确定是否有可能进行另一场比赛。

为此，只需探索两个字符串中较短的一个，以重复出现重叠字符。即：如果在string1 中匹配的位置留下了一个短的string1，则从string1 中的新起点重复初始搜索。相反，如果 string2 的不匹配部分较短，则搜索它以查找重叠字符的重复。

根据需要重复。

任务完成！

这在内存分配方面不需要太多（所有搜索都在原地完成，只需要分配结果字符串缓冲区）并且只需要（最多）一次通过重叠的字符串之一。

Answer 8

怎么样（请原谅 C#）：

public static string OverlapConcat(string s1, string s2)
{
    // Handle nulls... never return a null
    if (string.IsNullOrEmpty(s1))
    {
        if (string.IsNullOrEmpty(s2))
            return string.Empty;
        else
            return s2;
    }
    if (string.IsNullOrEmpty(s2))
        return s1;

    // Checks above guarantee both strings have at least one character
    int len1 = s1.Length - 1;
    char last1 = s1[len1];
    char first2 = s2[0];

    // Find the first potential match, bounded by the length of s1
    int indexOfLast2 = s2.LastIndexOf(last1, Math.Min(len1, s2.Length - 1));
    while (indexOfLast2 != -1)
    {
        if (s1[len1 - indexOfLast2] == first2)
        {
            // After the quick check, do a full check
            int ix = indexOfLast2;
            while ((ix != -1) && (s1[len1 - indexOfLast2 + ix] == s2[ix]))
                ix--;
            if (ix == -1)
                return s1 + s2.Substring(indexOfLast2 + 1);
        }

        // Search for the next possible match
        indexOfLast2 = s2.LastIndexOf(last1, indexOfLast2 - 1);
    }

    // No match found, so concatenate the full strings
    return s1 + s2;
}

在确定需要复制的内容之前，此实现不会复制任何字符串（部分或其他），这对性能有很大帮助。

此外，匹配检查首先测试潜在匹配区域的极端值（2 个单个字符），这在普通英文文本中应该很有可能避免检查任何其他字符是否不匹配。

只有当它建立了最长的匹配，或者根本不可能匹配时，才会连接两个字符串。我在这里使用了简单的“+”，因为我认为算法其余部分的优化已经消除了您原来的大部分低效率。试一试，让我知道它是否足以满足您的目的。

Answer 9

或者你可以在 mysql 中使用以下存储函数：

DELIMITER //

DROP FUNCTION IF EXISTS concat_with_overlap //

CREATE FUNCTION concat_with_overlap(a VARCHAR(100), b VARCHAR(100))
  RETURNS VARCHAR(200) DETERMINISTIC
BEGIN 
  DECLARE i INT;
  DECLARE al INT;
  DECLARE bl INT;
  SET al = LENGTH(a);
  SET bl = LENGTH(a);
  IF al=0 THEN 
    RETURN b;
  END IF;
  IF bl=0 THEN 
    RETURN a;
  END IF;
  IF al < bl THEN
     SET i = al;
  ELSE
     SET i = bl;
  END IF;

  search: WHILE i > 0 DO
     IF RIGHT(a,i) = LEFT(b,i) THEN
    RETURN CONCAT(a, SUBSTR(b,i+1));
     END IF;
     SET i = i - 1;
  END WHILE search;

  RETURN CONCAT(a,b);
END//

我用你的测试数据试了一下：

mysql> select a,b,c,
    -> concat_with_overlap( concat_with_overlap( a, b ), c ) as result 
    -> from testing //
+-------------+---------+--------+-------------+
| a           | b       | c      | result      |
+-------------+---------+--------+-------------+
| a           | b       | c      | abc         |
| abcde       | defgh   | ghlmn  | abcdefghlmn |
| abcdede     | dedefgh |        | abcdedefgh  |
| abcde       | d       | ghlmn  | abcdedghlmn |
| abcdef      |         | defghl | abcdefghl   |
| abXabXabXac | XabXac  |        | abXabXabXac |
+-------------+---------+--------+-------------+
6 rows in set (0.00 sec)

Answer 10

您可以使用 DFA。例如，字符串XYZ 应该被正则表达式^((A)?B)?C 读取。该正则表达式将匹配与XYZ 字符串的后缀匹配的最长前缀。使用这样的正则表达式，您既可以匹配并获得匹配结果，也可以生成 DFA，您可以在其上使用状态指示“cut”的正确位置。

在 Scala 中，第一个实现——直接使用正则表达式——可能是这样的：

def toRegex(s1: String) = "^" + s1.map(_.toString).reduceLeft((a, b) => "("+a+")?"+b) r
def concatWithoutMatch(s1 : String, s2: String) = {
  val regex = toRegex(s1)
  val prefix = regex findFirstIn s2 getOrElse ""
  s1 + s2.drop(prefix length)
}

例如：

scala> concatWithoutMatch("abXabXabXac", "XabXacd")
res9: java.lang.String = abXabXabXacd

scala> concatWithoutMatch("abc", "def")
res10: java.lang.String = abcdef

scala> concatWithoutMatch(concatWithoutMatch("abcde", "defgh"), "ghlmn")
res11: java.lang.String = abcdefghlmn

Answer 11

如果你在数据库之外做，试试 perl：

sub concat {
  my($x,$y) = @_;

  return $x if $y eq '';
  return $y if $x eq '';

  my($i) = length($x) < length($y) ?  length($x) : length($y);
  while($i > 0) {
      if( substr($x,-$i) eq substr($y,0,$i) )  {
          return $x . substr($y,$i);
      }
      $i--;
  }
  return $x . $y;
}

这和你的算法完全一样，如果 java 或 perl 更快，我只是好奇 ;-)

Answer 12

为什么不做这样的事情。 首先获取三列中的第一个字符或单词（将表示重叠）。

然后，开始将第一个字符串添加到字符串缓冲区，一次一个字符。

每次查看是否到达与第二或第三字符串重叠的部分。

如果是，则开始连接包含第一个字符串中的内容的字符串。

完成开始后，如果没有重叠，则从第二个字符串开始，然后是第三个字符串。

因此，在问题的第二个示例中，我将 d 和 g 保留在两个变量中。

然后，当我添加第一个字符串时 abc 来自第一个字符串，然后我看到 d 也在第二个字符串中，所以我转向从第二个字符串添加 def 是从字符串 2 添加的，然后我继续并以字符串 3 结束。

如果您在数据库中执行此操作，为什么不使用存储过程来执行此操作？