no message

Author: Chris Wu

problems/coin-change.py

@@ -0,0 +1,39 @@
+# DP
+class Solution(object):
+    def coinChange(self, coins, amount):
+        dp = [float('inf')]*(amount+1)
+        
+        if amount==0: return 0
+        
+        dp[0] = 0
+        for coin in coins:
+            if coin<=amount:
+                dp[coin] = 1
+            
+        for a in xrange(amount+1):
+            for coin in coins:
+                if a-coin>=0:
+                    dp[a] = min(dp[a], dp[a-coin]+1)
+                    
+        return dp[amount] if dp[amount]!=float('inf') else -1
+
+# BFS
+import collections
+class Solution(object):
+    def coinChange(self, coins, amount):
+        visited = set()
+        
+        coins.sort(reverse=True)
+        q = collections.deque([(0, 0)])
+        
+        while q:
+            current_amount, count = q.popleft()
+            
+            if current_amount==amount: return count
+            if current_amount>amount: continue
+            if current_amount in visited: continue
+            visited.add(current_amount)
+            
+            for coin in coins:
+                q.append((current_amount+coin, count+1))
+        return -1

problems/generate-parentheses.py

@@ -20,3 +20,17 @@ def dfs(path, open_count, open_remain, close_remain):
         opt = []
         dfs('', 0, N, N)
         return opt
+
+
+class Solution(object):
+    def generateParenthesis(self, N):
+        def helper(open_remain, close_remain, s):
+            if open_remain==0 and close_remain==0:
+                ans.append(s)
+            if close_remain>open_remain and close_remain>0:
+                helper(open_remain, close_remain-1, s+')')
+            if open_remain>0:
+                helper(open_remain-1, close_remain, s+'(')
+        ans = []
+        helper(N, N, '')
+        return ans

problems/knight-dialer.py

@@ -0,0 +1,65 @@
+class Solution(object):
+    def knightDialer(self, n):
+        def helper(initial, n):
+            # return the number of posible count starting from initial with n steps left
+            
+            if str(initial)+'-'+str(n) in history: return history[str(initial)+'-'+str(n)]
+            count = 0
+            
+            if n==0: return 1
+            for next_number in memo[initial]:
+                count += helper(next_number, n-1)
+            
+            history[str(initial)+'-'+str(n)] = count
+            return count
+        
+        memo = {
+            1: [6, 8],
+            2: [7, 9],
+            3: [4, 8],
+            4: [0, 3, 9],
+            5: [],
+            6: [0, 1, 7],
+            7: [2, 6],
+            8: [1, 3],
+            9: [2, 4],
+            0: [4, 6]
+        }
+        
+        history = {}
+        count = 0
+
+        for i in xrange(10):
+            count += helper(i, n-1)
+        return count % 1000000007
+
+"""
+dp[n][i] := number of ways to ends at number i after n moves.
+
+Time: O(N).
+Space: O(N). Can reduce to O(1).
+"""
+class Solution(object):
+    def knightDialer(self, n):
+        dp = [[0 for _ in xrange(10)] for _ in xrange(n)]
+        for i in xrange(10): dp[0][i] = 1 #initialize
+        
+        memo = {
+            1: [6, 8],
+            2: [7, 9],
+            3: [4, 8],
+            4: [0, 3, 9],
+            5: [],
+            6: [0, 1, 7],
+            7: [2, 6],
+            8: [1, 3],
+            9: [2, 4],
+            0: [4, 6]
+        }
+
+        for j in xrange(n-1):
+            for i in xrange(10):
+                for next_n in memo[i]:
+                    dp[j+1][next_n] += dp[j][i]
+        
+        return sum(dp[n-1]) % 1000000007

problems/knight-probability-in-chessboard.py

