代码随想录算法训练营第九天|151. 反转字符串中的单词，55.右旋转字符串，28. 找出字符串中第一个匹配项的下标，459. 重复的子字符串

151. 反转字符串中的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：
输入：s = “the sky is blue”
输出：“blue is sky the”

示例 2：
输入：s = " hello world "
输出：“world hello”
解释：反转后的字符串中不能存在前导空格和尾随空格。

示例 3：
输入：s = “a good example”
输出：“example good a”
解释：如果两个单词间有多余的空格，反*转后的字符串需要将单词间的空格减少到仅有一个。

简单方法，去除多余空格后，存储单词列表，然后反转。

class Solution:
    def reverseWords(self, s: str) -> str:
        res = s.split()
        res.reverse()
        return ' '.join(res)

参考昨天的思路，反转也就是替换

class Solution:
    def reverseWords(self, s: str) -> str:
        # 将字符串拆分为单词，即转换成列表类型
        words = s.split()

        # 反转单词
        left, right = 0, len(words) - 1
        while left < right:
            words[left], words[right] = words[right], words[left]
            left += 1
            right -= 1

        # 将列表转换成字符串
        return " ".join(words)

扩展思路，不使用辅助空间，空间复杂度$O(1)$。解题思路如下：

• 移除多余空格
• 将整个字符串反转
• 将每个单词反转

举个例子，源字符串为："the sky is blue "

• 移除多余空格 : “the sky is blue”
• 字符串反转：“eulb si yks eht”
• 单词反转：“blue is sky the”
  python字符不可变，反转单词的时候，需要将其转换成列表，然后通过join函数再将其转换成列表，所以空间复杂度不是$O(1)$。

class Solution:
    def reverseWords(self, s: str) -> str:
        # 删除前后空白
        s = s.strip()
        # 反转整个字符串
        s = s[::-1]
        # 将字符串拆分为单词，并反转每个单词
        s = ' '.join(word[::-1] for word in s.split())
        return s

55.右旋转字符串

字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。给定一个字符串 s 和一个正整数 k，请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。

例如，对于输入字符串 “abcdefg” 和整数 2，函数应该将其转换为 “fgabcde”。

示例
输入：
2
abcdefg
输出：fgabcde

这类旋转题目通常想法是切分左右旋转然后整体旋转，这题就适用该方法。

n = int(input())
s = input()
s1=s[:len(s)-n]
s2=s[:-n]
print([s1[::-1]+s2[::-1]][::-1])

参考

#获取输入的数字k和字符串
k = int(input())
s = input()

#通过切片反转第一段和第二段字符串
#注意：python中字符串是不可变的，所以也需要额外空间
s = s[len(s)-k:] + s[:len(s)-k]
print(s)

k = int(input())
s = input()

print(s[-k:] + s[:-k])

28. 找出字符串中第一个匹配项的下标

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

示例 1：
输入：haystack = “sadbutsad”, needle = “sad”
输出：0
解释：“sad” 在下标 0 和 6 处匹配。第一个匹配项的下标是 0 ，所以返回 0 。

示例 2：
输入：haystack = “leetcode”, needle = “leeto”
输出：-1
解释：“leeto” 没有在 “leetcode” 中出现，所以返回 -1

采用滚动窗口方式，注意窗口回滚条件，该方法思考后和暴力法区别不大，时间都是$O(n^2)$。

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        n1 = len(haystack)
        n2 = len(needle)
        t = 0; i = 0
        while i < n1:
            if t == n2:
                return i-n2
            if haystack[i] == needle[t]:
                t += 1
                i += 1
            else:
                i = i-t+1#不满足时，需要滚回重新判别
                t = 0
                
        return -1 if t < n2 else i-n2

暴力法

class Solution(object):
    def strStr(self, haystack, needle):
        """
        :type haystack: str
        :type needle: str
        :rtype: int
        """
        m, n = len(haystack), len(needle)
        for i in range(m):
            if haystack[i:i+n] == needle:
                return i
        return -1   

KMP经典题目，其思想就是:当出现字符串不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息避免从头再去做匹配，待补充。

459. 重复的子字符串

给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。

示例 1:
输入: s = “abab”
输出: true
解释: 可由子串 “ab” 重复两次构成。

示例 2:
输入: s = “aba”
输出: false

示例 3:
输入: s = “abcabcabcabc”
输出: true
解释: 可由子串 “abc” 重复四次构成。 (或子串 “abcabc” 重复两次构成。)

观察next数组，发现若字符串可由重复子串构成，最长相等前后缀不包含的子串长度是字符串s的最小重复子串，参考上面KMP算法

class Solution:
    def getNext(self, next: List[int], s: str) -> None:
        j = 0
        next[0] = 0
        for i in range(1, len(s)):
            while j > 0 and s[i] != s[j]:
                j = next[j - 1]
            if s[i] == s[j]:
                j += 1
            next[i] = j
            
    def repeatedSubstringPattern(self, s: str) -> bool:
        if len(s) == 0:
            return False
        next = [0] * len(s)
        self.getNext(next, s)
        if next[len(s)-1] == 0:
            return False
        res = len(s)-next[len(s)-1]
        n1 = len(s)//res
        #return next
        return n1*s[:res]==s

参考官方方法，如果一个字符串s是由重复子串组成，那么最长相等前后缀不包含的子串一定是字符串s的最小重复子串，此为充分必要条件，证明省略。上面代码可以进一步优化，只需要判断最长相等前后缀不包含的子串长度能否被该字符串长度整除。

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:  
        if len(s) == 0:
            return False
        nxt = [0] * len(s)
        self.getNext(nxt, s)
        if nxt[-1] != 0 and len(s) % (len(s) - nxt[-1]) == 0:
            return True
        return False
    
    def getNext(self, nxt, s):
        nxt[0] = 0
        j = 0
        for i in range(1, len(s)):
            while j > 0 and s[i] != s[j]:
                j = nxt[j - 1]
            if s[i] == s[j]:
                j += 1
            nxt[i] = j
        return nxt

移动匹配法，判断字符串s是否由重复子串组成，只要两个$s$拼接在一起，里面还出现一个s的话，就说明是由重复子串组成。这种解法有一个问题，最终还是要判断 一个字符串$（s+s）$是否出现过 $s$ 的过程，用contains，find 之类的库函数，这些函数的时间复杂度（暴力解法是$m\ast n$，一般库函数实现为 $O(m+n)$，上一题实现的方法。

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        n = len(s)
        if n <= 1:
            return False
        ss = s[1:] + s[:-1] 
        print(ss.find(s))              
        return ss.find(s) != -1

这道题偏向总结规律，主要还是KMP方法练习。