170_Two_Sum_III-Data_structure_design

296_Best_Meeting_Point

Author: qiyuangong

README.md

@@ -71,6 +71,8 @@
 | 163 | [Missing Ranges](https://leetcode.com/problems/missing-ranges/) ♥ | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/163_Missing_Ranges.py) | Add -1 to lower for special case, then check if curr - prev >= 2|
 | 166 | [Fraction to Recurring Decimal](https://leetcode.com/problems/fraction-to-recurring-decimal/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/166_Fraction_to_Recurring_Decimal.py) | % and Hash to find duplicate |
 | 167 | [Two Sum II - Input array is sorted](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/167_Two_Sum_II_Input_array_is_sorted.py) | Two points O(n) and O(1) |
+| 170 | [Two Sum III - Data structure design](https://leetcode.com/problems/two-sum-iii-data-structure-design/) 
+&hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/170_Two_Sum_III-Data_structure_design.py) | 1. Hash, O(1) for add, O(n) for find, O(n) space<br>2. sorted list, O(logn) for add, O(n) for find, O(n) space<br> 3. Sort before find, O(1) for add, O(nlogn) for find, O(n) space|
 | 186 | [Reverse Words in a String II](https://leetcode.com/problems/reverse-words-in-a-string-ii/) &hearts;| [Python](https://github.com/qiyuangong/leetcode/blob/master/python/186_Reverse_Words_in_a_String_II.py) | Reverse all and reverse each words |
 | 198 | [House Robber](https://leetcode.com/problems/house-robber/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/198_House_Robber.py) | f(k) = max(f(k – 2) + num[k], f(k – 1)), O(n) and O(1) |
 | 200 | [Number of Islands](https://leetcode.com/problems/number-of-islands/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/200_Number_of_Islands.py) | 1. Quick union find, O(nlogn) and O(n^2)<br>2. BFS with marks, O(n^2) and O(1) |
@@ -93,6 +95,7 @@
 | 280 | [Wiggle Sort](https://leetcode.com/problems/wiggle-sort/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/280_Wiggle_Sort.py) &hearts; | 1. Sort and insert (n - 1) / 2 from tail to correct position, O(nlogn) and O(1)<br>2. Sort and swap(i, i + 1) from 1 to n - 1, O(nlogn)<br>3. Iteratively check order and reverse order, if not satisfied, then swap i with i + 1, O(n) |
 | 286 | [Walls and Gates](https://leetcode.com/problems/walls-and-gates/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/286_Walls_and_Gates.py) | BFS with queue, O(mn) and O(mn) |
 | 288 | [Unique Word Abbreviation](https://leetcode.com/problems/unique-word-abbreviation/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/288_Unique_Word_Abbreviation.py) | hash |
+| 296 | [Best Meeting Point](https://leetcode.com/problems/best-meeting-point/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/296_Best_Meeting_Point.py) | Think hard about Manhattan Distance in 1D case. Sort and find mean, O(mnlogmn) and O(1) |
 | 298 | [Binary Tree Longest Consecutive Sequence](https://leetcode.com/problems/binary-tree-longest-consecutive-sequence/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/298_Binary_Tree_Longest_Consecutive_Sequence.py) | Bottom-up or top-down recursion, O(n) and O(n) |
 | 305 | [Number of Islands II](https://leetcode.com/problems/number-of-islands-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/305_Number_of_Islands_II.py) | Quick union find with weights, O(nlogn) and O(n) |
 | 322 | [Coin Change](https://leetcode.com/problems/coin-change/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/322_Coin_Change.py) | Bottom-up or top-down DP, dp[n] = min(dp[n], dp[n - v_i]), where v_i is the coin, O(amount * n) and O(amount) |

python/170_Two_Sum_III-Data_structure_design.py

@@ -0,0 +1,40 @@
+class TwoSum(object):
+
+    def __init__(self):
+        """
+        initialize your data structure here
+        """
+        self.internal = []
+        self.dic = {}
+
+    def add(self, number):
+        """
+        Add the number to an internal data structure.
+        :rtype: nothing
+        """
+        self.internal.append(number)
+        if number in self.dic:
+            # more than once
+            self.dic[number] = True
+            return
+        # once
+        self.dic[number] = False
+
+    def find(self, value):
+        """
+        Find if there exists any pair of numbers which sum is equal to the value.
+        :type value: int
+        :rtype: bool
+        """
+        for v in self.internal:
+            if value - v in self.dic:
+                if v << 1 == value and not self.dic[v]:
+                    continue
+                return True
+        return False
+
+
+# Your TwoSum object will be instantiated and called as such:
+# twoSum = TwoSum()
+# twoSum.add(number)
+# twoSum.find(value)

python/296_Best_Meeting_Point.py

@@ -0,0 +1,57 @@
+class Solution(object):
+    # def minTotalDistance(self, grid):
+    #     """
+    #     :type grid: List[List[int]]
+    #     :rtype: int
+    #     """
+    #     # sort
+    #     rows = []
+    #     cols = []
+    #     for i in range(len(grid)):
+    #         for j in range(len(grid[0])):
+    #             if grid[i][j] == 1:
+    #                 rows.append(i)
+    #                 cols.append(j)
+    #     row = rows[len(rows) / 2]
+    #     cols.sort()
+    #     col = cols[len(cols) / 2]
+    #     return self.minDistance1D(rows, row) + self.minDistance1D(cols, col)
+
+    # def minDistance1D(self, points, origin):
+    #     distance = 0
+    #     for point in points:
+    #         distance += abs(point - origin)
+    #     return distance
+
+    def minDistance1D(self, points):
+        # two points
+        distance = 0
+        i, j = 0, len(points) - 1
+        while i < j:
+            distance += points[j] - points[i]
+            i += 1
+            j -= 1
+        return distance
+
+    def minTotalDistance(self, grid):
+        rows = self.collectRows(grid)
+        cols = self.collectCols(grid)
+        row = rows[len(rows) / 2]
+        col = cols[len(cols) / 2]
+        return self.minDistance1D(rows) + self.minDistance1D(cols)
+
+    def collectRows(self, grid):
+        rows = []
+        for i in range(len(grid)):
+            for j in range(len(grid[0])):
+                if grid[i][j] == 1:
+                    rows.append(i)
+        return rows
+
+    def collectCols(self, grid):
+        cols = []
+        for j in range(len(grid[0])):
+            for i in range(len(grid)):
+                if grid[i][j] == 1:
+                    cols.append(j)
+        return cols