Added a few more DP problems

prakhar1989 · prakhar1989 · commit 9a3a4c7b4e68 · 2015-08-11T00:25:22.000+05:30
diff --git a/dp/coinchange.py b/dp/coinchange.py
@@ -0,0 +1,24 @@
+"""
+Problem: http://www.algorithmist.com/index.php/Coin_Change
+"""
+def coinchange(total, coins):
+    M = len(coins)
+    table = [[0]*M for i in range(total+1)]
+    for i in range(M):
+        table[0][i] = 1
+
+    for i in range(1, total+1):
+        for j in range(M):
+            # count of solutions excluding coin
+            x = table[i][j-1] if j > 0 else 0
+
+            # count of solutions including coin
+            y = table[i-coins[j]][j] if i - coins[j] >= 0 else 0
+            table[i][j] = x + y
+
+    return table[total][M-1]
+
+if __name__ == "__main__":
+    print coinchange(10, [2, 3, 5, 6]) # 5
+    print coinchange(5, [2, 3, 5])     # 2
+    print coinchange(4, [1, 2, 3])     # 4
diff --git a/dp/kadane.py b/dp/kadane.py
@@ -0,0 +1,26 @@
+"""
+The recurrence relation that we solve at each step is the following -
+
+Let S[i] = be the max value contigous subsequence till the ith element
+of the array.
+
+Then S[i] = max(A[i], A[i] + S[i - 1])
+At each step, we have two options
+1) We add the ith element to the sum till the i-1th elem
+2) We start a new array starting at i
+
+We take a max of both these options and accordingly build up the array.
+"""
+def max_value_contigous_subsequence(arr):
+    A = [arr[0]] + [0] * (len(arr) - 1)
+    max_to_here = arr[0]
+    for i in range(1, len(arr)):
+        A[i] = max(arr[i], arr[i] + A[i-1])
+        max_to_here = max(max_to_here, A[i])
+    return max_to_here
+
+if __name__ == "__main__":
+    x = [-2, -3, 4, -1, -2, 1, 5, -3]
+    y = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+    z = [-1, 3, -5, 4, 6, -1, 2, -7, 13, -3]
+    print map(max_value_contigous_subsequence, [x, y, z])
diff --git a/misc/kadane.py b/misc/kadane.py
diff --git a/trees/binarysearchtree.py b/trees/binarysearchtree.py
@@ -12,14 +12,13 @@ def __init__(self, value):
     def __repr__(self):
         return "Node with value - %s" % self.value
 
-
 class BinarySearchTree(object):
     def __init__(self):
         self.root = None
         self.len = 0
 
     def __len__(self):
-        return self.len 
+        return self.len
 
     def is_empty(self):
         return self.root == None
@@ -41,7 +40,7 @@ def _postorder(self, node, values):
             self._postorder(node.left, values)
             self._postorder(node.right, values)
             values.append(node.value)
-            
+
     def values(self, reverse = False, order="in"):
         values = []
         if order == "in":
@@ -55,7 +54,7 @@ def values(self, reverse = False, order="in"):
         return values
 
     def _search(self, root, value):
-        if not root or root.value == value: 
+        if not root or root.value == value:
             return root
         if value < root.value:
             return self._search(root.left, value)
@@ -80,11 +79,11 @@ def get_min(self):
     def get_max(self):
         """ returns the element with the maximum value """
         return self._extremes(self.root, find_min=False)
-    
+
     def successor(self, value):
         """ returns the successor of the element with value - value"""
         node = self.find_element(value)
-        if not node: 
+        if not node:
             return None
         if node.right:
             return self._extremes(node.right, find_min=True)
@@ -115,14 +114,14 @@ def insert(self, value):
             new_node.parent = parent
         self.len += 1
         return
-    
+
     def delete(self, value):
         """ deletes a node from tree with value - value """
         node = self.find_element(value)
         if not node:
             return None
         if not node.left or not node.right:
-            node_spliced = node 
+            node_spliced = node
         else:
             node_spliced = self.successor(node.value)
         if node_spliced.left:
@@ -137,7 +136,7 @@ def delete(self, value):
             node_spliced.parent.left = temp_node
         else:
             node_spliced.parent.right = temp_node
-        
+
         if node != node_spliced:
             node.value = node_spliced.value
         return node_spliced
