LeetCode 923.多重三数之和

给定一个整数数组 arr ，以及一个整数 target 作为目标值，返回满足 i < j < k 且 arr[i] + arr[j] + arr[k] == target 的元组 i, j, k 的数量。

由于结果会非常大，请返回 109 + 7 的模。

示例 1：

输入：arr = [1,1,2,2,3,3,4,4,5,5], target = 8
输出：20
解释：
按值枚举(arr[i], arr[j], arr[k])：
(1, 2, 5) 出现 8 次；
(1, 3, 4) 出现 8 次；
(2, 2, 4) 出现 2 次；
(2, 3, 3) 出现 2 次。
示例 2：

输入：arr = [1,1,2,2,2,2], target = 5
输出：12
解释：
arr[i] = 1, arr[j] = arr[k] = 2 出现 12 次：
我们从 [1,1] 中选择一个 1，有 2 种情况，
从 [2,2,2,2] 中选出两个 2，有 6 种情况。

提示：

3 <= arr.length <= 3000
0 <= arr[i] <= 100
0 <= target <= 300

先对arr进行排序，然后固定一个数字，进行相向双指针计算即可：

class Solution {
public:
    int threeSumMulti(vector<int>& arr, int target) {
        long long ans = 0;

        sort(arr.begin(), arr.end());

        // 每次固定一个数字
        for (int i = 0; i < arr.size() - 2; ++i) {
            int left = i + 1;
            int right = arr.size() - 1;

            if (arr[i] + arr[i + 1] + arr[i + 2] > target) {
                break;
            }

            if (arr[i] + arr[right] + arr[right - 1] < target) {
                continue;
            }

            while (left < right) {
                if (arr[i] + arr[left] + arr[right] > target) {
                    --right;
                } else if (arr[i] + arr[left] + arr[right] < target) {
                    ++left;
                } else {
                    // 如果left和right指向的数字的值相同
                    // 说明[left, right]中任意两数字加arr[i]的和都为target
                    if (arr[left] == arr[right]) {
                        ans += (right - left + 1) * (right - left) / 2;
                        break;
                    }

					// 计算左指针指向的数字有多少个连续相同的
                    int leftSame = 1;
                    ++left;
                    while (arr[left] == arr[left - 1]) {
                        ++leftSame;
                        ++left;
                    }

                    // 计算右指针指向的数字有多少个相同的
                    int rightSame = 1;
                    --right;
                    while (arr[right] == arr[right + 1]) {
                        ++rightSame;
                        --right;
                    }

                    ans += leftSame * rightSame;
                }
            }
        }

        return ans % (int)(1e9 + 7);
    }
};

如果arr的长度为n，则此算法时间复杂度为O(n${}^2$)，空间复杂度为O(logn)。