[LeetCode] 1013. Partition Array Into Three Parts With Equal Sum

Given an array A of integers, return true if and only if we can partition the array into three non-empty parts with equal sums.

Formally, we can partition the array if we can find indexes i+1 < j with (A[0] + A[1] + ... + A[i] == A[i+1] + A[i+2] + ... + A[j-1] == A[j] + A[j-1] + ... + A[A.length - 1])

Example 1:

Input: A = [0,2,1,-6,6,-7,9,1,2,0,1]
Output: true
Explanation: 0 + 2 + 1 = -6 + 6 - 7 + 9 + 1 = 2 + 0 + 1

Example 2:

Input: A = [0,2,1,-6,6,7,9,-1,2,0,1]
Output: false

Example 3:

Input: A = [3,3,6,5,-2,2,5,1,-9,4]
Output: true
Explanation: 3 + 3 = 6 = 5 - 2 + 2 + 5 + 1 - 9 + 4

Constraints:

• 3 <= A.length <= 50000
• -10^4 <= A[i] <= 10^4

将数组分成和相等的三个部分。题意是给你一个整数数组A，只有可以将其划分为三个和相等的非空部分时才返回true，否则返回false。

思路是two pointer。首先判断corner case，如果整个数组中所有元素的加和sum不能被3整除，则一定是false。然后双指针从两边逼近，看左边的leftSum和右边的rightSum是否能都得到1/3的sum。注意双指针while循环的退出条件是（left + 1 < right），如果写成（left < right）会报错，比如如下的case。

Input

[1,-1,1,-1]

Output

true

Expected

false

时间O(n)

空间O(n) - 用了两个数组存放leftSum和rightSum

Java实现

class Solution {
    public boolean canThreePartsEqualSum(int[] A) {
        int sum = 0;
        for (int i : A) {
            sum += i;
        }
        // corner case
        if (sum % 3 != 0) {
            // 总和不是3的倍数，直接返回false
            return false;
        }

        // 使用双指针,从数组两头开始一起找，节约时间
        int left = 0;
        int leftSum = A[left];
        int right = A.length - 1;
        int rightSum = A[right];

        // 使用left + 1 < right 的原因，防止只能将数组分成两个部分
        // 例如：[1,-1,1,-1]，使用left < right作为判断条件就会出错
        while (left + 1 < right) {
            if (leftSum == sum / 3 && rightSum == sum / 3) {
                // 左右两边都等于 sum/3 ，中间也一定等于
                return true;
            }
            if (leftSum != sum / 3) {
                // left = 0赋予了初值，应该先left++，在leftSum += A[left];
                leftSum += A[++left];
            }
            if (rightSum != sum / 3) {
                // right = A.length - 1 赋予了初值，应该先right--，在rightSum += A[right];
                rightSum += A[--right];
            }
        }
        return false;
    }
}

JavaScript实现

/**
 * @param {number[]} A
 * @return {boolean}
 */
var canThreePartsEqualSum = function (A) {
    let sum = 0;
    for (num of A) {
        sum += num;
    }

    // corner case
    if (sum % 3 !== 0) {
        return false;
    }

    // normal case
    let left = 0;
    let leftSum = A[left];
    let right = A.length - 1;
    let rightSum = A[right];
    while (left + 1 < right) {
        if (leftSum === sum / 3 && rightSum === sum / 3) {
            // 左右两边都等于 sum/3 ，中间也一定等于
            return true;
        }
        if (leftSum !== sum / 3) {
            // left = 0赋予了初值，应该先left++，在leftSum += A[left];
            leftSum += A[++left];
        }
        if (rightSum !== sum / 3) {
            // right = A.length - 1 赋予了初值，应该先right--，在rightSum += A[right];
            rightSum += A[--right];
        }
    }
    return false;
};

LeetCode 题目总结