算法------（13）KMP

已于 2024-03-02 16:17:49 修改
阅读量1k 收藏 21
点赞数 22
分类专栏： 算法基础课 文章标签： 算法 c++ 开发语言
于 2024-03-01 09:07:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41593360/article/details/136293421
版权

例题：（1）AcWing 831. KMP字符串 

        。。其实写完也不太理解。。随便写点吧

        KMP就是求next数组和运用next的数组的过程。相比传统匹配模式一次更新一单位距离的慢速方法，next数组可以让下表字符串一次更新n - next【n】个距离，加快了匹配速度。next【i】记录的是某字符串的前i个字符中前缀与后缀最长的匹配长度。

        对于模版中的j，我的理解是已经匹配了j个字符，因此next【i】还可以理解为对于已经匹配了i个字符的字符串来说，假如后续匹配不成立，则该字符串至少还有next【i】个字符是匹配的。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e5+10,M = 1e6+10;
int ne[N];
int n,m;
char p[N],s[M];
int main()
{
    cin >> n >> p+1 >> m >> s+1;
    ne[1] = 0;
    for(int i = 2,j = 0;i<=n;i++){
        while(j && p[i] != p[j+1]) j = ne[j];
        if(p[i] == p[j+1]) j++;
        ne[i] = j;
    }
    for(int i = 1,j = 0;i<=m;i++){
        while(j && s[i] != p[j+1]) j = ne[j];
        if(s[i] == p[j+1]) j++;
        if(j == n){
            printf("%d ",i - n);
            j = ne[j];
        }
    }
    return 0;
}

练习：（1） Leetcode 459 重复的子字符串

        。。。好难啊！！！！这是easy？？？

        我们可以证明 非空字符串s可由一个子串重复多次构成 当且仅当 把两个s连接起来且去掉前面后面的各一个字符，其中仍然存在s作为新字符串的子串。 

        从前往后推很显然，从后往前推需要一定证明。显然我不会，摘抄一下Leetcode的答案。

（2） P1470 [USACO2.3] 最长前缀 Longest Prefix

         其实与KMP无关但不知道为什么加了个KMP的标签。。。没做出来。。

        跟之前做过的一些题目有些类似。dp[i]的含义为[0,i-1]个字母可以分解，因此我们枚举每一个j，只要满足[0,j-1]时能分解且[j,i-1]也在P集合内即可。对于查询[j,i-1]，由于题目说P集合内字符串长度<=10，因此我们对每一个i只需要枚举10个j即可，这样大大优化了时间。

        以及不知为什么本地跑不了。。。（问了朋友可能是文件输入输出的关系）

#include <iostream>
#include <unordered_set>
#include <string>
using namespace std;
const int N = 2e5+10;
bool dp[N];
unordered_set<string> res;
int main(int argc, char** argv) {
	string ss;
	while(cin >> ss){
		if(ss == ".") break;
		res.insert(ss);
	}
	string ans = "";
	while(cin >> ss){
		ans += ss;
	}
	dp[0] = true;
	int n = ans.length();
	for(int i = 1;i<=n;i++){
		for(int j = i;j>=max(i-10,0);j--){
			if(dp[j] && (res.find(ans.substr(j,i-j))!=res.end())){
				dp[i] = true;
				continue;
			}
		}
	}
	for(int i = n;i>=0;i--){
		if(dp[i]){
			printf("%d",i);
			break;
		}
	}
	return 0;
}

(3) P3435 [POI2006] OKR-Periods of Words

        太难了太难了。。。

        一个前缀的最大周期长度就是其长度减去其最小匹配长度，也就是其最短的共同前后缀的长度。 next数组求的是最大匹配长度，而不断递归求next数组得到的正是不为0的最小匹配长度。递归处理时可以把next数组直接更新为求得的最短长度，这样求取速度会更快。

#include <iostream>
using namespace std;
typedef long long ll;
const int N = 1000010;
char str[N];
int ne[N];
int main(int argc, char** argv) {
	int n;
	scanf("%d%s",&n,str+1);
	ne[1] = 0;
	for(int i = 2,j = 0;i<=n;i++){
		while(j && str[i] != str[j+1]) j = ne[j];
		if(str[i] == str[j+1]) j++;
		ne[i] = j;
	}
	ll ans = 0;
	for(int i = 2,j = 2;i<=n;i++,j = i){
		while(ne[j]) j = ne[j];
		if(ne[i]) ne[i] = j;
		ans += i-j;
	}
	printf("%lld",ans);
	return 0;
}

