no message

Chris Wu · Chris Wu · commit 585debd87c63 · 2019-03-20T14:33:51.000+08:00
diff --git a/3sum.py b/3sum.py
@@ -49,6 +49,12 @@ def threeSum(self, nums):
 					l+=1
 					r-=1
 		return res
+		
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-
+"""
 
 	"""
     def threeSum(self, nums):
diff --git a/add-binary.py b/add-binary.py
@@ -1,4 +1,10 @@
 #https://leetcode.com/problems/add-binary/
 class Solution(object):
     def addBinary(self, a, b):
-        return bin(int(a, 2)+int(b, 2))[2:]
+        return bin(int(a, 2)+int(b, 2))[2:]
+
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
diff --git a/best-time-to-buy-an-stock.py b/best-time-to-buy-an-stock.py
@@ -11,4 +11,10 @@ def maxProfit(self, prices):
                 minPrice = price
             if (price-minPrice>maxProfit):
                 maxProfit = price-minPrice
-        return maxProfit
+        return maxProfit
+
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
diff --git a/binary-search-tree-iterator.py b/binary-search-tree-iterator.py
@@ -0,0 +1,42 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class BSTIterator(object):
+
+    def __init__(self, root):
+        self.stack = []
+        while root:
+            self.stack.append(root)
+            root = root.left
+            
+        
+
+    def next(self):
+        node = self.stack.pop()
+        r = node.right
+        while r:
+            self.stack.append(r)
+            r = r.left
+        return node.val
+            
+        
+
+    def hasNext(self):
+        return len(self.stack)!=0
+        
+
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()
+
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
diff --git a/course-schedule.py b/course-schedule.py
@@ -0,0 +1,38 @@
+"""
+we build a graph of adjacency list, like [0]
+0->[2,4,5]
+1->[3,4]
+meaning before taking 2,4,5 we need to take 0, before taking 3,4 we need to take 1
+if we find a loop back to itself then it is impossible, for example
+0->[2,4,5]
+1->[3,4]
+2->[0,3]
+0->2->0, which is imposible
+
+now we iterate every course to see if it can loop back to itself in anyway [1]
+we do this by dfs and search for it self
+if we find itself we find loop
+
+the time efficiency is O(V^2+VE), bc each dfs in adjacency list is O(V+E) and we do it V times
+space efficiency is O(E)
+V is the numCourses(Vertices)
+E is the prerequisites(Edges)
+"""
+class Solution(object):
+    def canFinish(self, numCourses, prerequisites):
+        graph = {n:[] for n in xrange(numCourses)} #[0]
+        
+        for n1, n2 in prerequisites:
+            graph[n1].append(n2)
+        
+        for target_course in xrange(numCourses): #[1]
+            stack = graph[target_course]
+            visited = set()
+            while stack:
+                course = stack.pop()
+                visited.add(course)
+                if course==target_course: return False
+                for ajc in graph[course]:
+                    if ajc not in visited:
+                        stack.append(ajc)
+        return True
diff --git a/first-unique-character-in-a-string.py b/first-unique-character-in-a-string.py
@@ -14,4 +14,10 @@ def firstUniqChar(self, string):
             if counter[char]==1:
                 return i
             
-        return -1
+        return -1
+
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
diff --git a/group-anagrams.py b/group-anagrams.py
@@ -11,4 +11,10 @@ def groupAnagrams(self, strs):
                 
             dic[tuple(string_count)].append(string)
         
-        return dic.values()
+        return dic.values()
+
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-
+"""
diff --git a/linked-list-cycle.py b/linked-list-cycle.py
@@ -8,4 +8,10 @@ def hasCycle(self, head):
             slow = slow.next
             if (fast==slow):
                 return True
-        return False
+        return False
+
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
diff --git a/longest-common-prefix.py b/longest-common-prefix.py
@@ -14,4 +14,10 @@ def longestCommonPrefix(self, strs):
                         return ''
                     else:
                         return bench_mark[:i-1]
-        return bench_mark
+        return bench_mark
+
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
diff --git a/longest-palindromic-substring.py b/longest-palindromic-substring.py
@@ -1,15 +1,14 @@
+"""
+findPalindorome() find the palindrone string from the center "mid"
+The center could be one char (case 1) or two the same char (case 2)
+We iterate through every char in string and assume it is the center
+And put it in findPalindorome() to find the longest
+
+Time Efficiency: O(N^2)
+Space Efficiency: O(N)
+"""
 class Solution(object):
     def longestPalindrome(self, s):
-
-        """
-        findPalindorome() find the palindrone string from the center "mid"
-        The center could be one char (case 1) or two the same char (case 2)
-        We iterate through every char in string and assume it is the center
-        And put it in findPalindorome() to find the longest
-
-        Time Efficiency: O(N^2)
-        Space Efficiency: O(N)
-        """
         def findPalindorome(mid, mid2=None):
             r = 0
             l = len(s)
@@ -42,5 +41,9 @@ def findPalindorome(mid, mid2=None):
             max_pal = p2 if len(p2)>len(max_pal) else max_pal
             
         return max_pal
-
+"""
+I really take time to explain my solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
         
