Open in App
Not now

# Maximize partitions that if sorted individually makes the whole Array sorted

• Difficulty Level : Medium
• Last Updated : 27 Jul, 2022

Given an array arr[]. The task is to divide arr[] into the maximum number of partitions, such that, those partitions if sorted individually make the whole array sorted.

Examples:

Input: arr[] = { 28, 9, 18, 32, 60, 50, 75, 70 }
Output: 4
Explanation: Following are the partitions in which the array is divided.
If we divide arr[] into four partitions {28, 9, 18}, {32}, { 60, 50}, and {75, 70}, sort them and concatenate.
Sorting all of them indivudually makes the whole array sorted.

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

Approach: This problem is implementation-based. Follow the steps below to solve the given problem.

• Create a maximum array that calculates the maximum element to the left till that index of the array.
• Create a minimum array that calculates the minimum element to the right till that index of the array.
• Iterate through the array, each time all elements to the leftMax[] are smaller (or equal) to all elements to the rightMax[], that means there is a new chunk, so increment the count by 1.
• Return count+1 as the final answer.

Below is the implementation of the above approach.

## C++

 `// C++ program for above approach` `#include ` `using` `namespace` `std;`   `// Function to find maximum partitions.` `int` `maxPartitions(vector<``int``>& arr)` `{` `    ``int` `N = arr.size();`   `    ``// To keep track of max` `    ``// and min elements at every index` `    ``vector<``int``> leftMax(arr.size());` `    ``vector<``int``> rightMin(arr.size());`   `    ``leftMax[0] = arr[0];`   `    ``for` `(``int` `i = 1; i < N; i++) {` `        ``leftMax[i] = max(leftMax[i - 1],` `                         ``arr[i]);` `    ``}`   `    ``rightMin[N - 1] = arr[N - 1];`   `    ``for` `(``int` `i = N - 2; i >= 0; i--) {` `        ``rightMin[i] = min(rightMin[i + 1],` `                          ``arr[i]);` `    ``}`   `    ``int` `count = 0;`   `    ``for` `(``int` `i = 0; i < N - 1; i++) {` `        ``if` `(leftMax[i] <= rightMin[i + 1]) {` `            ``count++;` `        ``}` `    ``}`   `    ``// Return count + 1 as the final answer` `    ``return` `count + 1;` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> arr{ 10, 0, 21, 32, 68 };`   `    ``cout << maxPartitions(arr);` `    ``return` `0;` `}`

## Java

 `// Java implementation of the above approach` `import` `java.util.*;` `public` `class` `GFG {`   `  ``// Function to find maximum partitions.` `  ``static` `int` `maxPartitions(``int``[] arr)` `  ``{` `    ``int` `N = arr.length;`   `    ``// To keep track of max` `    ``// and min elements at every index` `    ``int``[] leftMax = ``new` `int``[arr.length];` `    ``int``[] rightMin = ``new` `int``[arr.length];`   `    ``leftMax[``0``] = arr[``0``];`   `    ``for` `(``int` `i = ``1``; i < N; i++) {` `      ``leftMax[i] = Math.max(leftMax[i - ``1``], arr[i]);` `    ``}`   `    ``rightMin[N - ``1``] = arr[N - ``1``];`   `    ``for` `(``int` `i = N - ``2``; i >= ``0``; i--) {` `      ``rightMin[i] = Math.min(rightMin[i + ``1``], arr[i]);` `    ``}`   `    ``int` `count = ``0``;`   `    ``for` `(``int` `i = ``0``; i < N - ``1``; i++) {` `      ``if` `(leftMax[i] <= rightMin[i + ``1``]) {` `        ``count++;` `      ``}` `    ``}`   `    ``// Return count + 1 as the final answer` `    ``return` `count + ``1``;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String args[])` `  ``{` `    ``int``[] arr = { ``10``, ``0``, ``21``, ``32``, ``68` `};`   `    ``System.out.println(maxPartitions(arr));` `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Python

 `# Python program for above approach`   `# Function to find maximum partitions.` `def` `maxPartitions(arr):` `    ``N ``=` `len``(arr)`   `    ``# To keep track of max` `    ``# and min elements at every index` `    ``leftMax ``=` `[]` `    ``rightMin ``=` `[]`   `    ``leftMax.append(arr[``0``])`   `    ``for` `i ``in` `range``(``1``, N):` `        ``leftMax.append(``max``(leftMax[i ``-` `1``], arr[i]))`   `    ``rightMin.append(arr[N ``-` `1``])`   `    ``for` `i ``in` `range``(``1``, N):` `        ``rightMin.append(``min``(rightMin[i ``-` `1``], arr[N ``-` `i ``-` `1``]))` `    ``rightMin.reverse()` `    ``count ``=` `0`   `    ``for` `i ``in` `range``(``0``, N ``-` `1``):` `        ``if` `(leftMax[i] <``=` `rightMin[i ``+` `1``]):` `            ``count ``=` `count ``+` `1`   `    ``# Return count + 1 as the final answer` `    ``return` `count ``+` `1`   `# Driver code` `arr ``=` `[``10``, ``0``, ``21``, ``32``, ``68``]` `print``(maxPartitions(arr))`   `# This code is contributed by Samim Hossain Mondal.`

## C#

 `// C# program for above approach` `using` `System;` `class` `GFG {`   `  ``// Function to find maximum partitions.` `  ``static` `int` `maxPartitions(``int``[] arr)` `  ``{` `    ``int` `N = arr.Length;`   `    ``// To keep track of max` `    ``// and min elements at every index` `    ``int``[] leftMax = ``new` `int``[arr.Length];` `    ``int``[] rightMin = ``new` `int``[arr.Length];`   `    ``leftMax[0] = arr[0];`   `    ``for` `(``int` `i = 1; i < N; i++) {` `      ``leftMax[i] = Math.Max(leftMax[i - 1], arr[i]);` `    ``}`   `    ``rightMin[N - 1] = arr[N - 1];`   `    ``for` `(``int` `i = N - 2; i >= 0; i--) {` `      ``rightMin[i] = Math.Min(rightMin[i + 1], arr[i]);` `    ``}`   `    ``int` `count = 0;`   `    ``for` `(``int` `i = 0; i < N - 1; i++) {` `      ``if` `(leftMax[i] <= rightMin[i + 1]) {` `        ``count++;` `      ``}` `    ``}`   `    ``// Return count + 1 as the final answer` `    ``return` `count + 1;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int``[] arr = { 10, 0, 21, 32, 68 };`   `    ``Console.WriteLine(maxPartitions(arr));` `  ``}` `}`   `// This code is contributed by ukasp.`

## Javascript

 ``

Output

`4`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Related Articles