题目

门 | GATE-CS-2006 | 第 34 题

给定一个字符串，编写一个程序来确定它是否是由两个子字符串连接而成的。例如，'barfoofoobar' 可以被表示为 'bar'，'foo'，和 'foobar' 的串联。

输入格式

输入字符串由用户指定。

输出格式

程序返回结果为布尔值，表示给定字符串是否由两个子字符串连接所得。

代码示例

下面是一个Python示例代码，该代码接受一个字符串作为输入，并检查该字符串是否可以由两个子串连接而成。

def is_concatenated(s):
    n = len(s)
    for i in range(1, n):
        left, right = s[:i], s[i:]
        if left in right:
            return True
    return False

使用上述代码进行测试：

s = 'barfoofoobar'
if is_concatenated(s):
    print(f"{s} can be represented as a concatenation of two substrings.")
else:
    print(f"{s} cannot be represented as a concatenation of two substrings.")

输出结果为：

'barfoofoobar' can be represented as a concatenation of two substrings.

思路分析

这道题其实可以用暴力的方式实现，具体思路是枚举字符串的某个位置，将字符串分为左右两部分，然后检查左半部分是否是右半部分的子串，若是则说明原来的字符串可以由这两个子串拼接而成。这个思路的时间复杂度是 $O(n^2)$。

如果想要进一步改进时间复杂度，可以使用哈希表。每次枚举一个位置，将字符串分为左右两部分。然后可以使用哈希表来快速查询是否存在一个子串与右半部分相等。具体地，遍历所有的可能右半部分，将其哈希值存入哈希表，然后查询左半部分是否在哈希表中。这里需要注意的是，要避免哈希冲突的问题。另外，字符串的哈希值可以使用 Rolling Hash 算法来求解，同时也可以使用类似于 Rabin-Karp 算法的方法进行优化。这个算法的时间复杂度是 $O(n\log n)$。

关于 Rolling Hash，如果您感兴趣，可以尝试理解下面的代码示例：

_cap = 10**9 + 7
_base = 131

class RollingHash:
    def __init__(self, s):
        n = len(s)
        self.powers = powers = [1] * (n+1)
        self.hash = hash = [0] * (n+1)
        for i in range(1, n+1):
            c = ord(s[i-1]) - ord('a') + 1
            hash[i] = (hash[i-1] * _base + c) % _cap
            powers[i] = (powers[i-1] * _base) % _cap

    def hash_value(self, i, j):
        return (self.hash[j] - self.hash[i-1] * self.powers[j-i+1]) % _cap

def is_concatenated(s):
    n = len(s)
    rh = RollingHash(s)
    h = set([rh.hash_value(1, i) for i in range(2, n)])
    for i in range(1, n):
        left, right = s[:i], s[i:]
        if rh.hash_value(1, i) in h and rh.hash_value(i+1, n) in h:
            return True
    return False

上面的代码提供了一个求 Rolling Hash 的示例。这个算法的思路是，对于一个字符串 $s$，其哈希值可以设计成：

$$ h(s) = \sum_{i=1}^n a_i \cdot b^i $$

其中 $a_i$ 表示字符串 $s$ 的第 $i$ 个字符对应的权值，$b$ 是一个大于 $n$ 的正整数。这里 $b$ 的取值可以是一个质数，例如上面的代码中取的是 $b=131$。为了避免哈希冲突，通常也需要对哈希值取模，例如上面的代码中取的是 $10^9+7$。然后，Rolling Hash 的关键就是如何在遍历字符串时快速计算出子串的哈希值。具体地，假设当前已经遍历到字符串 $s$ 的第 $i$ 个位置（从 $1$ 开始），并且已经计算出了 $s[1:i]$ 的哈希值 $H[1:i]$，那么新的哈希值可以通过如下方式计算：

$$ H[1:i+1] = a_{i+1} + b \cdot H[1:i] $$

这个式子的意思是，在计算哈希值时，增加新的字符 $a_{i+1}$，也就是将 $s[i+1]$ 这个字符的权值加入到哈希值中，同时左移以前的哈希值 $H[1:i]$，也就是将原来的哈希值乘以 $b$，以便下一个字符加入到哈希值的末尾。这里还需要用一个数组 $powers$ 来记录 $b^i$ 的值，以便快速计算子串的哈希值。最终，整个字符串的哈希值就是 $H[1:n]$。