Gym - 100889H Hitting Points 计算几何+三分+二分

题目链接

Hitting Points

题意

按逆时针顺序给你二维平面上严格凸包的n个点,编号0到n-1, 有q次询问, 每次询问确定一个编号为idx的基础点, 以idx和(idx+1)%n构成的向量为x轴, 在(k,0)这个点上有一条垂直于x轴的线绕(k,0)这个点逆时针旋转, 问第一次碰到的点的编号是多少. 如果碰到两个点就输出两个答案.

做法

考虑落到每一个点的时候有多少点在线的上方, 这样构成了一个先递减后递增的序列. 由于第一次碰到的点一定是有最少的点在这个点和基准点(k, 0)所连接的这条线的上方, 因此可以三分中间的最小值. 但是有可能存在两个最小值,我们可以大范围内三分, 将整个区域缩小成一个较小的区域后暴力.

对于怎么求有多少个点在这条线的上方, 可以考虑二分. 找到逆时针方向最后一个在线的下方的点或者找逆时针方向最后一个在线的上方的点. 这两种情况分别对应于选中的点与逆时针方向点的连线与基准线的关系.

二分和整数三分被我自己写死了. 当个模板记录一下

代码

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#define inf 0x3f3f3f3f
#define cases(t) for (int cas = 1; cas <= int(t); ++cas)
using namespace std;
typedef double db;
const db eps = 1e-7;
const int N = 1e5 + 5;
int sign(db p) { return p < -eps ? -1 : p > eps; }
struct point {
    db x, y;
    point operator+(const point& t) const { return {x + t.x, y + t.y}; }
    point operator-(const point& t) const { return {x - t.x, y - t.y}; }
    point operator*(const db k) const { return {x * k, y * k}; }
    point operator/(const db k) const { return {x / k, y / k}; }
    db operator^(const point& t) const { return x * t.y - y * t.x; }
    db abs2() const { return x * x + y * y; }
    db abs() const { return sqrt(abs2()); }
    point unit() const { return *this / abs(); }
} a[N];
int n, q;
int check(int idx, int k, int p) {
    p %= n;
    int l = p, r = l + n - 1, mid, ans;
    point base = ((a[(idx + 1) % n] - a[idx]).unit() * k) + a[idx];
    point line = a[l] - base;
    point next = a[r % n] - base;
    if (sign(next ^ line) >= 0) { 
    	//上方 找逆时针最后一个在线的下方的点
        int l = p, r = p + n - 1, mid;
        while (l < r) {
            int mid = (l + r + 1) >> 1;
            point tmp = a[mid % n] - base;
            if (sign(tmp ^ line) >= 0)
                r = mid - 1;
            else
                l = mid;
        }
        return p + n - l;
    } else { 
    	//下方 找逆时针最后一个在线的上方的点
        int l = p, r = p + n - 1, mid;
        while (l < r) {
            int mid = (l + r + 1) >> 1;
            point tmp = a[mid % n] - base;
            if (sign(tmp ^ line) < 0)
                r = mid - 1;
            else
                l = mid;
        }
        return l - p + 1;
    }
}
vector<int> solve(int idx, int k) {
    int l = idx, r = idx + n - 1, mn = inf;
    while (r - l >= 3) {
        int mid1 = (l + r) / 2;
        int mid2 = (mid1 + r) / 2;
        if (check(idx, k, mid1) <= check(idx, k, mid2))
            r = mid2;
        else
            l = mid1;
    }
    int ret1 = -1, ret2 = -1;
    for (int i = l; i <= r; ++i) {
        int ret = check(idx, k, i);
        if (ret < mn) {
            mn = ret;
            ret1 = i;
            ret2 = -1;
        } else if (ret == mn) {
            ret2 = i;
        }
    }
    if (~ret2) return {ret1, ret2};
    return {ret1};
}
int main() {
    scanf("%d%d", &n, &q);
    for (int i = 0; i < n; ++i) scanf("%lf%lf", &a[i].x, &a[i].y);
    while (q--) {
        int idx, k;
        scanf("%d%d", &idx, &k);
        vector<int> res = solve(idx, k);
        for (auto pp : res) printf("%d ", pp % n);
        puts("");
    }
    return 0;
}