算法补充之KMP作用原理(一)

leetcode 028.实现strStr(),即查找重复字符串(KMP算法) 前言 本题是经典的字符串单模匹配的模型,因此可以使用字符串匹配算法解决,常见的字符串匹配算法包括暴力匹配、Knuth-Morris-Pratt 算法、Boyer-Moore 算法、Sunday 算法等,本文 ## 前言 本题是经典的字符串单模匹配的模型,因此可以使用字符串匹配算法解决,常见的字符串匹配算法包括暴力匹配、Knuth-Morris-Pratt 算法、Boyer-Moore 算法、Sunday 算法等,本文将讲解朴素解法(暴力匹配)和KMP算法 因为哈希方法可能出现哈希值相等但是字符串不相等的情况 阅读详情

1. 整体把握

一般都可以想到 O ( n 2 ) O(n^2) O(n2)的暴力算法,KMP改进暴力算法使其算法复杂度为O(m+n)。本文参考:维基百科。

2.算法学习

2.1 使用局部匹配表
  • To illustrate the algorithm’s details, consider a (relatively artificial) run of the algorithm, where W = “ABCDABD” and S = “ABC ABCDAB ABCDABCDABDE”. At any given time, the algorithm is in a state determined by two integers:
  • m, denoting the position within S where the prospective match for W begins,
    i, denoting the index of the currently considered character in W.

通过例子学习KMP,先从以上定义确定W、S、m、i分别代表的意义,然后看几个规则:

  • For the moment, we assume the existence of a “partial match” table T, described below, which indicates where we need to look for the start of a new match in the event that the current one ends in a mismatch.局部匹配表的意义
  • The entries of T are constructed so that if we have a match starting at S[m] that fails when comparing S[m + i] to W[i], then the next possible match will start at index m + i - T[i] in S (that is, T[i] is the amount of “backtracking” we need to do after a mismatch). 局部匹配表如何使用
  • This has two implications: first, T[0] = -1, which indicates that if W[0] is a mismatch, we cannot backtrack and must simply check the next character;
  • and second, although the next possible match will begin at index m + i - T[i], as in the example above, we need not actually check any of the T[i] characters after that, so that we continue searching from W[T[i]].

假设我们有一个partial match table(如下图所示),重复上面查表的规则和方法,我们可以手动复现下面的KMP算法过程:
这里写图片描述
  
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

特别强调:每次当前母串中 m + i m+i m+i位置失配时,查表中对应的i的值,然后将下一次匹配的位置设置为 m + i − T [ i ] m + i - T[i] m+i−T[i],但是只需要从T[i]处开始匹配就可以了。

2.2 构造局部匹配表
没有优化的构造方法

这里写图片描述
  由"ABCDABD"构造其局部匹配表如上图所示,过程如下:

  • We consider the example of W = “ABCDABD” first. We will see that it follows much the same pattern as the main search, and is efficient for similar reasons. We set T[0] = -1.T[0]默认为-1,注意当前是i位置发生了失配
  • To find T[1], we must discover a proper suffix of “A” which is also a prefix of pattern W. But there are no proper suffixes of “A”, so we set T[1] = 0.这里需要了解前缀和后缀的定义
  • To find T[2], we see that the substring W[0] - W[1] (“AB”) has a proper suffix “B”. However “B” is not a prefix of the pattern W. Therefore, we set T[2] = 0.不同于说是AB子串的前缀,而强调了是W的前缀,这里为下面的简易判断方式做了铺垫。
  • 3Continuing to T[3], we first check the proper suffix of length 1, and as in the previous case it fails. Should we also check longer suffixes?
    • No, we now note that there is a shortcut to checking all suffixes: let us say that we discovered a proper suffix which is a proper prefix (A proper prefix of a string is not equal to the string itself) and ending at W[2] with length 2 (the maximum possible); then its first character is also a proper prefix of W, hence a proper prefix itself, and it ends at W[1], which we already determined did not occur as T[2] = 0 and not T[2] = 1. Hence at each stage, the shortcut rule is that one needs to consider checking suffixes of a given size m+1 only if a valid suffix of size m was found at the previous stage (i.e. T[x] = m) and should not bother to check m+2, m+3, etc.通过反证法,证明了T[i]与T[i-1]的一些关系