@@ -0,0 +1,27 @@
+class Solution(object):
+    def knightProbability(self, N, K, r, c):
+        if K==0: return 1
+        
+        dp = [[[0 for _ in xrange(N)] for _ in xrange(N)] for _ in xrange(K+1)]
+        
+        dp[0][r][c] = 1
+        possible = float(0)
+        
+        for k in xrange(1, K+1):
+            for i in xrange(N):
+                for j in xrange(N):
+                    if dp[k-1][i][j]>0:
+                        for x, y in [(i+1, j+2), (i-1, j+2), (i+1, j-2), (i-1, j-2), (i+2, j+1), (i-2, j+1), (i+2, j-1), (i-2, j-1)]:
+                            if 0<=x and x<N and 0<=y and y<N:
+                                dp[k][x][y]+=dp[k-1][i][j]
+                                if k==K: possible+=dp[k-1][i][j] #calculate the possible in the last iteration.
+                                
+        return possible/(8**K)
+
+"""
+dp[k][i][j] := number of ways to move to (i, j) after k moves.
+dp[k][i][j] = sum(dp[k-1][x][y]), for all possible (x, y) that can moves to (i, j).
+
+Time: O(K*N^2)
+Space: O(K*N^2)
+"""

problems/largest-1-bordered-square.py

@@ -0,0 +1,46 @@
+class Solution(object):
+    def largest1BorderedSquare(self, grid):
+        if not grid or not grid[0]: return 
+        M, N = len(grid), len(grid[0])
+        
+        dp = [[[0, 0] for _ in xrange(N+1)] for _ in xrange(M+1)]
+        ans = 0
+        for i in xrange(M):
+            for j in xrange(N):
+                if grid[i][j]==1:
+                    #[0]
+                    dp[i+1][j+1][0] = dp[i][j+1][0]+1
+                    dp[i+1][j+1][1] = dp[i+1][j][1]+1
+
+                    #[1]
+                    K = min(dp[i+1][j+1][0], dp[i+1][j+1][1])
+                    
+                    #[2]
+                    for k in xrange(K, -1, -1):
+                        if dp[i+1-k+1][j+1][1]>=k and dp[i+1][j+1-k+1][0]>=k:
+                            ans = max(ans, k**2)
+                            break
+                    
+                elif grid[i][j]==0:
+                    #[0]
+                    dp[i+1][j+1][0] = 0
+                    dp[i+1][j+1][1] = 0
+
+        return ans
+
+"""
+[0]
+dp[i+1][j+1][0] := number of the vertical continuous `1`s above grid[i][j]
+dp[i+1][j+1][0] := number of the vertical continuous `1`s left to grid[i][j]
+
+For each i and j
+    Imagine (i, j) is the bottom-right dot of the square.
+    [1] First, check the max length of the square: K. (through min(number of the vertical continuous `1`s above the bottom-right dot, number of the vertical continuous `1`s left to the bottom-right dot).)
+    [2] Then, for each possible k, checking from large to small
+        Get the number of the vertical continuous `1`s above the bottom-left dot.
+        Get the number of the vertical continuous `1`s left to the top-right dot.
+        See if they are large enough to form square with border==k.
+
+Time: O(N^3) assume that the N is the length of the grid and grid[0].
+Space: O(N^2)
+"""

problems/out-of-boundary-paths.py

@@ -0,0 +1,26 @@
+"""
+dp[k][i][j] := number of ways to get to (i, j)
+dp[k+1][i][j] = sum(dp[k][x][y]) for all (x, y) that can get to (i, j)
+For each k and i and j, also accumulate the ans
+
+Time: O(KMN)
+Space: O(KMN)
+"""
+
+class Solution(object):
+    def findPaths(self, M, N, K, i, j):
+        ans = 0
+        
+        dp = [[[0 for _ in xrange(N)] for _ in xrange(M)] for _ in xrange(K+1)]
+        dp[0][i][j] = 1
+        
+        for k in xrange(K):
+            for i in xrange(M):
+                for j in xrange(N):
+                    if dp[k][i][j]>0:
+                        for x, y in [(i+1, j), (i-1, j), (i, j+1), (i, j-1)]:
+                            if x<0 or x>=M or y<0 or y>=N:
+                                ans+=dp[k][i][j]
+                            else:
+                                dp[k+1][x][y]+=dp[k][i][j]
+        return ans % (1000000007)