[python刷题模板] 前缀函数/next数组/kmp算法

已于 2023-09-20 21:36:26 修改
阅读量605 收藏
点赞数
分类专栏： python刷题模板 文章标签： python 算法 开发语言
于 2023-02-12 16:47:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuliangcan/article/details/128996043
版权

[python刷题模板] 前缀函数/next数组/kmp算法

一、 算法&数据结构

1. 描述

前缀函数和next数组基本上是一个东西，但储存的内容不同。
他们是kmp算法的基础。但真的不太好理解，以及不好写，背不过。
前缀函数π(i)可以在O(n)的时间计算出来数组内每个前缀的前缀函数。
  • 参考 oiwiki前缀函数与 KMP 算法
  • kmp还可以结合字典树搞ac自动机，待施工。
  • 前缀函数π[i]代表的前缀s[:i+1]和后缀s[-i:]相同的情况下，是前缀长度。
    • 简单来说 pi[i] 就是，子串 s[0… i] 最长的相等的真前缀与真后缀的长度。
  • next数组是指模式串在i位置匹配失败后，应该向前跳到哪个位置开始继续匹配。

2. 复杂度分析

  1. 预处理O(n)
  2. 查询O(n)

3. 常见应用

  1. 字符串查询。

4. 常用优化

  1. 从意义上来说，前缀函数值得是前后缀相同的长度；next数组是匹配失败后模式串指针j要去的位置。
  • 因此kmp搜索用next数组写法简单点(参考模板代码3)；但找前后缀用前缀函数更直观（模板代码1）。

二、 模板代码

1. 裸前缀函数

例题: 4808. 构造字符串
这题暴力能过，但还是前缀函数nb。

# Problem: 构造字符串
# Contest: AcWing
# URL: https://www.acwing.com/problem/content/4811/
# Memory Limit: 256 MB
# Time Limit: 1000 ms

import sys
import bisect
import random
import io, os
from bisect import *
from collections import *
from contextlib import redirect_stdout
from itertools import *
from array import *
from functools import lru_cache
from types import GeneratorType
from heapq import *
from math import sqrt, gcd, inf

if sys.version >= '3.8':  # ACW没有comb
    from math import comb

RI = lambda: map(int, sys.stdin.buffer.readline().split())
RS = lambda: map(bytes.decode, sys.stdin.buffer.readline().strip().split())
RILST = lambda: list(RI())
DEBUG = lambda *x: sys.stderr.write(f'{str(x)}\n')

MOD = 10 ** 9 + 7

def prefix_function(s):
    """计算s的前缀函数"""
    n = len(s)
    pi = [0] * n
    for i in range(1, n):
        j = pi[i - 1]
        while j > 0 and s[i] != s[j]:
            j = pi[j - 1]
        if s[i] == s[j]:
            j += 1
        pi[i] = j
    return pi
#       ms
def solve():
    n, k = RI()
    t, = RS()
    mx = prefix_function(t)[-1]

    if mx == 0:
        return print(t * k)
    suf = t[mx:]
    print(t + suf * (k - 1))


if __name__ == '__main__':
    solve()

2. 树上kmp

链接: 1367. 二叉树中的链表

试了下树上kmp是负优化，但可能是数据问题。

class Solution:
    def isSubPath(self, head: ListNode, root: TreeNode) -> bool:
        path = []
        while head:
            path.append(head.val)
            head = head.next
        n = len(path)
        def get_next(p):
            n = len(p)
            nxt = [0]*n
            nxt[0] = -1
            j,k=0,-1
            while j < n-1:
                if k == -1 or p[j] == p[k]:
                    j+=1
                    k+=1
                    if p[j] == p[k]:
                        nxt[j] = nxt[k]
                    else:
                        nxt[j] = k 
                else:
                    k = nxt[k]
           
            return nxt
        nxt = get_next(path)
        # print(nxt)
        
        def dfs_kmp(tree, j):
            if j == n:
                return True
            if not tree:
                return False
            if j == -1 or tree.val == path[j]:
                return dfs_kmp(tree.left,j+1) or dfs_kmp(tree.right,j+1)
            else:
                return dfs_kmp(tree,nxt[j])

