【bzoj1565】[NOI2009]植物大战僵尸

1565: [NOI2009]植物大战僵尸

Time Limit: 10 Sec  Memory Limit: 64 MB
Submit: 2164  Solved: 1001
[Submit][Status][Discuss]

Description

Input

Output

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

Sample Input

3 2
10 0
20 0
-10 0
-5 1 0 0
100 1 2 1
100 0

Sample Output

25

HINT

在样例中, 植物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 。

 

 

【题解】

这题的麻烦之处在于网络中可能出现环，导致死循环。

首先建图：如果一行之中，有一个植物被在同一行中左边的植物保护，就会形成环，那么我们只需要在每一行的植物向左边一个植物连一条边就行了。然后就是由保护者向被保护者连一条边。

拓扑判环、删点，不再赘述。

重新建图：遍历每个点，如果这个点没被删除，就在新图上保留有这个点出发的所有边。并判断：如果点权为正，从此点向终点连边，否则，由起点向此点连边。顺便记下所有正点权之和sum

求最大流ans后，sum-ans就是答案。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<ctime>
#include<algorithm>
using namespace std;
#define MAXN 610000
#define INF 1000000000
struct node{int y,next,v,rel;}E[MAXN],e[MAXN];
int n,m,len,S,T,ans,sum,v[MAXN],Link1[MAXN],id[MAXN],q[MAXN],del[MAXN],Link[MAXN],level[MAXN];
inline int read()
{
    int x=0,f=1;  char ch=getchar();
    while(!isdigit(ch))  {if(ch=='-')  f=-1;  ch=getchar();}
    while(isdigit(ch))  {x=x*10+ch-'0';  ch=getchar();}
    return x*f;
}
void insert1(int x,int y)  {id[y]++;E[++len].next=Link1[x];Link1[x]=len;E[len].y=y;}
void insert2(int x,int y,int v)  
{
    e[++len].next=Link[x];Link[x]=len;e[len].y=y;e[len].v=v;e[len].rel=len+1;
    e[++len].next=Link[y];Link[y]=len;e[len].y=x;e[len].v=0;e[len].rel=len-1;
}
void dfs(int x)
{
    del[x]=1;
    for(int i=Link1[x];i;i=E[i].next)
        if(!del[E[i].y])  dfs(E[i].y);
}
void topsort()
{
    int head=0,tail=0;
    for(int i=1;i<=n*m;i++)  if(!id[i])  q[++tail]=i;  else del[i]=1;
    while(++head<=tail)
    {
        int now=q[head];
        del[now]=0;
        for(int i=Link1[now];i;i=E[i].next)
        {
            id[E[i].y]--;
            if(!id[E[i].y])  q[++tail]=E[i].y;
        }
    }
    for(int i=1;i<=n*m;i++)  if(del[i])  dfs(i);
}     
void build()
{
    len=0;  S=0;  T=n*m+1;
    for(int i=1;i<=n*m;i++)
        if(!del[i])
        {
            if(v[i]>0) {sum+=v[i]; insert2(i,T,v[i]);}
            else insert2(S,i,-v[i]);
            for(int j=Link1[i];j;j=E[j].next)
                if(!del[E[j].y])
                    insert2(i,E[j].y,INF);
        }
}
bool bfs()
{
    memset(level,-1,sizeof(level));
    int head=0,tail=1;
    q[1]=S;  level[S]=0;
    while(++head<=tail)
    {
        for(int i=Link[q[head]];i;i=e[i].next)
            if(e[i].v&&level[e[i].y]<0)
            {
                q[++tail]=e[i].y;
                level[q[tail]]=level[q[head]]+1;
            }
    }
    return level[T]>=0;
}
int MAXFLOW(int x,int flow)
{
    if(x==T)  return flow;
    int d=0,maxflow=0;
    for(int i=Link[x];i&&maxflow<flow;i=e[i].next)
        if(level[e[i].y]==level[x]+1&&e[i].v)
            if(d=MAXFLOW(e[i].y,min(e[i].v,flow-maxflow)))
            {
                maxflow+=d;
                e[i].v-=d;
                e[e[i].rel].v+=d;
            }
    if(!maxflow)  level[x]=-1;
    return maxflow;
}
void solve()
{
    int d=0;
    while(bfs())
        while(d=MAXFLOW(S,INF))
            ans+=d;
}
int main()
{
    //freopen("pvz.in","r",stdin);
    //freopen("pvz.out","w",stdout);
    n=read();  m=read();
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            int x=(i-1)*m+j;
            v[x]=read();  int w=read();
            while(w--)
            {
                int a=read(),b=read();
                a++;  b++;
                int y=(a-1)*m+b;
                insert1(x,y);
            }
        }
    for(int i=1;i<=n;i++)
        for(int j=2;j<=m;j++)
        {
            int x=(i-1)*m+j,y=x-1;
            insert1(x,y);
        }
    topsort();
    build();
    solve();
    printf("%d\n",sum-ans);
    return 0;
}