HDU 2604 Queuing DP + 矩阵快速幂

题目大意：

给出长度L和需要取模的数M, 

现在要找出长度为 L 的由 f 和 m 构成的字符串， 其中不含有 fmf 和 fff 这两种字串的字符串的数量， 最后输出结果模上M

大致思路：

首先这是一个dp问题， 我们用0表示f, 用1表示m则， 需要找到长度为L的串， 其中不包含010和000的字串的字符串的数量

那么我们用 dp[ n ][ 00 ],  dp[ n ][ 01 ] , dp[ n ][ 10 ], dp[ n ][ 11 ],  分别表示满足条件的长度为n且结尾分别是00, 01, 10, 11的字符串的数量

这里的00， 01， 10，11 由于可以用二进制中的0,1,2,3，分别表示，所以在代码中表示也方便

那么不难发现递推关系：

其中dp[2][0,1,2,3] = 1;

dp[ n + 1 ][ 00 ] = dp[ n ][ 10 ];

dp[ n + 1 ][ 01 ] = dp[ n ][ 10 ] + dp[ n ][ 00 ];

dp[ n + 1 ][ 10 ] = dp[ n ][ 11 ];

dp[ n + 1 ][ 11 ] = dp[ n ][ 11 ] + dp[ n ][ 01 ];

推到这里我直接写了个dp就交上去了，，，复杂度O(T*L)，可是没想到 test 的组数非常多，，于是TLE了

那么可以用矩阵来进行优化：

这样子时间复杂度降到了O(T*log(L)),,,

代码如下：

Result  :  Accepted     Memory  :  292 KB     Time  :  234 ms

/*
 * Author: Gatevin
 * Created Time:  2014/7/28 16:53:28
 * File Name: test.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

int L,M;

struct Matrix
{
    int a[5][5];
    Matrix()
    {
        memset(a, 0, sizeof(a));
        for(int i = 1; i <= 4; i++)
        {
            a[i][i] = 1;
        }
    }
};

Matrix operator * (const Matrix & m1, const Matrix & m2)
{
    Matrix m;
    for(int i = 1; i <= 4; i++)
    {
        for(int j = 1; j <= 4; j++)
        {
            m.a[i][j] = 0;
            for(int k = 1; k <= 4; k++)
            {
                m.a[i][j] = (m.a[i][j] + (m1.a[i][k]*m2.a[k][j]) % M) % M;
            }
        }
    }
    return m;
}

Matrix quick_pow(Matrix base, int pow)
{
    Matrix I;
    while(pow)
    {
        if(pow & 1)
        {
            I = I * base;
        }
        base = base*base;
        pow >>= 1;
    }
    return I;
}

int main()
{
    while(cin>>L>>M)
    {
        if(L == 0)
        {
            cout<<"0"<<endl;
            continue;
        }
        if(L == 1)
        {
            cout<<"2"<<endl;
            continue;
        }
        Matrix S;
        memset(S.a, 0, sizeof(S.a));
        S.a[1][1] = 1 % M;
        S.a[1][2] = 1 % M;
        S.a[2][3] = 1 % M;
        S.a[2][4] = 1 % M;
        S.a[3][1] = 1 % M;
        S.a[4][3] = 1 % M;
        Matrix tran = quick_pow(S, L - 2);
        int f[5];
        f[1] = f[2] = f[3] = f[4] = 1;;
        int answer = 0;
        for(int i = 1; i <= 4; i++)
        {
            for(int j = 1; j <= 4; j++)
            {
                answer = (answer + f[i]*tran.a[i][j]) % M;
            }
        }
        cout<<answer<<endl;
    }
    return 0;
}