Bzoj 1565: [NOI2009]植物大战僵尸 最大权闭合图,拓扑排序

题目: http://cojs.tk/cogs/problem/problem.php?pid=410

410. [NOI2009] 植物大战僵尸

★★★   输入文件：pvz.in   输出文件：pvz.out   简单对比
时间限制：2 s   内存限制：512 MB

【问题描述】

Plants vs. Zombies（PVZ）是最近十分风靡的一款小游戏。Plants（植物）和Zombies（僵尸）是游戏的主角，其中Plants防守，而Zombies进攻。该款游戏包含多种不同的挑战系列，比如Protect Your Brain、Bowling等等。其中最为经典的，莫过于玩家通过控制Plants来防守Zombies的进攻，或者相反地由玩家通过控制Zombies对Plants发起进攻。

现在，我们将要考虑的问题是游戏中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的进攻方案，选择进攻哪些植物以及进攻的顺序，从而获得最大的能源收入。

【输入文件】

输入文件pvz.in的第一行包含两个整数N,M，分别表示地图的行数和列数。

接下来N×M行描述每个位置上植物的信息。第r×M+c+ 1行按照如下格式给出植物Pr,c的信息：第一个整数为Score[Pr,c],第二个整数为集合Attack[Pr,c]中的位置个数w，接下来w个位置信息（r’,c’），表示Pr,c可以攻击位置第r’行第c’列。

【输出文件】

输出文件pvz.out仅包含一个整数，表示可以获得的最大能源收入。注意，你也可以选择不进行任何攻击，这样能源收入为0。

【输入样例】

3 2

10 0

20 0

-10 0

-5 1 0 0

100 1 2 1

100 0

【输出样例】

25

【样例说明】

在样例中,植物P1,1可以攻击位置(0,0),P2, 0可以攻击位置(2,1)。

一个方案为，首先进攻P1,1,P0,1，此时可以攻击P0,0。共得到能源收益为(-5)+20+10 = 25。注意,位置(2,1)被植物P2,0保护，所以无法攻击第2行中的任何植物。

【大致数据规模】

约20%的数据满足1 ≤N,M≤ 5；

约40%的数据满足1 ≤N,M≤ 10；

约100%的数据满足1 ≤N≤ 20，1 ≤M≤ 30，-10000 ≤Score≤ 10000

题解：

最大权闭合图+拓扑排序

首先，这道题中关于位置之间有依赖关系。比如在题目中要攻击(0,0)，必须先攻击(1,1)。还有先把靠右的吃掉，才能吃左侧的。

题中的 保护关系 和 先右后左关系 可以想到 最大权闭合图。（要吃掉某个 植物a 必须先吃掉 植物b(在a的右边或保护a的植物),我们要从a连边到b）

但是这道题中有环，我们可以在 反向边上跑拓扑序 来把 在环中 或 被环直接或间接指向 的点去除(这些植物一定不能吃掉)。

判环好像可以用传递闭包。。。

#include<bits/stdc++.h>
using namespace std;
#define MAXN 620
#define INF 1e9
struct Ts
{
    int begin,end,next;
}ts[360010];
struct node
{
    int begin,end,value,next;
}edge[721210];
int cnt,cnt1,Head[MAXN],Head1[MAXN],Id[MAXN],q[MAXN],dis[MAXN],cur[MAXN],Score[MAXN],S,T,m,N,ans;
bool use[MAXN];
void addts(int bb,int ee)
{
    Id[ee]++;
    ts[++cnt1].begin=bb;ts[cnt1].end=ee;ts[cnt1].next=Head1[bb];Head1[bb]=cnt1;
}
void addedge(int bb,int ee,int vv)
{
    edge[++cnt].begin=bb;edge[cnt].end=ee;edge[cnt].value=vv;edge[cnt].next=Head[bb];Head[bb]=cnt;
}
void addedge1(int bb,int ee,int vv)
{
    //Id[bb]++;
    addedge(bb,ee,vv);addedge(ee,bb,0);
}
int read()
{
    int s=0,fh=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')fh=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){s=s*10+(ch-'0');ch=getchar();}
    return s*fh;
}
int xy(int x,int y){return (x-1)*m+y;}
void Toposort()
{
    int head=0,tail=0,u,i,v;
    for(i=1;i<=T;i++)if(Id[i]==0)q[++tail]=i;
    while(head!=tail)
    {
        head++;if(head==610)head=0;
        u=q[head];use[u]=true;
        if(Score[u]>0)ans+=Score[u];
        for(i=Head1[u];i!=-1;i=ts[i].next)
        {
            v=ts[i].end;
            Id[v]--;
            if(Id[v]==0)
            {
                tail++;if(tail==610)tail=0;
                q[tail]=v;
            }
        }
    }
}
int BFS()
{
    int head,tail,i,u,v;
    head=0;tail=1;q[tail]=S;
    memset(dis,-1,sizeof(dis));dis[S]=0;
    while(head!=tail)
    {
        head++;if(head==610)head=0;
        u=q[head];
        for(i=Head[u];i!=-1;i=edge[i].next)
        {
            v=edge[i].end;
            if(edge[i].value>0&&dis[v]<0&&use[v]==true)
            {
                dis[v]=dis[u]+1;
                tail++;if(tail==610)tail=0;
                q[tail]=v;
            }
        }
    }
    if(dis[T]<=0)return 0;
    else return 1;
}
int Dfs(int u,int minflow)
{
    int ans=0,used=0,i,v;
    if(u==T)return minflow;
    for(i=cur[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].end;
        if(edge[i].value>0&&dis[v]==dis[u]+1)
        {
            ans=minflow-used;
            ans=Dfs(v,min(ans,edge[i].value));
            edge[i].value-=ans;if(edge[i].value>0)cur[u]=i;
            edge[i^1].value+=ans;
            used+=ans;
            if(used==minflow)return minflow;
        }
    }
    if(used==0)dis[u]=-1;
    return used;
}
int Dinic()
{
    int maxflow=0,ans=0,i;
    while(BFS()){for(i=1;i<=T;i++)cur[i]=Head[i];ans=Dfs(S,INF);if(ans==0)break;maxflow+=ans;}
    return maxflow;
}
int main()
{
    //freopen("pvz.in","r",stdin);
    //freopen("pvz.out","w",stdout);
    int n,i,j,k,xy1,xy2,R,C,K;
    n=read();m=read();
    memset(Head,-1,sizeof(Head));cnt=1;
    memset(Head1,-1,sizeof(Head1));cnt1=1;
    N=xy(n,m);ans=0;S=N+1;T=S+1;
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=m;j++)
        {
            xy1=xy(i,j);
            Score[xy1]=read();
            if(Score[xy1]>0){addedge1(S,xy1,Score[xy1]);addts(xy1,S);}
            else {addedge1(xy1,T,-Score[xy1]);addts(T,xy1);}
            K=read();
            for(k=1;k<=K;k++)
            {
                R=read();C=read();R++;C++;
                xy1=xy(i,j);xy2=xy(R,C);
                addts(xy1,xy2);
                addedge1(xy2,xy1,INF);
            }
            if(j!=m){addedge1(xy(i,j),xy(i,j+1),INF);addts(xy(i,j+1),xy(i,j));}
        }
    }
    memset(use,false,sizeof(use));//标记能用的点(即 不在环中 或 不被环中的点所指向 或间接指向 的点).
    Toposort();
    printf("%d",ans-Dinic());
    fclose(stdin);
    fclose(stdout);
    return 0;
}