HDU 1358 KMP模板

新添加一个模板：get_repeat(int idx, int nex[])

给入一个下标，返回：

正数P：表示s[0]...s[idx] 可以从 s[0]...s[(idx+1)/P] 这前几个字母，经过重复P次，得到s[0]..s[idx]

负数-P：表示最少需要添加P个数字，才能使得s[0]..s[idx]成为可重复串

特判：P=1： 表示串为a,abc,abcdefg这样的串

核心思想：还是利用idx+1 - next[idx+1] 得到最短循环串的长度，进行求解。

int get_repeat(int idx, int nex[])//返回在idx位置，如果是重复串，重复了多少次。如果不重复，返回-k，表示还需要添加k个字符才能重复
{
	int lenP = idx + 1;
	int cir = lenP - nxt[lenP];
	if (cir == lenP)    return 1;    //重复了一次，表明整个串前后没有相同部分
	else if (lenP % cir == 0)    return lenP / cir;    //返回idx结尾，重复的次数
	else 
	{
		//表明不重复,返回最少要添加多少个字符，才能重复。此值为负数 
		return  lenP % cir -cir;
	}
}

AC CODE

/*
#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <tr1/unordered_map>
#include <ctime>
using std::tr1::unordered_map;
*/

#include <iostream>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cstdio>
#include <map>
using namespace std;

/*
   using std::sort;
   using std::bitset;
   using std::max;
   using std::cout;
   using std::stack;
   using std::cin;
   using std::endl;
   using std::swap;
   using std::pair;
   using std::vector;
   using std::set;
   using std::map;
   using std::multiset;
   using std::queue;
   using std::greater;
   using std::string;
   using std::priority_queue;
   using std::max_element;
   using std::min_element;

   using __gnu_pbds::pairing_heap_tag;
   __gnu_pbds::priority_queue<int, greater<int>, pairing_heap_tag> heap;
#define Hash unordered_map
*/
#define pr(x) cout<<#x<<" = "<<x<<" "
#define prln(x)    cout<<#x<<" = "<<x<<endl

#define lson o*2, L, M
#define rson o*2+1, M + 1,R

#define MAXN 1000010


//pattern为模板串，从0下标，长度为len。 返回next数组
	template<typename T>
void kmp_pre(T pattern[], int len, int next[])
{
	next[0] = next[1] = 0;
	for(int i = 1 ; i < len ; i++)
	{ 
		int j = next[i];
		while(j && pattern[i] != pattern[j])
			j = next[j];
		next[i+1] = pattern[i] == pattern[j] ? j+1 : 0;
	}
}

//text为匹配串，lenT为其长度。pattern为模板串，lenP为其长度，next为上面得到的next数组。
//返回一个vector，表示所有匹配成功的在text的下标（从0开始）
//还返回一个true/false表示是否有匹配成功的
	template<typename T>
bool find(T text[], int lenT, T pattern[], int lenP, int next[], vector<int> &ret)//下标皆为从0开始
{  
	ret.clear();
	int j = 0; //初始化在模式串第一个位置
	for (int i = 0; i < lenT; ++ i)
	{
		while (j && pattern[j] != text[i])    j = next[j];
		if (pattern[j] == text[i]) j++;
		if (j == lenP)
		{
			j=0;        //得到一个答案后，进行第二次匹配，j归0 
			ret.push_back(i-lenP+1);
		}
	}
	return ret.size();
}
vector<int>ans;
int nxt[1000010];
char pattern[1000010], text[1000010];


int get_repeat(int idx, int nex[])//返回在idx位置，如果是重复串，重复了多少次。如果不重复，返回-k，表示还需要添加k个字符才能重复
{
	int lenP = idx + 1;
	int cir = lenP - nxt[lenP];
	if (cir == lenP)    return 1;    //重复了一次，表明整个串前后没有相同部分
	else if (lenP % cir == 0)    return lenP / cir;    //返回idx结尾，重复的次数
	else 
	{
		//表明不重复,返回最少要添加多少个字符，才能重复。此值为负数 
		return  lenP % cir -cir;
	}
}



int main()
{
	int T = 0;
	while (1)
	{
		int lenP;
		scanf("%d\n", &lenP);
		if (!lenP)    break;
		scanf("%s", pattern);

		++T;
		printf("Test case #%d\n", T);
		//        int lenP = strlen(pattern);
		//        int lenT = strlen(text);
		kmp_pre(pattern, lenP, nxt);
		//find(text, lenT, pattern, lenP, nxt, ans);
		//cout << ans.size() << endl;
		for (int i = 1; i < lenP; ++ i)
		{
			int t = get_repeat(i, nxt);
			if (t>1)
				printf("%d %d\n", i + 1, t);
		}
		printf("\n");
	}
	return 0;
}