HDU2243-考研路茫茫――单词情结

考研路茫茫——单词情结

                                                              Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
                                                                                      Total Submission(s): 6166    Accepted Submission(s): 2101

Problem Description

背单词，始终是复习英语的重要环节。在荒废了3年大学生涯后，Lele也终于要开始背单词了。
一天，Lele在某本单词书上看到了一个根据词根来背单词的方法。比如"ab",放在单词前一般表示"相反，变坏，离去"等。

于是Lele想，如果背了N个词根，那这些词根到底会不会在单词里出现呢。更确切的描述是：长度不超过L，只由小写字母组成的，至少包含一个词根的单词，一共可能有多少个呢？这里就不考虑单词是否有实际意义。

比如一共有2个词根 aa 和 ab ，则可能存在104个长度不超过3的单词，分别为
(2个) aa,ab,
(26个)aaa,aab,aac...aaz,
(26个)aba,abb,abc...abz,
(25个)baa,caa,daa...zaa,
(25个)bab,cab,dab...zab。

这个只是很小的情况。而对于其他复杂点的情况，Lele实在是数不出来了，现在就请你帮帮他。

 

Input

本题目包含多组数据，请处理到文件结束。
每组数据占两行。
第一行有两个正整数N和L。(0<N<6,0<L<2^31)
第二行有N个词根，每个词根仅由小写字母组成，长度不超过5。两个词根中间用一个空格分隔开。

 

Output

对于每组数据，请在一行里输出一共可能的单词数目。
由于结果可能非常巨大，你只需要输出单词总数模2^64的值。

 

Sample Input

  
  

   
   2 3
aa ab
1 2
a
  
  

 

Sample Output

  
  

   
   104
52
  
  

 

Author

linle

 

Recommend

lcy

 

解题思路：这题和POJ2778有点类似，这题算至少出现了一次，那么我们可以先求它的反面，即一次都没出现，然后算出总数量减一减即可。不过因为这题算的是长度不超过n，所以构造矩阵时需要再加一维来进行统计

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <cctype>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <bitset>
#include <functional>

using namespace std;

#define LL long long
#define ull unsigned long long
const int INF = 0x3f3f3f3f;

char ch[15];
int n, m;

struct Matrix
{
	ull v[40][40];
	Matrix()
	{
		memset(v, 0, sizeof v);
	}
} dan;

Matrix mul(Matrix a, Matrix b, int d)
{
	Matrix ans;
	for (int i = 0; i < d; i++)
		for (int j = 0; j < d; j++)
			for (int k = 0; k < d; k++)
				ans.v[i][j] += (1LL * a.v[i][k] * b.v[k][j]);
	return ans;
}

Matrix pow(Matrix a, int k, int d)
{
	Matrix ans = dan;
	while (k)
	{
		if (k & 1) ans = mul(ans, a, d);
		k >>= 1;
		a = mul(a, a, d);
	}
	return ans;
}

struct Trie
{
	int next[40][26], fail[40], flag[40];
	int root, tot;
	int newnode()
	{
		for (int i = 0; i < 26; i++) next[tot][i] = -1;
		flag[tot++] = 0;
		return tot - 1;
	}
	void init()
	{
		tot = 0;
		root = newnode();
	}
	void insert(char ch[])
	{
		int k = root;
		for (int i = 0; ch[i]; i++)
		{
			if (next[k][ch[i] - 'a'] == -1) next[k][ch[i] - 'a'] = newnode();
			k = next[k][ch[i] - 'a'];
		}
		flag[k] = 1;
	}
	void build()
	{
		queue<int>q;
		fail[root] = root;
		for (int i = 0; i < 26; i++)
		{
			if (next[root][i] == -1) next[root][i] = root;
			else
			{
				fail[next[root][i]] = root;
				q.push(next[root][i]);
			}
		}
		while (!q.empty())
		{
			int pre = q.front();
			q.pop();
			if (flag[fail[pre]]) flag[pre] = 1;
			for (int i = 0; i < 26; i++)
			{
				if (next[pre][i] == -1) next[pre][i] = next[fail[pre]][i];
				else
				{
					fail[next[pre][i]] = next[fail[pre]][i];
					q.push(next[pre][i]);
				}
			}
		}
	}
	void solve()
	{
		Matrix ans, a;
		for (int i = 0; i < tot; i++)
			for (int j = 0; j < 26; j++)
				if (!flag[next[i][j]]) ans.v[i][next[i][j]]++;
		for (int i = 0; i < tot + 1; i++) ans.v[i][tot] = 1;
		for (int i = 0; i < tot + 1; i++)
		{
			for (int j = 0; j < tot + 1; j++) dan.v[i][j] = 0;
			dan.v[i][i] = 1;
		}
		ans = pow(ans, m, tot + 1);
		ull ans1 = 0;
		for (int i = 0; i < tot + 1; i++) ans1 += ans.v[0][i];
		ans1--;
		ans.v[0][0] = 26, ans.v[1][0] = ans.v[1][1] = 1, ans.v[0][1] = 0;
		dan.v[0][0] = dan.v[0][1] = 1, dan.v[1][0] = dan.v[1][1] = 0;
		ans = pow(ans, m, 2);
		printf("%llu\n", ans.v[0][0] - ans1 - 1);
	}
	void debug()
	{
		for (int i = 0; i < tot; i++)
		{
			printf("id = %3d,fail = %3d,end = %3d,chi = [", i, fail[i], flag[i]);
			for (int j = 0; j < 26; j++) printf("%2d", next[i][j]);
			printf("]\n");
		}
	}
}ac;

int main()
{
	while (~scanf("%d %d", &n, &m))
	{
		ac.init();
		for (int i = 1; i <= n; i++)
		{
			scanf("%s", ch);
			ac.insert(ch);
		}
		ac.build();
		ac.solve();
	}
	return 0;
}