初探字符串匹配 题目整理

最新推荐文章于 2024-01-25 22:58:59 发布
最新推荐文章于 2024-01-25 22:58:59 发布
阅读量309 收藏 1
点赞数 2
分类专栏： 字符串 文章标签： 字符串 kmp manacher
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qcwlmqy/article/details/98250108
版权

初探字符串匹配

K M P KMP KMP算法

模式串匹配，就是给定一个需要处理的文本串（理论上应该很长）和一个需要在文本串中搜索的模式串（理论上长度应该远小于文本串），查询在该文本串中，给出的模式串的出现有无、次数、位置等。

K M P KMP KMP 的精髓在于，对于每次失配之后，我都不会从头重新开始枚举，而是根据我已经得知的数据，从某个特定的位置开始匹配；
而对于模式串的每一位，都有唯一的“特定变化位置”，这个在失配之后的特定变化位置可以帮助我们利用已有的数据不用从头匹配，从而节约时间。

next数组处理

用 n e x t next next 数组记录到它为止的模式串前缀的真前缀和真后缀最大相同的位置

然而这个地方我们要考虑“模式串前缀的前缀和后缀最大相同的位置”原因在于，我们需要用到next数组换位时，当且仅当未完全匹配
我们的操作只是针对模式串的前缀
毕竟是失配函数，失配之后只有可能是某个部分前缀需要“快速移动”

KMP 中前后缀不包括模式串本身,即只考虑真前缀和真后缀,因为模式串本身需要整体考虑，当且仅当匹配完整个串之后

对自己匹配即可

int Next[maxm];
void GetNext(int len) {
	int k = 0;
	Next[0] = Next[1] = 0;	//第一个直接跳到1
	for (int i = 2; i <= len; i++) {
		while (k && p[i] != p[k + 1])k = Next[k];	//找到可匹配的位置
		if (p[k + 1] == p[i]) k++;
		Next[i] = k;		//记录匹配的位置
	}
}
kmp
int kmp(int n, int m) {
	int i, j = 0;
	for (int i = 1; i <= n; i++) {
		while (j && s[i] != p[j + 1])j = Next[j];
		if (p[j + 1] == s[i]) j++;
		if (j == m) {
			printf("%d\n", i - m + 1);
			j = Next[j];
		}
	}
}

HDU1711 Number Sequence

题意：
两个数组匹配
思路：
板子题+1

POJ3461 Oulipo

题意：
字符串匹配
思路：
板子题+2

n e x t next next数组的应用

前缀的 前缀和后缀的最长公共长度

next代表前缀的 前缀和后缀的最长公共长度

HDU2594 Simpsons’ Hidden Talents

题意： s 1 s1 s1的前缀和 s 2 s2 s2的后缀的最长公共长度
思路：
合并 s 1 s1 s1和 s 2 s2 s2
求 s 1 + s 2 s1+s2 s1+s2的next数组
求最后一个字符的next位置
注意next位置要小于len1或len2