理解最为困难的就是第二点,在T[3]上我们本应该检查前后缀长度为1和2,但是由于T[2]等于0,所以我们只需要检查长度为1的前后缀。用DP的思想很容易理解,因为T[i]的最长前后缀应该是T[i-1]的基础上再拓展一个字符。当然,并不一定T[3]的最长前后缀长度一定为T[i-1]+1,只是说我们需要检查的长度范围为0到T[i-1]+1。

优化的构造方法

有人称之为优化的KMP算法,实际上维基百科直接给的就是优化后的版本,而没有提及上面的优化前的版本,这种优化通过观察在构建局部匹配表上做了改进。维基上的内容不是很好理解,根据这篇,很快理解了优化的本质。如下公式所示:
   i f   p [ T [ i ] ] = = p [ i ] , 则 令 T [ i ] = T [ T [ i ] ] if  p[T[i]]==p[i],则令T[i]=T[T[i]] if p[T[i]]==p[i],则令T[i]=T[T[i]]

图不正确 2018年7月15号检查回顾,发现错误。

这里写图片描述
   
  在编程上的实现比思想上更加简单,只要在没有优化的版本增加判断条件,进行优化就可以了。

3. 伪代码

学习伪代码,然后尝试自己去实现,在某些字符串的题目中,KMP给我们提供了 O ( m + n ) O(m+n) O(m+n)的备用函数,结合深度搜索可以解决很多复杂的问题。

algorithm kmp_search:
    input:
        an array of characters, S (the text to be searched)
        an array of characters, W (the word sought)
    output:
        an array of integers, P (positions in S at which W is found)
        an integer, nP (number of positions)

    define variables:
        an integer, j ← 0 (the position of the current character in S)
        an integer, k ← 0 (the position of the current character in W)
        an array of integers, T (the table, computed elsewhere)

    let nP ← 0

    while j < length(S) do
        if W[k] = S[j] then
            let j ← j + 1
            let k ← k + 1
            //如果k=length w 那么代表一个完整的匹配完成
            if k = length(W) then
                (occurrence found, if only first occurrence is needed, m may be returned here)
                //记录这个匹配信息 模式串开始位置位j-k(模式串长度) np+1,括号里面的话的意思,如果只要找到第一个匹配完成的位置,则这里直接return就可以了。
                let P[nP] ← j - k, nP ← nP + 1
                //重新开始,这里和失配的处理一样,因为即使这个匹配完成了,也存在前面的字符后面匹配的一部分,所以必须trackback
                let k ← T[k] //(T[length(W)] can't be -1)
        else
	    //失配发生的时候,直接trackback
            let k ← T[k]
            //如果k<0的时候,直接跳到下一个字符
            if k < 0 then
                let j ← j + 1
                let k ← k + 1

仔细观察发现没有 m m m了,在上面的算法学习部分是有个 m m m标志模式串起始位置的,这里基于两个思考:
   m = m + k − T [ k ] + T [ k ] = m + k ,   m = j − k m=m+k-T[k]+T[k]=m+k, m=j-k m=m+k−T[k]+T[k]=m+k, m=j−k
  注意上面的j是先增加了1,所以这里为j-k。上面的伪代码实现起来应该很容易,然后看局部匹配表的伪代码如下:

