A matriz é dividido em três porções iguais e

/ * Dê-lhe um array de inteiros A, apenas três podem retornar verdadeiro e divididos igualmente em parte não-vazia única, caso contrário false. 
Formalmente, se podemos encontrar o índice i + 1 <j satisfazendo (A [0] + A [ 1] + ... + A [i] == A [i + 1] + A [i + 2] + ... + A [j-1] == A [j] + A [j-1] + ... + A [a.length - 1]) pode ser uma matriz de três alíquotas. 
Link: https: //leetcode-cn.com/problems/partition-array-into-three-parts-with-equal-sum 
saída: [0,2,1, 6,6, -7,9,1, 2,0,1] 
saída: verdadeiro 
interpretação: 2 + 0 + 1 = -6 + 6--7 = 2 + 9 + 1 + 1 + 0 * / 
// violência primeira solução, a eficácia é baixa 
booleano public static canThreePartsEqualSum (int [] a) { 
     booleana = Resultado de falsa; 
     int SUM = 0; 
    para (int i = 0; I <a.length-2; i ++) { 
        SUM = a + [I]; 
        int SUM2 = 0; 
        para (int. J = 1 I +; J <-A.length 1;. J ++) { 
            SUM2 = A + [J];
            IF (SUM == SUM2) { 
                int SUM3 = 0; 
                para (int 1 + K = J;. K <a.length; K ++) { 
                    SUM3 = A + [K]; 
                } 
                IF (SUM3 == SUM2) { 
                    Resultado = a verdade; 
                    break; 
                } 
            } 
        } 
        IF (Result) break; 
    } 

    resultado de retorno; 
} 
// segundo, a solução de referência LeetCode irmão mais velho. (Como eu penso nisso)

public static booleana canThreePartsEqualSum2 (int [] A) { 
    int SUM = 0; 
    para (int S: A) { 
        ; SUM = S + 
    } 
    (!. 3% SUM = 0) IF {// matriz pode ser dividido em três porções iguais e , então o divisível número total por 3 pode 
        voltar a falsa; 
    } 
    int = SOMA alvo / 3; // interpretar cada parte é suposto ser 
    SUM = 0; 
    int Tag = 0; 
    para (int S: a) {// cada parte é determinada e é sempre de um terço, e a + 1 Tag. 
        SUM = S +; 
        IF (SUM == alvo) { 
            SUM = 0; 
            Tag ++; 
        } 
    } 
    Tag retorno> = 3; // imediatamente dividido em três igual a 3. porção Tag , etiqueta superior a 3, e um número total das três porções iguais, e o resto deve ser de 0 
}