VIJOS1067 Warcraft III 守望者的烦恼 矩阵乘法

/*
我们可以用上面的方法二分求出任何一个线性递推式的第n项，
其对应矩阵的构造方法为：
在右上角的(n-1)*(n-1)的小矩阵中的主对角线上填1，矩阵第n行填对应的系数，其它地方都填0。
例如，我们可以用下面的矩阵乘法来二分计算f(n) = 4f(n-1) - 3f(n-2) + 2f(n-4)的第k项：
[ [ 0  1  0  0]        [f(k-4)]       [f(k-3)]
  [ 0  0  1  0]    *   [f(k-3)]   =   [f(k-2)]
  [ 0  0  0  1]        [f(k-2)]       [f(k-1)]
  [ 2  0 -3  4] ]      [f(k-1)]       [f( k )]
  
本题要我们 求 f(n)=sum(f(n-i))   1<=i<=k

因此构造一个k*k的矩阵然后求n-k次幂
然后用构造前k项 然后是之与前面所求出的矩阵相乘即可得到f(n);

我的构造方法 以 k=2 为例

[f(1),f(2)] *  [ [ 0 1 ]    ^(n-k)   =  [f(n-1),f(n)]
                 [ 1 1 ] ]
                 
左乘与右乘构造方法其实一样，因为个人习惯，我喜欢左乘，所以构造上方的那种方法，
*/

 

背景

守望者-warden，长期在暗夜精灵的的首都艾萨琳内担任视察监狱的任务，监狱是成长条行的，守望者warden拥有一个技能名叫“闪烁”，这个技能可以把她传送到后面的监狱内查看，她比较懒，一般不查看完所有的监狱，只是从入口进入，然后再从出口出来就算完成任务了。

描述

头脑并不发达的warden最近在思考一个问题，她的闪烁技能是可以升级的，k级的闪烁技能最多可以向前移动k个监狱，一共有n个监狱要视察，她从入口进去，一路上有n个监狱，而且不会往回走，当然她并不用每个监狱都视察，但是她最后一定要到第n个监狱里去，因为监狱的出口在那里，但是她并不一定要到第1个监狱。

守望者warden现在想知道，她在拥有k级闪烁技能时视察n个监狱一共有多少种方案？

格式

输入格式

第一行是闪烁技能的等级k(1<=k<=10)
第二行是监狱的个数n(1<=n<=2^31-1)

输出格式

由于方案个数会很多，所以输出它 mod 7777777后的结果就行了

样例1

样例输入1[复制]

2
4

样例输出1[复制]

5

限制

各个测试点1s

提示

把监狱编号1 2 3 4,闪烁技能为2级，
一共有5种方案
→1→2→3→4
→2→3→4
→2→4
→1→3→4
→1→2→4

小提示：建议用int64，否则可能会溢出

 

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>

#define MAXN 20
#define MOD 7777777

using namespace std;

struct Matrix
{
    int size;
    long long modulo;
    long long element[MAXN][MAXN];
    void setSize(int);
    void setModulo(long long);
    Matrix operator* (Matrix);
    Matrix power(int);

};

void Matrix::setSize(int a)
{
    for (int i=0; i<a; i++)
        for (int j=0; j<a; j++)
            element[i][j]=0;
    size = a;
}

void Matrix::setModulo(long long a)
{
    modulo = a;
}

Matrix Matrix::operator* (Matrix param)
{
    Matrix product;
    product.setSize(size);
    product.setModulo(modulo);
    for (int i=0; i<size; i++)
        for (int j=0; j<size; j++)
            for (int k=0; k<size; k++)
            {
                product.element[i][j]+=(element[i][k]*param.element[k][j]);
                product.element[i][j]%=modulo;
            }
    return product;
}

Matrix Matrix::power(int exp)
{
    Matrix res,A;
    A=*this;
    res.setSize(size);
    res.setModulo(MOD);
    for(int i=0;i<size;i++)
        res.element[i][i]=1;
    while(exp)
    {
        if(exp&1)
            res=res*A;
        exp>>=1;
        A=A*A;
    }
    return res;
}

int n,k;
long long f[20];
Matrix m;

int main()
{
    while(~scanf("%d%d",&k,&n))
    {
        f[0]=0;
        for(int i=1;i<=k;i++)
        {
            f[i]=0;
            for(int j=1;j<=i;j++)
                f[i]=(f[i]+f[i-j])%MOD;
            f[i]++;
        }
        if(n<=k)
            printf("%lld\n",f[n]);
        else
        {
            m.setModulo(MOD);
            m.setSize(k);
            for(int i=0;i<k-1;i++)
                m.element[i+1][i]=1;
            for(int i=0;i<k;i++)
                m.element[i][k-1]=1;
            m=m.power(n-k);
            long long ans=0;
            for(int i=0;i<k;i++)
                ans=(ans+(f[i+1]*m.element[i][k-1])%MOD)%MOD;
            printf("%lld\n",ans);
        }

    }
    return 0;
}