BZOJ 1565: [NOI2009]植物大战僵尸

题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=1565

/**
题目来源：BZOJ 1565: [NOI2009]植物大战僵尸

题目意思：给出N*M的矩阵，矩阵中每一个方格都有一棵植物，同时每个植物
都有一个score值（可以是正，也可以是负）先输入N,M，然后是N*M行数据，
每一行数据第一个数是对应格子的score值，然后是一个数w，代表该植物可以保护
w个位置，然后给出这w位置的坐标，代表该位置植物可以保护这些位置的植物，但是
每棵植物无法保护自己所在的位置，僵尸是从矩阵右侧出发的，有无数多个，僵尸一
但进入植物的攻击区域后，还没发动攻击就会被植物立即消灭，而且僵尸只能水平方向
前进，僵尸欲想往更左侧走，就要先除掉右侧植物，所以右侧的植物对左侧植物有保护
作用。僵尸除掉一颗植物，就可以获得其score，求僵尸可以获得最大的score值。

解题思路：最大权闭合子图，每个方格看成一个节点，对应一个编号，如果x对y
有保护作用，就连一条x->y的边，这个题目要去环，其实最大权闭合子图问题
应该是不会怕环的，但是这个题目僵尸已进入受保护的区域就马上会被消灭，
这些区域根本就是没法访问的，如果A可以保护B,B又保护C，C又保护A，那么
A,B,C无法被消灭，只有最终保护伞（保护伞就是保护该点的节点数）为0的这些
点可能被僵尸攻击。所以这个题目要么先用拓扑排序或tarjan去除环，然后在建立
网络流模型，用最大权闭合子图的方法求解一下即可。

注意：原图中我们是x对y有保护作用，则从x引一条到y的边，然而建立网络流需要
用的图时，如果x对y是保护作用，则要建立y到x且权值为无穷大的边，因为如果y
要是想除去，必须先除去x,也就是说若y属于S割，由于y到x的边为无穷大在，无穷大的
边无法被抵消，这就保证了x也比属于S割，只要注意好这一点，然后正权值点与S建
边，负权值的点向T建边，求图的最小割，所有正权值和-负点的权值和就是答案。

*/
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>

using namespace std;

int N,M,S,T,sum,maxFlow;    ///N行M列的矩阵
const int maxn = 1000;
const int INF = 0x3f3f3f3f;
const int maxm = 1000000;
int score[maxn],vis[maxn],level[maxn];
int head1[maxn],cnt1,inDegree[maxn];
int head2[maxn],cnt2,cur[maxn];
struct Edge1 {
    int to;
    int nex;
}edge1[maxm<<1];
struct Edge2 {
    int to;
    int cap;
    int nex;
}edge2[maxm<<1];
void addEdge1(int u,int v) {
    edge1[cnt1].to = v;
    edge1[cnt1].nex = head1[u];
    head1[u] = cnt1++;
    inDegree[v]++;
}
void addEdge2(int u,int v,int cap) {
    edge2[cnt2].to = v;
    edge2[cnt2].cap = cap;
    edge2[cnt2].nex = head2[u];
    head2[u] = cnt2++;

    edge2[cnt2].to = u;
    edge2[cnt2].cap = 0;
    edge2[cnt2].nex = head2[v];
    head2[v] = cnt2++;
}
void input() {
    memset(head1,-1,sizeof(head1));
    memset(inDegree,0,sizeof(inDegree));
    cnt1 = 0;
    int s,t,x,y,u,v;
    for(int i = 0; i < N; i++) {
        for(int j = 0; j < M; j++) {
            scanf("%d%d",&s,&t);
            u = i*M+j+1;
            score[u] = s;
            for(int k = 1; k <= t; k++) {
                scanf("%d%d",&x,&y);
                v = x*M+y+1;
                addEdge1(u,v);
            }
            if(j != M-1)
                addEdge1(u+1,u);
        }
    }
}
void delCircle(int x) {
    vis[x] = 1;
    for(int i = head1[x]; i!=-1; i = edge1[i].nex) {
        int v = edge1[i].to;
        if(vis[v]==0) {
            delCircle(v);
        }
    }
}
void topSort() {
    memset(vis,0,sizeof(vis));
    queue<int>qu;
    for(int i = 1; i <= N*M; i++) {
        if(inDegree[i] == 0) {
            qu.push(i);
        } else {
            vis[i] = 1;
        }
    }
    while(!qu.empty()) {
        int u = qu.front();
        qu.pop();
        for(int i = head1[u]; i!=-1; i =edge1[i].nex) {
            int v = edge1[i].to;
            inDegree[v]--;
            if(inDegree[v]==0) {
                vis[v] = 0;
                qu.push(v);
            }
        }
    }
    for(int i = 1; i <= N*M; i++) {
        if(vis[i]==1) {
            delCircle(i);
        }
    }
}
void build() {
    memset(head2,-1,sizeof(head2));
    cnt2 = 0;
    sum = 0;
    S = 0;
    T = N*M+1;
    for(int i = 1; i <= N*M; i++) {
        if(vis[i]==0) {
            if(score[i]>=0) {
                sum += score[i];
                addEdge2(S,i,score[i]);
            } else {
                addEdge2(i,T,-score[i]);
            }
            for(int j = head1[i]; j != -1; j = edge1[j].nex) {
                int v = edge1[j].to;
                if(vis[v]==0) {   ///v对i依赖，所以建立v到i的边。
                    addEdge2(v,i,INF);
                }
            }
        }
    }
}
bool bfs() {
    memset(level,-1,sizeof(level));
    level[S] = 0;
    queue<int>qu;
    qu.push(S);
    while(!qu.empty()) {
        int u = qu.front();
        qu.pop();
        for(int i = head2[u]; i != -1; i = edge2[i].nex) {
            int v = edge2[i].to;
            if(edge2[i].cap > 0 && level[v] == -1) {
                level[v] = level[u] + 1;
                qu.push(v);
            }
        }
    }
    if(level[T]==-1) return false;
    else return true;
}
int dfs(int x,int flow) {
    if(x == T)
        return flow;
    int all=0,temp;
    for(int &i = cur[x]; i != -1; i = edge2[i].nex) {
        int v = edge2[i].to;
        if(edge2[i].cap>0 && level[v]==level[x]+1) {
            temp = dfs(v,min(flow-all,edge2[i].cap));
            edge2[i].cap -= temp;
            edge2[i^1].cap += temp;
            all += temp;
            if(all == flow) return flow;
        }
    }
    if(all == 0) level[x] = -1;
    return all;
}
int dinic() {
    maxFlow = 0;
    while(bfs()) {
       for(int i = S; i <= T; i++) {
            cur[i] = head2[i];
        }
        maxFlow += dfs(S,INF);
    }
    return maxFlow;
}
int main() {

        scanf("%d%d",&N,&M);
        input();
        topSort();
        build();
        int ans = sum-dinic();
        printf("%d\n",ans);
    return 0;
}