将数组分成两个子数组，右子数组中的每个元素都严格大于左子数组中的每个元素

给定一个数组arr[]组成 对于N 个整数，任务是将数组划分为两个非空子数组，使得右子数组中的每个元素都严格大于左子数组中的每个元素。如果可以这样做，则打印两个结果子数组。否则，打印“不可能”。

例子：

Input: arr[] = {5, 3, 2, 7, 9}
Output:
5 3 2 
7 9
Explanation:
One of the possible partition is {5, 3, 2} and {7, 9}.
The minimum of 2^nd subarray {7} is greater than the maximum of the first subarray (5).

Input: arr[] = {1,1,1,1,1}
Output: Impossible
Explanation: 
There is no partition possible for this array.

朴素的方法：最简单的方法是遍历数组，对于每个索引，检查第一个子数组的最大值是否小于第二个子数组的最小值。如果发现为真，则打印两个子数组。
时间复杂度： O(N ² )
辅助空间：O(N)

高效的方法：上述方法可以通过计算前缀最大数组和后缀最小数组来优化，这导致第一个子数组的最大值和^第二个子数组的最小值的恒定时间计算。请按照以下步骤解决问题：

• 初始化一个数组，比如min[]，以存储最小后缀数组。
• 初始化 3 个变量，比如ind 、 mini和maxi ，分别存储分区索引、后缀最小值和前缀最大值。
• 反向遍历数组并将mini更新为mini = min (mini, arr[i]) 。将mini分配给min[i]。
• 现在，遍历数组arr[]并执行以下操作：
  • 更新MAXI为MAXI = MAX(MAXI，ARR [I])。
  • 如果i+1 < N以及maxi < min[i+1] ，则打印在索引i处创建的分区并中断。
• 完成上述步骤后，如果以上情况都不满足，则打印“ Impossible”。

下面是上述方法的实现：

C++

// C++ program of the above approach
#include 
using namespace std;
 
// Function to partition the array
// into two non-empty subarrays
// which satisfies the given condition
void partitionArray(int *a, int n)
{
 
  // Stores the suffix Min array
  int *Min = new int[n];
 
  // Stores the Minimum of a suffix
  int Mini = INT_MAX;
 
  // Traverse the array in reverse
  for (int i = n - 1; i >= 0; i--) {
 
    // Update Minimum
    Mini = min(Mini, a[i]);
 
    // Store the Minimum
    Min[i] = Mini;
  }
 
  // Stores the Maximum value of a prefix
  int Maxi = INT_MIN;
 
  // Stores the index of the partition
  int ind = -1;
 
  for (int i = 0; i < n - 1; i++) {
 
    // Update Max
    Maxi = max(Maxi, a[i]);
 
    // If Max is less than Min[i+1]
    if (Maxi < Min[i + 1]) {
 
      // Store the index
      // of partition
      ind = i;
 
      // break
      break;
    }
  }
 
  // If ind is not -1
  if (ind != -1) {
 
    // Print the first subarray
    for (int i = 0; i <= ind; i++)
      cout << a[i] << " ";
 
    cout << endl;
 
    // Print the second subarray
    for (int i = ind + 1; i < n; i++)
      cout << a[i] << " ";
  }
 
  // Otherwise
  else
    cout << "Impossible";
}
 
// Driver Code
int main()
{
  int arr[] = { 5, 3, 2, 7, 9 };
  int N = 5;
  partitionArray(arr, N);
  return 0;
}
 
// This code is contributed by Shubhamsingh10

Java

// Java program of the above approach
 
import java.util.*;
 
class GFG {
 
    // Function to partition the array
    // into two non-empty subarrays
    // which satisfies the given condition
    static void partitionArray(int a[], int n)
    {
        // Stores the suffix min array
        int min[] = new int[n];
 
        // Stores the minimum of a suffix
        int mini = Integer.MAX_VALUE;
 
        // Traverse the array in reverse
        for (int i = n - 1; i >= 0; i--) {
 
            // Update minimum
            mini = Math.min(mini, a[i]);
 
            // Store the minimum
            min[i] = mini;
        }
 
        // Stores the maximum value of a prefix
        int maxi = Integer.MIN_VALUE;
 
        // Stores the index of the partition
        int ind = -1;
 
        for (int i = 0; i < n - 1; i++) {
 
            // Update max
            maxi = Math.max(maxi, a[i]);
 
            // If max is less than min[i+1]
            if (maxi < min[i + 1]) {
 
                // Store the index
                // of partition
                ind = i;
 
                // break
                break;
            }
        }
 
        // If ind is not -1
        if (ind != -1) {
 
            // Print the first subarray
            for (int i = 0; i <= ind; i++)
                System.out.print(a[i] + " ");
 
            System.out.println();
 
            // Print the second subarray
            for (int i = ind + 1; i < n; i++)
                System.out.print(a[i] + " ");
        }
 
        // Otherwise
        else
            System.out.println("Impossible");
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = { 5, 3, 2, 7, 9 };
        int N = arr.length;
        partitionArray(arr, N);
    }
}

