知识点 -斐波拉契数和线性递推方程取模

知识点 -斐波拉契数和线性递推方程取模

解决问题类型：

斐波那契数列的各种性质

结论：

定义

（1）满足递推方程$F_i=F_{i-1}+F_{i-2},i\ge 3;F_1=F_2=1$，的数列 { F n } \left\{ F_{n} \right\} {Fn​}称为斐波那契数列，$F_n$为斐波那契数。

（2）斐波那契数列的通项公式为$F_n=\frac{1}{\sqrt{5}}\left[{\left(\frac{1+\sqrt{5}}{2}\right)}^n-{\left(\frac{1-\sqrt{5}}{2}\right)}^n\right]$

（3）$F_n\equiv 276601605(691504013^n-308495997^n)(mod(10^9+9))$

性质

• Cassini’s 特征:
  $$F_{n-1}{F}_{n+1}-F_n^2=(-1{)}^n$$
• 加法规则:
  $$F_{n+k}=F_k{F}_{n+1}+F_{k-1}{F}_n$$
• 加法规则推论:
  $$F_{2n}=F_n(F_{n+1}+F_{n-1})$$
• 用上面的结论加归纳法可以证明：对任意正整数 $k$, $F_{nk}$ 是 $F_n$的倍数.
• 逆命题也正确: 如果 $F_m$ 是 $F_n$的倍数,那么m是n的倍数。
• GCD 特征:$$GCD(F_m,F_n)=F_{GCD(m,n)}$$
• 斐波那契数列是欧几里得最差情况的输入

斐波那契编码

一个自然数可以被唯一地表示为斐波那契数的和
$$N=F_{k_1}+F_{k_2}+\dots +F_{k_r}$$
每次贪心地用最大的斐波那契数去减即可。

模p的循环节

​ 对于递推式$x_i=a\ast x_{i-1}+b\ast x_{i-2}$。

​ 如果$c=a^2+4b$是模$p$的二次剩余，那么循环节的的长度是$p-1$的因子，否则，循环节的长度是$(p+1)(p-1)$的因子。

模m的循环节

（1）把m素因子分解，即$m=p_1^{a_1}\ast p_2^{a_2}\ast p_3^{a_3}...\ast p_n^{a_n}$

（2）分别计算Fib数模每个$p_i^{a_i}$的循环节长度，假设长度分别是$l_1,l_2...l_k$

（3）那么Fib模n的循环节长度$L=lcm(l_1,l_2...l_k)$

算$p^a$的循环节要用到定理： 令$G(p)$ 是 $modp$的最小循环节,则 $G(p^a)=G(p)\ast p^{a-1}$

十进制矩阵快速幂

解$M^n$,$n<1e6$,M是2乘2的矩阵,时间复杂度为$O(n\ast log(10)\ast k^3)$, 注意1e6已经是上限。

想法是：$a^{123}=a^3+a^{2\ast 10}+a^{3\ast 100}$

 int len = strlen(str);
    for(int i = len-1;i >= 0;i --) {
        int d = str[i]-'0';
        if(d != 0)  res = res*mat_pow_mod(base,d);
        base = mat_pow_mod(base,10);
    }

复杂度：

例题

牛客多校 -generator 1

给出 $x_0,x_1,a,b,n,MOD$ 求解公式 $x_i=a\ast x_{i-1}+b\ast x_{i-2}$

数据范围： $1\le x_0,x_1,a,b\le 10^9$ $1\le n\le 10^{10^6},10^9\le MOD\le 2\ast 10^9$

代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Scanner;
  
public class Main {
    public static int moder;
  
    public static class Matrix{
        public static final int N = 2;
  
        public int[][] a;
  
        public Matrix(){a = new int[2][2];}
  
        public Matrix multiply(Matrix p){
            Matrix ret = new Matrix();
            for (int i = 0; i < N; ++ i){
                for (int k = 0; k < N; ++ k){
                    for (int j = 0; j < N; ++ j){
                        ret.a[i][j] = (int) ((ret.a[i][j] + 1L * a[i][k] * p.a[k][j]) % moder);
                    }
                }
            }
            return ret;
        }
    }
  
    public static void main(String[] args){
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        try {
            String nextLine = bufferedReader.readLine();
            String[] splitted = nextLine.split(" ");
            int x0 = Integer.parseInt(splitted[0]);
            int x1 = Integer.parseInt(splitted[1]);
            int a = Integer.parseInt(splitted[2]);
            int b = Integer.parseInt(splitted[3]);
            nextLine = bufferedReader.readLine();
            splitted = nextLine.split(" ");
            moder = Integer.parseInt(splitted[1]);
            int x = moder;
            BigInteger mod = BigInteger.ONE;
            for (int i = 2; i * i <= x; ++ i){
                if (x % i == 0){
                    while (x % i == 0){
                        mod = mod.multiply(BigInteger.valueOf(i));
                        x /= i;
                    }
                    mod = mod.multiply(BigInteger.valueOf(i - 1));
                    mod = mod.divide(BigInteger.valueOf(i));
                    mod = mod.multiply(BigInteger.valueOf(i + 1));
                }
            }
            if (x > 1){
                mod = mod.multiply(BigInteger.valueOf(x - 1));
                mod = mod.multiply(BigInteger.valueOf(x + 1));
            }
            BigInteger n = BigInteger.ZERO;
            for (int i = 0; i < splitted[0].length(); ++ i){
                n = n.multiply(BigInteger.TEN).add(BigInteger.valueOf(splitted[0].charAt(i) - '0')).mod(mod);
            }
            n = n.add(mod);
            Matrix aa = new Matrix();
            Matrix ret = new Matrix();
            aa.a[0][1] = 1;
            aa.a[1][0] = b;
            aa.a[1][1] = a;
            ret.a[0][0] = ret.a[1][1] = 1;
            for (int i = 0; i < 4000000; ++i) {
                if (n.testBit(i)) {
                    ret = ret.multiply(aa);
                }
                aa = aa.multiply(aa);
            }
            Long ans = (1L * ret.a[0][0] * x0 + 1L * ret.a[0][1] * x1) % moder;
            System.out.println(ans);
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }
}