HDU5411——CRB and Puzzle——————【矩阵快速幂优化dp】

CRB and Puzzle

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 558    Accepted Submission(s): 227

Problem Description

CRB is now playing Jigsaw Puzzle.
There are N kinds of pieces with infinite supply.
He can assemble one piece to the right side of the previously assembled one.
For each kind of pieces, only restricted kinds can be assembled with.
How many different patterns he can assemble with at most M pieces? (Two patterns P and Q are considered different if their lengths are different or there exists an integer j such that j-th piece of P is different from corresponding piece of Q.)

 

 

Input

There are multiple test cases. The first line of input contains an integer T, indicating the number of test cases. For each test case:
The first line contains two integers N, M denoting the number of kinds of pieces and the maximum number of moves.
Then N lines follow. i-th line is described as following format.
k a1 a2 ... ak
Here k is the number of kinds which can be assembled to the right of the i-th kind. Next k integers represent each of them.
1 ≤ T ≤ 20
1 ≤ N ≤ 50
1 ≤ M ≤ 105
0 ≤ k ≤ N
1 ≤ a1 < a2 < … < ak ≤ N

 

 

Output

For each test case, output a single integer - number of different patterns modulo 2015.

 

 

Sample Input

1

3 2

1 2

1 3

0

 

 

Sample Output

6

Hint

possible patterns are ∅, 1, 2, 3, 1→2, 2→3

 

 

题目大意：给你t组测试数据，每组给n和m分别表示有n种商品，让你排列出最长长度为m的序列，有n行，每行有k表示该种商品后边可以放k种商品，然后后边是k个数。

 

解题思路：这道题跟嫦娥那题其实比较像，都是先用dp求出转移方程，然后套用一下矩阵快速幂加速。因为是要求最长长度为m的序列，所以就需要求出长度为0 -> m的所有结果。分奇偶。当为偶：a¹+a²+a³+a⁴....a^2K 那么（a¹+a²+a³....a^k）*(1+a^k)   。当为奇：a¹+a²+a³+a⁴....a^2K+1 那么（a¹+a²+a³....a^k）*（1+a^k+1）+a^k+1。    这就可以用dfs去处理。

 

#include<bits/stdc++.h>
using namespace std;
typedef long long INT;
const int MOD=2015;
int n;
struct Matrix{
    int a[52][52];
    Matrix(){
        memset(a,0,sizeof(a));
    }
    void clr(){
        memset(a,0,sizeof(a));
    }
    void init(){
        for(int i=1;i<=n;i++){
            a[i][i]=1;
        }
    }
    Matrix operator *(const Matrix & X)const{
        Matrix ret;
        int i,j,k;
        for(int i=1;i<=n;i++){      //可以先枚举k。再用n*n去取模，能加速。
            for(int j=1;j<=n;j++){
                for(int k=1;k<=n;k++){
                    ret.a[i][j] = ret.a[i][j] +a[i][k]*X.a[k][j];
                }
                ret.a[i][j]%=MOD;
            }
        }
        return ret;
    }
    Matrix operator +(const Matrix & X)const {
        Matrix ret;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                ret.a[i][j]=a[i][j]+X.a[i][j];
            }
        }
        return ret;
    }
};
Matrix one;
Matrix Pow(Matrix A,int x){
    Matrix ret;
    ret.init();
    while(x){   //可以换成for加速
        if(x&1)
            ret=ret*A;
        A=A*A;
        x>>=1;
    }
    return ret;
}
Matrix dfs(Matrix a,int k){
    if(k==1)
        return a;
    if(k%2){
        return (dfs(a,k/2)*(Pow(a,k/2+1)+one))+Pow(a,k/2+1);
    }else{
        return dfs(a,k/2)*(Pow(a,k/2)+one);
    }
}
int main(){
    int t,m,k,a;
    scanf("%d",&t);
    while(t--){
        Matrix trans;
        trans.clr();
        scanf("%d%d",&n,&m);
        one.init();
        for(int i=1;i<=n;++i){
            scanf("%d",&k);
            for(int j=1;j<=k;++j){
                scanf("%d",&a);
                trans.a[i][a]=1;
            }
        }
        if(m==1){
            printf("%d\n",n+1);
            continue;
        }
        Matrix ans=dfs(trans,m-1);
        INT sum=0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                sum+=ans.a[i][j];
            }
        }
        sum+=n+1;
        printf("%lld\n",sum%2015);
    }
    return 0;
}