牛客多校第九场 A The power of Fibonacci 杜教bm解线性递推

题意：
计算斐波那契数列前n项和的m次方模1e9

题解：

$F[i] – F[i-1] – F[i-2] = 0$

$F[i]^2 – 2 F[i-1]^2 – 2 F[i-2]^2 + F[i-3] = 0$

$F[i]^3 – 3 F[i-1]^3 – 6 F[i-2]^3 + 3 F[i-3] + F[i-4] = 0$

可以看出，斐波那契数列的高次幂依然是可以线性递推出来的，可以推广到任意幂次的情况，具体证明参见Fibonomial Coefficient

硬套杜教bm即可。

#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <cstring>
#include <bitset>
#include <cmath>
#include <cctype>
#include <unordered_map>
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <sstream>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef vector<long long> VI;
typedef unsigned long long ull;
const ll inff = 0x3f3f3f3f3f3f3f3f;
const ll mod=1e9;
#define FOR(i,a,b) for(int i(a);i<=(b);++i)
#define FOL(i,a,b) for(int i(a);i>=(b);--i)
#define SZ(x) ((long long)(x).size())
#define REW(a,b) memset(a,b,sizeof(a))
#define inf int(0x3f3f3f3f)
#define si(a) scanf("%d",&a)
#define sl(a) scanf("%I64d",&a)
#define sd(a) scanf("%lf",&a)
#define ss(a) scanf("%s",a)
#define pb push_back
#define eps 1e-6
#define lc d<<1
#define rc d<<1|1
#define Pll pair<ll,ll>
#define P pair<int,int>
#define pi acos(-1)
ll powmod(ll a,ll b)
{
    ll res=1ll;
    while(b)
    {
        if(b&) res=res*a%mod;
        a=a*a%mod,b>>=;
    }
    return res;
}
namespace linear_seq {
    const int N=;
    using int64 = long long;
    using vec = std::vector<int64>;
    ll res[N],base[N],_c[N],_md[N];
    vector<int> Md;
    void mul(ll *a,ll *b,int k) {
        FOR(i,,k+k-) _c[i]=;
        FOR(i,,k-) if (a[i]) FOR(j,,k-) _c[i+j]=(_c[i+j]+a[i]*b[j])%mod;
        for (int i=k+k-;i>=k;i--) if (_c[i])
            FOR(j,,SZ(Md)-) _c[i-k+Md[j]]=(_c[i-k+Md[j]]-_c[i]*_md[Md[j]])%mod;
        FOR(i,,k-) a[i]=_c[i];
    }
    int solve(ll n,VI a,VI b) { // a 系数 b 初值 b[n+1]=a[0]*b[n]+...
//        printf("%d\n",SZ(b));
        ll ans=,pnt=;
        int k=SZ(a);
        assert(SZ(a)==SZ(b));
        FOR(i,,k-) _md[k--i]=-a[i];_md[k]=;
        Md.clear();
        FOR(i,,k-) if (_md[i]!=) Md.push_back(i);
        FOR(i,,k-) res[i]=base[i]=;
        res[]=;
        while ((1ll<<pnt)<=n) pnt++;
        for (int p=pnt;p>=;p--) {
            mul(res,res,k);
            if ((n>>p)&) {
                for (int i=k-;i>=;i--) res[i+]=res[i];res[]=;
                FOR(j,,SZ(Md)-) res[Md[j]]=(res[Md[j]]-res[k]*_md[Md[j]])%mod;
            }
        }
        FOR(i,,k-) ans=(ans+res[i]*b[i])%mod;
        if (ans<) ans+=mod;
        return ans;
    }
    VI BM(VI s) {
        VI C(,),B(,);
        int L=,m=,b=;
        FOR(n,,SZ(s)-) {
            ll d=;
            FOR(i,,L) d=(d+(ll)C[i]*s[n-i])%mod;
            if (d==) ++m;
            else if (*L<=n) {
                VI T=C;
                ll c=mod-d*powmod(b,mod-)%mod;
                while (SZ(C)<SZ(B)+m) C.pb();
                FOR(i,,SZ(B)-) C[i+m]=(C[i+m]+c*B[i])%mod;
                L=n+-L; B=T; b=d; m=;
            } else {
                ll c=mod-d*powmod(b,mod-)%mod;
                while (SZ(C)<SZ(B)+m) C.pb();
                FOR(i,,SZ(B)-) C[i+m]=(C[i+m]+c*B[i])%mod;
                ++m;
            }
        }
        return C;
    }
    static void extand(vec &a, size_t d, int64 value = ) {
        if (d <= a.size()) return;
        a.resize(d, value);
    }
    static void exgcd(int64 a, int64 b, int64 &g, int64 &x, int64 &y) {
        if (!b) x = , y = , g = a;
        else {
            exgcd(b, a % b, g, y, x);
            y -= x * (a / b);
        }
    }
    static int64 crt(const vec &c, const vec &m) {
        int n = c.size();
        int64 M = , ans = ;
        for (int i = ; i < n; ++i) M *= m[i];
        for (int i = ; i < n; ++i) {
            int64 x, y, g, tm = M / m[i];
            exgcd(tm, m[i], g, x, y);
            ans = (ans + tm * x * c[i] % M) % M;
        }
        return (ans + M) % M;
    }
    static vec ReedsSloane(const vec &s, int64 mod) {
        auto inverse = [](int64 a, int64 m) {
            int64 d, x, y;
            exgcd(a, m, d, x, y);
            return d ==  ? (x % m + m) % m : -;
        };
        auto L = [](const vec &a, const vec &b) {
            int da = (a.size() >  || (a.size() ==  && a[])) ? a.size() -  : -;
            int db = (b.size() >  || (b.size() ==  && b[])) ? b.size() -  : -;
            return std::max(da, db + );
        };
        auto prime_power = [&](const vec &s, int64 mod, int64 p, int64 e) {
            // linear feedback shift register mod p^e, p is prime
            std::vector<vec> a(e), b(e), an(e), bn(e), ao(e), bo(e);
            vec t(e), u(e), r(e), to(e, ), uo(e), pw(e + );;
            pw[] = ;
            for (int i = pw[] = ; i <= e; ++i) pw[i] = pw[i - ] * p;
            for (int64 i = ; i < e; ++i) {
                a[i] = {pw[i]}, an[i] = {pw[i]};
                b[i] = {}, bn[i] = {s[] * pw[i] % mod};
                t[i] = s[] * pw[i] % mod;
                if (t[i] == ) {
                    t[i] = , u[i] = e;
                } else {
                    for (u[i] = ; t[i] % p == ; t[i] /= p, ++u[i]);
                }
            }
            for (size_t k = ; k < s.size(); ++k) {
                for (int g = ; g < e; ++g) {
                    if (L(an[g], bn[g]) > L(a[g], b[g])) {
                        ao[g] = a[e -  - u[g]];
                        bo[g] = b[e -  - u[g]];
                        to[g] = t[e -  - u[g]];
                        uo[g] = u[e -  - u[g]];
                        r[g] = k - ;
                    }
                }
                a = an, b = bn;
                for (int o = ; o < e; ++o) {
                    int64 d = ;
                    for (size_t i = ; i < a[o].size() && i <= k; ++i) {
                        d = (d + a[o][i] * s[k - i]) % mod;
                    }
                    if (d == ) {
                        t[o] = , u[o] = e;
                    } else {
                        for (u[o] = , t[o] = d; t[o] % p == ; t[o] /= p, ++u[o]);
                        int g = e -  - u[o];
                        if (L(a[g], b[g]) == ) {
                            extand(bn[o], k + );
                            bn[o][k] = (bn[o][k] + d) % mod;
                        } else {
                            int64 coef = t[o] * inverse(to[g], mod) % mod * pw[u[o] - uo[g]] % mod;
                            int m = k - r[g];
                            extand(an[o], ao[g].size() + m);
                            extand(bn[o], bo[g].size() + m);
                            for (size_t i = ; i < ao[g].size(); ++i) {
                                an[o][i + m] -= coef * ao[g][i] % mod;
                                if (an[o][i + m] < ) an[o][i + m] += mod;
                            }
                            while (an[o].size() && an[o].back() == ) an[o].pop_back();
                            for (size_t i = ; i < bo[g].size(); ++i) {
                                bn[o][i + m] -= coef * bo[g][i] % mod;
                                if (bn[o][i + m] < ) bn[o][i + m] -= mod;
                            }
                            while (bn[o].size() && bn[o].back() == ) bn[o].pop_back();
                        }
                    }
                }
            }
            return std::make_pair(an[], bn[]);
        };
        std::vector<std::tuple<int64, int64, int>> fac;
        for (int64 i = ; i * i <= mod; ++i)
            if (mod % i == ) {
                int64 cnt = , pw = ;
                while (mod % i == ) mod /= i, ++cnt, pw *= i;
                fac.emplace_back(pw, i, cnt);
            }
        if (mod > ) fac.emplace_back(mod, mod, );
        std::vector<vec> as;
        size_t n = ;
        for (auto &&x: fac) {
            int64 mod, p, e;
            vec a, b;
            std::tie(mod, p, e) = x;
            auto ss = s;
            for (auto &&x: ss) x %= mod;
            std::tie(a, b) = prime_power(ss, mod, p, e);
            as.emplace_back(a);
            n = std::max(n, a.size());
        }
        vec a(n), c(as.size()), m(as.size());
        for (size_t i = ; i < n; ++i) {
            for (size_t j = ; j < as.size(); ++j) {
                m[j] = std::get<>(fac[j]);
                c[j] = i < as[j].size() ? as[j][i] : ;
            }
            a[i] = crt(c, m);
        }
        return a;
    }
    ll gao(VI a,ll n,ll mod,bool prime=true) {
        VI c;
        if(prime) c=BM(a);
        else c=ReedsSloane(a,mod);
        c.erase(c.begin());
        FOR(i,,SZ(c)-) c[i]=(mod-c[i])%mod;
        return solve(n,c,VI(a.begin(),a.begin()+SZ(c)));
    }
};
ll gmod(ll a,ll b)
{
    ll res=;
    while(b)
    {
        if(b&) res=res*a%mod;
        a=a*a%mod,b>>=;
    }
    return res;
}
int main()
{
   vector<ll> v;
    v.push_back();
    v.push_back();
    ll n, m;
    cin >> n >> m;
    for (int i = ; i < ; ++i) v.push_back((v[i - ] + v[i - ]) % mod);
    for (auto& t : v) t = powmod(t, m);
    for (int i = ; i < ; ++i) v[i] = (v[i - ] + v[i]) % mod;
    printf("%lld\n", linear_seq::gao(v,n,mod,false));
}

