Split given Array in minimum number of subarrays such that rearranging the order of subarrays sorts the array
Last Updated :
23 Jul, 2025
Given an array arr[] consisting of N integers, the task is to find the minimum number of splitting of array elements into subarrays such that rearranging the order of subarrays sorts the given array.
Examples:
Input: arr[] = {6, 3, 4, 2, 1}
Output: 4
Explanation:
The given array can be divided into 4 subarrays as {6}, {3, 4}, {2}, {1} and these subarrays can be rearranged as {1}, {2}, {3, 4}, {6}. The resulting array will be {1, 2, 3, 4, 6} which is sorted. So, the minimum subarrays the given array can be divided to sort the array is 4.
Input: arr[] = {1, -4, 0, -2}
Output: 4
Approach: The given problem can be solved by maintaining a sorted version of the array arr[] and grouping together all integers in the original array which appear in the same sequence as in the sorted array. Below are the steps:
- Maintain a vector of pair V that stores the value of the current element and the index of the current element of the array arr[] for all elements in the given array.
- Sort the vector V.
- Initialize a variable, say cnt as 1 that stores the minimum number of subarrays required.
- Traverse the vector V for i in the range [1, N - 1] and perform the following steps:
- If the index of the ith element in the original array is (1 + index of (i - 1)th element) in the original array, then the two can be grouped together in the same subarray.
- Otherwise, the two elements need to be in separate subarrays and increment the value of cnt by 1.
- After completing the above steps, print the value of cnt as the resultant possible breaking of subarrays.
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 minimum number of
// subarrays such that rearranging the
// subarrays sort the array
int numberOfSubarrays(int arr[], int n)
{
// Stores the minimum number of
// subarrays
int cnt = 1;
// Stores all the elements in the
// array with their indices
vector<pair<int, int> > v(n);
// Copy array elements in vector
for (int i = 0; i < n; i++) {
v[i].first = arr[i];
v[i].second = i;
}
// Sort the vector v
sort(v.begin(), v.end());
// Iterate through vector v
for (int i = 1; i < n; i++) {
// If the (i)th and (i-1)th element
// can be grouped in same subarray
if (v[i].second == v[i - 1].second + 1) {
continue;
}
else {
cnt++;
}
}
// Return resultant count
return cnt;
}
// Driver Code
int main()
{
int arr[] = { 6, 3, 4, 2, 1 };
int N = sizeof(arr) / sizeof(arr[0]);
cout << numberOfSubarrays(arr, N);
return 0;
}
// Java program for the above approach
import java.util.*;
class GFG{
static class pair
{
int first, second;
public pair(int first, int second)
{
this.first = first;
this.second = second;
}
}
// Function to find minimum number of
// subarrays such that rearranging the
// subarrays sort the array
static int numberOfSubarrays(int arr[], int n)
{
// Stores the minimum number of
// subarrays
int cnt = 1;
// Stores all the elements in the
// array with their indices
pair[] v = new pair[n];
// Copy array elements in vector
for (int i = 0; i < n; i++) {
v[i] = new pair(0,0);
v[i].first = arr[i];
v[i].second = i;
}
// Sort the vector v
Arrays.sort(v,(a,b)->a.first-b.first);
// Iterate through vector v
for (int i = 1; i < n; i++) {
// If the (i)th and (i-1)th element
// can be grouped in same subarray
if (v[i].second == v[i - 1].second + 1) {
continue;
}
else {
cnt++;
}
}
// Return resultant count
return cnt;
}
// Driver Code
public static void main(String[] args)
{
int arr[] = { 6, 3, 4, 2, 1 };
int N = arr.length;
System.out.print(numberOfSubarrays(arr, N));
}
}
// This code is contributed by 29AjayKumar
# Python Program to implement
# the above approach
# Function to find minimum number of
# subarrays such that rearranging the
# subarrays sort the array
def numberOfSubarrays(arr, n):
# Stores the minimum number of
# subarrays
cnt = 1
# Stores all the elements in the
# array with their indices
v = []
# Copy array elements in vector
for i in range(n):
v.append({'first': arr[i], 'second': i})
# Sort the vector v
v = sorted(v, key = lambda i: i['first'])
# Iterate through vector v
for i in range(1, n):
# If the (i)th and (i-1)th element
# can be grouped in same subarray
if (v[i]['second'] == v[i - 1]['second']+1):
continue
else:
cnt += 1
# Return resultant count
return cnt
# Driver Code
arr = [6, 3, 4, 2, 1]
N = len(arr)
print(numberOfSubarrays(arr, N))
# This code is contributed by gfgking
// C# program for the above approach
using System;
using System.Collections.Generic;
public class GFG{
class pair : IComparable<pair>
{
public int first, second;
public pair(int first, int second)
{
this.first = first;
this.second = second;
}
public int CompareTo(pair other)
{
// return other.Salary.CompareTo(this.Salary);
if (this.first < other.first)
{
return 1;
}
else if (this.first > other.first)
{
return -1;
}
else
{
return 0;
}
}
}
// Function to find minimum number of
// subarrays such that rearranging the
// subarrays sort the array
static int numberOfSubarrays(int []arr, int n)
{
// Stores the minimum number of
// subarrays
int cnt = 1;
// Stores all the elements in the
// array with their indices
pair[] v = new pair[n];
// Copy array elements in vector
for (int i = 0; i < n; i++) {
v[i] = new pair(0,0);
v[i].first = arr[i];
v[i].second = i;
}
// Sort the vector v
Array.Sort(v);
// Iterate through vector v
for (int i = 1; i < n; i++) {
// If the (i)th and (i-1)th element
// can be grouped in same subarray
if (v[i].second == v[i - 1].second + 1) {
continue;
}
else {
cnt++;
}
}
// Return resultant count
return cnt;
}
// Driver Code
public static void Main(String[] args)
{
int []arr = { 6, 3, 4, 2, 1 };
int N = arr.Length;
Console.Write(numberOfSubarrays(arr, N));
}
}
// This code is contributed by shikhasingrajput
<script>
// JavaScript Program to implement
// the above approach
// Function to find minimum number of
// subarrays such that rearranging the
// subarrays sort the array
function numberOfSubarrays(arr, n) {
// Stores the minimum number of
// subarrays
let cnt = 1;
// Stores all the elements in the
// array with their indices
let v = [];
// Copy array elements in vector
for (let i = 0; i < n; i++) {
v.push({ first: arr[i], second: i })
}
// Sort the vector v
v.sort(function (a, b) { return a.first - b.first })
// Iterate through vector v
for (let i = 1; i < n; i++) {
// If the (i)th and (i-1)th element
// can be grouped in same subarray
if (v[i].second == v[i - 1].second + 1) {
continue;
}
else {
cnt++;
}
}
// Return resultant count
return cnt;
}
// Driver Code
let arr = [6, 3, 4, 2, 1];
let N = arr.length;
document.write(numberOfSubarrays(arr, N));
// This code is contributed by Potta Lokesh
</script>
Time Complexity: O(N*log N)
Auxiliary Space: O(N)
Explore
DSA Fundamentals
Data Structures
Algorithms
Advanced
Interview Preparation
Practice Problem