Chapter 09 section 01 C++ codes updated. Java codes added.

liuyubobobo · liuyubobobo · commit 9ad390b6924e · 2017-11-18T22:21:08.000-08:00
diff --git a/09-Dynamic-Programming/Course Code (C++)/01-Fibonacci/main.cpp b/09-Dynamic-Programming/Course Code (C++)/01-Fibonacci/main.cpp
@@ -5,6 +5,7 @@ using namespace std;
 
 int num = 0;
 
+// 递归求斐波那契数列
 int fib( int n ){
 
     num ++;
@@ -27,9 +28,9 @@ int main() {
     int res = fib(n);
     time_t endTime = clock();
 
-    cout<<"fib("<<n<<") = "<<res<<endl;
-    cout<<"time : "<<double(endTime-startTime)/CLOCKS_PER_SEC<<" s"<<endl;
-    cout<<"run function fib() "<<num<<"times."<<endl;
+    cout << "fib(" << n << ") = " << res << endl;
+    cout << "time : " << double(endTime - startTime) / CLOCKS_PER_SEC << " s" << endl;
+    cout << "run function fib() " << num << " times." << endl;
 
     return 0;
 }
diff --git a/09-Dynamic-Programming/Course Code (C++)/01-Fibonacci/main2.cpp b/09-Dynamic-Programming/Course Code (C++)/01-Fibonacci/main2.cpp
@@ -1,24 +1,25 @@
 #include <iostream>
 #include <ctime>
 #include <vector>
+
 using namespace std;
 
 vector<int> memo;
 int num = 0;
 
 // 记忆化搜索
-int fib( int n ){
+int fib(int n){
 
     num ++;
 
-    if( n == 0 )
+    if(n == 0)
         return 0;
 
-    if( n == 1 )
+    if(n == 1)
         return 1;
 
-    if( memo[n] == -1 )
-        memo[n] = fib(n-1) + fib(n-2);
+    if(memo[n] == -1)
+        memo[n] = fib(n - 1) + fib(n - 2);
 
     return memo[n];
 }
@@ -28,16 +29,17 @@ int main() {
     num = 0;
 
     //int n = 42;
-    int n = 1000;
-    memo = vector<int>(n+1,-1);
+    int n = 1000; // 注意: 我们使用n = 1000只是为了测试性能, 实际上会溢出
+                  // 斐波那契额数列是以指数速度上涨的
+    memo = vector<int>(n + 1, -1);
 
     time_t startTime = clock();
     int res = fib(n);
     time_t endTime = clock();
 
-    cout<<"fib("<<n<<") = "<<res<<endl;
-    cout<<"time : "<<double(endTime-startTime)/CLOCKS_PER_SEC<<" s"<<endl;
-    cout<<"run function fib() "<<num<<"times."<<endl;
+    cout << "fib(" << n << ") = " << res << endl;
+    cout << "time : " << double(endTime - startTime) / CLOCKS_PER_SEC << " s" << endl;
+    cout << "run function fib() " << num << "times." << endl;
 
     return 0;
 }
diff --git a/09-Dynamic-Programming/Course Code (C++)/01-Fibonacci/main3.cpp b/09-Dynamic-Programming/Course Code (C++)/01-Fibonacci/main3.cpp
@@ -6,26 +6,28 @@ using namespace std;
 // 动态规划
 int fib( int n ){
 
-    vector<int> memo(n+1, -1);
+    vector<int> memo(n + 1, -1);
 
     memo[0] = 0;
     memo[1] = 1;
-    for( int i = 2 ; i <= n ; i ++ )
-        memo[i] = memo[i-1] + memo[i-2];
+    for(int i = 2 ; i <= n ; i ++)
+        memo[i] = memo[i - 1] + memo[i - 2];
 
     return memo[n];
 }
 
 int main() {
 
-    int n = 1000;
+    // int n = 42
+    int n = 1000; // 注意: 我们使用n = 1000只是为了测试性能, 实际上会溢出
+                  // 斐波那契额数列是以指数速度上涨的
 
     time_t startTime = clock();
     int res = fib(n);
     time_t endTime = clock();
 
-    cout<<"fib("<<n<<") = "<<res<<endl;
-    cout<<"time : "<<double(endTime-startTime)/CLOCKS_PER_SEC<<" s"<<endl;
+    cout << "fib(" << n << ") = " << res << endl;
+    cout << "time : " << double(endTime - startTime) / CLOCKS_PER_SEC << " s" << endl;
 
     return 0;
 }
diff --git a/09-Dynamic-Programming/Course Code (Java)/01-Fibonacci/src/Solution1.java b/09-Dynamic-Programming/Course Code (Java)/01-Fibonacci/src/Solution1.java
@@ -0,0 +1,36 @@
+// 递归求斐波那契数列
+public class Solution1 {
+
+    private int num = 0;
+
+    public int fib( int n ){
+
+        num ++;
+
+        if( n == 0 )
+            return 0;
+
+        if( n == 1 )
+            return 1;
+
+        return fib(n-1) + fib(n-2);
+    }
+
+    public int getNum(){
+        return num;
+    }
+
+    public static void main(String[] args) {
+
+        int n = 42;
+
+        Solution1 solution = new Solution1();
+        long startTime = System.currentTimeMillis();
+        int res = solution.fib(n);
+        long endTime = System.currentTimeMillis();
+
+        System.out.println("fib(" + n + ") = " + res);
+        System.out.println("time : " + (endTime - startTime) + " ms");
+        System.out.println("run function fib() " + solution.getNum() + " times.");
+    }
+}
diff --git a/09-Dynamic-Programming/Course Code (Java)/01-Fibonacci/src/Solution2.java b/09-Dynamic-Programming/Course Code (Java)/01-Fibonacci/src/Solution2.java
@@ -0,0 +1,50 @@
+import java.util.Arrays;
+
+// 记忆化搜索
+public class Solution2 {
+
+    private int num = 0;
+
+    public int fib(int n){
+
+        int[] memo = new int[n + 1];
+        Arrays.fill(memo, -1);
+        return fib(n, memo);
+    }
+
+    private int fib(int n, int[] memo){
+
+        num ++;
+
+        if(n == 0)
+            return 0;
+
+        if(n == 1)
+            return 1;
+
+        if(memo[n] == -1)
+            memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
+
+        return memo[n];
+    }
+
+    public int getNum(){
+        return num;
+    }
+
+    public static void main(String[] args) {
+
+        //int n = 42;
+        int n = 1000; // 注意: 我们使用n = 1000只是为了测试性能, 实际上会溢出
+                      // 斐波那契额数列是以指数速度上涨的
+
+        Solution2 solution = new Solution2();
+        long startTime = System.currentTimeMillis();
+        int res = solution.fib(n);
+        long endTime = System.currentTimeMillis();
+
+        System.out.println("fib(" + n + ") = " + res);
+        System.out.println("time : " + (endTime - startTime) + " ms");
+        System.out.println("run function fib() " + solution.getNum() + " times.");
+    }
+}
diff --git a/09-Dynamic-Programming/Course Code (Java)/01-Fibonacci/src/Solution3.java b/09-Dynamic-Programming/Course Code (Java)/01-Fibonacci/src/Solution3.java
@@ -0,0 +1,33 @@
+import java.util.Arrays;
+
+// 动态规划
+public class Solution3 {
+
+    public int fib(int n){
+
+        int[] memo = new int[n + 1];
+        Arrays.fill(memo, -1);
+
+        memo[0] = 0;
+        memo[1] = 1;
+        for(int i = 2 ; i <= n ; i ++)
+            memo[i] = memo[i - 1] + memo[i - 2];
+
+        return memo[n];
+    }
+
+    public static void main(String[] args) {
+
+        //int n = 42;
+        int n = 1000; // 注意: 我们使用n = 1000只是为了测试性能, 实际上会溢出
+                      // 斐波那契额数列是以指数速度上涨的
+
+        Solution3 solution = new Solution3();
+        long startTime = System.currentTimeMillis();
+        int res = solution.fib(n);
+        long endTime = System.currentTimeMillis();
+
+        System.out.println("fib(" + n + ") = " + res);
+        System.out.println("time : " + (endTime - startTime) + " ms");
+    }
+}
diff --git a/readme.md b/readme.md
@@ -99,13 +99,14 @@
 | 8-1 树形问题 Letter Combinations of a Phone Number | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/01-02-Letter-Combinations-of-a-Phone-Number/) | [Java源码](08-Recurion-and-Backstracking/Course%20Code%20(Java)/01-02-Letter-Combinations-of-a-Phone-Number/src/) |
 | 8-2 什么是回溯 | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/01-02-Letter-Combinations-of-a-Phone-Number/) | [Java源码](08-Recurion-and-Backstracking/Course%20Code%20(Java)/01-02-Letter-Combinations-of-a-Phone-Number/src/) |
 | 8-3 排列问题 Permutations | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/03-Permutations/) | [Java源码](08-Recurion-and-Backstracking/Course%20Code%20(Java)/03-Permutations/src/) |
