243_Shortest_Word_Distance

252_Meeting_Rooms

Author: qiyuangong

README.md

@@ -71,4 +71,6 @@
 | 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) |
+| 243 | [Shortest Word Distance](https://leetcode.com/problems/shortest-word-distance/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/243_Shortest_Word_Distance.py) | Update index1 and index2, and check distance, O(n) and O(1) |
+| 252 | [Meeting Rooms](https://leetcode.com/problems/meeting-rooms/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/252_Meeting_Rooms.py) | 1. Sort and compare intervals[i].end with intervals[i+1], O(nlogn) and O(1)<br>2. Sort and check intervals when count >= 2, O(nlogn) and O(n) |
 | 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/243_Shortest_Word_Distance.py

@@ -0,0 +1,34 @@
+class Solution(object):
+    # def shortestDistance(self, words, word1, word2):
+    #     """
+    #     :type words: List[str]
+    #     :type word1: str
+    #     :type word2: str
+    #     :rtype: int
+    #     """
+    #     indexes = []
+    #     for index, word in enumerate(words):
+    #         if word1 == word:
+    #             indexes.append((index, 1))
+    #         elif word2 == word:
+    #             indexes.append((index, 2))
+    #     ls, min_range = len(indexes), len(words)
+    #     for i in range(ls - 1):
+    #         if indexes[i][1] == indexes[i + 1][1]:
+    #             continue
+    #         curr_range = abs(indexes[i][0] - indexes[i + 1][0])
+    #         if curr_range < min_range:
+    #             min_range = curr_range
+    #     return min_range
+
+    def shortestDistance(self, words, word1, word2):
+        index1 = index2 = -1
+        res = len(words)
+        for index, word in enumerate(words):
+            if word1 == word:
+                index1 = index
+            elif word2 == word:
+                index2 = index
+            if index1 != -1 and index2 != -1:
+                res = min(res, abs(index1 - index2))
+        return res

python/252_Meeting_Rooms.py

@@ -0,0 +1,37 @@
+# Definition for an interval.
+# class Interval(object):
+#     def __init__(self, s=0, e=0):
+#         self.start = s
+#         self.end = e
+
+class Solution(object):
+    # def canAttendMeetings(self, intervals):
+    #     """
+    #     :type intervals: List[Interval]
+    #     :rtype: bool
+    #     """
+    #     # if start then count += 1
+    #     # if end then count -= 1
+    #     # if count >= 2, then False
+    #     check = []
+    #     for it in intervals:
+    #         check.append((it.start, True))
+    #         check.append((it.end - 1, False))
+    #     check.sort(key=lambda x : x[0])
+    #     count = 0
+    #     for t in check:
+    #         if t[1]:
+    #             count += 1
+    #             if count > 1:
+    #                 return False
+    #         else:
+    #             count -= 1
+    #     return True
+
+    def canAttendMeetings(self, intervals):
+        intervals.sort(key=lambda x: x.start)
+        ls = len(intervals)
+        for i in range(ls - 1):
+            if intervals[i].end > intervals[i + 1].start:
+                return False
+        return True