题目
给定一个由 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
}
