斐波那契数列笔记

　　在中学时，我们就知道斐波那契数列是个很神奇的数列，在自然，生物，数学中都能找到他的影子，现在本人总结一下我关于斐波那契数列知识的例题。

　　斐波那契数列公式：

　　

　　

　　因为(1-sqrt(5))/2的绝对值小于1所以当i较大的时候，往往可以忽略掉这一项，f(n)≈((1+Sqrt(5))/2)^n/sqrt(5);

斐波那契数列性质：

　　1.斐波那契数列个位数数每60一循环。

　　2.当n大于1时，有F(n)和F(n-1)互质。

　　3.若i为奇数， f(i)*f(i)=f(i-1)*f(i+1)+1，否则f(i)*f(i)=f(i-1)*f(i+1)-1

　　4. f(n)=f(i)*f(n-i-1)+f(i+1)*f(n-i)

　　5.齐肯多夫定理：任何一个正整数都可以表示为若干个不连续的斐波那契数之和。

定理证明：

　　　　以F(n)来表示第n个斐波那契数。m为任意正整数。

　　　　当m=1,2,3时，因为1=F(2),2=F(3),3=F(4),所以命题成立。下面采用数学归纳法证明定理对任何m均成立。

　　　　假设定理对任何小于m的正整数数都成立。下证命题对m也成立。

　　　　（1）若m是斐波那契数，则命题对m也成立。

　　　　（2）若m不是斐波那契数，设n1是满足F(n1)< m < F(n1 +1)的最大正整数。

　　　　　　　　设m'=m-F(n1),则m'=m-F(n1)<F(n1+1)-F(n1)=F(n1-1)，即m'<F(n1-1)。

　　　　　　　　m'<m，所以由归纳假设，m'可以表示成不连续的斐波那契数之和，即 m'=F(n2)+F(n3)+...+F(nt),

　　　　其中n2>n3>...>nt,且是不连续的整数。又m'< F(n1-1)，所以n2<n1-1，即n2与n1也是不连续的整数。

　　　　故m=F(n1)+m'=F(n1)+F(n2)+F(n3)+...+F(nt),且n1>n2>...>nt是不连续的整数。

　　　　因此，命题对m也成立。

 （证明来自百度百科）

斐波那契数列题：

　　1. HDU 1568：http://acm.hdu.edu.cn/showproblem.php?pid=1568

　　分析：题目要求斐波那契数的前4位，化简上面的公式有：f(n)=n*log10((1+sqrt(5))/2)-log10(sqrt(5))；

　　2. HDU 1021 ：http://acm.hdu.edu.cn/showproblem.php?pid=1021

　　分析：问第n个斐波那契数f(n)%3是否为0？算出前几个找规律：从2开始没4个一循环为yes。

 　　3.HDU 1588 Gauss Fibonacci：http://acm.hdu.edu.cn/showproblem.php?pid=1588

　　分析：有g(i)=k*i+b;求F(g(i)) 其中i从0到n-1的和余上M的值，假设用S(n)来表示。那么我们首先推出S(n)的公式为：S(n)=F(g(0))+F(g(1))+F(g(2))+...+F(g(n-1))=F(b)+F(k*b)+F(2*k+b)+...+F((n-1)*k+b)。可以看出S(n)共有n项斐波那契数，一项项求斐波那契再求和是不现实的。较好的办法是把那n项斐波那契数用矩阵表示出来。对于第n项斐波那契，我们可以构造如下矩阵：

，那么对于S(n）我们就可以表示成如下矩阵形式：S(n)=A^b-1 *mat+A^k+b-1 *mat+A^2*k+b-1 *mat+...+A^(n-1)*k+b-1 *mat。我们令B=A^b-1 *mat,然后在提出公因式B。然后S(n)可化简为：S(n)=(I+A^k +A^2*k+...+A^(n-1)*k ) * B。再令D=A^k ，S(n)进一步化简为：S(n)=( I+D¹ +D² +...D^n-1 ) * B。到这里，S(n)的公式已经是最简单的了，并且也没必要再化简，因为到这里可以用二分法很快求的 D¹ +D² +...D^n-1的值。需要注意的是，k，b的值可能为0，对于这些特殊情况我们也要分情况讨论。

代码如下：

#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
__int64 MOD;

struct Matrix
{
    __int64 map[2][2];
    int n;
    Matrix (int k=0)
    {
        n = 2;
        memset(map, 0, sizeof map);
        if(k) for(int i=0; i<2; i++)
            map[i][i] = 1;
    }
    Matrix operator * (const Matrix &a) const
    {
        Matrix e;
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                for(int k=0; k<n; k++)
                    e.map[i][j] = (e.map[i][j]+ map[i][k]*a.map[k][j]) % MOD;
        return e;
    }
    Matrix operator + (const Matrix &a) const
    {
        Matrix e;
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                e.map[i][j]=(map[i][j]+a.map[i][j]) % MOD;
        return e;
    }
    Matrix Pow(__int64 k) const
    {
        Matrix a = *this;
        Matrix e(1);
        while(k)
        {
            if(k&1)
                e = e * a;
            a = a * a;
            k >>= 1;
        }
        return e;
    }
    Matrix operator * (const __int64 k) const
    {
        Matrix a = *this;
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                a.map[i][j] *= k;
        return a;
    }
    Matrix GuassSum(int k) const
    {
        Matrix a = *this;
        if(k==1) return a;
        Matrix t = this->GuassSum(k/2);
        if(k&1)
        {
            Matrix c = this->Pow(k/2+1);
            t = t + c + c * t;
        }
        else
        {
            Matrix c = this->Pow(k/2);
            t = t + t * c;
        }
        return t;
    }
    void print(char s[]="") const
    { 
        printf("Matrix %s:
", s);
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<n-1; j++)
                printf("%I64d ",map[i][j]);
            printf("%I64d
",map[i][n-1]);
        }
    }
};

int main()
{
    Matrix base, mat, I(1);
    base.map[0][0]=base.map[0][1]=base.map[1][0] = 1;
    mat.map[0][0]=1;
    __int64 k, b, n;
    while(~scanf("%I64d %I64d %I64d %I64d",&k, &b, &n, &MOD))
    {
        if(k==0 && b==0)
            puts("0");
        else if(n==1)
            if(b==0)
                puts("0");
            else
            {
                Matrix B = base.Pow(b-1) * mat;
                printf("%I64d
", B.map[0][0]%MOD);
            }
        else if(b && k)
        {
            Matrix B = base.Pow(b-1) * mat;
            Matrix D = base.Pow(k);
            Matrix ans = (I + D.GuassSum(n-1)) * B;// 注意：矩阵乘法不满足交换律，次数若把B提到（I+D.GuassSum(n-1)）前面会错。下同。
            printf("%I64d
", ans.map[0][0]%MOD);
        }
        else if(b==0 && k)
        {
            Matrix B = base.Pow(k-1) * mat;
            Matrix D = base.Pow(k);
            Matrix ans = (I + D.GuassSum(n-2)) * B;
            printf("%I64d
", ans.map[0][0]%MOD);
        }
        else if(b && k==0)
        {
            Matrix B = base.Pow(b-1) * mat;
            B = B * n;
            printf("%I64d
", B.map[0][0]%MOD);
        }
    }
    return 0;
}