KMP算法及其扩展应用

kmp是判断一个字符串是否是另一个字符串的子串，通过next数组，能实现o（n）复杂度

#ifndef KMP_H
#define KMP_H
#include<string>
#include<iostream>
#include<vector>
using namespace std;
//生成next数组
vector<int> makeNext(string m)
{
	vector<int>next(m.length()+1);
	next[0] = -1;
	if (m.length() < 2)
		return next;
	next[1] = 0;
	int pos = 2;
	int cn = 0;
	while (pos <= m.length())
	{
		if (m[pos - 1] == m[cn])
			next[pos++] = ++cn;
		else if (cn > 0)
			cn = next[cn];
		else
			next[pos++] = 0;
	}
	return next;
}//构建next数组完毕

int kmp(string s, string m)
{
	if (s.length() < 0 || s.length() < m.length())
		return -1;
	vector<int>next = makeNext(m);
	int s1 = 0, m1 = 0;
	while (s1 < s.length() && m1 < m.length())
	{
		if (s[s1] == m[m1])//s1与m1匹配上了，s1与m1均增加
		{
			++s1; ++m1;
		}
		else if (next[m1] == -1)//不幸，第一个字符就没匹配上
			++s1;
		else
			m1 = next[m1];//中间某一个位置没匹配上，利用next数组，继续匹配。
	}//while循环结束，表示s1==s.length()或者m1==m.length()，出现后者时，匹配成功
	return m1== m.length() ? s1 - m1 : -1;
}

#endif

Kmp的一个实现是判断一二叉树是不是另一个二叉树的子树

#ifndef SUBTREEEQUAL_H
#define SUBTREEEQUAL_H
#include<iostream>
#include<string>
#include<vector>
#include"kmp.h"
using namespace std;
//声明一棵树
struct Node{
	int value;
	Node *left;
	Node *right;
	Node(int x) :value(x), left(nullptr), right(nullptr) {}
};
//把树进行字符串化
string serialByPre(Node *head)
{
	if (head == nullptr)
		return "_#";
	string res = to_string(head->value) + "#";
	res += serialByPre(head->left);
	res += serialByPre(head->right);
	return res;
}
//判断一棵树是否包含另一棵树。
bool isSubtree(Node *t1, Node *t2)
{
	string t1s1 = serialByPre(t1);
	string t2s2 = serialByPre(t2);
	return kmp(t1s1, t2s2) != -1;
}
#endif

int main()
{
	Node *p1 = new Node(1);
	Node *p2 = new Node(2);
	Node *p3 = new Node(3);
	Node *p4 = new Node(4);
	Node *p5 = new Node(5);
	p1->left = p2;
	p1->right = p3;
	p2->left = p4;
	p2->right = p5;
	p3->left = nullptr;
	p3->right = nullptr;
	p4->left = nullptr;
	p4->right = nullptr;
	p5->left = nullptr;
	p5->right = nullptr;

	Node*q1 = new Node(2);
	Node*q2 = new Node(4);
	Node*q3 = new Node(5);
	q1->left = q2;
	q1->right = q3;
	q2->left = nullptr;
	q2->right = nullptr;
	q3->left = nullptr;
	q3->right = nullptr;

	cout<<isSubtree(p1, q1) << endl;

	system("pause");
	return 0;
}

kmp算法的另一个应用是：
给定一个字符串str1，只能往str1的后面添加字符变成str2。
要求1：str2必须包含两个str1，两个str1可以有重合，但是不能以同一个位置开头。
要求2：str2尽量短最终返回str2
例如abc123abc，两个abc是相同的，因此在第二个abc后面，添加123abc，就可以了，称为abc123abc123

利用next数组，求出最大相同的前缀和后缀的长度，比如这里的abc的长度为等，这样原字符串从下标为3往后的子串加至自己，就得到了答案。

#ifndef KMP_SHORTEST_TWICE_H
#define KMP_SHORTEST_TWICE_H
#include<iostream>
#include<vector>
#include<string>
using namespace std;

int getnext(string s)
{
	vector<int>next(s.length() + 1);
	next[0] = -1;
	if (s.length() < 2)
		return -1;
	next[1] = 0;
	int pos = 2;
	int cn = 0;
	while (pos <= s.length())//next数组与字符串s一样长，所以pos可以等于s.length()
	{
		if (s[pos - 1] == s[cn])
			next[pos++] = ++cn;
		else if (cn > 0)
			cn = next[cn];
		else
			next[pos++] = 0;
	}
	return next[next.size() - 1];
}

string HaveTwice(string s)
{
	if (s.length() == 0)
		return "";
	else if (s.length() == 1)
		return s + s;
	else if (s.length() == 2)
		return s[0] == s[1] ? s + s.substr(1) : s + s;
	else
		return s + s.substr(getnext(s));
}
#endif // !KMP_SHORTEST_TWICE_H
void main()
{
     string s1 = "123abc123";
     cout << HaveTwice(s1) << endl;
}