day n

Author: sunriseXu

120. Triangle.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def minimumTotal(self, triangle):
+        """
+        :type triangle: List[List[int]]
+        :rtype: int
+        triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
+                2
+               3 4
+              6 5 7
+             4 1 8 3
+        
+        """
+        dp = [i for i in triangle[-1]]
+        for i in range(len(triangle) - 1):
+            current = triangle[len(triangle) - i - 2]
+            for j in range(len(current)):
+                dp[j] = min(dp[j], dp[j+1]) + current[j]
+        return dp[0]
+
+s = Solution()
+res = s.minimumTotal([[2],[3,4],[6,5,7],[4,1,8,3]])
+print(res)

139. Word Break.py

@@ -0,0 +1,33 @@
+class Solution(object):
+    def wordBreak(self, s, wordDict):
+        """
+        :type s: str
+        :type wordDict: List[str]
+        :rtype: bool
+        s = "catsandog", wordDict = ["cats","dog","sand","and","cat"]
+        """
+        results = dict()
+        def findPrefix(substring):
+            res = []
+            for i in wordDict:
+                if substring.startswith(i):
+                    res.append(i)
+            return res
+        def recurse(substring):
+            if substring in results:
+                return False
+            if substring == '':
+                return True
+            prefixs = findPrefix(substring)
+            if not prefixs:
+                results[substring] = False
+                return False
+            for prefix in prefixs:
+                if recurse(substring[len(prefix):]):
+                    return True
+            results[substring] = False
+            return False
+        return recurse(s)
+s = Solution()
+res = s.wordBreak(s = "catsandog", wordDict = ["cats","dog","sand","and","cat"])
+print(res)

198. House Robber.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def rob(self, nums):
+        if not nums:
+            return 0
+        if len(nums) == 1:
+            return nums[0]
+        last = 0
+        current = nums[0]
+        for i in range(1, len(nums)):
+            tmp = current
+            current = max(current, last + nums[i])
+            last = tmp
+        return current
+s = Solution()
+res = s.rob([1,2,3,1])
+print(res)