3. 裸kmp

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

class Kmp:
    """kmp算法，计算前缀函数pi,根据pi转移，复杂度O(m+n)"""

    def __init__(self, t):
        """传入模式串，计算前缀函数"""
        self.t = t
        n = len(t)
        self.pi = pi = [0] * n
        j = 0
        for i in range(1, n):
            while j and t[i] != t[j]:
                j = pi[j - 1]  # 失配后缩短期望匹配长度
            if t[i] == t[j]:
                j += 1  # 多配一个
            pi[i] = j

    def find_all_yield(self, s):
        """查找t在s中的所有位置，注意可能为空"""
        n, t, pi, j = len(self.t), self.t, self.pi, 0
        for i, v in enumerate(s):
            while j and v != t[j]:
                j = pi[j - 1]
            if v == t[j]:
                j += 1
            if j == n:
                yield i - j + 1
                j = pi[j - 1]

    def find_one(self, s):
        """查找t在s中的第一个位置，如果不存在就返回-1"""
        for ans in self.find_all_yield(s):
            return ans
        return -1

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        m,n = len(haystack),len(needle)
        
        # def get_next(p):
        #     n = len(p)
        #     nxt = [-1] * n
        #     j, k = 0, -1
        #     while j < n - 1:
        #         if k == -1 or p[j] == p[k]:
        #             j += 1
        #             k += 1
        #             if p[j] == p[k]:
        #                 nxt[j] = nxt[k]
        #             else:
        #                 nxt[j] = k
        #         else:
        #             k = nxt[k]

        #     return nxt
            
        # nxt = get_next(needle)
        # print(nxt)

        # i = j = 0        
        # while i < m and j < n:
        #     if j == -1 or haystack[i] == needle[j]:
        #         i += 1
        #         j += 1
        #     else:
        #         j = nxt[j]
        # if j == n:
        #     return i - j 
        # return -1

        
        def prefix_function(s):
            """计算s的前缀函数"""
            n = len(s)
            pi = [0] * n
            for i in range(1, n):
                j = pi[i - 1]
                while j > 0 and s[i] != s[j]:
                    j = pi[j - 1]
                if s[i] == s[j]:
                    j += 1
                pi[i] = j
            return pi
            
        pi = prefix_function(needle)
        print(pi)

        i ,j = 0,0        
        while i < m and j < n:
            while  j > 0 and haystack[i] != needle[j]:
                j = pi[j-1]
            if haystack[i] == needle[j]:               
                j += 1
            if j == n:
                return i - j + 1
            
            i += 1
        return -1

4. KMP+矩阵快速幂

链接: 2851. 字符串转换

