力扣刷题——字符串篇KMP算法（ 28. 实现 strStr()，459.重复的子字符串）

最新推荐文章于 2023-10-18 17:16:22 发布

hhhhyyc

最新推荐文章于 2023-10-18 17:16:22 发布

阅读量397

点赞数

分类专栏： leetcode 文章标签： leetcode 算法字符串

本文链接：https://blog.csdn.net/m0_51011333/article/details/121949700

版权

leetcode 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

28. 实现 strStr()

题目

力扣题目链接

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

示例 1: 输入: haystack = "hello", needle = "ll" 输出: 2

示例 2: 输入: haystack = "aaaaa", needle = "bba" 输出: -1

说明: 当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

思路

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

KMP算法流程

下面先直接给出KMP的算法流程（如果感到一点点不适，没关系，坚持下，稍后会有具体步骤及解释，越往后看越会柳暗花明☺）：

假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置:

如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++，继续匹配下一个字符；
如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]。此举意味着失配时，模式串P相对于文本串S向右移动了j - next [j] 位。

换言之，当匹配失败时，模式串向右移动的位数为：失配字符所在位置 - 失配字符对应的next 值，即移动的实际位数为：j - next[j]，且此值大于等于1。
很快，你也会意识到next 数组各值的含义：代表当前字符之前的字符串中，有多大长度的相同前缀后缀。例如如果next [j] = k，代表j 之前的字符串中有最大长度为k 的相同前缀后缀。

此也意味着在某个字符失配时，该字符对应的next 值会告诉你下一步匹配中，模式串应该跳到哪个位置（跳到next [j] 的位置）。如果next [j] 等于0或-1，则跳到模式串的开头字符，若next [j] = k 且 k > 0，代表下次匹配跳到j 之前的某个字符，而不是跳到开头，且具体跳过了k 个字符。

next数组

3.2 步骤
①寻找前缀后缀最长公共元素长度
对于P = p0 p1 …pj-1 pj，寻找模式串P中长度最大且相等的前缀和后缀。如果存在p0 p1 …pk-1 pk = pj- k pj-k+1…pj-1 pj，那么在包含pj的模式串中有最大长度为k+1的相同前缀后缀。举个例子，如果给定的模式串为“abab”，那么它的各个子串的前缀后缀的公共元素的最大长度如下表格所示：

比如对于字符串aba来说，它有长度为1的相同前缀后缀a；而对于字符串abab来说，它有长度为2的相同前缀后缀ab（相同前缀后缀的长度为k + 1，k + 1 = 2）。

②求next数组
next 数组考虑的是除当前字符外的最长相同前缀后缀，所以通过第①步骤求得各个前缀后缀的公共元素的最大长度后，只要稍作变形即可：将第①步骤中求得的值整体右移一位，然后初值赋为-1，如下表格所示：

比如对于aba来说，第3个字符a之前的字符串ab中有长度为0的相同前缀后缀，所以第3个字符a对应的next值为0；而对于abab来说，第4个字符b之前的字符串aba中有长度为1的相同前缀后缀a，所以第4个字符b对应的next值为1（相同前缀后缀的长度为k，k = 1）。

③根据next数组进行匹配
匹配失配，j = next [j]，模式串向右移动的位数为：j - next[j]。换言之，当模式串的后缀pj-k pj-k+1, …, pj-1 跟文本串si-k si-k+1, …, si-1匹配成功，但pj 跟si匹配失败时，因为next[j] = k，相当于在不包含pj的模式串中有最大长度为k 的相同前缀后缀，即p0 p1 …pk-1 = pj-k pj-k+1…pj-1，故令j = next[j]，从而让模式串右移j - next[j] 位，使得模式串的前缀p0 p1, …, pk-1对应着文本串 si-k si-k+1, …, si-1，而后让pk 跟si 继续匹配。如下图所示：

求next数组代码

void getnext(string s,int *next)
{
    next[0]=-1;
    int j=-1;
    for(int i=0;i<s.s.size()-1;i++)
    {
        if(j==-1||s[i]==s[j])
        {
           i++;
            j++;
            if(s[i]==s[j])
                next[i]=j;
            else 
            	next[i]=next[j];
		}
        else 
            j=next[j];
            
    }

    
}

整体代码如下

class Solution {
public:
        void getnext(string s,int *next)
        {
            int j=-1;
            next[0]=-1;
            for(int i=0;i<s.size()-1;)
            {
                if(j==-1||s[i]==s[j])
                {
                    i++;
                    j++;
                    if(s[i]==s[j])
                        next[i]=next[j];
                    else 
                        next[i]=j;
                }
                else 
                    j=next[j];

            }

        }
    int strStr(string haystack, string needle) {
        if(needle.size()==0) return 0;
        int *next=new int[needle.size()];
        getnext(needle,next);
        int i=0;
        int j=0;
        int length_1 = haystack.size();
        int length_2 = needle.size();
        /*
        while((i<haystack.size())&&(j<needle.size()))//会报错
        因为计算给定字符串的（unsigned int型）长度，就是这一点！！！
        它的返回值是一个 unsigned int 类型。j<strlen(s)在执行时，
        由于两边的类型不一样所以要转换， 无符号比有符度号的内有效值范围大，
        所以将i转换成无符号的数字再比较， 这一转就出问题了，
        有符号的-1转换成无符号成了0xffffffff，这是无符号的最大值，
        所以i<strlen(a)始终为false，所以我写的函数只要当j<0，必定跳出循环。
        在此建议使用strlen函数的值作为条件循环时，应先赋值给int类型，或者使用c++中的string。
        */
        while((i<length_1)&&(j<length_2))
        {
            if(j==-1||haystack[i]==needle[j])
            {
                i++;
                j++;

            }
            else{
                j=next[j];
            }
        }
        if(j==needle.size())
        {
            return i-j;
        }
        return -1;
       


    }
};

459.重复的子字符串

题目

力扣题目链接

给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。

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

示例 2:
输入: “aba”
输出: False

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

思路

暴力解法：

如果一个长度位n的字符串，能被其子串重复（子串长度为s）

那么n必是s的倍数
并且对于任意s[n]==s[n-s]

整体代码如下

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        int n = s.size();
        for (int i = 1; i * 2 <= n; ++i) {
            if (n % i == 0) {
                bool match = true;
                for (int j = i; j < n; ++j) {
                    if (s[j] != s[j - i]) {
                        match = false;
                        break;
                    }
                }
                if (match) {
                    return true;
                }
            }
        }
        return false;
    }
};

KMP求重复子串

因为next数组的求法分为两种：

一种是最长相等前后缀的长度-1，求得next数组
一种是将最长相等前后缀的长度右移一位，next[0]=-1;求得next数组

而使用第一种求法全体-1；

数组长度为：len

最长相等前后缀的长度为：next[len - 1] + 1。

如果len % (len - (next[len - 1] + 1)) == 0 ，则说明 (数组长度-最长相等前后缀的长度) 正好可以被数组的长度整除，说明有该字符串有重复的子字符串。

数组长度减去最长相同前后缀的长度相当于是第一个周期的长度，也就是一个周期的长度，如果这个周期可以被整除，就说明整个数组就是这个周期的循环。

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