A

论业界毒瘤之矩阵快速幂 + 快速乘。

因为%数是1e13爆long long了所以要快速乘...不会O(1)的就写了个O(logn)的。

这个溢出害我调了半天...

【题目描述】

斐波那契数列满足f[0]=0,f[1]=1,f[i]=f[i-1]+f[i-2](i>=2)。已知f[i]对1e13取模的结果k，求最小的可能的i。无解输出-1。

【输入】

输入包含一个非负整数k。

【输出】

输出一个整数，为最小的可能的i。无解输出-1。

【输入样例】

17711

7

【输出样例】

22

9366795780274 

【提示】

对于100%的数据点，0<=k<1e13。

解：若 x % 1e13 == k 那么 x % d == k % d (d | 1e13)

由这个性质我们可以十进制拆分。

由于斐波那契数列数列的某个性质：对k取模时循环节不会超过6k

我们搞了个循环节表出来：

10 60

100 300

1000及以上  1500及以上

这里是找循环节的代码。

#include <cstdio>
#include <vector>
const int N = 1000010;
std::vector<int> pos[N];
int f[N];
int main() {
    int n;
    scanf("%d", &n);
    f[0] = 0;
    f[1] = 1;
    pos[1].push_back(1);
    for(int i = 2; ; i++) {
        f[i] = (f[i - 1] + f[i - 2]) % n;
        for(int j = 0; j < pos[f[i]].size(); j++) {
            if(f[pos[f[i]][j] - 1] == f[i - 1]) {
                printf("find:%d 
", i - pos[f[i]][j]);
                return 0;
            }
        }
        pos[f[i]].push_back(i);
    }
    return 0;
}

然后算法流程如下：

找到60以内对10取模结果为k % 10的数。

对每个数，在300范围内加60，判断是不是%100结果为k % 100

对每个数，在1500内加300，判断%1000结果是不是k % 1000

...

直到%1e13

矩阵快速幂有剧毒...

#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
typedef long long LL;
const int N = 100010;

inline LL m(LL a, LL b, LL p) {
    a %= p;
    b %= p;
    LL ans = 0;
    while(b) {
        if(b & 1) {
            ans = (ans + a) % p;
        }
        a = (a + a) % p;
        b = b >> 1;
    }
    return ans;
}
LL b[3][3], a[3][3], c[3][3], ans[3][3];
inline void mulself(LL p) {
    memset(b, 0, sizeof(b));
    for(int i = 1; i <= 2; i++) {
        for(int j = 1; j <= 2; j++) {
            for(int k = 1; k <= 2; k++) {
                b[i][j] += m(a[i][k], a[k][j], p) % p;
                b[i][j] %= p;
            }
        }
    }
    std::swap(a, b);
    return;
}

inline void mula(LL p) {
    memset(b, 0, sizeof(b));
    for(int i = 1; i <= 2; i++) {
        for(int j = 1; j <= 2; j++) {
            for(int k = 1; k <= 2; k++) {
                b[i][j] += m(ans[i][k], a[k][j], p) % p;
                b[i][j] %= p;
            }
        }
    }
    std::swap(b, ans);
    return;
}

inline void mulc(LL p) {
    memset(b, 0, sizeof(b));
    for(int j = 1; j <= 2; j++) {
        for(int k = 1; k <= 2; k++) {
            b[1][j] += m(c[1][k], ans[k][j], p) % p;
            b[1][j] %= p;
        }
    }
    std::swap(b, c);
    return;
}

inline LL getsum(LL k, LL p) {
    if(k == 0) {
        return 0;
    }
    if(k == 1) {
        return 1;
    }
    k--;
    memset(a, 0, sizeof(a));
    memset(c, 0, sizeof(c));
    memset(ans, 0, sizeof(ans));
    a[1][2] = 1;
    a[2][1] = 1;
    a[2][2] = 1;
    ans[1][1] = 1;
    ans[2][2] = 1;
    c[1][2] = 1;
    while(k) {
        if(k & 1) {
            mula(p);
        }
        mulself(p);
        k = k >> 1;
    }
    mulc(p);
    return c[1][2];
}


std::vector<LL> v[2];
LL d[20], po[20];

int main() {
    /*for(int i = 1; i <= 66; i++) {
        printf("%d %lld 
", i, getsum(i, 100000000000000));
    }
    LL x;
    while(scanf("%lld", &x)) {
        printf("----%lld
", getsum(x, 10000000000));
    }*/

    LL k;
    scanf("%lld", &k);
    d[1] = 60;
    d[2] = 300;
    po[2] = 100;
    for(LL i = 3, t = 1000; i <= 15; i++, t = t * 10) {
        d[i] = t + (t >> 1);
        po[i] = t;
    }

    for(int i = 0; i <= 60; i++) {
        if(getsum(i, 10) == k % 10) {
            v[0].push_back(i);
            //printf("%dth 
", i);
        }
    }
    int p = 0;

    for(int i = 2; i <= 13; i++) {
        //printf("i = %d 
", i);
        p = p ^ 1;
        v[p].clear();
        for(int j = 0; j < v[!p].size(); j++) {
            for(LL g = v[!p][j]; g <= d[i]; g += d[i - 1]) {
                //printf("%lld is find 
", g);
                ///printf("%d == %d 
", getsum(g, po[i]), k % po[i]);
                if(getsum(g, po[i]) == k % po[i]) {
                    //printf("%lld           pass 
", g);
                    v[p].push_back(g);
                }
            }
        }
        if(!v[p].size()) {
            printf("-1");
            return 0;
        }
    }

    LL ans = 1ll << 62;
    for(int i = 0; i < v[p].size(); i++) {
        ans = std::min(ans, v[p][i]);
    }
    printf("%lld", ans);
    return 0;
}