HNOI2016矿区（计算几何+对偶图）

题目链接

题目大意

给出一个平面图，每次询问一块区域内所有多边形面积的平方和除以所有多边形的面积和。
$n\le 2\times 10^5$

题解

对偶图神仙题orz……
平面图显然可以想到转对偶图做，转化的方法就是对于每条没有visit过的边，找到它的反向边，按照顺时针转动直到有一条新边出现，再沿着那条边走，直到走回来。
会发现，这样走的话只会走出两种区域，一种是平面图中的最小区域（也就是对偶图中的点），一种是把整个平面图框起来的区域。对于后者，我们在对偶图中建一个根对应它，所有在边界上的区域和它连边。

考虑怎么求值。对于一个询问，我们把所有在询问边界上边对应的对偶图中边删掉，那么就会形成若干连通块，要么整个连通块一起统计进答案，要么都不能被统计进答案。
不妨让询问边界上的边都从内向外连边。我们考虑对偶图的一棵dfs树，如果边界上的某条边是非树边，则不考虑。如果它是树边，若它从下往上连，那么答案加上其子树中所有节点的贡献；否则答案减去其子树中所有节点的贡献。
这是因为考虑从根开始往下搜索，如果搜索到了某条从下向上连的边，那么就说明其进入了某个连通块；否则就说明其走出了某个连通块。因此答案是对的。
注意对偶图有重边的情况！！！！（Debug了2小时，好菜）
复杂度$O(mlogm+k)$。

#include <bits/stdc++.h>
namespace IOStream {
	const int MAXR = 10000000;
	char _READ_[MAXR], _PRINT_[MAXR];
	int _READ_POS_, _PRINT_POS_, _READ_LEN_;
	inline char readc() {
	#ifndef ONLINE_JUDGE
		return getchar();
	#endif
		if (!_READ_POS_) _READ_LEN_ = fread(_READ_, 1, MAXR, stdin);
		char c = _READ_[_READ_POS_++];
		if (_READ_POS_ == MAXR) _READ_POS_ = 0;
		if (_READ_POS_ > _READ_LEN_) return 0;
		return c;
	}
	template<typename T> inline void read(T &x) {
		x = 0; register int flag = 1, c;
		while (((c = readc()) < '0' || c > '9') && c != '-');
		if (c == '-') flag = -1; else x = c - '0';
		while ((c = readc()) >= '0' && c <= '9') x = x * 10 - '0' + c;
		x *= flag;
	}
	template<typename T1, typename ...T2> inline void read(T1 &a, T2&... x) {
		read(a), read(x...);
	}
	inline int reads(char *s) {
		register int len = 0, c;
		while (isspace(c = readc()) || !c);
		s[len++] = c;
		while (!isspace(c = readc()) && c) s[len++] = c;
		s[len] = 0;
		return len;
	}
	inline void ioflush() { fwrite(_PRINT_, 1, _PRINT_POS_, stdout), _PRINT_POS_ = 0; fflush(stdout); }
	inline void printc(char c) {
		if (!c) return;
		_PRINT_[_PRINT_POS_++] = c;
		if (_PRINT_POS_ == MAXR) ioflush();
	}
	inline void prints(const char *s, char c) {
		for (int i = 0; s[i]; i++) printc(s[i]);
		printc(c);
	}
	template<typename T> inline void print(T x, char c = '\n') {
		if (x < 0) printc('-'), x = -x;
		if (x) {
			static char sta[20];
			register int tp = 0;
			for (; x; x /= 10) sta[tp++] = x % 10 + '0';
			while (tp > 0) printc(sta[--tp]);
		} else printc('0');
		printc(c);
	}
	template<typename T1, typename ...T2> inline void print(T1 x, T2... y) {
		print(x, ' '), print(y...);
	}
}
using namespace IOStream;
using namespace std;
typedef long long ll;
typedef pair<int, int> P;

