【二分】-----【四值零和】

四值零和

题目链接

---

题目描述

对于给定的 $n$ 行 4 列的矩阵，我们定义一个“四值零和”的四元组 $a,b,c,d$ 为第一列第 $a$ 行、第二列第 $b$ 行、第三列第 $c$ 行、第四列第 $d$ 行的元素，满足这四个元素之和恰好为 $0$。

请统计出该矩阵中有多少个不同的“四值零和”的四元组。

---

输入描述

第一行输入一个整数 $n$，$(1\le n\le 2500)$ 代表矩阵行数。

此后 $n$ 行，第 $i$ 行输入四个整数 $a_{i,1},a_{i,2},a_{i,3},a_{i,4}$，$(-2^{28}\le a_{i,j}\le 2^{28})$，代表矩阵中第 $i$ 行的四个元素。

---

输出描述

在一行上输出一个整数，代表“四值零和”的四元组数量。

---

示例一

输入：

2
1 1 1 -3
-1 1 1 3

输出：

4

说明：

在这个样例中，只有 $1+1+1-3=0$ 是等于 0 的。

所以一共有四个不同的“四值零和”的四元组：

• $1,1,1,1$
• $1,1,2,1$
• $1,2,1,1$
• $1,2,2,1$

---

示例二

输入：

3
1 1 1 -3
-1 1 1 3
1 -1 1 3

输出：

12

说明：

在这个样例中，答案即为 $2\times 2\times 3\times 1=12$。

---

示例三

输入：

6
-45 22 42 -16
-41 -27 56 30
-36 53 -37 77
-36 30 -75 -46
26 -38 -10 62
-32 -54 -6 45

输出：

5

---

题解（折半枚举 + 二分查找）

一、思路分析

1. 暴力四重循环（TLE）

最朴素的方法就是暴力枚举四元组，即：

• 遍历 $n^4$ 种组合，分别从每列中任选一行取出一个数，相加判断是否为 0。
• 时间复杂度是 $O(n^4)$，显然在 $n=2500$ 的规模下不可行，会超时。

2. 折半优化（经典的 4Sum II 问题）

我们可以利用经典的折半枚举 + 二分查找技巧，将四维搜索空间降为二维：

• 枚举前两列的组合：$a_i+b_j$
• 枚举后两列的组合：$c_k+d_l$
• 然后问题转化为：在所有的 $c+d$ 中，查找有多少个等于 $-(a+b)$ 的值

这种方式的核心思想是：

• 将 $O(n^4)$ 的复杂度变成两次 $O(n^2)$ 的枚举 + 排序 + 二分
• 总体时间复杂度：$O(n^2\log n)$

---

六、算法流程

1. 将每对 $(a_i,b_j)$ 的和保存到数组 en12 中；
2. 将每对 $(c_k,d_l)$ 的和保存到数组 en34 中；
3. 对 en34 排序；
4. 对于 en12 中的每个值 x，在 en34 中用二分查找统计 $-x$ 出现的次数，累加到答案中。

---

七、代码实现（带详细注释）

#include <bits/stdc++.h>
#define int long long
using namespace std;

// 该函数负责枚举两个指定列（x 列和 y 列）所有可能的两数之和，并存入 ender 向量中
// ender：用于存放结果的容器
// nums：存储 n 行 4 列矩阵的二维数组
// x, y：表示当前要组合的两列（1~4）
// n：矩阵的行数
void pin(vector<int>& ender, vector<vector<int>> nums, int x, int y, int n)
{
    for(int i = 1; i <= n; i++)         // 遍历第一个数所在的行
    {
        for(int j = 1; j <= n; j++)     // 遍历第二个数所在的行
        {
            // 将第 i 行第 x 列 与 第 j 行第 y 列 的和计算出来
            int count = nums[i][x] + nums[j][y];
            ender.push_back(count);     // 保存所有 a[i] + b[j] 或 c[i] + d[j]
        }
    }
}

signed main()
{
    int n;
    cin >> n;  // 读取矩阵的行数

    // 创建二维数组 nums，大小为 (n+1) 行、5 列（方便使用 1-based 下标）
    vector<vector<int>> nums(n + 1, vector<int>(5, 0));

    // 读入矩阵中的每行 4 个元素：a[i][1] ~ a[i][4]
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= 4; j++)
        {
            cin >> nums[i][j];
        }
    }

    // en12 存放所有 a[i][1] + a[j][2] 的组合，即 A 列与 B 列的所有两数之和
    // en34 存放所有 a[i][3] + a[j][4] 的组合，即 C 列与 D 列的所有两数之和
    vector<int> en12;
    vector<int> en34;
    pin(en12, nums, 1, 2, n);
    pin(en34, nums, 3, 4, n);

    // 为了后续使用二分查找，先对 en34 排序
    sort(en34.begin(), en34.end());

    int ender = 0;  // 用于记录符合条件（四数之和为 0）的四元组总数

    // 遍历 en12 中的每一个两数之和 s，查找有多少个 -s 存在于 en34 中
    for(int i = 0; i < en12.size(); i++)
    {
        // 利用二分查找，找到 en34 中值等于 -en12[i] 的个数：
        // upper_bound 返回大于 -s 的第一个元素的迭代器位置
        // lower_bound 返回第一个大于等于 -s 的位置
        // 二者差即为等于 -s 的元素个数
        ender += (upper_bound(en34.begin(), en34.end(), -en12[i])
                - lower_bound(en34.begin(), en34.end(), -en12[i]));
    }

    // 输出符合 a[i][1] + a[j][2] + a[k][3] + a[l][4] == 0 的四元组个数
    cout << ender;

    return 0;
}

