# 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:**

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.

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

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)