查找由列表中单词构成的子串的起始索引

在实际应用中，我们常常需要在一个长字符串中查找由列表中一些单词构成的子串出现的起始索引。这个问题常见于文本检索、自然语言处理等领域。本文将介绍如何用Python实现这一功能。

问题描述

给定一个字符串S和一个由n个单词组成的列表L，找出S中匹配L中所有单词的子串出现的起始索引。如果匹配的子串有多个，返回第一个匹配的子串的位置。如果不存在这样的子串，返回-1。

解决方案

暴力法

最朴素的思路是从S的每个字符开始，逐个尝试匹配L中的所有单词。具体来说，我们可以枚举S的起始位置i，然后依次检查S[i:i+k]是否等于L中的某个单词，其中k为单词长度。该方法的时间复杂度为O(nmk)，其中n为列表L中单词个数，m为平均单词长度，k为S的长度。此方法速度较慢，并且对于较长的S可能会超时。因此，我们需要寻求更高效的算法。

哈希表法

利用哈希表可以将查找子串的时间复杂度降至O(nk)。具体来说，我们可以将L中每个单词的哈希值预处理出来，并存储在一个哈希表中。然后，枚举S的起始位置i，计算S[i:i+k]的哈希值，然后在哈希表中查找该哈希值对应的单词是否存在。如果存在，则依次检查S[i:i+k]是否等于该单词，如果全部匹配成功，则返回该子串的起始位置i。这个方法需要额外的空间存储哈希表，但能够极大地提高查找效率。

双指针法

利用双指针也可以实现O(nk)的查找子串的时间复杂度。具体来说，我们可以设定两个指针p和q，分别指向S的起始位置。然后，我们移动指针q，每次将S[q:q+k]加入一个哈希表中。如果发现S[q:q+k]不在L中，我们将指针p右移一位，并删除S[p:p+k]在哈希表中的记录，直到S[q:q+k]在L中或者q达到S的末尾位置。如果找到了匹配的子串，返回p，否则返回-1。该方法的时间复杂度为O(kn)，空间复杂度为O(n)。

代码实现

我们将给出Python实现哈希表法的代码，读者可以自行实现双指针法的代码。在这里，我们假设S和L都是仅包含小写字母的字符串。

def findSubstring(s: str, words: List[str]) -> List[int]:
    if not s or not words:
        return []
    word_len = len(words[0])
    word_cnt = len(words)
    str_len = len(s)
    words_dict = {}
    for w in words:
        words_dict[w] = words_dict.get(w, 0) + 1
    res = []
    for i in range(word_len):
        left, right = i, i
        cur_dict = {}
        while right + word_len <= str_len:
            cur_word = s[right:right+word_len]
            right += word_len
            if cur_word not in words_dict:
                left = right
                cur_dict = {}
            else:
                cur_dict[cur_word] = cur_dict.get(cur_word, 0) + 1
                while cur_dict[cur_word] > words_dict[cur_word]:
                    sub_word = s[left:left+word_len]
                    left += word_len
                    cur_dict[sub_word] -= 1
                if right - left == word_len * word_cnt:
                    res.append(left)
    return res

总结

本文介绍了三种查找由列表中单词构成的子串的起始索引的方法，分别是暴力法、哈希表法和双指针法。在实际应用中，我们需要根据具体问题的特点选择最适合的算法。