BZOJ 1565 NOI2009 植物大战僵尸 topo+最小割（最大权闭合子图）

题目链接：https://www.luogu.org/problemnew/show/P2805（bzoj那个实在是有点小小的辣眼睛。。。我就把洛谷的丢出来吧。。。）

 

题意概述：给出一张有向图，这张有向图上的每个点都有一个点权，想要访问某个点必须要先访问这个点所能够访问（遍历）到的所有点，在访问到一个点之后将会得到这个点的权值（可正可负）。问访问这张图可以得到的最大点权和。

 

原题说过来说过去实际上是描述了一个植物之间的保护关系，也就是说明了植物之间的先后访问顺序之间的关系。可以描述为要“要访问点a，先要访问点b”这样的形式，并且题意总结出来之后很容易发现这就是一个最大权闭合子图问题。

但是我们注意到原题给出的并不一定是一个DAG图。事实上，可能有些植物互相保护，导致僵尸只能当炮灰。。。。于是我们需要把环去掉，这一步可以topo序解决，只是不是真的topo，而是从入度为0的点开始的（访问所有可以不经过环就可以访问到的点）。

然后就是直接网络流上跑最大权闭合子图。但是值得注意的是最大权闭合子图是满足一种推导关系，即上面的“要访问点a，先要访问先b”这种关系形成的一条有向边，容量为inf，因为要满足这样的推导关系，所以上面求topo的时候连的边要反过来。然后原点向所有点权为正的边连一条边，容量为点权；所有点权为负的点向汇点连一条边，容量为点权的相反数。在求最小割的时候如果一条边被割掉，那么意义就是做出选择（S有关的边是不选这个点，T有关的边是选了这个点）之后付出的代价。

最后只需要把所有的正权点权值相加（可以得到的最大收益），减去最小割（付出的最小代价），就是我们最终获得的最大收益。

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<cctype>
using namespace std;
const int MAXN=25;
const int MAXM=35;

int N,M,sco[MAXN][MAXM];
struct XY{ int x,y; };
vector<XY>att[MAXN][MAXM];
struct graph{
    static const int maxn=605;
    static const int maxm=360050;
    struct edge{ int from,to,next; }E[maxm];
    int n,first[maxn],np,rd[maxn],topo[maxn];
    graph(){ np=0; }
    void add_edge(int u,int v){
        E[++np]=(edge){u,v,first[u]};
        first[u]=np;
    }
    void topo_sort(){
        queue<int>q;
        for(int i=1;i<=n;i++)
            if(!rd[i]) topo[i]=1,q.push(i);
        while(!q.empty()){
            int i=q.front(); q.pop();
            for(int p=first[i];p;p=E[p].next){
                int j=E[p].to;
                if(--rd[j]==0) topo[j]=1,q.push(j);
            }
        }
    }
}gp;
struct NET{
    static const int maxn=605;
    static const int maxm=360050;
    static const int inf=1e7+5;
    struct edge{ int from,to,next,cap,flow; }E[maxm<<1];
    int S,T,n,first[maxn],np,fl[maxn],gap[maxn],d[maxn],cur[maxn];
    NET(){ np=0; }
    void add_edge(int u,int v,int w){
        E[++np]=(edge){u,v,first[u],w,0};
        first[u]=np;
        E[++np]=(edge){v,u,first[v],0,0};
        first[v]=np;
    }
    void BFS(){
        queue<int>q;
        for(int i=1;i<=n;i++) d[i]=n;
        d[T]=0; q.push(T);
        while(!q.empty()){
            int i=q.front(); q.pop();
            for(int p=first[i];p;p=E[p].next){
                int j=E[p].to,pp=(p-1^1)+1;
                if(E[pp].cap>E[pp].flow&&d[j]==n) d[j]=d[i]+1,q.push(j);
            }
        }
    }
    int augment(){
        int now=T,flow=inf;
        while(now!=S){
            flow=min(flow,E[fl[now]].cap-E[fl[now]].flow);
            now=E[fl[now]].from;
        }
        now=T;
        while(now!=S){
            E[fl[now]].flow+=flow,E[(fl[now]-1^1)+1].flow-=flow;
            now=E[fl[now]].from;
        }
        return flow;
    }
    int ISAP(){
        memcpy(cur,first,sizeof(first));
        BFS();
        for(int i=1;i<=n;i++) gap[d[i]]++;
        int now=S,flow=0;
        while(d[S]<n){
            if(now==T) flow+=augment(),now=S;
            bool ok=0;
            for(int p=cur[now];p;p=E[p].next){
                int j=E[p].to;
                if(E[p].cap>E[p].flow&&d[j]+1==d[now]){
                    ok=1,fl[j]=cur[now]=p,now=j;
                    break;
                }
            }
            if(!ok){
                int minl=n;
                for(int p=first[now];p;p=E[p].next){
                    int j=E[p].to;
                    if(E[p].cap>E[p].flow&&d[j]+1<minl) minl=d[j]+1;
                }
                if(--gap[d[now]]==0) break;
                gap[d[now]=minl]++;
                cur[now]=first[now];
                if(now!=S) now=E[fl[now]].from;
            }
        }
        return flow;
    }
}net;

void data_in()
{
    scanf("%d%d",&N,&M);
    int w,x,y;
    for(int i=1;i<=N;i++)
    for(int j=1;j<=M;j++){
        scanf("%d%d",&sco[i][j],&w);
        for(int k=1;k<=w;k++){
            scanf("%d%d",&x,&y);
            att[i][j].push_back((XY){x+1,y+1});
        }
    }
}
int idx(int x,int y){ return (x-1)*M+y; }
void build_net()
{
    for(int i=1;i<=N;i++)
    for(int j=1;j<=M;j++){
        int id=idx(i,j);
        for(int k=1;k+j<=M;k++){
            gp.add_edge(id+k,id);
            gp.rd[id]++;
        }
        for(int k=0;k<att[i][j].size();k++){
            int _id=idx(att[i][j][k].x,att[i][j][k].y);
            gp.add_edge(id,_id); gp.rd[_id]++;
        }
    }
    gp.n=N*M; gp.topo_sort();
    for(int p=1;p<=gp.np;p++){
        int x=gp.E[p].from,y=gp.E[p].to;
        if(gp.topo[x]&&gp.topo[y]) net.add_edge(y,x,net.inf);
    }
    net.n=N*M+2,net.S=net.n-1,net.T=net.n;
    for(int i=1;i<=N;i++)
    for(int j=1;j<=M;j++) if(gp.topo[idx(i,j)]){
        if(sco[i][j]>0) net.add_edge(net.S,idx(i,j),sco[i][j]);
        else if(sco[i][j]<0) net.add_edge(idx(i,j),net.T,-sco[i][j]);
    }
}
void work()
{
    build_net();
    int sum=0;
    for(int i=1;i<=N;i++)
    for(int j=1;j<=M;j++)
        if(sco[i][j]>0&&gp.topo[idx(i,j)]) sum+=sco[i][j];
    printf("%d\n",sum-net.ISAP());
}
int main()
{
    data_in();
    work();
    return 0;
}