Merge branch 'smv1999:master' into main

Author: vishvarana

Data Structures/Trees/BinaryTree_Maximum_Path_Sum.cpp

@@ -0,0 +1,56 @@
+/*
+Src : LeetCode
+--------------
+
+A path in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence at most once. Note that the path does not need to pass through the root.
+The path sum of a path is the sum of the node's values in the path.
+Given the root of a binary tree, return the maximum path sum of any path.
+
+Input: root = [-10,9,20,null,null,15,7]
+Output: 42
+Explanation: The optimal path is 15 -> 20 -> 7 with a path sum of 15 + 20 + 7 = 42.
+*/
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+	/**The logic is very simple. The maximum path sum will always consist of a node and its left and right sub-tree maximum path sum. As the node values can be negative also so 
+	4 cases comes here .
+	1) A node and its both sub-trees will constitute the sum 
+	2) Only a node and its left sub-tree will constitute the sum
+	3) Only a node and its right sub-tree will constitute the sum
+	4) Only one node will constitute the sum
+	*/
+    int maxPathSum(TreeNode* root) {
+        if(root==NULL)
+            return 0;
+        int ans=root->val,sum;
+        sum=helper(root,ans);
+        return max(ans,sum);
+    }
+    
+    int helper(TreeNode* root,int &ans){
+        if(root==NULL)
+            return 0;
+        int l=helper(root->left,ans);
+        int r=helper(root->right,ans);
+        if(l<0)
+            l=0;
+        if(r<0)
+            r=0;
+        //Case 1 and 4 is checked here
+        ans=max(ans,l+r+root->val);
+        //Case 2 and 3 is checked here
+        return max(l+root->val,r+root->val);
+    }
+};

Divide and Conquer/ClosestPairOfPoints.py