struct HashTable {
	static const int BASE = 1 << 21, MOD = BASE - 1;
	ll key[BASE]; int val[BASE];
	inline int get_hash(ll x) {
		return (x >> 16 ^ x << 5 ^ x >> 1) & MOD;
	}
	inline int get_step(ll x) {
		return (x >> 15 ^ x << 6 ^ x >> 2) & MOD;
	}
	inline void ins(ll x, int v) {
		int h = get_hash(x), s = get_step(x) | 1;
		while (key[h]) (h += s) &= MOD;
		key[h] = x, val[h] = v;
	}
	inline int get(ll x) {
		int h = get_hash(x), s = get_step(x) | 1;
		while (key[h] != x) (h += s) &= MOD;
		return val[h];
	}
} hs;
const int MAXP = 200005, MAXN = 400005, MAXM = 1200005;
struct Linker { int u, v; double ang; } lnk[MAXM];
struct Edge { int fr, to, next, tp; } edge[MAXM];
int bel[MAXM], xx[MAXP], yy[MAXP], vis[MAXM], nxt[MAXM];
int arr[MAXP], head[MAXN], rt, n, m, K, tot, bcnt;
ll area[MAXN], sqr[MAXN], sum[MAXN];
vector<int> vec[MAXP];
inline bool cmp(int a, int b) { return lnk[a].ang < lnk[b].ang; }
inline void link(int u, int v) {
	lnk[tot] = (Linker) { u, v, atan2(yy[v] - yy[u], xx[v] - xx[u]) };
	vec[u].push_back(tot++);
}
void dfs(int u, int fa) {
	vis[u] = 1;
	sum[u] = area[u], sqr[u] = area[u] * area[u];
	for (int i = head[u]; ~i; i = edge[i].next) {
		int v = edge[i].to;
		if (vis[v]) continue;
		edge[i].tp = 1, edge[i ^ 1].tp = 2, dfs(v, u);
		sum[u] += sum[v], sqr[u] += sqr[v];
	}
}
inline void addedge(int u, int v) {
	edge[tot] = (Edge) { u, v, head[u], 0 };
	head[u] = tot++;
}
int main() {
	read(n, m, K);
	for (int i = 1; i <= n; i++) read(xx[i], yy[i]);
	for (int i = 1; i <= m; i++) {
		int u, v; read(u, v);
		link(u, v), link(v, u);
	}
	for (int i = 1; i <= n; i++) {
		sort(vec[i].begin(), vec[i].end(), cmp);
		for (int j = 1; j < (int)vec[i].size(); j++)
			nxt[vec[i][j]] = vec[i][j - 1];
		nxt[vec[i][0]] = vec[i].back();
	}
	int mm = tot; ll lstans = 0;
	for (int i = 0; i < mm; i++) if (!vis[i]) {
		++bcnt;
		for (int j = i; !vis[j]; j = nxt[j ^ 1]) {
			vis[j] = 1;
			bel[j] = bcnt;
			ll xa = xx[lnk[j].u], ya = yy[lnk[j].u];
			ll xb = xx[lnk[j].v], yb = yy[lnk[j].v];
			area[bcnt] += xa * yb - ya * xb;
		}
		if (area[bcnt] < 0) rt = bcnt;
	}
	tot = 0;
	memset(vis, 0, sizeof(vis));
	memset(head, -1, sizeof(head));
	for (int i = 0; i < mm; i++) if (bel[i] != bel[i ^ 1]) {
		addedge(bel[i], bel[i ^ 1]);
		hs.ins((ll)lnk[i].u * n + lnk[i].v, tot - 1);
	}
	dfs(rt, 0);
	while (K--) {
		int c; read(c); c = (c + lstans) % n + 1;
		ll fz = 0, fm = 0;
		for (int i = 0; i < c; i++) {
			read(arr[i]); arr[i] = (arr[i] + lstans) % n + 1;
			if (i > 0) {
				int p = hs.get((ll)arr[i - 1] * n + arr[i]);
				if (edge[p].tp == 1) fz -= sqr[edge[p].to], fm -= sum[edge[p].to];
				else if (edge[p].tp == 2) fz += sqr[edge[p].fr], fm += sum[edge[p].fr];
			}
		}
		int p = hs.get((ll)arr[c - 1] * n + arr[0]);
		if (edge[p].tp == 1) fz -= sqr[edge[p].to], fm -= sum[edge[p].to];
		else if (edge[p].tp == 2) fz += sqr[edge[p].fr], fm += sum[edge[p].fr];
		fm *= 2;
		ll g = __gcd(fz, fm);
		print(lstans = fz / g, fm / g);
	}
	ioflush();
	return 0;
}