no message

Author: Chris Wu

clone-graph.py

@@ -0,0 +1,66 @@
+"""
+approach 2 is more easy to understand
+but approach 1 is better, since it only iterate once
+both of them are O(N) in time efficiency and O(N) in space efficiency
+
+1.
+in 'clone' we store original and clone node as key value pair [0]
+in 'stack' we store the original node which its clone is generated but the clone's neighbors isn't set yet [1]
+we pop the node in the stack and set its clone's neighbors [2]
+if the neighbor is not generated before we generate a clone and push it to stack [3]
+by this way we are basically traverse the graph by DFS
+
+2.
+we traverse every node in the graph
+if a node's neighbor is not in clone, which means it hasn't been visit yet, we add it to stack
+by this way we have every node and its clone in the 'clone' dictionary now [0]
+
+we iterate every node in the clone and setup its neighbors [1]
+"""
+class Solution(object):
+    def cloneGraph(self, start):
+        if start==None: return start
+        clone = {} #[0]
+        stack = [] #[1]
+        
+        clone[start] = Node(start.val, [])
+        stack.append(start)
+        
+        while stack:
+            node = stack.pop()
+            for nb in node.neighbors:
+                if nb not in clone: #[3]
+                    clone[nb] = Node(nb.val, [])
+                    stack.append(nb)
+                clone[node].neighbors.append(clone[nb]) #[2]
+                
+        return clone[start]
+
+class Solution(object):
+    def cloneGraph(self, start):
+        clone = {}
+        stack = [start]
+        
+        while stack: #[0]
+            node = stack.pop()
+            if node not in clone:
+                clone[node] = Node(node.val, [])
+                for nb in node.neighbors:
+                    stack.append(nb)
+                
+        for node in clone: #[1]
+            for nb in node.neighbors:
+                clone[node].neighbors.append(clone[nb])
+                
+        return clone[start]
+
+
+
+
+
+
+
+
+
+
+

evaluate-division.py

@@ -0,0 +1,58 @@
+"""
+I learn the solution from @mlaw0.
+He used BFS, so I use DFS. The runtime is almost the same.
+But I think BFS is more suitable in this case, bc we don't have to go down that deep.
+
+we know if a/b=2, b/c=3, then
+1. b/a=1/2, c/b=1/3 [2]
+2. a/c=2*3, becasue (a/b)*(b/c)=a/c=2*3
+we can build graph: a->(b, 2), b->(c, 3).
+a->(b, 2) means a-->2-->b
+b->(c, 3) means b-->3-->c
+so if we need a/c, we are finding a-->?-->c, which is a-->2-->b-->3-->c, which is a-->2*3-->c
+
+first we build the graph [0]
+for every query, we find from the starting point (n1) itself [1]
+in the stack is the next thing we want to check if it is n2
+we keep on pushing neighbor or neighbor's neighbor to the stack until we find n2 [3]
+
+to prevent we visit the visited node we use a set to keep track [4]
+
+we can further optimize the answer by updating the graph at the same time
+bc it is not likely that we build the graph for a single search [5]
+"""
+class Solution(object):
+    def calcEquation(self, equations, values, queries):
+        def findVal(query):
+            n1, n2 = query
+            if n1 not in graph or n2 not in graph: return -1.0
+            
+            stack = [(n1, 1.0)] #[1]
+            visited = set() #[4]
+            
+            while stack:
+                n, val = stack.pop()
+                visited.add(n)
+                if n==n2:
+                    return val
+                else:
+                    for nb, nb_val in graph[n]: #nb means neighbor
+                        if nb not in visited:
+                            stack.append((nb, nb_val*val)) #[3]
+                            if n!=n1: graph[n1].append((nb, nb_val*val)) #[5]
+            return -1.0
+            
+        def addEdge(n1, n2, val):
+            if n1 in graph:
+                graph[n1].append((n2, val))
+            else:
+                graph[n1] = [(n2, val)]
+        
+        #[0]
+        graph = {}
+        for (n1, n2), val in zip(equations, values):
+            addEdge(n1, n2, val)
+            addEdge(n2, n1, 1/val)
+
+        return [findVal(query) for query in queries]
+

evaluate-reverse-polish-notation.py

