POJ - 1775 Triathlon（半平面交 + 线性规划）

链接 Triathlon

题意

有 $n$ 个选手参加三个比赛，给出每个选手三个比赛的速度，裁判可以任意调整每个比赛的路程，问能不能让选手 $i$ 胜出，可以则输出 $Yes$；

思路

设每段路程为 $x,y,z$ ，那么每个选手比赛花费的时间 $$T=\frac{x}{u_i}+\frac{y}{v_i}+\frac{z}{w_i}$$

那么如果要想然 $i$ 选手胜出，则

$$T_i-T_j=\frac{x}{u_i}+\frac{y}{v_i}+\frac{z}{w_i}-(\frac{x}{u_j}+\frac{y}{v_j}+\frac{z}{w_j})<0$$
因为每段路程都大于 $0$，所以我们将这个式子除 $z$，变成二元不等式，然后求可行域，用半平面交判断即可；

$$ax+by+c<0$$

难点在于将直线表达式换成向量，当然也可以不用向量做，直接用直线表达式做；

换成向量的话，给出一个图比较好理解做法；

这是$ax+by<0$的向量情况，要得到题中的情况，我们只需要平移即可；
这样我们就可以得到向量坐标，然后半平面交即可；

AC代码

#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <map>
#include <vector>

#define x first
#define y second

using namespace std;

const double eps = 1e-10;
const int N = 10010;
typedef pair<double, double> PDD;
const double pi = 3.1415926535898;

int T;
int n, cnt;
double u[N], v[N], w[N];

struct Line
{
    PDD st, ed;
    Line(){}
    Line(PDD a, PDD b)
    {
        st = a, ed = b;
    }
} line[N];


PDD operator -(PDD a, PDD b)
{
    return make_pair(a.x - b.x, a.y - b.y);
}

PDD operator *(PDD a, double u)
{
    return make_pair(a.x * u, a.y * u);
}

PDD operator +(PDD a, PDD b)
{
    return make_pair(a.x + b.x, a.y + b.y);
}

int sign(double x)
{
    if (fabs(x) < eps) return 0;
    if (x < 0) return -1;
    return 1;
}

int dcmp(double x, double y)
{
    if (fabs(x - y) < eps) return 0;
    if (x < y) return -1;
    return 1;
}

double cross(PDD a, PDD b)
{
    return a.x * b.y - a.y * b.x;
}

double area(PDD a, PDD b, PDD c)
{
    return cross(b - a, c - a);
}

PDD get_intersect(PDD p, PDD v, PDD q, PDD w)
{
    PDD u = p - q;
    double t = cross(w, u) / cross(v, w);
    return make_pair(p.x + v.x * t, p.y + v.y * t);
}

double point_product(PDD a, PDD b)
{
    return a.x * b.x + a.y * b.y;
}

double get_len(PDD a, PDD b)
{
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
}

double get_angle(Line a)
{
    return atan2(a.ed.y - a.st.y, a.ed.x - a.st.x);
}

bool cmp(Line a, Line b)
{
    double A = get_angle(a);
    double B = get_angle(b);

    if (!dcmp(A, B)) return area(a.st, a.ed, b.st) < 0;

    return A < B;
}

PDD get_intersect(Line a, Line b)
{
    return get_intersect(a.st, a.ed - a.st, b.st, b.ed - b.st);
}

bool on_right(Line a, Line b, Line c)
{
    PDD o = get_intersect(b, c);
    return sign(area(a.st, a.ed, o)) <= 0;
}

bool half_plane_intersection()
{
    int q[N];
    sort(line, line + cnt, cmp);

    int hh = 0, tt = -1;
    for (int i = 0; i < cnt; i ++)
    {
        if (i && !dcmp(get_angle(line[i]), get_angle(line[i - 1]))) continue;

        while (hh + 1 <= tt && on_right(line[i], line[q[tt]], line[q[tt - 1]])) tt --;
        while (hh + 1 <= tt && on_right(line[i], line[q[hh]], line[q[hh + 1]])) hh ++;

        q[++ tt] = i;
    }

    while (hh + 1 <= tt && on_right(line[q[hh]], line[q[tt]], line[q[tt - 1]])) tt --;
    while (hh + 1 <= tt && on_right(line[q[tt]], line[q[hh]], line[q[hh + 1]])) hh ++;

    q[++ tt] = q[hh];
    return tt - hh >= 3;
}

bool solve(int id)
{
    cnt = 0;
    double x1, y1, x2, y2;

    for (int j = 1; j <= n; j ++)
    {
        if (j == id) continue;
        double a = (u[j] - u[id]) / (u[id] * u[j]);
        double b = (v[j] - v[id]) / (v[id] * v[j]);
        double c = (w[j] - w[id]) / (w[id] * w[j]);
        if (!sign(a))
        {
            if (!sign(b))
            {
                if (sign(c) >= 0) return false;
                continue;
            }
            x1 = sign(b);
            x2 = 0;
            y2 = y1 = - c / b;
        }
        else
        {
            if (!sign(b))
            {
                x2 = x1 = - c / a;
                y2 = 0;
                y1 = -sign(a);
            }
            else
            {
                x1 = sign(b);
                y1 = -(c + a * x1) / b;
                x2 = 0;
                y2 = - c / b;
            }
        }
        line[cnt ++] = Line(make_pair(x1, y1), make_pair(x2, y2));
    }

    line[cnt ++] = Line(make_pair(0.0, 0.0), make_pair(100000.0, 0.0));
    line[cnt ++] = Line(make_pair(100000.0, 0.0), make_pair(100000.0, 100000.0));
    line[cnt ++] = Line(make_pair(100000.0, 100000.0), make_pair(0.0, 100000.0));
    line[cnt ++] = Line(make_pair(0.0, 100000.0), make_pair(0.0, 0.0));
    
    return half_plane_intersection();
}

int main(){

    while (~scanf("%d", &n))
    {
        for (int i = 1; i <= n; i ++) cin >> u[i] >> v[i] >> w[i];

        for (int i = 1; i <= n; i ++)
        {
            if (solve(i)) puts("Yes");
            else puts("No");
        }
    }
    

    return 0;
}

——END