FZU 1901 KMP 有点意思的题了

2016年8月20日09:22:29

去HUST的VJ上看了别人的代码，发现一些其妙的技巧，和next数组的理解，决定记录下来。

对于所有的方案，可以归结于以下几类（实际上就是一类，我们画图了而已）

首先，next[len]表示，从[0,  next[len]])的区域和串最后面[len-next[len], next[len]  )区域的字符串是一样的。(len表示当前串长度)

对于一个长度为13的串，next[13]，显然就表示前面几个字母，和后面几个字母相同。 在图上就是s[0]...s[3] 和s[9]..s[12]相同。

显然P=9成立，因为s[0]=s[0+9]  s[1]=s[1+9] s[2]=s[2+9] s[3]=s[3+9] 然后s[4]配对的时候，不存在s[4+9=13]13这个元素。

所以我们可以先通过这个状态，得到第一个合法解：P=9 （len - next[len]）

经过next[4]=2,可以知道s[0]s[1] 和s[2]s[3]相同。

又因为s[0]..s[4]和s[9]..s[12]相同，所以s[0],s[1]和s[11],s[12] 相同。

从而得到P=11的解。 11 = len - next[4]

再然后显然，就是求next[2]了，因为这表示s[0] s[1]区间前缀和后缀相同的情况，后缀又等于整个串的后缀。

假设s[0]==s[1]的话，next[2]就是1

得到P=12    12=len-next[2]

然后next[1]=0，实际上已经算法结束了。这个时候的前缀等于后缀的部分已经是空集了。

对于next[len]是下图情况：

有交集部分。 显然s[0]....s[8]  和s[5]...s[13]是相同。

s[0]=s[5], s[1]=s[5]....s[i]=s[i+5] 

得到一个答案P=5    LEN - next[LEN] = 14-9=5

下面情况略多。先看图上面的情况。(next[9]=6)

s[0]=s[3]   ->    s[0]=s[5]=s[8]=s[8]  (因为next[14]=9,看蓝色的圈，他们是等价的，两个蓝色的圈是相同的对不对，然后左边蓝色圈里的首位相同，肯定右边蓝色圈里首位也相同。两个蓝色圈又相同，所以可以得到这样的式子)

s[0] = s[8]

s[1] = s[9]

...

得到的P=8.    LEN - next[9] = 14-6=8。

对于图下面的情况也是类似，next[9]=4.

同时s[0]显然可以等于s[10],（第一个红圈和第三个红圈彼此等价）从而得出解， p = 14-4=10

然后递归下去，每一个next所指的字符串区域相同的前缀（从s[0]开始）和后缀，都可以对应上原串的前缀（从s[0]开始）和后缀(s[len-1]结尾)。

回到第一张图

对于所有的P，大致也就是这些情况了。我们需要证明，刚才上述的算法，能包含所有的情况。

对于上图所示的情况，

实际上是这样的。两个橘黄色是相同的。然后就回到了上面的状态了。所有的子状态都是可达的。所以这题就做完了。

先next[13]得到9

然后就是next[9]=4。

看起来只得到的P=9的情况，没有P=4的情况。

实际上漏了第一步……就是13-next[13]的情况…… 

再多列举一些情况，可以证明出来，任何一个状态都是可达的。这题这下算做完了吧？

对下面的题解略加解释：因为没想到这样就可以做完了， 所以我又算出最小循环节，穷举了一遍……

=======================

2016年8月20日凌晨

这题强行OJ第一……但是加了无数技巧以后得到的，恕我自私，那个代码就不公开了~ 只公开另外一个我AC的程序

708664

2016-08-20 02:12:27

Accepted

1901

GNU C++

109 ms

8560KB

6257B

cmtm4

题目大意：

给一个字符串。

问你，有多少个P的取值方案，可以对任意i，让s[i] == s[i+p] （i+p不超字符串范围）

并且最终方案额外加上一个输出 “总串长”

我是没懂为啥要输出总串长……反正按照我对题目的理解，并不需要，但是看样例都输出了，我也输出了……

依旧是KMP。

首先是求最小循环节，如果有更大的循环节，一定也可以有若干个最小循环节组合构成。（做法，lenP - next[lenP] 得到最小循环节长度，证明相关见之前的博客）

既然知道最小循环节，那么可以得出形如3,6,9,12,15……这样的成倍数的答案。

比如对于

aaabcaaabcaaabc……

循环节为aaabc，所以依次输出了5,10,15，20……

这只是解决了输出答案的一部分。

对于数据：

aaabaaabaaaba这样的数据是不够的 

显然循环节为

[aaaba]aab[aaaba]  （下标从0开始标）

但是，除了之前得到的答案8之外，还有12,13.

对于12,13,就需要利用next数组的特性得到了。

对于第一个a，对应到最后一个a的情况，实际上和第一个a对应到第四个a是一样的。

所以可以直接通过next数组缩小范围进行求解即可。

相当于求，[aaaba]，首位相同的部分是哪些。比如在[aaaba]中，第一个a和最后一个a是一样，这样就知道第一个a和原串中最后一个a是对应的。

计算完这一步以后，还可以继续执行相同的操作，直到程序结束。

/*
#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 <cmath>
#include <cstring>
#include <string>
#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[maxn];
char pattern[maxn], text[maxn];


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;
	}
}



bool vis[maxn];
int main()
{
	int T = 0;
	scanf("%d", &T);
	for (int i = 1; i <= T;++i)
	{
		printf("Case #%d: ", i);
		//cout<<endl<<endl;
		scanf("%s", pattern);
		int lenP = strlen(pattern);
		memset(vis, 0, sizeof(vis));
/*
		if (lenP==1)
		{
			cout<<"1\n1\n";
			continue;
		}
		*/

		kmp_pre(pattern, lenP, nxt);
		int cir = lenP - nxt[lenP];
		//printf("%d\n",(int)ceil(1.0 * lenP / cir));

		for (int i = cir; i <= lenP - 1;  i += cir)	vis[i] = 1;

		//for (int i = 0; i != g.size();++i)	cout<<g[i]<<" ";cout<<endl;
		/*
		cout<<g.size()<<endl;
		for (int i = 0; i != g.size() -1; ++ i)
			cout<<g[i]<<" ";
		cout<<g[g.size()-1]<<endl;
		*/


		//int q = lenP - lenP % cir - 1;
		int now = nxt[lenP];
		now = nxt[now];

		int sb=0;
		while (now)
		{	
			//++sb;
			//if (sb>maxn)	exit(0);
			//cout<<now<<" "<<lenP<<" "<<lenP - now << endl;
			vis[lenP - now] = 1;
			now = nxt[now];
		}
		vis[lenP] = 1;
		int ans = 0;
		for (int i = 1; i <= lenP; ++ i)	ans += vis[i];
		printf("%d\n", ans);
		for (int i = 1; i < lenP; ++ i)
			if (vis[i])	printf("%d ", i);
		printf("%d\n", lenP);
	}
	return 0;
}