recursion problems added.

Author: harshsavasil

recursion/coin_change.py

@@ -0,0 +1,61 @@
+"""
+You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.
+
+Example 1:
+
+Input: coins = [1, 2, 5], amount = 11
+Output: 3 
+Explanation: 11 = 5 + 5 + 1
+Example 2:
+
+Input: coins = [2], amount = 3
+Output: -1
+
+Note: You may assume that you have an infinite number of each kind of coin.
+Solution 1 using dp O(n^2)
+Solution 2 using dfs or bfs with pruning
+"""
+
+from typing import List
+
+
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+
+        self.ans = float('inf')
+
+        # Start searching from the biggest coin
+        coins.sort(reverse=True)
+        self.dfs(coins, amount, 0)
+        return -1 if self.ans == float('inf') else self.ans
+
+    def dfs(self, coins, amount, prev_count):
+        """
+        Recursive DFS function to seach valid coins combination.
+        First is to use greedy method find out a potential-best solution.
+        Then start to search the second biggest coin with pruning when the coins number >= the potential-best solution.
+
+        Args:
+            coins: coins list from which we pick coins into combination
+            amount: target amount 
+            prev_count: number of coins picked before this round
+
+        """
+        # Set up stop condtion
+        if len(coins) == 0:
+            return
+
+        if amount % coins[0] == 0:
+            # Update potential answer
+            self.ans = min(self.ans, prev_count + amount // coins[0])
+        else:
+            for k in range(amount // coins[0], -1, -1):
+                # Set up pruning condtion
+                if prev_count + k >= self.ans:
+                    break
+                self.dfs(coins[1:], amount - k * coins[0], prev_count + k)
+
+
+solution = Solution()
+assert solution.coinChange([1, 2, 5], 11) == 3, "Test case 1 failed"
+assert solution.coinChange([1, 2, 5], 13) == 4, "Test case 2 failed"

recursion/generate_paranthesis.py

@@ -0,0 +1,36 @@
+import collections
+from typing import List
+
+
+class Solution:
+    def generateParenthesisUsingBFS(self, n: int) -> List[str]:
+        ans = []
+        # For element in queue, it means (pre-string, left, right)
+        queue = collections.deque([('', n, n)])
+        while queue:
+            pre, left, right = queue.popleft()
+            if right == 0:
+                ans.append(pre)
+            if left:
+                queue.append((pre + '(', left - 1, right))
+            if right > left:
+                queue.append((pre + ')', left, right - 1))
+        return ans
+
+    def generateParenthesis(self, n: int) -> List[str]:
+        ans = []
+
+        def helper(openB, closeB, brackets):
+            if closeB == 0:
+                ans.append(brackets)
+            if openB > 0:  # add open bracket
+                helper(openB - 1, closeB, brackets + "(")
+            if closeB > openB:
+                helper(openB, closeB - 1, brackets + ")")
+        helper(n, n, "")
+        return ans
+
+
+solution = Solution()
+print(solution.generateParenthesis(3))
+print(solution.generateParenthesisUsingBFS(3))

recursion/permutations.py

@@ -0,0 +1,25 @@
+from typing import List
+
+
+class Solution:
+    def __init__(self):
+        self._ans = []
+        self._total = 0
+
+    def generate_permutations(self, index, nums):
+        if index == self._total:
+            self._ans.append(nums.copy())
+            return
+        for i in range(index, self._total):
+            nums[index], nums[i] = nums[i], nums[index]
+            self.generate_permutations(index + 1, nums)
+            nums[index], nums[i] = nums[i], nums[index]
+
+    def permute(self, numbers: List[int]) -> List[List[int]]:
+        self._total = len(numbers)
+        self.generate_permutations(0, numbers)
+        return self._ans
+
+
+solution = Solution()
+print(solution.permute([1, 2, 3, 4]))