题目描述

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

思路：

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

代码：（用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->directionLL 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;
}