Leetcode的AC指南 —— 字符串 :459. 重复的子字符串

摘要:
**Leetcode的AC指南 —— 字符串 :459. 重复的子字符串 **。题目介绍:给定一个非空的字符串 s ,检查是否可以通过由它的一个子串重复多次构成。

文章目录

  • 一、题目
  • 二、解析 (go语言版)
    • 1、KMP的next数组
    • 2、移动匹配(KMP)
  • 三、其他语言版本
    • Java
    • C++
    • Python

一、题目


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

力扣题目链接

示例 1:

输入: s = "abab"
输出: true
解释: 可由子串 "ab" 重复两次构成。

示例 2:

输入: s = "aba"
输出: false

示例 3:

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

提示:
1 <= s.length <= 104
s 由小写英文字母组成

二、解析 (go语言版)


1、KMP的next数组

这里再重新理解下next数组,它表示的是最长相等前后缀长度。在 i 处遇到元素不相等时,通过next[i]的值来下次开始比较的位置。
举例:

下标 0 1 2 3 4 5 6 7 8 9 10 11
字符串 a f b c a f b c a f b T
next数组 0 0 0 0 1 2 3 4 5 6 7 0
  • 当 i=10 ,j = 6时,此时字符相等,则 j++ ,next[10] = j = 7
  • 当 i=11, j = 7时,此时字符不相等,则 j = next[ j - 1 ] = 3
  • 下一次比较从 下标3 和 下标11 开始
    • 因为next数组记录了最长相等前后缀长度,可以发现下标0、1、2等于下标4、5、6,这个信息在next数据已经记录过了,我们可以直接跳过匹配字符串的前缀进行接下来的比较。

关于一个字符串s是否可以由多个子串重复构成,这个可以查看s的前缀表,也就是next数组。

  • s的最长相等前后缀长度 是 next数组的最后一个元素。
  • 观察next数组,数组长度减去最长相同前后缀的长度相当于是第一个周期的长度,也就是一个周期的长度,如果这个周期可以被整除,就说明整个数组就是这个周期的循环

package main

import (
	"fmt"
)

func main() {
	for {

		//var h string
		//fmt.Scanln(&h)

		var n string
		fmt.Scanln(&n)
		fmt.Println(repeatedSubstringPattern(n))

	}

}
func repeatedSubstringPattern(s string) bool {
	n := len(s)
	next := make([]int, n)
	j := 0
	next[0] = 0
	for i := 1; i < n; i++ {
		for j > 0 && s[i] != s[j] {
			j = next[j-1]
		}
		if s[i] == s[j] {
			j++
		}
		next[i] = j
	}
	fmt.Println("next:", next)
	if next[n-1] != 0 && n%(n-next[n-1]) == 0 {
		return true
	}
	return false
}

  • 时间复杂度O(n)
  • 空间复杂度O(n)

2、移动匹配(KMP)

思路:

  • 若字符串s是重复的,则在s+s的拼接处一定还存在一个s。
  • 为了避免搜索出原来的s,去除s+s的首尾字符。
  • 判断一个字符串中是否出现另一个字符串,参考 28.实现strStr

func repeatedSubstringPattern(s string) bool {

	// 在两个s的拼接处,查找s是否出现过
	h := s + s
	h = h[1 : len(h)-1] // 防止找到开头和结尾的s

	// 构造next数组
	next := make([]int, len(s))
	j := 0
	next[0] = 0
	for i := 1; i < len(s); i++ {
		for j > 0 && s[i] != s[j] {
			j = next[j-1]
		}
		if s[i] == s[j] {
			j++
		}
		next[i] = j
	}
	j = 0
	for i := 0; i < len(h); i++ {
		for j > 0 && h[i] != s[j] {
			j = next[j-1]
		}
		if h[i] == s[j] {
			j++
		}
		if j == len(s) {
			return true
		}
	}

	return false
}

三、其他语言版本


Java

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        if (s.equals("")) return false;

        int len = s.length();
        // 原串加个空格(哨兵),使下标从1开始,这样j从0开始,也不用初始化了
        s = " " + s;
        char[] chars = s.toCharArray();
        int[] next = new int[len + 1];

        // 构造 next 数组过程,j从0开始(空格),i从2开始
        for (int i = 2, j = 0; i <= len; i++) {
            // 匹配不成功,j回到前一位置 next 数组所对应的值
            while (j > 0 && chars[i] != chars[j + 1]) j = next[j];
            // 匹配成功,j往后移
            if (chars[i] == chars[j + 1]) j++;
            // 更新 next 数组的值
            next[i] = j;
        }

        // 最后判断是否是重复的子字符串,这里 next[len] 即代表next数组末尾的值
        if (next[len] > 0 && len % (len - next[len]) == 0) {
            return true;
        }
        return false;
    }
}

C++

class Solution {
public:
    void getNext (int* next, const string& s){
        next[0] = 0;
        int j = 0;
        for(int i = 1;i < s.size(); i++){
            while(j > 0 && s[i] != s[j]) {
                j = next[j - 1];
            }
            if(s[i] == s[j]) {
                j++;
            }
            next[i] = j;
        }
    }
    bool repeatedSubstringPattern (string s) {
        if (s.size() == 0) {
            return false;
        }
        int next[s.size()];
        getNext(next, s);
        int len = s.size();
        if (next[len - 1] != 0 && len % (len - (next[len - 1] )) == 0) {
            return true;
        }
        return false;
    }
};

Python

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

你可能感兴趣的:(leetcode的AC指南,leetcode,算法)