HDU 6136 贪心+优先队列+并查集优化

题意：

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6136
一个长度为L的环形赛道上有n辆赛车，每个赛车有一个初始位置和一个顺时针或逆时针的速度，第i个赛车重量为i，当两个赛车相遇之后重量小的会被毁掉，重量大将状态不变，继续前进，问经过多长时间之后，只剩下一辆车。

---

思路：

贪心，可以想到一个明显的结论，所有车里最先相撞的一定是某两个相邻的赛车，那么可以将所有相邻的赛车相撞需要的时间保存在优先队列里，每次选出时间最小的一对，这两辆车会最先相撞，小的毁掉，剩下一个大的，将大的与其左右两边还存在的赛车构成两对加入队列，一直到只剩一辆车结束。
大体思路出来了，但是在每次撞击之后添加新的赛车对的过程，需要利用并查集优化，找到左右两边还存活的最近的赛车。对于规定的分数输出，只需要在最后一对时候保存分数，其余时候都用double即可。

---

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MAXN = 1e5 + 10;

struct node {
    int u, v;
    double t;
    bool operator < (const node &rhs) const {
        return t - rhs.t > 1e-6;
    }
};

struct NODE {
    int d, v, id;
    bool operator < (const NODE &rhs) const {
        return d < rhs.d;
    }
} p[MAXN];

int n, len;

double getTime(NODE a, NODE b) {
    if (a.d > b.d) swap(a, b);

    if (a.v >= 0 && b.v >= 0) {
        if (a.v >= b.v) return 1.0 * (b.d - a.d) / (a.v - b.v);
        else return 1.0 * (len - (b.d - a.d)) / (b.v - a.v);
    }
    else if (a.v < 0 && b.v >= 0) {
        return 1.0 * (len - (b.d - a.d)) / (b.v - a.v);
    }
    else if (a.v >= 0 && b.v < 0) {
        return 1.0 * (b.d - a.d) / (a.v - b.v);
    }
    else {
        if (a.v >= b.v) return 1.0 * (b.d - a.d) / (a.v - b.v);
        else return 1.0 * (len - (b.d - a.d)) / (b.v - a.v);
    }
}

int L[MAXN], R[MAXN];
bool die[MAXN];

int findL(int x) {
    return !die[x] ? x : L[x] = findL(L[x]);
}

int findR(int x) {
    return !die[x] ? x : R[x] = findR(R[x]);
}

int main() {
    //freopen("in.txt", "r", stdin);
    int T;
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &n, &len);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &p[i].d);
        }
        for (int i = 1; i <= n; i++) {
            scanf("%d", &p[i].v);
            p[i].id = i;
        }
        sort (p + 1, p + 1 + n);
        L[1] = n; R[n] = 1;
        for (int i = 2; i <= n; i++) L[i] = i - 1;
        for (int i = 1; i < n; i++) R[i] = i + 1;
        priority_queue <node> que;
        memset(die, false, sizeof(die));
        node now, next;
        for (int i = 1; i < n; i++) {
            now.u = i; now.v = i + 1;
            now.t = getTime(p[i], p[i + 1]);
            que.push(now);
        }
        if (n > 2) {
            now.u = 1; now.v = n;
            now.t = getTime(p[1], p[n]);
            que.push(now);
        }
        pair <int, int> ans;
        while (!que.empty()) {
            now = que.top(); que.pop();
            int u = now.u, v = now.v;
            if (die[u] || die[v]) continue;
            if (p[u].id > p[v].id) swap(u, v);
            ans = make_pair(u, v);
            die[u] = true;
            next.v = v;

            next.u = findR(R[v]);
            if (next.u != 0 && next.u != next.v) {
                next.t = getTime(p[next.u], p[next.v]);
                que.push(next);
            }

            next.u = findL(L[v]);
            if (next.u != 0 && next.u != next.v) {
                next.t = getTime(p[next.u], p[next.v]);
                que.push(next);
            }
        }
        NODE a = p[ans.first], b = p[ans.second];
        LL x, y;
        if (a.d > b.d) swap(a, b);
        if (a.v >= 0 && b.v >= 0) {
            if (a.v >= b.v) x = b.d - a.d, y = a.v - b.v;
            else x = len - (b.d - a.d), y = b.v - a.v;
        }
        else if (a.v < 0 && b.v >= 0) {
            x = len - (b.d - a.d), y = b.v - a.v;
        }
        else if (a.v >= 0 && b.v < 0) {
            x = b.d - a.d, y = a.v - b.v;
        }
        else {
            if (a.v >= b.v) x = b.d - a.d, y = a.v - b.v;
            else x = len - (b.d - a.d), y = b.v - a.v;
        }
        LL g = __gcd(x, y);
        x /= g; y /= g;
        printf("%I64d/%I64d\n", x, y);
    }
    return 0;
}