COCI CONTEST #3 29.11.2014 KAMIONI

题目描述

A国的城市可以看做是数轴上的整数点，有n辆卡车在公路上往返行驶，它们只能在到达某个城市才能掉头，掉头是不需要时间的，而且卡车在途中不能停下来。这n辆卡车初始时可能位于不同的城市，在某个时刻它们同时出发，每辆卡车每分钟可以到达下一个城市，即每分钟可以行使单位1的路程。当卡车到达终点时，它将会进入时空隧道，瞬间消失。给出每辆卡车的行驶的路径，即卡车的起点、中途每次掉头的点及终点，有m次查询，每次查询指定两辆卡车，问它们一共相遇多少次？
注意：卡车相遇点不一定是城市。另外，相遇时其中一辆卡车进入时光隧道不算相遇；起始瞬间两辆卡车位于同一地点不算相遇；其中一辆卡车正好掉头不算相遇。
n<=100000,m<100000,城市的编号在[1,10^9]之间。每辆卡车路径掉头的次数不超过3*10^5；所有卡车掉头的总次数之和不超过3*10^5.

输入：

第一行两个整数n，m，表示卡车的数量和查询的次数。
接下来n行，每行的第一个数为Ki（2<=Ki<=3*10^5），表示卡车的路径包含Ki个点，接下来有Ki个数，每个数在区间[1,10^9]之间，按顺序表示卡车行驶时经过的城市，包括起点和终点。
所有Ki之和超过3*10^5
接下来m行，每行两个整数，表示查询这两辆卡车一共相遇多少次。

输出：

对每次查询，输出一个整数，表示它们相遇次数。
50%的数据，n<100,Ki<1000,m<1000

思路：

首先我们应该将每一辆车的转折点按照发生时间来排序。讲每一个查询都保存下来，当然重复的我们只留一个去计算，其余的我们应当保存在一个与保留的那一个有关的数据结构里。顺便提一下，做这道题是一定要估计好空间复杂度，防止被卡空间。然后在保存一个询问的时候只保存在拐点少的那个的名下。然后枚举每一个拐点就可以了。
然后我们分析时间复杂度：
$如果某个卡车的转折点小于\sqrt{k}个，即使和它名下存的查询关系多于\sqrt{k}个，但是它在转折点数组中的出现次数一定小于\sqrt{k}次。$
$如果某个卡车的转折点多于\sqrt{k}个，即使它在转折点一定枚举\sqrt{k}+次，但是和它有查询关系的卡车一定小于\sqrt{k}个。$
通过以上分析，我们知道均摊的时间复杂度不会超过$\sqrt{k}个$。所以总的时间复杂度就是$O(k^{\frac{3}{2}})$.

代码：（用hash表实现去重以及保存询问）

#include<algorithm>
#include<map>
#include<cstdio>
#include<vector>
#define LL long long
#define PII pair<int, int>
const int MAXN = 300010;
using namespace std;
struct event {
    int id, p, dir; //id->trucks' number; p->position; dir->direction
    LL time;
    bool operator < (const event &rhs) const
    {
        if(time != rhs.time) return time < rhs.time;
        return dir > rhs.dir;
    }
    event(){}
    event(int a, int b, int c, LL d){id = a, p = b, dir = c; time = d;}
};
int h[2000000];
PII hsh[2000000];
int hshit(PII t)
{
    int p = 1LL * (t.second - t.first) * t.first * 12580 % 2000000;
    while(h[p] && hsh[p] != t) p = (p + 1) % 2000000;
    ++ h[p];
    hsh[p] = t;
    return p;
}
struct query {
    int id, was_left, qid;
    query() {}
    query(int a, int b, int c) { id = a; was_left = b; qid = c; }
};
struct List {
    int id, num;
    vector<int> index;
    List *next;
    List(){next = NULL; id = num = -1;}
}*Adj[MAXN], *hs[2000000];
struct truck
{
    int k, p, dir;
    LL time;
    vector<query> queries;
} trucks[MAXN];
inline void GET(int &n)
{
    n = 0; char c;
    do c = getchar(); while(c > '9' || c < '0');
    while(c >= '0' && c <= '9') {n = n*10 + c - '0'; c = getchar();}
}
int n, m;
void init(event &e)
{
    trucks[e.id].p = e.p;
    trucks[e.id].dir = e.dir;
    trucks[e.id].time = e.time;
}
int check(const truck &a, const truck &b, LL pretime, int predir)
{
    if (!b.dir && pretime >= b.time)
        return 0;
    int b_pos, a_pos;
    if (!b.dir)
    {
        b_pos = b.p;
        a_pos = (a.time - b.time) *(-predir) + a.p;
    }
    else
    {
        a_pos = a.p;
        b_pos = (a.time - b.time) * b.dir + b.p;
    }
    return b_pos < a_pos ? -1 : 1;
}
int ans[MAXN];
void solve(const truck &t, query &q, LL pretime, int predir)
{
    int is_left = check(t, trucks[q.id], pretime, predir);
    ans[q.qid] += (q.was_left * is_left == -1);
    q.was_left = is_left;
}
int main()
{
    vector<event> events;
    GET(n); GET(m);
    int x, newx;
    LL tsum;
    event e;
    for(int i = 0; i < n; ++ i)
    {
        tsum = 0;
        GET(trucks[i].k); GET(x);
        for(int j = 0; j < trucks[i].k - 1; ++ j)
        {
            GET(newx);
            e = event(i, x, x < newx ? 1 : -1, tsum);
            if(!j) init(e);
            else events.push_back(e);
            tsum += abs(x - newx);
            x = newx;
        }
        e = event(i, x, 0, tsum);
        events.push_back(e);
    }
    int a, b;
    for(int i = 0; i < m; i ++)
    {
        GET(a); GET(b);
        -- a; -- b;
        if(a > b) swap(a, b);
        int t = hshit(PII(a, b));
        if(h[t] > 1) {
            hs[t]->num ++;
            hs[t]->index.push_back(i);
            continue;
        }
        else {
            if(!Adj[a]) {
                Adj[a] = new List();
                Adj[a]->num = 1;
                Adj[a]->id = b;
                hs[t] = Adj[a];
                hs[t]->index.push_back(i);
            }
            else {
                List *p = new List();
                p->next = Adj[a]->next;
                p->id = b;
                p->num = 1;
                Adj[a]->next = p;
                hs[t] = p;
                hs[t]->index.push_back(i);
            }
        }
        if (trucks[a].k > trucks[b].k) swap(a, b);
        trucks[a].queries.push_back(query(b, trucks[b].p < trucks[a].p ? -1 : 1, i));
    }
    sort(events.begin(), events.end());
    for(int i = 0; i < events.size(); i ++)
    {
        e = events[i];
        LL prev_time = trucks[e.id].time;
        int prev_dir = trucks[e.id].dir;
        init(e);
        for(int i = 0; i < trucks[e.id].queries.size(); i ++)
        {
            query &q = trucks[e.id].queries[i];
            solve(trucks[e.id], q, prev_time, prev_dir);
        }
    }
    int sz;
    for(int i = 0; i < n; i ++)
        for(List *p = Adj[i]; p; p = p->next) {
            sz = p->index.size();
            for(int j = 1; j < sz; j ++)
                ans[p->index[j]] = ans[p->index[0]];
        }
    for(int i = 0; i < m; ++i)
        printf("%d\n", ans[i]);
    return 0;
}