poj3070 (斐波那契,矩阵快速幂)

Fibonacci

Time Limit: 1000MS   Memory Limit: 65536K
Total Submissions: 9630   Accepted: 6839

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:

.

求斐波那契序列的公式。

由于该矩阵的特殊结构使得a(n+1)[0][0] = a(n)[0][0]+a(n)[0][1], a(n+1)[0][1] = a(n)[1][1], a(n+1)[1][0] = a(n)[0][1]+a(n)[1][0], a(n+1)[1][1] = a(n)[1][0];

code:

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstring>
 4 #include<vector>
 5 #include<algorithm>
 6 #include<cmath>
 7 #define M(a,b) memset(a,b,sizeof(a))
 8
 9 using namespace std;
10
11 int n;
12 struct matrix
13 {
14     int a[2][2];
15     void init()
16     {
17         a[0][0] = a[1][0] = a[0][1] = 1;
18         a[1][1] = 0;
19     }
20 };
21
22 matrix mamul(matrix a,matrix b)
23 {
24     matrix c;
25     for(int i = 0;i<2;i++)
26     {
27         for(int j = 0;j<2;j++)
28         {
29             c.a[i][j] = 0;
30             for(int k = 0;k<2;k++)
31                 c.a[i][j]+=(a.a[i][k]*b.a[k][j]);
32             c.a[i][j]%=10000;
33         }
34     }
35     return c;
36 }
37
38 matrix mul(matrix s, int k)
39 {
40     matrix ans;
41     ans.init();
42     while(k>=1)
43     {
44         if(k&1)
45             ans = mamul(ans,s);
46         k = k>>1;
47         s = mamul(s,s);
48     }
49     return ans;
50 }
51
52 int main()
53 {
54     while(scanf("%d",&n)==1&n>=0)
55     {
56         if(n==0) puts("0");
57         else
58         {
59             matrix ans;
60             ans.init();
61             ans = mul(ans,n-1);
62             printf("%d\n",ans.a[0][1]%10000);
63         }
64     }
65     return 0;
66 }

下面代码只是测试公式,无法解决取模的问题,因为中间为double型,无法取模:

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstring>
 4 #include<vector>
 5 #include<algorithm>
 6 #include<cmath>
 7 #define M(a,b) memset(a,b,sizeof(a))
 8
 9 using namespace std;
10
11 double Pow(double a,int n)
12 {
13     double ans = 1;
14     while(n>=1)
15     {
16         if(n&1)
17             ans = a*ans;
18         n = n>>1;
19         a = a*a;
20     }
21     return ans;
22 }
23
24 int main()
25 {
26    int n;
27    double a = (sqrt(5.0)+1.0)/2;
28    double b = (-sqrt(5.0)+1.0)/2;
29    double c = (sqrt(5.0))/5;
30    while(scanf("%d",&n)==1)
31    {
32         int ans = (int)(c*(Pow(a,n)-Pow(b,n)))%10000;
33         printf("%d\n",ans);
34    }
35    return 0;
36 }
时间: 2024-10-14 18:13:20

poj3070 (斐波那契,矩阵快速幂)的相关文章

斐波那契 矩阵快速幂

1 #include <iostream> 2 #include <cstdlib> 3 #include <cstring> 4 #include <queue> 5 #include <cstdio> 6 #include <algorithm> 7 #include <map> 8 #include <time.h> 9 #include <ext/pb_ds/assoc_container.hpp

斐波那契优化 快速幂+矩阵乘法

题目:你能求得第n个斐波那契数吗?0<n<maxlongint 由于结果太大,输出的结果mod32768 思路:一般的求斐波那契数列的方法有递归,动归,或者用滚动优化,但是空间复杂或者时间复杂度都太高了,现在有一种用矩阵加快速幂的优化算法,可以让时间复杂度维持在logn. 具体的 初始化一个2×2的矩阵,初始值为{1,0,0,1} 则分别代表{a2,a1,a1,a0},把此矩阵平方后得到{2,1,1,0}分别代表{a3,a2,a2,a1}如此下去,便可以得到规律,其实这个算法主要就是优化在快速

hdu 4549 M斐波那契数列(快速幂 矩阵快速幂 费马小定理)

