Leetcode 刷题笔记(八) —— 字符串篇之 KMP

文章目录

  • 系列文章目录
  • 前言
    • 什么是 KMP 算法?
    • next 数组
  • 题录
    • 28. 实现 strStr()
    • 459. 重复的子字符串

系列文章目录

一、 数组类型解题方法一:二分法
二、数组类型解题方法二:双指针法
三、数组类型解题方法三:滑动窗口
四、数组类型解题方法四:模拟
五、链表篇之链表的基础操作和经典题目
六、哈希表篇之经典题目
七、字符串篇之经典题目
八、字符串篇之 KMP
九、解题方法:双指针
十、栈与队列篇之经典题目
十 一、栈与队列篇之 top-K 问题
更新中 …


前言

刷题路线以及 KMP 详解 :代码随想录

什么是 KMP 算法?

KMP 是以 3 位发明者名字的首字母命名的,常用来字符串匹配上。如:判断 s1 是不是 s2 的子串,KMP 算法将解决此问题的时间复杂度从 O(m*n) 降低到了 O(n)
它的思想是当出现字符串不匹配时,可以记录一部分之前已经匹配的文本内容,利用这些信息避免从头再去做匹配。

如:文本串:aabaabaaf,模式串:aabaaf,判断 aabaaf 是否为 aabaabaaf 的子串
aabaabaaf
aabaaf
当在文本串下标 i = 5 处发现 b 和 f 不匹配时,模式串没有从文本串下标 i = 1 和 i = 2 开始从头比较,
aabaabaaf
. aabaaf
. . aabaaf
而是让下标 i 不回退,改变模式串下次比较的下标,在 aabaaf 的 f处 匹配失败,但是我们发现 f 前边的 aa (. . . aaf 和 开头的 aa. . . .) 相同 而因为已经匹配到 f 说明 f 前的 aabaa(aabaaf) 一定与 文本串(aabaabaaf)的 aabaa 已经完全匹配,那么文本串(aabaabaaf)发生匹配失败的前的 aa 一定在 模式串(aabaaf)的前缀出现。此时就可以直接去比较两个 aa 后边的字符就可以了。
aabaabaaf
. . . aabaaf

next 数组

数组next[i] 保存模式串[0, i] 区间子串的最长相同前后缀的长度,在匹配失败时,用来找到下次应该匹配的位置。最大相等前后缀的长度作为下标刚好是前缀尾部后一个位置,刚好作为匹配失败模式串指针回退的位置。

题录

28. 实现 strStr()

Leetcode 链接
实现 strStr() 函数。

给你两个字符串 haystack 和 needle ,请你在 haystack 字符串中找出 needle 字符串出现的第一个位置(下标从 0 开始)。如果不存在,则返回 -1 。
说明:
当 needle 是空字符串时,我们应当返回什么值呢?这是一个在面试中很好的问题。
对于本题而言,当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。

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

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

示例 3:
输入:haystack = “”, needle = “”
输出:0

题解: 我们称 haystack = “hello”, needle = “ll” 中前者为文本串,后者为模式串
方式一:暴力解,第一层循环遍历文本串表示相同子串开始位置,第二层循环遍历模式串

class Solution {
    public int strStr(String haystack, String needle) {
        int hLen = haystack.length();
        int nLen = needle.length();
        // 模式串为空,返回0
        if (nLen == 0) return 0;
        // i 表示文本串该位置作为匹配的起始位置,所以 循环到hLen - nLen 结束,因为再往后一个位置作为匹配的起始位置,文本串剩余位置不够模式串匹配
        for (int i = 0; i <= hLen - nLen; i++) {
            if (haystack.charAt(i) == needle.charAt(0)) {
            	// 文本串 i 下标位置和模式串0下标位置已经匹配上,从 i+1 位置开始向后匹配
                int j = 1; 
                // j 指向模式串每轮匹配位置,则文本串每轮匹配位置为 i + j
                while (j < nLen && haystack.charAt(i + j) == needle.charAt(j)) {
                	// 当前字符匹配,j 指向下轮要匹配的位置
                    j++;
                }
                // 如果已经匹配到最后一个位置,表示整个模式串匹配成功,返回本轮匹配的起始位置
                if (j == nLen) return i;
            }
        }
        // 没有匹配成功
        return -1;
    }
}

KMP解法:

