HDU 5318 (dp+矩阵快速幂优化)

The Goddess Of The Moon

Time Limit: 6000/3000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

Total Submission(s): 605 Accepted Submission(s): 259



Problem Description

Chang’e （嫦娥） is a well-known character in Chinese ancient mythology. She’s the goddess of the Moon. There are many tales about Chang'e, but there's a well-known story regarding the origin of the Mid-Autumn Moon Festival. In a very distant past, ten suns had
risen together to the heavens, thus causing hardship for the people. The archer Yi shot down nine of them and was given the elixir of immortality as a reward, but he did not consume it as he did not want to gain immortality without his beloved wife Chang'e.



However, while Yi went out hunting, Fengmeng broke into his house and forced Chang'e to give up the elixir of immortality to him, but she refused to do so. Instead, Chang'e drank it and flew upwards towards the heavens, choosing the moon as residence to be
nearby her beloved husband.



Yi discovered what had transpired and felt sad, so he displayed the fruits and cakes that his wife Chang'e had liked, and gave sacrifices to her. Now, let’s help Yi to the moon so that he can see his beloved wife. Imagine the earth is a point and the moon is
also a point, there are n kinds of short chains in the earth, each chain is described as a number, we can also take it as a string, the quantity of each kind of chain is infinite. The only condition that a string A connect another string B is there is a suffix
of A , equals a prefix of B, and the length of the suffix(prefix) must bigger than one(just make the joint more stable for security concern), Yi can connect some of the chains to make a long chain so that he can reach the moon, but before he connect the chains,
he wonders that how many different long chains he can make if he choose m chains from the original chains.



Input

The first line is an integer T represent the number of test cases.

Each of the test case begins with two integers n, m.

(n <= 50, m <= 1e9)

The following line contains n integer numbers describe the n kinds of chains.

All the Integers are less or equal than 1e9.



Output

Output the answer mod 1000000007.



Sample Input

2
10 50
12 1213 1212 1313231 12312413 12312 4123 1231 3 131
5 50
121 123 213 132 321

Sample Output

86814837
797922656
Hint11 111 is different with 111 11

题意：

给n种数字串，每种数量无限，从中选m个串连起来，连的规则是a的后缀等于b的前缀，且长度大于等于2；问这样能连出多少个不同的串注意题目的Hint，不仅仅是长度不同。

所以要对串去重，相同的串是同一种；

思路：

暴力预处理a[i][j]表示第 j 种串能否连第 i 种串后面，能a[i][j]=1,否则a[i][j]=0;

设dp[i][j]表示选了i个串，以第j种串结尾的方案数，那么转移方程为dp[i][j]+=dp[i-1][k]*a[k][j](1<=k<=n)，就是对于每一个k，如果 j 能连到k后面（即a[k][j]=1）那么就加dp[i][k]方案数，否则（a[k][j]=0）就不加（就是加0）；

有了状态转移方程，选m个串肯定要递推到dp[m][k](1<=k<=n),然而m达到1e9，太大！！仔细观察转移方程，它是两个二维数组的乘积，每个状态变化的k，模拟一下就知道这是个矩阵的乘法，而且只有一个因式，不如考虑一下矩阵快速幂；

下面用等比数列通向来类比矩阵快速幂：

a[i][j]这个矩阵在dp递推过程中是不变的，视为常数B=a[i][j](代表整个矩阵)；

设An=dp
(代表整个矩阵),

那么An=A(n-1)*B（类比转移方程）注意这里n是选的串的数量,题目要求选m 个即求Am;

这样就是个等比数列An=A1*B^(n-1);

带回题目要求dp[1]*a[i][j]^(m-1);

dp[1][j](1<=j<=n)的含义是选了一个1个串以j结尾书方案数，显然一个串只能以自己结尾且方案数是1；即dp[i][i]=1(1<=i<=n),其他的dp值为0，这个矩阵只有对角线为1其他都为0，不就是单位矩阵么（它乘任何矩阵都不会改变矩阵的值）;那么最终结果就是a[i][j]^（m-1)所有数的和，;就是矩阵快速幂嘛。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<set>
#include<vector>
#include<map>
#include<stack>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxn=50+5;
const int mod=1000000007;
const int INF=0x3f3f3f3f;
typedef __int64 ll;
struct node
{
    ll a[maxn][maxn];
};
int n;
set<string>u;
string s[maxn];
bool judge(int x,int y)
{
    int li=s[x].size(),lj=s[y].size();
    if(li==1||lj==1) return false;
    for(int i=li-2;i>=0;i--)
    {
        int ti=i,j=0;
        while(ti<li && j<lj && s[x][ti++]==s[y][j++])
        if(ti==li) return true;
    }
    return false;
}
node mul(node&x,node&y)
{
    node ans;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            ll tmp=0;
            for(int k=1,kk=1;k<=n;k++,kk++)
            {
                tmp=(tmp+x.a[i][k]*y.a[kk][j])%mod;
            }
            ans.a[i][j]=tmp%mod;
        }
    }
    return ans;
}
node Pow(node a,int m)
{
    node ans;
    memset(ans.a,0,sizeof ans.a);
    for(int i=1;i<=n;i++) ans.a[i][i]=1;
    while(m)
    {
        if(m&1)
            ans=mul(ans,a);
        a=mul(a,a);
        m>>=1;
    }
    return ans;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int m;
        scanf("%d%d",&n,&m);
        string tmp;
        u.clear();
        int pos=1;
        for(int i=1;i<=n;i++)
        {
            cin>>tmp;
            int si=u.size();//这个去重的方法很sb相信大家有好方法。
            u.insert(tmp);
            if(si!=u.size())
            {
                s[pos++]=tmp;
            }
        }
        n=pos-1;
        node an,tm;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            if(judge(i,j)) tm.a[i][j]=1;
            else tm.a[i][j]=0;
        an=Pow(tm,m-1);
        ll ans=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            ans=(ans+an.a[i][j])%mod;
        printf("%I64d\n",ans);
    }
    return 0;
}