hdu 3483 A Very Simple Problem 矩阵

#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
#define LL __int64
const LL maxn=55;
LL c[maxn][maxn];
LL n,mod,x,m;
struct matrix{
    LL f[maxn][maxn];
};
void init()
{
    LL i,j,k;
    c[0][0]=c[1][0]=c[1][1]=1;
    for(i=2;i<maxn;i++)
    {
        c[i][0]=c[i][i]=1;
        for(j=1;j<i;j++)
            c[i][j]=c[i-1][j]+c[i-1][j-1];
    }
}
matrix mul(matrix a,matrix b)
{
    LL i,j,k;
    matrix c;
    memset(c.f,0,sizeof(c.f));
    for(k=0;k<m;k++)
    {
        for(i=0;i<m;i++)
        {
            if(!a.f[i][k])continue;
            for(j=0;j<m;j++)
            {
                if(!b.f[k][j])continue;
                c.f[i][j]=(c.f[i][j]+a.f[i][k]*b.f[k][j]%mod)%mod;
            }
        }
    }
    return c;
}
matrix pow_mod(matrix a,LL b)
{
    matrix s;
    memset(s.f,0,sizeof(s.f));
    for(LL i=0;i<m;i++)
        s.f[i][i]=1;

    while(b)
    {
        if(b&1)
            s=mul(s,a);
        a=mul(a,a);
        b=b>>1;

    }
    return s;
}
int main()
{
    init();
    while(cin>>n>>x>>mod)
    {
        if(n<0&&mod<0&&x<0)break;
        matrix e;
        LL i,j,ans=0;
        memset(e.f,0,sizeof(e.f));
        for(j=0;j<=x;j++)
        {
            for(i=j;i<=x;i++)
                e.f[i][j]=c[x-j][i-j]*x%mod;
        }
        e.f[0][x+1]=e.f[x+1][x+1]=1;
        m=x+2;
        e=pow_mod(e,n);

        for(i=0;i<m-1;i++)ans=(ans+x*e.f[i][m-1])%mod;
        cout<<(ans+mod)%mod<<endl;
    }
    return 0;
}
/*
    矩阵
    c[i][j]为组合数，在i个数中j个的方案数
    x^(k+1)*(k+1)^x=x^(k+1)*(c[x][0]*k^x+c[x][1]*k^(x-1)+...+c[x][x]*k^0)
    =c[x][0]*x*(x^k*k^x)+c[x][1]*x*(x^k*k*^(x-1))+...+c[x][x]*x*(x^k*k^0)
    可列矩阵
    
|x^k*k^x x^k*k^(x-1) ... x^k*k^0 s[k-1]|*|c[x][0]*x 0            ... 0       1 |=|x^(k+1)*(k+1)^x x^(k+1)*(k+1)^(x-1) ...x^(k+1)*(k+1)^0 s[k]|
                                         |c[x][1]*x c[x-1][0]*x  ... 0       0 |
                                         |c[x][2]*x c[x-1][1]*x  ... 0       0 |
                                         |...       ....         ... ...       |  
                                         |c[x][x]*x c[x-1]c[x-1] ... c[0][0] 0 |
                                         |0         0            ... 0       1 |
*/