add more problems

Author: LEUNGUU

easy/300.longest_increasing_subsequence.py

@@ -0,0 +1,34 @@
+# Longest Increasing Subsequence
+#
+# [Medium] [AC:42.8% 421.8K of 986.2K] [filetype:python3]
+#
+# Given an unsorted array of integers, find the length of longest increasing subsequence.
+#
+# Example:
+#
+# Input: [10,9,2,5,3,7,101,18]
+#
+# Output: 4
+#
+# Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4.
+#
+# Note:
+#
+# There may be more than one LIS combination, it is only necessary for you to return the length.
+#
+# Your algorithm should run in O(n2) complexity.
+#
+# Follow up: Could you improve it to O(n log n) time complexity?
+#
+# [End of Description]:
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        if not nums:
+            return 0
+        sz = len(nums)
+        dp = [1] * sz
+        for i in range(sz):
+            for j in range(i):
+                if nums[i] > nums[j]:
+                    dp[i] = max(dp[i], dp[j] + 1)
+        return max(dp)

easy/416.partition_equal_subset_sum.py

@@ -0,0 +1,81 @@
+# Partition Equal Subset Sum
+#
+# [Medium] [AC:44.0% 205.3K of 466.4K] [filetype:python3]
+#
+# Given a non-empty array containing only positive integers, find if the array can be partitioned into two subsets such
+# that the sum of elements in both subsets is equal.
+#
+# Note:
+#
+# Each of the array element will not exceed 100.
+#
+# The array size will not exceed 200.
+#
+# Example 1:
+#
+# Input: [1, 5, 11, 5]
+#
+# Output: true
+#
+# Explanation: The array can be partitioned as [1, 5, 5] and [11].
+#
+# Example 2:
+#
+# Input: [1, 2, 3, 5]
+#
+# Output: false
+#
+# Explanation: The array cannot be partitioned into equal sum subsets.
+#
+# [End of Description]:
+# bag
+# class Solution:
+#     def canPartition(self, nums: List[int]) -> bool:
+#         total = sum(nums)
+#         # sum cannot be divided by 2
+#         if total % 2 != 0:
+#             return False
+#         capacity = sum(nums) // 2
+#         sz = len(nums)
+#         # initialize dp
+#         dp = []
+#         for _ in range(sz+1):
+#             inner1 = []
+#             for _ in range(capacity+1):
+#                 inner1.append(False)
+#             dp.append(inner1)
+#
+#         # base case
+#         for i in range(sz+1):
+#             dp[i][0] = True
+#
+#         # since we use i - 1 to call nums, so we need to add one to the size
+#         # i must start from 1
+#         for i in range(1, sz+1):
+#             # need to include capacity itself
+#             # j must start from 1, since 0 is the base case
+#             for j in range(1, capacity+1):
+#                 # judge if there is enough space for i
+#                 if j - nums[i - 1] >= 0:
+#                     # dp[i][j] = dp[i - 1][j]
+#                 # else:
+#                     dp[i][j] = dp[i - 1][j] or dp[i - 1][j - nums[i - 1]]
+#         return dp[sz][capacity]
+
+
+class Solution:
+    def canPartition(self, nums: List[int]) -> bool:
+        total = sum(nums)
+        if total % 2 != 0:
+            return False
+        capacity = sum(nums) // 2
+        sz = len(nums)
+        dp = [False] * (capacity + 1)
+        # base case
+        dp[0] = True
+
+        for i in range(sz):
+            for j in range(capacity, -1, -1):
+                if j - nums[i] >= 0:
+                    dp[j] = dp[j] or dp[j - nums[i]]
+        return dp[capacity]

easy/518.coin_change_2.py

@@ -0,0 +1,84 @@
+# Coin Change 2
+#
+# [Medium] [AC:50.6% 148.7K of 294.1K] [filetype:python3]
+#
+# You are given coins of different denominations and a total amount of money. Write a function to compute the number of
+# combinations that make up that amount. You may assume that you have 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
+#
+# Note:
+#
+# You can assume that
+#
+# 0 <= amount <= 5000
+#
+# 1 <= coin <= 5000
+#
+# the number of coins is less than 500
+#
+# the answer is guaranteed to fit into signed 32-bit integer
+#
+# [End of Description]:
+# bag
+class Solution:
+    def change(self, amount: int, coins: List[int]) -> int:
+        sz = len(coins)
+        dp = []
+        for _ in range(sz + 1):
+            inner = []
+            for _ in range(amount + 1):
+                inner.append(0)
+            dp.append(inner)
+        # base case
+        for i in range(sz + 1):
+            dp[i][0] = 1
+
+        for i in range(1, sz + 1):
+            for j in range(1, amount + 1):
+                if j - coins[i - 1] >= 0:
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i - 1]]
+                else:
+                    dp[i][j] = dp[i - 1][j]
+        return dp[sz][amount]
+
+
+class Solution:
+    def change(self, amount: int, coins: List[int]) -> int:
+        sz = len(coins)
+        dp = [0] * (amount + 1)
+        # base case
+        dp[0] = 1
+        for i in range(sz):
+            for j in range(1, amount + 1):
+                if j - coins[i] >= 0:
+                    dp[j] = dp[j] + dp[j - coins[i]]
+        return dp[amount]