zoukankan      html  css  js  c++  java
  • 斐波那契数列

    数字政通第一题:员工每年共有n天休假,可以选择1天或者连续2天申请调休,问员工一共有多少种可以休假的选择方式?

    题目类似于下题。

     1 #include "stdafx.h"
     2 #include <iostream>
     3 
     4 template<class T>
     5 bool FibArray(T a[], int n)             //数组版
     6 {
     7     if (n < 1)
     8         return false;
     9 
    10     a[0] = 1;
    11     a[1] = 1;
    12 
    13     for (int i = 2; i < n; ++i)
    14         a[i] = a[i-1] + a[i-2];
    15 
    16     return true;
    17 }
    18 
    19 template<class T>
    20 T FibRecursion(int n)                   //递归版
    21 {
    22     if (n<0)
    23         return -1;
    24 
    25     if (n == 0 || n == 1)
    26         return 1;
    27 
    28     return FibRecursion<T>(n-1) + FibRecursion<T>(n-2);     
    29 }
    30 
    31 int _tmain(int argc, _TCHAR* argv[])
    32 {
    33     double a[100];
    34     FibArray<double>(a, 100);
    35     int result = FibRecursion<int>(30);                
    36     system("pause");
    37     return 0;
    38 }

    参考:http://www.jb51.net/article/37286.htm

    一:递归实现
    使用公式f[n]=f[n-1]+f[n-2],依次递归计算,递归结束条件是f[1]=1,f[2]=1。
    二:数组实现
    空间复杂度和时间复杂度都是0(n),效率一般,比递归来得快。
    三:vector<int>实现
    时间复杂度是0(n),时间复杂度是0(1),就是不知道vector的效率高不高,当然vector有自己的属性会占用资源。
    四:queue<int>实现
    当然队列比数组更适合实现斐波那契数列,时间复杂度和空间复杂度和vector<int>一样,但队列太适合这里了,
    f(n)=f(n-1)+f(n-2),f(n)只和f(n-1)和f(n-2)有关,f(n)入队列后,f(n-2)就可以出队列了。
    五:迭代实现
    迭代实现是最高效的,时间复杂度是0(n),空间复杂度是0(1)。
    六:公式实现
    百度的时候,发现原来斐波那契数列有公式的,所以可以使用公式来计算的。
    由于double类型的精度还不够,所以程序算出来的结果会有误差,如果把公式展开计算,得出的结果就是正确的。
    完整的实现代码如下:

     1 #include "iostream"
     2 #include "queue"
     3 #include "cmath"
     4 using namespace std;
     5 int fib1(int index)     //递归实现
     6 {
     7     if(index<1)
     8     {
     9         return -1;
    10     }
    11     if(index==1 || index==2)
    12         return 1;
    13     return fib1(index-1)+fib1(index-2);
    14 }
    15 int fib2(int index)     //数组实现
    16 {
    17     if(index<1)
    18     {
    19         return -1;
    20     }
    21     if(index<3)
    22     {
    23         return 1;
    24     }
    25     int *a=new int[index];
    26     a[0]=a[1]=1;
    27     for(int i=2;i<index;i++)
    28         a[i]=a[i-1]+a[i-2];
    29     int m=a[index-1];
    30     delete a;         //释放内存空间
    31     return m;
    32 }
    33 int fib3(int index)           //借用vector<int>实现
    34 {
    35     if(index<1)
    36     {
    37         return -1;
    38     }
    39     vector<int> a(2,1);      //创建一个含有2个元素都为1的向量
    40     a.reserve(3);
    41     for(int i=2;i<index;i++)
    42     {
    43         a.insert(a.begin(),a.at(0)+a.at(1));
    44         a.pop_back();
    45     }
    46     return a.at(0);
    47 } 
    48 int fib4(int index)       //队列实现
    49 {
    50     if(index<1)
    51     {
    52         return -1;
    53     }
    54     queue<int>q;
    55     q.push(1);
    56     q.push(1);
    57     for(int i=2;i<index;i++)
    58     {
    59         q.push(q.front()+q.back());
    60         q.pop();
    61     }
    62     return q.back();
    63 }
    64 int fib5(int n)          //迭代实现
    65 {
    66     int i,a=1,b=1,c=1;
    67     if(n<1)
    68     {
    69         return -1;
    70     }
    71     for(i=2;i<n;i++)
    72     {
    73         c=a+b;     //辗转相加法(类似于求最大公约数的辗转相除法)
    74         a=b;
    75         b=c;
    76     }
    77     return c;
    78 }
    79 int fib6(int n)
    80 {
    81     double gh5=sqrt((double)5);
    82     return (pow((1+gh5),n)-pow((1-gh5),n))/(pow((double)2,n)*gh5);
    83 } 
    84 int main(void)
    85 {
    86     printf("%d
    ",fib3(6));
    87     system("pause");
    88     return 0;
    89 }

    七:二分矩阵方法

     1 void multiply(int c[2][2],int a[2][2],int b[2][2],int mod)
     2 {
     3     int tmp[4];
     4     tmp[0]=a[0][0]*b[0][0]+a[0][1]*b[1][0];
     5     tmp[1]=a[0][0]*b[0][1]+a[0][1]*b[1][1];
     6     tmp[2]=a[1][0]*b[0][0]+a[1][1]*b[1][0];
     7     tmp[3]=a[1][0]*b[0][1]+a[1][1]*b[1][1];
     8     c[0][0]=tmp[0]%mod;
     9     c[0][1]=tmp[1]%mod;
    10     c[1][0]=tmp[2]%mod;
    11     c[1][1]=tmp[3]%mod;
    12 }//计算矩阵乘法,c=a*b
    13 int fibonacci(int n,int mod)//mod表示数字太大时需要模的数
    14 {
    15     if(n==0)return 0;
    16     else if(n<=2)return 1;//这里表示第0项为0,第1,2项为1
    17     int a[2][2]={{1,1},{1,0}};
    18     int result[2][2]={{1,0},{0,1}};//初始化为单位矩阵
    19     int s;
    20     n-=2;
    21     while(n>0)
    22     {
    23         if(n%2 == 1)
    24             multiply(result,result,a,mod);
    25         multiply(a,a,a,mod);
    26         n /= 2;
    27     }//二分法求矩阵幂
    28     s=(result[0][0]+result[0][1])%mod;//结果
    29     return s;
    30 }

    附带的再贴上二分法计算a的n次方函数。

     1 int pow(int a,int n)
     2 {
     3     int ans=1;
     4     while(n)
     5     {
     6         if(n&1)
     7             ans*=a;
     8         a*=a;
     9         n>>=1;
    10     }
    11     return ans;
    12 }
  • 相关阅读:
    TCP/IP 网路基础
    三、Django之请求与响应-Part 1
    二、Django快速安装
    Linux 优化详解
    缓存的正确使用方式
    HTML从入门到放弃
    Ansible开发之路
    程序猿数据库学习指南
    MySQL错误代码大全
    Python之网络编程
  • 原文地址:https://www.cnblogs.com/kira2will/p/3983134.html
Copyright © 2011-2022 走看看