LuoguP2472 SCOI2007 蜥蜴

SevenDays_Coder

已于 2022-08-27 22:28:54 修改

阅读量114

点赞数 2

文章标签： c++

于 2022-08-27 22:20:25 首次发布

本文链接：https://blog.csdn.net/SevenDays_Coder/article/details/126562770

版权

蒟蒻第二篇博客，恶补网络流之后决定整个活

一、模型建立

网络流

这道题的难点在于它的限制是在点上而不是在边上，那我们考虑如何把点的限制转移成边的容量。

换个思维方式，这个点只能经过k次，那我们考虑将一个点拆成起点和终点，在它们之间搭建一条容量为k的边，就可以控制这个点经过的蜥蜴数量了。

1、建一个超级源点，向每只L发送一只蜥蜴，由源点向蜥蜴点的入口建一条容量为1的边

2、对于每个点，由它的终点向它能跳到的点的起点建一条容量为INF的边

3、对于每一个点，由它的起点向它的终点建一条容量为高度的边

4、建一个超级汇点，对于每一个能跳到矩阵外的点，建一条由该点终点向汇点的容量为INF的边

最后结果为蜥蜴数减最大流

二、注意事项

建模之后代码就比较好写了。

几个提醒

1、读入要注意行末换行符

2、数组大小，点为N*N*2，边为N*N*N*N*2

(~~其实实际就差不多4e4左右就能过Luogu了,但保险起见开满~~)

3、平面距离!即二维欧几里得距离!计算距离时尽量避免开方运算

时间复杂度O(N*M*M)

三、AC代码

#include<bits/stdc++.h>
const int N=30;
const int INF=1e9;
const int M=2e4+5;
using namespace std;
int r,c,d;
inline int Read()//读入多位数 
{
	int x=0;
	char ch=getchar();
	while(!isdigit(ch))
		ch=getchar();
	while(isdigit(ch))
	{
		x=(x<<1)+(x<<3)+ch-'0';
		ch=getchar();
	}
	return x;
}
inline int readi()//读入一位数 
{
	char ch=getchar();
	while(!isdigit(ch))
		ch=getchar();
	return ch-'0';
}
inline char readc()//读入字符 
{
	char c=getchar();
	while(c!='.'&&c!='L')
		c=getchar();
	return c;
}
//以上读入写发可能过于复杂，但很保险，不推荐 
int n,m;
int H[N*N],X[N*N],Y[N*N],Id[N][N]; 
int Liz[N*N];//蜥蜴点 
void Init()//读入 
{
	r=Read(),c=Read(),d=Read();
	for(int i=1;i<=r;i++)
		for(int j=1;j<=c;j++)
		{
			H[++n]=readi();
			X[n]=i;
			Y[n]=j;
			Id[i][j]=n;
		}
	for(int i=1;i<=r;i++)
		for(int j=1;j<=c;j++)
			if(readc()=='L')
				Liz[++m]=Id[i][j];
}
int Head[(N*N)<<1],To[M<<1],Nxt[M<<1],W[M<<1],Etot=1;
void Addedge(int x,int y,int z)//建边 
{
	W[++Etot]=z;
	To[Etot]=y;
	Nxt[Etot]=Head[x];
	Head[x]=Etot;
	W[++Etot]=0;
	To[Etot]=x;
	Nxt[Etot]=Head[y];
	Head[y]=Etot;//反边 
}
int s,t;
int Pgg(int x,int y)//求两点距离 
{
	return ((X[x]-X[y])*(X[x]-X[y]))+((Y[x]-Y[y])*(Y[x]-Y[y])); 
    //不开根号，下面把距离平方一下就好了 
}
void Build()//建图 
{
	t=n*2+1;//汇点 
	for(int i=1;i<=m;i++)//源点->蜥蜴点起点 
		Addedge(s,Liz[i],1);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			if(i!=j&&d*d>=Pgg(i,j)) //能跳到 
				Addedge(i+n,j,INF);//终点->被跳点起点 
	for(int i=1;i<=n;i++) 
	{
		if(H[i])//有石头 
			Addedge(i,i+n,H[i]);//起点->终点 
		if(X[i]<=d||Y[i]<=d||X[i]+d>r||Y[i]+d>c)//能跳出去 
			Addedge(i+n,t,INF);//终点->汇点 
	}
}
//最大流模板（数据量小所以基本没加各种优化）
queue<int>Q;
int Dep[(N*N)<<1];
bool BFS()
{
	memset(Dep,0,sizeof(Dep)); 
	Dep[s]=1;
	Q.push(s);
	while(!Q.empty())
	{
		int u=Q.front(),v;
		Q.pop();
		for(int i=Head[u];i;i=Nxt[i])
			if(!Dep[v=To[i]]&&W[i]>0)
			{
				Dep[v]=Dep[u]+1;
				Q.push(v);
			}
	}
	return Dep[t];
}
int DFS(int u,int pfl)
{
	if(u==t)
		return pfl;
	int flow=0;
	for(int i=Head[u];i;i=Nxt[i])
	{
		int v=To[i];
		if(Dep[v]!=Dep[u]+1||W[i]<=0)
			continue;
		int del=DFS(v,min(W[i],pfl));
		flow+=del;
		pfl-=del;
		W[i]-=del;
		W[i^1]+=del;
		if(pfl==0)
			break;
	}
	if(flow==0)
		Dep[u]=0;
	return flow;
}
int Dinic()
{
	int res=0;
	while(BFS())
		res+=DFS(s,INF);
	return res;
}
int main()
{
	Init();
	Build();
	cout<<m-Dinic()<<endl;
 	return 0;
}