//未优化的版本,伪代码:
algorithm kmp_table:
    input:
        an array of characters, W (the word to be analyzed)
        an array of integers, T (the table to be filled)
    output:
        nothing (but during operation, it populates the table)

    define variables:
        an integer, pos ← 2 (the current position we are computing in T)
        an integer, cnd ← 0 (the zero-based index in W of the next 
character of the current candidate substring)

    (the first few values are fixed but different from what the algorithm 
might suggest)
    let T[0] ← -1, T[1] ← 0
    //pos从2开始,所以刚开始的判断为w[1],w[0],cnd=0 注意cnd代表了当前substring的最长前缀的下一个值。
    while pos < length(W) do
        (first case: the substring continues)
        if W[pos - 1] = W[cnd] then
            let cnd ← cnd + 1, T[pos] ← cnd, pos ← pos + 1
        //如果没有拓展这个最长前缀,按照上面的算法我们应该以--cnd>=0的方式检查
        //但是这样会判断多余的长度,采用cnd=T[cnd]避免检查没有必要的最长前缀长度
        (second case: it does not, but we can fall back)
        else if cnd > 0 then
            let cnd ← T[cnd]
		//第三种情况,从T[pos-1]的cnd值直到0都检查过了,没有符合要求的前后缀,则此时设置T[pos]=0;
        (third case: we have run out of candidates.  Note cnd = 0)
        else
            let T[pos] ← 0, pos ← pos + 1

对于cnd=T[cnd],其实网上很多人都困惑,但它并不是KMP算法的原理部分,而是编程者的技巧,这种编程技巧源自一种观察:
这里写图片描述
观察i=10,此时因为p[pos-1] != p[cnd](此时pos=10 cnd=2),执行cnd=T[cnd]。我们知道了p[pos-1] != p[cnd]的事实,从KMP原理上此时cnd应该为2,去检查PA == AT?,不过可以多思考一步,如果AT能成为pos=10的W的最长前缀,那么A一定PA的最长前缀。按照这种逻推广到一般情形,遇到上面p[pos-1] != p[cnd]的情况时,下一步应该检查的最长前缀的长度为T[cnd],而不是cnd-1。**这里需要多想想,再次强调这是编程方式的一种优化。**再看看优化后的KMP算法的局部匹配表的构造算法:

//经过优化的局部匹配表构造算法
algorithm kmp_table:
    input:
        an array of characters, W (the word to be analyzed)
        an array of integers, T (the table to be filled)
    output:
        nothing (but during operation, it populates the table)

    define variables:
        an integer, pos ← 2 (the current position we are computing in T)
        an integer, cnd ← 0 (the zero-based index in W of the next 
character of the current candidate substring)

    (the first few values are fixed but different from what the algorithm 
might suggest)
    let T[0] ← -1, T[1] ← 0
    while pos < length(W) do
        (first case: the substring continues)
        if W[pos - 1] = W[cnd] then
            let cnd ← cnd + 1, T[pos] ← cnd, pos ← pos + 1
        (second case: it does not, but we can fall back)
        else if cnd > 0 then
            let cnd ← T[cnd]
		    //注意这里的continue,不能省略
            continue;
        (third case: we have run out of candidates.  Note cnd = 0)
        else
            let T[pos] ← 0, pos ← pos + 1
        //源自上面的原理,很容易得到修改上面的伪代码。
        if p[T[pos-1]] == p[pos-1] 
	        T[pos-1]=T[T[pos-1]]

4. 总结

KMP算法记录篇远没有结束,还需要自己转化成C++代码,并且实战一个算法题。对于字符串的算法题目,使用回溯加KMP能解决一些难度较大的算法题。

KMP算法原理 KMP算法原理 KMP算法是一种字符串匹配算法,它是对朴素模式算法(暴力匹配)的改进。 我们先看朴素模式下是怎么进行字符串匹配的。假设我们有两个字符串,被匹配的的大串称为 主串,要匹配的小串称为模式串。 模式串要和主串匹配,我们很容易想到一个双重循环下的暴力匹配方法。先从主串的第一个字符开始匹配,依次遍历模式串的字符,如果不匹配就从主串的第二个字符匹配。如果主串的长度为n,模式串的长度为m,显然这个算法的最坏时间复杂度为O(nm)O(nm)O(nm)。 这个方法一个最大的缺点就是没能从每次失败匹配中 阅读详情

