Bzoj1565 [NOI2009]植物大战僵尸

Time Limit: 10 Sec  Memory Limit: 64 MB
Submit: 2363  Solved: 1092

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 。

Source

 

网络流+拓扑排序

因为植物可能会互相保护而形成环，所以先用拓扑排序排除环，求出图中的闭合子图。

然后按照先吃右边才能吃左边的关系，从每个点向它左边一格的点连边，容量为INF

保护型的植物向它保护的植物连边，容量为INF。

吃植物能获得收益时，该植物向汇点连边，容量为收益。

吃植物需要代价时，源点向该植物连边，容量为代价的绝对值。

答案=可能获得的收益总和-最小割。

 

/*by SilverN*/
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int mx[5]={0,1,0,-1,0};
const int my[5]={0,0,1,0,-1};
const int INF=1e9;
const int mxn=2010;
int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct edge{
    int v,nxt,f;
}e[mxn*500];
int hd[mxn],mct=1;
void add_edge(int u,int v,int f){
    e[++mct].v=v;e[mct].nxt=hd[u];e[mct].f=f;hd[u]=mct;return;
}
void insert(int u,int v,int f){
    add_edge(u,v,f);add_edge(v,u,0);return;
}
vector<int>eg[mxn];
int n,m,S,T;
int d[mxn];
bool BFS(){
    memset(d,0,sizeof d);
    queue<int>q;
    d[S]=1;
    q.push(S);
    while(!q.empty()){
        int u=q.front();q.pop();
        for(int i=hd[u];i;i=e[i].nxt){
            int v=e[i].v;
            if(e[i].f && !d[v]){
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
    return d[T];
}
int DFS(int u,int lim){
    if(u==T)return lim;
    int f=0,tmp;
    for(int i=hd[u];i;i=e[i].nxt){
        int v=e[i].v;
        if(d[v]==d[u]+1 && e[i].f && (tmp=DFS(v,min(lim,e[i].f)))){
            e[i].f-=tmp;   e[i^1].f+=tmp;
            f+=tmp;        lim-=tmp;
            if(!lim)return f;
        }
    }
    d[u]=0;
    return f;
}
int Dinic(){
    int res=0;
    while(BFS())res+=DFS(S,INF);
    return res;
}
int id[50][50],cnt=0,ed;
void init(){
    for(int i=1;i<=n;i++)
     for(int j=1;j<=m;j++)
         id[i][j]=++cnt;
    ed=n*m;
    return;
}
int sc[mxn];
int ind[mxn];
int st[mxn],top=0;
bool vis[mxn];
void topo(){//拓扑排序，判断植物能否攻击 
    int i,j,res=0;
    for(i=1;i<=cnt;i++)
        if(!ind[i])st[++top]=i;
    while(top){
        int u=st[top--];
        vis[u]=1;
        if(sc[u]>0){
            res+=sc[u];
            insert(u,T,sc[u]);//可能得到的分数 
        }
        else  insert(S,u,-sc[u]);//需要付出的代价 
        for(j=0;j<eg[u].size();j++){
            int v=eg[u][j];
            ind[v]--;
            insert(u,v,INF);
            if(!ind[v])st[++top]=v;
        }
    }
    for(i=1;i<=n;i++)
        for(j=2;j<=m;j++){
            if(vis[id[i][j]] && vis[id[i][j-1]]){//先吃右面再吃左面 
                insert(id[i][j],id[i][j-1],INF);
            }
        }
    res=res-Dinic();
    printf("%d\n",res);
}
int main(){
    int i,j,w,x,y;
    n=read();m=read();
    init();
    S=0;T=ed+1;
    for(i=1;i<=n;i++){
        for(j=1;j<=m;j++){
            sc[id[i][j]]=read();
            w=read();
            while(w--){
                x=read()+1;y=read()+1;
                eg[id[i][j]].push_back(id[x][y]);
                ind[id[x][y]]++;
            }
            if(j>1){//先解锁右面的才能吃左面的 
                eg[id[i][j]].push_back(id[i][j-1]);
                ind[id[i][j-1]]++;
            }
        }
    }
    topo();
    return 0;
}