GDKOI2016 day 2 Problem 4. 小學生數學題 - 數學題

　　題意：求

∑i=1ni−1modpk,p≤105

　　
　　不知道是啥題。
　　我們可以注意到，當n<p 的時候顯然是一定有解的，而當n≥p 時，對於每個kp 項，可能單獨沒有逆元，但是也可能∑⌊n/p⌋k=11/k 是p 的倍數把p 約掉，這樣就存在逆元了。既然題目保證了一定存在逆元，那麼我們可以把這部分分開出來算。
　　設

F(n)=∑i=1ni−1,G(n)=∑i=1,i≠jpni−1

那麼我們有

F(n)=G(n)+F(⌊n/p⌋)/p

因此我們每次可以將n 的規模縮小p ，函數F 的次數是O(logpn) 的。現在我們的問題是如何計算G(n) 。
　　爲了方便分析，不妨我們先設p∣n ，這樣我們可以有

G(n)=∑a=1p−1∑b=0⌊n/p⌋−11a+bp

這裏我們還是比較難進行快速計算，可以想辦法把形式比較好的1a+bp 給拆開，比如冪級數展開：

1a+bp=a−1∑i=0∞(−1)ibiaipi

注意我們是在模pk 的意義下做的這個玩意，因此我們可以將k−1 以後的項全部直接刪掉。故得到

G(n)=∑a=1p−1∑b=0⌊n/p⌋−1a−1∑i=0k−1(−1)ibiaipi=∑i=0k−1(−1)i∑a=1p−1piai+1∑b=0⌊n/p⌋−1bi

　　推至此，我們可以發現前面的∑k−1i=0∑p−1a=1piai+1 是可以在O(kp) 的時間內計算出來的，接下來的問題就是計算∑⌊n/p⌋b=0bi 了。
　　出題人似乎給的做法是伯努利數或者直接矩陣乘法？然而我都不會那些東西所以YY了一下k 次方和。
　　以下是我YY的計算∑ni=0ik 的做法，不知道有沒有錯。。。
　　設Sk(n) 表示上面要求的這個式子，嘗試用組合數來計算這串東西。
　　注意到

(nk)=nk⎯⎯k!=∑ki=0(−1)i+ks(k,i)nik!

其中s(n,k) 表示第一類斯特林數s(n,k)=(n−1)s(n−1,k)+s(n−1,k−1) 。那麼

Sk(n)=∑j=0n(k!(jk)−∑i=0k−1(−1)i+ks(k,i)ji)=k!∑j=0n(jk)−∑i=0k−1(−1)i+ks(k,i)∑j=0nji=k!(n+1k+1)−∑i=0k−1(−1)i+ks(k,i)Si(n)=(n+1)k+1⎯⎯⎯⎯⎯k+1−∑i=0k−1(−1)i+ks(k,i)Si(n)

　　於是我們只需要O(k2) 地預處理出第一類斯特林數然後就可以按k來遞推算了，當然邊界是S1(n)=n(n+1)/2 。
　　回到原問題中，既然我們要求的是∑⌊n/p⌋−1b=0bi ，那麼就可以直接代進去得到：

G(n)=∑i=0k−1(−1)i∑a=1p−1piai+1Si(⌊n/p⌋−1)

　　到了這一步，我們就可以愉快地將pi 和1ai+1 全都預處理出來，然後就可以在O(kp) 的時間計算G(n) 了。
　　補充一下當p∤n 的時候，我們可以把後面的餘項劃歸入前面一部分，若設r=nmodp ，則此時

G(n)=∑i=0k−1(−1)i∑a=1rpiai+1Si(⌊n/p⌋)+∑i=0k−1(−1)i∑a=r+1p−1piai+1Si(⌊n/p⌋−1)

　　再回到上一步F(n)=G(n)+F(n/p)/p ，也就可以遞歸計算了。
　　至此我們只需要預處理一些東西，然後遞歸快速計算就可以辣。
　　時間複雜度？每一層計算G 的複雜度是O(kp) ,遞歸層數是O(logpn) ，總複雜度是O(kplogpn) 。
　　應該有更優的做法>_<

　　爲毛一直都沒有人告訴我上面的冪級數展開少了個(−1)i 。。。。調了好久啊TAT
　　奇怪的Code：（懶得刪註釋了）

#include <bits/stdc++.h>
//using namespace std;
#define rep(i,a,b) for(int i = a , _ = b ; i <= _ ; i ++)
#define per(i,a,b) for(int i = a , _ = b ; i >= _ ; i --)
#define cr(x) memset(x , 0 , sizeof x)

#define gprintf(...) //fprintf(stderr , __VA_ARGS__)

typedef long long ll;

const int maxp = 100007;
const int maxk = 121;

ll mod , n , s[maxk][maxk] , inva[maxp];
ll powa[maxp][maxk] , S[maxk] , powp[maxk];

inline ll add(ll a , ll b , ll mod) { a = (a + b) % mod ; if (a < 0) a += mod ; if (a >= mod) a -= mod ; return a ; }
inline ll dec(ll a , ll b , ll mod) { a = (a - b) % mod ; if (a < 0) a += mod ; if (a >= mod) a -= mod ; return a ; }
inline ll qmul(ll a , ll b , ll p) {
    return (a * b - (ll)(a / (double)p * b + 1e-3) * p + p) % p;
}

#define neg(x) (((x) & 1) ? -1 : 1)

int p , k;

void input() {
    scanf("%d%d%lld" , &p , &k , &n);
    mod = 1;
    rep (i , 1 , k) mod = mod * p;
}

