算法导论之字符串匹配算法
c a c b a c a b a c
b Байду номын сангаас b a c
时间复杂度是O(m+n)
a b a b a c a b a b a c a b a b a c
BM 算法
"坏字符规则"：
后移位数 = 坏字符的位置 - 搜索词中的上一次出现位置
好后缀
好后缀规则
后移位数 = 好后缀的位置 - 搜索词中的上一次出现位置 ABDCCAB ABCCCAB ABCCCAB
T字串
匹配序号 index1 index2 index3 index4 index5 index6 index7 index8 index9 index10
a a
b b a a a b a a a b a b a c b a b a c
a b a b a c
a b a b a b a a b a
a b a b
最好时间复杂度是O(n/m) 最坏时间复杂度是O(n*m)
SUNDAY算法
谢谢
有了覆盖函数，那么实现kmp算法就是很简单 的了，我们的原则还是从左向右匹配，但是当 失配发生时，我们不用把index向回移动， index前面已经匹配过的部分在P自身就能体现 出来当发生在j长度失配时，只要把P向右移动joverlay(j)长度就可以了。
a b a b a c -1 -1 0 1 2 -1
a[0]a[1]...a[k-1]a[k]= a[j-k]a[j-k+1]...a[j-1]a[j]
则对于pattern的前j+1序列字符，则有如下可能
P[k+1]==P[j+1] 此时 overlay(j+1)=k+1=overlay(j)+1
⑴
overlay(j+1)=k+1
overlay(j)=k
字符串匹配算法
中国矿业大学 计算机学院 孟靖宇
我们经常要在一段文本中某个特定的位置找出 某个 特定的字符或模式。 由此，便产生了字符串的匹配问题。
假设文本是一个长度为n的数组T[1...n]，模式是一个长度 为m<=n的数组P[1....m]。
简单字符串匹配
目标是找出所有在文本T=abcabaabcaabac中的模式 P=abaa所有出现。 该模式仅在文本中出现了一次，在位移s=3处。位移s=3 是有效位移。
a[0]a[1]...a[k-1]a[k]= a[j-k]a[j-k]...a[j-1]a[j]
而没有更大的k满足这个条件，就是说要找到尽可能大k,使P 前k字符与后k字符相匹配，k要尽可能的大， 原因是如果有比较大的k存在，而我们选择较小的满足条件的 k，
在红色部分失配，正确的结果是k=1的情况， 把P右移4位，如果选择k=0,右移5位则会产 生错误。 计算这个overlay函数的方法可以采用递推， 可以想象如果对于pattern的前j个字符，如果 覆盖函数值为k
a
-1 -1 0 1 2 -1
ab aba abab
abaabcaba
ababa ababac abaabac
0
由于计数是从0始的，因此覆盖函数的值为0说明有1个匹配， 其中-1表示没有覆盖，那么何为覆盖呢，下面比较数学的来 看一下定义，比如对于序列
a[0]a[1]...a[j-1]a[j]
要找到一个k,使它满足
对于目的字串T是banananobano,要匹配的字串P是 nano的情况 只要P字串第一个字符先和T字串的第一个字符比较， 如果相同就比较下一个，如果不同就把P右移一下， 之后再从P的每一个字符比较，这个算法的运行过 程如下图。
nano
时间复杂度是O(m * n)
KMP算法
T P
T P
覆盖函数所表征的是P本身的性质，可以让为其表 征的是P从左开始的所有连续子串的自我覆盖程度。 比如如下的字串
n = length(T) m = length(P) int flag=1; for(s = 0 ; s < n-m ; s++) { flag=1; for(i = 0 ; i < m ; i++) { if (P[i] != T[s+i]) {flag=0;break;} } if(flag) {cout << s; break;} }
⑵ P[k+1]≠P[j+1] 此时只能在P前k+1 个子符组成的子串中找到相应的overlay 函数，h=overlay(k),如果此时 P[h+1]==P[j+1],则overlay(j+1)=h+1否则 重复(2)过程.
overlay(j)=k
overlay(k)=h
overlay(j+1)=h+1
简单的字符串匹配算法用一个循环来找出所有 有效位移，该循环对n-m+1个可能的每一个s值 检查条件
P[0....m-1]=T[s....s+m-1]
简单字符串匹配算法，上图针对文本T=acaabc 和模式P=aab。
n-m+1个可能的位移s中的每一个值，比较相应 的字符的循环。 所以，在最坏情况下，此简单模式匹配算法的 运行时间为O（(n-m+1)m）。
KMP算法数据结构中的字符串匹配算法
KMP算法数据结构中的字符串匹配算法KMP算法是一种高效的字符串匹配算法，它在数据结构中被广泛应用于解决字符串匹配问题。
KMP算法的核心思想是利用已经匹配过的信息，尽可能减少回溯的次数，从而提高匹配的效率。
本文将介绍KMP算法的原理、实现步骤以及应用场景，帮助读者更好地理解和运用这一经典的算法。
### 1. KMP算法原理KMP算法的原理基于两个重要概念：最长公共前缀和部分匹配值。
最长公共前缀是指一个字符串的前缀（不包括整个字符串本身）与该字符串的另一个后缀相同的最大长度；部分匹配值是指字符串的前缀与后缀的最长公共部分的长度。
KMP算法通过预处理模式串，构建部分匹配表，实现在匹配过程中的高效跳转，从而减少不必要的比较次数。
### 2. KMP算法实现步骤KMP算法的实现步骤主要包括以下几个关键步骤：#### 2.1 构建部分匹配表首先，需要对模式串进行预处理，计算出每个位置的部分匹配值。
这一步是KMP算法的关键，也是提高匹配效率的核心。
通过部分匹配表，可以在匹配过程中实现快速跳转，避免不必要的回溯。
#### 2.2 匹配过程在匹配过程中，利用部分匹配表中的信息，实现模式串相对于文本串的高效移动。
通过比较文本串和模式串中对应位置的字符，根据部分匹配表中的数值进行跳转，从而快速定位匹配位置。
#### 2.3 匹配成功或失败处理如果匹配成功，返回匹配的起始位置；如果匹配失败，根据部分匹配表中的信息，调整模式串的位置，继续匹配直至完成整个文本串的匹配。
### 3. KMP算法应用场景KMP算法在实际应用中具有广泛的应用场景，特别适用于需要频繁进行字符串匹配的情况。
以下是一些常见的应用场景：- 字符串匹配：在文本编辑器、搜索引擎等软件中，用于查找指定字符串在文本中的位置。
- 数据压缩：在数据压缩算法中，用于查找重复出现的子串，实现数据的高效压缩。
- DNA序列比对：在生物信息学中，用于比对DNA序列，寻找相似性或重复出现的基因片段。
字符串匹配算法总结
Brute Force(BF或蛮力搜索) 算法：这是世界上最简单的算法了。
首先将匹配串和模式串左对齐，然后从左向右一个一个进行比较，如果不成功则模式串向右移动一个单位。
速度最慢。
那么，怎么改进呢？我们注意到Brute Force 算法是每次移动一个单位，一个一个单位移动显然太慢，是不是可以找到一些办法，让每次能够让模式串多移动一些位置呢？当然是可以的。
我们也注意到，Brute Force 是很不intelligent 的，每次匹配不成功的时候，前面匹配成功的信息都被当作废物丢弃了，当然，就如现在的变废为宝一样，我们也同样可以将前面匹配成功的信息利用起来，极大地减少计算机的处理时间，节省成本。
^_^注意，蛮力搜索算法虽然速度慢，但其很通用，文章最后会有一些更多的关于蛮力搜索的信息。
KMP算法首先介绍的就是KMP 算法。
这个算法实在是太有名了，大学上的算法课程除了最笨的Brute Force 算法，然后就介绍了KMP 算法。
也难怪，呵呵。
谁让Knuth D.E. 这么world famous 呢，不仅拿了图灵奖，而且还写出了计算机界的Bible <The Art of Computer Programming>( 业内人士一般简称TAOCP). 稍稍提一下，有个叫H.A.Simon 的家伙，不仅拿了Turing Award ，顺手拿了个Nobel Economics Award ，做了AI 的爸爸，还是Chicago Univ 的Politics PhD ，可谓全才。
KMP 的思想是这样的：利用不匹配字符的前面那一段字符的最长前后缀来尽可能地跳过最大的距离比如模式串ababac 这个时候我们发现在c 处不匹配，然后我们看c 前面那串字符串的最大相等前后缀，然后再来移动下面的两个都是模式串，没有写出来匹配串原始位置ababa c移动之后aba bac因为后缀是已经匹配了的，而前缀和后缀是相等的，所以直接把前缀移动到原来后缀处，再从原来的c 处，也就是现在的第二个b 处进行比较。
字符串匹配度算法
字符串匹配度算法字符串匹配度算法是计算两个字符串之间相似程度的一种算法。
在信息检索、文本分类、推荐系统等领域广泛应用。
它通过计算字符串之间的相似度来判断它们之间的关系，从而方便我们进行各种文本处理和分析工作。
字符串匹配度算法的核心思想是将字符串转换为向量表示，然后通过比较向量之间的距离或相似度来衡量字符串之间的相似程度。
常用的字符串匹配度算法有编辑距离算法、余弦相似度算法、Jaccard相似度算法等。
编辑距离算法是最常见的字符串匹配度算法之一，它衡量两个字符串之间的差异程度。
编辑距离算法将两个字符串进行插入、删除和替换操作，使它们变得相同。
通过计算进行了多少次操作，就可以得到它们之间的编辑距离。
编辑距离越小，表示两个字符串越相似。
余弦相似度算法是一种常用的基于向量的字符串匹配度算法。
它将字符串转换为向量表示，然后计算它们之间的夹角余弦值。
夹角余弦值越接近于1，表示两个字符串越相似；越接近于0，表示两个字符串越不相似。
Jaccard相似度算法是一种用于计算集合之间相似度的算法，也可以用于衡量字符串之间的相似度。
Jaccard相似度算法将字符串看作是字符的集合，然后计算它们之间的共同元素比例。
共同元素比例越高，表示两个字符串越相似。
除了这些常用的字符串匹配度算法外，还有很多其他的算法可以用于字符串的相似性比较。
不同的算法适用于不同的场景和需求，我们可以根据具体情况选择合适的算法。
总的来说，字符串匹配度算法是一种十分重要的工具，它可以帮助我们理解和处理文本数据。
在实际应用中，我们可以根据具体的需求选择合适的算法，从而完成各种文本处理和分析任务。
通过深入研究和应用这些算法，我们可以提高信息检索的准确性，加快文本处理的速度，提升推荐系统的效果。
希望大家能够重视字符串匹配度算法的研究和应用，为解决实际问题做出更多贡献。
python字符串匹配算法
python字符串匹配算法一、引言在计算机科学中，字符串匹配是指在文本中查找特定模式的子串。
这种操作在很多实际应用中都非常重要，例如在文件搜索、数据过滤、自然语言处理等领域。
Python提供了一些内置函数和库，可以方便地进行字符串匹配。
二、基本算法1. 朴素字符串匹配算法（Naive String Matching）：这是一种简单的字符串匹配算法，通过遍历文本串，逐个字符地与模式串进行比较，以确定是否存在匹配。
2. 暴力匹配算法（Brute Force）：这是一种基于字符比较的字符串匹配算法，通过逐个字符地比较文本串和模式串，直到找到匹配或者遍历完整个文本串为止。
3. KMP算法（Knuth-Morris-Pratt Algorithm）：这是一种高效的字符串匹配算法，通过记忆已经比较过的字符，减少不必要的重复比较，从而提高匹配速度。
三、Python实现1. 朴素字符串匹配算法：在Python中，可以使用`str.find()`方法或`str.index()`方法来查找模式串在文本串中的位置。
示例如下：```pythontext = "Hello, world!"pattern = "world"index = text.find(pattern)if index != -1:print("Pattern found at index", index)else:print("Pattern not found")```2. 暴力匹配算法：在Python中，可以使用`re`模块来实现暴力匹配算法。
示例如下：```pythonimport retext = "Hello, world! This is a test."pattern = "world"matches = re.findall(pattern, text)if matches:print("Pattern found in text")else:print("Pattern not found in text")```3. KMP算法：在Python中，可以使用`re`模块中的`search()`方法来实现KMP算法。
字符串匹配算法
字符串匹配算法字符串匹配算法是一种计算机科学领域中重要的基础算法。
它在广泛的应用领域中都有重大作用，比如文本处理、文本搜索、生物信息学、语音识别等。
字符串匹配算法可以在给定的文本或字符串中快速查找所需的子串。
这类算法的定义是通过模式和文本的对比来查找子串，如果模式在文本中发现，就代表算法成功匹配了字符串。
字符串匹配算法分为基于内容的和基于文本的，而且其中还有很多不同的算法技术，如暴力搜索法、KMP算法、BoyerMoore算法，这些算法有各自的优点和特点。
暴力搜索法是最基础的字符串匹配算法，它的基本思想是从文本的第一个字符开始，将模式中的每一个字符逐一与文本中的字符相比较，每比较完一个字符，文本指针就向后移动一位，直到模式中的每一个字符都被比较完，如果文本中的所有字符都与模式中的字符相同，则模式匹配成功，否则匹配失败，在失败后文本指针会重新指向文本的第二个字符重新进行模式匹配。
KMP算法是一种效率较高的字符串匹配算法，它的思路是先在模式字符串中构造一个部分匹配表，然后根据模式串和文本串的匹配情况，如果不匹配，就会根据部分匹配表往回退，寻找新的匹配位置。
KMP算法的运行效率比暴力搜索法要高，它涉及到字符串的预处理，在多次匹配的应用中，KMP算法的运行效率更高。
BoyerMoore算法是一种更为复杂的字符串匹配算法，它同样是基于文本搜索，它是暴力搜索与KMP算法的有机结合。
BoyerMoore算法在比较和移动模式字符串上比KMP算法效率更高，它充分利用字符串中坏字符的特性，在比较和移动模式字符串时做出了非常明智的选择，这就使得BoyerMoore算法的效率比KMP算法更高。
字符串匹配算法是计算机科学领域中重要的基础算法，其在文本处理、文本搜索、生物信息学、语音识别等方面都发挥了重要作用。
字符串匹配算法分为基于内容的和基于文本的，而且其中还有暴力搜索法、KMP算法、BoyerMoore算法等许多不同的算法技术，每一种算法都有其特殊的优点。
字符串匹配算法
字符串匹配算法公告：CSDN新版博客排名规则公示，请各位用户周知字符串匹配算法（一）简介分类：算法2008-10-29 15:223587人阅读评论(8)收藏举报注：本文大致翻译自EXACT STRING MATCHING ALGORITHMS，去掉一些废话，增加一些解释。
文本信息可以说是迄今为止最主要的一种信息交换手段，而作为文本处理中的一个重要领域——字符串匹配，就是我们今天要说的话题。
（原文还特意提及文本数据数量每18个月翻一番，以此论证算法必须要是高效的。
不过我注意到摩尔定律也是18个月翻番，这正说明数据的增长是紧紧跟随处理速度的，因此越是使用高效的算法，将来待处理的数据就会越多。
这也提示屏幕前的各位，代码不要写得太快了……）字符串匹配指的是从文本中找出给定字符串（称为模式）的一个或所有出现的位置。
本文的算法一律输出全部的匹配位置。
模式串在代码中用x[m]来表示，文本用y[n]来，而所有字符串都构造自一个有限集的字母表Σ，其大小为σ。
根据先给出模式还是先给出文本，字符串匹配分为两类方法：第一类方法基于自动机或者字符串的组合特点，其实现上，通常是对模式进行预处理；第二类方法对文本建立索引，这也是现在搜索引擎采用的方法。
本文仅讨论第一类方法。
文中的匹配算法都是基于这样一种方式来进行的：设想一个长度为m的窗口，首先窗口的左端和文本的左端对齐，把窗口中的字符与模式字符进行比较，这称为一趟比较，当这一趟比较完全匹配或者出现失配时，将窗口向右移动。
重复这个过程，直到窗口的右端到达了文本的右端。
这种方法我们通常叫sliding window。
对于穷举法来说，找到所有匹配位置需要的时间为O(mn)，基于对穷举法改进的结果，我们按照每一趟比较时的比较顺序，把这些算法分为以下四种：1从左到右：最自然的方式，也是我们的阅读顺序2从右到左：通常在实践中能产生最好的算法3特殊顺序：可以达到理论上的极限4任意顺序：这些算法跟比较顺序没关系（例如：穷举法）一些主要算法的简单介绍如下：从左到右采用哈希，可以很容易在大部分情况下避免二次比较，通过合理的假设，这种算法是线性时间复杂度的。
4种字符串匹配算法：BS朴素Rabin-karp（上）
4种字符串匹配算法：BS朴素Rabin-karp（上） 字符串的匹配的算法⼀直都是⽐较基础的算法，我们本科数据结构就学过了严蔚敏的KMP算法。
KMP算法应该是最⾼效的⼀种算法，但是确实稍微有点难理解。
所以打算，开这个博客，⼀步步的介绍4种匹配的算法。
也是《算法导论》上提到的。
我会把提到的四种算法全部⽤c/c++语⾔实现。
提供参考学习。
下图的表格，介绍了各个算法的处理时间和匹配时间。
希望我写的⽐较清楚。
如果不理解的，或者不对的，欢迎留⾔。
字符串匹配算法及其处理时间和匹配时间算法预处理时间匹配时间朴素算法0O((n-m+1)m)Rabin-Karp⊙(m)O((n-m+1)m)有限⾃动机算法O(m|∑|)⊙(n)KMP(Knuth-Morris-Pratt)⊙(m)⊙(n)====BF算法（朴素的模式匹配）====================================================== 介绍，上⾯这四个算法之前，和所有的教材⼀下，先介绍⼀下BF算法吧（暴⼒算法）。
它的思路很简单：把每个字符串都拿来做对⽐。
时间复杂度是O(m*n)。
我们不妨先看看代码：1char* strStr(const char* str,const char* target)2 {3if(!*target) return str;4char *p1 = (char *)str;56while(*p2)7 {8char *p1begin = p1;9char *p2 = (char *)target;10while(*p1 && *p2 && (*p1 == *p2))11 {12 p1++;13 p2++;14 }15if(!*p2) return p1begin;16 }17return NULL;18 }图解： 上图是我通过上⾯的代码画的⼀张偏于理解的图：第10⾏~14⾏是重点代码，为别进⾏++的操作，做对⽐，并且指针⼀直往后指。
字符串匹配算法
字符串匹配算法字符串匹配算法是计算机科学中重要的算法之一，用于在一个字符串中查找特定的子串。
在实际应用中，字符串匹配算法被广泛地应用于文本搜索、数据处理和模式识别等领域。
本文将介绍常见的字符串匹配算法，包括暴力匹配算法、KMP算法和Boyer-Moore算法。
1. 暴力匹配算法暴力匹配算法，也称为朴素匹配算法，是最简单的字符串匹配算法之一。
它的思想是从主串的第一个字符开始，逐个与子串进行比较，直到找到匹配或者遍历完整个主串。
具体实现时，可以使用两个指针分别指向主串和子串的第一个字符，然后循环比较两个指针所指向的字符。
如果字符相等，则继续比较下一个字符；如果字符不相等，则移动主串的指针到下一个位置，再重新开始比较。
暴力匹配算法的时间复杂度为O(mn)，其中m为主串长度，n为子串长度。
由于需要逐个比较字符，效率较低，尤其在处理大规模文本时。
2. KMP算法KMP算法（Knuth-Morris-Pratt算法）是一种高效的字符串匹配算法，可以在O(m+n)的时间复杂度内完成匹配。
该算法利用了子串内部的特点，避免了不必要的字符比较。
KMP算法的核心思想是构建一个部分匹配表，用于记录子串中每个位置的最长可匹配前缀和后缀的长度。
构建部分匹配表的过程可以在预处理阶段完成，时间复杂度为O(n)。
具体实现时，通过匹配过程中的前后指针的移动，根据部分匹配表和主串的字符进行比较。
如果字符匹配，则同时向后移动两个指针；如果字符不匹配，则根据部分匹配表的信息，移动子串的指针到指定位置，继续进行匹配。
KMP算法的优势在于避免了不必要的比较操作，提高了匹配效率。
它在文本搜索、模式识别等领域得到广泛应用。
3. Boyer-Moore算法Boyer-Moore算法是一种基于字符比较和移动的字符串匹配算法，具有较高的效率。
该算法先从子串的末尾开始与主串进行比较，然后根据比较结果选择合适的移动策略。
Boyer-Moore算法结合了两种不同的启发式策略，分别是坏字符规则和好后缀规则。
字符串匹配算法的原理和实现
字符串匹配算法的原理和实现随着互联网应用的广泛普及，各种搜索引擎、数据挖掘等技术越来越受到人们的关注。
在很多应用中，我们需要对文本进行匹配，即在一段文本中查找某个字符串是否出现过，或者查找多个字符串在文本中的位置。
这就需要用到字符串匹配算法，本文将介绍字符串匹配算法的原理和实现。
一、暴力匹配算法暴力匹配算法是最朴素的字符串匹配算法，也称为朴素算法或者蛮力算法。
它的原理非常简单，就是从文本的第一个字符开始依次比较，如果匹配失败，则将文本的指针后移一位，开始下一次比较。
具体实现可以用以下代码表示：```int search(string pattern, string text) {int n = text.length();int m = pattern.length();for(int i = 0; i < n - m + 1; i++) {int j;for(j = 0; j < m; j++) {if(pattern[j] != text[i+j]) {break;}}if(j == m) {return i;}}return -1;}```该算法的时间复杂度为O(nm)，其中n和m分别是文本和模式串的长度。
当模式串非常短时，该算法的效率还可以接受，但是当模式串很长时，算法效率就会变得很低，甚至比较文本中的每个字符都慢。
因此，我们需要更加快速和高效的算法来实现字符串匹配。
二、KMP算法KMP算法全称为Knuth-Morris-Pratt算法，它是一种比暴力匹配算法更加高效的字符串匹配算法，可以在O(n+m)的时间复杂度内完成字符串匹配。
KMP算法的基本思想是利用匹配失败后的信息来避免无谓的比较，具体过程如下：1.计算模式串的前缀函数（Prefix Function）。
前缀函数的定义是：对于模式串P的每个位置i（0 <= i < m），对应的前缀函数（Pi）表示模式串的第0个位置到第i个位置的最长的，既是最前面的，也是最后面的，与整个模式串P的某个前缀相等的后缀的长度。
KMP算法（字符串匹配）
KMP算法（字符串匹配）遇到字符串匹配问题,⼀般我就只能想到O(nm)的朴素算法...今天有这样⼀种算法,使得复杂度变为O(n),这就是KMP(烤馍⽚)算法粘⼀个模板题先:给出两个字符串s1和s2，其中s2为s1的⼦串，求出s2在s1中所有出现的位置。
然后本题还要求输出所有s2中字符的前缀数组,现在留下⼀个疑点,前缀数组(这是啥?),先往后看⾸先确定⼀点,就是在进⾏字符串匹配时,会是拿⼀个字符串与另⼀个字符串的⼀部分进⾏⽐较,那么我们有以下称呼(拿本题进⾏举例):s2叫做模式串,s1叫做母串我们先分析朴素算法的原理与弊端:朴素算法是将每⼀个母串字符拿出⽐较,⼀旦不符合就会放弃前⾯匹配的所有信息,重头再来,然⽽KMP不然,KMP就是⼀种"失败为成功之母"的算法,每次在匹配失败时利⽤前⾯信息进⾏更⾼效的匹配,具体的思想需要⽤到这个"前缀数组"那么这是啥呢?先考虑⼀个问题:如何利⽤失败信息,如果匹配失败,我们会放弃当前匹配,然⽽这起码证明前⾯的匹配都是成功的,也就是说,只要我找到模式串前⾯的能与⾃⼰(当前匹配失败之前的⼀个位置)匹配上的⼦串,那么⼀定也能与前⾯匹配,进⾏再次查找,⽽不⽤进⾏朴素算法暴⼒枚举,前缀数组就是保存这样的指针的数组,预处理⼤概是这样的:inline void init(){p[1]=0;int j=0;for(int i=1;i<m;i++){while(j>0&&b[j+1]!=b[i+1]) j=p[j];if(b[j+1]==b[i+1]) j++;p[i+1]=j;}}总体代码是这样的:#include<cstdio>#include<cstring>#include<string>using namespace std;char a[1000005];char b[1000005];int p[1000005];int n,m;inline void init(){p[1]=0;int j=0;for(int i=1;i<m;i++){while(j>0&&b[j+1]!=b[i+1]) j=p[j];if(b[j+1]==b[i+1]) j++;p[i+1]=j;}}inline void find(){int j=0;for(int i=0;i<n;i++){while(j>0&&a[i+1]!=b[j+1]) j=p[j];if(b[j+1]==a[i+1]) j++;if(j==m){printf("%d\n",i-m+2);j=p[j];}}}int main(){scanf("%s%s",a+1,b+1);n=strlen(a+1);m=strlen(b+1);init();find();for(int i=1;i<=m;i++)printf("%d ",p[i]);return 0;}为什么KMP主体与预处理这么像呢?因为预处理本⾝就是我\ \ \ \ 匹配\ \ \ \ \ 我⾃⼰最后就是输出前缀数组了Processing math: 100%。