题目

给定一个由 0 和 1 组成的数组 A，将数组分成 3 个非空的部分，使得所有这些部分表示相同的二进制值。

如果可以做到，请返回任何 [i, j]，其中 i+1 < j，这样一来：

A[0], A[1], ..., A[i] 组成第一部分；
A[i+1], A[i+2], ..., A[j-1] 作为第二部分；
A[j], A[j+1], ..., A[A.length - 1] 是第三部分。
这三个部分所表示的二进制值相等。
如果无法做到，就返回 [-1, -1]。

注意，在考虑每个部分所表示的二进制时，应当将其看作一个整体。例如，[1,1,0] 表示十进制中的 6，而不会是 3。此外，前导零也是被允许的，所以 [0,1,1] 和 [1,1] 表示相同的值。

示例 1：
输入：[1,0,1,0,1]
输出：[0,3]
示例 2：
输出：[1,1,0,1,1]
输出：[-1,-1]

提示：

3 <= A.length <= 30000
A[i] == 0 或 A[i] == 1

思路

有几个不太容易一眼就发现的小tips

• 分为三等份的相同值，其 ‘1’ 的个数应该是相同的，也就是说，在给定的数组中，’1‘ 的个数应该可以 % 3 == 0，否则无法分为三等份。可以分为三等份的每一份中’1‘的个数应该是数组中’1‘的个数除三。
• 知道‘1’的个数以后，我们可以确定下来每一份的值，该值是唯一的，可以通过最后一份来求出：从后往前遍历数组，直到‘1’的个数等于数组中‘1’的个数除三，该二进制数就是每一份的值。（该过程可以保留后缀的‘0’的数量以备后面用到）
• 确定值后，可以从前向后遍历数组，同样通过‘1’的个数找数，‘1’的个数找齐后，加上刚才求出后缀0，如果后面的0的数量没有求出的后缀0多，则无法分割。若有，求这个二进制数的值，等于之前求出的值，则这个位置就是i 的值，若不像等，则无法分割。重复该步骤可以得到j 的值。

该方法的时间复杂度为O(n)，如果大家有更优秀的解决办法，或者可以优化的地方，欢迎留言。

code

func threeEqualParts(A []int) []int {
    var lA = len(A) -1
    result := make([]int,0,2)
    ones := 0
    for _, a := range A {
        if a == 1 {
            ones++
        }
    }
    if ones % 3 != 0{
        result = append(result, -1, -1)
        return result
    }
    
    partOnes := ones / 3
    if partOnes == 0 {
        result = append(result, 0, 4)
        return result
    }
    tPartOnes := partOnes
    suffixZero := 0
    flag := false
    realValue := 0
    var tmpI, tmpJ int
    
    for i:=lA;i>0;i-- {
        // 确定真值 suffixZero
        if !flag && A[i] == 0{
            suffixZero++
        }
        if A[i] == 1 {
            flag = true
            tPartOnes--
            if tPartOnes == 0{
                realValue = cal(A[i:])
                tmpJ = i
                break
            }
        }   
    }
    
    
    tmpI,ok := find(A[:tmpJ], partOnes, realValue, suffixZero)
    if ! ok {
        result = append(result, -1, -1)
        return result
    }
    tmpJ, ok = find(A[tmpI+1:tmpJ], partOnes, realValue, suffixZero)
    if ! ok {
        result = append(result, -1, -1)
        return result
    }
    tmpJ = tmpI+tmpJ+2
    
    result = append(result, tmpI, tmpJ)
    return result
    
}

// 用来找 1、2 部分，从前找，找到就返回当前位置
func find(A []int, partOnes, realValue, suffixZero int) (i int, b bool) {
    l := len(A) -1
    tmpI:=0
    for i, a := range A {
        if a == 1 {
            partOnes--
            if partOnes==0{
                for j:=suffixZero;j>0;j--{
                    if i+j > l {
                        return 0, false
                    }
                    if A[i+j] != 0{
                        return 0, false
                    }
                }
                tmpI = i+suffixZero
                break
            }
        }
    }
    
    if cal(A[:tmpI+1]) != realValue {
        return 0, false
    }
    return tmpI, true
}

func cal(A []int) int {
    l := len(A)
    result := 0
    for i, a := range A {
        result += a * ((l-i) * (l-i))
    }
    return result
}