class Solution {
    public int strStr(String haystack, String needle) {
        int hLen = haystack.length();
        int nLen = needle.length();
        if (nLen == 0) return 0;
        // j 为模式串指针,表示接下来模式串比较的位置
        int j = 0;
        // 得到模式串对应的 next 数组
        int[] next = getNext(needle);
        // i 为文本串指针,表示接下来文本串比较的位置
        // 这里循环与暴力解法结束位置不同需要注意,因为这里的 i 表示接下来文本串比较的位置,i 要走到头
        for (int i = 0; i < hLen; i++) {
            // 如果不相等,j 回退,而 i不动
            while (j > 0 && haystack.charAt(i) != needle.charAt(j)) {
                // j 回退到[0,j)子串的最大相等前后缀的前缀尾后一个位置,如果没有相等的前后缀直接回到0 下标
                j = next[j - 1];
            }
            // 如果相等 j++,循环结束 i也++,表示接下来比较的位置
            if (haystack.charAt(i) == needle.charAt(j)) {
                j++;
                // 模式串指针 j 已经走到最后,成功匹配
                if (j == nLen) return i - nLen + 1;
            } 
        }
        return -1;
    }
    public int[] getNext(String s) {
        int len = s.length();
        // 1. 初始化
        int[] next = new int[len];
        int j = 0;   // 前缀指针 j=0, 后缀指针 i=1
        // j 代表接下来应该比较的前缀,同时代表这最大相等前后缀长度;i 代表接下来应该比较的后缀
        for (int i = 1; i < len; i ++) {
            // i 接下来需要比较的后缀,同时也表示 next 数组本轮填充位置
            // 不相等时回退
            while (j > 0 && s.charAt(i) != s.charAt(j)) {
                // j 回退到[0,j)子串的最大相等前后缀的前缀尾后一个位置,如果没有相等的前后缀直接回到0 下标
                j = next[j - 1];
            }
            // 相等时 j++,表示最大相等前后缀长度+1,同时指向下一次应该比较的前缀位置
            if (s.charAt(i) == s.charAt(j)) {
                j++;
            }
            // next数组 i 下标填充 [0, i] 子串的最大相等前后缀长度
            next[i] = j;
        }
        return next;
    }
}

459. 重复的子字符串

Leetcode 链接
给定一个非空的字符串 s ,检查是否可以通过由它的一个子串重复多次构成。
示例 1:
输入: s = “abab”
输出: true
解释: 可由子串 “ab” 重复两次构成。

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

示例 3:
输入: s = “abcabcabcabc”
输出: true
解释: 可由子串 “abc” 重复四次构成。 (或子串 “abcabc” 重复两次构成。)
题解:
暴力解法:以前 i 个字符作为子串是否能被重构,第一层循环遍历所有 i 的可能,第二次循环使用双指针判断能否被重构

    public boolean repeatedSubstringPattern(String s) {
        int len = s.length();
        // i 表示子串长度,从 1 到最大 len/2
        for (int i = 1; i <= len / 2; i++) {
        	// 如果子串长度为 len 的因数,表示可能被 [0,i) 区间子串重构
            if (len % i == 0) {
                int j = 0;
                // 双指针 j 和 j + i 位置逐个比较
                for (; j < len - i; j ++) {
                    if(s.charAt(j) != s.charAt(j + i)) {
                    	// 一旦必相等,表示不能被 [0,i) 区间子串重构
                    	break;
                    }
                }
                // 如果是因为越界结束循环,表示可以被重构
                if (j + i == len) return true;
            }
        }
        return false;
    }

巧解:
举个栗子: 如果能被子串重构,那么原字符串经过循环移位后一定能等于原字符串
abab
. baba
. . abab
abababab 也就是说满足原字符串是两个原字符串拼接再一起去头去尾 bababa 的子串

    public boolean repeatedSubstringPattern(String s) {
	    String str = s + s;
	    return str.substring(1, str.length()-1).contains(s);
    }

KMP解法:
举个栗子:
s = “abcabcabcabc” 对应 next 数组为:000 123 456 789,s.length() = 12 = 9(next 数组最后一位) + 3(重构子串长度),3 是 s长度的因数,所以 s 能被子串重构

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        int len = s.length();
        int[] next = new int[len];
        // 前缀指针 j
        int j = 0;
        // 填充 next 数组
        for (int i = 1; i < len; i++) {
            while (j > 0 && s.charAt(j) != s.charAt(i)) {
                j = next[j - 1];
            }
            if (s.charAt(j) == s.charAt(i)) {
                j++;
            }
            next[i] = j;
        }
        // 子串长度不能等于 s 长度
        if (next[len - 1] == 0) return false;
        // 子串长度:len - next[len - 1] 
        return (len % (len - next[len - 1]) == 0);
    }
}

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