相关推荐

KMP算法原理详解_论文解读版

1. KMP算法是什么,解决了什么问题,及其不足之处(算法最坏情况) 2. KMP原理 3. KMP实例 4. 引用文献

Sudouble的专栏 4028

KMP 算法详解

KMP算法是一种高效的字符串匹配算法,算法名称取自于三位共同发明人名字的首字母组合。该算法的主要使用场景就是在字符串(也叫主串)中的模式串(也叫子串)定位问题,常见的有“求子串出现的起始位置”、“求子串的出现次数”等。

这里是阿安的博客 5万+

新手友好的PythonUI库PySimpleGUI项目已下架,切换4.50.6版本的方法

过期后,如果还想使用 PySimpleGUI,则需要切换到版本 4,而版本 4 在 GitHub 上有很多社区维护的版本可以选择。开发团队尝试了 7 年,但始终没能获得足够的收入来维持项目的运营,尤其是开源项目通常面临资金不足的问题。商业许可证是永久有效的,用户可以在支持期结束后依然使用应用程序,并会提供离线版本的文档以供参考。尽管项目关闭,但对购买了商业许可证的用户,团队仍会在接下来的一年内提供支持。

baidu_34681715的博客 6860

KMP算法最浅显理解——一看就明白

说明 KMP算法看懂了觉得特别简单,思路很简单,看不懂之前,查各种资料,看的稀里糊涂,即使网上最简单的解释,依然看的稀里糊涂。 我花了半天时间,争取用最短的篇幅大致搞明白这玩意到底是啥。 这里不扯概念,只讲算法过程和代码理解: KMP算法求解什么类型问题 字符串匹配。给你两个字符串,寻找其中一个字符串是否包含另一个字符串,如果包含,返回包含的起始位置。 如下面两个字符串: c...

好记性不如烂笔头的专栏 33万+

EPICS Phoebus手册1

EPICS客户端phoebus 手册

yuyuyuliang00的博客 3972

前导0预测(Leading-Zero Anticipator,LZA)

前导0预测(Leading-Zero Anticipator,LZA) 浮点加法在完成之后会进行尾数规格化移位,而在进行尾数加法时,可以使用前导0预测(Leading-Zero Anticipator,LZA)同时计算移位,前导0预测只发生在一个正数加上一个负数的情况下,电路图如图1所示。 图1 传统LZD算法和LZA算法 1. 基础算法 算法的目标是计算出加法结果序列左边连续0的数量,下文中对...

crw1111111的博客 7386

KMP算法(next数组求法)

KMP算法是一种改进的字符串匹配算法,由D.E.Knuth,J.H.Morris和V.R.Pratt提出的,因此人们称它为克努特—莫里斯—普拉特操作(简称KMP算法)。KMP算法的核心是利用匹配失败后的信息,尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是通过一个next()函数实现,函数本身包含了模式串的局部匹配信息。KMP算法的时间复杂度O(m+n)。

weixin_51780040的博客 1万+

DTS 数据迁移

支持关系型数据库(MySQL, Oracle, SQL Server等)、NoSQL数据库、大数据系统等。DTS数据迁移是现代化数据架构调整和云迁移过程中的重要工具,能够大大降低数据迁移的复杂度和风险。DTS (Data Transmission Service) 是一种数据迁移和同步服务,:先迁移历史数据(全量),再实时同步新增变化(增量):不同数据库类型间迁移,如Oracle到MySQL。:将单库数据迁移到分库分表架构。:将业务数据迁移到分析型数据库。:将本地数据库迁移到云数据库。

qq_41081716的博客 752

全网最容易理解的KMP算法讲解

