Partition a set into two subsets such that difference between max of one and min of other is minimized

Given an array arr[] of N integers, the task is to split the array into two subsets such that the absolute difference between the maximum of first subset and minimum of second subset is minimum.

Examples:

Input: arr[] = {3, 1, 2, 6, 4}
Output: 1
Explanation:
Splitting the given array in two subsets, A = [1, 2, 4], B = [3, 6]. Difference of maximum of first set is 4 and minimum of second set is 3 and their difference is 1.

Input: arr[] = {2, 1, 3, 2, 4, 3}
Output: 0
Explanation:
Splitting the given array in two subsets, A = [1, 2, 2, 3], B = [3, 4]. Difference of maximum of first set is 3 and minimum of second set is 3 and their difference is 0.

Approach: To solve the above problem we have to find the two integers such that m and n such that max of first set is m and the min of second set is n. The idea is to sort the given array ascending order and after sorting the array, the minimum difference between the consecutive element is the required minimum difference after partitioning the array elements into subsets.



Below is the implementation of above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to split the array
int splitArray(int arr[], int N)
{
    // Sort the array in increasing order
    sort(arr, arr + N);
  
    int result = INT_MAX;
  
    // Calculating the max difference
    // between consecutive elements
    for (int i = 1; i < N; i++) {
        result = min(result,
                     arr[i] - arr[i - 1]);
    }
  
    // Return the final minimum difference
    return result;
}
  
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 3, 1, 2, 6, 4 };
  
    // Size of array
    int N = sizeof(arr) / sizeof(arr[0]);
  
    // Function Call
    cout << splitArray(arr, N);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// java program for the above approach
import java.util.*; 
class GFG{
  
// Function to split the array
static int splitArray(int arr[], int N)
{
    // Sort the array in increasing order
    Arrays.sort(arr);
  
    int result = Integer.MAX_VALUE;
  
    // Calculating the max difference
    // between consecutive elements
    for (int i = 1; i < N; i++) 
    {
        result = Math.min(result,
                          arr[i] - arr[i - 1]);
    }
  
    // Return the final minimum difference
    return result;
}
  
// Driver Code
public static void main(String[] args) 
    // Given array arr[]
    int arr[] = { 3, 1, 2, 6, 4 };
  
    // Size of array
    int N = arr.length;
  
    // Function Call
    System.out.print(splitArray(arr, N));
}
}
  
// This code is contributed by shivanisinghss2110

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
  
# Function to split the array
def splitArray(arr, N):
      
    # Sort the array in increasing
    # order
    arr = sorted(arr)
  
    result = 10 ** 9
  
    # Calculating the max difference
    # between consecutive elements
    for i in range(1, N):
        result = min(result, arr[i] - arr[i - 1])
  
    # Return the final minimum difference
    return result
  
# Driver Code
if __name__ == '__main__':
      
    # Given array arr[]
    arr = [ 3, 1, 2, 6, 4 ]
  
    # Size of array
    N = len(arr)
  
    # Function Call
    print(splitArray(arr, N))
  
# This code is contributed by mohit kumar 29

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
class GFG{
  
// Function to split the array
static int splitArray(int []arr, int N)
{
    // Sort the array in increasing order
    Array.Sort(arr);
  
    int result = Int32.MaxValue;
  
    // Calculating the max difference
    // between consecutive elements
    for (int i = 1; i < N; i++) 
    {
        result = Math.Min(result,
                          arr[i] - arr[i - 1]);
    }
  
    // Return the final minimum difference
    return result;
}
  
// Driver Code
public static void Main() 
    // Given array arr[]
    int []arr = { 3, 1, 2, 6, 4 };
  
    // Size of array
    int N = arr.Length;
  
    // Function Call
    Console.Write(splitArray(arr, N));
}
}
  
// This code is contributed by Code_Mech

chevron_right


Output:

1

Time Complexity: O(N*log N)

competitive-programming-img




My Personal Notes arrow_drop_up

Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.