斐波那契數列的實現（簡單遞歸和動態規划）

一、簡單遞歸的實現

#include "stdafx.h"
#include <string>
using namespace std;
int f(int n)
{
    if (n == 0)
    {
        return 0;
    }
    if (n == 1)
    {
        return 1;
    }
    return f(n - 1) + f(n - 2);
}
int _tmain(int argc, _TCHAR* argv[])
{
    printf("%d", f(10));
    getchar();
    return 0;
}

　　求解斐波那契數列當中的n=5時的值這個問題的遞歸樹如下圖所示：

     可見遞歸算法由於會多次計算同樣的子問題而出現效率低下的問題，為了避免重復計算子問題，提升算法的效率，可以使用動態規划的思維來改進算法。

二、動態規划算法

1、具有備忘功能的自頂向下算法

     使用一個數組來記錄各個子問題的解，當再一次遇到這一問題的時候直接查找數組來獲得解避免多次計算子問題。

#include "stdafx.h"
#include <string>
using namespace std;
int f(int a[],int n)
{
    if (n == 0)
    {
        a[0] = 0;
        return 0;
    }
    if (n == 1)
    {
        a[1] = 1;
        return 1;
    }
    if (a[n] >= 0)
    {
        return a[n];
    }
    a[n] = f(a, n - 1) + f(a, n - 2);
    return f(a, n - 1) + f(a, n - 2);
}
int _tmain(int argc, _TCHAR* argv[])
{
    int n = 10;//需要求解的數
    int* a = (int*)malloc((n + 1)*sizeof(int));
    for (int i = 0; i < n + 1; i++)
    {
        a[i] = -1;
    }
    printf("%d\n子問題的解", f(a, n));
    for (int i = 0; i < n + 1; i++)
    {
        printf("%d ", a[i]);
    }
    getchar();
    return 0;
}

 

 2、自底向上解決方案

　　先求解子問題再根據子問題的解來求解父問題，斐波那契數列的子問題圖如下：

#include "stdafx.h"
#include <string>
using namespace std;
int f(int a[],int n)
{
    a[0] = 0;
    a[1] = 1;
    for (int i = 2; i <= n; i++)
    {
        a[i] = a[i - 1] + a[i - 2];
    }
    return a[n];
}
int _tmain(int argc, _TCHAR* argv[])
{
    int n = 10;//需要求解的數
    int* a = (int*)malloc((n + 1)*sizeof(int));
    for (int i = 0; i < n + 1; i++)
    {
        a[i] = -1;
    }
    printf("%d\n子問題的解", f(a, n));
    for (int i = 0; i < n + 1; i++)
    {
        printf("%d ", a[i]);
    }
    getchar();
    return 0;
}

　　自底向上的計算方法實現起來非常容易，分析算法，僅從形式上面分析算法可知，算法的時間主要消耗在計算數據規模為n的數組里面的數上面了，所以時間復雜度為O（n）。