数学：广义斐波纳契数列循环节

我们定义一个f(n)函数，f(n) = a * f(n - 1) + b * f(n - 2), f(1) = c, f(2) = d.
问f(n)在模1000000007情况下的最小循环节。即求最小的m，使对任意的n有f(n) % 1000000007 = f(n + m) % 1000000007

这个题目不仅交不了，而且我还没办法验证代码的正确性，我还没办法

所以这里仅仅贴一份广义斐波纳契的代码，希望它是对的吧

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cmath>
using namespace std;
typedef long long LL;
const int N = 2;
const LL MOD = 1000000007;

LL fac[2][505];
int cnt,ct;

LL pri[6] = {2, 3, 7, 109, 167, 500000003};
LL num[6] = {4, 2, 1, 2, 1, 1};

struct Matrix
{
    LL m[N][N];
} ;

Matrix A;
Matrix I = {1, 0, 0, 1};

Matrix multi(Matrix a,Matrix b)
{
    Matrix c;
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++)
        {
            c.m[i][j]  =0;
            for(int k=0; k<N; k++)
            {
                c.m[i][j] += a.m[i][k] * b.m[k][j];
                c.m[i][j] %= MOD;
            }
        }
    }
    return c;
}

Matrix power(Matrix A,LL n)
{
    Matrix ans = I, p = A;
    while(n)
    {
        if(n & 1)
        {
            ans = multi(ans,p);
            n--;
        }
        n >>= 1;
        p = multi(p,p);
    }
    return ans;
}

LL quick_mod(LL a,LL b)
{
    LL ans = 1;
    a %= MOD;
    while(b)
    {
        if(b & 1)
        {
            ans = ans * a % MOD;
            b--;
        }
        b >>= 1;
        a = a * a % MOD;
    }
    return ans;
}

LL Legendre(LL a,LL p)
{
    LL t = quick_mod(a,(p-1)>>1);
    if(t == 1) return 1;
    return -1;
}

void dfs(int dept,LL product = 1)
{
    if(dept == cnt)
    {
        fac[1][ct++] = product;
        return;
    }
    for(int i=0; i<=num[dept]; i++)
    {
        dfs(dept+1,product);
        product *= pri[dept];
    }
}

bool OK(Matrix A,LL n)
{
    Matrix ans = power(A,n);
    return ans.m[0][0] == 1 && ans.m[0][1] == 0 &&
           ans.m[1][0] == 0 && ans.m[1][1] == 1;
}

int main()
{
    fac[0][0] = 1;
    fac[0][1] = 2;
    fac[0][2] = 500000003;
    fac[0][3] = 1000000006;
    LL a,b,c,d;
    while(cin>>a>>b>>c>>d)
    {
        LL t = a * a + 4 * b;
        A.m[0][0] = a;
        A.m[0][1] = b;
        A.m[1][0] = 1;
        A.m[1][1] = 0;
        if(Legendre(t,MOD) == 1)
        {
            for(int i=0; i<4; i++)
            {
                if(OK(A,fac[0][i]))
                {
                    cout<<fac[0][i]<<endl;
                    break;
                }
            }
        }
        else
        {
            ct = 0;
            cnt = 6;
            dfs(0,1);
            sort(fac[1],fac[1]+ct);
            for(int i=0;i<ct;i++)
            {
                if(OK(A,fac[1][i]))
                {
                    cout<<fac[1][i]<<endl;
                    break;
                }
            }
        }
    }
    return 0;
}

当然，要附上博主的链接，做这个题的时候的玄学的数学方法，可能这辈子都不会再用到了

https://blog.csdn.net/ACdreamers/article/details/25616461

当然不能就这么算了，普通的斐波纳契数列求其模除一个数的循环节的题还是好找的

HDU3977

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int res;
int factor[33][2];
long long len[1000005];
struct Mat
{
    long long mat[3][3];
    int row,col;
};
long long gcd(long long a,long long b)
{
    return b==0?a:gcd(b,a%b);
}
long long lcm(long long a,long long b)
{
    return a/gcd(a,b)*b;
}
Mat mod_mul(Mat a,Mat b,long long p)
{
    Mat ans;
    ans.row=a.row;
    ans.col=b.col;
    memset(ans.mat,0,sizeof(ans.mat));
    for(int i=0;i<ans.row;i++)
        for(int k=0;k<a.col;k++)
            if(a.mat[i][k])
                for(int j=0;j<ans.col;j++)
                {
                    ans.mat[i][j]+=a.mat[i][k]*b.mat[k][j];
                    ans.mat[i][j]%=p;
                }
    return ans;
}
Mat mod_pow(Mat a,long long k,long long p)
{
    Mat ans;
    ans.row=a.row;
    ans.col=a.col;
    for(int i=0;i<a.row;i++)
        for(int j=0;j<a.col;j++)
            ans.mat[i][j]=(i==j);
    while(k)
    {
        if(k&1) ans=mod_mul(ans,a,p);
        a=mod_mul(a,a,p);
        k>>=1;
    }
    return ans;
}
long long deal(int x)
{
    if(len[x]!=-1) return len[x];
    Mat A;
    A.mat[0][0]=A.mat[0][1]=A.mat[1][0]=1,A.mat[1][1]=0;
    A.row=A.col=2;
    long long p=1ll*(x-1)*(x+1);
    long long ans=p;
    for(long long i=2;i*i<p;i++)
        if(p%i==0)
        {
            Mat B=mod_pow(A,i,x);
            if(B.mat[0][0]==1&&B.mat[0][1]==0)
            if(B.mat[1][0]==0&&B.mat[1][1]==1)
                ans=min(ans,i);
            B=mod_pow(A,p/i,x);
            if(B.mat[0][0]==1&&B.mat[0][1]==0)
            if(B.mat[1][0]==0&&B.mat[1][1]==1)
                ans=min(ans,p/i);
        }
    return len[x]=ans;
}
void get_factor(int p)
{
    res=0;
    for(int i=2;i*i<=p;i++)
        if(p%i==0)
        {
            factor[res][0]=i,factor[res][1]=0;
            while(p%i==0) p/=i,factor[res][1]++;
            res++;
        }
    if(p>1) factor[res][0]=p,factor[res++][1]=1;
}
int main()
{
    memset(len,-1,sizeof(len));
    len[1]=1,len[2]=3,len[3]=8,len[4]=6,len[5]=20;
    int T,p,cas=1;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&p);
        get_factor(p);
        long long ans=1;
        for(int i=0;i<res;i++)
        {
            long long tmp=deal(factor[i][0]);
            for(int j=1;j<factor[i][1];j++) tmp*=factor[i][0];
            ans=lcm(ans,tmp);
        }
        printf("Case #%d: %lld
",cas++,ans);
    }
}

这个坑等数学学好了再滚回来填（可能数学学不好了QAQ）