算法 四等分数组

对于一个长度为N的整型数组A， 数组里所有的数都是正整数，对于两个满足0<=X <= Y <N的整数，
A[X], A[X+1] … A[Y]构成A的一个切片，记作(X, Y).
用三个下标 m1, m2, m3下标满足条件0 < m1, m1 + 1 < m2, m2 +1 < m3 < N – 1。
可以把这个整型数组分成(0, m1-1), (m1+1, m2-1), (m2+1, m3-1), (m3+1, N-1) 四个切片。
如果这四个切片的整数求和相等，称作“四等分”。 编写一个函数，求一个给定的整型数组是否可以四等分
要求： 函数的计算复杂度为O(N)，使用的额外存储空间（除了输入的数组之外）最多为O(N)。

代码

vector<int> quarterArray(vector<int> nums) {
        if (nums.size() < 7) {
            return {};
        }
        vector<__int64> sum(nums.size(), 0);
        sum[0] = nums[0]; 
        for (int i = 1; i < static_cast<int> (nums.size()); ++i) {
            sum[i] += sum[i - 1] + nums[i]; 
        }
        int low = 0; 
        int high = static_cast<int>(nums.size()) - 1;
        __int64 firstSum = nums[low++]; 
        __int64 lastSum = nums[high--];
        while (low + 4 <= high) {
            if (firstSum < lastSum) {
                firstSum += nums[low++]; 
            }
            else if (firstSum > lastSum) {
                lastSum += nums[high--];
            }

            else {
                int l = low + 1;
                int h = high - 1;
                while (l <= h) {
                    int m = (l + h) >> 1; 
                    __int64 secSum = sum[m - 1] - sum[low];
                    __int64 thdSum = sum[high - 1] - sum[m];
                    if (secSum > thdSum) {
                        h = m - 1;
                    }
                    else if (secSum < thdSum) {
                        l = m + 1;
                    }
                    else {
                        if (secSum == firstSum) {
                            return {low, m, high};
                        }
                        else {
                            firstSum += nums[low++];
                            break;
                        }
                    }
                }
            }
        }
        return{}; 
    }