Partition an array such into maximum increasing segments

We are given an array of N integers, we need to partition the array into segments such that every element of a segment is greater than every element of previous segment. In other words, if we sort these individual segments, the whole array becomes sorted. We need to find a valid partition with maximum number of subarrays.

Examples:

arr[] = {3 1 2 4 100 7 9}
Output : 3
You should partition the array into the following subarrays: (3, 1, 2), (4) and (100, 7, 9).

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



Approach A greedy approach works really well as it leads to the following algorithm. Find the shortest prefix such that all the elements in the prefix are less than or equal to the elements in the rest of the array.

Consider this prefix as the first subarray of the partition. Recursively call the same algorithm on the rest of the array. Implementation wise, we can preprocess an array of max values for each prefix and another array of min values for each suffix. This way we can easily perform a check to see if a given prefix is a viable candidate for a partition subarray.

Below is the implementation of above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to divide into maximum number of segments
  
#include <iostream>
using namespace std;
  
    // Returns the maximum number of sorted subarrays 
    // in a valid partition
    int sorted_partitions(int arr[],int n)
    {
          
        int right_min[n + 1];
        right_min[n] = INT8_MAX;
        for (int i = n - 1; i >= 0; i--) {
            right_min[i] = min(right_min[i + 1], arr[i]);
        }
  
        // Finding the shortest prefix such that all the elements
        // in the prefix are less than or equal to the elements
        // in the rest of the array. 
        int partitions = 0;
        for (int current_max = arr[0], i = 0; i < n; i++) {
            current_max = max(current_max, arr[i]);
            
            // if current max is less than the right prefix min,
            // we increase number of partitions.
            if (current_max <= right_min[i + 1])
                partitions++;
        }
  
        return partitions;
    }
  
    // Driver code
    int main()
    {
        int arr[] = { 3, 1, 2, 4, 100, 7, 9 };
        // Find minimum value from right for every index
        int n = sizeof(arr)/sizeof(arr[0]);
          
        int ans = sorted_partitions(arr,n);
        cout << ans << endl;
        return 0;
          
    // This code is contributed by ANKITRAI1
    }

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to divide into maximum number of segments
import java.util.Arrays; 
  
class GFG {
  
    // Returns the maximum number of sorted subarrays 
    // in a valid partition
    static int sorted_partitions(int arr[])
    {
        // Find minimum value from right for every index
        int n = arr.length;
        int[] right_min = new int[n + 1];
        right_min[n] = Integer.MAX_VALUE;
        for (int i = n - 1; i >= 0; i--) {
            right_min[i] = Math.min(right_min[i + 1], arr[i]);
        }
  
        // Finding the shortest prefix such that all the elements
        // in the prefix are less than or equal to the elements
        // in the rest of the array. 
        int partitions = 0;
        for (int current_max = arr[0], i = 0; i < n; i++) {
            current_max = Math.max(current_max, arr[i]);
            
            // if current max is less than the right prefix min,
            // we increase number of partitions.
            if (current_max <= right_min[i + 1])
                partitions++;
        }
  
        return partitions;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int[] arr = new int[] { 3, 1, 2, 4, 100, 7, 9 };
        int ans = sorted_partitions(arr);
        System.out.println(ans);
    }
}

chevron_right


Python 3

# Python 3 program to divide into
# maximum number of segments
import sys

# Returns the maximum number of sorted
# subarrays in a valid partition
def sorted_partitions( arr, n):

right_min = [0] * (n + 1)
right_min[n] = sys.maxsize
for i in range(n – 1, -1, -1):
right_min[i] = min(right_min[i + 1], arr[i])

# Finding the shortest prefix such that
# all the elements in the prefix are less
# than or equal to the elements in the
# rest of the array.
partitions = 0
current_max = arr[0]
for i in range(n):
current_max = max(current_max, arr[i])

# if current max is less than the right
# prefix min, we increase number of partitions.
if (current_max <= right_min[i + 1]): partitions += 1 return partitions # Driver code arr = [ 3, 1, 2, 4, 100, 7, 9 ] # Find minimum value from right # for every index n = len(arr) ans = sorted_partitions(arr, n) print(ans) # This code is contributed by ita_c [tabby title="C#"]

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to divide into maximum number of segments
using System;
  
class GFG {
  
    // Returns the maximum number of sorted subarrays 
    // in a valid partition
    static int sorted_partitions(int []arr)
    {
        // Find minimum value from right for every index
        int n = arr.Length;
        int[] right_min = new int[n + 1];
        right_min[n] =  int.MaxValue;
        for (int i = n - 1; i >= 0; i--) {
            right_min[i] = Math.Min(right_min[i + 1], arr[i]);
        }
  
        // Finding the shortest prefix such that all the elements
        // in the prefix are less than or equal to the elements
        // in the rest of the array. 
        int partitions = 0;
        for (int current_max = arr[0], i = 0; i < n; i++) {
            current_max = Math.Max(current_max, arr[i]);
          
            // if current max is less than the right prefix min,
            // we increase number of partitions.
            if (current_max <= right_min[i + 1])
                partitions++;
        }
  
        return partitions;
    }
  
    // Driver code
    public static void Main()
    {
        int[] arr = { 3, 1, 2, 4, 100, 7, 9 };
        int ans = sorted_partitions(arr);
        Console.WriteLine(ans);
    }
}
// This code is contributed by anuj_67..

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to divide into maximum 
// number of segments 
  
// Returns the maximum number of 
// sorted subarrays in a valid partition 
function sorted_partitions($arr, $n
      
    $right_min[$n + 1] = array(); 
    $right_min[$n] = PHP_INT_MAX; 
    for ( $i = $n - 1; $i >= 0; $i--)
    
        $right_min[$i] = min($right_min[$i + 1],
                                        $arr[$i]); 
    
  
    // Finding the shortest prefix such 
    // that all the elements in the prefix 
    // are less than or equal to the elements 
    // in the rest of the array. 
    $partitions = 0; 
    for ($current_max = $arr[0],
                        $i = 0; $i < $n; $i++)
    
        $current_max = max($current_max, $arr[$i]); 
          
        // if current max is less than the 
        // right prefix min, we increase 
        // number of partitions. 
        if ($current_max <= $right_min[$i + 1]) 
            $partitions++; 
    
  
    return $partitions
  
// Driver code 
$arr = array( 3, 1, 2, 4, 100, 7, 9 ); 
  
// Find minimum value from 
// right for every index 
$n = sizeof($arr); 
  
$ans = sorted_partitions($arr, $n); 
echo $ans, "\n"
  
// This code is contributed by ajit 
?>

chevron_right


Output:

3


My Personal Notes arrow_drop_up

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.



Improved By : vt_m, Ryuga, jit_t, Ita_c



Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.