话说杜教BM真是神器啊。

补充：

模数为1e9+9时的计算方法（zoj3774）

考虑斐波那契数列的通项公式：$\frac{1}{\sqrt5} \left [ \left ( \frac{1+\sqrt5}{2} \right ) ^n+\left (\frac{1-\sqrt5}{2} \right) ^n \right ]$

记

$a=\left ( \frac{1+\sqrt5}{2} \right ) ^n$
$b=\left ( \frac{1-\sqrt5}{2} \right ) ^n$

然后可以将斐波那契数列每一项二项式展开，共有m+1项，

$(Feb_i)^m=\left ( a^i + b^i \right )^m=\sum _{r=0}^m(-1)^rC_m^r(a^{m-r}b^r)^i$

发现，对于数列从1-n的每一项，它们二次展开后的m+1项中，系数相同的项是一个等比数列，比如斐波那契数列第1-n项二次展开后的第r项系数均为$(-1)^rC_m^r$

$(-1)^rC_m^r(a^{m-r}b^r)$　　$(-1)^rC_m^r(a^{m-r}b^r)^2$　　$(-1)^rC_m^r(a^{m-r}b^r)^3$　　$(-1)^rC_m^r(a^{m-r}b^r)^4$　　balabala......　　$(-1)^rC_m^r(a^{m-r}b^r)^n$