@@ -0,0 +1,40 @@
+"""
+iterate through the tokens
+
+if the token is +-*/
+then take out two operands to calculate with the operator
+put the result to stack
+(take 2 operands out bc +-*/ are all binary operator)
+
+if the token is operands
+put it to stack
+
+the final answer should be the one left in the stack
+"""
+class Solution(object):
+    def evalRPN(self, tokens):
+        def calculate(operator, n1, n2):
+            if operator=='+':
+                return n2+n1
+            elif operator=='-':
+                return n2-n1
+            elif operator=='*':
+                return n2*n1
+            elif operator=='/' and n1!=0:
+                #by description
+                #division between two integers should truncate toward zero.
+                if n2%n1!=0:
+                    return int(n2/float(n1))
+                else:
+                    return n2/n1
+            else:
+                print('ERROR')
+                
+        stack = []
+        
+        for t in tokens:
+            if t in '+-*/':
+                stack.append(calculate(t, stack.pop(), stack.pop()))
+            else:
+                stack.append(int(t))
+        return stack.pop()

min-stack.py

@@ -2,23 +2,26 @@
 class MinStack(object):
 
     def __init__(self):
-        self.s = []
+        self.stack = []
 
 
     def push(self, x):
-        self.s.append(x)
+        self.stack.append((x, min(x, self.getMin())))
 
 
     def pop(self):
-        self.s.pop(len(self.s)-1)
+        if len(self.stack)==0: return None
+        return self.stack.pop()[0]
 
 
     def top(self):
-        return self.s[len(self.s)-1]
+        if len(self.stack)==0: return None
+        return self.stack[-1][0]
 
 
     def getMin(self):
-        return min(self.s)
+        if len(self.stack)==0: return float('inf')
+        return self.stack[-1][1]
 
 
 

moving-average-from-data-stream.py

@@ -0,0 +1,16 @@
+class MovingAverage(object):
+
+    def __init__(self, size):
+        self.queue = collections.deque()
+        self.size = size
+        self.sum = 0
+        
+    def next(self, val):
+        self.queue.append(val)
+        
+        if len(self.queue)>self.size:
+            self.sum = self.sum+val-self.queue.popleft()
+        else:
+            self.sum = self.sum+val
+            
+        return self.sum/float(len(self.queue))

number-of-recent-calls.py

@@ -0,0 +1,24 @@
+"""
+everytime we ping
+we put the t in the queue
+
+and check the leftmost(smallest) if it is in the range of 3000
+if it is out of range, pop it, we don't need it anymore
+bc it would definitely be out of range for the next ping
+and bc the description says t is strictly increasing
+keep do the same until the leftmost is in the range
+
+now all the value in the queue is in the range
+return the length of the queue
+"""
+from collections import deque
+class RecentCounter(object):
+    def __init__(self):
+        self.q = collections.deque()
+
+    def ping(self, t):
+        self.q.append(t)
+        while len(self.q)>0 and self.q[0]<t-3000:
+            self.q.popleft()
+        
+        return len(self.q)

task-scheduler.py

@@ -0,0 +1,35 @@
+"""
+Here is what I learn from @awice and solution approach 3.
+
+There are two cases: #[0]
+if n is small enough for all tasks to run without idle the answer would be len(tasks)
+if n is not small enough
+it would be like the Figure 2 in https://leetcode.com/problems/task-scheduler/Figures/621_Task_Scheduler_new.PNG
+the answer of the case2 is the number of total number of square in the Figure 2
+
+in Figure 2, we can see
+n (cooling interval) is 4
+max_count is 4, max_count is the max number of each task that is going to be executed
+t is 2, t is the number of task with max_count, which is 'A' and 'B', they both have to be executed 4 times
+
+t is the left over of the last row in Figure 2 #[1]
+max_count-1 is the height of the Figure 2 except last row #[2]
+n+1 is the width of the Figure
+so in case2 the answer is (max_count-1)*(n+1)+t
+
+in case2 there would be no way that t is 0
+if t is zero, that means the last row don't have idle
+if the last row don't have idle, there would be no idle for all the rows
+in that case, it is case1
+
+the answer is not possible to be smaller then len(tasks)
+if your case2 answer is smaller than len(tasks), it is wrong
+the situation would be case1
+that is why we take the max out of two cases #[3]
+"""
+class Solution(object):
+    def leastInterval(self, tasks, n):
+        task_count = collections.Counter(tasks).values()
+        max_count = max(task_count) #[2]
+        t = task_count.count(max_count) #[1]
+        return max(len(tasks), (max_count-1)*(n+1)+t) #[3]