Day09｜字符串02:28. 实现 strStr()、459.重复的子字符串、字符串总结、双指针回顾

QHG7C0

已于 2023-07-21 09:32:21 修改

阅读量69

点赞数

分类专栏：数据结构与算法（一刷）文章标签：数据结构

于 2023-07-20 16:52:31 首次发布

本文链接：https://blog.csdn.net/weixin_43303286/article/details/131834735

版权

数据结构与算法（一刷）专栏收录该内容

60 篇文章 3 订阅

订阅专栏

28.实现strStr()

leetcode链接:力扣题目链接(opens new window

视频链接：

给你两个字符串 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 。

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

这题就是大名鼎鼎的KMP算法的应用。之前一刷是理解了，但是二刷乍一看还是一脸蒙，决定再重新从头到尾捋一下。

最先想到的是暴力匹配算法，用i和j分别遍历pat和txt串：

// 暴力匹配（伪码）
int search(String pat, String txt) {
    int M = pat.length;
    int N = txt.length;
    for (int i = 0; i <= N - M; i++) {
        int j;
        for (j = 0; j < M; j++) {
            if (pat[j] != txt[i+j])
                break;
        }
        // pat 全都匹配了
        if (j == M) return i;
    }
    // txt 中不存在 pat 子串
    return -1;
}

对于暴力算法，如果出现不匹配字符，同时回退txt和pat的指针，嵌套 for 循环，时间复杂度 O(MN)，空间复杂度O(1)。最主要的问题是，如果字符串中重复的字符比较多，该算法就显得很蠢。labuladong的博客
于是可以使用数组将pat串的特征储存起来，使不符合条件回退时不用从头再来而是会退到恰当的区域。这就是KMP算法，主要分为两步，构造状态数组next以及匹配。

匹配

labuladong哥将字符串匹配看作一个动态规划问题，dp数组可定义为：[动态规划之 KMP 算法详解]:(https://mp.weixin.qq.com/s/r9pbkMyFyMAvmkf4QnL-1g)

dp[j][c] = next
0 <= j < M，代表当前的状态
0 <= c < 256，代表遇到的字符（ASCII 码）
0 <= next <= M，代表下一个状态

dp[4]['A'] = 3 表示：
当前是状态 4，如果遇到字符 A，
pat 应该转移到状态 3

dp[1]['B'] = 2 表示：
当前是状态 1，如果遇到字符 B，
pat 应该转移到状态 2

这样匹配算法就可以写为：

public int search(String txt) {
    int M = pat.length();
    int N = txt.length();
    // pat 的初始态为 0
    int j = 0;
    for (int i = 0; i < N; i++) {
        // 当前是状态 j，遇到字符 txt[i]，
        // pat 应该转移到哪个状态？
        j = dp[j][txt.charAt(i)];
        // 如果达到终止态，返回匹配开头的索引
        if (j == M) return i - M + 1;
    }
    // 没到达终止态，匹配失败
    return -1;
}

时间复杂度O(N)

创建dp数组

创建dp数组的过程只和pat串有关，pat串定好数组就定了，空间复杂度O(M）。关键在于如何构建dp数组。

构建dp数组的框架：

for 0 <= j < M: # 状态
    for 0 <= c < 256: # 字符
        dp[j][c] = next

其中题目提到只包含小写字母，那么可把c定为26。

关键的是查找next状态，可讲next分为两种状态：

状态推进：如果遇到的字符c和pat[j]匹配的话，状态就应该向前推进一个，也就是说next = j + 1

状态重启：c和pat[j]不匹配的话，需要回退，回退到哪里？影子状态

所谓影子状态，就是和当前状态具有相同的前缀。比如下面这种情况：

当前状态j = 4，其影子状态为X = 2，它们都有相同的前缀 “AB”。因为状态X和状态j存在相同的前缀，所以当状态j准备进行状态重启的时候（遇到的字符c和pat[j]不匹配），可以通过X的状态转移图来获得最近的重启位置。

比如说刚才的情况，如果状态j遇到一个字符 “A”，应该转移到哪里呢？首先状态 4 只有遇到 “C” 才能推进状态，遇到 “A” 显然只能进行状态重启。状态j会把这个字符委托给状态X处理，也就是dp[j]['A'] = dp[X]['A']：

这样，我们就可以细化一下刚才的框架代码：

int X # 影子状态
for 0 <= j < M:
    for 0 <= c < 256:
        if c == pat[j]:
            # 状态推进
            dp[j][c] = j + 1
        else: 
            # 状态重启
            # 委托 X 计算重启位置
            dp[j][c] = dp[X][c]

完整代码（JAVA版本）

public class KMP {
    private int[][] dp;
    private String pat;

    public KMP(String pat) {
        this.pat = pat;
        int M = pat.length();
        // dp[状态][字符] = 下个状态
        dp = new int[M][256];
        // base case
        dp[0][pat.charAt(0)] = 1;
        // 影子状态 X 初始为 0
        int X = 0;
        // 构建状态转移图（稍改的更紧凑了）
        for (int j = 1; j < M; j++) {
            for (int c = 0; c < 256; c++)
                dp[j][c] = dp[X][c];
            dp[j][pat.charAt(j)] = j + 1;
            // 更新影子状态
            X = dp[X][pat.charAt(j)];
        }
    }

    public int search(String txt) {
        int M = pat.length();
        int N = txt.length();
        // pat 的初始态为 0
        int j = 0;
        for (int i = 0; i < N; i++) {
            // 计算 pat 的下一个状态
            j = dp[j][txt.charAt(i)];
            // 到达终止态，返回结果
            if (j == M) return i - M + 1;
        }
        // 没到达终止态，匹配失败
        return -1;
    }
}

自己写的C++版本：

class Solution {
public:
    vector<vector<int>> getNext(string needle){
        int n = needle.size();
        vector<vector<int>> dp (n, vector<int>(256,0));
        // auto dp = new int[n][256];
        dp[0][needle[0]] = 1;
        //影子状态X
        int x = 0;
        for(int j = 1;j < n; j++){
            for(int c = 0;c < 256;c++){
                dp[j][c] = dp[x][c];
            }
            dp[j][needle[j]] = j + 1;
            x = dp[x][needle[j]];
        }
        return dp;
    }
    int strStr(string haystack, string needle) {
        int m = needle.size();
        int n = haystack.size();
        auto dp = getNext(needle);
        int j = 0;
        for(int i = 0; i < n; i++){
            j = dp[j][haystack[i]];
            if(j == m){
                return i - m + 1;
            }
        }
        return -1;
    }
};

459.重复的子字符串

今天了解一个KMP就很头痛了，先跳过这一题了2333。

字符串总结

与C相比，C++把字符串包装成了String类，加了size()，不用’\0’判断末尾了，并且重载了运算符+。与char数组相比更方便。

其他的就是注意库函数的使用。

双指针总结

双指针有很多，滑动窗口，从前往后和从后往前，二分等等，在数组、链表和字符串上都有用，也做了一些类型的题目，希望下次遇到类似的可以直接想到思路。

QHG7C0

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day09｜字符串02:28. 实现 strStr()、459.重复的子字符串、字符串总结、双指针回顾

与C相比，C++把字符串包装成了String类，加了size()，不用’\0’判断末尾了，并且重载了运算符+。与char数组相比更方便。其他的就是注意库函数的使用。双指针有很多，滑动窗口，从前往后和从后往前，二分等等，在数组、链表和字符串上都有用，也做了一些类型的题目，希望下次遇到类似的可以直接想到思路。
复制链接

扫一扫