指数循环节与斐波那契模p循环节

原文链接： https://blog.csdn.net/ACdreamers/article/details/10983813

指数循环节：
$$a^{n}modp=a^{n\%\varphi (p)+\varphi (p)}modp(n\ge \varphi (p))$$


斐波那契模p循环节：
对于一个正整数n，我们求Fib数模n的循环节的长度的方法如下
（1）把n素因子分解，即$n=p_1^{a_1}{p}_2^{a_2}...p_k^{a_k}$
（2）分别计算Fib数模每个的循环节长度，假设长度分别是$x_1,x_2,...,x_k$
（3）那么Fib模n的循环节长度$lcm(x_1,x_2,...,x_k)$

Fib数模$p^m$的最小循环节长度等于$G(p)\ast p^{m-1}$，其中$G(p)$表示Fib数模素数p的最小循环节长度。

对于求$G(p)$我们利用如下定理：

如果5是模p的二次剩余(即是$5^{\frac{p-1}{2}}\%=1$)，那么循环节的的长度是的$p-1$因子，否则，循环节的长度是$2\ast (p-1)$的因子。

对于小于等于5的素数，我们直接特殊判断，$G(2)=3,G(3)=8,G(5)=20$。

那么我们可以先求出所有的因子，然后用矩阵快速幂来一个一个判断.

#include 
#include 
#include 
#include 
#include 
 
using namespace std;
typedef unsigned long long LL;
 
const int M = 2;
 
struct Matrix
{
    LL m[M][M];
};
 
Matrix A;
Matrix I = {1,0,0,1};
 
Matrix multi(Matrix a,Matrix b,LL MOD)
{
    Matrix c;
    for(int i=0; i>= 1;
        p = multi(p,p,MOD);
    }
    return ans;
}
 
LL gcd(LL a,LL b)
{
    return b? gcd(b,a%b):a;
}
 
const int N = 400005;
const int NN = 5005;
 
LL num[NN],pri[NN];
LL fac[NN];
int cnt,c;
 
bool prime[N];
int p[N];
int k;
 
void isprime()
{
    k = 0;
    memset(prime,true,sizeof(prime));
    for(int i=2; i>= 1;
        a = a * a % m;
    }
    return ans;
}
 
LL legendre(LL a,LL p)
{
    if(quick_mod(a,(p-1)>>1,p)==1) return 1;
    else                           return -1;
}
 
void Solve(LL n,LL pri[],LL num[])
{
    cnt = 0;
    LL t = (LL)sqrt(1.0*n);
    for(int i=0; p[i]<=t; i++)
    {
        if(n%p[i]==0)
        {
            int a = 0;
            pri[cnt] = p[i];
            while(n%p[i]==0)
            {
                a++;
                n /= p[i];
            }
            num[cnt] = a;
            cnt++;
        }
    }
    if(n > 1)
    {
        pri[cnt] = n;
        num[cnt] = 1;
        cnt++;
    }
}
 
void Work(LL n)
{
    c = 0;
    LL t = (LL)sqrt(1.0*n);
    for(int i=1; i<=t; i++)
    {
        if(n % i == 0)
        {
            if(i * i == n) fac[c++] = i;
            else
            {
                fac[c++] = i;
                fac[c++] = n / i;
            }
        }
    }
}
 
LL find_loop(LL n)
{
    Solve(n,pri,num);
    LL ans=1;
    for(int i=0; i>n)
        cout<