Minimum sum of absolute differences of pairs in a triplet from three arrays
Last Updated :
17 Aug, 2023
Given three arrays a[], b[] and c[] of sizes A, B and C respectively, the task is to find the minimum possible value of abs(a[i] - b[j]) + abs(b[j] - c[k]) where 0 ? i ? A, 0 ? j ? B and 0 ? k ? C.
Examples:
Input: A = 3, B = 2, C = 2, a[] = {1, 8, 5}, b[] = {2, 9}, c[] = {5, 4}
Output: 3
Explanation:
The triplet (a[0], b[0], c[1]), i.e. (1, 2, 4) has minimum sum of absolute difference of pairs, i.e. abs(1 - 2) + abs(2 - 4) = 1 + 2 = 3.
Input: A = 4, B = 3, C = 3, a[] = {4, 5, 1, 7}, b[] = {8, 5, 6}, c[] = {2, 7, 12}
Output: 2
Explanation:
The triplet (a[1], b[1], c[1]), i.e. (1, 5, 7) has minimum sum of absolute difference of pairs, i.e. abs(5 - 5) + abs(5 - 7) = 0 + 2 = 2.
Approach: The idea to solve this problem is to sort the arrays a[] and c[] and then traverse the array b[] and find the elements which satisfy the given condition.
Follow the steps below to solve the problem:
- Initialize the variable, say min, as INT_MAX, to store the minimum possible value.
- Sort the arrays a[] and c[] in increasing order.
- Traverse the array b[] and for each element, say b[i], find the closest element to b[i] from the arrays a[] and c[] as arr_close and crr_close and do the following:
- To find the closest element, firstly find the lower_bound of the target element b[i].
- If the lower bound is found, check if it is the first element of the array or not. If it is not, then compare the lower bound and its previous element with the target element and find which is closest to the target element.
- If the lower bound is not found, then the closest element will be the last element of the array.
- Update min as the minimum of abs(b[i] – arr_close) + abs(b[i] – crr_close).
- After completing the above steps, print the value of min as the result.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
// Function to find the value
// closest to K in the array A[]
int closestValue(vector<int> A, int k)
{
// Initialize close value as the
// end element
int close = A.back();
// Find lower bound of the array
auto it = lower_bound(A.begin(),
A.end(), k);
// If lower_bound is found
if (it != A.end()) {
close = *it;
// If lower_bound is not
// the first array element
if (it != A.begin()) {
// If *(it - 1) is closer to k
if ((k - *(it - 1))
< (close - k)) {
close = *(it - 1);
}
}
}
// Return closest value of k
return close;
}
// Function to find the minimum sum of
// abs(arr[i] - brr[j]) and abs(brr[j]-crr[k])
void minPossible(vector<int> arr,
vector<int> brr,
vector<int> crr)
{
// Sort the vectors arr and crr
sort(arr.begin(), arr.end());
sort(crr.begin(), crr.end());
// Initialize minimum as INT_MAX
int minimum = INT_MAX;
// Traverse the array brr[]
for (int val : brr) {
// Stores the element closest
// to val from the array arr[]
int arr_close = closestValue(arr, val);
// Stores the element closest
// to val from the array crr[]
int crr_close = closestValue(crr, val);
// If sum of differences is minimum
if (abs(val - arr_close)
+ abs(val - crr_close)
< minimum)
// Update the minimum
minimum = abs(val - arr_close)
+ abs(val - crr_close);
}
// Print the minimum absolute
// difference possible
cout << minimum;
}
// Driver Code
int main()
{
vector<int> a = { 1, 8, 5 };
vector<int> b = { 2, 9 };
vector<int> c = { 5, 4 };
// Function Call
minPossible(a, b, c);
return 0;
}
// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
class GFG{
// Lower_bound function
public static int lower_bound(int arr[], int key)
{
int low = 0;
int high = arr.length - 1;
while (low < high)
{
int mid = low + (high - low) / 2;
if (arr[mid] >= key)
{
high = mid;
}
else
{
low = mid + 1;
}
}
return low;
}
// Function to find the value
// closest to K in the array A[]
static int closestValue(int A[], int k)
{
// Initialize close value as the
// end element
int close = A[A.length - 1];
// Find lower bound of the array
int it = lower_bound(A, k);
// If lower_bound is found
if (it != A.length)
{
close = A[it];
// If lower_bound is not
// the first array element
if (it != 0)
{
// If *(it - 1) is closer to k
if ((k - A[it - 1]) < (close - k))
{
close = A[it - 1];
}
}
}
// Return closest value of k
return close;
}
// Function to find the minimum sum of
// abs(arr[i] - brr[j]) and abs(brr[j]-crr[k])
static void minPossible(int arr[], int brr[],
int crr[])
{
// Sort the vectors arr and crr
Arrays.sort(arr);
Arrays.sort(crr);
// Initialize minimum as INT_MAX
int minimum = Integer.MAX_VALUE;
// Traverse the array brr[]
for(int val : brr)
{
// Stores the element closest
// to val from the array arr[]
int arr_close = closestValue(arr, val);
// Stores the element closest
// to val from the array crr[]
int crr_close = closestValue(crr, val);
// If sum of differences is minimum
if (Math.abs(val - arr_close) +
Math.abs(val - crr_close) < minimum)
// Update the minimum
minimum = Math.abs(val - arr_close) +
Math.abs(val - crr_close);
}
// Print the minimum absolute
// difference possible
System.out.println(minimum);
}
// Driver Code
public static void main(String[] args)
{
int a[] = { 1, 8, 5 };
int b[] = { 2, 9 };
int c[] = { 5, 4 };
// Function Call
minPossible(a, b, c);
}
}
// This code is contributed by Kingash
# Python program to implement
# the above approach
# Lower_bound function
def lower_bound(arr, key):
low = 0;
high = len(arr) - 1;
while (low < high):
mid = low + (high - low) // 2;
if (arr[mid] >= key):
high = mid;
else:
low = mid + 1;
return low;
# Function to find the value
# closest to K in the array A[]
def closestValue(A, k):
# Initialize close value as the
# end element
close = A[-1];
# Find lower bound of the array
it = lower_bound(A, k);
# If lower_bound is found
if (it != len(A)):
close = A[it];
# If lower_bound is not
# the first array element
if (it != 0):
# If *(it - 1) is closer to k
if ((k - A[it - 1]) < (close - k)):
close = A[it - 1];
# Return closest value of k
return close;
# Function to find the minimum sum of
# abs(arr[i] - brr[j]) and abs(brr[j]-crr[k])
def minPossible(arr, brr, crr):
# Sort the vectors arr and crr
arr.sort();
crr.sort();
# Initialize minimum as LET_MAX
minimum = 10**9;
# Traverse the array brr[]
for val in brr:
# Stores the element closest
# to val from the array arr[]
arr_close = closestValue(arr, val);
# Stores the element closest
# to val from the array crr[]
crr_close = closestValue(crr, val);
# If sum of differences is minimum
if (abs(val - arr_close) +
abs(val - crr_close) < minimum):
# Update the minimum
minimum = abs(val - arr_close) + abs(val - crr_close);
# Print the minimum absolute
# difference possible
print(minimum);
# Driver code
a = [ 1, 8, 5 ];
b = [ 2, 9 ];
c = [ 5, 4 ];
# Function Call
minPossible(a, b, c);
# This code is contributed by gfgking
// C# program for the above approach
using System;
class GFG{
// Lower_bound function
public static int lower_bound(int[] arr, int key)
{
int low = 0;
int high = arr.Length - 1;
while (low < high)
{
int mid = low + (high - low) / 2;
if (arr[mid] >= key)
{
high = mid;
}
else
{
low = mid + 1;
}
}
return low;
}
// Function to find the value
// closest to K in the array A[]
static int closestValue(int []A, int k)
{
// Initialize close value as the
// end element
int close = A[A.Length - 1];
// Find lower bound of the array
int it = lower_bound(A, k);
// If lower_bound is found
if (it != A.Length)
{
close = A[it];
// If lower_bound is not
// the first array element
if (it != 0)
{
// If *(it - 1) is closer to k
if ((k - A[it - 1]) < (close - k))
{
close = A[it - 1];
}
}
}
// Return closest value of k
return close;
}
// Function to find the minimum sum of
// abs(arr[i] - brr[j]) and abs(brr[j]-crr[k])
static void minPossible(int[] arr, int[] brr,
int[] crr)
{
// Sort the vectors arr and crr
Array.Sort(arr);
Array.Sort(crr);
// Initialize minimum as INT_MAX
int minimum = Int32.MaxValue;
// Traverse the array brr[]
foreach(int val in brr)
{
// Stores the element closest
// to val from the array arr[]
int arr_close = closestValue(arr, val);
// Stores the element closest
// to val from the array crr[]
int crr_close = closestValue(crr, val);
// If sum of differences is minimum
if (Math.Abs(val - arr_close) +
Math.Abs(val - crr_close) < minimum)
// Update the minimum
minimum = Math.Abs(val - arr_close) +
Math.Abs(val - crr_close);
}
// Print the minimum absolute
// difference possible
Console.WriteLine(minimum);
}
// Driver Code
static void Main()
{
int []a = { 1, 8, 5 };
int []b = { 2, 9 };
int []c = { 5, 4 };
// Function Call
minPossible(a, b, c);
}
}
// This code is contributed by SoumikMondal
<script>
// JavaScript program to implement
// the above approach
// Lower_bound function
function lower_bound(arr, key)
{
let low = 0;
let high = arr.length - 1;
while (low < high)
{
let mid = low + Math.floor((high - low) / 2);
if (arr[mid] >= key)
{
high = mid;
}
else
{
low = mid + 1;
}
}
return low;
}
// Function to find the value
// closest to K in the array A[]
function closestValue(A, k)
{
// Initialize close value as the
// end element
let close = A[A.length - 1];
// Find lower bound of the array
let it = lower_bound(A, k);
// If lower_bound is found
if (it != A.length)
{
close = A[it];
// If lower_bound is not
// the first array element
if (it != 0)
{
// If *(it - 1) is closer to k
if ((k - A[it - 1]) < (close - k))
{
close = A[it - 1];
}
}
}
// Return closest value of k
return close;
}
// Function to find the minimum sum of
// abs(arr[i] - brr[j]) and abs(brr[j]-crr[k])
function minPossible(arr, brr, crr)
{
// Sort the vectors arr and crr
arr.sort();
crr.sort();
// Initialize minimum as LET_MAX
let minimum = Number.MAX_VALUE;
// Traverse the array brr[]
for(let val in brr)
{
// Stores the element closest
// to val from the array arr[]
let arr_close = closestValue(arr, val);
// Stores the element closest
// to val from the array crr[]
let crr_close = closestValue(crr, val);
// If sum of differences is minimum
if (Math.abs(val - arr_close) +
Math.abs(val - crr_close) < minimum)
// Update the minimum
minimum = Math.abs(val - arr_close) +
Math.abs(val - crr_close);
}
// Print the minimum absolute
// difference possible
document.write(minimum);
}
// Driver code
let a = [ 1, 8, 5 ];
let b = [ 2, 9 ];
let c = [ 5, 4 ];
// Function Call
minPossible(a, b, c);
// This code is contributed by susmitakundugoaldanga.
</script>
Time Complexity: O(A*log A + C*log C + B*log A + B*log C)
Auxiliary Space: O(A + B + C)
Similar Reads
DSA Tutorial - Learn Data Structures and Algorithms
DSA (Data Structures and Algorithms) is the study of organizing data efficiently using data structures like arrays, stacks, and trees, paired with step-by-step procedures (or algorithms) to solve problems effectively. Data structures manage how data is stored and accessed, while algorithms focus on
7 min read
Quick Sort
QuickSort is a sorting algorithm based on the Divide and Conquer that picks an element as a pivot and partitions the given array around the picked pivot by placing the pivot in its correct position in the sorted array. It works on the principle of divide and conquer, breaking down the problem into s
12 min read
Merge Sort - Data Structure and Algorithms Tutorials
Merge sort is a popular sorting algorithm known for its efficiency and stability. It follows the divide-and-conquer approach. It works by recursively dividing the input array into two halves, recursively sorting the two halves and finally merging them back together to obtain the sorted array. Merge
14 min read
Bubble Sort Algorithm
Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. This algorithm is not suitable for large data sets as its average and worst-case time complexity are quite high.We sort the array using multiple passes. After the fir
8 min read
Breadth First Search or BFS for a Graph
Given a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
15+ min read
Binary Search Algorithm - Iterative and Recursive Implementation
Binary Search Algorithm is a searching algorithm used in a sorted array by repeatedly dividing the search interval in half. The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N). Binary Search AlgorithmConditions to apply Binary Searc
15 min read
Data Structures Tutorial
Data structures are the fundamental building blocks of computer programming. They define how data is organized, stored, and manipulated within a program. Understanding data structures is very important for developing efficient and effective algorithms. What is Data Structure?A data structure is a st
2 min read
Insertion Sort Algorithm
Insertion sort is a simple sorting algorithm that works by iteratively inserting each element of an unsorted list into its correct position in a sorted portion of the list. It is like sorting playing cards in your hands. You split the cards into two groups: the sorted cards and the unsorted cards. T
9 min read
Dijkstra's Algorithm to find Shortest Paths from a Source to all
Given a weighted undirected graph represented as an edge list and a source vertex src, find the shortest path distances from the source vertex to all other vertices in the graph. The graph contains V vertices, numbered from 0 to V - 1.Note: The given graph does not contain any negative edge. Example
12 min read
Selection Sort
Selection Sort is a comparison-based sorting algorithm. It sorts an array by repeatedly selecting the smallest (or largest) element from the unsorted portion and swapping it with the first unsorted element. This process continues until the entire array is sorted.First we find the smallest element an
8 min read