Partition Array into Disjoint Intervals LT915

Given an array A, partition it into two (contiguous) subarrays left and right so that:

• Every element in left is less than or equal to every element in right.
• left and right are non-empty.
• left has the smallest possible size.

Return the length of left after such a partitioning.  It is guaranteed that such a partitioning exists.

Example 1:

Input: [5,0,3,8,6]
Output: 3
Explanation: left = [5,0,3], right = [8,6]

Example 2:

Input: [1,1,1,0,6,12]
Output: 4
Explanation: left = [1,1,1,0], right = [6,12]

 

Note:

1. 2 <= A.length <= 30000
2. 0 <= A[i] <= 10^6
3. It is guaranteed there is at least one way to partition A as described.

 Idea 1. max(nums[0]... nums[i]) <= min(nums[i+1],..nums[n-1]), build maxArray from left, minArray from right

Time comlexity: T(n)

Space complexity: T(n)

using index:

class Solution {
    public int partitionDisjoint(int[] A) {
       int[] maxIndex = new int[A.length];
        for(int i = 1; i < A.length; ++i) {
            if(A[i] > A[maxIndex[i-1]]) {
                maxIndex[i] = i;
            }
            else {
                maxIndex[i] = maxIndex[i-1];
            }
        }
        
        int[] minIndex = new int[A.length];
        minIndex[A.length-1] = A.length-1;
        for(int i = A.length-2; i >= 0; --i) {
            if(A[i] < A[minIndex[i+1]]) {
                minIndex[i] = i;
            }
            else {
                minIndex[i] = minIndex[i+1];
            }
        }
        
        for(int i = 0; i < A.length-1; ++i) {
            if(A[maxIndex[i]] <= A[minIndex[i+1]]) {
                return i + 1;
            }
        }
        
        return 0;
    }
}

No need to use index

class Solution {
     public int partitionDisjoint(int[] A) {
        int[] maxFromLeft = new int[A.length];
         maxFromLeft[0] = A[0];
         for(int i = 1; i < A.length; ++i) {
             maxFromLeft[i] = Math.max(maxFromLeft[i-1], A[i]);
         }
         
         int[] minFromRight = new int[A.length];
         minFromRight[A.length-1] = A[A.length-1];
         for(int i = A.length-2; i >= 0; --i) {
             minFromRight[i] = Math.min(minFromRight[i+1], A[i]);
         }
         
         for(int i = 0; i < A.length-1; ++i) {
             if(maxFromLeft[i] <= minFromRight[i+1]) {
                 return i + 1;
             }
         }
         
         return 0;
     }
 }

Idea 2. 从讨论里看到的妙解，只需要保持2个变量，localMax记录有效partition里的最大值, maxSoFar记录遍历至今的最大值，nums[0]...nums[paritionIndex] (localMax) | [nums[partitonIndex]...nums[i-1]| (maxSoFar),  遍历到一个数nums[i], 

paritionIndex 不变 if nums[i] >= localMax

paritionIndex = i, 需要包括nums[i], localMax也需要更新至maxSoFar

Time complexity: O(n)

Space complexity: O(1)

class Solution {
    public int partitionDisjoint(int[] A) {
       int localMax = A[0];
       int maxSoFar = A[0];
       int partitionIndex = 0;
       for(int i = 1; i < A.length; ++i) {
           if(A[i] < localMax) {
               partitionIndex = i;
               localMax = maxSoFar;
           }
           maxSoFar = Math.max(maxSoFar, A[i]);
       }
        
        return partitionIndex + 1;
    }
}