BZOJ 4541: [Hnoi2016]矿区 平面图转对偶图+DFS树

Posted 2020-09-22 Oncle_Ha

4541: [Hnoi2016]矿区

Time Limit: 30 Sec  Memory Limit: 512 MB
Submit: 433  Solved: 182
[Submit][Status][Discuss]

Description

　　平面上的矿区划分成了若干个开发区域。简单地说，你可以将矿区看成一张连通的平面图，平面图划分为了若
干平面块，每个平面块即为一个开发区域，平面块之间的边界必定由若干整点(坐标值为整数的点)和连接这些整点
的线段组成。每个开发区域的矿量与该开发区域的面积有关：具体而言，面积为s的开发区域的矿量为 s^2。现在
有 m 个开采计划。每个开采计划都指定了一个由若干开发区域组成的多边形，一个开采计划的优先度被规定为矿
量的总和÷开发区域的面积和；例如，若某开采计划指定两个开发区域，面积分别为 a和b，则优先度为(a^2+b^2)
/(a+b)。由于平面图是按照划分开发区域边界的点和边给出的，因此每个开采计划也只说明了其指定多边形的边界
，并未详细指明是哪些开发区域（但很明显，只要给出了多边形的边界就可以求出是些开发区域）。你的任务是求
出每个开采计划的优先度。为了避免精度问题，你的答案必须按照分数的格式输出，即求出分子和分母，且必须是
最简形式（分子和分母都为整数，而且都消除了最大公约数；例如，若矿量总和是 1.5，面积和是2，那么分子应
为3，分母应为4；又如，若矿量和是 2，面积和是 4，那么分子应为 1，分母应为 2）。由于某些原因，你必须依
次对每个开采计划求解（即下一个开采计划会按一定格式加密，加密的方式与上一个开采计划的答案有关）。具体
的加密方式见输入格式。

Input

　　第一行三个正整数 n,m,k，分别描述平面图中的点和边，以及开采计划的个数。接下来n行，第 i行(i=1,2,…
,n)有两个整数x_i, y_i,  表示点i的坐标为(x_i, y_i)。接下来m行，第 i行有两个正整数a,b，表示点a和b 之间
有一条边。接下来一行若干个整数，依次描述每个开采计划。每个开采计划的第一个数c指出该开采计划由开发区
域组成的多边形边界上的点的个数为d=(c+P) mod n + 1；接下来d个整数，按逆时针方向描述边界上的每一个点：
设其中第i个数为z_i，则第i个点的编号为(z_i+P) mod n + 1。其中P 是上一个开采计划的答案中分子的值；对于
第 1 个开采计划，P=0。

Output

　　对于每个开采计划，输出一行两个正整数，分别描述分子和分母。

Sample Input

9 14 5
0 0
1 0
2 0
0 1
1 1
2 1
0 2
1 2
2 2
1 2
2 3
5 6
7 8
8 9
1 4
4 7
5 8
3 6
6 9
4 8
1 5
2 6
6 8
3 3 0 4 7 1 3 4 6 4 8 0 4 3 6 2 3 8 0 4 6 2 5 0 4 5 7 6 3

Sample Output

1 1
1 2
1 1
9 10
3 4

HINT

 

输入文件给出的9个点和14条边描述的平面图如下所示：

第一个开采计划，输入的第1个值为3，所以该开采计

划对应的多边形有(3+0) mod 8 +1=4个点，将接下的4个数3,0,4,7，分别代入(z_i+0) mod n + 1得到4个点的编号

为4,1,5,8。计算出第一个开采计划的分子为1，分母为1。类似地，可计算出余下开采计划的多边形的点数和点的

编号：第二个开采计划对应的多边形有3个点，编号分别为5, 6, 8。第三个开采计划对应的多边形有6个点，编号

分别为1, 2, 6, 5, 8, 4。第四个开采计划对应的多边形有5个点，编号分别为1, 2, 6, 8, 4。第五个开采计划对

应的多边形有6个点，编号分别为1, 5, 6, 8, 7, 4。

对于100%的数据，n, k ≤ 2×10^5, m ≤ 3n-6, |x_i|, |y

