no message

Author: chris

add-two-numbers.py

@@ -0,0 +1,71 @@
+class Solution(object):
+
+    #I like this better and it's faster
+    #Runtime: O(N)
+    #Space: O(N)
+    def addTwoNumbers(self, l1, l2):
+
+        #get number from the whole linked list
+        def getTotal(l):
+            total = 0
+            x = 0
+            while l:
+                total+=l.val*(10**x)
+                x+=1
+                l = l.next
+            return total
+        
+        total = getTotal(l1)+getTotal(l2)
+
+        #put the number back into linked list
+        num_string = str(total)[::-1]
+        pre = ListNode(None)
+        curr = pre
+        
+        for n in num_string:
+            curr.next = ListNode(int(n))
+            curr = curr.next
+            
+        return pre.next
+
+
+    #This solution is like adding two numbers in paper
+    #Runtime: O(N)
+    #Space: O(N)
+    def addTwoNumbers(self, l1, l2):
+        pre = ListNode(None)
+        curr = pre
+
+        #carry is either 0 or 1
+        #because the max value of l1 and l2 is 18, for example
+        #3+4=7, 7 has only one digit, so carry is 0, we put 7 in the node
+        #8+7=15, 15 has two digits, so carry is 1, we put 5 in the node
+        #we take carry into the next round calculation
+        carry = 0
+
+        while l1 or l2:
+            total = carry
+            
+            if l1:
+                total+=l1.val
+                l1 = l1.next
+            if l2:
+                total+=l2.val
+                l2 = l2.next
+                
+            if total>=10:
+                carry=1
+                curr.next = ListNode(total%10)
+            else:
+                carry = 0
+                curr.next = ListNode(total)
+            
+            curr = curr.next
+        
+        #check if there is carry left behind, for example
+        #[5]+[5]=[0,1]
+        #both linked list are done iterate, but still haven't finish adding
+        if carry!=0:
+            curr.next = ListNode(carry)
+            
+        return pre.next

number-of-islands.py

@@ -0,0 +1,87 @@
+class Solution(object):
+
+    """
+    we assume 1 means unexplored, 2 is explored
+    when we discover an unexplored place we count+=1
+    and use explore_adjacent() to mark the whole island to 2, so we will not count it again
+    """
+
+    #DFS
+    def numIslands(self, grid):
+        if grid is None or grid==[] or grid==[[]]: return 0
+        
+        count = 0
+        height = len(grid)
+        width = len(grid[0])
+
+        #explore_adjacent() if grid[h][w] is unexplored, mark it as explored. 1->2.
+        #and continue to do the same to the adjacent
+        def explore_adjacent(h, w):
+            #check border
+            if h<0 or h>height-1: return
+            if w<0 or w>width-1: return
+
+            #if grid[h][w]==0: it is sea, return
+            #if grid[h][w]==2: we already explore this place, return
+            if grid[h][w]=='1':
+                grid[h][w] = '2'
+                explore_adjacent(h+1, w)
+                explore_adjacent(h-1, w)
+                explore_adjacent(h, w+1)
+                explore_adjacent(h, w-1)
+            return
+        
+        for h in range(height):
+            for w in range(width):
+                #if v==0: it is sea, continue to find unexplored
+                #if v==2: we already explore this place, continue to find unexplored
+                if grid[h][w]=='1':
+                    #if we discover an unexplored place
+                    #count it
+                    #and set it as root to explore the whole island
+                    count+=1
+                    explore_adjacent(h, w)
+        return count
+
+    #BFS
+    def numIslands(self, grid):
+        if grid is None or grid==[] or grid==[[]]: return 0
+        
+        count = 0
+        height = len(grid)
+        width = len(grid[0])
+        
+        def explore_adjacent(h_root, w_root):
+            if h_root<0 or h_root>height-1: return
+            if w_root<0 or w_root>width-1: return
+
+            #start the queue from root
+            queue = [(h_root, w_root)]
+                
+            while len(queue)>0:
+                coor = queue.pop(0)
+                h = coor[0]
+                w = coor[1]
+                
+                #check border
+                if h<0 or h>height-1: continue
+                if w<0 or w>width-1: continue
+                
+                if grid[h][w]=='1':
+                    grid[h][w] = '2'
+                    queue.extend([(h+1, w), (h-1, w), (h, w+1), (h, w-1)])
+
+            #this function will end if there are no new adjacent to add to queue
+            #which means the whole island explored (mark as 2)
+            return
+                    
+        for h in range(height):
+            for w in range(width):
+                if grid[h][w]=='1':
+                    #if we discover an unexplored place
+                    #count it
+                    #and set it as root to explore the whole island
+                    count+=1
+                    explore_adjacent(h, w)
+                    
+        return count