递归+记忆化递归+DP：斐波那契数列

递归：算法复杂度O（2^N）

 1 int fib(int n)
 2 {
 3     if (n == 0)
 4     {
 5         return 0;
 6     }
 7     if (n == 1)
 8     {
 9         return 1;
10     }
11
12     return fib(n - 1) + fib(n - 2);
13 }

由于普通的递归会进行大量的重复计算，因此，我们采用记忆化递归，记录出现过的斐波那契数字，不再重复计算。

记忆化递归：算法复杂度O（N）

 1 vector<int> memo;  //memo[i]记录第i个斐波那契数列
 2
 3 int fib(int n)
 4 {
 5     if (n == 0)
 6     {
 7         return 0;
 8     }
 9     if (n == 1)
10     {
11         return 1;
12     }
13     if (memo[n] == -1)
14     {
15         memo[n] = fib(n - 1) + fib(n - 2);
16     }
17
18     return memo[n];
19 }

动态规划：将原问题拆解成若干个子问题，同时保存子问题的答案，使每个子问题只求一次，最终获得原问题答案。

算法复杂度：O（N）

 1 int fib(int n)
 2 {
 3     vector<int> memo(n + 1, -1);
 4
 5     memo[0] = 0;
 6     memo[1] = 1;
 7     for (int i = 2; i <= n; i++)
 8     {
 9         memo[i] = memo[i - 1] + memo[i - 2];
10     }
11     return memo[n];
12 }