_i| ≤ 3×10^4。所有开采计划的d之和不超过2×10^6。保证任何开采计划都包含至少一个开发区域，且这些开发

区域构成一个连通块。保证所有开发区域的矿量和不超过 2^63-1。保证平面图中没有多余的点和边。保证数据合

法。由于输入数据量较大，建议使用读入优化。

 

Source

 题意：一个开采计划优先度为$\frac{\sum S^2(X)}{\sum S(X)}$其中X∈A,S(x)为开发区域的面积。

 想法：将原平面图G转对偶图G‘后，一个域被算入的条件就是不与外面的无穷域Rt连通。如果以无穷域为根，DFS遍历得到的树T。对于在G‘中与Rt相连的要么是Rt在T中的儿子，要么是T中叶子节点。理由：DFS树没有横叉边。同时因为这个理由，一个开采计划就一定是树上一个连通块。所以只要保证这个连通块被割下来就好了咯。

具体过程：

1.平面图G转对偶图G’。(不会戳这里)

2.DFS遍历图G‘得到树T，每个节点维护$S(x)$，$S^2(x)$子树和

3.回答询问。对于有向边(u->v)，先找到其在G‘中对应的上下域(a,b)。如果(a,b)是非树边，那么就可以忽略，毕竟不会影响答案统计。是树边，就要分情况累加答案。

先分析一下：假设(u->v)方向的都割掉连通块与叶子节点通路上的边，那么就肯定是减去b的子树和，反之加上a的子树和。如果(u->v)的不是，答案便要取反。所以这样统计是可行的。判断条件：a是不是b的父亲。

总复杂度$O(M\log M+\sum d)$

 

#include< algorithm>
#include< cmath >
#include< cstdio >
#include< vector >

#define gec getchar
#define FILE(F) freopen(F".in","r",stdin),freopen(F".out","w",stdout)
#define DEBUG fprintf(stderr,"Passing [%s] in Line (%d)\n",__FUNCTION__,__LINE__);

