HDU 4549（矩阵快速幂+费马小定理）

M斐波那契数列

Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)

Problem Description

M斐波那契数列F[n]是一种整数数列，它的定义如下：

F[0] = a
F[1] = b
F[n] = F[n-1] * F[n-2] ( n > 1 )

现在给出a, b, n，你能求出F[n]的值吗？

Input

输入包含多组测试数据；
每组数据占一行，包含3个整数a, b, n（ 0 <= a, b, n <= 10^9 ）

Output

对每组测试数据请输出一个整数F[n]，由于F[n]可能很大，你只需输出F[n]对1000000007取模后的值即可，每组数据输出一行。

Sample Input

0 1 0
6 10 2

Sample Output

0
60

问题分析

又是一道矩阵快速幂的题，通过题里给出的条件我们再往后推几项就可以发现本题的通项公式是
F[n]=a (n=0)；
F[n]=a^Fib[n-1]*b^Fib[n] (n>0)。
然后题里又要求mod（1e9+7），即求Fn%(1e9+7)。
所以我们可以化为F[n]%m=a^(Fib[n-1]%(m-1))*b^(Fib[n]%(m-1))%m（为了方便，设m = 1e9+7）；
这里可以转换成这样是利用了费马小定理的性质（如下）：

若p是素数，gcd(a,p)=1,则a^(p-1)%p ≡ 1。

若a^b mod p 中b很大，则可以简化为a^b mod p = a^[b mod (p-1)] mod p

证明如下：

b=t*(p-1)+r，其中r为b除以(p-1)的余数，即为b mod (p-1)。

a^b=(a^(p-1))^t * a^r ≡ 1^t * a^r ≡ a^r (mod p)

费马小定理的推广：如果p为质数，x^p-x（x是任意正整数）必能被p整除。

好，接下来上AC code（^_^）

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;
typedef long long ll;
const int n = 2,md = 1e9+7;

struct Matrix
{
    ll m[n][n];
};

Matrix mul(Matrix a, Matrix b) //矩阵乘法模板 
{
    Matrix ans;
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            ans.m[i][j] = 0;
            for(int k = 0; k < n; k++)
            {
                ans.m[i][j] += a.m[i][k]*b.m[k][j];
            }
            ans.m[i][j] %= (md-1);//注意这里
        }
    }
    return ans;
}

Matrix quickPow(Matrix a, int b) //矩阵快速幂模板
{
    Matrix ans = {    //单位矩阵
        1,0,
        0,1
    }; 
    Matrix tmp = a;
    while(b) {
        if(b&1)
            ans = mul(ans,tmp);
        tmp = mul(tmp,tmp);
        b >>= 1;
    }
    return ans;
}

ll pow_(ll a,ll n)
{
    ll ans = 1, res = a%md;
    while(n){
        if(n&1) {
            ans = ans*res;
            ans %= md;
        }
        res = res*res;
        res %= md;
        n >>= 1;
    }
    return ans;
}

int main()
{
    Matrix t = {
        0,1,
        1,1
    };
    int a,b,n; 
    while(~scanf("%d%d%d",&a,&b,&n))
    {
        Matrix tmp = quickPow(t,n);

        //F[n]%m=a^(Fib[n-1]%(m-1))*b^(Fib[n]%(m-1))%m
        int ans = (pow_(a,tmp.m[0][0])*pow_(b,tmp.m[1][0]))%md;
        printf("%d\n",ans); 
    }
    return 0;
}