Python3

# Python3 program for the above approach
import sys
 
# Function to partition the array
# into two non-empty subarrays
# which satisfies the given condition
def partitionArray(a, n) :
 
  # Stores the suffix Min array
  Min = [0] * n
 
  # Stores the Minimum of a suffix
  Mini = sys.maxsize
 
  # Traverse the array in reverse
  for i in range(n - 1, -1, -1):
 
    # Update Minimum
    Mini = min(Mini, a[i])
 
    # Store the Minimum
    Min[i] = Mini
   
  # Stores the Maximum value of a prefix
  Maxi = -sys.maxsize - 1
 
  # Stores the index of the partition
  ind = -1
  for i in range(n - 1):
 
    # Update Max
    Maxi = max(Maxi, a[i])
 
    # If Max is less than Min[i+1]
    if (Maxi < Min[i + 1]) :
 
      # Store the index
      # of partition
      ind = i
 
      # break
      break
     
  # If ind is not -1
  if (ind != -1) :
 
    # Print first subarray
    for i in range(ind + 1):
      print(a[i], end = " ")
    print()
 
    # Print second subarray
    for i in range(ind + 1 , n , 1):
      print(a[i], end = " ")
   
  # Otherwise
  else :
    print("Impossible")
 
# Driver Code
arr = [ 5, 3, 2, 7, 9 ]
N = 5
partitionArray(arr, N)
 
# This code is contributed by sanjoy_62.

C#

// C# program of the above approach
using System;
 
class GFG {
 
  // Function to partition the array
  // into two non-empty subarrays
  // which satisfies the given condition
  static void partitionArray(int[] a, int n)
  {
    // Stores the suffix min array
    int[] min = new int[n];
 
    // Stores the minimum of a suffix
    int mini = Int32.MaxValue;
 
    // Traverse the array in reverse
    for (int i = n - 1; i >= 0; i--) {
 
      // Update minimum
      mini = Math.Min(mini, a[i]);
 
      // Store the minimum
      min[i] = mini;
    }
 
    // Stores the maximum value of a prefix
    int maxi = Int32.MinValue;
 
    // Stores the index of the partition
    int ind = -1;
 
    for (int i = 0; i < n - 1; i++) {
 
      // Update max
      maxi = Math.Max(maxi, a[i]);
 
      // If max is less than min[i+1]
      if (maxi < min[i + 1]) {
 
        // Store the index
        // of partition
        ind = i;
 
        // break
        break;
      }
    }
 
    // If ind is not -1
    if (ind != -1) {
 
      // Print the first subarray
      for (int i = 0; i <= ind; i++)
        Console.Write(a[i] + " ");
 
      Console.WriteLine();
 
      // Print the second subarray
      for (int i = ind + 1; i < n; i++)
        Console.Write(a[i] + " ");
    }
 
    // Otherwise
    else
      Console.Write("Impossible");
  }
 
  // Driver Code
  public static void Main(string[] args)
  {
    int[] arr = { 5, 3, 2, 7, 9 };
    int N = arr.Length;
    partitionArray(arr, N);
  }
}
 
// This code is contributed by ukasp.

Javascript

 
// javascript program of the above approach   
 
// Function to partition the array
// into two non-empty subarrays
// which satisfies the given condition
    function partitionArray(a , n)
    {
        // Stores the suffix min array
        var min = Array(n).fill(0);
 
        // Stores the minimum of a suffix
        var mini = Number.MAX_VALUE;
 
        // Traverse the array in reverse
        for (i = n - 1; i >= 0; i--) {
 
            // Update minimum
            mini = Math.min(mini, a[i]);
 
            // Store the minimum
            min[i] = mini;
        }
 
        // Stores the maximum value of a prefix
        var maxi = Number.MIN_VALUE;
 
        // Stores the index of the partition
        var ind = -1;
 
        for (i = 0; i < n - 1; i++) {
 
            // Update max
            maxi = Math.max(maxi, a[i]);
 
            // If max is less than min[i+1]
            if (maxi < min[i + 1]) {
 
                // Store the index
                // of partition
                ind = i;
 
                // break
                break;
            }
        }
 
        // If ind is not -1
        if (ind != -1) {
 
            // Prvar the first subarray
            for (i = 0; i <= ind; i++)
                document.write(a[i] + " ");
 
            document.write("<br/>");
 
            // Prvar the second subarray
            for (i = ind + 1; i < n; i++)
                document.write(a[i] + " ");
        }
 
        // Otherwise
        else
            document.write("Impossible");
    }
 
    // Driver Code
     
        var arr = [ 5, 3, 2, 7, 9 ];
        var N = arr.length;
        partitionArray(arr, N);
 
// This code contributed by Rajput-Ji
 

输出：

5 3 2 
7 9

时间复杂度： O(N)
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live