字符串匹配算法

暴力法

从左到右一个个匹配，如果这个过程中有某个字符不匹配，就跳回去，将模式串向右移动一位。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <stack>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <vector>
using namespace std;
int brute_force(const char *text, const char *pattern) {
	for (int i = 0; text[i]; ++i) {
		int flag = 1;
		for (int j = 0; pattern[j]; ++j) {
			if (text[i + j] == pattern[j]) continue;
			flag = 0;
			break;
		} 
		if (flag) return i;
	} 
	return -1;
} 
#define TEST(func, s1, s2) { \
	printf("%s(\"%s\", \"%s\") = %d\n", #func, s1, s2, func(s1, s2)); \
} 
int main() {
	char s1[100], s2[100];
	while (cin >> s1 >> s2) {
		TEST(brute_force, s1, s2);
	} 
	return 0;
}

kmp

我们只需要比较i指针指向的字符和j指针指向的字符是否一致。如果一致就都向后移动，如果不一致

"利用已经部分匹配这个有效信息，保持i指针不回溯，通过修改j指针，让模式串尽量地移动到有效的位置。”

存在着这样的性质：最前面的k个字符和j之前的最后k个字符是一样的。

P[0 ~ k-1] == P[j-k ~ j-1]

一个字符串最长相等前缀和后缀。

字符串 abcdab
前缀的集合：{a,ab,abc,abcd,abcda}
后缀的集合：{b,ab,dab,cdab,bcdab}
那么最长相等前后缀不就是ab嘛.

红色部分代表两串中已匹配的部分，绿色和蓝色部分分别代表主串和子串中不匹配的字符。

灰色部分就是红色部分字符串的最长相等前后缀，我们子串移动的结果就是让子串的红色部分最长相等前缀和主串红色部分最长相等后缀对齐。


而且next数组的数值只与子串本身有关。
所以next[i]=j,含义是：下标为i 的字符前的字符串最长相等前后缀的长度为j。表示该处字符不匹配时应该回溯到的字符的下标

若i与j`仍不相等。

using namespace std;
void GetNext(const char *pattern, int *next) {
	next[0] = -1;
	for (int i = 1, j = -1; pattern[i]; ++i) {
		while (j != -1 && pattern[j + 1] - pattern[i]) j = next[j];
		if (pattern[j + 1] == pattern[i]) j += 1;
		next[i] = j;
	} 
	return ;
} 
int kmp(const char *text, const char *pattern) {
	int n = strlen(pattern);
	int *next = (int *)malloc(sizeof(int) * n);
	GetNext(pattern, next);
	for (int i = 0, j = -1; text[i]; i++) {
		while (j != -1 && text[i] - pattern[j + 1]) j = next[j];
		if (text[i] == pattern[j + 1]) j += 1;
		if (pattern[j + 1] == 0) return i - j;
	}
	return -1;
} 

#define TEST(func, s1, s2) { \
	printf("%s(\"%s\", \"%s\") = %d\n", #func, s1, s2, func(s1, s2)); \
} 

sunday

黄金对齐点位，先预处理模式串中每个字符最后出现的位置。这样就可以在文本串匹配失败后，找到文本串下一个字符出现在模式串中的位置。

int GetNextJ(char ch, const char *pattern, int *next, int j) {
	while (j != -1 && ch - pattern[j + 1]) j = next[j];
	if (ch == pattern[j + 1]) j += 1;
	return j;
} 
int kmp(const char *text, const char *pattern) {
	int n = strlen(pattern);
	int *next = (int *)malloc(sizeof(int) * n);
	GetNext(pattern, next);
	for (int i = 0, j = -1; text[i]; i++) {
		j = GetNextJ(text[i], pattern, next, j);
		if (pattern[j + 1] == 0) return i - j;
	} 
	return -1;
} 
int sunday(const char *text, const char *pattern) {
	#define BASE 256
	int n = strlen(text), m, last_pos[BASE];
	for (int i = 0; i < BASE; i++) last_pos[i] = -1;
	for (m = 0; pattern[m]; ++m) last_pos[pattern[m]] = m;
	for (int i = 0; i + m <= n; i += (m - last_pos[text[i + m]])) {
		int flag = 1;
		for (int j = 0; pattern[j]; ++j) {
			if (text[i + j] == pattern[j]) continue;
			flag = 0;
			break;
		} 
		if (flag) return i;
	} 
	return -1;
} 
#define TEST(func, s1, s2) { \
printf("%s(\"%s\", \"%s\") = %d\n", #func, s1, s2, func(s1, s2)); \
} 

Shift-[AndOr]

先预处理模式串为比特位，通过上图中的第一条公式筛选后，当前p最高位的1表示i位置之前有多少位与模式串多少位重合。

int GetNextP(char ch, int *code, int p) {
	return (p << 1 | 1) & code[ch];
}
int shift_and(const char *text, const char *pattern) {
	int code[256] = {0};
	int n = 0;
	for (n = 0; pattern[n]; ++n) code[pattern[n]] |= (1 << n);
	int p = 0;
	for (int i = 0; text[i]; i++) {
		p = GetNextP(text[i], code, p);
		if (p & (1 << (n - 1))) return i - n + 1;
	} 
	return -1;
} 
#define TEST(func, s1, s2) { \
	printf("%s(\"%s\", \"%s\") = %d\n", #func, s1, s2, func(s1, s2)); \
} 
int main() {
	char s1[100], s2[100];
	while (cin >> s1 >> s2) {
		TEST(brute_force, s1, s2);
		TEST(kmp, s1, s2);
		TEST(sunday, s1, s2);
		TEST(shift_and, s1, s2);
	} 
	return 0;
}