Chapter 09 Optional 02 codes added.

Author: liuyubobobo

09-Dynamic-Programming/Course Code (C++)/Optional-01-More-about-Fibonacci/CMakeLists.txt

@@ -3,5 +3,5 @@ project(Optional_01_More_about_Fibonacci)
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 
-set(SOURCE_FILES main.cpp)
+set(SOURCE_FILES main3.cpp)
 add_executable(Optional_01_More_about_Fibonacci ${SOURCE_FILES})

09-Dynamic-Programming/Course Code (C++)/Optional-01-More-about-Fibonacci/main1.cpp

@@ -17,8 +17,8 @@ using namespace std;
 /// 依靠的依然是, 求第n个斐波那契数, 我们只需要n-1和n-2两个斐波那契数,
 /// 更小的斐波那契数不需要一直保存。
 ///
-/// Time Complexity: O(n)
-/// Space Complexity: O(1)
+/// 时间复杂度: O(n)
+/// 空间复杂度: O(1)
 class Solution {
 
 public:

09-Dynamic-Programming/Course Code (C++)/Optional-01-More-about-Fibonacci/main2.cpp

@@ -13,8 +13,8 @@ using namespace std;
 /// 幂运算可以使用分治法, 优化为O(logn)的复杂度
 /// 具体该方法的证明, 有兴趣的同学可以自行在互联网上搜索学习。
 ///
-/// Time Complexity: O(logn)
-/// Space Complexity: O(1)
+/// 时间复杂度: O(logn)
+/// 空间复杂度: O(1)
 class Solution {
 
 public:

09-Dynamic-Programming/Course Code (C++)/Optional-01-More-about-Fibonacci/main3.cpp

@@ -17,8 +17,8 @@ using namespace std;
 /// 注意: 这个方法的时间复杂度依然是O(logn)的,因为数的幂运算也需要logn的时间
 /// 但这个方法快于使用矩阵的幂运算符的方法
 ///
-/// Time Complexity: O(logn)
-/// Space Complexity: O(1)
+/// 时间复杂度: O(logn)
+/// 空间复杂度: O(1)
 class Solution {
 
 public:

09-Dynamic-Programming/Course Code (C++)/Optional-02-More-about-LIS/CMakeLists.txt

@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.5)
+project(Optional_02_More_about_LIS)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+
+set(SOURCE_FILES main.cpp)
+add_executable(Optional_02_More_about_LIS ${SOURCE_FILES})

09-Dynamic-Programming/Course Code (C++)/Optional-02-More-about-LIS/main.cpp

@@ -0,0 +1,79 @@
+#include <iostream>
+#include <vector>
+#include <cassert>
+
+using namespace std;
+
+/// 300. Longest Increasing Subsequence
+/// https://leetcode.com/problems/longest-increasing-subsequence/description/
+///
+/// 我们这一章介绍的动态规划法求解LIS问题, 时间复杂度为O(nlogn)的
+/// LIS有一个经典的, 同时也非常巧妙的动态规划方法, 其时间复杂度为O(nlogn)的
+/// 以下为参考代码和简单注释, 如果需要更详细的解释, 大家可以自行在互联网上搜索学习
+/// 通过这个例子, 也请大家再体会改变动态规划的状态定义,
+/// 带来解决问题方法的重大不同, 甚至是时间复杂度数量级上的巨大优化
+///
+/// 时间复杂度: O(nlogn)
+/// 空间复杂度: O(n)
+class Solution {
+
+public:
+    int lengthOfLIS(vector<int>& nums) {
+
+        if(nums.size() == 0)
+            return 0;
+
+        // dp[i] 表示最长长度为i的递增子序列, 最后一个数字的最小值
+        vector<int> dp(nums.size() + 1, INT_MIN);
+        dp[1] = nums[0];
+        int len = 1;
+        for(int i = 1 ; i < nums.size() ; i ++) {
+            if(nums[i] > dp[len]){
+                len ++;
+                dp[len] = nums[i];
+            }
+            else{
+                // 我们的dp数组将是一个单调递增的数组, 所以可以使用二分查找法
+                vector<int>::iterator iter = lower_bound(dp.begin(), dp.begin() + (len + 1), nums[i]);
+                if(*iter != nums[i]){
+                    int index = iter - dp.begin();
+                    assert(index >= 1 && index <= len);
+                    dp[index] = min(dp[index], nums[i]);
+                }
+            }
+        }
+
+        return len;
+    }
+};
+
+int main() {
+
+    int nums1[] = {10, 9, 2, 5, 3, 7, 101, 18};
+    vector<int> vec1(nums1, nums1 + sizeof(nums1)/sizeof(int));
+    cout << Solution().lengthOfLIS(vec1) << endl;
+    // 4
+
+    // ---
+
+    int nums2[] = {4, 10, 4, 3, 8, 9};
+    vector<int> vec2(nums2, nums2 + sizeof(nums2)/sizeof(int));
+    cout << Solution().lengthOfLIS(vec2) << endl;
+    // 3
+
+    // ---
+
+    int nums3[] = {2, 2};
+    vector<int> vec3(nums3, nums3 + sizeof(nums3)/sizeof(int));
+    cout << Solution().lengthOfLIS(vec3) << endl;
+    // 1
+
+    // ---
+
+    int nums4[] = {1, 3, 6, 7, 9, 4, 10, 5, 6};
+    vector<int> vec4(nums4, nums4 + sizeof(nums4)/sizeof(int));
+    cout << Solution().lengthOfLIS(vec4) << endl;
+    // 6
+
+    return 0;
+}

09-Dynamic-Programming/Course Code (Java)/Optional-01-More-about-Fibonacci/src/Solution1.java

@@ -11,8 +11,8 @@
 /// 依靠的依然是, 求第n个斐波那契数, 我们只需要n-1和n-2两个斐波那契数,
 /// 更小的斐波那契数不需要一直保存。
 ///
-/// Time Complexity: O(n)
-/// Space Complexity: O(1)
+/// 时间复杂度: O(n)
+/// 空间复杂度: O(1)
 public class Solution1 {
 
     public int climbStairs(int n) {

09-Dynamic-Programming/Course Code (Java)/Optional-01-More-about-Fibonacci/src/Solution2.java

@@ -7,8 +7,8 @@
 /// 幂运算可以使用分治法, 优化为O(logn)的复杂度
 /// 具体该方法的证明, 有兴趣的同学可以自行在互联网上搜索学习。
 ///
-/// Time Complexity: O(logn)
-/// Space Complexity: O(1)
+/// 时间复杂度: O(logn)
+/// 空间复杂度: O(1)
 public class Solution2 {
 
     public int climbStairs(int n) {

09-Dynamic-Programming/Course Code (Java)/Optional-01-More-about-Fibonacci/src/Solution3.java

@@ -7,8 +7,8 @@
 /// 注意: 这个方法的时间复杂度依然是O(logn)的,因为数的幂运算也需要logn的时间
 /// 但这个方法快于使用矩阵的幂运算符的方法
 ///
-/// Time Complexity: O(logn)
-/// Space Complexity: O(1)
+/// 时间复杂度: O(logn)
+/// 空间复杂度: O(1)
 public class Solution3 {
 
     public int climbStairs(int n) {

09-Dynamic-Programming/Course Code (Java)/Optional-02-More-about-LIS/src/Solution.java

@@ -0,0 +1,80 @@
+import java.util.Arrays;
+
+/// 300. Longest Increasing Subsequence
+/// https://leetcode.com/problems/longest-increasing-subsequence/description/
+///
+/// 我们这一章介绍的动态规划法求解LIS问题, 时间复杂度为O(nlogn)的
+/// LIS有一个经典的, 同时也非常巧妙的动态规划方法, 其时间复杂度为O(nlogn)的
+/// 以下为参考代码和简单注释, 如果需要更详细的解释, 大家可以自行在互联网上搜索学习
+/// 通过这个例子, 也请大家再体会改变动态规划的状态定义,
+/// 带来解决问题方法的重大不同, 甚至是时间复杂度数量级上的巨大优化
+///
+/// 时间复杂度: O(nlogn)
+/// 空间复杂度: O(n)
+public class Solution {
+
+    public int lengthOfLIS(int[] nums) {
+
+        if(nums.length == 0)
+            return 0;
+
+        // dp[i] 表示最长长度为i的递增子序列, 最后一个数字的最小值
+        int dp[] = new int[nums.length + 1];
+        Arrays.fill(dp, Integer.MIN_VALUE);
+
+        int len = 1;
+        dp[1] = nums[0];
+        for(int i = 1 ; i < nums.length ; i ++)
+            if(nums[i] > dp[len]){
+                len ++;
+                dp[len] = nums[i];
+            }
+            else{
+                // 我们的dp数组将是一个单调递增的数组, 所以可以使用二分查找法
+                int index = lowerBound(dp, 0, len, nums[i]);
+                if(dp[index] != nums[i])
+                    dp[index] = Math.min(dp[index], nums[i]);
+            }
+
+        return len;
+    }
+
+    // lowerBound求出arr[l...r]范围里，大于等于target的第一个元素所在的索引
+    private int lowerBound(int[] arr, int l, int r, int target){
+
+        int left = l, right = r + 1;
+        while(left != right){
+            int mid = left + (right - left) / 2;
+            if(arr[mid] >= target)
+                right = mid;
+            else // arr[mid] < target
+                left = mid + 1;
+        }
+        return left;
+    }
+
+    public static void main(String[] args) {
+
+        int nums1[] = {10, 9, 2, 5, 3, 7, 101, 18};
+        System.out.println((new Solution()).lengthOfLIS(nums1));
+        // 4
+
+        // ---
+
+        int nums2[] = {4, 10, 4, 3, 8, 9};
+        System.out.println((new Solution()).lengthOfLIS(nums2));
+        // 3
+
+        // ---
+
+        int nums3[] = {2, 2};
+        System.out.println((new Solution()).lengthOfLIS(nums3));
+        // 1
+
+        // ---
+
+        int nums4[] = {1, 3, 6, 7, 9, 4, 10, 5, 6};
+        System.out.println((new Solution()).lengthOfLIS(nums4));
+        // 6
+    }
+}

readme.md

@@ -121,7 +121,7 @@
 | 9-8 LIS问题 Longest Increasing Subsequence | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/09-Dynamic-Programming/Course%20Code%20(C%2B%2B)/08-Longest-Increasing-Subsequence/) | [Java源码](09-Dynamic-Programming/Course%20Code%20(Java)/08-Longest-Increasing-Subsequence/src/) |
 | 9-9 LCS，最短路，求动态规划的具体解以及更多 | [C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/09-Dynamic-Programming/Course%20Code%20(C%2B%2B)/09-Longest-Common-Subsequence/) | [Java源码](09-Dynamic-Programming/Course%20Code%20(Java)/09-Longest-Common-Subsequence/src/) |
 | 补充代码1：更多和斐波那契数相关 | [C++](09-Dynamic-Programming/Course%20Code%20(C%2B%2B)/Optional-01-More-about-Fibonacci/) | [Java](09-Dynamic-Programming/Course%20Code%20(Java)/Optional-01-More-about-Fibonacci/src/) |
-| 补充代码2：LIS问题的O(nlogn)解法 | [整理中] | [敬请期待] |
+| 补充代码2：LIS问题的O(nlogn)解法 | [C++](09-Dynamic-Programming/Course%20Code%20(C%2B%2B)/Optional-02-More-about-LIS/) | [Java](09-Dynamic-Programming/Course%20Code%20(Java)/Optional-02-More-about-LIS/src/) |
 | 补充代码3：更多和背包问题相关 | [整理中] | [敬请期待] |
 | 补充代码4：另一个经典DP模型：回文子串数 | [整理中] | [敬请期待] |
 | **第十章：贪心算法** | [章节C++源码](https://github.com/liuyubobobo/Play-with-Algorithm-Interview/tree/master/10-Greedy-Algorithms/Course%20Code%20(C%2B%2B)/) | [章节Java源码](10-Greedy-Algorithms/Course%20Code%20(Java)/) |