斐波那契数列 递推 递归 备忘录 动态规划

当n=0时，f(n) = 0     

当n=1时，f(n) = 1

当n>1时，f(n) = f(n-1) + f(n-2)

递归算法：

[cpp]  view plain copy

1. int fun(int n)  
2. {  
3.     if(n <= 0)  
4.         return 0;  
5.     if(n == 1)  
6.         return 1;  
7.   
8.     return fun(n-1)+fun(n-2);  
9. }  

备忘录方法：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. const int N = 100;  
5. int f[N];  
6.   
7. int fun(int n)  
8. {  
9.     if(f[n]>=0)  
10.         return f[n];  
11.   
12.     if(n == 0)  
13.     {  
14.         f[0] = 0;  
15.         cout<<"0"<<endl;  
16.         return f[0];  
17.     }  
18.   
19.     if(n == 1)  
20.     {  
21.         f[1] = 1;  
22.         cout<<"1"<<endl;  
23.         return f[1];  
24.     }  
25.   
26.     cout<<n<<endl;  
27.     f[n] = fun(n-1) + fun(n-2);  
28.     return f[n];  
29. }  
30.   
31. int main()  
32. {  
33.     for (int i=0; i<N; i++)  
34.         f[i] = -1;  
35.   
36.     cout<<fun(4);  
37.     return 0;  
38. }  

由于计算的时候只需要前两个数即可，所以代码还可以继续优化。但是对于上述的备忘录方法貌似不能继续进行空间优化了(不知道对否，如果理解的不对请不吝赐教~)。

但是对于下面的方法（就称为遍历方法吧）,还是可以继续优化的。  自底向上的动态规划

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. const int N = 100;  
5. int f[N];  
6.   
7. int main()  
8. {  
9.       
10.     int n;  
11.     cin>>n;  
12.   
13.     for (int i=0; i<=n; i++)  
14.     {  
15.         if(i==0)  
16.             f[i] = 0;  
17.         else if(i==1)  
18.             f[i] = 1;  
19.         else  
20.             f[i] = f[i-1] + f[i-2];  
21.     }  
22.   
23.     cout<<f[n];  
24.   
25.     return 0;  
26. }  

   斐波那契数（动态规划）

通过把所计算的值存储在递归过程的外部数组中，明确地避免重复计算。这一程序计算的时间与N成正比。

                  int F(int i)

                  {

 

                          if(knownF[i] != unknown)

                                 return knownF[i];

                          if(i == 0) t = 0;

                          if(i == 1) t = 1;

                          if(i > 1)  t = F(i - 1) + F(i - 2);

                          return knownF[i] = t;

                  }

自顶向下的动态规划

由于计算的时候只用了前两个数，所以没有必要使用数组。

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. int main()  
5. {  
6.     int n;  
7.     cin>>n;  
8.   
9.     int temp1, temp2, temp;  
10.     for (int i=0; i<=n; i++)  
11.     {  
12.         if(i==0)  
13.             temp1 = 0;  
14.         else if(i==1)  
15.             temp2 = 1;  
16.         else  
17.         {  
18.             temp = temp1 + temp2;  
19.             temp1 = temp2;  
20.             temp2 = temp;  
21.               
22.         }  
23.     }  
24.   
25.     cout<<temp;  
26.   
27.     return 0;  
28. }  

总结：从代码中可以看出来，遍历方法实际上是一种自底向上的方法，而备忘录方法是一种自顶向下的方法，也许正由于这个原因造成了备忘录方法无法进行空间优化。(待证)