(4) Leetcode 面试题17.17 多次搜索

          对每一个smalls内的字符串求next数组，然后与big字符串进行kmp匹配。注意kmp的i返回的是字符串的最后一个字符下标。以及每一次匹配都要先清空next数组。

class Solution {
    int ne[1010];
    vector<vector<int>> res;
public:
    void next(string str){
        char x[1010];
        int n = str.length();
        for(int i = 1;i<=n;i++) x[i] = str[i-1]; 
        for(int i = 2,j = 0;i<=n;i++){
            while(j && x[i] != x[j+1]) j = ne[j];
            if(x[i] == x[j+1]) j++;
            ne[i] = j;
        }
    }
    vector<int> get(string a,string b){
        char x[1010],y[1010];
        int n = a.length(),m = b.length();
        for(int i = 1;i<=n;i++) x[i] = a[i-1];
        for(int i = 1;i<=m;i++) y[i] = b[i-1];
        vector<int> ans;
        for(int i = 1,j = 0;i<=n;i++){
            while(j && x[i] != y[j+1]) j = ne[j];
            if(x[i] == y[j+1]) j++;
            if(j == m){
                ans.push_back(i-m);
                j = ne[j];
            }
        }
        return ans;
    }
    vector<vector<int>> multiSearch(string big, vector<string>& smalls) {
        int n = smalls.size();
        for(int i = 0;i<n;i++){
            if(smalls[i] == ""){
                res.push_back({});
                continue;
            }
            memset(ne,0,sizeof(ne));
            next(smalls[i]);
            res.push_back(get(big,smalls[i]));
        }
        return res;
    }
};

(5) Leetcode 3036 匹配模式数组的子数组数目

        做出来的第一个Hard题！虽然完全不是自己想出来的！！。。。

        把nums转化为跟pattern数组一样模式的长度为n-1的数组，此题便转化为求nums数组中有几个子数组为pattern数组，这样一来直接用kmp匹配即可。转化这一步还是挺难想到的。

class Solution {
    int x[1000100],y[1000100],ne[1000100];// x,y 1-n
public:
    int countMatchingSubarrays(vector<int>& nums, vector<int>& pattern) {
       int n = nums.size()-1,m = pattern.size();
       for(int i = 0;i<n;i++){
           if(nums[i] < nums[i+1]) x[i+1] = 1;
           else if(nums[i] == nums[i+1]) x[i+1] = 0;
           else x[i+1] = -1;
       } 
       for(int i = 1;i<=m;i++){
           y[i] = pattern[i-1];
       } 
       for(int i = 2,j = 0;i<=m;i++){
           while(j && y[i] != y[j+1]) j = ne[j];
           if(y[i] == y[j+1]) j++;
           ne[i] = j; 
       }
       int ans = 0;
       for(int i = 1,j = 0;i<=n;i++){
           while(j && x[i] != y[j+1]) j = ne[j];
           if(x[i] == y[j+1]) j++;
           if(j == m){
               ans++;
               j = ne[j];
           }
       }
       return ans;
    }
};

(6) Leetcode 3037.在无限流中寻找模式

         做出的第二道Hard题，想出了匹配方式但是在优化上栽了！不过还算可以！

        由于是无限流，所以每次更新就匹配一次肯定会超时，因此用vector处理，由于next数组是确定的，因此每次不用从头匹配，只需要一个一个进行匹配即可。

/**
 * Definition for an infinite stream.
 * class InfiniteStream {
 * public:
 *     InfiniteStream(vector<int> bits);
 *     int next();
 * };
 */
class Solution {
    int ne[110000];
    vector<int> p,q;
public:
    int findPattern(InfiniteStream* stream, vector<int>& pattern) {
        p.push_back(0);
        q.push_back(0);
        int r = 0,m = pattern.size();
        for(int i = 1;i<=m;i++){
            q.push_back(pattern[i-1]);
        }
        for(int i = 2,j = 0;i<=m;i++){
            while(j && q[i] != q[j+1]) j = ne[j];
            if(q[i] == q[j+1]) j++;
            ne[i] = j;
        }
        int i = 1,j = 0;
        while(1){
            p.push_back(stream->next());
            while(j && p[i] != q[j+1]) j = ne[j];
            if(p[i] == q[j+1]) j++;
            if(j == m) return i-m;
            i++;
        }
    }
};

