Split array into minimum number of subsets such that elements of all pairs are present in different subsets at least once

Given an array arr[] consisting of N distinct integers, the task is to find the minimum number of times the array needs to be split into two subsets such that elements of each pair are present into two different subsets at least once.

Examples:

Input: arr[] = { 3, 4, 2, 1, 5 } 
Output: 3 
Explanation:
Possible pairs are { (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5) } 
Splitting the array into { 1, 2 } and { 3, 4, 5 } 
Elements of each of the pairs { (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5) } are present into two different subsets. 
Splitting the array into { 1, 3 } and { 2, 4, 5 } 
Elements of each of the pairs { (1, 2), (1, 4), (1, 5), (2, 3), (3, 4), (3, 5) } are present into two different subsets. 
Splitting the array into { 1, 3, 4 } and { 2, 5 } 
Elements of each of the pairs { (1, 2), (1, 5), (2, 3), (3, 5), (2, 4), (4, 5) } are present into two different subsets. 
Since elements of each pair of the array is present in two different subsets at least once, the required output is 3.

Input: arr[] = { 2, 1, 3 } 
Output: 2 

Approach: The idea is to always split the array into two subsets of size floor(N / 2) and ceil(N / 2). Before each partition just swap the value of arr[i] with arr[N / 2 + i]. Follow the steps given below to solve the problem:

• If N is odd, then total possible swap(arr[i], arr[N / 2 + i]) is equal to N / 2 + 1. Therefore, print (N / 2 + 1).
• If N is even, then total possible swap(arr[i], arr[N / 2 + i]) is equal to N / 2. Therefore, print (N / 2). 
  

Below is the C++ implementation of the above approach:

C++

// C++ program to to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find minimum count of ways to split
// the array into two subset such that elements of
// each pair occurs in two different subset
int MinimumNoOfWays(int arr[], int n)
{

    // Stores minimum count of ways to split array
    // into two subset such that elements of
    // each pair occurs in two different subset
    int mini_no_of_ways;

    // If N is odd
    if (n % 2 == 0) {
        mini_no_of_ways = n / 2;
    }
    else {
        mini_no_of_ways = n / 2 + 1;
    }
    return mini_no_of_ways;
}

// Driver Code
int main()
{
    int arr[] = { 3, 4, 2, 1, 5 };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << MinimumNoOfWays(arr, N);
    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;

class GFG{

// Function to find minimum count of ways to split
// the array into two subset such that elements of
// each pair occurs in two different subset
static int MinimumNoOfWays(int arr[], int n)
{

    // Stores minimum count of ways to split array
    // into two subset such that elements of
    // each pair occurs in two different subset
    int mini_no_of_ways;

    // If N is odd
    if (n % 2 == 0) {
        mini_no_of_ways = n / 2;
    }
    else {
        mini_no_of_ways = n / 2 + 1;
    }
    return mini_no_of_ways;
}

// Driver code
public static void main(String[] args)
{
    int arr[] = { 3, 4, 2, 1, 5 };
    int N = arr.length;
    System.out.print(MinimumNoOfWays(arr, N));
}
}

// This code is contributed by sanjoy_62

Python3

# Python program to to implement
# the above approach

# Function to find minimum count of ways to split
# the array into two subset such that elements of
# each pair occurs in two different subset
def MinimumNoOfWays(arr, n):

    # Stores minimum count of ways to split array
    # into two subset such that elements of
    # each pair occurs in two different subset
    min_no_of_ways = 0

    # if n is even
    if (n % 2 == 0):
        mini_no_of_ways = n // 2

    # n is odd
    else:
        mini_no_of_ways = n // 2 + 1

    return mini_no_of_ways

# driver code
if __name__ == '__main__':
    arr = [3, 4, 1, 2, 5]
    n = len(arr)
    print(MinimumNoOfWays(arr, n))

# This code is contributed by MuskanKalra1

C#

// C# program to implement
// the above approach
using System;
class GFG
{

// Function to find minimum count of ways to split
// the array into two subset such that elements of
// each pair occurs in two different subset
static int MinimumNoOfWays(int []arr, int n)
{

    // Stores minimum count of ways to split array
    // into two subset such that elements of
    // each pair occurs in two different subset
    int mini_no_of_ways;

    // If N is odd
    if (n % 2 == 0)
    {
        mini_no_of_ways = n / 2;
    }
    else
    {
        mini_no_of_ways = n / 2 + 1;
    }
    return mini_no_of_ways;
}

  // Driver code
  public static void Main(string[] args)
  {
      int[] arr = { 3, 4, 2, 1, 5 };
      int N = arr.Length;
      Console.WriteLine(MinimumNoOfWays(arr, N));
  }
}

// This code is contributed by AnkThon

Javascript

<script>
// javascript program to implement
// the above approach

    // Function to find minimum count of ways to split
    // the array into two subset such that elements of
    // each pair occurs in two different subset
    function MinimumNoOfWays(arr , n) {

        // Stores minimum count of ways to split array
        // into two subset such that elements of
        // each pair occurs in two different subset
        var mini_no_of_ways;

        // If N is odd
        if (n % 2 == 0) {
            mini_no_of_ways = n / 2;
        } else {
            mini_no_of_ways = n / 2 + 1;
        }
        return parseInt(mini_no_of_ways);
    }

    // Driver code

        var arr = [ 3, 4, 2, 1, 5 ];
        var N = arr.length;
        document.write(MinimumNoOfWays(arr, N));

// This code contributed by gauravrajput1
</script>

Output:

3

Time Complexity: O(1)
Space Complexity: O(1)