题目链接http://acm.hdu.edu.cn/showproblem.php?pid=4549: 题目是中文的很容易理解吧.可一开始我把题目看错了,这毛病哈哈. 一开始我看错题时,就用了一个快速幂来解,不用说肯定wa,看题目的通过率也不高,我想会不会有啥坑啊.然而我就是那大坑,哈哈. 不说了,直接说题吧,先讨论k=1,2,3;时的解.这应该会解吧,不多说了: 从第四项开始f(4)=a^1+b^2;f(5)=a^2+b^3;f(6)=a^3+b^5......; 看出来了吧,a上的指数成斐波

算法学习笔记 递归之 快速幂、斐波那契矩阵加速

递归的定义 原文地址为:http://blog.csdn.net/thisinnocence 递归和迭代是编程中最为常用的基本技巧,而且递归常常比迭代更为简洁和强大.它的定义就是:直接或间接调用自身.经典问题有:幂运算.阶乘.组合数.斐波那契数列.汉诺塔等.其算法思想: 原问题可分解子问题(必要条件): 原与分解后的子问题相似(递归方程): 分解次数有限(子问题有穷): 最终问题可直接解决(递归边界): 对于递归的应用与优化,直接递归时要预估时空复杂度,以免出现用时过长或者栈溢出.优化递归就是以

斐波那契加求幂运算

斐波那契博大精深啊,还有求幂的迭代也有点意思 1 //斐波那契有好多中方法 2 #include <iostream> 3 #include <deque> 4 using namespace std; 5 6 //注意普通斐波那契,在太大数时就会发生越界,比如long long 只能存表示第92个数,这些都是小的斐波那契,当要大时,就得用大数方法了 7 //用int ,只能到第46个,47就不行了,unsighed int 只能到92 8 int fibnaq(int n) //

斐波那契数列快速计算

感觉一天时间过得挺快,而自己却没有什么收获. 1.之前恰好看了跟快速幂乘法一样的计算大数乘法模,防止溢出,感觉挺有用的,而且用的挺多的. 2.分析问题的能力还很差,遇到一个问题,无法正确的进行转化,怎么进行考虑,感觉自己这方面还很欠缺,这应该是通过大量做题,然后不断总结得出来的吧!毕竟题做的多了,遇到新题也就那几种套路.感觉也是挺对的,面试题的那些小套路在搞竞赛的人面前根本什么也不是,感觉这句话挺有道理的. 3. 这次做的这道题,最后就是转化为求第n个斐波那契数,而我根本没有推导出这个.然后,之

矩阵乘法&amp;&amp;矩阵快速幂&amp;&amp;最基本的矩阵模型——斐波那契数列

矩阵,一个神奇又令人崩溃的东西,常常用来优化序列递推 在百度百科中,矩阵的定义: 在数学中,矩阵(Matrix)是一个按照长方阵列排列的复数或实数集合 ,最早来自于方程组的系数及常数所构成的方阵.这一概念由19世纪英国数学家凯利首先提出. 好,很高深对吧.那我们就更加直接地理解一下矩阵的实质:二维数组 好了这个SB都会,就不解释了 同二维数组一样,矩阵是一个'纵横排列的二维数据表格',它一般是一个n*m的二维数组,其中n*m表示它有n行m列 每一位上的数可以用下标i,j来表示,形如这样一个矩阵:

求:简单又困难的 “斐波那契数列”代码

下面给出上篇博客的代码解释具体的我也在注释里面写清楚了. 至于矩阵构造嘛..还是要看个人悟性(也有运气),显然这个我还是不行的,这个矩阵初始化我复制的. 1 #include <cstdio> 2 #include <cstring> 3 const int M = 1E9 + 7; 4 struct Matrix { 5 long long a[2][2]; 6 Matrix() { memset(a, 0, sizeof(a)); } //构造矩阵 7 //定义矩阵乘法 8 M

斐波拉契数列、楼梯问题、奶牛问题

斐波拉契数列:波那契数列,又称黄金分割数列,指的是这样一个数列:0.1.1.2.3.5.8.13.21.34.--在数学上,斐波纳契数列以如下被以递归的方法定义:F(0)=0,F(1)=1,F(n)=F(n-1)+F(n-2)(n≥2,n∈N*)[from 百度百科 http://baike.baidu.com/link?url=8LKtKTAllUGDMe610zIO0DAjS3CCeAOpXiCFvH_Y47_I_XDRgzyGcrzsodd1OHO726FJNPWkqzkQC7PIuGu_