created divide_and_conquer folder and added max_sub_array_sum.py under it (issue #817)

Author: Dharni0607

divide_and_conquer/closest_pair_of_points.py

@@ -0,0 +1,67 @@
+"""
+The algorithm finds distance between closest pair of points in the given n points.
+Approach: Divide and conquer 
+The points are sorted based on x-cords 
+& by applying divide and conquer approach, 
+minimum distance is obtained recursively.
+
+Edge case: closest points lie on different sides of partition
+This case handled by forming a strip of points 
+which are at a distance (< closest_pair_dis) from mid-point.
+(It is a proven that strip contains at most 6 points)
+And brute force method is applied on strip to find closest points. 
+
+Time complexity: O(n * (logn) ^ 2)
+"""
+
+
+import math 
+
+
+def euclidean_distance(point1, point2):
+    return math.sqrt(pow(point1[0] - point2[0], 2) + pow(point1[1] - point2[1], 2))
+
+
+def column_based_sort(array, column = 0):
+    return sorted(array, key = lambda x: x[column])
+    
+
+#brute force approach to find distance between closest pair points
+def dis_btw_closest_pair(points, no_of_points, min_dis = float("inf")):
+    for i in range(no_of_points - 1):
+        for j in range(i+1, no_of_points):
+            current_dis = euclidean_distance(points[i], points[j])
+            if current_dis < min_dis:
+                min_dis = current_dis
+    return min_dis
+
+
+#divide and conquer approach
+def closest_pair_of_points(points, no_of_points):
+    # base case
+    if no_of_points <= 3:
+        return dis_btw_closest_pair(points, no_of_points)
+    
+    #recursion
+    mid = no_of_points//2
+    closest_in_left = closest_pair_of_points(points[:mid], mid)
+    closest_in_right = closest_pair_of_points(points[mid:], no_of_points - mid)
+    closest_pair_dis = min(closest_in_left, closest_in_right)
+    
+    #points which are at a distance (< closest_pair_dis) from mid-point
+    cross_strip = []
+    for point in points:
+        if abs(point[0] - points[mid][0]) < closest_pair_dis:
+            cross_strip.append(point)
+
+    cross_strip = column_based_sort(cross_strip, 1)
+    closest_in_strip = dis_btw_closest_pair(cross_strip, 
+                     len(cross_strip), closest_pair_dis)
+    return min(closest_pair_dis, closest_in_strip)
+    
+
+points = [[2, 3], [12, 30], [40, 50], [5, 1], [12, 10]]
+points = column_based_sort(points)
+print("Distance:", closest_pair_of_points(points, len(points)))
+
+

divide_and_conquer/max_sub_array_sum.py

@@ -0,0 +1,72 @@
+""" 
+Given a array of length n, max_sub_array_sum() finds the maximum of sum of contiguous sub-array using divide and conquer method.
+
+Time complexity : O(n log n)
+
+Ref : INTRODUCTION TO ALGORITHMS THIRD EDITION (section : 4, sub-section : 4.1, page : 70)
+
+"""
+
+
+def max_sum_from_start(array):
+    """ This function finds the maximum contiguous sum of array from 0 index
+
+    Parameters : 
+    array (list[int]) : given array
+    
+    Returns : 
+    max_sum (int) : maximum contiguous sum of array from 0 index
+
+    """
+    array_sum = 0
+    max_sum = float("-inf")
+    for num in array:
+        array_sum += num
+        if array_sum > max_sum:
+            max_sum = array_sum
+    return max_sum
+
+
+def max_cross_array_sum(array, left, mid, right):
+    """ This function finds the maximum contiguous sum of left and right arrays
+
+    Parameters : 
+    array, left, mid, right (list[int], int, int, int) 
+    
+    Returns : 
+    (int) :  maximum of sum of contiguous sum of left and right arrays
+
+    """
+
+    max_sum_of_left = max_sum_from_start(array[left:mid+1][::-1])
+    max_sum_of_right = max_sum_from_start(array[mid+1: right+1])
+    return max_sum_of_left + max_sum_of_right
+
+
+def max_sub_array_sum(array, left, right):
+    """ This function finds the maximum of sum of contiguous sub-array using divide and conquer method
+
+    Parameters : 
+    array, left, right (list[int], int, int) : given array, current left index and current right index
+    
+    Returns : 
+    int :  maximum of sum of contiguous sub-array
+
+    """
+
+    # base case: array has only one element
+    if left == right:
+        return array[right]
+    
+    # Recursion
+    mid = (left + right) // 2
+    left_half_sum = max_sub_array_sum(array, left, mid)
+    right_half_sum = max_sub_array_sum(array, mid + 1, right)
+    cross_sum = max_cross_array_sum(array, left, mid, right)
+    return max(left_half_sum, right_half_sum, cross_sum)
+
+
+array = [-2, -5, 6, -2, -3, 1, 5, -6]
+array_length = len(array)
+print("Maximum sum of contiguous subarray:", max_sub_array_sum(array, 0, array_length - 1))
+