矩阵快速幂，要求矩阵是正方形，可以把线性dp的O(n)优化成O(lgn)
https://leetcode.cn/problems/string-transformation/
"""
MOD = 10 ** 9 + 7


class Kmp:
    """kmp算法，计算前缀函数pi,根据pi转移，复杂度O(m+n)"""

    def __init__(self, t):
        """传入模式串，计算前缀函数"""
        self.t = t
        n = len(t)
        self.pi = pi = [0] * n
        j = 0
        for i in range(1, n):
            while j and t[i] != t[j]:
                j = pi[j - 1]  # 失配后缩短期望匹配长度
            if t[i] == t[j]:
                j += 1  # 多配一个
            pi[i] = j

    def find_all_yield(self, s):
        """查找t在s中的所有位置，注意可能为空"""
        n, t, pi, j = len(self.t), self.t, self.pi, 0
        for i, v in enumerate(s):
            while j and v != t[j]:
                j = pi[j - 1]
            if v == t[j]:
                j += 1
            if j == n:
                yield i - j + 1
                j = pi[j - 1]

    def find_one(self, s):
        """查找t在s中的第一个位置，如果不存在就返回-1"""
        for ans in self.find_all_yield(s):
            return ans
        return -1


def matrix_multiply(a, b, MOD=10 ** 9 + 7):
    m, n, p = len(a), len(a[0]), len(b[0])
    ans = [[0] * p for _ in range(m)]
    for i in range(m):
        for j in range(n):
            for k in range(p):
                ans[i][k] = (ans[i][k] + a[i][j] * b[j][k]) % MOD
    return ans


def matrix_pow_mod(a, b, MOD=10 ** 9 + 7):
    n = len(a)
    ans = [[0] * n for _ in range(n)]
    for i in range(n):
        ans[i][i] = 1
    while b:
        if b & 1:
            ans = matrix_multiply(ans, a, MOD)
        a = matrix_multiply(a, a, MOD)
        b >>= 1
    return ans


class Solution:
    def numberOfWays(self, s: str, t: str, k: int) -> int:
        if t not in s + s:
            return 0
        n = len(s)
        c = len(list(Kmp(t).find_all_yield(s + s[:-1])))
        m = [
            [c - 1, c],
            [n - c, n - 1 - c]
        ]
        m = matrix_pow_mod(m, k)
        return m[0][s != t]

三、其他

四、更多例题

五、参考链接

七水shuliang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python求解next数组实现KMP算法
Together_CZ的博客
07-30 5275
今天在做题的时候遇上好几道题目都是有关于KMP字符串匹配中的next数组的相关问题的，这是一个自己的盲区，毕竟之前一直没有看到过，今天就好好研究一下吧，KMP算法的来源，原理我都不多说了，这个是学习数据结构中的经典。     KMP算法，是由Knuth，Morris，Pratt共同提出的模式匹配算法，其对于任何模式和目标序列，都可以在线性时间内完成匹配查找，而不会发生退化，是一个非常优秀的模式匹
KMP算法中next数组的理解-python
tangyaruo的博客
12-01 1140
KMP算法解决了在字符串匹配过程中模式串指针回溯的问题，从而提高了字符串匹配效率。KMP具体细节在这里不展开讲，主要是梳理一下对KMP核心next数组的理解，要注意的是：目前网上有很多种版本的KMP算法，其next数组的定义也完全不同，因此，在学习KMP算法的时候，要先明确next数组的定义。 在本文中next[j]存放的是模式串P中P[0]到P[j-1]这个子串中，最长公共前缀和后缀的长度。 ...
kmp模板
我不想打铁
08-09 752
kmp模板，自己整理，仅做模板保存 #include<bits/stdc++.h> using namespace std; char tt[200],ss[200];//tt为模式串，下标从0开始,ss为匹配串 int net[200]; void getnet(int len) { net[0]=-1; int k=-1; for(int q=1;q&...
KMP算法python实现
敲代码的小风
10-11 386
【代码】KMP算法python实现。
KMP模板
m0_53437775的博客
10-01 114
KMP（python实现）
KMP(模板)
fuhaitao9999的博客
02-10 161
Oulipo The French author Georges Perec (1936–1982) once wrote a book, La disparition, without the letter 'e'. He was a member of the Oulipo group. A quote from the book: Tout avait Pair nor...
数据结构 KMP算法及next数组求解过程
11-04
函数内部实现KMP算法，结合next数组进行字符串匹配。 总之，KMP算法和next数组是数据结构中非常重要的部分，它们提供了高效字符串匹配的方法，对于理解和应用字符串处理有着重要意义。通过深入学习和实践，我们可以...
kmp的next数组算法.zip
最新发布
04-25
具体实现就是通过一个next()函数实现，函数本身包含了模式串的局部匹配信息。KMP算法的时间复杂度 也就是说，KMP算法是用来解决字符串匹配问题的，从一个主字符串text中寻找一个子字符串(模式字符串)pattern，看这个...
kmp算法 Python 版源码
01-15
kmp算法
KMP算法中next数组求法.docx
05-06
KMP算法中next数组求法 KMP算法是字符串匹配算法中的一种高效算法，next数组是KMP算法的核心结构。next数组的计算是KMP算法的关键步骤，本文将详细介绍next数组的计算方法。 next数组的定义： next数组的定义为：...
Python实现字符串匹配的KMP算法
12-26
具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配信息。 #! /usr/bin/python # coding=utf-8 """ 基于这篇文章的python实现 http://blog.sae.sina.com.cn/archives/307 """ import unittest def ...
KMP算法的多种模式数组next求法的比较（Python版代码）
xjcvip007的博客
01-07 699
28、Implement strStr() 题意： Implement strStr().Returns the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack. 思路：这题在字符串中找子串，是经典的KMP算法，定义S为原字符串，T为待匹配字符串，从S中找出T
python内置函数next()方法用法详解
IT之一小佬的博客
09-28 6715
python内置函数next()方法用法详解
python【数据结构与算法】KMP算法模板（我吐了！）
李响
10-13 541
import math import cmath import sys import string import heapq import bisect from queue import Queue,PriorityQueue,LifoQueue from collections import Counter,deque from itertools import permutations,combinations from functools import cmp_to_key def Gen_nex
kmp算法next计算方法_【数据结构——串】KMP算法——next数组Python的实现方式
weixin_39557087的博客
12-03 318
用字符串 匹配字符串 ，即判断 是否包含 ， 表示字符串 第 个字符next数组本身也是一个记录下标的数组，所以会受到我们对于匹配项编码排序的影响，理论上不连续编码也是可以的，甚至不用数字编码都可行，但是为了编程方便，所以我们才采用了连续的整数进行编码本文采用如下编码方式，这种编码可以避免出现负数，（可以认为0位置的值为和任意字符都可以匹配的值，所以如果当前位置为0，那就需要j和i都要...
KMP算法的形成思路、next数组的构建思路以及两个具体代码运算过程
weixin_65259109的博客
01-18 280
然而，在实际目标串s与模式串t的比较过程中，每个位置都可能成为失配位置，而且在真正的搜索引擎当中，会有无数个目标串，但是搜索的目标只有1个模式串。根据上面一开始的两张图我们可以得知，KMP算法的核心在于将元素一一比较、找到不匹配的点、讲t串模式串的比较指针移动到一个合适位置，然后通过继续比较移动s串目标串的比较指针。由上面这个求next[8]的例子我们可以得出，只要知道了0，1号元素的next值和每一个序号的next值，就可以通过比较的方法得到每一个序号的next值。（如果大家感兴趣的话这个过程叫回溯）。
字符串模式匹配经典算法KMP算法及其Python代码实现
weixin_59283901的博客
07-30 1098
KMP算法个人理解和Python实现
详解KMP及其Python实现
CSDNwzl的博客
03-03 1872
详解KMP及其Python实现 一、 KMP是什么 KMP算法是一种改进的字符串匹配算法。KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配信息。时间复杂度O(m+n)。 求解问题举例： 给定一下两个字符串str（n位）与ptr（m位），求ptr在srt中出现的次数或者其出现的...
python实现kmp算法（学不会你喷我）
热门推荐
your_answer的博客
03-19 1万+
1、首先kmp算法是解决子串匹配问题的，解决这个问题的暴力算法很容易想到。那就是子串的首部和母串的第i个部位对上后，两个串剩下的字符继续匹配，直到匹配不上，子串首部移到母串的i+1的位置上，重复上面的过程。这个算法的复杂度是O(n^2)，仔细一想是挺浪费的，要是子串和母串匹配了几个字符了，那么指针还要移回来（原谅我c的说法），整个子串才移动一个位置，这样效率就很蛋疼了。2、那有没有指针尽量不回移的...
KMP next数组函数
05-27
下面是一个用于计算KMP算法中next数组的函数实现，供你参考： ```python def getNext(pattern): n = len(pattern) next = [0] * n next[0] = -1 i, j = 0, -1 while i < n - 1: if j == -1 or pattern[i] == pattern[j]: i += 1 j += 1 next[i] = j else: j = next[j] return next ``` 该函数接受一个模式串pattern作为参数，返回一个长度为模式串长度的next数组。在函数中，使用变量i和j来表示当前计算的位置和前一个位置的next值，初始值分别为0和-1。在循环中，如果当前字符和前一个字符相同，则直接计算next值；如果不同，则需要利用前一个位置的next值来进行计算，直到找到相同的前缀后缀或者已经回溯到开头。最后，返回计算得到的next数组即可。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值