题目

给定一个数组 A，将其划分为两个不相交（没有公共元素）的连续子数组 left 和 right， 使得：

left 中的每个元素都小于或等于 right 中的每个元素。
left 和 right 都是非空的。
left 要尽可能小。
在完成这样的分组后返回 left 的长度。可以保证存在这样的划分方法。

示例 1：

输入：[5,0,3,8,6]
输出：3
解释：left = [5,0,3]，right = [8,6]

示例 2：

输入：[1,1,1,0,6,12]
输出：4
解释：left = [1,1,1,0]，right = [6,12]

思路&代码

1. 第一次很简单的设想拿左面数组部分的最大值和右面数组部分的最小值比较，如果最大值小于或等于最小值，那么就可以输出下标+1作为位置。
   时间复杂度是包含一次循环和一次max或min调用，为O(n^2)，很自然地超时了

class Solution:
    def partitionDisjoint(self, A: List[int]) -> int:
        max_A=A[0]
        for i in range(len(A)):
            if (max_A < A[i]):
                max_A = A[i]
            if(max_A<=min(A[i+1::])):
                return i+1

2. 优化一下，仔细想想，会发现其实如果遍历数组的时候，分为两个状态其实就可以把复杂度变为O(n)了，即遍历一遍就可以得到结果。

• record左面的数为左数组，右面的为右数组，record作为分界线
• 初始化：把最左边的数作为候选数和最大值数，状态设为1，随时记录左边已经遍历的数的最大值max_left。
• 状态1：在状态1的情况下，当向后遍历时，A[i]都小于候选数，那么就继续向后遍历，保持状态1，flag=0，同时record下标向后移到i+1，记录可以切分的点
• 状态2：在状态1的情况下，当向后遍历时，A[i]大于了候选数，此时问题不大，因为如果后面的数依然都大于候选数，那么是可以保持record不变而直接输出的，此时只需要将状态由1跳转到2，flag=1，record保持不变
• 状态3：在状态2的情况下，当向后遍历时，A[i]又小于了候选数，此时会出现右面的数比左面record之前的数组部分要小的情况，所以要更新record为i+1，将i+1之前的所有数重新并入左面数组，返回状态1，将候选数更新为左面最大数max_left
• 遍历一遍完成后，输出record就可以了，时间复杂度为O(n)，顺利通过

class Solution:
    def partitionDisjoint(self, A: List[int]) -> int:
        candidate=A[0] # 候选数
        max_left=A[0] # 左面已经遍历过的最大值
        record=0 # 记录下左面全部小于候选数的最后的位置
        flag=0 # 标志位，用于检测是否遇到大于候选数之后又遇到小于候选数的情况
        for i in range(len(A)):
            if(flag==0):
                if(candidate>A[i]):
                    record=i
                if (candidate < A[i]):
                    flag=1
                if(max_left<=A[i]):
                    max_left=A[i]
            else:
                # 遇到大于候选数之后又遇到小于候选数的情况
                if (max_left <= A[i]):
                    max_left = A[i]

                if (candidate <= A[i]):
                    pass
                else:
                    candidate=max_left
                    flag=0
                    record=i
        return record+1