additional file in divide_and_conqure (closest pair of points)

Author: Dharni0607

Diff for: divide_and_conquer/closest_pair_of_points.py

@@ -1,66 +1,113 @@
 """
-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 
+The algorithm finds distance btw closest pair of points in the given n points.
+Approach used -> Divide and conquer 
+The points are sorted based on Xco-ords 
 & by applying divide and conquer approach, 
 minimum distance is obtained recursively.
 
-Edge case: closest points lie on different sides of partition
+>> 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. 
+whose Xco-ords distance is less than closest_pair_dis
+from mid-point's Xco-ords.
+Closest pair distance is found in the strip of points. (closest_in_strip)
 
-Time complexity: O(n * (logn) ^ 2)
+min(closest_pair_dis, closest_in_strip) would be the final answer.
+ 
+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 euclidean_distance_sqr(point1, point2):
+    return 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])
+def dis_btw_closest_pair(points, points_counts, min_dis = float("inf")):
+    """ brute force approach to find distance between closest pair points
+
+    Parameters : 
+    points, points_count, min_dis (tuple(tuple(int, int)), int, int) 
+    
+    Returns : 
+    min_dis (float):  distance between closest pair of points
+
+    """
+
+    for i in range(points_counts - 1):
+        for j in range(i+1, points_counts):
+            current_dis = euclidean_distance_sqr(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):
+def dis_btw_closest_in_strip(points, points_counts, min_dis = float("inf")):
+    """ closest pair of points in strip
+
+    Parameters : 
+    points, points_count, min_dis (tuple(tuple(int, int)), int, int) 
+    
+    Returns : 
+    min_dis (float):  distance btw closest pair of points in the strip (< min_dis)
+
+    """
+
+    for i in range(min(6, points_counts - 1), points_counts):
+        for j in range(max(0, i-6), i):
+            current_dis = euclidean_distance_sqr(points[i], points[j])
+            if current_dis < min_dis:
+                min_dis = current_dis
+    return min_dis
+
+
+
+def closest_pair_of_points_sqr(points, points_counts):
+    """ divide and conquer approach
+
+    Parameters : 
+    points, points_count (tuple(tuple(int, int)), int) 
+    
+    Returns : 
+    (float):  distance btw closest pair of points 
+
+    """
+
     # base case
-    if no_of_points <= 3:
-        return dis_btw_closest_pair(points, no_of_points)
+    if points_counts <= 3:
+        return dis_btw_closest_pair(points, points_counts)
 
-    #recursion
-    mid = no_of_points//2
+    # recursion
+    mid = points_counts//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_in_right = closest_pair_of_points(points[mid:], points_counts - 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 contains the points, whose Xcoords are at a 
+    distance(< closest_pair_dis) from mid's Xcoord
+    """
+
     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, 
+    closest_in_strip = dis_btw_closest_in_strip(cross_strip, 
                      len(cross_strip), closest_pair_dis)
     return min(closest_pair_dis, closest_in_strip)
+
 
+def closest_pair_of_points(points, points_counts):
+    return math.sqrt(closest_pair_of_points_sqr(points, points_counts))
+
 
-points = [[2, 3], [12, 30], [40, 50], [5, 1], [12, 10]]
+points = ((2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (0, 2), (5, 6), (1, 2))
 points = column_based_sort(points)
 print("Distance:", closest_pair_of_points(points, len(points)))
 

Diff for: divide_and_conquer/max_sub_array_sum.py renamed to divide_and_conquer/max_subarray_sum.py

@@ -1,9 +1,11 @@
 """ 
-Given a array of length n, max_sub_array_sum() finds the maximum of sum of contiguous sub-array using divide and conquer method.
+Given a array of length n, max_subarray_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)
+Ref : INTRODUCTION TO ALGORITHMS THIRD EDITION 
+(section : 4, sub-section : 4.1, page : 70)
 
 """
 
@@ -43,11 +45,12 @@ def max_cross_array_sum(array, left, mid, right):
     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
+def max_subarray_sum(array, left, right):
+    """ Maximum contiguous sub-array sum, using divide and conquer method
 
     Parameters : 
-    array, left, right (list[int], int, int) : given array, current left index and current right index
+    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
@@ -60,13 +63,13 @@ def max_sub_array_sum(array, left, 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)
+    left_half_sum = max_subarray_sum(array, left, mid)
+    right_half_sum = max_subarray_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))
+print("Maximum sum of contiguous subarray:", max_subarray_sum(array, 0, array_length - 1))