221_Maximal_Square

228_Summary_Ranges

Author: qiyuangong

README.md

@@ -69,4 +69,6 @@
 | 217 | [Contains Duplicate](https://leetcode.com/problems/contains-duplicate/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/217_Contains_Duplicate.py) | 1. Set and compare length<br>2. Sort and check i,i +1|
 | 219 | [Contains Duplicate II](https://leetcode.com/problems/contains-duplicate-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/219_Contains_Duplicate_II.py) | 1. Brute force<br> 2. Maintenance a set that contains previous k numbers, and check if curr in set |
 | 220 | [Contains Duplicate III](https://leetcode.com/problems/contains-duplicate-iii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/220_Contains_Duplicate_III.py) | 1. Sort and binary Search <br>2. Bucket sort |
+| 221 | [Maximal Square](https://leetcode.com/problems/maximal-square/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/221_Maximal_Square.py) | 1. Brute force<br> 2. dp[i][j] = min(dp[i-1][j], dp[i-1][j-1], dp[i][j-1]) + 1, O(mn) and O(mn)<br>3. dp[j] = min([j], dp[j-1], prev) + 1, O(mn) and O(n)|
+| 228 | [Summary Ranges](https://leetcode.com/problems/summary-ranges/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/228_Summary_Ranges.py) | Detect start and jump, O(n) and O(1) |
 | 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/221_Maximal_Square.py

@@ -0,0 +1,61 @@
+class Solution(object):
+    # def maximalSquare(self, matrix):
+    #     """
+    #     :type matrix: List[List[str]]
+    #     :rtype: int
+    #     """
+    #     # Brute force O(mn^2)
+    #     if matrix is None or len(matrix) == 0:
+    #         return 0
+    #     rows, cols = len(matrix), len(matrix[0])
+    #     res = 0
+    #     for i in range(rows):
+    #         for j in range(cols):
+    #             if matrix[i][j] == '1':
+    #                 sqlen, flag = 1, True
+    #                 while sqlen + i < rows and sqlen + j < cols and flag:
+    #                     for k in range(j, sqlen + j + 1):
+    #                         if matrix[i + sqlen][k] == '0':
+    #                             flag = False
+    #                             break
+    #                     for k in range(i, sqlen + i + 1):
+    #                         if matrix[k][j + sqlen] == '0':
+    #                             flag = False
+    #                             break
+    #                     if flag:
+    #                         sqlen += 1
+    #                 if res < sqlen:
+    #                     res = sqlen
+    #     return res * res
+
+    # def maximalSquare(self, matrix):
+    #     # dp[i][j] = min(dp[i-1][j],dp[i-1][j-1],dp[i][j-1])+1
+    #     if matrix is None or len(matrix) == 0:
+    #         return 0
+    #     rows, cols, res = len(matrix), len(matrix[0]), 0
+    #     dp = [[0] * (cols + 1) for _ in range(rows + 1)]
+    #     for i in range(1, rows + 1):
+    #         for j in range(1, cols + 1):
+    #             if matrix[i - 1][j - 1] == '1':
+    #                 dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1
+    #                 res = max(res, dp[i][j])
+    #     return res * res
+
+    def maximalSquare(self, matrix):
+        # dp[j] = min([j], dp[j-1], prev) + 1
+        # O(n) space
+        if matrix is None or len(matrix) == 0:
+            return 0
+        rows, cols, res, prev = len(matrix), len(matrix[0]), 0, 0
+        dp = [0] * (cols + 1)
+        for i in range(1, rows + 1):
+            for j in range(1, cols + 1):
+                temp = dp[j]
+                if matrix[i - 1][j - 1] == '1':
+                    dp[j] = min(dp[j - 1], dp[j], prev) + 1
+                    res = max(res, dp[j])
+                else:
+                    dp[j] = 0
+                prev = temp
+        return res * res
+

python/228_Summary_Ranges.py

@@ -0,0 +1,37 @@
+class Solution(object):
+    # def summaryRanges(self, nums):
+    #     """
+    #     :type nums: List[int]
+    #     :rtype: List[str]
+    #     """
+    #     if nums is None or len(nums) == 0:
+    #         return []
+    #     res = []
+    #     start, prev, ls = nums[0], nums[0], len(nums)
+    #     for i in range(ls):
+    #         curr = nums[i]
+    #         if curr - prev > 1:
+    #             if start == prev:
+    #                 res.append("%d" % start)
+    #             else:
+    #                 res.append("%d->%d" % (start, prev))
+    #             start = curr
+    #         prev = curr
+    #     if start == prev:
+    #         res.append("%d" % start)
+    #     else:
+    #         res.append("%d->%d" % (start, prev))
+    #     return res
+
+    def summaryRanges(self, nums):
+        res = []
+        start, ls = 0, len(nums)
+        for i in range(ls):
+            if i + 1 <  ls and nums[i + 1] == nums[i] + 1:
+                continue
+            if i == start:
+                res.append(str(nums[start]))
+            else:
+                res.append("%d->%d" % (nums[start], nums[i]))
+            start = i + 1
+        return res