300. Longest Increasing Subsequence.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def lengthOfLIS(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        [10,9,2,5,3,7,101,18]
+        
+        """
+        
+        dp = [1] * len(nums)
+        for i in range(len(nums)):
+            for j in range(i):
+                if nums[i] > nums[j]:
+                    dp[i] = max(dp[i], dp[j] + 1)
+        maxLen = 0
+        for i in dp:
+            maxLen = max(maxLen, i)
+        return maxLen
+
+s = Solution()
+res = s.lengthOfLIS([10,9,2,5,3,7,101,18])
+print(res)

322. Coin Change.py

@@ -0,0 +1,35 @@
+class Solution(object):
+    def coinChange(self, coins, amount):
+        """
+        :type coins: List[int]
+        :type amount: int
+        :rtype: int
+        coins = [1,2,5], amount = 11
+        5 + 5 + 1
+        """
+        minDict = {}
+        def dp(amount):
+            if amount == 0:
+                return 0
+            if amount < 0:
+                return -1
+            if amount in minDict:
+                if minDict[amount] != -1:
+                    return minDict[amount]
+                else:
+                    return -1
+            minSum = float("inf")
+            for coin in coins:
+                res = dp(amount - coin)
+                if res >= 0:
+                    minSum = min(minSum, res)
+            if minSum != float("inf"):
+                minDict[amount] = minSum + 1
+            else:
+                minDict[amount] = -1
+            return minDict[amount]
+        return dp(amount)
+
+s = Solution()
+res = s.coinChange([2], 0)
+print(res)

373. Find K Pairs with Smallest Sums.py

@@ -0,0 +1,31 @@
+class Solution(object):
+    def kSmallestPairs(self, nums1, nums2, k):
+        """
+        :type nums1: List[int]
+        :type nums2: List[int]
+        :type k: int
+        :rtype: List[List[int]]
+        """
+        import heapq
+        smallestHeap = []
+        output = []
+        visited = []
+        heapq.heapify(smallestHeap)
+        heapq.heappush(smallestHeap, (nums1[0] + nums2[0], 0, 0))
+        visited.append((0, 0))
+        while k and smallestHeap:
+            _, i, j = heapq.heappop(smallestHeap)
+            output.append([nums1[i], nums2[j]])
+            if i+1 < len(nums1) and (i+1, j) not in visited:
+                heapq.heappush(smallestHeap, (nums1[i+1] + nums2[j], i+1, j))
+                visited.append((i+1, j))
+            if j+1 < len(nums2) and (i, j+1) not in visited:
+                heapq.heappush(smallestHeap, (nums1[i] + nums2[j+1], i, j+1))
+                visited.append((i, j+1))
+            k -= 1
+        return output
+s = Solution()
+res = s.kSmallestPairs(nums1 = [1,7,11], nums2 = [2,4,6], k = 3)
+print(res)
+
+            

5. Longest Palindromic Substring.py

@@ -0,0 +1,41 @@
+class Solution(object):
+    def longestPalindrome(self, s):
+        """
+        :type s: str
+        :rtype: str
+        s = "babad"
+        dp[start][end] = dp[start+1][end-1] + 2
+        """
+        dp = []
+        maxLen = 1
+        maxIdx = (0,0)
+        for i in range(len(s)):
+            tmp = [0] * len(s)
+            dp.append(tmp)
+        for i in range(len(s)):
+            # init?
+            currLen = len(s) - i
+            for j in range(currLen):
+                # print(j)
+                # print(j+i)
+                if i == 0:
+                    dp[j][j+i] = 1
+                elif i == 1:
+                    if s[j] == s[j+i]:
+                        dp[j][j+i] = 2
+                        if maxLen < dp[j][j+i]:
+                            maxLen = dp[j][j+i]
+                            maxIdx = (j, j+i)
+                else:
+                    if dp[j+1][j+i-1] > 0 and s[j] == s[j+i]:
+                        dp[j][j+i] += dp[j+1][j+i-1] + 2
+                        if maxLen < dp[j][j+i]:
+                            maxLen = dp[j][j+i]
+                            maxIdx = (j, j+i)
+        return s[maxIdx[0]:maxIdx[1]+1]
+
+s = Solution()
+res = s.longestPalindrome( "babad")
+print(res)
+                
+        

502. IPO.py

@@ -0,0 +1,30 @@
+class Solution(object):
+    def findMaximizedCapital(self, k, w, profits, capital):
+        """
+        :type k: int
+        :type w: int
+        :type profits: List[int]
+        :type capital: List[int]
+        :rtype: int
+        """
+        import heapq
+        maxProfit = []
+        minCapital = [(c, p) for c, p in zip(capital, profits)]
+        heapq.heapify(minCapital)
+        # c is no decendency oder
+        for i in range(k):
+        
+            while minCapital and minCapital[0][0] <= w:
+                # we get all project we can afford currently
+                c, p = heapq.heappop(minCapital)
+                # push them in to heap with order
+                heapq.heappush(maxProfit, -1 * p)
+            if not maxProfit:
+                break
+            # now, pick up largest profit and add to capital
+            w += -1 * heapq.heappop(maxProfit)
+        return w
+
+s = Solution()
+res = s.findMaximizedCapital(k = 2, w = 0, profits = [1,2,3], capital = [0,1,1])
+print(res)

63. Unique Paths II.py

@@ -0,0 +1,30 @@
+class Solution(object):
+    def uniquePathsWithObstacles(self, obstacleGrid):
+        '''
+        dp[i] = d[i] + dp2[i-1]
+        '''
+        
+        # init first row 
+        m, n = len(obstacleGrid), len(obstacleGrid[0])
+        dp = [0] * n
+        if obstacleGrid[0][0] == 0:
+            dp[0] = 1 
+        for i in range(1, n):
+            if obstacleGrid[0][i] == 0 and dp[i-1] > 0:
+                dp[i] = dp[i-1]
+        for i in range(1, m):
+            dp2 = [0] * n
+            for j in range(n):
+                if obstacleGrid[i][j] == 1:
+                    dp2[j] = 0
+                else:
+                    if j-1 < 0:
+                        dp2[j] = dp[j]
+                    else:
+                        dp2[j] = dp[j] + dp2[j-1]
+            dp = dp2
+        return dp[-1]
+s = Solution()
+res = s.uniquePathsWithObstacles([[1]])
+print(res)
+                

70. Climbing Stairs.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def climbStairs(self, n):
+        if n == 1:
+            return 1
+        if n == 2:
+            return 2
+        last = 1
+        current = 2
+        for i in range(n-2):
+            tmp = current
+            current += last
+            last = tmp
+        return current
+s = Solution()
+res = s.climbStairs(6)
+print(res)