minor updates

Author: weng

BST2doubly_llist.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+'''
+Leetcode: Convert Binary Search Tree (BST) to Sorted Doubly-Linked List
+'''
+from __future__ import division
+import random
+from BinaryTree import *
+
+
+def get_tail(node):
+    while node.right:
+        node = node.right
+    return node
+
+
+def convert(root):
+    if not root: return None
+    left_list = convert(root.left)
+    right_list = convert(root.right)
+    
+    if left_list:
+        tail = get_tail(left_list)
+        tail.right = root
+        root.left = tail
+    
+    if right_list:
+        right_list.left = root
+        root.right = right_list
+    
+    if left_list: return left_list
+    else: return root
+
+
+if __name__ == '__main__':
+    print BST
+    head = convert(BST)
+    
+    # to right
+    node = head
+    while node.right:
+        print node.value, '->',
+        node = node.right
+    print node.value
+    
+    # to right
+    while node.left:
+        print node.value, '<-',
+        node = node.left
+    print node.value
+
+
+

BinaryTree.pyc

@@ -11,18 +11,39 @@
 from __future__ import division
 import random
 
+
+# We can use a Queue to store the current tour. We first enqueue first petrol pump to the queue, we keep enqueueing petrol pumps till we either complete the tour, or current amount of petrol becomes negative. If the amount becomes negative, then we keep dequeueing petrol pumps till the current amount becomes positive or queue becomes empty.
+def gas_station(gas, cost):
+    n = len(gas)
+    start = 0; next = 1
+    Q = []
+    cur_gas = gas[start] - cost[start]
+    while start != next or cur_gas < 0:
+        while start != next and cur_gas < 0:
+            # pop, changing starting point
+            cur_gas -= gas[start] - cost[start]
+            start = (start+1)%n
+            if start == 0: # go back to the first trial
+                return -1
+        cur_gas += gas[next] - cost[next]
+        next = (next+1)%n
+    return start
+
+
+'''
+What if we want to keep the leftover gas as much as possible?
+'''
 # G(i,j) = the maximum leftover gas a car goes from i-th station to j-th.
 # the car can use gas at i-th but not at j-th
 # only valid when G(i,j) >= 0
 # G(i,j) = max{G(i,mid)+G(k,mid) for i < mid < j, 
 #              gas[i] - (cost[i]+...+cost[j])}
 # We use G(i,i) for a circular route.
-# ~ O(n^2)
-def gas_station(gas, cost):
+# ~ O(n^3)
+def gas_station2(gas, cost):
     n = len(gas)
     G = {}
-    for i in range(n):
-        G[i,(i+1)%n] = gas[i] - cost[i]
+    for i in range(n): G[i,(i+1)%n] = gas[i] - cost[i]
     print G
 
     for k in range(2,n+1):
@@ -45,9 +66,60 @@ def gas_station(gas, cost):
     return max(circles.values()) >= 0
 
 
+''' 
+What if we want to get the trip with the minimum times of stops?
+'''
+# G(i,j,s) = maximum leftover gas from i-th to j-th station with s stops in-between; 0 <= s <= j-i-1
+# G(i,j,0) = gas[i] - sum(cost[i..j-1])
+# G(i,j,s) = max{G(i,mid,s1) + G(mid,j,s2) for 
+#                     0 <= s1 <= mid-i-1, 
+#                     0 <= s2 <= j-mid-1,
+#                     s1+s2+1 == s}
+# Final results: argmin_s G(i,j,s) >= 0.
+# ~O(n^4)
+def gas_station3(gas, cost):
+    n = len(gas)
+    G = {}
+    for i in range(n): G[i,(i+1)%n,0] = gas[i] - cost[i]
+    
+    for k in range(2, n+1):
+        for i in range(n):
+            j = i+k
+            G[i,j%n,0] = gas[i] - sum([cost[x%n] for x in range(i,j)])
+            for s in range(1, k):
+                G[i,j%n,s] = -float('inf')
+                for mid in range(i+1,i+k):
+                    for s1 in range(0, mid-i):
+                        s2 = s-s1-1
+                        if s2 < 0 or s2 > j-mid-1: continue
+                        
+                        print '(i,j,s)=(%d,%d,%d)'%(i,j,s), s1, s2
+                        G[i,j%n,s] = max(G[i,j%n,s], \
+                                         G[i,mid%n,s1]+G[mid%n,j%n,s2])
+            #'''
+            for x,y,z in G:
+                if z == s:
+                    print x,y,z, ':', G[x,y,z]
+            #'''
+    
+    for k,v in G.items(): print k,v
+    
+    min_step = n-1
+    for i in range(n):
+        args = [x for x in range(0,n) if G[i,i,x] > 0]
+        if args:
+            min_s = min(args)
+            min_step = min(min_step, min_s)
+            print i,'-->',i, 'steps:',min_s, 'leftover gas:', G[i,i,min_s]
+    return min_step
+
+
+# Greedy algorithm, starting at 
+
+
 if __name__ == '__main__':
     gas = [10,5,10,5,10]
