HDU 6136 Death Podracing （2017 Multi-Univ Training Contest 8）

Problem

Problem Link

Idea

解题的必要前提：将剩余的所有人按照初始位置从小到大排序，重新依次编号 1 ~ n 。则显然，最早的两人相遇一定发生在某两个编号相邻的人之间（1 与 n 也视作相邻）。

故用 set 维护剩余的人的编号，当某个编号为 i 的人被淘汰后，在 set 中删除编号 i ，同时查找与 i 左相邻及右相邻的两个编号，显然此时这两个编号也又可能是在淘汰 i 之后，最快相遇的一对。

对于任意一对，结构体记录 两人的编号 x, y 与两人相遇所需时间 ，压入优先队列（相遇所需时间最短的先出队列）。逐次出队，处理两人相遇，淘汰 power 较小的，同时维护 set 。当 set 中仅有两个编号时，这两人即为最晚相遇的一对。直接处理两人路程差及速度差， GCD 处理后输出。

Code

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int T, n, L;
struct Point {
    int d, v, power;
} pr[N];
bool cmp(Point a, Point b) {
    return a.d < b.d;
}
struct P {
    int x, y;
    double times;
} p, q;
bool operator<(P a, P b) {
    return a.times > b.times;
}
int sgn(int x) {
    if(x == 0)  return 0;
    return x > 0 ? 1 : -1;
}
double calTime(int x, int y) {
    int dist = pr[y].d - pr[x].d;
    int dv = pr[x].v - pr[y].v;
    if(dv < 0) {
        dist = L - dist;
        dv *= -1;
    }
    return dist * 1.0 / dv;
}
set<int> st;
set<int>::iterator it;
void solve() {
    it = st.begin();
    int x = *it;
    int y = *(++it);
    int dist = pr[y].d - pr[x].d;
    int dv = pr[x].v - pr[y].v;
    if(dv < 0) {
        dist = L - dist;
        dv *= -1;
    }
    int GCD = __gcd(dist, dv);
    printf("%d/%d\n", dist/GCD, dv/GCD);    
}
int main()
{
    freopen("in", "r", stdin);
    scanf("%d", &T);
    while(T-- && scanf("%d %d", &n, &L)!=EOF)
    {
        st.clear();
        for(int i=0;i<n;i++)
            scanf("%d", &pr[i].d);
        for(int i=0;i<n;i++)
            scanf("%d", &pr[i].v);
        for(int i=0;i<n;i++) {
            pr[i].power = i;
            st.insert(i);
        }

        if(n == 2) {
            solve();    continue;
        }

        sort(pr, pr+n, cmp);

        priority_queue<P> que;
        while(!que.empty()) que.pop();
        for(int i=0;i<n;i++)
        {
            p.x = i,    p.y = (i+1)%n,  p.times = calTime(p.x, p.y);
            que.push(p);
        }
        while(!que.empty())
        {
            p = que.top();
            que.pop();

            if(st.find(p.x) == st.end() || st.find(p.y) == st.end())    continue;
            if(pr[ p.x ].power > pr[ p.y ].power) {
                swap(p.x, p.y);
            }

            st.erase(p.x);

            if(st.size() == 2) {
                solve();
                break;
            }
            it = st.lower_bound(p.x);
            if(it == st.begin())    it = st.end();
            it--;
            q.x = *it;
            it = st.lower_bound(p.x);
            if(it == st.end())  it = st.begin();
            q.y = *it;
            if(q.x > q.y)   swap(q.x, q.y);
            q.times = calTime(q.x, q.y);
            que.push(q);

        }
    }
}