(7) Leetcode 3008.找出数组中的美丽下标

         Hard被卡了。。

        匹配用kmp，后续查找时的优化思路为对a中每一个下标数组，在b的下标数组二分查找第一个大于等于它的数，如果这个数存在则返回其与a中对应下标的差，和其前面一个与a中对应下标的差，如果满足则返回。

class Solution {
    char p[500100],q[500100],r[500010];
    int ne1[500100],ne2[500100];
public:
    vector<int> beautifulIndices(string s, string a, string b, int k) {
        vector<int> res;
        vector<int> res1,res2;
        int n = a.length(),m = b.length(),o = s.length();
        for(int i = 1;i<=n;i++) p[i] = a[i-1];
        for(int i = 1;i<=m;i++) q[i] = b[i-1];
        for(int i = 1;i<=o;i++) r[i] = s[i-1];
        for(int i = 2,j = 0;i<=n;i++){
            while(j && p[i] != p[j+1]) j = ne1[j]; 
            if(p[i] == p[j+1]) j++; 
            ne1[i] = j;
        }
        for(int i = 2,j = 0;i<=m;i++){
            while(j && q[i] != q[j+1]) j = ne2[j]; 
            if(q[i] == q[j+1]) j++; 
            ne2[i] = j;
        }
        for(int i = 1,j = 0;i<=o;i++){
            while(j && r[i] != p[j+1]) j = ne1[j]; 
            if(r[i] == p[j+1]) j++; 
            if(j == n){
                res1.push_back(i-n);
                j = ne1[j];
            } 
        }
        for(int i = 1,j = 0;i<=o;i++){
            while(j && r[i] != q[j+1]) j = ne2[j]; 
            if(r[i] == q[j+1]) j++; 
            if(j == m){
                res2.push_back(i-m);
                j = ne2[j];
            } 
        }
        int c1 = res1.size(),c2 = res2.size();
        for (int i: res1) {
            auto it = lower_bound(res2.begin(), res2.end(), i);
            if (it != res2.end() && *it - i <= k ||
                it != res2.begin() && i - *--it <= k) {
                res.push_back(i);
            }
        }
        return res;
    }
};

（8） Leetcode 758.字符串中的加粗单词

         没啥难的。。挑错时间太长所以贴上来羞辱一下自己。。

        kmp加合并区间。首先先对words每一个字符串求next然后与s进行匹配，求出每一个需要加粗的区间。由于这些区间存在重叠而导致标签数过多，因此要求最小的标签数就需要合并区间。

class Solution {
    int ne[15];
    typedef pair<int,int> pii;
public:
    vector<pii> segs;
    vector<char> init(string x){
        vector<char> p;
        p.push_back(0);
        int n = x.length();
        for(int i = 1;i<=n;i++) p.push_back(x[i-1]);
        return p;
    }
    void next(vector<char> x){
        int n = x.size()-1;
        for(int i = 2,j = 0;i<=n;i++){
            while(j && x[i] != x[j+1]) j = ne[j];
            if(x[i] == x[j+1]) j++;
            ne[i] = j;
        }
    }
    void kmp(vector<char> x,vector<char> y){
        int n = x.size() - 1,m = y.size() - 1;
        for(int i = 1,j = 0;i<=n;i++){
            while(j && x[i] != y[j+1]) j = ne[j];
            if(x[i] == y[j+1]) j++;
            if(j == m){
                segs.push_back({i-m,i-1});
                j = ne[j];
            }
        }
    }
    string boldWords(vector<string>& words, string s) {
        int n = words.size();
        auto p = init(s);
        for(int i = 0;i<n;i++){
            memset(ne,0,sizeof(ne));
            auto q = init(words[i]);
            next(q);
            kmp(p,q);
        }
        vector<pii> res;
        sort(segs.begin(),segs.end());
        int fs = -2e9,ed = -2e9;
        for(auto seg:segs){
            int l = seg.first,r = seg.second;
            if(ed+1<l){
                if(fs!=-2e9) res.push_back({fs,ed});
                fs = l;
                ed = r;
            }
            else{
                ed = max(ed,r);
            }
        }
        if(fs!=-2e9) res.push_back({fs,ed});
        int flag = 0;
        string ans = "";
        for(auto seg:res){
            int l = seg.first,r = seg.second;
            ans += s.substr(flag,l - flag);
            ans += "<b>";
            ans += s.substr(l,r-l+1);
            ans += "</b>";
            flag = r+1;
        }
        n = s.length();
        cout <<flag;
        if(flag < n ) ans += s.substr(flag,n-flag);
        return ans;
    }
};

 （9） P2375 [NOI2014] 动物园           很难，虽然写出来了但并不完全理解。。

           在求取next数组的过程中，我们可以求取每一个i所对应的有相同的前后缀的所有子串的个数，然后再进行一次匹配，当我们递归到子串长度不重叠时，就可以得到该长度下所有的不重叠的子串有相同前后缀的个数。

