斐波那契数列

斐波那契数列是什么?

一、斐波那契数列指的是这样一个数列：1、1、2、3、5、8、13、21、…… 这个数列从第三项开始，每一项都等于前两项之和。

二、应用：通常在个别股票中不是太准确，通常在指数上有用。当市场行情处于重要关键变盘时间区域时，这些数字可以确定具体的变盘时间。使用斐波那契数列时可以由市场中某个重要的阶段变盘点向未来市场推算，到达时间时市场发生方向变化的概率较大。

第一种解法(递归法):

利用C++求解斐波那契数列，我们可以用递归算求解问题，例如，我们需要求斐波那契数列的第n项是什么？我们可以写一个递归函数fun来解决，参数为一个int整数a,我们知道斐波那契数列的第一个数是1，第二个数也是1，所以我们在进行fun函数的时候，如果n==1那么返回1，如果n==2那么也返回1，如果不是1也不是2，那么我们可以进行递归解法，我们知道第n项=第n-1项+第n-2项，那么如果不是1和2,那么返回的就是fun(n-1)+fun(n-2).

递归法代码：

#include<bits/stdc++.h> //万能头文件 
using namespace std; //批准使用std 
int sum=0;
int fun(int n){ //递归函数,求斐波那契数列的第N项数字 
    if(n==0) //如果是第0项数字 
      return 0; //返回0 
    if(n==1) //如果求第一项数字 
      return 1; //返回1 
    sum++;
    return fun(n-1)+fun(n-2); //进行递归式调用 
}
int main(){ //主函数 
    while(1){ //无限循环输入 
        sum=0;
        int n; //定义整数,代表斐波那契数列的第n项数字 
        cin>>n; //输入n 
        cout<<fun(n)<<endl; //输出斐波那契数列的第n项数字的值    
        cout<<sum<<endl;    
    }
    return 0; //结束 
}

第二种解法（递推法）

#include<bits/stdc++.h> //万能头文件 
using namespace std; //允许使用std里面的函数及类 
long long f[5000000]; //记忆化的数组
int main(){ //主函数 
    long long n; //定义整数,代表斐波那契数列的第n项数字 
    f[1]=f[2]=1; //将斐波那契数列的第一项和第二项初始化为1 
    cin>>n; //输入n 
    for(long long i=3;i<=n;i++) //从第三项开始自下而上计算 
      f[i]=f[i-2]+f[i-1]; //f[i-2]和f[i-1]的值绝对是算出来了的 
    cout<<f[n]<<endl;// 输出数组下标为n的值 
    return 0; //结束 
}

第三种解法（递推滚动数组优化法）

#include<iostream>
using namepace std;
int f[3];
int main(){
   int n;
   cin>>n;
   f[1]=f[2]=1;
   for (int i=3;i<=n;i++){
      f[i%3]=f[（i-1）%3]+f[（i-2）%3];
      }
   cout<<f[n%3]<<endl;
   return 0;}

第四种解法（三个变量循环法）

#include<iostream>
using namepace std
int main(){
   int n;
   cin>>n;
   int a, b,c;
   c=a=b=1;
   for (int i=3;i<=n;i++){
      c=b+a;
      a=b;
      b=c;
   
      }
   cout<<c<<endl;
   return 0;}

第五种解法（记忆化递归）

#include<iostream>
#include<cstring>
using namepace std;

int cache[200000];
int find(int n)
// r如果缓存中存在，就直接缓存，否则计算，然后将计算的结果保存到缓存；
{
   if(cache[n]!=-1) return cache[n];
   else
   {
       return cache[n]=find(n-1)+find(n-2);
int main(){
   int n;
   cin>>n;
   memset(cache,-1,sizeof(cache));
   cache[2]=cache[1]=1
   cout<<find(n)<<endl;
   return 0;}

第六种解法（矩阵快速幂法）

#include<bits/stdc++.h>
using namespace std;
struct Matrix{
   int row,column;
   int **v;
   Matrix(){
      memset(v,0,sizeof(v));
   }
};
Matrix multiply(Matrix a,Matrix b){
   Matrix ans;
   ans.row=a.row;
   ans.column=b.column;
   for(int i=1;i<=a.row;i++)
   {
       for(int j=1;j<=b.column;j++)
           for(int k=1;k<=a.column;k++)
           {
               ans.v[i][j]+=a.v[i][k]*b.v[k][j];
            }
       }
      return ans;
    }
Matrix power(Matrix a, long long n){
  Matrix ans,base;
  ans.v[1][1]=ans.v[2][2]=1;
  while(n!=0){
      if(n%2 ==1) ans=multiply(ans,base);
      base=multiply(base,base);
      n/=2;
      }
  return ans;
}
int main(){
  long long n;
  cin>>n;
  Matrix ans, base ,last;
  base.row=2;
  base.column=2;
  base.v[1][1]=base.v[1][2]=base.v[2][1]=1;
  last.row=2;
  last.column=1;
  last.v[1][1]=last.v[2][1]=1;
  if(n==1 ||n==2)
      cout<<1<<endl;
  else{
      ans=power(base,n-2);
      ans=multiply(ans,last);
      cout<<ans.v[1][1]<<endl;}
      
   return 0;}

总结:递归和递推的关系

递推主要指通过找规律找到递推表达式，是一种解决问题的方式

递归是指递归该函数，指递归函数自己调用自己的函数，是一种编程方式