-| 8-4 组合问题 Combinations | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/04-Combinations) | [Java源码] |
-| 8-5 回溯法解决组合问题的优化 | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/05-Combinations-optimized) | [Java源码] |
-| 8-6 二维平面上的回溯法 Word Search | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/06-Word-Search) | [Java源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(Java)/06-Word-Search/src) |
-| 8-7 floodfill算法，一类经典问题 Number of Islands | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/07-Number-of-Islands) | [Java源码] |
-| 8-8 回溯法是人工智能的基础 N Queens | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/08-N-Queens) | [Java源码] |
+| 8-4 组合问题 Combinations | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/04-Combinations/) | [Java源码](08-Recurion-and-Backstracking/Course%20Code%20(Java)/04-Combinations/src/) |
+| 8-5 回溯法解决组合问题的优化 | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/05-Combinations-optimized/) | [Java源码](08-Recurion-and-Backstracking/Course%20Code%20(Java)/05-Combinations-optimized/src/) |
+| 8-6 二维平面上的回溯法 Word Search | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/06-Word-Search/) | [Java源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(Java)/06-Word-Search/src/) |
+| 8-7 floodfill算法，一类经典问题 Number of Islands | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/07-Number-of-Islands/) | [Java源码](08-Recurion-and-Backstracking/Course%20Code%20(Java)/07-Number-of-Islands/src/) |
+| 8-8 回溯法是人工智能的基础 N Queens | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/08-Recurion-and-Backstracking/Course%20Code%20(C%2B%2B)/08-N-Queens/) | [Java源码](08-Recurion-and-Backstracking/Course%20Code%20(Java)/08-N-Queens/src/) |
 | 补充代码1：更多和生成排列相关 | [整理中] | [敬请期待] |
 | 补充代码2：更多和组合相关 | [整理中] | [敬请期待] |
+| 补充代码3：更多和八皇后问题相关 | [整理中] | [敬请期待] |
 | **第九章：动态规划基础** | [章节C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/09-Dynamic-Programming/Course%20Code%20(C%2B%2B)) | [章节Java源码] |
 | 9-1 什么是动态规划 | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/09-Dynamic-Programming/Course%20Code%20(C%2B%2B)/01-Fibonacci) | [Java源码] |
 | 9-2 第一个动态规划问题 Climbing Stairs | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/09-Dynamic-Programming/Course%20Code%20(C%2B%2B)/02-Climbing-Stairs) | [Java源码] |