void init_stirling(int k , ll mod) {
//  gprintf("initalization of stirling mod %lld\n" , mod);
    s[0][0] = 1;
    s[1][0] = 0 , s[1][1] = 1;
    rep (i , 2 , k) {
        s[i][0] = 0;
        rep (j , 1 , k) {
            s[i][j] = add(qmul(i - 1 , s[i - 1][j] , mod) , s[i - 1][j - 1] , mod);
//          gprintf("%lld%c" , s[i][j] , j == k ? '\n' : ' ');
        }
    }
}

void init_inv(int k , ll mod) {
//  gprintf("calculating inverse of mod %lld\n" , mod);
    inva[1] = 1;
    powa[1][1] = 1;
    rep (i , 2 , p - 1) {
        inva[i] = dec(0 , qmul(inva[mod % i] , mod / i , mod) , mod);
//      gprintf("%lld\n" , qmul(inva[i] , i , mod));
        powa[i][1] = inva[i];
    }
    powp[0] = 1;
    rep (i , 1 , k - 1) powp[i] = powp[i - 1] * p;
    rep (a , 1 , p - 1) {
        ll t = inva[a];
        rep (i , 2 , k)
            powa[a][i] = qmul(powa[a][i - 1] , t , mod);
    }
}

namespace ASS {

    #include <assert.h>

    static ll tmp[maxk];
    static ll _pow[100 * 10][25];

    void _S(ll n , ll mod) {
        rep (i , 1 , n) {
            _pow[i][1] = i;
            rep (j , 2 , k)
                _pow[i][j] = qmul(_pow[i][j - 1] , i , mod);
        }
        rep (i , 0 , k) {
            tmp[i] = 0;
            rep (j , 1 , n)
                tmp[i] = add(tmp[i] , _pow[j][i] , mod);
            if (!i) tmp[i] = (n + 1) % mod;
            gprintf("%lld%c" , tmp[i] , i == k ? '\n' : ' ');
            assert(tmp[i] == S[i]);
        }
    }

}

void get_S(ll n , ll mod , int k) {
//  gprintf("calculating sum %lld of power %d\n" , n , k);
    S[0] = (n + 1) % mod;
//  if (!n) S[0] = 1;
    if (n < k) {
        static ll pown[maxk][maxk];
        rep (i , 1 , n) {
            pown[i][1] = i;
            rep (j , 2 , k)
                pown[i][j] = qmul(pown[i][j - 1] , i , mod);
        }
        rep (i , 1 , k) {
            S[i] = 0;
            rep (j , 1 , n)
                S[i] = add(S[i] , pown[j][i] , mod);
        }
    } else {
        int cur_k = -1;
        rep (K , 1 , k) {
            S[K] = 1;
            rep (j , 0 , K) {
                if ((n + 1 - j) % (K + 1) == 0)
                    S[K] = qmul((n + 1 - j) / (K + 1) , S[K] , mod);
                else
                    S[K] = qmul(n + 1 - j , S[K] , mod);
            }
            int cur_i = cur_k;
            rep (i , 0 , K - 1) {
                S[K] = dec(S[K] , cur_i * qmul(s[K][i] , S[i] , mod) , mod);
                cur_i = - cur_i;
            }
            cur_k = - cur_k;
        }
    }
    #ifdef DEBUG
        rep (i , 0 , k) {
            gprintf("%lld%c" , S[i] , i == k ? '\n' : ' ');
        }
        ASS::_S(n , mod);
    #endif
}

ll G(ll n , ll mod , int k) {
    init_inv(k , mod);
    init_stirling(k , mod);
//  gprintf("calculating G(%lld , %lld)\n" , n , mod);
    ll ret = 0;
    if (n % p == 0) {
        get_S(n / p - 1 , mod , k);
        rep (a , 1 , p - 1)
            rep (i , 0 , k - 1) {
//              gprintf("p^%d : %lld , 1/%d^(%d+1) %lld , S[%d] : %lld\n" , i , powp[i] , a , i , powa[a][i + 1] , i , S[i]);               
                ret = add(ret , neg(i) * qmul(qmul(powp[i] , powa[a][i + 1] , mod) , S[i] , mod) , mod);
            }
    } else {
        if (n < p) {
            rep (i , 1 , n)
                ret = add(ret , inva[i] , mod);
            gprintf("result of G(%lld , %lld) = %lld\n" , n , mod , ret);
            return ret;
        }
        ll r = n % p;
        get_S(n / p , mod , k);
        rep (a , 1 , r)
            rep (i , 0 , k - 1) {
//              gprintf("p^%d : %lld , 1/%d^(%d+1) %lld , S[%d] : %lld\n" , i , powp[i] , a , i , powa[a][i + 1] , i , S[i]);
                ret = add(ret , neg(i) * qmul(qmul(powp[i] , powa[a][i + 1] , mod) , S[i] , mod) , mod);
            }
        get_S(n / p - 1 , mod , k);
        rep (a , r + 1 , p - 1)
            rep (i , 0 , k - 1)
                ret = add(ret , neg(i) * qmul(qmul(powp[i] , powa[a][i + 1] , mod) , S[i] , mod) , mod);
    }
    gprintf("result of G(%lld , %lld) = %lld\n" , n , mod , ret);
    return ret;
}

ll F(ll n , ll mod , int k) {
    if (!n) return 0;
    return (G(n , mod , k) + F(n / p , mod * p , k + 1) / p) % mod;
}

void solve() {
//  printf("%lld\n" , G(102728 , 823543));
    ll ans = F(n , mod , k);
    printf("%lld\n" , ans);
}

int main() {
    #ifndef ONLINE_JUDGE
        freopen("math.in" , "r" , stdin);
    #endif
    input();
    solve();
    return 0;
}