可以用等比数列计算，记$t_r=a^rb^{m-r}$

$ans_r=(-1)^rC_m^r\frac{t_r(t_r^n-1)}{t_r-1}$

$ans=\sum _{r=0}^m ans_r$

枚举r从0到m并计算，求和即可。

注意，根号5在模1e9+9意义下可用383008016代替（二次剩余），根号1/5可用276601605代替（逆元）

然而在模1e9意义下无法用整数表示这两个数，故此方法失效。

#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
typedef long long ll;
const int P=;
const int INV2=;
const int SQRT5=;
const int INVSQRT5=;
const int A=;
const int B=;

const int N=;

ll n,K;
ll fac[N],inv[N];
ll pa[N],pb[N];

inline void Pre(int n){
    fac[]=;
    for (int i=;i<=n;i++) fac[i]=fac[i-]*i%P;
    inv[]=;
    for (int i=;i<=n;i++) inv[i]=(P-P/i)*inv[P%i]%P;
    inv[]=;
    for (int i=;i<=n;i++) inv[i]=inv[i]*inv[i-]%P;
    pa[]=;
    for (int i=;i<=n;i++) pa[i]=pa[i-]*A%P;
    pb[]=;
    for (int i=;i<=n;i++) pb[i]=pb[i-]*B%P;
}

inline ll C(int n,int m){
    return fac[n]*inv[m]%P*inv[n-m]%P;
}

inline ll Pow(ll a,ll b){
    ll ret=;
    for (;b;b>>=,a=a*a%P)
        if (b&)
            ret=ret*a%P;
    return ret;
}

inline ll Inv(ll x){
    return Pow(x,P-);
}

inline void Solve(){
    ll Ans=;
    for (int j=;j<=K;j++){
        ll t=pa[K-j]*pb[j]%P,tem;
        tem=t==?n%P:t*(Pow(t,n)-+P)%P*Inv(t-)%P;
        if (~j&)
            Ans+=C(K,j)*tem%P,Ans%=P;
        else
            Ans+=P-C(K,j)*tem%P,Ans%=P;
    }
    Ans=Ans*Pow(INVSQRT5,K)%P;
    printf("%lld\n",Ans);
}

int main(){
    int T;
    #ifdef LOCAL
    freopen("t.in","r",stdin);
    freopen("t.out","w",stdout);
    #endif
    Pre();
    scanf("%d",&T);
    while (T--){
        scanf("%lld%lld",&n,&K);
        Solve();
    }
}