LeetCode30-与所有单词相关联的字串

https://zhuanlan.zhihu.com/p/51296482 

 

这是我上午花了好长好长好处时间写的一篇随笔，该说的话都在这里面了，我不会赤裸裸的跟大家说：我想推荐大家去看看的。啊哈哈哈哈。

---

30-与所有单词相关联的字串

给定一个字符串 s 和一些长度相同的单词 words。在 s 中找出可以恰好串联 words 中所有单词的子串的起始位置。

注意子串要与 words 中的单词完全匹配，中间不能有其他字符，但不需要考虑 words 中单词串联的顺序。

示例 1:

[0,9]

示例 2:

[]

这一题我刚开始做的时候是按照暴力法来做的，没办法啊，菜鸟的第一想法就是最简单最容易理解的暴力搜索法（其实是最容易想到的，其他更简单的方法要是能想到，谁还用暴力法啊）

思路：

1）可以先将目标words数组内的字符串元素自由组合，python中可以使用itertools.permutations() 这个函数极为方便，能够快速的生成给定数组内元素的排列列表，并且列表内元素不允许重复出现，就跟数学中的排列是一样的。

2）得到目标words数组内的排列列表后，就可以依次遍历字符串 s了，只要字符串中有与words数组内的排列列表相等的字串，把对应的下标值记录下来返回就可。

代码如下：

from itertools import permutations


class Solution:
    # 可以先将word数组内字符串自由组合，然后用s.index()函数即可得到答案
    # 要考虑字符串s和words中出现的重复字符
    # 此种解法超出时间限制
    def findSubstring(self, s, words):
        """
        :type s: str
        :type words: List[str]
        :rtype: List[int]
        """
        if s is None or len(words) == 0 or len(s) < len(words[0] * len(words)):
            return []
        if s is None or len(words) == 0 or len(s) < len(words[0] * len(words)):
            return []
        # 采用itertools.permutations()函数将word数组内字符串自由组合,如[('foo', 'bar'), ('bar', 'foo')]
        words_permutations = permutations(words)
        words_list = set([])
        # 然后依次遍历words_permutations组合，找到与字符串s对应位置相等的字符串
        # 完全的暴力法
        for index in words_permutations:
            # 将words_permutations内某一种组合情况合并为一个字符串（例如('foo', 'bar')合并为"foobar"），供后面使用
            index = ''.join(list(index))
            if index in s:
                start = s.index(index)
                words_list.add(start)
                for i in range(start, len(s)-len(index)+1):
                    if s[i:i+len(index)] == index:
                        words_list.add(i)
        return list(words_list)


if __name__ == "__main__":
    s = "barfoothefoobarman"
    words = ["foo","bar"]
    result = Solution().findSubstring(s, words)
    print(result)

是不是感觉很简单，但是要泼一盆冷水的是：最后超出时间限制了，真的是要捶人啊！这是要逼我祭出大招啊——去找度娘，度娘始终是不会让我失望的，终于是找到了一种更为巧妙的方法。上面的暴力法之所以花费时间较多，是因为我们考虑到了所有的排列情况，这才会时间爆炸，如果我们不需要去考虑排列情况，只需要单纯的比较words 数组对应的字符串与字符串 s 的关系，那时间岂不是能省去一大截。答案是：那踏马肯定是的啊，我都说到这儿了，说的话肯定是对的啊，哈哈哈哈哈。那现在的关键就是如何省略排列情况这一步了。

思路：

1）每次从s中切对应长度（words中各个元素的长度之和）的一条子串，
2）然后再把这条子串按words中单个单词的长度再切成更小子串构成一个list, 把words和list排序后的结果比对一下，看是否完全相同，如果是则我们返回对应的起始点。否则继续。

代码如下：

class Solution:
    # 每次从s中切对应长度（words中各个元素的长度之和）的一条子串，
    # 然后再把这条子串按words中单个单词的长度再切成更小子串构成一个list, 把words和list排序后的结果比对一下，
    # 看是否完全相同，如果是则我们返回对应的起始点。否则继续。
    def findSubstring(self, s, words):
        """
        :type s: str
        :type words: List[str]
        :rtype: List[int]
        """

        if s is None or len(words) == 0:
            return []
        word_length = len(words[0])
        words_length = word_length * len(words)
        words.sort()
        word_list = []
        for index in range(len(s) - words_length + 1):
            sub_s = [s[index+i*word_length: index+(i+1)*word_length] for i in range(len(words))]
            sub_s.sort()
            if words == sub_s:
                word_list.append(index)
        return word_list


if __name__ == "__main__":
    s = "aa"
    words = ["aa", "af"]
    result = Solution().findSubstring(s, words)
    print(result)

是不是觉得so so so easy?别急，我还有更好的...好个屁了，写到这儿已经虐的差不多了，人懒写不动了，各位读者要是有更好的想法也可以积极分享哈！