POJ 3070(矩阵快速幂，求斐波那契第n项)

Fibonacci

Time Limit: 1000MS

Memory Limit: 65536K

Description

In the Fibonacci integer sequence, F0 = 0, F1 = 1, and Fn = Fn − 1 + Fn − 2 for n ≥ 2. For example, the first ten terms of the Fibonacci sequence are:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …

An alternative formula for the Fibonacci sequence is

.

Given an integer n, your goal is to compute the last 4 digits of Fn.

Input

The input test file will contain multiple test cases. Each test case consists of a single line containing n (where 0 ≤ n ≤ 1,000,000,000). The end-of-file is denoted by a single line containing the number −1.

Output

For each test case, print the last four digits of Fn. If the last four digits of Fn are all zeros, print ‘0’; otherwise, omit any leading zeros (i.e., print Fn mod 10000).

Sample Input

0
9
999999999
1000000000
-1

Sample Output

0
34
626
6875

Hint

As a reminder, matrix multiplication is associative, and the product of two 2 × 2 matrices is given by

.

Also, note that raising any 2 × 2 matrix to the 0th power gives the identity matrix:

.

问题分析

lz的第一道矩阵快速幂。
之前lz只知道快速幂，没想到还有矩阵快速幂。
那在这里就先稍微讲一下快速幂。

比如求x^11
11的二进制是1011，我们都知道(X^m)*(X^n) = X^(m+n)。所以同样我们也可以将x^11这样来做。（x^11 = x^8*x^2*x^1 = x^(8+2+1)）

int QuickPow(int x,int n)
{
    int res = x;
    int ans = 1;
    while(n)
    {
        if(n&1)
        {
            ans = ans * res;
        }
        res = res*res;
        n = n>>1;
    }
    return ans;
}

求x^n还有一种求法就是二分递归来求。利用x^n = x^(n/2)*x^(n/2) （n为偶数时），x^n = x^(n/2)*x^(n/2)*x（n为奇数时）；
具体实现如下

int _pow(int x,int n)
{
    if(n==0)
        return 1;
    if(n==1)
        return x;
    if(n&1==0)
        return _pow(x*x,n/2);
    else
        return _pow(x*x,n/2)*x;
}

这里再说一下
单位矩阵的定义： n*n的矩阵 Matrix ( i , i )=1; 任何一个矩阵乘以单位矩阵就是它本身 n*单位矩阵=n， 可以把单位矩阵等价为整数1。（单位矩阵用在矩阵快速幂中）

好，稍微了解一下后进人正题。

题意：求斐波那契数列的第n项%10000。

因为数据较大，而且题里给出了斐波那契的矩阵公式

这不就是求这个矩阵A（假设为A）的n次嘛。所以Fn就可以通过A^n来求出。

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

#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int n = 2,md = 10000;

struct Matrix
{
    int 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;
        }
    }
    return ans;
}

Matrix quickPow(Matrix a, ll 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;
}

int main()
{
    ll n;
    Matrix a = {
        1,1,
        1,0
    };
    while(cin>>n&&n!=-1)
    {
        Matrix tmp = quickPow(a,n); //a^n 
        cout<< tmp.m[0][1] << endl; //Fn 
    }
    return 0;
}