274_H-Index

322_Coin_Change

Author: qiyuangong

README.md

@@ -86,8 +86,10 @@
 | 259 | [3Sum Smaller](https://leetcode.com/problems/3sum-smaller/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/259_3Sum_Smaller.py) | 1. Reduce to two sum smaller, then binary search, O(n^2lgn) and O(1)<br>2. Reduce to two sum smaller, then two points, O(n^2) and O(1)|
 | 266 | [Palindrome Permutation](https://leetcode.com/problems/palindrome-permutation/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/266_Palindrome_Permutation.py) | Compute frequency, check number of odd occurrences <= 1 then palindrome, O(n) and O(n)|
 | 267 | [Palindrome Permutation II](https://leetcode.com/problems/palindrome-permutation-ii/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/267_Palindrome_Permutation_II.py) | Check palindrome then generate half with [Permutations II](https://leetcode.com/problems/permutations-ii/), O(n^2) and O(n^2) |
+| 274 | [H-Index](https://leetcode.com/problems/h-index/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/274_H-Index.py) | [Background](https://en.wikipedia.org/wiki/H-index)<br>1. Sort and check number of papers greater than h, O(nlogn) and O(1)<br>2. Counting sort, O(n) and O(n) |
 | 288 | [Unique Word Abbreviation](https://leetcode.com/problems/unique-word-abbreviation/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/288_Unique_Word_Abbreviation.py) | hash |
 | 305 | [Number of Islands II](https://leetcode.com/problems/number-of-islands-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/305_Number_of_Islands_II.py) | Quick union find with weights, O(nlogn) and O(n) |
+| 322 | [Coin Change](https://leetcode.com/problems/coin-change/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/322_Coin_Change.py) | Bottom-up or top-down DP, dp[n] = min(dp[n], dp[n - v_i]), where v_i is the coin, O(amount * n) and O(amount) |
 | 337 | [House Robber III](https://leetcode.com/problems/house-robber-iii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/337_House_Robber_III.py) | 1. Recursion with hash map, O(n) and O(n)<br>2. Recursion on two steps, O(n) and O(1) |
 | 339 | [Nested List Weight Sum](https://leetcode.com/problems/nested-list-weight-sum/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/339_Nested_List_Weight_Sum.py) | Depth-first recursion |
 | 340 | [Longest Substring with At Most K Distinct Characters](https://leetcode.com/problems/longest-substring-with-at-most-k-distinct-characters/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/340_Longest_Substring_with_At_Most_K_Distinct_Characters.py) | Maintain a sliding window with at most k distinct characters and a count for this window. Note that the start position need a loop to update.|

python/274_H-Index.py

@@ -0,0 +1,33 @@
+class Solution(object):
+    # def hIndex(self, citations):
+    #     """
+    #     :type citations: List[int]
+    #     :rtype: int
+    #     """
+    #     # Sort and check the max h where the number of paper with no less than h citations
+    #     # is no less than h
+    #     citations.sort()
+    #     ls = len(citations)
+    #     h = ls
+    #     while h > 0 and citations[ls - h] < h:
+    #             h -= 1 
+    #     return h
+
+    # def hIndex(self, citations):
+    #     citations.sort()
+    #     i = 0
+    #     while i < len(citations) and citations[len(citations) - 1 - i] > i:
+    #         i += 1
+    #     return i
+
+    def hIndex(self, citations):
+        # counting sort
+        ls = len(citations)
+        papers = [0] * (ls + 1)
+        for c in citations:
+            papers[min(ls, c)] += 1
+        k, s = ls, papers[ls]
+        while k > s:
+            k -= 1
+            s += papers[k]
+        return k

python/322_Coin_Change.py

@@ -0,0 +1,48 @@
+class Solution(object):
+    # def coinChange(self, coins, amount):
+    #     """
+    #     :type coins: List[int]
+    #     :type amount: int
+    #     :rtype: int
+    #     """
+    #     # Top-down dp
+    #     if amount < 1:
+    #         return 0
+    #     return self.coinChange_helper(coins, amount, [0] * (amount + 1))
+
+    # def coinChange_helper(self, coins, amount, count):
+    #     if amount < 0:
+    #         return -1
+    #     if amount == 0:
+    #         return 0
+    #     if count[amount - 1] != 0:
+    #         return count[amount - 1]
+    #     min_count = 1000000000
+    #     for coin in coins:
+    #         res = self.coinChange_helper(coins, amount - coin, count)
+    #         if res >= 0 and res < min_count:
+    #             min_count = 1 + res
+    #     if min_count == 1000000000:
+    #         count[amount - 1] = -1
+    #     else:
+    #         count[amount - 1] = min_count
+    #     return count[amount - 1]
+
+    def coinChange(self, coins, amount):
+        # bottom-up dp
+        if amount == 0:
+            return 0
+        if coins is None or len(coins) == 0:
+            return -1
+        coins.sort()
+        dp = [1000000000] * (amount + 1)
+        for i in range(1, amount + 1):
+            for coin in coins:
+                if i == coin:
+                    dp[i] = 1
+                    break
+                elif i > coin:
+                    dp[i] = min(dp[i], dp[i - coin] + 1)
+        if dp[amount] == 1000000000:
+            return -1
+        return dp[amount]