---

八、复杂度分析

步骤	复杂度
枚举 en12、en34 各 $n^2$ 项	$O(n^2)$
对 en34 排序	$O(n^2\log n)$
每个 en12 项二分查找	$O(n^2\log n)$
总复杂度	$O(n^2\log n)$

---

九、总结

• 本题是一个经典的高维枚举降维问题，等价于 4Sum II；
• 暴力四重循环不可行，应采用分组 + 排序 + 二分查找优化；
• 技巧核心在于：枚举 $a+b$，查找 $-(c+d)$，或反过来均可；
• 本题使用 STL 提供的 lower_bound 与 upper_bound，简洁高效。

---

杂谈（折半枚举 +哈希查找）

注意：对于本题来讲，会爆空间，但是是一个比较好的思路

---

使用 哈希表优化“二分查找”部分，将时间复杂度可以进一步简化为：

枚举两两组合（$O(n^2)$） + 哈希查表（$O(1)$） = 总体 $O(n^2)$ 级别，无排序，常数更小，速度更快。

---

一、核心思想（哈希优化 vs 二分）

在之前的做法中，我们是这样操作的：

• 枚举所有 $A[i]+B[j]$，存到数组 en12；
• 枚举所有 $C[k]+D[l]$，存到数组 en34 并排序；
• 对于每个 $x$ in en12，二分查找 en34 中有多少个 $-x$。

现在我们换一种方式：

1.1哈希版本的做法：

• 第一阶段：枚举所有 $A[i]+B[j]$，统计出现次数，存入哈希表 map<int, int>；
• 第二阶段：枚举所有 $C[i]+D[j]$，直接查找哈希表中是否存在 $-(C[i]+D[j])$，若存在则加上其出现次数。

---

二、完整代码：

#include <bits/stdc++.h>
#define int long long
using namespace std;

signed main()
{
    int n;
    cin >> n;  // 读入矩阵行数

    // 创建一个 (n+1) × 5 的二维数组，1-based 下标，方便后续处理
    vector<vector<int>> nums(n + 1, vector<int>(5, 0));

    // 读入每一行的 4 个元素，存入 nums[i][1~4]
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= 4; j++)
        {
            cin >> nums[i][j];
        }
    }

    // 哈希表，用于统计 nums[i][1] + nums[j][2] 的所有和及其出现次数
    unordered_map<int, int> sums;

    int ender = 0;  // 记录最后结果：满足条件的四元组个数

    // 枚举所有 (A[i], B[j]) 的组合，计算 a + b 的值并计数
    for(int i = 1; i <= n; i++)         
    {
        for(int j = 1; j <= n; j++)    
        {
            int count = nums[i][1] + nums[j][2];  // 计算第一列和第二列对应元素之和
            sums[count]++;  // 记录这个和出现的次数
        }
    }
    
    // 枚举所有 (C[i], D[j]) 的组合，查找是否存在 a + b = -(c + d)
    for(int i = 1; i <= n; i++)         
    {
        for(int j = 1; j <= n; j++)    
        {
            int count = nums[i][3] + nums[j][4];  // 计算第三列和第四列对应元素之和
            ender += sums[-count];  // 查找是否存在 a+b == - (c+d)，并累加次数
        }
    }

    // 输出满足四数之和为 0 的四元组个数
    cout << ender;
    return 0;
}

---

三、时间复杂度分析

步骤	时间复杂度
枚举 $C[i]+D[j]$	$O(n^2)$
枚举 $A[i]+B[j]$ + 查表	$O(n^2)$
总计	$O(n^2)$

相比排序 + 二分的 $O(n^2\log n)$，哈希表方案常数更小，速度更快，但是对于大数据量会爆空间。

---

三、总结

方法	是否排序	是否二分	是否哈希	复杂度	优劣说明
排序 + 二分	是	是	否	$O(n^2\log n)$	稳定，适用于不支持哈希环境
哈希查表法	否	否	是	$O(n^2)$	更快，适用于小数据量环境

---