NOIP模拟 run - 双向链表

题目大意：

企鹅国正在举办全面运动会，第一项比赛就是跑步。N 个人在圆形跑道上跑步，他们都有各自的速度和起点。但这个跑步规则很奇怪，当两个人相遇的时候编号较小的就会出局，当场上剩下最后一个人的时候跑步就结束了。豆豆想知道多长时间游戏会结束？

输入格式

第一行一个整数 T 表示数据组数；

每组数据的第一行是两个整数 N 和 L ，表示参赛人数以及跑道长度。

接下来一行有 N 个不同的整数 Di，表示每个人的起点。

接下来一行有 N 个不同的整数 Vi，表示每个人的跑步速度，如果速度为负数，就是在反着跑。

输出格式

对于每组数据，以最简分数形式表示游戏结束的时间。

数据范围

对于 30% 的数据，2≤n≤100, 1≤L≤200；

对于 60% 的数据，2≤n≤103。

对于 100% 的数据，2≤n≤105，T≤5, 1≤L≤109, 0≤Di<L, 0≤|Vi|≤109；

题目分析：

双向链表的运用：首先要知道最先相遇的肯定是相邻的两个人（因为任何一方都不能越过另一个人），那么将每个人按照起点排序，将相邻两个人的相遇时间放入优先队列，每次取出时间最短的两个人，将编号较小的那个从双向链表中删除，直到队列中只剩下两个人，最后输出答案。

code

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

const int N = 1e5 + 5;
int T, n, cnt;
typedef long long ll;
ll L;
bool dele[N];
struct node{
    int id, last, nxt, speed, start;
    inline bool operator < (const node &b) const{
        return start < b.start;
    }
}bdList[N];
struct node2{
    int id1, id2;
    double t;
    friend bool operator < (const node2 &a, const node2 &b){
        return a.t > b.t;
    }
};
priority_queue<node2> que;

inline double calcTime(int u, int v){
    if(bdList[u].speed < bdList[v].speed) swap(u, v);
    ll dis = (bdList[v].start - bdList[u].start + L) % L, deltaV = (bdList[u].speed - bdList[v].speed);
    return 1.0 * dis / deltaV;
}

inline void del(int k){
    bdList[bdList[k].nxt].last = bdList[k].last;
    bdList[bdList[k].last].nxt = bdList[k].nxt;
}

inline void init(){
    memset(dele, 0, sizeof dele);
    while(!que.empty()) que.pop();
    memset(bdList, 0, sizeof bdList);
    cnt = 0;
}

inline ll GCD(ll a, ll b){return b == 0 ? a : GCD(b, a % b);}

int debug;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL), cout.tie(NULL);
    cin >> T;
    while(T--){
        cin >> n >> L;
        init();
        for(int i = 1; i <= n; i++){
            bdList[i].id = i;
            cin >> bdList[i].start;
        }
        for(int i = 1; i <= n; i++) cin >> bdList[i].speed;
        sort(bdList + 1, bdList + n + 1);
        for(int i = 1; i <= n; i++) bdList[i].last = i - 1, bdList[i].nxt = i + 1;
        bdList[1].last = n, bdList[n].nxt = 1;

        for(int i = 1; i <= n; i++){
            double t = calcTime(i, bdList[i].nxt);
            que.push((node2){i, bdList[i].nxt, t});
        }
        // while(!que.empty()) cout<<que.top().id1<<" "<<que.top().id2<<" "<<que.top().t<<endl, que.pop();return 0;
        while(!que.empty()){
            // cout<<++debug<<endl;
            while(dele[que.top().id1] || dele[que.top().id2]) que.pop();
            int u = que.top().id1, v = que.top().id2;
            que.pop(); cnt++;
            if(cnt == n - 1){
                if(bdList[u].speed < bdList[v].speed) swap(u, v);
                ll dis = (bdList[v].start - bdList[u].start + L) % L;
                ll deltaV = bdList[u].speed - bdList[v].speed;
                ll gcd = GCD(dis, deltaV);
                cout << (dis / gcd) << "/" << (deltaV / gcd) << endl;
                break;
            }
            node2 temp;
            double tt;
            if(bdList[u].id < bdList[v].id)
                temp.id1 = bdList[u].last, temp.id2 = v, temp.t = calcTime(bdList[u].last, v), del(u), dele[u] = true;
            else temp.id1 = u, temp.id2 = bdList[v].nxt, temp.t = calcTime(u, bdList[v].nxt), del(v), dele[v] = true;
            que.push(temp);
        }
    }
}