luogu P2805 [NOI2009]植物大战僵尸（有向图的环&最大权闭合子图）

luogu P2805 [NOI2009]植物大战僵尸（有向图的环&最大权闭合子图）

题目大意

现在，我们将要考虑的问题是游戏中Zombies对Plants的进攻，请注意，本题中规则与实际游戏有所不同。游戏中有两种角色，Plants和Zombies，每个Plant有一个攻击位置集合，它可以对这些位置进行保护；而Zombie进攻植物的方式是走到植物所在的位置上并将其吃掉。

游戏的地图可以抽象为一个N行M列的矩阵，行从上到下用0到N–1编号，列从左到右用0到M–1编号；在地图的每个位置上都放有一个Plant，为简单起见，我们把位于第r行第c列的植物记为Pr, c。

Plants分很多种，有攻击类、防守类和经济类等等。为了简单的描述每个Plant，定义Score和Attack如下：

Score[Pr, c]

Zombie击溃植物Pr, c可获得的能源。若Score[Pr, c]为非负整数，则表示击溃植物Pr, c可获得能源Score[Pr, c]，若为负数表示击溃Pr, c需要付出能源 -Score[Pr, c]。

Attack[Pr, c]

植物Pr, c能够对Zombie进行攻击的位置集合。

Zombies必须从地图的右侧进入，且只能沿着水平方向进行移动。Zombies攻击植物的唯一方式就是走到该植物所在的位置并将植物吃掉。因此Zombies的进攻总是从地图的右侧开始。也就是说，对于第r行的进攻，Zombies必须首先攻击Pr, M-1；若需要对Pr, c（0≤c<M-1）攻击，必须将Pr,M-1, Pr, M-2 … Pr, c+1先击溃，并移动到位置(r, c)才可进行攻击。

在本题的设定中，Plants的攻击力是无穷大的，一旦Zombie进入某个Plant的攻击位置，该Zombie会被瞬间消灭，而该Zombie没有时间进行任何攻击操作。因此，即便Zombie进入了一个Plant所在的位置，但该位置属于其他植物的攻击位置集合，则Zombie会被瞬间消灭而所在位置的植物则安然无恙（在我们的设定中，Plant的攻击位置不包含自身所在位置，否则你就不可能击溃它了）。

Zombies的目标是对Plants的阵地发起进攻并获得最大的能源收入。每一次，你可以选择一个可进攻的植物进行攻击。本题的目标为，制定一套Zombies的进攻方案，选择进攻哪些植物以及进攻的顺序，从而获得最大的能源收入。

解题思路

由于消灭一些植物需要先消灭一些其他的植物，因此很容易想到最大权闭合图

但是直接用最大权闭合子图的话会发现一些问题，即有一些相互保护的植物，在最大权闭合子图的定义中我们是可以选择这些点的，但是实际上这些植物是绝对不可能被吃掉的，因此我们在建图之前需要提前拆去这些点，以及这些点的子点，因为这些点都是不可破坏的。最后做最大权闭合子图即可

AC代码

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
const int maxm=5e6+5;
const int inf=0x3f3f3f3f;
struct Edge{
    int to,nxt,cap,flow;
}edge[maxm];
int tol;
int head[maxn];
void init(){
    tol=2;
    memset(head,-1,sizeof(head));
}
void AddEdge(int u,int v,int w,int rw=0){
    edge[tol].to=v;edge[tol].cap=w;edge[tol].flow=0;
    edge[tol].nxt=head[u];head[u]=tol++;
    edge[tol].to=u;edge[tol].cap=rw;edge[tol].flow=0;
    edge[tol].nxt=head[v];head[v]=tol++;
}
int Q[maxn];
int dep[maxn],cur[maxn],sta[maxn];
bool bfs(int s,int t,int n){
    int front=0,tail=0;
    memset(dep,-1,sizeof(dep[0])*(n+1));
    dep[s]=0;
    Q[tail++]=s;
    while(front<tail){
        int u=Q[front++];
        for(int i=head[u];i!=-1;i=edge[i].nxt){
            int v=edge[i].to;
            if(edge[i].cap>edge[i].flow&&dep[v]==-1){
                dep[v]=dep[u]+1;
                if(v==t) return true;
                Q[tail++]=v;
            }
        }
    }
    return false;
}
int dinic(int s,int t,int n){
    int maxflow=0;
    while(bfs(s,t,n)){
        for(int i=0;i<n;i++) cur[i]=head[i];
        int u=s,tail=0;
        while(cur[s]!=-1){
            if(u==t){
                int tp=inf;
                for(int i=tail-1;i>=0;i--)
                {
                    tp=min(tp,edge[sta[i]].cap-edge[sta[i]].flow);
                }
                maxflow+=tp;
                for(int i=tail-1;i>=0;i--){
                    edge[sta[i]].flow+=tp;
                    edge[sta[i]^1].flow-=tp;
                    if(edge[sta[i]].cap-edge[sta[i]].flow==0) tail=i;
                }
                u=edge[sta[tail]^1].to;
            }
            else if(cur[u]!=-1&&edge[cur[u]].cap>edge[cur[u]].flow&&dep[u]+1==dep[edge[cur[u]].to]){
                sta[tail++]=cur[u];
                u=edge[cur[u]].to;
            }
            else{
                while(u!=s&&cur[u]==-1) u=edge[sta[--tail]^1].to;
                cur[u] = edge [cur[u]].nxt;
            }
        }
    }
    return maxflow;
}
int n,m;
bool dea[maxn];
inline int Hash(int x,int y){return m*x+y+1;}
int val[35][35];
vector<int> vec[35][35];
vector<int> G[maxn];
bool vis[maxn],vis2[maxn];
void dfs(int v)
{
	vis[v]=vis2[v]=true;
	for(auto u:G[v])
	{
		if(!vis2[u]) dfs(u);
		else if(vis[u]) dea[u]=true; 
	}
	vis[v]=false;
}
void dfs2(int v)
{
	dea[v]=true;
	for(auto u:G[v])
	{
		if(dea[u]) continue;
		dfs2(u);
	}
}
int32_t main()
{
	scanf("%d%d",&n,&m);
	memset(dea,0,sizeof(dea));
	int s=0,t=n*m+1;
	int ns;
	int x,y;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			scanf("%d%d",&val[i][j],&ns);
			if(j-1>=0) G[Hash(i,j)].push_back(Hash(i,j-1));
			while(ns--)
			{
				scanf("%d%d",&x,&y);
				G[Hash(i,j)].push_back(Hash(x,y));
				vec[i][j].push_back(Hash(x,y));
			}
		}
	}
	memset(vis,0,sizeof(vis));
	memset(vis2,0,sizeof(vis2));
	int ans=0;
	for(int i=0;i<n*m;i++) if(!vis[i])dfs(i);
	for(int i=0;i<n*m;i++) if(dea[i]) dfs2(i);
	init();
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			if(dea[Hash(i,j)]) continue;
			if(val[i][j]>0)AddEdge(s,Hash(i,j),val[i][j]),ans+=val[i][j];
			else AddEdge(Hash(i,j),t,-val[i][j]);
			if((j-1)>=0&&(!dea[Hash(i,j-1)])) AddEdge(Hash(i,j-1),Hash(i,j),inf);
			for(auto pps:vec[i][j])
			{
				if(!dea[pps]) AddEdge(pps,Hash(i,j),inf);
			}
		}
	}
	printf("%d\n",ans-dinic(s,t,t+1));
}