Fib数模n的循环节

最新推荐文章于 2021-04-06 01:00:58 发布
最新推荐文章于 2021-04-06 01:00:58 发布
阅读量1.1w 收藏 22
点赞数 9
分类专栏： 基础数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ACdreamers/article/details/10983813
版权

我们知道Fibonacci数列，现在我们来求一个Fib数模n的循环节的长度。


对于一个正整数n，我们求Fib数模n的循环节的长度的方法如下：


    （1）把n素因子分解，即

    （2）分别计算Fib数模每个的循环节长度，假设长度分别是

    （3）那么Fib模n的循环节长度


从上面三个步骤看来，貌似最困难的是第二步，那么我们如何求Fib模的循环节长度呢？

 

     这里有一个优美的定理：Fib数模的最小循环节长度等于，其中表示Fib数模素数的最小循环节长度。可以看出我们现在最重要的就是求

 

 

对于求我们利用如下定理：

 

   如果5是模的二次剩余，那么循环节的的长度是的因子，否则，循环节的长度是的因子。


顺便说一句，对于小于等于5的素数，我们直接特殊判断，loop(2)=3,loop(3)=8,loop(5)=20。


那么我们可以先求出所有的因子，然后用矩阵快速幂来一个一个判断，这样时间复杂度不会很大。

 


模板代码：

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <math.h>

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<M; i++)
    {
        for(int j=0; j<M; j++)
        {
            c.m[i][j] = 0;
            for(int k=0; k<M; k++)
                c.m[i][j] = (c.m[i][j]%MOD + (a.m[i][k]%MOD)*(b.m[k][j]%MOD)%MOD)%MOD;
            c.m[i][j] %= MOD;
        }
    }
    return c;
}

Matrix power(Matrix a,LL k,LL MOD)
{
    Matrix ans = I,p = a;
    while(k)
    {
        if(k & 1)
        {
            ans = multi(ans,p,MOD);
            k--;
        }
        k >>= 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<N; i++)
    {
        if(prime[i])
        {
            p[k++] = i;
            for(int j=i+i; j<N; j+=i)
                prime[j] = false;
        }
    }
}

LL quick_mod(LL a,LL b,LL m)
{
    LL ans = 1;
    a %= m;
    while(b)
    {
        if(b & 1)
        {
            ans = ans * a % m;
            b--;
        }
        b >>= 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<cnt; i++)
    {
        LL record=1;
        if(pri[i]==2)
            record=3;
        else if(pri[i]==3)
            record=8;
        else if(pri[i]==5)
            record=20;
        else
        {
            if(legendre(5,pri[i])==1)
                Work(pri[i]-1);
            else
                Work(2*(pri[i]+1));
            sort(fac,fac+c);
            for(int k=0; k<c; k++)
            {
                Matrix a = power(A,fac[k]-1,pri[i]);
                LL x = (a.m[0][0]%pri[i]+a.m[0][1]%pri[i])%pri[i];
                LL y = (a.m[1][0]%pri[i]+a.m[1][1]%pri[i])%pri[i];
                if(x==1 && y==0)
                {
                    record = fac[k];
                    break;
                }
            }
        }
        for(int k=1; k<num[i]; k++)
            record *= pri[i];
        ans = ans/gcd(ans,record)*record;
    }
    return ans;
}

void Init()
{
    A.m[0][0] = 1;
    A.m[0][1] = 1;
    A.m[1][0] = 1;
    A.m[1][1] = 0;
}

int main()
{
    LL n;
    Init();
    isprime();
    while(cin>>n)
        cout<<find_loop(n)<<endl;
    return 0;
}



典型题目


题目一：http://acm.hdu.edu.cn/showproblem.php?pid=3977

题目二：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=5075

题目三：http://acm.hdu.edu.cn/showproblem.php?pid=3978

题目四：http://acm.hdu.edu.cn/showproblem.php?pid=4291