@@ -0,0 +1,94 @@
+# Task. Given 𝑛 points on a plane, find the smallest distance between a pair of two (different) points. Recall
+# that the distance between points (𝑥1, 𝑦1) and (𝑥2, 𝑦2) is equal to √︀((𝑥1 − 𝑥2)² + (𝑦1 − 𝑦2)²)
+
+import math
+def dist(p1, p2):
+    return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
+
+def closest_split_pair(p_x, p_y, delta, best_pair):
+    ln_x = len(p_x)  # store length - quicker
+    mx_x = p_x[ln_x // 2][0]  # select midpoint on x-sorted array
+
+    # Create a subarray of points not further than delta from midpoint on x-sorted array
+    s_y = [x for x in p_y if mx_x - delta <= x[0] <= mx_x + delta]
+
+    best = delta  # assign delta value to best
+    ln_y = len(s_y)  # store length of subarray for quickness
+    for i in range(ln_y - 1):
+        for j in range(i+1, min(i + 5, ln_y)):    # We have to check only next 5 points;
+            p, q = s_y[i], s_y[j]
+            dst = dist(p, q)
+            if dst < best:
+                best_pair = p, q
+                best = dst
+    return best_pair[0], best_pair[1], best
+
+
+def brute(ax):
+    mi = dist(ax[0], ax[1])
+    p1 = ax[0]
+    p2 = ax[1]
+    ln_ax = len(ax)
+    if ln_ax == 2:
+        return p1, p2, mi
+    for i in range(ln_ax-1):
+        for j in range(i + 1, ln_ax):
+            if i != 0 and j != 1:
+                d = dist(ax[i], ax[j])
+                if d < mi:  # Update min_dist and points
+                    mi = d
+                    p1, p2 = ax[i], ax[j]
+    return p1, p2, mi
+
+
+def closest_pair(ax, ay):
+    ln_ax = len(ax)  # It's quicker to assign variable
+    if ln_ax <= 3:
+        return brute(ax)  # A call to bruteforce comparison
+    mid = ln_ax // 2  # Division without remainder, need int
+    Qx = ax[:mid]  # Two-part split
+    Rx = ax[mid:]
+
+    midpoint = ax[mid][0]
+    Qy = list()
+    Ry = list()
+    for x in ay:  # split ay into 2 arrays using midpoint
+        if x[0] < midpoint:
+           Qy.append(x)
+        else:
+           Ry.append(x)
+    # Call recursively both arrays after split
+    (p1, q1, mi1) = closest_pair(Qx, Qy)
+    (p2, q2, mi2) = closest_pair(Rx, Ry)
+
+    # Determine smaller distance between points of 2 arrays
+    if mi1 <= mi2:
+        d = mi1
+        mn = (p1, q1)
+    else:
+        d = mi2
+        mn = (p2, q2)
+
+    # Call function to account for points on the boundary
+    (p3, q3, mi3) = closest_split_pair(ax, ay, d, mn)
+    # Determine smallest distance for the array
+    if d <= mi3:
+        return mn[0], mn[1], d
+    else:
+        return p3, q3, mi3
+
+
+def solution(a):
+    ax = sorted(a, key=lambda x: x[0])  # Presorting x-wise O(nlogn)
+    ay = sorted(a, key=lambda x: (x[1], x[0]))  # Presorting y-wise then x-wise O(nlogn)
+    p1, p2, mi = closest_pair(ax, ay)  # Recursive D&C function
+    return mi
+
+
+# Input
+points = list()
+n = int(input())
+for i in range(n):
+    points.append([int(i) for i in input().split()])
+
+print(solution(points))

General Questions/combinational_sum.py

@@ -0,0 +1,94 @@
+"""
+DESCRIPTION :
+Given an array of integers arr[] and a target number k, write a program to find all unique combinations in arr[] 
+such that the sum of all integers in the combination is equal to k.
+The same repeated number may be chosen from arr[] unlimited number of times.
+
+NOTE :
+        1. All numbers will be positive integers.
+        2. Elements in a combination (a1, a2, …, ak) must be in non-descending order. (ie, a1 ≤ a2 ≤ … ≤ ak).
+        3. The combinations themselves must be sorted in ascending order.
+        4. The solution set must not contain duplicate combinations.
+        
+EXAMPLE :
+
+Given array 2,3,6,7 and target 7,
+A solution set is:
+[2, 2, 3]
+
+CONSTRAINTS:
+1 <= N <= 30
+1 <= A[i] <= 20
+1 <= B <= 100
+
+SOLUTION APPROACH :
+
+In every recursion run, you either include the element in the combination or you don’t. 
+To account for multiple occurrences of an element, 
+make sure you call the next function without incrementing the current index.
+
+"""
+# SOLUTION IN PYTHON3
+
+
+class Solution:
+    # @param A : list of integers
+    # @param B : integer
+    # @return a list of list of integers
+    def combinationSum(self, A, B):
+        # Remove duplicate and sort since each element can be repeated 
+        # in combination either way.
+        # Removing duplicates here helps us avoid removing them from the final result.
+        A=sorted(set(A))
+        # if the target sum is less than 2 or the lis A is empty,
+        # then retirn an empty list
+        if B<2 or len(A)==0:
+            return []
+
+        
+        result=[]
+        comb=[]
+        index=0
+        self.find(result, comb, A, B, index)
+        return result
+    
+    def find(self, result, comb, A, B, index):
+        # The recursion will nest until we hit the target. At this point we append and return.
+        if sum(comb) == B:
+            result.append(comb[:])
+            return
+        # If the sum is bigger, we also terminate the recursion chain.
+        if sum(comb)>B:
+            return
+        
+        for i in range(index, len(A)):
+            comb.append(A[i])
+            # Start from same index since an element can be repeated.
+            self.find(result, comb, A, B, i)
+            comb.pop()
+                
+ '''
+ 
+Sample Input : A  = [2,3,5], B = 8 
+Output:  
+[   
+    [2,2,2,2],   
+    [2,3,3],   
+    [3,5] 
+]
+
+EXPLANATION: 
+All the unique combinations whose sum is 8 is printed.
+2+2+2+2 = 8
+2+3+3 = 8
+3+5 = 8
+
+COMPLEXITY ANALYSIS :
+
+Time Complexity -> O(l^k) 
+Where l is the length of the array, k is the length of the longest possible combination (namely target / minInArray).
+
+Space Complexity -> O(k)
+for storing the path, which could be k long at most.
+
+'''