Leetcode算法周赛-双指针，三指针操作

5643. 将数组分成三个子数组的方案数
      我们称一个分割整数数组的方案是 好的 ，当它满足：

数组被分成三个 非空 连续子数组，从左至右分别命名为 left ， mid ， right 。
left 中元素和小于等于 mid 中元素和，mid 中元素和小于等于 right 中元素和。
给你一个 非负 整数数组 nums ，请你返回 好的 分割 nums 方案数目。由于答案可能会很大，请你将结果对 109 + 7 取余后返回。

示例 1：

输入：nums = [1,1,1]
输出：1
解释：唯一一种好的分割方案是将 nums 分成 [1] [1] [1] 。
示例 2：

输入：nums = [1,2,2,2,5,0]
输出：3
解释：nums 总共有 3 种好的分割方案：
[1] [2] [2,2,5,0]
[1] [2,2] [2,5,0]
[1,2] [2,2] [5,0]
示例 3：

输入：nums = [3,2,1]
输出：0
解释：没有好的分割方案。

提示：

3 <= nums.length <= 105
0 <= nums[i] <= 104

class Solution {
    public int waysToSplit(int[] a) {
        int n = a.length;
        int[] v = new int[n+1];
        // 初始化前缀和数组
        for(int i = 1; i <= n; i++) {
            v[i] = v[i - 1] + a[i - 1];
        }
        // 返回值 ret
        long ret = 0;
        int M = 100000007;
        
        for(int i = 1; i < n; i++) {
            // 特判
            if(v[i] * 3 > v[n]) break;
            
            // 第一次二分找右边界
            int l = i + 1, r = n - 1;
            while(l <= r) {
                int mid = (l + r) >> 1;
                if(v[n] - v[mid] < v[mid] - v[i]) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                }
            }
            
            // 第二次二分找左边界
            int ll = i + 1, rr = n - 1;
            while(ll <= rr) {
                int mid = (ll + rr) >> 1;
                if(v[mid] - v[i] < v[i]) {
                    ll = mid + 1;
                } else {
                    rr = mid - 1;
                }
            }
            ret += (l - ll) % M;
        }
        return (int)(ret);
    }   
};

方法一：二分查找
解题思路
本题将一个数组分成三个子数组，需要将数组切割两刀，求解 好的 分割方案数，即求解切割的两刀的可能的位置数。

好的 方案为：

sum(left) <= sum(mid) <= sum(right) 其中 left、mid、right 为三个非空连续子数组。
求解切割的两刀的可能的位置数：

（1）首先确定第一刀的可选位置：

第一刀的起始位置：可以从0开始。
第一刀的终止位置：最大到 sum(nums) / 3位置，因为超过该位置，则后续的 mid 和 right 中元素的和就不可能小于等于 left中元素的和了。
（2）然后确定第二刀的可选位置：

第二刀的起始位置： 为 mid 中元素的和的最小值时，即当 mid 中元素的和等于 left中元素的和，sum(mid) == sum(left)。
第二刀的终止位置： 为 mid 中元素的和的最大值时，即当 mid 中元素的和等于 right中元素的和，sum(mid) == sum(mid + right) / 2。
求解第二刀的两个位置，即为在一个数组中找到目标元素的在数组中的左边界位置和目标元素在数组中的右边界位置，很明显应该使用二分查找算法。

为了使用二分查找，我们需要提前计算一个原数组的前缀和数组，

作者：mufanlee
链接：https://leetcode-cn.com/problems/ways-to-split-array-into-three-subarrays/solution/5643-jiang-shu-zu-fen-cheng-san-ge-zi-sh-fmep/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
    public int waysToSplit(int[] nums) {
        int n = nums.length;
        // 计算前缀和
        int[] sums = new int[n];
        sums[0] = nums[0];
        for (int i = 1; i < n; i++) {
            sums[i] = sums[i - 1] + nums[i];
        }

        final int MOD = 1000000000 + 7;
        long ans = 0;
        // 第一刀的最大值：sum(nums) / 3
        int t = sums[n - 1] / 3;
        for (int i = 0; i < n && sums[i] <= t; i++) {
            // 二分查找第二刀的最小值：sum(mid) == sum(left)
            // 在 [i+1, n] 中二分查找 sums[i] * 2，sums[i] 为到 i 为止元素和，因为是前缀数组，因而应该查找 sum(left) + sum(mid)
            int left = lowerBound(i + 1, n - 1, sums, sums[i] * 2);
            // 二分查找第二刀的最大值：sum(mid) == sum(mid + right) / 2
            // 在 [i+1, n] 中二分查找 sums[i] + (sums[n - 1] - sums[i]) / 2)，因为是前缀数组，因而应该查找 sum(left) + sum(mid + right) / 2
            int right = upperBound(i + 1, n - 1, sums, sums[i] + (sums[n - 1] - sums[i]) / 2);
            if (right >= left) {
                ans += right - left + 1;
            }
        }
        return (int) (ans % MOD);
    }

    public int lowerBound(int left, int right, int[] nums, int target) {
        while (left < right) {
            int mid = left + ((right - left) >> 1);
            if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        return left;
    }

    public int upperBound(int left, int right, int[] nums, int target) {
        while (left < right) {
            int mid = left + ((right - left) >> 1);
            if (nums[mid] <= target) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        return left - 1;
    }
}

看了其他大佬的三指针思路，记录三指针解题方法。

在前缀数组上枚举第一刀 i 的位置，对于每个 i 我们寻找第二刀最小的 l 和最大的 r，分别满足 sum[l] - sum[i] >= sum[i] 和 sum[n] - sum[r] >= sum[r] - sum[i]，即sum(mid) >= sum(left) 和 sum(right) >= sum(mid)，这两个条件满足单调性，可以利用三指针求解。

代码

作者：mufanlee
链接：https://leetcode-cn.com/problems/ways-to-split-array-into-three-subarrays/solution/5643-jiang-shu-zu-fen-cheng-san-ge-zi-sh-fmep/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
    public int waysToSplit(int[] nums) {
        int n = nums.length;
        int[] sum = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            sum[i] = sum[i - 1] + nums[i - 1];
        }

        final int MOD = 1000000000 + 7;
        long ans = 0;
        // |______|________|_______|________|
        // 1      i        l       r        n
        // i 表示第一刀的位置，枚举第一刀的位置，计算第二刀的可选位置数
        for (int i = 1, l = 2, r = 2; i <= n - 1; i++) {
            l = Math.max(l, i + 1);
            r = Math.max(r, i + 1);
            // sum(right) >= sum(mid)，r最大为n-1，right保证要有一个数
            while (r <= n - 1 && sum[n] - sum[r] >= sum[r] - sum[i]) {
                r++;
            }
            // sum(mid) >= sum(left)
            while (l <= n - 1 && sum[l] - sum[i] < sum[i]) {
                l++;
            }
            if (l <= r) {
                ans += r - l;
            }
        }
        return (int) (ans % MOD);
    }
}