子串的循环

  • 字符编号从0开始，那么 i f ( i if(i%(i-next[i])==0) if(i，则i前面的串为一个轮回串，其中轮回子串出现 i / ( i − n e x t [ i ] ) i/(i-next[i]) i/(i−next[i])次。
  • next数组往前跳的步长是一样的
  • 周期性字符串⇔ n m o d &ThinSpace;&ThinSpace; ( n − n e x t [ n ] ) = 0 n \mod (n−next[n]) =0 nmod(n−next[n])=0 && n e x t [ n ] ! = 0 next[n] != 0 next[n]!=0，循环节长度是 n − n e x t [ n ] n−next[n] n−next[n]

HDU1358 Period

题意：求循环前缀
思路：板子题+1

POJ2406 Power Strings

题意：求字符串是否有一个字符串循环得到
思路：板子题+2

m a n a c h e r manacher manacher算法

  • 对于一个回文串，有且仅有一个对称中心。且叫它回文对称中心。
  • 在一个回文串内，任选一段区间 X ，一定存在关于"回文对称中心"对称的一个区间，且把这个区间叫做关于区间_X_的对称区间。
  • 区间和对称区间一定全等
  • 若一个区间的对称区间是回文串，这个区间必定是一个回文串。在大的回文串内，它们回文半径相等
  • 然而我们通过确定关系预先得到的回文半径，它的数值，必定小于等于这个位置真实的回文串半径

记录这些数据到p数组。同时记录一个mid，一个r，分别代表 已经确定的右侧最靠右的回文串的对称中心和右边界。
若当前扫描到的位置为i，若mid<=i<=r，则我们可以找到它的一个对称点
这个点的位置是多少？是 m i d × 2 − i mid×2-i mid×2−i

  • 若扩展一个新的关于该字符的回文半径，可以先确定一部分P[i]。
  • 我们能确定的范围，其右侧不得大于r，即：p[i]+i<=r 移项得：p[i] <= r-i
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 11000005;
char s[maxn << 1];
int p[maxn << 1], cnt = 1;
void Read() {
	char ch = getchar();
	s[0] = '~'; s[1] = '|';
	while (ch<'a' || ch>'z')
		ch = getchar();
	while (ch >= 'a' && ch <= 'z') {
		s[++cnt] = ch;
		s[++cnt] = '|';
		ch = getchar();
	}
	return;
}
int main() {
	int ans, r, mid;
	Read();
	ans = r = mid = 0;
	for (int i = 1; i <= cnt; i++) {
		if (i < r) p[i] = min(p[(mid << 1) - i], r - i);
		else p[i] = 1;
		while (s[i - p[i]] == s[i + p[i]])
			p[i]++;
		if (p[i] + i > r) r = p[i] + i, mid = i;
		ans = max(ans, p[i]);
	}
	printf("%d\n", ans - 1);
}

HDU3068 最长回文

题意：求最长回文串长度
思路：板子题+1

BZOJ2342 双倍回文

题意：回文子串，前半串为回文串，后半串也是回文串
思路：
先跑一遍板子，当加入新的子串，检测前半串是否为回文串即可
由于回文串是四的倍数，回文串的对称中心为 ∣ | ∣,前半串的对称中心也为 ∣ | ∣

if (p[i] + i > r) {
			if (s[i] == '|') {
				int limit = max(r, i + 4);
				for (int j = i + (p[i] - 1) / 4 * 4; j >= limit; j -= 4) {
					if (p[i - (j - i) / 2] >= (j - i) / 2) {
						ans = max(ans, j - i);
						break;
					}
				}
			}
			r = p[i] + i, mid = i;
		}

例题代码

Number Sequence

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
#pragma warning (disable:4996)
const int maxn = 1000005;
const int maxm = 10005;
int s[maxn], p[maxm];
int Next[maxm];
void GetNext(int len) {
	int k = 0;
	Next[0] = Next[1] = 0;
	for (int i = 2; i <= len; i++) {
		while (k && p[i] != p[k + 1])k = Next[k];
		if (p[k + 1] == p[i]) k++;
		Next[i] = k;
	}
}
int kmp(int n, int m) {
	int i, j = 0;
	for (int i = 1; i <= n; i++) {
		while (j && s[i] != p[j + 1])j = Next[j];
		if (p[j + 1] == s[i]) j++;
		if (j == m) {
			return i - m + 1;
			//j = Next[j];
		}
	}
	return -1;
}
int main() {
	int t, n, m; scanf("%d", &t);
	while (t--) {
		scanf("%d%d", &n, &m);
		for (int i = 1; i <= n; i++)scanf("%d", &s[i]);
		for (int i = 1; i <= m; i++)scanf("%d", &p[i]);
		GetNext(m);
		printf("%d\n", kmp(n, m));
	}
}

Oulipo

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
#pragma warning (disable:4996)
const int maxn = 1000005;
const int maxm = 1000005;
char s[maxn], p[maxm];
int Next[maxm];
void GetNext(int len) {
	int k = 0;
	Next[0] = Next[1] = 0;
	for (int i = 2; i <= len; i++) {
		while (k && p[i] != p[k + 1])k = Next[k];
		if (p[k + 1] == p[i]) k++;
		Next[i] = k;
	}
}
int kmp(int n, int m) {
	int i, j = 0, cnt = 0;
	for (int i = 1; i <= n; i++) {
		while (j && s[i] != p[j + 1])j = Next[j];
		if (p[j + 1] == s[i]) j++;
		if (j == m) {
			cnt++;
			j = Next[j];
		}
	}
	return cnt;
}
int main() {
	int t; scanf("%d", &t);
	while (t--) {
		scanf("%s%s", p + 1, s + 1);
		int n = strlen(s + 1), m = strlen(p + 1);
		GetNext(m);
		printf("%d\n", kmp(n, m));
	}
}

Simpsons’ Hidden Talents

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
#pragma warning (disable:4996)
const int maxn = 100005;
const int maxm = 100005;
char s[maxn], p[maxm];
int Next[maxm];
void GetNext(int len) {
	int k = 0;
	Next[0] = Next[1] = 0;
	for (int i = 2; i <= len; i++) {
		while (k && s[i] != s[k + 1])k = Next[k];
		if (s[k + 1] == s[i]) k++;
		Next[i] = k;
	}
}
int main() {
	while (~scanf("%s%s", s + 1, p + 1)) {
		int n = strlen(s + 1);
		int m = strlen(p + 1);
		strcat(s + 1, p + 1);
		GetNext(n + m);
		int k = n + m;
		while (k > n || k > m)
			k = Next[k];
		if (k == 0) {
			printf("0\n");
			continue;
		}
		s[k + 1] = 0;
		printf("%s %d\n", s + 1, k);
	}
}

Period

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
#pragma warning (disable:4996)
const int maxm = 1000005;
char p[maxm];
int Next[maxm];
void GetNext(int len) {
	int k = 0;
	Next[0] = Next[1] = 0;
	for (int i = 2; i <= len; i++) {
		while (k && p[i] != p[k + 1])k = Next[k];
		if (p[k + 1] == p[i]) k++;
		Next[i] = k;
	}
}
int main() {
	int m, g = 0;
	while (~scanf("%d", &m)&&m) {
		scanf("%s", p + 1);
		GetNext(m);
		printf("Test case #%d\n", ++g);
		for (int i = 2; i <= m; i++) {
			if (Next[i]&&i % (i - Next[i]) == 0)
				printf("%d %d\n", i, i / (i - Next[i]));
		}
		printf("\n");
	}
}

Power Strings

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
#pragma warning (disable:4996)
const int maxm = 1000005;
char p[maxm];
int Next[maxm];
void GetNext(int len) {
	int k = 0;
	Next[0] = Next[1] = 0;
	for (int i = 2; i <= len; i++) {
		while (k && p[i] != p[k + 1])k = Next[k];
		if (p[k + 1] == p[i]) k++;
		Next[i] = k;
	}
}
int main() {
	int m;
	while (~scanf("%s", p + 1) && p[1] != '.') {
		m = strlen(p + 1);
		GetNext(m);
		if (m % (m - Next[m]) == 0)printf("%d\n", m / (m - Next[m]));
		else printf("1\n");
	}
}

最长回文

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 11000005;
char s[maxn << 1];
int p[maxn << 1], cnt = 1;
void Read(char ch) {
	s[0] = '~'; s[1] = '|';
	while (ch<'a' || ch>'z')
		ch = getchar();
	while (ch >= 'a' && ch <= 'z') {
		s[++cnt] = ch;
		s[++cnt] = '|';
		ch = getchar();
	}
	return;
}
int main() {
	int ans, r, mid; char ch;
	while ((ch = getchar()) != EOF) {
		cnt = 1;
		Read(ch);
		ans = r = mid = 0;
		for (int i = 1; i <= cnt; i++) {
			if (i < r) p[i] = min(p[(mid << 1) - i], r - i);
			else p[i] = 1;
			while (s[i - p[i]] == s[i + p[i]])
				p[i]++;
			if (p[i] + i > r) r = p[i] + i, mid = i;
			ans = max(ans, p[i]);
		}
		printf("%d\n", ans - 1);
	}
}

双倍回文

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#pragma warning (disable:4996)
const int maxn = 11000005;
char s[maxn << 1];
int p[maxn << 1], cnt = 1;
void Read() {
	char ch = getchar();
	s[0] = '~'; s[1] = '|';
	while (ch<'a' || ch>'z')
		ch = getchar();
	while (ch >= 'a' && ch <= 'z') {
		s[++cnt] = ch;
		s[++cnt] = '|';
		ch = getchar();
	}
	return;
}
int main() {
	int ans, r, mid, n;
	scanf("%d", &n);
	Read();
	ans = r = mid = 0;
	for (int i = 1; i <= cnt; i++) {
		if (i < r) p[i] = min(p[(mid << 1) - i], r - i);
		else p[i] = 1;
		while (s[i - p[i]] == s[i + p[i]])
			p[i]++;
		if (p[i] + i > r) {
			if (s[i] == '|') {
				int limit = max(r, i + 4);
				for (int j = i + (p[i] - 1) / 4 * 4; j >= limit; j -= 4) {
					if (p[i - (j - i) / 2] >= (j - i) / 2) {
						ans = max(ans, j - i);
						break;
					}
				}
			}
			r = p[i] + i, mid = i;
		}
	}
	printf("%d\n", ans);
}
qcwlmqy
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode面试刷题技巧- 字符串匹配习题集（一）
wenyusuran的专栏
05-23 846
字符串匹配常用算法 1 暴力匹配 思想：逐一匹配 时间复杂度： 实现： #----------------------------------------- #https://www.geeksforgeeks.org/naive-algorithm-for-pattern-searching/?ref=lbp deffind_brute_force(pat,txt): """在txt中找到pat的匹配项，并返回txt匹配时第一个索引""" m,n=len(...
字符串模糊匹配初探
12-11
而字符串模糊匹配初探-Excel+VBA实现.doc可能详细解释了如何通过VBA编程实现模糊匹配，并提供了具体的代码示例。 总的来说，理解并掌握字符串模糊匹配在Excel和VBA中的应用，对于提升数据处理和分析的效率至关重要...
[经典面试题][腾讯]字符串匹配
SmartSi
02-14 234
题目 假设两个字符串中所含有的字符和个数都相同我们就叫这两个字符串匹配，比如：abcda和adabc,由于出现的字符个数都是相同，只是顺序不同，所以这两个字符串是匹配的。要求高效。 思路 假定字符串中都是ASCII字符。用一个数组来计数，前者加，后者减，全部为0则匹配。 代码 /*--------------------------------------------- * 日期：...
字符串匹配经典题目——KMP算法（Leetcode题解-Python语言）
自动化研究生在读，此博客记录了我的学习与刷题经验，欢迎大家阅读交流
03-16 2340
28. 实现 strStr() strStr(haystack: str, needle: str) 的作用就是在 haystack 字符串（长度为 n）中找出 needle 字符串（长度为 m）出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 ；如果 needle 是空字符串，则返回 0。 Python 中对应的写法是 haystack.find(needle)。 如果让我们自己实现这个函数，最简单的思路就是对 haystack 字符串中每个字符的位置，都用 needle 字符串试着去匹配
面试题---->字符串匹配
weixin_33974433的博客
09-13 190
题目：假设两个字符串中所含有的字符和个数都相同我们就叫这两个字符串匹配，比如：abcda和adabc,由于出现的字符个数都是相同，只是顺序不同，所以这两个字符串是匹配的。给出判断两个字符串是否匹配的函数，要求高效！ 方法思想:假定字符串中都是ASCII字符。如下用一个数组来计数，字符串中ascii码对应的位置数组值，前者加，后者减，全部为0则匹配。 import junit.framework...
串结构练习——字符串匹配
空白页
02-10 745
串结构练习——字符串匹配 Time Limit: 1000MS Memory limit: 65536K 题目描述   给定两个字符串string1和string2，判断string2是否为string1的子串。   输入  输入包含多组数据，每组测试数据包含两行，第一行代表string1，第二行代表string2，string1和string2
Spark初探
02-26
Spark基于内存计算，提高了在大数据环境下数据处理的实时性，同时保证了高容错性和高可伸缩性，允许用户将Spark部署在大量廉价硬件之上，形成集群。...Spark是基于内存计算的大数据并行计算框架。Spark基于内存计算，...
几何图形识别软件初探.pdf
11-19
几何图形识别软件初探.pdf
算法之字符串匹配问题（Java练习题）
月夜的博客
07-12 3098
字符串匹配问题 【题目】 给定字符串str，其中绝对不含有字符'.'和'*'。再给定字符串exp， 其中可以含有'.'或'*'，'*'字符不能是exp的首字符，并且任意两个 '*'字符不相邻。exp中的'.'代表任何一个字符，exp中的'*'表示'*' 的前一个字符可以有0个或者多个。请写一个函数，判断str是否能被 exp匹配。 【举例】 str="abc"，exp="abc"，返回true。 str="abc"，exp=&amp
用一道例题来分享两种匹配字符串的算法！
YEDITABA的博客
11-28 483
输入一个字符串，同时输入帧头和帧尾（可以是多个字符），将该字符串中合法的帧识别出来， 提示 ：帧头和帧尾分别是 head 和 tail 字符串 "asdheaddjfvjdhtail"中headdjfvjdhtail是合法帧， 主函数.c文件 #include #include #define MAX_SIZE 100 int main() {     int i;   
【算法专题】字符串匹配
weixin_42638946的博客
11-23 666
字符串匹配 1. 概述 字符串匹配的经典算法是KMP，关于KMP可以参考：网址。还会用到AC自动机，可以参考：AC自动机。 这里不仅会讨论字符串匹配的情况，还会讨论不能含有某些字符串的情况。 2. 例题 AcWing 831. KMP字符串 问题描述 问题链接：AcWing 831. KMP字符串 分析 注意：p和s的下标都是从 1 开始的。 具体分析如下图： 代码 C++ #include <iostream> using namespace
牛客题目-字符串匹配
jqq125的博客
05-01 388
题目： 注意：（1）短字符串中可能有多个【】； （2）【】中的字符仅匹配到其中一个即可； 示例： 解答： #include <stdio.h> #include <string.h> int invert(char s) //统一转化为大写字母的数字表示 { if(s>='a'&&s<='z')//a为97，A为65 ...
字符串匹配（BF && KMP）详解 + 刷题
最新发布
IT OR 考公？
01-25 1106
P1308 && P3375，两道 字符串匹配 题目
字符串朴素匹配算法和KMP匹配算法及一个匹配习题
qq_33375550的博客
04-19 378
``` # -*- coding:utf-8 -*- # 请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符， # 而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有 # 字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配 # 考察字符串操作，匹配, ...
字符串经典题之正则匹配字符串
快乐江湖的博客
05-18 250
题目 字符串通配符 注意 此题和LeetCode 10：正则表达式匹配这道题虽然看着一样，但是本质不一样。力扣上的这道题，对于*匹配的是它前面的0个或多个，是单个字符，而牛客的这道题*匹配任意字符串多次 关于力扣的这道题，有兴趣的读者可以查看这篇博客，其难度要比本题高很多 动态规划之正则表达式匹配字符串 思路 仔细分析，其实很简单。采用两个指针分别扫描模式串和字符串，如果两个指针指向的字符相同，那么就比较下一个，如果模式串遇到?，那么对于目标串可以是任意。如果模式串遇到*，那么这个*可以匹配目标
面试题：字符串匹配
weixin_42145502的博客
06-19 236
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。 #include <iostream> #include <vector> #include <string> #include <string.h> using namespace std; /** * @brief replaceSpace * @param str * @param le
字符串匹配问题
biubiu_buaa的博客
06-22 817
Brute Force算法 比较简单好理解 #include <iostream> int match(char *s, char *t); int main() { char str_s[7] = "aaaaab"; char str_t[5] = "aaab"; int result = match(str_s, str_t); if(result >= 0...
Python3新特性解析：从print函数到字节与字符串
同时，字符串和字符串格式化也发生了变化，使用f-string（格式化字符串字面值）或str.format()方法来实现更直观和可读的字符串组合。 Python 3的内置dict类型也有所优化，提供了更快的查找速度和更高效的空间利用。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值