diff --git a/longest-substring-without-repeating-characters.py b/longest-substring-without-repeating-characters.py
@@ -1,26 +1,24 @@
-class Solution(object):
+"""
+everytime we iterate to the next char (on index i)
+we move the start to the place, where all the char between the start and i are all unique
+and keep undating counter til the end
 
-    """
-    everytime we iterate to the next char (on index i)
-    we move the start to the place, where all the char between the start and i are all unique
-    and keep undating counter til the end
-    
-    how do we move the start?
-    we write down the index of the char we last seen
-    if char is seen, we set the start to (the index we seen char last time)+1
-    so we don't repeat char, BUT
+how do we move the start?
+we write down the index of the char we last seen
+if char is seen, we set the start to (the index we seen char last time)+1
+so we don't repeat char, BUT
 
-    another rule of start is not moving leftward
-    bc this will cause more repeating char between start and i
-    so we have to keep start incremental
-    
-    we only iterate through the string once so
-    Time Efficiency is O(N)
+another rule of start is not moving leftward
+bc this will cause more repeating char between start and i
+so we have to keep start incremental
 
-    we use a dict to keep track of the index of char so
-    Space Efficiency is O(N)
-    """
+we only iterate through the string once so
+Time Efficiency is O(N)
 
+we use a dict to keep track of the index of char so
+Space Efficiency is O(N)
+"""
+class Solution(object):
     def lengthOfLongestSubstring(self, s):
         if s is None or s=='': return 0
         counter = 0 #max length of substring
@@ -34,4 +32,9 @@ def lengthOfLongestSubstring(self, s):
             counter = max(counter, i-start+1)
             mark[char_now] = i
                 
-        return counter
+        return counter
+"""
+I really take time to explain my solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
diff --git a/meeting-rooms-ii.py b/meeting-rooms-ii.py
@@ -50,7 +50,11 @@ def minMeetingRooms(self, intervals):
 
         return len(free_rooms)
 
-
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
 
 
 
diff --git a/merge-two-sorted-lists.py b/merge-two-sorted-lists.py
@@ -25,4 +25,10 @@ def mergeTwoLists(self, l1, l2):
         elif l2:
             curr.next = l2
         
-        return pre.next
+        return pre.next
+
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
diff --git a/min-stack.py b/min-stack.py
@@ -30,4 +30,10 @@ def getMin(self):
 # obj.push(x)
 # obj.pop()
 # param_3 = obj.top()
-# param_4 = obj.getMin()
+# param_4 = obj.getMin()
+
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
diff --git a/moving-average-from-data-stream.py b/moving-average-from-data-stream.py
@@ -13,4 +13,10 @@ def next(self, val):
         else:
             self.sum = self.sum+val
             
-        return self.sum/float(len(self.queue))
+        return self.sum/float(len(self.queue))
+
+"""
+I really take time to make the best solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
diff --git a/network-delay-time.py b/network-delay-time.py
@@ -0,0 +1,59 @@
+"""
+Dijkstra's algorithm heap implementation
+first, we build an adjacent list. [0]
+if you don't know what is adjacent list, see https://www.khanacademy.org/computing/computer-science/algorithms/graph-representation/a/representing-graphs
+
+we use a hash-map 'dis' to keep track of every node's distance to K. [1]
+and we use a priority queue 'pq' to store all the node we encounter and its distance to K. [2]
+which we use a tuple (distance to K, node)
+
+for every node we visit, if its distance to K is determined, we don't need to look at it anymore. [3]
+because we always pop the nearest one to the K in the priority queue, we can be sure that the distance in 'dis' is the shortest.
+then from the node, which we know the shortest path from K to the node, we keep on explore its neighbors. [4]
+
+then if we didn't visit every node we return -1, else we return the node which it takes the longest time to reach. [5]
+
+for time complexity
+we use O(E) to make an adjacency list from edge list.
+we will go through the while loop V-1 times because we need to determined the distance of V-1 other nodes.
+for every loop 
+    we need O(logV) to get the nearest node, bc we pop from priority queue.
+    we go push the node the priority queue d times (which is the depth of every node)
+    push the node takes O(logV), we assume all the node is in the queue.
+    so every loop we use O(d*logV+logV)~=O(d*logV)
+so total for total, it is O((V-1)*(d*logV))+O(E), we know that V-1~=V and V*d=E
+so it is O(ElogV)+O(E)~=O(ElogV)
+E is the number of edges, which is the length of 'times' of the input
+V is the number of node, which is the 'N' of the inout
+
+for space complexity
+we used O(V) in both the 'dis' and 'pq', and O(E) on the adjacency list.
+so, it is O(V+E).
+"""
+class Solution(object):
+    def networkDelayTime(self, times, N, K):
+        aj_list = collections.defaultdict(list) #[0]
+        for u, v, w in times: 
+            aj_list[u].append((w, v))
+        
+        dis = {} #[1]
+        pq = [(0, K)] #[2]
+        
+        while pq:
+            if len(dis)==N: break
+
+            d, node = heapq.heappop(pq)
+            if node in dis: continue #[3]
+
+            dis[node] = d
+            
+            for d2, nb in aj_list[node]: #[4]
+                if nb not in dis: #[3]
+                    heapq.heappush(pq, (d+d2, nb)) #[2]
+                    
+        return max(dis.values()) if len(dis)==N else -1 #[5]
+"""
+I really take some time to explain my solution, because I wanted to help people understand.
+If you like my answer, a star on GitHub I will really appreciated.
+https://github.com/wuduhren/leetcode-python
+"""
diff --git a/reverse-integer.py b/reverse-integer.py
diff --git a/reverse-linked-list.py b/reverse-linked-list.py
diff --git a/roman-to-integer.py b/roman-to-integer.py
diff --git a/two-sum.py b/two-sum.py
diff --git a/valid-parentheses.py b/valid-parentheses.py
