HDOJ 2604 Queuing (递推+矩阵快速幂）

点击打开链接

题意：给你一个长度为L的由m和f两种字母组成的字符串，定义存在fmf以及fff子串的都是不符合要求的串，问长度为L的符合要求的串有多少个？

 

解题思路：

首先找出递推关系式，先给出递推关系式：( L )=( L - 1 ) + ( L - 3 ) + ( L - 4 ); （L>=5，因为L=0比较特殊，如果L=4也用递推式算，得不到正确答案）

 

考虑当L=n时的情况，有两种情况：

①.如果最后一个字符为m ：此时，只要前面长度为n-1的串符合要求，则当前长度为n的串必然符合要求。

②.如果最后一个字符为f：此时，无法确定，因为可能存在不符合要求的串，继续分情况讨论

(1).最后倒数二个字符为f，仍然可能存在不符合要求的串，继续分情况讨论

1.倒数第三个字符为f,因为存在fff，所以该种情况必然不符合要求，舍去

2.倒数第三个字符为m，仍然有可能不符合要求，再分

a.最后第四个字符为f，存在fmf，所以该种情况必然不符合要求，舍去

b.最后第四个字符为m,只要前面长度为n-4的串符合要求，则当前长度为n的串必然也符合要求

(2).最后第二个字符为m，存在可能不符合要求的情况，分

1.最后第三个字符为f，存在fmf，此时必然不符合要求舍去

2.最后第三个字符为m，只要前面长度为n-3的串的情况符合要求，则当前长度为n的串必然符合要求。

所以讲符合要求的情况相加就得到：( L )=( L - 1 ) + ( L - 3 ) + ( L - 4 );

前面已经讲过如果只是用普通递归方法会超内存，所以这里要考虑优化。

怎么优化？先看下面的矩阵相乘的结果：

x矩阵是多少会得到后面的矩阵？我们只需考虑后面矩阵的第一行，因为其他元素为0.

第1行第1列的元素我们需要得到f ( n )，因为f(n)=f(n-1)+f(n-3)+f(n-4); 所以我们必须保留f(n-1)，f(n-3)，f(n-4) 所以与之相乘的数必须为1.

所以第1列元素可以确定，为1 0 1 1，注意，是第一列而不是第一行。

根据第一行第二列元素，我们可以确定x矩阵第二列元素：1 0 0 0.

根据第一行第三列元素，我们可以确定x矩阵第三列元素：0 1 0 0.

根据第一行第四列元素，我们可以确定x矩阵第四列元素：0 0 1 0.

所以x矩阵已经确定，所以我们可以得到下面的矩阵乘式：

所以，反复乘以x矩阵就可以得到想要的f(n);

所以可以先求出x矩阵的L-4(不是L)次方，到这就转化为了矩阵快速幂问题。

#include<cstdio>
#include<iostream>
#include<cstring>
struct matrix{
int a[10][10];
}base,ans;
int l, m;
matrix multiply(matrix x, matrix y)
{
    matrix tmp;
    for (int i = 0; i < 4; i++)
        for (int j = 0; j < 4; j++)
        {
            tmp.a[i][j] = 0;
            for (int k = 0; k < 4; k++)
                tmp.a[i][j] = (tmp.a[i][j] + x.a[i][k] * y.a[k][j]) % m;
        }
    return tmp;
}
int fast_mod(int k)
{
    while (k)
    {
        if (k & 1) ans = multiply(ans, base);
        base = multiply(base, base);
        k >>= 1;
    }
    return ans.a[0][0];
}
int main()
{
    int k;
    while (scanf("%d%d", &l, &m) != EOF)
    {
        memset(ans.a, 0, sizeof(ans.a));
        ans.a[0][3] = 2 % m;
        ans.a[0][2] = 4 % m;
        ans.a[0][1] = 6 % m;
        ans.a[0][0] = 9 % m;
        memset(base.a, 0, sizeof(base.a));
        base.a[0][0] = base.a[0][1] = base.a[1][2] = base.a[2][0] = base.a[2][3] = base.a[3][0] = 1;
        k = l - 4;
        if (k <= 0) printf("%d\n", ans.a[0][4-l]);
        else printf("%d\n", fast_mod(k));
    }
    return 0;
}