README + 518 + 723

Author: Cappuccinuo

Array/723. Longest Continuous Increasing Subsequence/README.md

@@ -0,0 +1,35 @@
+Time spent : 10 min(self)
+
+GIVEN: an unsorted array of integers
+
+RETURNS: The length of longest continuous increasing subsequence(subarray)
+
+**Example 1:**
+
+```
+Input: [1,3,5,4,7]
+Output: 3
+Explanation: The longest continuous increasing subsequence is [1,3,5], its length is 3. 
+Even though [1,3,5,7] is also an increasing subsequence, it's not a continuous one where 5 and 7 are separated by 4. 
+
+```
+
+**Example 2:**
+
+```
+Input: [2,2,2,2,2]
+Output: 1
+Explanation: The longest continuous increasing subsequence is [2], its length is 1. 
+```
+
+
+
+Sliding window
+
+Every increasing subsequence is disjoint, and the boundary of each such subsequence occurs whenever nums[i - 1] >= nums[i]. When it does, it marks the start of a new increasing subsequence at nums[i], and we store such i in the variable anchor.
+
+
+
+Time complexity: O(N)
+
+Space complexity: O(1)

Array/723. Longest Continuous Increasing Subsequence/Solution.java

@@ -0,0 +1,34 @@
+class Solution {
+    public int findLengthOfLCIS(int[] nums) {
+        if (nums.length == 0) {
+            return 0;
+        }
+        int count = 1;
+        int max = 0;
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] > nums[i - 1]) {
+                count++;
+            }
+            else {
+                max = Math.max(count, max);
+                count = 1;
+            }
+        }
+        max = Math.max(count, max);
+        return max;
+    }
+}
+
+class Solution {
+    public int findLengthOfLCIS(int[] nums) {
+        int ans = 0;
+        int anchor = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (i > 0 && nums[i - 1] >= nums[i]) {
+                anchor = i;
+            }
+            ans = Math.max(ans, i - anchor + 1);
+        }
+        return ans;
+    }
+}

Dynamic Programming/518. Coin Change 2/README.md

@@ -0,0 +1,41 @@
+Time spent : 15min(See hint)
+
+GIVEN: coins of different denominations and a total amount of money
+
+RETURNS: the number of combinations that make up that amount
+
+**Note**:
+You may assume that you have an infinite number of each kind of coin.
+
+**Example 1:**
+
+```
+Input: amount = 5, coins = [1, 2, 5]
+Output: 4
+Explanation: there are four ways to make up the amount:
+5=5
+5=2+2+1
+5=2+1+1+1
+5=1+1+1+1+1
+
+```
+
+**Example 2:**
+
+```
+Input: amount = 3, coins = [2]
+Output: 0
+Explanation: the amount of 3 cannot be made up just with coins of 2.
+
+```
+
+**Example 3:**
+
+```
+Input: amount = 10, coins = [10] 
+Output: 1
+```
+
+
+
+For each coin, we can calculate how many combinations there is for every amount. When coin is 1, all the amount just have 1 combinations. For other coins, dp[i] = dp[i] + dp[i - coin], dp[i] means combinations for amount i.

Dynamic Programming/518. Coin Change 2/Solution.java

@@ -0,0 +1,14 @@
+class Solution {
+    public int change(int amount, int[] coins) {
+        int[] dp = new int[amount + 1];
+        dp[0] = 1;
+        for (int coin : coins) {
+            for (int i = 1; i <= amount; i++) {
+                if (coin <= i) {
+                    dp[i] += dp[i - coin];
+                }
+            }
+        }
+        return dp[amount];
+    }
+}

README.md

@@ -294,6 +294,8 @@
 | 290  |  75  |                      [Sort Colors][75]                       |   Java   |   Medium   |       2018.2.28       |                      Sort                       |                                           |
 | 291  | 435  |               [Non-overlapping Intervals][435]               |   Java   |   Medium   |       2018.2.28       |                     Greedy                      |                                           |
 | 292  | 134  |                      [Gas Station][134]                      |   Java   |   Medium   |       2018.3.1        |                     Greedy                      |                                           |
+| 293  | 518  |                     [Coin Change 2][518]                     |   Java   |   Medium   |       2018.3.1        |               Dynamic Programming               |                                           |
+| 294  | 723  |       [Longest Continuous Increasing Subsequence][723]       |   Java   |    Easy    |       2018.3.1        |                      Array                      |                                           |
 
 
 [1]:<https://leetcode.com/problems/two-sum/> "Two Sum"
@@ -516,6 +518,7 @@
 [503]:<https://leetcode.com/problems/next-greater-element-ii/> "Next Greater Element II"
 [504]:<https://leetcode.com/problems/base-7/> "Base 7"
 [516]:<https://leetcode.com/problems/longest-palindromic-subsequence/> "Longest Palindromic Subsequence"
+[518]:<https://leetcode.com/problems/coin-change-2/> "Coin Change 2"
 [520]:<https://leetcode.com/problems/detect-capital/> "Detect Capital"
 [521]:<https://leetcode.com/problems/longest-uncommon-subsequence-i/> "Longest Uncommon Subsequence I"
 [532]:<https://leetcode.com/problems/k-diff-pairs-in-an-array/> "K-diff pairs in an array"
@@ -575,6 +578,7 @@
 [712]:<https://leetcode.com/problems/minimum-ascii-delete-sum-for-two-strings/> "Minimum ASCII delete Sum for Two Strings"
 [717]:<https://leetcode.com/problems/1-bit-and-2-bit-characters/> "1-bit and 2-bit characters"
 [720]:<https://leetcode.com/problems/longest-word-in-dictionary/> "Longest Word in Dictionary"
+[723]:<https://leetcode.com/problems/longest-continuous-increasing-subsequence/> "Longest Continuous Increasing Subsequence"
 [725]:<https://leetcode.com/problems/split-linked-list-in-parts/> "Split Linked List in Parts"
 [728]:<https://leetcode.com/problems/self-dividing-numbers/> "Self Dividing Numbers"
 [733]:<https://leetcode.com/problems/flood-fill/> "Flood Fill"