昨天，羅拉去面試回來，垂頭喪氣。顯然是面試不順利，我趕忙過去安慰。
經過詢問才知道，羅拉麵試掛在了動態規劃。
說到動態規劃，八哥可就來精神了，於是就結合勞拉的面試題簡單的和她介紹了動態規劃。
事情是這樣的，勞拉的面試官給了她一道題，題目如下：
有一個數列，規律如下：1、1、2、3、5、8、13....
如果要求第N個數值，用程式碼如何實現。
羅拉一看這題，心裡一喜，“這題目，不簡單嗎？”。
於是和麵試官賣弄道：“這不是斐波那契數列嗎？這個數列從第3項開始，每一項都等於前兩項之和”。
面試官笑笑，“沒錯，那麼如何實現求第n個數呢？”
“這簡單，稍後”，羅拉毫不含糊，在紙上啪啪寫下幾行程式碼,很快哈，兩分鐘不到，她就寫出來了，只用了兩行程式碼。
public class Fibonacci {
public int rec_fib(int n) {
if (n == 1 || n == 2) return 1;
else return rec_fib(rec_fib(n - 1) + rec_fib(n - 2));
}
}
八哥仔細一看，好傢伙，年輕人不講碼德啊，直接遞迴。
在羅拉仔細準備迎接面試官得誇獎的時候。
面試官問：“遞迴，不錯，還有更好的方法嗎？”
羅拉懵了，她覺得自己的程式碼夠簡單，應該沒啥問題吧。
仔細想了一會兒，也沒想出其他的辦法。最後只能和麵試官互道珍重回家等通知了。
那麼，大家發現這個寫法的問題了嗎？
下面八哥就和大家嘮嗑嘮嗑。
首先，寫法肯定是沒問題的，但是問題出在遞迴上面。
下面，我們分別計算一下n=10 和 n=45 的時候，看看這個程式耗費的時間
public class Fibonacci {
public static void main(String[] args) {
long star = System.currentTimeMillis();
System.out.println(rec_fib(10));
long end = System.currentTimeMillis();
System.out.println("計算n=10 耗時："+(end - star)/1000 + "s");
star = System.currentTimeMillis();
System.out.println(rec_fib(45));
end = System.currentTimeMillis();
System.out.println("計算n=45 耗時："+(end - star)/1000 + "s");
}
public static long rec_fib(int n) {
if (n == 1 || n == 2) return 1;
else return rec_fib(n - 1) + rec_fib(n - 2);
}
}
輸出結果如下：
55
計算n=10 耗時：0s
1134903170
計算n=45 耗時：3s
發現沒？計算fn(45)的居然花了三秒多，如果我們計算100，1000那豈不是原地螺旋爆炸？
那為啥會計算fn(45)會花這麼多時間呢？接下來我們就分析分析。
首先我們根據這個數列的特點，很容易寫出下面的推導公式。
然後，我們可以畫一下遞迴圖
發現問題沒有？是不是發現有些資料被多次計算？比如f(48)被算了兩次，f(47)會被算3次，越往下算的越多。
仔細想想，按照這樣重複計算，n = 50那得重複多少次啊。
我們再來分析一下羅拉寫的這個演算法的時間複雜度。
按照我們這麼拆分下去，很容易發現，這玩意就基本等於一顆完全二叉樹了。自然時間複雜度就是：
指數級別的時間複雜度，不爆炸都對不起遞迴了好吧。
出了問題，我們就要解決問題。
打蛇打七寸，既然知道痛點是重複計算，那我們從重複計算的地方著手就好了。
我們很容易想到把計算過的值存起來，用的時候直接用就好了。
比如我們可以用資料記錄計算過的值。
羅拉聽完，若有所思，隨後啪啪一份程式碼就出來了。
public class Fibonacci {
public static long men_fib(int n) {
if (n < 0) return 0;
if (n <= 2) return 1;
long[] men = new long[n + 1];
men[1] = 1;
men[2] = 1;
menHelper(men, n);
return men[n];
}
public static long menHelper(long[] men, int n) {
if (n == 1 || n == 2) return 1;
if (men[n] != 0) return men[n];
men[n] = menHelper(men, n - 1) + menHelper(men, n - 2);
return men[n];
}
}
使用一個men[n]陣列記錄計算過的值，這樣避免了重複計算。
這個時候羅拉又重新執行f(10)和fn(45),檢視執行時間.
public class Fibonacci {
public static void main(String[] args) {
long star = System.currentTimeMillis();
System.out.println(men_fib(10));
long end = System.currentTimeMillis();
System.out.println("計算n=10 耗時：" + (end - star) / 1000 + "s");
star = System.currentTimeMillis();
System.out.println(men_fib(45));
end = System.currentTimeMillis();
System.out.println("計算n=45 耗時：" + (end - star) / 1000 + "s");
}
public static long men_fib(int n) {
if (n < 0) return 0;
if (n <= 2) return 1;
long[] men = new long[n + 1];
men[1] = 1;
men[2] = 1;
menHelper(men, n);
return men[n];
}
public static long menHelper(long[] men, int n) {
if (n == 1 || n == 2) return 1;
if (men[n] != 0) return men[n];
men[n] = menHelper(men, n - 1) + menHelper(men, n - 2);
return men[n];
}
}
執行結果
55
計算n=10 耗時：0s
1134903170
計算n=45 耗時：0s
看，基本都是瞬間執行完。
即使計算f(100)，也很快。
3736710778780434371
計算n=100 耗時：0s
效率提升可觀吧，如果羅拉當時這麼做了，至少還能再蹭一杯茶。然後再相忘江湖吧。
我們使用一個資料記錄計算過的值，相當於整了一個備忘錄，這是遞迴常見的優化方式。這個其實已經有了一點動態規劃的味道。
不過呢，這個帶備忘錄的遞迴屬於自頂向下的方法。那怎麼理解自頂向下呢？廢話不多說，上圖
看這個圖，我們執行的時候是按照這個順序f(50),f(49)...f(1),f(1)執行的吧，從上往下計算，可以粗略的認為這就是自頂向下。
我們還可以採用自底向上的方式，也就是按照下面的形式
我們還是用一個陣列dp記錄計算過值，因為我們已經知道了，第1個和第2個數。所以我們可以通過第1個和第2個數。從1開始，遞推出50,這個就是自底向上。
按照這個思路，羅拉很快，一分鐘不到哈，就寫出了程式碼，年輕人就是雷厲風行。
public static long fib(int n) {
if (n == 1 || n == 2) return 1;
int[] dp = new int[n + 1];
dp[1] = 1;
dp[2] = 1;
for (int i = 3; i <= n; i++)
dp[i] = dp[i - 1] + dp[i - 1];
return dp[n];
}
同樣執行了執行f(10)和fn(45)
public class Fibonacci {
public static void main(String[] args) {
long star = System.currentTimeMillis();
System.out.println(fib(10));
long end = System.currentTimeMillis();
System.out.println("計算n=10 耗時：" + (end - star) / 1000 + "s");
star = System.currentTimeMillis();
System.out.println(fib(45));
end = System.currentTimeMillis();
System.out.println("計算n=100 耗時：" + (end - star) / 1000 + "s");
}
public static long fib(int n) {
if (n == 1 || n == 2) return 1;
int[] dp = new int[n + 1];
dp[1] = 1;
dp[2] = 1;
for (int i = 3; i <= n; i++)
dp[i] = dp[i - 1] + dp[i - 1];
return dp[n];
}
}
檢視執行時間。
55
計算n=10 耗時：0s
1134903170
計算n=45 耗時：0s
答案顯而易見，效果與備忘錄一樣，這個時候我們再分析一下時間複雜度。
這種自底向上方式就是動態規劃。（ps：自頂向上不等於動態規劃）
整個過程，我們就用了一個額外陣列dp,和一個for迴圈，那麼很容易得到時間複雜度為
這對指數級別的時間複雜度，在N比較大的情況下，就是降維打擊啊。
可能有人有疑問了，我如果對遞迴用了備忘錄優化，不是可以達到一樣的效果嗎？這樣的話動態規劃有什麼優勢呢？
年輕人別急嘛，動態規劃沒那麼簡單，當然掌握核心思想也不難。
我這只是舉個例子，其實斐波那契數列沒必要用動態規劃，只是這個例子比較簡單而已，剛好可以用來入門。
動態規劃也不是用於解決這類問題的。
動態規劃通常用來求解最優化問題,一般此類問題有很多的解，我們希望找到一個最優的解(比如最大值、最小值)。
注意我說的是我們找的解是一個最優解，而不是最優解，因為一個問題可能有多個解都是最優解。
是不是有點難以理解？那我舉個例子：
比如，我有100米的鋼材，可以切成不同的長度出售，不同長度價格不同。
就像圖中劃分那樣，如果我們要賺最多錢，怎麼賣比較好呢？
這個時候你用備忘錄就很難做了吧。
怎樣，沒頭緒了吧，別急用動態規劃就很容易做這類題目，至於怎麼做，且聽下回分解。
歡迎關注八哥：兔八哥雜談，會持續更新一些文章。
此文為原創文章，轉自啊請註明出處！！！