二分查找在大规模数据排序中的应用与优化

银河系李老幺

1. 问题描述与理解

这道题目来自华东师范大学2022年的机试编程题，考察的是对大规模数据处理和二分查找算法的综合应用能力。题目要求我们处理两个数组的乘积矩阵，并找出排序后的第k大元素。

1.1 问题核心

给定两个数组a和b，长度分别为n和m（n,m≤10^5），我们需要构造一个n×m的矩阵c，其中c[i][j]=a[i]×b[j]。然后将这个矩阵中的所有元素从大到小排序，找出第k大的元素值。

1.2 数据规模分析

最直观的解法是计算出所有n×m个乘积，排序后取第k个。但当n和m都是10^5时，乘积矩阵将有10^10个元素，这显然无法在合理时间内完成计算和排序。因此，我们需要寻找更高效的算法。

2. 解题思路与算法选择

2.1 暴力法的局限性

直接计算所有乘积并排序的时间复杂度是O(nm log(nm))，当n和m都是10^5时，nm=10^10，这样的复杂度完全不可接受。我们需要一个时间复杂度更低的算法。

2.2 二分查找的思路

观察到我们可以将问题转化为：找到一个数x，使得矩阵中大于等于x的元素数量恰好为k。这提示我们可以使用二分查找来解决这个问题。

具体思路：

先对两个数组进行排序
确定二分查找的上下界
对于每个中间值mid，计算矩阵中有多少元素大于等于mid
根据计算结果调整二分查找的范围

2.3 二分查找的复杂度

二分查找的时间复杂度是O(log(max_val - min_val))，其中max_val和min_val是可能的最大和最小乘积值。对于每个mid值，我们需要O(n log m)的时间来计算有多少元素大于等于mid。因此总时间复杂度是O(n log m log(max_val - min_val))，这在n和m都是10^5时是可接受的。

3. 算法实现细节

3.1 预处理：数组排序

首先需要对两个数组进行排序，这是为了后续能够高效地计算每行中满足条件的元素数量。

cpp复制sort(a + 1, a + 1 + n); // 排序保持单调性
sort(b + 1, b + 1 + m);

3.2 二分查找框架

设置初始的查找范围为可能的最小乘积和最大乘积：

cpp复制int l = -1e12, r = 1e12; // 1e6 * 1e6
while(l < r){
    int mid = l + r >> 1;
    if(check(mid)) r = mid; // 看 mid 实际在 n * m 里面能排 rk 几和 k 比较
    else l = mid + 1;
}

3.3 check函数的实现

check函数需要计算矩阵中有多少元素大于mid。由于数组已排序，我们可以对每行使用二分查找：

cpp复制bool check(int x){
    int sum = 0;
    for(int i = 1; i <= n; i ++){
        if(a[i] < 0){ // 单调递减
            int l = 1, r = m;
            while(l < r){
                int mid = (l + r + 1) >> 1;
                if(a[i] * b[mid] <= x) r = mid - 1;
                else l = mid;
            }
            // 考虑边界
            if(l == 1 && a[i] * b[l] <= x) l = 0;
            sum += m - l;
        }else{ // >= 0 单调递增
            int l = 1, r = m;
            while(l < r){
                int mid = l + r >> 1;
                if(a[i] * b[mid] <= x) l = mid + 1;
                else r = mid; 
            }
            // 考虑边界
            if(l == m && a[i] * b[l] <= x) l = m + 1;
            sum += l - 1;
        }
    }
    int rk = n * m - sum + 1;
    return rk <= k;
}

3.4 边界条件处理

特别注意当a[i]为正数或负数时，乘积的单调性会发生变化：

当a[i]为正数时，a[i]*b[j]随b[j]增大而增大（单调递增）
当a[i]为负数时，a[i]*b[j]随b[j]增大而减小（单调递减）

这导致我们需要针对这两种情况分别处理二分查找的逻辑。

4. 代码实现与优化

4.1 完整代码实现

cpp复制#include<bits/stdc++.h>
using namespace std;
#define int long long 
const int N = 1e5 + 10;
int a[N], b[N];
int n, m, k;

bool check(int x){
    int sum = 0;
    for(int i = 1; i <= n; i ++){
        if(a[i] < 0){ // 单调递减
            int l = 1, r = m;
            while(l < r){
                int mid = (l + r + 1) >> 1;
                if(a[i] * b[mid] <= x) r = mid - 1;
                else l = mid;
            }
            if(l == 1 && a[i] * b[l] <= x) l = 0;
            sum += m - l;
        }else{ // >= 0 单调递增
            int l = 1, r = m;
            while(l < r){
                int mid = l + r >> 1;
                if(a[i] * b[mid] <= x) l = mid + 1;
                else r = mid; 
            }
            if(l == m && a[i] * b[l] <= x) l = m + 1;
            sum += l - 1;
        }
    }
    int rk = n * m - sum + 1;
    return rk <= k;
}

void solve(){
    cin >> n >> m >> k;
    for(int i = 1; i <= n; i ++) cin >> a[i];
    for(int i = 1; i <= m; i ++) cin >> b[i];
    sort(a + 1, a + 1 + n);
    sort(b + 1, b + 1 + m);
    int l = -1e12, r = 1e12;
    while(l < r){
        int mid = l + r >> 1;
        if(check(mid)) r = mid;
        else l = mid + 1;
    }
    cout << l << endl;
}

signed main(){
    int T = 1;
    while(T --){
        solve();
    }
    return 0;
}