题解

之前尝试HNOI2016的时候弃坑的一道，然后给补回来
（为啥我一些计算几何就写得好长，不过我写啥都长orz）

我们尝试给这个平面图分域，好把这个平面图转成对偶图

怎么分呢，我今天也是第一次会
首先我们把一条边拆成两条有向边，每个点的出边按照弧度排序

显然，相邻的两条边一定夹着一个域

我们从一个没有找到所在域的边（这里的边是有方向的，一条边的域我定义为这条边逆时针方向的多边形），然后到了目标节点后，我们把这条边变成目标节点的出边来二分一下这条边顺时针第一条边是什么边，这样因为平面图是联通的，会走回起点，走的这一圈就是多边形的边，同时我们可以计算多边形的面积，如果面积为负那么说明这个域是除了平面图以外广袤的平面

这样的话，我们可以通过一条边的两个方向对应着不同的两个域建立起域与域的链接关系，我们跑一棵生成树出来

然后统计的时候枚举多边形的每条边，看看这条边是不是在生成树上，不在就忽略，在的话一定是链接一个多边形内的域u和多边形的外的域v，如果fa[v] = u那么我们减去siz[v]，否则加上siz[u]

计算面积的时候防止/2的误差可以面积*2这么算，最后分子乘上2

注意域和域之间会有重边

代码

#include <bits/stdc++.h>
#define enter putchar('\n')
#define space putchar(' ')
#define pii pair<int,int>
#define fi first
#define se second
#define MAXN 200005
#define pb push_back
#define mp make_pair
#define eps 1e-8
//#define ivorysi
using namespace std;
typedef long long int64;
typedef double db;
template<class T>
void read(T &res) {
    res = 0;T f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9') {
        res = res * 10 + c - '0';
        c = getchar();
    }
}
template<class T>
void out(T x) {
    if(x < 0) {x = -x;putchar('-');}
    if(x >= 10) out(x / 10);
    putchar('0' + x % 10);
}
bool dcmp(db a,db b) {
    return fabs(a - b) < 1e-8;
}
struct Point {
    int64 x,y;
    Point(){}
    Point(int64 _x,int64 _y) {
        x = _x;y = _y;
    }
    friend Point operator + (const Point &a,const Point &b) {
        return Point(a.x + b.x,a.y + b.y);
    }
    friend Point operator - (const Point &a,const Point &b) {
        return Point(a.x - b.x,a.y - b.y);
    }
    friend int64 operator * (const Point &a,const Point &b) {
        return a.x * b.y - a.y * b.x;
    }
    friend int64 dot(const Point &a,const Point &b) {
        return a.x * b.x + a.y * b.y;
    }
}P[MAXN];
vector<pair<db,int> >ver[MAXN];
vector<int> id[MAXN],poly;
vector<pii > L;

int N,M,K,Ncnt;
struct node {
    int to,next;
}E[MAXN * 6];
int head[MAXN * 4],sumE,fa[MAXN * 4];
int64 siz[MAXN * 4],val[MAXN * 4];
int vis[MAXN * 4],tims;
void add(int u,int v) {
    E[++sumE].to = v;
    E[sumE].next = head[u];
    head[u] = sumE;
}
int64 gcd(int64 a,int64 b) {
    return b == 0 ? a : gcd(b,a % b);
}
void Init() {
    read(N);read(M);read(K);
    for(int i = 1 ; i <= N ; ++i) {
        scanf("%lld%lld",&P[i].x,&P[i].y);
    }
    int u,v;
    for(int i = 1 ; i <= M ; ++i) {
        read(u);read(v);
        ver[u].pb(mp(atan2((P[v] - P[u]).y,(P[v] - P[u]).x),v));
        ver[v].pb(mp(atan2((P[u] - P[v]).y,(P[u] - P[v]).x),u));
    }
    for(int i = 1 ; i <= N ; ++i) {
        sort(ver[i].begin(),ver[i].end());
        id[i].resize(ver[i].size());
    }
}
int find_pos(int id,db t) {
    int L = 0,R = ver[id].size() - 1;
    while(L < R) {
        int mid = (L + R) >> 1;
        if(dcmp(ver[id][mid].fi,t)) return mid;
        if(ver[id][mid].fi > t + eps) R = mid - 1;
        else L = mid + 1;
    }
    return L;
}
int find_Edge(int u,int v) {
    db t = atan2((P[v] - P[u]).y,(P[v] - P[u]).x);
    return id[u][find_pos(u,t)];
}
void dfs(int u) {
    vis[u] = 1;
    siz[u] = val[u];
    for(int i = head[u] ; i ; i = E[i].next) {
        int v = E[i].to;
        if(!vis[v]) {
            fa[v] = u;
            dfs(v);
            siz[u] += siz[v];
        }
    }
}
void Solve() {
    ++Ncnt;
    for(int i = 1 ; i <= N ; ++i) {
        int s = ver[i].size();
        for(int j = 0 ; j < s ; ++j) {
            if(!id[i][j]) {
                L.clear();L.pb(mp(i,j));
                pair<db,int> p = ver[i][j];
                int st = i,to = p.se;
                int64 siz = 0;
                while(1) {
                    db t = atan2((P[st] - P[to]).y,(P[st] - P[to]).x);
                    siz += P[st] * P[to];
                    int pos = find_pos(to,t);
                    --pos;if(pos < 0) pos += ver[to].size();
                    L.pb(mp(to,pos));
                    p = ver[to][pos];
                    st = to;to = p.se;
                    if(st == i) break;
                }
                int y;
                if(siz < 0) y = 1;
                else y = ++Ncnt;
                for(int k = 0 ; k < L.size() ; ++k) id[L[k].fi][L[k].se] = y;
                if(y != 1) val[y] = siz * siz;
            }
        }
    }
    for(int i = 1 ; i <= N ; ++i) {
        for(int j = 0 ; j < ver[i].size() ; ++j) {
            pair<db,int> p = ver[i][j];
            int u = id[i][j],v = find_Edge(p.se,i);
            add(u,v);
        }
    }
    dfs(1);
    int64 ans = 0;
    int64 d;
    memset(vis,0,sizeof(vis));tims = 0;
    while(K--) {
        ++tims;
        poly.clear();
        read(d);d = (d % N + ans % N) % N + 1;
        int64 u;
        for(int i = 1 ; i <= d ; ++i) {
            read(u);u = (u % N + ans % N) % N + 1;
            poly.pb(u);
        }
        poly.pb(poly[0]);
        int s = poly.size();
        int64 down = 0,up = 0;
        for(int i = 0 ; i < s - 1 ; ++i) {
            down += P[poly[i]] * P[poly[i + 1]];
            int u = find_Edge(poly[i],poly[i + 1]),v = find_Edge(poly[i + 1],poly[i]);
            if(fa[v] == u || fa[u] == v) {
                if(fa[v] == u && vis[v] != tims) {up -= siz[v];vis[v] = tims;}
                else if(fa[u] == v && vis[u] != tims) {up += siz[u];vis[u] = tims;}
            }
        }
        if(up % 2 == 0) up /= 2;
        else down *= 2;
        int64 g = gcd(up,down);
        down /= g;up /= g;
        out(up);space;out(down);enter;
        ans = up;
    }
}
int main() {
#ifdef ivorysi
    freopen("mine4.in","r",stdin);
#endif
    Init();
    Solve();
    return 0;
}