#include <iostream>
#include <cstring>
using namespace std; 
const int N = 1e6+10,mod = 1e9+7;
typedef long long ll;
char p[N];
int ne[N],nums[N];
int main(int argc, char** argv) {
	int t;
	scanf("%d",&t);
	while(t--){
		scanf("%s",p+1);
		int n = strlen(p+1);
		nums[1] = 1;
		for(int i = 2,j = 0;i<=n;i++){
			while(j && p[i] != p[j+1]) j = ne[j];
			if(p[i] == p[j+1]) j++;
			ne[i] = j;
			nums[i] = nums[ne[i]] + 1;
		}
		ll res = 1;
		for(int i = 1,j = 0;i<=n;i++){
			while(j && p[i]!=p[j+1]) j = ne[j];
			if(p[i] == p[j+1]) j++;
			while(j * 2 > i) j = ne[j]; 
			res = res * (nums[j] + 1) % mod;
		}
		printf("%lld\n",res);
		for(int i = 1;i<=n;i++){
			ne[i] = 0;
			nums[i] = 0;
		} 
	}
	return 0;
}

 

        

FancySuMMer11
关注
  • 22
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-算法-KMP
weixin_45532984的博客
05-19 897
一. KMP算法的介绍 1. 常规暴力解法 2. KMP的加速过程 二. KMP算法的使用 1. next数组的使用 2. next数组从何而来 三. KMP算法的实战 四. KMP算法的证明 假设在k位置有一个区间使得这部分和str2相等，那么 ...
KMP算法-严蔚敏数据结构
weixin_43957315的博客
04-08 676
KMP 算法是 D.E.Knuth、J,H,Morris 和 V.R.Pratt 三位神人共同提出的，称之为 Knuth-Morria-Pratt 算法，简称 KMP 算法。该算法相对于 Brute-Force（暴力）算法有比较大的改进，主要是消除了主串指针的回溯，从而使算法效率有了某种程度的提高。 算法具体实现以及相关说明建议直接B站搜索-严蔚敏数据结构。讲解详细，通俗易懂。 ...
KMP算法---C语言
精致的灰的博客
11-07 3068
文章目录字符串匹配BF算法代码实现BF算法的时间复杂度KMP算法求next数组next数组的代码实现next数组的优化KMP算法的代码实现KMP算法的时间复杂度 字符串匹配 BF算法和KMP算法都主要是为了解决字符串匹配问题，即在主串（又叫文本串）（ primary string，简写为s）中寻找子串（又叫模式串） ( pattern string，简写为p)，其功能类似于strstr函数，与之不同的是strstr(str1,str2)返回值是一个指针，即返回 str1字符串从str2第一次出现的位置；否
数据结构- KMP 算法
每天进步一点点！
11-27 1405
KMP 算法
Java 算法篇-深入了解 BF 与 KMP 算法
小扳手
04-19 3717
KMP 是一种高效的字符串匹配算法，用于在一个主串中查找一个模式串的出现位置。KMP 算法的核心思想是利用已匹配的信息来尽量减少不必要的比较，从而提高匹配效率。KMP 算法的时间复杂度为 O(m+n)，其中 m 是主串的长度，n 是模式串的长度。相比于 BF 暴力匹配算法，KMP 算法具有更高的效率，尤其在处理大规模文本匹配时表现优异。简单来说，KMP 算法比 BF 算法有更高的效率，是 BF 一个升级的算法。
字符串匹配算法--KMP算法--BM算法
余的日常学习
05-24 1016
字符串匹配算法--KMP算法--BM算法
算法篇 --- KMP算法
weixin_60569662的博客
02-15 769
next[i]: 部分匹配表的产生 部分匹配表的产生和前缀和后缀有关系 基本概念："前缀"和"后缀"。 "前缀"指除了最后一个字符以外，一个字符串的全部头部组合； "后缀"指除了第一个字符以外，一个字符串的全部尾部组合 部分匹配值"就是"前缀"和"后缀"的最长的共有元素的长度。 以"ABCDABD"为例： A AB ABC ABCD ABCDA ABCDAB BCDABD CDABD DABD ABD BD D 前缀： A AB ABC ABCD
DS串应用--KMP算法
Galaxy_Su的博客
12-25 427
题目描述 学习KMP算法，给出主串和模式串，求模式串在主串的位置 算法框架如下，仅供参考 输入 第一个输入t，表示有t个实例 第二行输入第1个实例的主串，第三行输入第1个实例的模式串 以此类推 输出 第一行输出第1个实例的模式串的next值 第二行输出第1个实例的匹配位置，位置从1开始计算，如果匹配成功输出位置，匹配失败输出0 以此类推 样例输入 3 qwertyuiop tyu aabbccdd ccc aaaabababac abac 样例输出 -1 0
算法-KMP算法
q2nAmor
07-21 1143
KMP算法字符串匹配是计算机的基本任务之一。问题：给定一个主字符串（以 S 代替）和模式串（以 P 代替），要求找出 P 在 S 中出现的位置，即串的模式匹配问题。今天来介绍解决这一问题的常用算法之一，Knuth-Morris-Pratt 算法（简称 KMP），这个算法是由Knuth、Morris、Pratt共同提出。 时间复杂度：O（m+n） （n为文本串T的长度） 空间复杂度：O（m） （m为模
字符串匹配算法 - KMP算法
特立独行的博客
03-19 706
KMP算法是一种字符串匹配算法，用于在一个字符串中查找另一个字符串出现的位置。
c语言中使用BF-KMP算法实例
09-04
主要介绍了c语言中使用BF-KMP算法，大家参考使用
BF--KMP算法
03-29
可以用于筛选字符串，用于网站搜索中，每一个文件都是一个字符串，利用BF--KMP算法可以筛选符合条件的条目
java 中模式匹配算法-KMP算法实例详解
08-30
主要介绍了java 中模式匹配算法-KMP算法实例详解的相关资料,需要的朋友可以参考下
数据结构-KMP算法原理
04-10
对KMP算法进行具体的分析，生动图解，保证能够一看就懂
13.Brute-Force算法与KMP算法.ppt
03-02
13.Brute-Force算法与KMP算法.ppt
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 544
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
算法训练营day41
stmfresher的博客
05-27 386
动态规划理论基础（主要就是确定动态规划的几个步骤）
Java多线程（04）—— 保证线程安全的方法与线程安全的集合类
最新发布
2201_75456895的博客
05-30 1185
其含义为：CAS(M, A, B);M 表示内存，A 和 B 分别表示一个寄存器；如果 M 的值和 A 的值相同，则把 M 和 B 的值交换，如果不同，则无事发生；因为，因此可以基于 CAS 指令，不进行加锁，来编写线程安全代码；CAS 指令操作经过操作系统，JVM 的层层封装，最后 Java 标准库，提供了一些工具类，其中最主要工具类就是由于原子类内部用的是 CAS 实现，所以性能要比加锁实现高很多；在包下；
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 730
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
PTA6-1 KMP算法
12-08
KMP算法是一种字符串匹配算法，用于在一个主串S内查找一个子串T的出现位置。KMP算法的核心是next数组，next数组记录了模式串T中每个前缀的最长相等前后缀的长度。在匹配过程中，当主串S的某个字符与模式串T的某个字符不匹配时，可以利用next数组中记录的信息，将模式串T向右移动一定的位数，从而避免了暴力匹配的重复比较。 以下是PTA6-1 KMP算法的代码实现： ```c++ void get_nextval(char T[], int next[]) { next[1] = 0; for(int i = 2; i <= T[0]; i++) { int x = next[i - 1]; while(x && T[i] != T[x + 1]) { x = next[x]; } if(T[i] == T[x + 1]) { ++x; } next[i] = x; } } int Index_KMP(char S[], char T[], int pos, int next[]) { int x = 0; for(int i = pos; i <= S[0]; i++) { if(S[i] == T[x + 1]) { ++x; if(x == T[0]) { return i - T[0] + 1; } continue; } while(x && T[x + 1] != S[i]) { x = next[x]; } if(T[x + 1] == S[i]) { ++x; } } return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值