typedef long long ll;
template
inline void read(T&x)
{
	x=0;bool f=0;char c=gec();
	for(;c<‘0‘||c>‘9‘;c=gec())f=(c==‘-‘);
	for(;c>=‘0‘&&c<=‘9‘;c=gec())x=x*10+c-‘0‘;
	x=f?-x:x;
}
const int MAXN(200010),MAXM(600010);
int n,m,k,a,b;ll P,Q;
struct Coor
{
	int x,y;
	Coor(){};
	Coor(int a,int b):x(a),y(b){};	
inline Coor operator +(const Coor&A){return Coor(x+A.x,y+A.y);}
inline Coor operator -(const Coor&A){return Coor(x-A.x,y-A.y);}
inline Coor operator *(const double k){return Coor(k*x,k*y);}
inline Coor operator /(const double k){return Coor(x/k,y/k);}
}PA[MAXN];
ll acorss(Coor A,Coor B)
{return (ll)A.x*B.y-(ll)A.y*B.x;}
ll dot(Coor A,Coor B)
{return (ll)A.x*B.x+(ll)A.y*B.y;}
//===================================================计算几何
struct Next
{
	int u,v,id;double ang;
	Next(){}
	Next(int a,int b,int k)
	{u=a; v=b; id=k; ang=atan2(PA[u].x-PA[v].x,PA[u].y-PA[v].y);}
inline bool operator <(const Next &A)const {return ang<A.ang;}
}e[MAXM<<1]; 
std::vectorEdge[MAXN];
int cnt=1,Nex[MAXM<<1],col[MAXM<<1];bool flag[MAXM<<1];
int etot,rt;ll S[MAXN<<1],Sp[MAXN<<1];
struct Node{int nd,nx;}bot[MAXM<<1];
int tot=1,first[MAXN<<1],fa[MAXN<<1];bool vis[MAXN<<1];//F-E+V=2
void add(int a,int b)
{bot[++tot]=(Node){b,first[a]};first[a]=tot;}
namespace planar_graph
{
	int Two_Find(int num,Next &x)
	{
		int l=0,r=Edge[num].size()-1,mid,Ans;
		for(;l<=r;)if(x<Edge[num][mid=(l+r)>>1])r=mid-1;else l=mid+1,Ans=mid;
		return Ans;
	}
	void Get_planar()
	{
		for(int i=2;i<=cnt;i++)
		if(!col[i])
		{
			int now=i;col[i]=++etot;ll tmp_s=0;
			for(;;)
			{
				now=Nex[now];col[now]=etot;
				if(e[now].v==e[i].u)break;//成环
				tmp_s+=acorss(PA[e[now].v]-PA[e[i].u],PA[e[now].u]-PA[e[i].u]);
			}
			S[etot]=tmp_s;
			if(tmp_s<=0)rt=etot;//无穷域
		}
		for(int i=2;i<=cnt;i++)
			add(col[i],col[i^1]);//相邻域连边
	}
	void build()
	{
		for(int i=1;i<=m;i++)
		{
			read(a);read(b);
			++cnt;e[cnt]=Next(a,b,cnt);
			Edge[a].push_back(e[cnt]);
			++cnt;e[cnt]=Next(b,a,cnt);
			Edge[b].push_back(e[cnt]);
		}
		for(int i=1;i<=n;i++)
			std::sort(Edge[i].begin(),Edge[i].end());
		for(int i=2;i<=cnt;i++)
		{
			Nex[i]=Two_Find(e[i].v,e[i^1])-1;
			if(Nex[i]<0)Nex[i]=Edge[e[i].v].size()-1;
			Nex[i]=Edge[e[i].v][Nex[i]].id;
		}//找下一条边
		Get_planar();
	}
}
//===================================================平面图转对偶图
namespace WW_HASH
{
	const int MP(980321),HM(233333);
	int nx[MAXM<<1],head[MP];
	void build_HASH()
	{
		for(int i=2,v;i<=cnt;i++)
		{
			v=((ll)e[i].u*HM%MP+e[i].v)%MP;
			nx[i]=head[v];head[v]=i;
		}
	}
	int Find(int a,int b)
	{
		int v=((ll)a*HM%MP+b)%MP;
		for(v=head[v];v;v=nx[v])
		if(e[v].u==a&&e[v].v==b)return v;
		exit(0);//不存在的
	}
}
void Dfs(int x)
{
	vis[x]=1; Sp[x]=S[x]*S[x]; S[x]<<=1;
	for(int v=first[x];v;v=bot[v].nx)
	if(!vis[bot[v].nd])
	{
		fa[bot[v].nd]=x;
		flag[v]=flag[v^1]=1;
		Dfs(bot[v].nd);
		S[x]+=S[bot[v].nd]; 
		Sp[x]+=Sp[bot[v].nd];
	}
}
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
const int SUMD(2000010);
int d,z[SUMD];
int main()
{
#ifndef ONLINE_JUDGE
	FILE("C");
#endif	
	read(n);read(m);read(k);
	for(int i=1;i<=n;i++)
		read(PA[i].x),read(PA[i].y);
	planar_graph::build();
	WW_HASH::build_HASH(); Dfs(rt);
//	DEBUG;
	for(int i=1;i<=k;i++)
	{
		read(d);d=(d+P)%n +1;
		for(int j=1;j<=d;j++)
			read(z[j]),z[j]=(z[j]+P)%n +1;
		z[0]=z[d];
		P=Q=0;
		for(int j=1,id;j<=d;j++)
		{ 
			id=WW_HASH::Find(z[j-1],z[j]);
//			fprintf(stderr,"id:%d\n",id);
			if(!flag[id])continue;//非树边
			if(fa[col[id]]==col[id^1])
			P-=Sp[col[id]],Q-=S[col[id]]; else
			P+=Sp[col[id^1]],Q+=S[col[id^1]];
//			fprintf(stderr,"%lld %lld\n",P,Q);
		}
		if(P<0)P=-P,Q=-Q;
//		DEBUG;
//		fprintf(stderr,"%lld %lld\n",P,Q);
		ll g=gcd(P,Q);P/=g;Q/=g;
		printf("%lld %lld\n",P,Q);
	}
	//DEBUG;
	return 0;
}