其实网上有很多讲解KMP算法的文章,详略不一,我认为有两点没有解释清楚:第一点:匹配失败以后,模式串的位移;第二点:next数组的生成算法;希望本篇文章能将KMP算法清晰易懂的拆解开来。

duzm200542901104的专栏 6523

【Simulink教程案例18】基于simulink的基础OFDM+64QAM发射接收链路仿真

OFDM(Orthogonal Frequency Division Multiplexing)即正交频分复用技术,实际上OFDM是MCM(Multi Carrier Modulation),多载波调制的一种。通过频分复用实现高速串行数据的并行传输, 它具有较好的抗多径衰落的能力,能够支持多用户接入。OFDM技术由MCM(Multi-Carrier Modulation,多载波调制)发展而来。OFDM技术是多载波传输方案的实现方式之一,它的。

FPGA/MATLAB学习教程/源码/项目合作开发 1991

【用unity实现100个游戏之18】从零开始制作一个类CSGO/CS2、CF第一人称FPS射击游戏——基础篇1(附项目源码)

生存和射击游戏一直是我的最爱,说起3D最普遍的应该就是射击系统了,你可以在任何情况下加入射击功能,所以我写下了这篇FPS开发记录。希望对你有帮助。在这个项目中,你将学习如何设计和实现射击系统、武器系统、玩家控制、场景设计等方面的内容。通过这个项目,你将深入了解游戏开发中的许多核心概念和技术,并且在实践中不断提升自己。本项目将带你从零开始逐步实现一个完整的第一人称射击游戏,并且会逐步引入一些高级功能,如特效、声音等。

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 5506

KMP算法详解

KMP算法是一种字符串模式匹配算法,不同的来源讲解方式也不一样,很容易混乱,在这里以一种特殊的方式来讲解KMP算法,希望大家不再被这个问题所困扰。 一. 一些基础问题 什么是字符串的模式匹配? 给定两个串S=“s1s2s3 …sn”和T=“t1t2t3 …tn”,在主串S中寻找子串T的过程叫做模式匹配,T称为模式。 如何寻找? 我们先从比较好理解的暴力匹配(朴素模式匹配BF算法)开始,进而引出K...

yyzsir的博客 9万+

Autosar CAN 网络管理测试用例(3)——Repeat Message Timer 时间测试

Autosar CAN 网络管理测试用例(3)——Repeat Message Timer 时间测试

蚂蚁小兵 2468

九分钟带你弄懂KMP算法【原理篇】

九分钟帮助你从初识到掌握KMP算法

qq_62839589的博客 2366

人工智能大模型原理与应用实战:AI模型转换为API的步骤和方法

传统的开发模式下,构建复杂的软件系统是非常费时费力的,而通过云计算、微服务等技术手段可以实现快速部署、弹性扩展的能力。在这种背景下,越来越多的公司将重点转移到研发人员的产品思维上,希望能够将自己的AI模型转换为一个可供他人调用的API接口。但是对于许多从事AI领域的研发人员来说,如何将自己的AI模型转换为API是一个比较棘手的问题。在这篇文章中,作者将从AI模型转换为API的过程分为以下几个步骤:AI模型准备阶段——模型选择、数据准备、模型训练。

AI天才研究院 2601

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

KMP算法原理详解

KMP算法是一种高效字符串匹配算法,通过预处理模式串构建next数组(记录最长公共前后缀长度),在匹配失败时利用已匹配信息跳过无效比较,将时间复杂度优化至O(n+m)。算法核心包括:计算next数组(动态规划)、匹配时保持文本指针不回溯、通过next值跳转优化。适用于文本编辑、基因比对等场景,相比朴素算法显著提升匹配效率。实现关键在于next数组的优化计算和匹配过程的指针跳转策略。

liulilittle的博客 2091

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

KMP算法的原理

