HDU Queuing(递推+矩阵快速幂）

Queuing

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 8207    Accepted Submission(s): 3593

Problem Description

Queues and Priority Queues are data structures which are known to most computer scientists. The Queue occurs often in our daily life. There are many people lined up at the lunch time. 

  Now we define that ‘f’ is short for female and ‘m’ is short for male. If the queue’s length is L, then there are 2^L numbers of queues. For example, if L = 2, then they are ff, mm, fm, mf . If there exists a subqueue as fmf or fff, we call it O-queue else it is a E-queue.
Your task is to calculate the number of E-queues mod M with length L by writing a program.

 

 

Input

Input a length L (0 <= L <= 10 ⁶) and M.

 

 

Output

Output K mod M(1 <= M <= 30) where K is the number of E-queues with length L.

 

 

Sample Input

3 8 4 7 4 8

 

 

Sample Output

6 2 1

题意：一个长度为L的串，只能由f和m组成，且子串中不能出现fff和fmf，输出有几种组合方式

解题思路：对于f(n)，如果该串最后一个字母是m，那么前面n-1个字母组成的串只要符合组合方式即可，那么+f(n-1),如果最后一个字母是f，最后三个字母能组成mmf,mff才有可能符合组合方式，mmf对于他前面n-3个字母同样只要满足组合方式就行，+f(n-3)，对于mff，前面一个字母肯定不能是f，那么就是最后四个字母为mmff，对于前面n-4个字母满足组合方式即可，+f(n-4)，至此推出f(n)=f(n-1)+f(n-3)+f(n-4)

建立转移矩阵

0 1 0 0　　　　

0 0 1 0 

0 0 0 1

1 1 0 1

建立初始矩阵

f(1)

f(2)

f(3)

f(4)

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define INF 0X3f3f3f3f
const ll MAXN = 4;
// const ll mod = 10000;
int mod;
//矩阵的大小 模数
ll n;
struct MAT
{
    int mat[MAXN][MAXN];
    MAT operator*(const MAT &a) const
    {
        //重载矩阵乘法
        MAT b;
        memset(b.mat, 0, sizeof(b.mat));
        for (int i = 0; i < MAXN; i++)
        {
            for (int j = 0; j < MAXN; j++)
            {
                for (int k = 0; k < MAXN; k++)
                    b.mat[i][j] = (b.mat[i][j] + mat[i][k] * a.mat[k][j]);
                b.mat[i][j] += mod;
                b.mat[i][j] %= mod;
            }
        }
        return b;
    }
} start, ans;
MAT Mqpow(MAT base, int b)
{
    MAT r;
    memset(r.mat, 0, sizeof(r.mat));
    r.mat[0][0] = 2, r.mat[1][0] = 4, r.mat[2][0] = 6, r.mat[3][0] = 9;
    //初始状态
    while (b)
    {
        if (b & 1)
            r = base * r;
        base = base * base;
        b >>= 1;
    }
    return r;
}
int main()
{

    start.mat[0][0] = 0, start.mat[0][1] = 1, start.mat[0][2] = 0, start.mat[0][3] = 0;
    start.mat[1][0] = 0, start.mat[1][1] = 0, start.mat[1][2] = 1, start.mat[1][3] = 0;
    start.mat[2][0] = 0, start.mat[2][1] = 0, start.mat[2][2] = 0, start.mat[2][3] = 1;
    start.mat[3][0] = 1, start.mat[3][1] = 1, start.mat[3][2] = 0, start.mat[3][3] = 1;
    //建立转移矩阵
    int f[5] = {0, 2, 4, 6, 9};
    while (~scanf("%d%d", &n, &mod))
    {
        if (n <= 4)
            printf("%d\n", f[n] % mod);
        else
            printf("%d\n", Mqpow(start, n - 4).mat[3][0]);
    }
    return 0;
}