HDU5318 The Goddess Of The Moon(DP + 矩阵快速幂)

最新推荐文章于 2019-04-05 20:24:21 发布

原创最新推荐文章于 2019-04-05 20:24:21 发布 · 250 阅读

1 ·

CC 4.0 BY-SA版权

数据结构专栏收录该内容

65 篇文章

订阅专栏

本文介绍了一种通过矩阵快速幂解决字符串连接问题的算法。针对给定的不同字符串，该算法利用动态规划思想来计算可能的连接方式总数。文章详细解释了状态转移方程及其求解过程，并提供了一个具体的实现示例。

/**
题意：n种字符串， 每种字符串长度很短而且有无穷多个， 现在取出m个连接成一个很长的字符串， a能接在b后面的条件是
a的前缀和b的后缀最大相同的长度要>=2， 问有多少种字符串

思路： 设dp[i][j] : 连接成的字符串中第i个字符串是第j个字符串的时候的种数， 可以找到状态转移方程， 因为j很小，
可以矩阵快速幂求dp[m][1,2,...n]， 注意得先去重
**/

#include<bits/stdc++.h>
typedef long long ll;
const ll mod = 1e9 + 7;
using namespace std;

typedef vector<ll> vec;
typedef vector<vec> mat;
ll a[55], n, m, T;

mat operator * (mat A, mat B) {
    int asz = A.size(), bsz = B[0].size();
    mat C(asz, vec(bsz));
    for(int i = 0; i < asz; i++) {
        for(int j = 0; j < bsz; j++) {
            for(int k = 0; k < B.size(); k++) {
                C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % mod;
            }
        }
    }
    return C;
}

mat operator ^ (mat A, ll n) {
    mat E(A.size(), vec(A.size()));
    for(int i = 0; i < A.size(); i++) E[i][i] = 1;
    while(n) {
        if(n & 1) E = E * A;
        A = A * A;
        n >>= 1;
    }
    return E;
}

///x能否接在y后面
bool can_conect(ll x, ll y) {
    if(!(x/10 && y/10)) return false;
    int xg[20], yg[20];
    int num1 = 0, num2 = 0;
    while(x) { xg[num1++] = x % 10; x /= 10; }
    while(y) { yg[num2++] = y % 10; y /= 10; }
    int len = min(num1, num2);
    for(int l = 2; l <= len; l++) {
        int flag = 1;
        for(int i = 0; i < l; i++) {
            if(xg[i] != yg[num2 - (l - i)]) { flag = 0; break; }
        }
        if(flag) return true;
    }
    return false;
}

int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%lld %lld", &n, &m);
        for(int i = 0; i < n; i++) scanf("%lld", &a[i]);
        sort(a, a + n);
        n = unique(a, a + n) - a;
        mat A(n + 1, vec(n + 1));
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                if(can_conect(a[i], a[j])) A[i][j] = 1;
                else A[i][j] = 0;
            }
            A[i][n] = 1;
        }
        A = A ^ (m - 1);
        ll ans = 0;
        for(int i = 0; i <= n; i++) {
            for(int j = 0; j < n; j++) {
                ans = (ans + A[i][j]) % mod;
            }
        }
        cout << ans << endl;
    }
    return 0;
}