-    cost = [8,2,2,12,10]
-    gas_station(gas, cost)
+    cost = [2,2,2,5,2]
+    print gas_station3(gas, cost)
 
 

gas_station.py

@@ -58,7 +58,7 @@ def check_conflict(cols, n, i, j):
 
 
 # cols = [col_0, col_1, ..., col_n-1]
-# Queen is put on row i, col prevs[i]
+# Queen is put on row i, col[i]
 # Currently there are len(cols) row
 def n_queens_place(cols, n, rets):
     if len(cols) == n:

n_queens.py

@@ -19,8 +19,8 @@
 # 1,5,3,4,2 (find 3,4)
 # 2,5,4,3,2 (switch 3,4)
 # Example 2:
-# 1,5,4,3,2,1,0 (find 1,5; the first element < the left element.)
-# 1,5,4,3,2,1,0 (find 2, the first element that > 1 from the end)
+# 1,5,4,3,2,1,0 (find 1; the first element (1) < the right element (5).)
+# 1,5,4,3,2,1,0 (find 2, the first element > 1 from the end)
 # 2,5,4,3,1,1,0 (switch 1,2)
 # 2,0,1,1,3,4,5 (reverse 5,4,3,1,1,0)
 def next_permu(L):

next_permutation.py

@@ -62,7 +62,7 @@ def palin_partition_min_cut(s):
                 min_cut = n-i
                 min_p = None
                 for p in palin_partition_min_cut(s[i+1:]):
-                    if len(p) < min:
+                    if len(p) < min_cut:
                         min_cut = len(p)
                         min_p = p
                 yield [first] + min_p

palin_partition.py

@@ -15,15 +15,20 @@
 '''
 from __future__ import division
 import random
+#from math import factorial
 
 # k = 0,1,...,(n!-1)
 def permu_seq(n, k):
-    from math import factorial
-    if k >= factorial(n): return ""
+    fact = 1
+    for i in range(1,n+1):
+        fact *= i
+    if k >= fact: return ""
+    
     digits = range(1,n+1)
     seq = []
-    for _ in range(n):
-        i, k = divmod(k, factorial(n-1))
+    while n > 0:
+        fact = int(fact/n)
+        i, k = divmod(k, fact)
         seq.append( digits[i] )
         digits.pop(i)
         n -= 1

permutation_seq.py

@@ -7,7 +7,7 @@
 For example,
 Consider the following matrix:
 [
-  [1,   3,  5,  7],
+  [ 1,  3,  5,  7],
   [10, 11, 16, 20],
   [23, 30, 34, 50]
 ]
@@ -62,14 +62,15 @@ def search_in_one_quad_matrix(M, val, i, j):
 
     mid_i = (i[0]+i[1]+1)//2
     mid_j = (j[0]+j[1]+1)//2
+    founded = False
     for a,b,c,d in [(i[0],j[0],mid_i-1,mid_j-1), \
                     (i[0],mid_j,mid_i-1,j[1]), \
                     (mid_i,j[0],i[1],mid_j-1), \
                     (mid_i,mid_j,i[1],j[1])]:
         if M[a][b] <= val <= M[c][d]:
             #print 'search_in_one_quad_matrix(M, val', '(',a,c,')', '(',b,d,') )'
-            return search_in_one_quad_matrix(M, val, (a,c), (b,d))
-    return False
+            founded |= search_in_one_quad_matrix(M, val, (a,c), (b,d))
+    return founded
 
 
 # Solution#3 Search in 1/4 sub-matrix

search_2D_matrix.py

@@ -11,6 +11,7 @@
 from __future__ import division
 import random
 
+
 # O(log n) in time.
 # Search in L[i:j]
 def binary_range_search(L, val, i, j):

search_range.py

@@ -21,7 +21,7 @@ def search_rotated_arr(L, val):
     l = 0; r = len(L)-1
     while l <= r:
         mid = (l + r + 1)//2
-        if L[mid] == val: return
+        if L[mid] == val: return mid
         if L[l] <= L[mid]:
             # the lower half is sorted
             if L[l] <= val <= L[mid]: r = mid-1