上面的题目一和题目二基本上是模板题，没有什么可以说的。对于第三题和第四题，我们可以看出题目四实际上是

题目三的简单版，都是一层一层找循环节，我们找出每一层的循环节后即可解决。


下面给出题目三的代码：

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <math.h>

using namespace std;
typedef long long LL;

const int M=2;

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

Matrix per= {1,0,0,1};

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

Matrix power(Matrix a,LL k,LL MOD)
{
    Matrix ans=per,p=a;
    while(k)
    {
        if(k&1)
        {
            ans=multi(ans,p,MOD);
            k--;
        }
        k>>=1;
        p=multi(p,p,MOD);
    }
    return ans;
}

LL gcd(LL a,LL b)
{
    return b? gcd(b,a%b):a;
}

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

//勒让德符号
int legendre(int a,int p)
{
    if(quick_mod(a,(p-1)>>1,p)==1) return 1;
    else                           return -1;
}

const int N=1000005;
const int NN=50005;

bool prime[N];
int p[N];
int num[NN],pri[NN];
int num1[NN],pri1[NN];
int arr[NN];
int loop[N];
int k,cnt,c;

void isprime()
{
    k=0;
    int i,j;
    memset(prime,true,sizeof(prime));
    for(i=2; i<N; i++)
    {
        if(prime[i])
        {
            p[k++]=i;
            for(j=i+i; j<N; j+=i)
            {
                prime[j]=false;
            }
        }
    }
}

void find(int n,int pri[],int num[])
{
    cnt=0;
    int t=(int)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 dfs(int dept,int product=1)
{
    if(dept==cnt)
    {
        arr[c++]=product;
        return;
    }
    for(int i=0; i<=num1[dept]; i++)
    {
        dfs(dept+1,product);
        product*=pri1[dept];
    }
}

int find_loop(int n)
{
    find(n,pri,num);
    int cnt1=cnt;
    LL ans=1;
    for(int i=0; i<cnt1; i++)
    {
        c=0;
        int record=1;
        if(pri[i]==2)
            record=3;
        else if(pri[i]==3)
            record=8;
        else if(pri[i]==5)
            record=20;
        else
        {
            if(legendre(5,pri[i])==1)
                find(pri[i]-1,pri1,num1);
            else
                find(2*(pri[i]+1),pri1,num1);
            dfs(0,1);
            sort(arr,arr+c);
            for(int k=0; k<c; k++)
            {
                Matrix A;
                A.m[0][0]=1;
                A.m[0][1]=1;
                A.m[1][0]=1;
                A.m[1][1]=0;
                Matrix a=power(A,arr[k]-1,pri[i]);
                int x=(a.m[0][0]+a.m[0][1])%pri[i];
                int y=(a.m[1][0]+a.m[1][1])%pri[i];
                if(x==1&&y==0)
                {
                    record=arr[k];
                    break;
                }
            }
        }
        for(int k=1; k<num[i]; k++)
            record*=pri[i];
        ans=ans/gcd(ans,record)*record;
    }
    return ans;
}

void Solve(int p,int k)
{
    loop[0]=p;
    for(int i=1; i<=k; i++)
        loop[i]=find_loop(loop[i-1]);
}

int work(int n,int k,int p)
{
    int t=n;
    LL ret,MOD;
    Matrix ans;
    Matrix A;
    A.m[0][0]=1;
    A.m[0][1]=1;
    A.m[1][0]=1;
    A.m[1][1]=0;
    Solve(p,k);
    for(int i=k; i>=0; i--)
    {
        MOD=loop[i];
        ans=power(A,t,MOD);
        ret=(ans.m[1][0]+ans.m[1][1])%MOD;
        t=ret;
    }
    return ret;
}

int main()
{
    isprime();
    int T,n,k,p,tt=1;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&k,&p);
        printf("Case #%d: %d\n",tt++,work(n,k,p));
    }
    return 0;
}


 

题目：http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1195

 

