AtCoder ABC 155D Pairs

题目链接：https://atcoder.jp/contests/abc155/tasks/abc155_d

题目大意

　　给定$N$个整数$A_1, A_2, dots, A_N$, 求集合$S = {A_i * A_j | 1 leq i, j leq N 且 i eq j}$的第$K$小。

分析

　　首先，通过把$N$个数分为正数，负数，零，再排下序，我们可以计算$S$中所有的正数，负数以及零的数目，进而可以判断出第$K$小的数是正数，是负数，还是零。

　　如果第$K$小的数是零，无需多言。

　　如果第$K$小的数不是零，则可以先求出上界与下界，通过二分法，指定所二分的数就是第$K$小的，然后用二分法计数有多少数比它小，直到上界等于下届为止。

　　时间复杂度为$O(Nlog^2N)$。

代码如下

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

/*-------------------Define Start-------------------*/
typedef bool BL;                        // 布尔类型
typedef char SB;                        // 有符号1字节,8位
typedef unsigned char UB;                // 无符号1字节,8位
typedef short SW;                        // 有符号短整型,16位
typedef unsigned short UW;                // 无符号短整型,16位
typedef long SDW;                        // 有符号整型,32位
typedef unsigned long UDW;               // 无符号整型,32位
typedef long long SLL;                    // 有符号长整型,64位
typedef unsigned long long ULL;            // 无符号长整型,64位
typedef char CH;                        // 单个字符
typedef float R32;                        // 单精度浮点数
typedef double R64;                        // 双精度浮点数

#define Rep(i, n) for (register SDW i = 0; i < (n); ++i)
#define For(i, s, t) for (register SDW i = (s); i <= (t); ++i)
#define rFor(i, t, s) for (register SDW i = (t); i >= (s); --i)
#define foreach(i, c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); ++i)
#define ms0(a) memset(a,0,sizeof(a))
#define msI(a) memset(a,0x7f,sizeof(a))
#define LOWBIT(x) ((x)&(-x))

#define MP make_pair
#define PB push_back
#define ft first
#define sd second
#define ALL(x) x.begin(),x.end()

#define pr(x) cout << #x << " = " << x << "  "
#define prln(x) cout << #x << " = " << x << endl

const ULL mod = 1e9 + 7;                //常用模数(可根据题目需要修改)
const ULL inf = 0x7fffffff;                //用来表示无限大
const ULL infLL = 0x7fffffffffffffffLL;    //用来表示无限大
/*-------------------Define End-------------------*/

const UDW maxN = 1e6 + 7;
SDW N, K; 
vector< SLL > posi; // 存正数 
SLL lenP; 
vector< SLL > nega; // 存负数 
SLL lenN;
SLL zero; // 记录0的个数 
SLL cntP; // 正数数对个数 
SLL cntN; // 负数数对个数 
SLL cntZ; // 零数对个数 
SLL ans;

void input(){
    SLL tmp;
    
    cin >> N >> K;
    Rep(i, N) {
        cin >> tmp;
        if(tmp == 0) {
            ++zero;
        }
        else if(tmp > 0) {
            posi.PB(tmp);
        }
        else {
            nega.PB(tmp);
        }
    }
    
    lenP = posi.size();
    lenN = nega.size();
    
    sort(ALL(posi));
    sort(ALL(nega));
    
    cntP = lenP * (lenP - 1) / 2 + lenN * (lenN - 1) / 2;
    cntN = lenP * lenN;
    cntZ = zero * (zero - 1) / 2 + zero * (lenP + lenN);
}

// 二分查找 A 中第一个满足 A * b > p的下标 
SLL upper_bound(vector< SLL > &A, SLL b, SLL p) {
    SLL L = 0;
    SLL R = A.size();
    
    while(L != R) {
        SLL mid = (L + R) >> 1;
        
        if(A[mid] * b <= p) {
            L = mid + 1;
        }
        else {
            R = mid;
        }
    }
    return R;
}

void solve(){
    if(K > cntN && K <= cntN + cntZ) {
        ans = 0;
    }
    else if(K <= cntN) { // 第 K 小数对乘积为负数 
        SLL L = posi.back() * nega[0];
        SLL R = posi[0] * nega.back();
        
        while(L != R) {
            SLL mid = (L + R) >> 1;
            SLL sum = 0; // 记录小于等于mid的数对个数 
            
            Rep(i, lenP) {
                SLL tmp = upper_bound(nega, posi[i], mid);
                sum += tmp; 
            } 
            
            if(sum >= K) {
                R = mid;
            }
            else {
                L = mid + 1;
            }
        }
        
        ans = R;
    }
    else { // 第 K 小数对乘积为正数 
        K -= cntN + cntZ;
        reverse(ALL(nega)); // 由于负数 ×负数会改变数组的有序性，会使二分出错，所以这里反转一下 
        
        SLL L = infLL;
        SLL R = 0;
        
        if(lenP >= 2) {
            L = min(L, posi[0] * posi[1]);
            R = max(R, posi[lenP - 1] * posi[lenP - 2]);
        }
        
        if(lenN >= 2) {
            L = min(L, nega[0] * nega[1]);
            R = max(R, nega[lenN - 1] * nega[lenN - 2]);
        }
        
        while(L != R) {
            SLL mid = (L + R) >> 1;
            SLL sum = 0; // 记录小于等于mid的数对个数 
            
            Rep(i, lenP) {
                SLL tmp = upper_bound(posi, posi[i], mid);
                sum += tmp; 
                if(tmp > i) {
                    --sum; // 减去自己乘自己 
                }
            } 
            
            Rep(i, lenN) {
                SLL tmp = upper_bound(nega, nega[i], mid);
                sum += tmp; 
                if(tmp > i) {
                    --sum; // 减去自己乘自己 
                }
            } 
            
            sum /= 2; // 一个数对算了两遍，要除以2 
            
            if(sum >= K) {
                R = mid;
            }
            else {
                L = mid + 1;
            }
        }
        
        ans = R;
    }
}

void output(){
    cout << ans << endl;
}

int main() {
    input();
    solve();
    output();
    return 0;
}