Minimum possible sum of absolute difference of pairs from given arrays
Last Updated :
03 Apr, 2023
Given two arrays a[] and b[] of size N and M respectively (N < M), the task is to find the minimum possible sum of absolute difference of pairs formed by pairing each element of array a[] with an element of array b[]
Note: Each element of each array can be considered only once.
Examples:
Input: a[] = {2, 3, 5}, b[] = {1, 2, 3, 4, 5}
Output: 0
Explanation: Elements {2, 3, 5} in array a[] can be paired with {2, 3, 5} in array b[].
This will give a minimum absolute difference of 0.
Input: a[] = {1, 4, 5, 8}, b[] = {1, 3, 4, 6, 7}
Output: 2
Naive approach: The easiest way is to sort the arrays and try all the possible combinations to choose N elements from b[] and make pairs with a[].
Time Complexity: O(N*logN + M*logM + MCN)
Auxiliary Space: O(1)
Efficient Approach: This problem can be efficiently solved by using the concept of dynamic programming using the following idea.
For each element at ith position of array a[], the jth element of b[] can either be used to form a pair with a[i] or not.
So the overlapping subproblem property can be used to form a dp[][] array to store the minimum absolute difference till ith element of b[] and jth element of a[] is considered and can be reused for further calculations.
Follow the steps mentioned below to implement the above idea:
- First sort both arrays.
- Initialize a matrix dp[][] where dp[i][j] indicates the total minimum absolute difference till the index ith index of b[] and jth index of a[].
- While iterating through the index of the larger array b[], at each point of iterations there can be two cases:
- Not taking the ith index into consideration of forming pair with minimum absolute difference sum. Then dp[i+1][j] = dp[i][j] as ith index is not considered and are moving to (i+1)th index directly.
- Considering the ith index. So add the absolute difference between elements at both ith and jth index and then move to (i+1)th and (j+1)th index respectively. So total value is dp[i+1][j+1] = dp[i][j] + abs(a[j] – b[i]).
- The value at dp[M][N] is the required answer.
Below is the implementation of the above approach.
C++
#include <bits/stdc++.h>
using namespace std;
int min_sum(int a[], int b[], int N, int M)
{
sort(a, a + N);
sort(b, b + M);
int dp[M + 1][N + 1];
for (int i = 0; i <= M; i++) {
for (int j = 0; j <= N; j++) {
dp[i][j] = 1e9;
}
}
dp[0][0] = 0;
for (int i = 0; i < M; i++) {
for (int j = 0; j <= N; j++) {
dp[i + 1][j] = dp[i][j];
}
for (int j = 0; j < N; j++) {
dp[i + 1][j + 1]
= min(dp[i + 1][j + 1],
dp[i][j]
+ abs(a[j] - b[i]));
}
}
return dp[M][N];
}
int main()
{
int a[] = { 1, 4, 5, 8 };
int N = sizeof(a) / sizeof(a[0]);
int b[] = { 1, 3, 4, 6, 7 };
int M = sizeof(b) / sizeof(b[0]);
cout << min_sum(a, b, N, M);
return 0;
}
|
Java
import java.util.*;
class GFG {
static int min_sum(int[] a, int[] b, int N, int M)
{
Arrays.sort(a);
Arrays.sort(b);
int[][] dp = new int[M + 1][N + 1];
for (int i = 0; i <= M; i++) {
for (int j = 0; j <= N; j++) {
dp[i][j] = 1000000000;
}
}
dp[0][0] = 0;
for (int i = 0; i < M; i++) {
for (int j = 0; j <= N; j++) {
dp[i + 1][j] = dp[i][j];
}
for (int j = 0; j < N; j++) {
dp[i + 1][ j + 1]
= Math.min(dp[i + 1][j + 1],
dp[i][j]
+ Math.abs(a[j] - b[i]));
}
}
return dp[M][N];
}
public static void main(String args[])
{
int[] a = { 1, 4, 5, 8 };
int N = a.length;
int[] b = { 1, 3, 4, 6, 7 };
int M = b.length;
System.out.print(min_sum(a, b, N, M));
}
}
|
Python3
def min_sum(a, b, N, M):
a.sort()
b.sort()
dp = [[0 for _ in range(N+1)] for _ in range(M+1)]
for i in range(0, M + 1):
for j in range(0, N+1):
dp[i][j] = int(1e9)
dp[0][0] = 0
for i in range(0, M):
for j in range(0, N+1):
dp[i + 1][j] = dp[i][j]
for j in range(0, N):
dp[i + 1][j + 1] = min(dp[i + 1][j + 1],
dp[i][j]
+ abs(a[j] - b[i]))
return dp[M][N]
if __name__ == "__main__":
a = [1, 4, 5, 8]
N = len(a)
b = [1, 3, 4, 6, 7]
M = len(b)
print(min_sum(a, b, N, M))
|
C#
using System;
public class GFG{
static int min_sum(int[] a, int[] b, int N, int M)
{
Array.Sort(a);
Array.Sort(b);
int[,] dp = new int[M + 1, N + 1];
for (int i = 0; i <= M; i++) {
for (int j = 0; j <= N; j++) {
dp[i,j] = 1000000000;
}
}
dp[0,0] = 0;
for (int i = 0; i < M; i++) {
for (int j = 0; j <= N; j++) {
dp[i + 1, j] = dp[i, j];
}
for (int j = 0; j < N; j++) {
dp[i + 1, j + 1]
= Math.Min(dp[i + 1, j + 1],
dp[i, j]
+ Math.Abs(a[j] - b[i]));
}
}
return dp[M, N];
}
static public void Main (){
int[] a = { 1, 4, 5, 8 };
int N = a.Length;
int[] b = { 1, 3, 4, 6, 7 };
int M = b.Length;
Console.Write(min_sum(a, b, N, M));
}
}
|
Javascript
<script>
function min_sum(a,b,N, M)
{
a.sort();
b.sort();
let dp = new Array(M+1);
for(let i=0;i<dp.length;i++) {
dp[i] = new Array(N+1)
}
for (let i = 0; i <= M; i++) {
for (let j = 0; j <= N; j++) {
dp[i][j] = 1e9;
}
}
dp[0][0] = 0;
for (let i = 0; i < M; i++) {
for (let j = 0; j <= N; j++) {
dp[i + 1][j] = dp[i][j];
}
for (let j = 0; j < N; j++) {
dp[i + 1][j + 1]
= Math.min(dp[i + 1][j + 1],
dp[i][j]
+ Math.abs(a[j] - b[i]));
}
}
return dp[M][N];
}
let a = [1, 4, 5, 8];
let N = a.length;
let b = [1, 3, 4, 6, 7 ];
let M = b.length;
document.write(min_sum(a, b, N, M));
</script>
|
Time complexity: O(N * M log N)
Auxiliary Space: O(N * M)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...