分析：由于本题数据特别多，开始一直TLE，后来发现矩阵乘法里面如果取模太多会导致速度变得很慢，以前POJ上

     的一道题关于矩阵求和也是因为这个TLE，尽量减少一些取模，速度会有几十倍甚至几百倍的提升。

 

代码：

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <math.h>
#include <map>

using namespace std;
typedef 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<M; i++)
    {
        for(int j=0; j<M; j++)
        {
            c.m[i][j] = 0;
            for(int k=0; k<M; 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 k,LL MOD)
{
    Matrix ans = I,p = a;
    while(k)
    {
        if(k & 1)
        {
            ans = multi(ans,p,MOD);
            k--;
        }
        k >>= 1;
        p = multi(p,p,MOD);
    }
    return ans;
}

int gcd(int a,int b)
{
    return b? gcd(b,a%b):a;
}

const int N = 400005;
const int NN = 5005;

int num[NN],pri[NN];
int fac[NN];
bool flag[NN];
int c;

bool prime[N];
int p[N];
int k;

int cnt1;
int pri1[NN],num1[NN];

void isprime()
{
    k = 0;
    memset(prime,true,sizeof(prime));
    for(int i=2; i<N; i++)
    {
        if(prime[i])
        {
            p[k++] = i;
            for(int j=i+i; j<N; j+=i)
                prime[j] = false;
        }
    }
}

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

int legendre(int a,int p)
{
    if(quick_mod(a,(p-1)>>1,p)==1) return 1;
    else                           return -1;
}

void Solve(int n,int pri[],int num[],int &cnt)
{
    cnt = 0;
    int t = (int)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 dfs(int dept,int cnt,LL product,int pri1[],int num1[])
{
    if(dept == cnt)
    {
        fac[c++] = product;
        return;
    }
    for(int i=0; i<=num1[dept]; i++)
    {
        dfs(dept+1,cnt,product,pri1,num1);
        product *= pri1[dept];
    }
}

map<int,int> mp;

LL find_loop(LL n)
{
    int cnt = 0;
    Solve(n,pri,num,cnt);
    LL ans = 1;
    for(int i=0; i<cnt; i++)
    {
        int record=1;
        if(mp.find(pri[i]) != mp.end())
        {
            record = mp[pri[i]];
            goto Test;
        }
        if(pri[i]==2)
            record=3;
        else if(pri[i]==3)
            record=8;
        else if(pri[i]==5)
            record=20;
        else
        {
            if(legendre(5,pri[i])==1)
            {
                c = 0;
                Solve(pri[i]-1,pri1,num1,cnt1);
                dfs(0,cnt1,1,pri1,num1);
            }
            else
            {
                c = 0;
                Solve(2*(pri[i]+1),pri1,num1,cnt1);
                dfs(0,cnt1,1,pri1,num1);
            }
            sort(fac,fac+c);
            for(int r=0; r<c; r++)
                flag[r] = 1;
            for(int k=c-1; k >= 0; k--)
            {
                if(!flag[k]) continue;
                Matrix a = power(A,fac[k]-1,pri[i]);
                int x = (a.m[0][0]%pri[i]+a.m[0][1]%pri[i])%pri[i];
                int y = (a.m[1][0]%pri[i]+a.m[1][1]%pri[i])%pri[i];
                if(x==1 && y==0)
                {
                    record = fac[k];
                }
                else
                {
                    for(int j=0; j<=k; j++)
                    {
                        if(fac[k] % fac[j] == 0)
                            flag[j] = 0;
                    }
                }
            }
            mp[pri[i]] = record;
        }
Test:
        for(int k=1; k<num[i]; k++)
            record *= pri[i];
        ans=ans/gcd(ans,record)*record;
    }
    return ans;
}

void Init()
{
    A.m[0][0] = 1;
    A.m[0][1] = 1;
    A.m[1][0] = 1;
    A.m[1][1] = 0;
}

int main()
{
    int T,n;
    Init();
    mp.clear();
    isprime();
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        LL ans = find_loop(n);
        printf("%I64d\n",ans);
    }
    return 0;
}


 

ACdreamers
关注
  • 9
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Fibonacci数列
会编程的小草
02-19 2618
蓝桥杯入门训练----- Fibonacci数列 问题描述   Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。 当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。   输入格式   输入包含一个整数n。   输出格式   输出一行，包含一个整数，表示Fn除以10007的余数。 说明：在本题中，答案是要求Fn
斐波那契模p循环节
neuq_zsmj的博客
08-27 1863
https://wenku.baidu.com/view/7fc328eb4693daef5ef73d87.html 先上文献资料 这里面提到了几个性质 1.对于和5互质的质数p，如果5是 mod p的二次剩余，那在 mod p 意义下的循环节长度为(p-1)的因子 2.对于和5互质的质数p ，如果5是 mod p 的非二次剩余，那么在 mod p 意义下的循环节长度为(2p+2)的因子 ...
[紫书CH10] 例题10-1：巨大的斐波拉契数(fib循环节、模算术、找规律、UVa11582)
Y-puyu 的博客
04-21 248
文章目录1. 题目来源2. 题目说明3. 题目解析方法一：fib循环节+模算术+找规律 1. 题目来源 链接：UVA11582 Colossal Fibonacci Numbers! 2. 题目说明 中文描述： 输入两个非负整数 a、b 和正整数 n(0≤a,b<264,1≤n≤1000)(0≤a,b <2^{64},1≤n≤1000)(0≤a,b<264,1≤n≤1000)...
hdu 1021 斐波那契数列取模（循环节）
ACM,再见！
07-21 2774
http://acm.hdu.edu.cn/showproblem.php?pid=1021 Problem Description There are another kind of Fibonacci numbers: F(0) = 7, F(1) = 11, F(n) = F(n-1) + F(n-2) (n>=2).   Input Inp
C++求循环节位数
爱吃棉花糖~
02-05 743
//求循环节的位数 #include<vector> #include<algorithm> #include<iostream> using namespace std; int f(int n, int m) { vector<int> v; n = n%m; for(;;) { v.push_back(n); n = n*10; n = n%m; if(n==0) return 0; if(find(v.begin
fib：使用任意大的整数记录第n n个斐波那契数
03-04
在数学上，第n个斐波那契数有一个公式。 我已经看到该实现称为O（1）。 但是，这依赖于浮点数并执行诸如浮点取幂之类的操作，因此我不确定它的速度或精度或O（1）是多少。 如果没有溢出，此程序将给出确切的答案-...
fib.rar_斐波那契_求斐波那契数
09-19
对于其他正整数n，我们通过递归调用`fib(n-1)`和`fib(n-2)`来得到F(n)的值。 然而，这种纯递归方法虽然直观，但效率较低，因为它会导致大量的重复计算。例如，为了计算F(24)，我们需要先计算F(23)和F(22)，而计算F...
Fib.rar_fib
09-24
2. "Fib数列前N项.cpp" - 这是核心的斐波那契数列计算程序，它应该能根据输入的整数N，生成并输出斐波那契数列的前N项。通常，这样的程序会使用循环或者递归的方式来实现。 3. "Fib数列前N项.plg" - 这个文件的扩展...
fib.rar_fib
09-20
return (fib_recursive(n-1, m) + fib_recursive(n-2, m)) % m ``` 由于斐波那契数列的增长速度非常快（大约以黄金比例φ的幂次增长），所以当n较大时，计算F(n)可能会超出大多数编程语言的整数范围，因此在实际...
fib.rar_fib.c
09-21
printf("请输入要计算的菲波拉契数列项数："); scanf("%d", &n); printf("第%d项是：%d\n", n, fibonacci(n)); return 0; } ``` 在"fib.cpp"文件中，可能是C++版本的实现，与C语言版本类似，只是语法上有细微...
1/n循环节长度
逐梦者
08-05 4022
ACM模版1/n循环节长度int euler(int n) { int res = n, a = n; for (int i = 2; i * i <= a; i++) { if (a % i == 0) { res = res / i * (i - 1); while (a % i == 0)
递推式循环节
shiyuan的专栏
07-06 3099
前天晚上去acdream群赛找虐，看到一道斐波那契数列的题，
蓝桥杯 循环小数 模拟除法 解题报告
colorfulshark
03-18 3342
1/7 = 0.142857142... 是个无限循环小数。 任何有理数都可以表示为无限循环小数的形式。   本题目要求即是：给出一个数字的循环小数表示法。   例如： 输入： 1,5 则输出： 0.2   输入： 1,7 则输出： 0.[142857]   输入： 7,6 则输出: 1.1[6]   用户输入的格式是：
求循环小数的循环节C/C++
gwk1234567的博客
05-24 4267
面对1/n这样的运算，有时候会出现无限循环 即给定一个数n,输出1/n的结果，若是循环小数，则只输出第一个循环节。例如：输入 n 3 输出 0.3 直接上代码讲解： #include <algorithm> #include <iostream> using namespace std; int a[100005];//此数组我们从下标1开始 int n; void get(int n) { int length = 1;//先取下标1记录 a[1
求斐波那契数列模n的循环节长度
_Griefs
08-24 332
HDU 3977 一、 #include<iostream> #include<cstdio> #include<algorithm> #include<string> #include<cmath> #include<cstring> #define ll long long using namespace std; con...
na(斐波那契数列对于的模的周期性)
HT008的Blog
09-24 3207
题目大意： 求F(F(N)) 0<=N<=10E100 答案对1e9+7取模这咋求呢，单纯的一个斐波那契数列我们可以用矩阵快速幂来求，但是对于第一层的F（N）我们是需要一个精确值的！咋办？ 用到一个性质！ 如果我们对斐波那契数列进行取模，那么这个数列就变成了一个周期数列！（不知道周期数列的自己百度） PS：我不会证明，找数学竞赛党吧 但是定理没有给出T与模数的关系。。。。 咋整？ 我们可
HDU 4794 Arnold 斐波那契数列循环节
We Can
12-11 2152
Arnold Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 182    Accepted Submission(s): 33 Problem Description Do you know Vladimir
求解斐波那契数列模$p$意义下最短循环节
weixin_30856965的博客
10-17 387
如题，毕克老师给我们出的noip(NOIplus)模拟赛的\(Day1T1\) 首先我们知道斐波那契数列的特征根 \[\phi_1=\frac{1+\sqrt{5}}{2}\] \[\phi_2=\frac{1-\sqrt{5}}{2}\] 于是 \[F_n=\frac{\phi_1^n-\phi_2^n}{\sqrt{5}}\] 对于不为\(5\)的质数\(p\) 若\(5\)是模\(...
斐波那契数列
热门推荐
nameofcsdn的博客
04-06 1万+
目录 一，斐波那契数列（Fibonacci sequence） 二，斐波那契数列模n的周期 ​ 三，OJ实战 2017年院赛A题 Neptune'Pudding CSU 1402: Fibonacci Multiply CSU 1587 爬楼梯 HDU - 2041 超级楼梯 HDU - 2046 骨牌铺方格 HDU 2044 一只小蜜蜂... HDU - 1021 Fibonacci Again Evil teacher HDU - 3977（斐波那契数列模n的周期） HD.
python中 def fib(n)
最新发布
05-11
这是一个定义斐波那契数列的函数，其中n表示要计算的数列项数。以下是一个示例实现： ```python def fib(n): if n <= 1: return n else: return fib(n-1) + fib(n-2) ``` 在这个函数中，当n小于等于1时，直接返回n。否则，通过递归调用函数自身来计算斐波那契数列的前n项之和。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值