首先我们通过判断一个字符串中是否包含另一个字符串的案例引出对应的字符串匹配算法。然后我们了解了BF算法和KMP算法的具体操作流程。顺带了解了什么是字符串的前后缀。重点分析了KMP算法的原理及如何求next数组,这两个是整个KMP算法中最难理解的地方。最后完成了KMP算法的代码实现。

keaiduo_sensen的博客 1058

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

KMP算法

一、字符串匹配场景 KMP算法可以解决以字符串匹配为模型的问题,算法应用场景非常广泛,并不仅仅限于文本的匹配。 以简单的字符串匹配为例,现有两个链分别为source和target, 要在Source链中匹配Target链,很容易观察出出从source链下标10的位置可以成功匹配,如下图所示:   二、非KMP算法对此类问题的求解方式 在字符串匹配问题中,最直观的想法就是,Sou...

l577217的博客 1万+

算法(一)|九千字硬核讲解KMP算法,搞懂KMP的来龙去脉

KMP算法为什么会这样想? KMP算法的主串指针i为什么可以不用回溯?KMP算法的时间复杂度为什么是O(m+n)? 大量数学公式硬核理解KMP的来龙去脉

DADONGOOO的博客 3482

python之KMP算法(原理详解)

KMP算法其实就是字符串匹配的一种高效算法,通常称作模式匹配; 本文结构如下: 一、朴素的匹配算法 1、匹配的概念 2、朴素算法原理 3、代码实现 二、KMP算法 1、KMP算法简介 2、KMP算法原理详解 3、求出next()函数 4、代码示例 一、朴素的匹配算法 1、匹配的概念 如下图所示,就是模式串T与主串S匹配成功,模式串首尾间的各个元素与主串之间的某一段元素完全相同 2、朴素算法原理 ...

weixin_45459565的博客 2526

【算法】KMP算法原理分析

KMP算法KMP算法简介一般字符串匹配算法KMP算法原理代码实现 KMP算法简介   KMP算法是一种改进的字符串匹配算法,由D.E.Knuth,J.H.Morris和V.R.Pratt提出的,因此人们称它为克努特—莫里斯—普拉特操作(简称KMP算法)。   一般的字符串匹配算法算法在子串中有多个字符和模板串中的若干个连续字符比较都相等,但最后一个字符比较不相等时,模板串和子串的比较位置都需要回退,而KMP算法在上述情况下,模板串位置不需要回退,从而可以大大提高效率   KMP算法的核心是利用子串匹配失败后

这道题我不会做...不会做啊..太难了!! 1066

kmp算法总结

搞ACM也有三年了,期间学习了不少算法,到12月把上海站打完也要成退役狗了。最近突然想把学过的一些算法回过头来好好总结一下,于是就有了我的算法总结系列。这是这个系列的开端,所以先写一个简单点的算法,以后会慢慢复习一些复杂的算法,最后还是希望自己能够坚持下去吧。 KMP算法 KMP算法是一种线性时间复杂度的字符串匹配算法,它是对BF(Brute-Force,最基本的字符串匹配算法)的改进。对

ddyyxx的程序员之路 1万+

kmp算法的原理及理解

kmp算法的原理及理解 前言     之前对kmp算法虽然了解它的原理,即求出P0···Pi的最大相同前后缀长度k;但是问题在于如何求出这个最大前后缀长度呢?我觉得网上很多帖子都说的不是很清楚,总感觉没有把那层纸戳破,后来翻看算法导论,32章 字符串匹配虽然讲到了对前后缀计算的正确性,但是大量的推理证明不大好理解,没有与程序结合起来讲。今天我在这里讲一讲我的一些理解,希望大家多多指教,如果有不...

IT老农民的博客 1300
上一篇: DSAA之图论Dijkstra(贪婪算法)(五)
下一篇: DSAA之图论Kruskal算法(七)
LoveStackover
博客等级 码龄9年 14粉丝 57原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值