Merge branch 'LC-55' into develop

Author: davidyslu

LC-4/README.md

@@ -4,6 +4,8 @@ Given two sorted arrays `nums1` and `nums2` of size `m` and `n` respectively, re
 
 The overall run time complexity should be `O(log (m+n))`.
 
+> * Difficulty: **HARD**
+
 ---
 ## Examples
 
@@ -44,7 +46,7 @@ Output: 2.00000
 - `0 <= m <= 1000`
 - `0 <= n <= 1000`
 - `1 <= m + n <= 2000`
-- `-106 <= nums1[i], nums2[i] <= 106`
+- `-10^6 <= nums1[i], nums2[i] <= 10^6`
 
 ---
 ## Solutions

LC-55/LC-55-1.cpp

@@ -0,0 +1,31 @@
+#include <vector>
+
+using namespace std;
+
+class Solution {
+public:
+    /**
+     * Concepts: Dynamic Programming (DP)
+     * 1. Create an array to store whether we can arrive this index
+     * 2. Iterate entire array
+     */
+    bool canJump(vector<int>& nums) {
+        int numsLen = nums.size();
+        if (numsLen <= 1) {
+            return true;
+        }
+
+        vector<bool> state(numsLen, false);
+        state[0] = true;
+
+        for (int i = 1; i < numsLen; ++i) {
+            for (int j = i -1; j >= 0; --j) {
+                if (state[j] && j + nums[j] >= i) {
+                    state[i] = true;
+                    break;
+                }
+            }
+        }
+        return state[numsLen - 1];
+    }
+};

LC-55/LC-55-2.cpp

@@ -0,0 +1,35 @@
+#include <vector>
+
+using namespace std;
+
+class Solution {
+public:
+    /**
+     * Concepts: Greedy Approach
+     * 1. Create an array to store the maximum reach steps and get initial
+     * 2. Iterate find the maximum reach steps:
+     *    - If the maxReach[i - 1] is lower than index i then return false
+     *    - Else get max(maxReach[i - 1], i + nums[i]) and if maxReach[i] can exceed (nums.size() - 1) then return true
+     */
+    bool canJump(vector<int>& nums) {
+        int numsLen = nums.size();
+        if (numsLen <= 1) {
+            return true;
+        }
+
+        vector<int> maxReach(numsLen);
+        maxReach[0] = nums[0];
+
+        for (int i = 1; i < numsLen; ++i) {
+            if (maxReach[i - 1] < i) {
+                return false;
+            }
+            maxReach[i] = max(maxReach[i - 1], i + nums[i]);
+            if (maxReach[i] >= numsLen - 1) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+};

LC-55/README.md

@@ -0,0 +1,40 @@
+# LC-55 - Jump Game
+
+You are given an integer array `nums`. You are initially positioned at the array's **first index**, and each element in the array represents your maximum jump length at that position.
+
+Return `true` *if you can reach the last index, or `false` otherwise.*
+
+> * Difficulty: **MEDIUM**
+
+---
+## Examples
+
+```
+Input: nums = [2,3,1,1,4]
+Output: true
+Explanation:
+Jump 1 step from index 0 to 1, then 3 steps to the last index.
+```
+
+```
+Input: nums = [3,2,1,0,4]
+Output: false
+Explanation:
+You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index.
+```
+
+---
+## Notes
+
+- `1 <= nums.length <= 10^4`
+- `0 <= nums[i] <= 10^5`
+
+---
+## Solutions
+
+1. Dynamic Programming (DP)
+  - Time complexity: $O(n^2)$
+  - Space complexity: $O(n)$
+2. Greedy Approach
+  - Time complexity: $O(n)$
+  - Space complexity: $O(n)$