【Luogu】P2805植物大战僵尸（拓扑排序+最大流）

　　题目链接

　　这题数据xie强qwq。拓扑用的那个图建反了得80.

　　一眼看出（个屁，题解上都说一眼看出，然而我还是太蒻了）这是个最大权闭合图。从被保护植物向保护植物连边，然后跑最大流，用正点权和减去。

　　哦最大权闭合图我会。

　　准备开始码。

　　等等题解下面好像还写东西？

　　emmmm有环，所以拓扑排序……

　　好，我写……

　　写了半小时，调了两发过样例交了。

　　wtf80？

　　然后想了半小时，想不出来为什么qwq、

　　然后手推。

　　不对呀数据给的这张图拓扑不动呀？

　　然后想了想，觉得不对呀……应该反着拓扑才对……

　　然后翻题解

　　emm果然是在反向图上拓扑。

　　emmmmmm

　　于是沉吟良久改了四句话，然后就A了。

　　qwqqqqqq。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<algorithm>
#include<queue>
#define maxn 12000
#define maxm 1000000
using namespace std;

inline long long read(){
    long long num=,f=;
    char ch=getchar();
    while(!isdigit(ch)){
        if(ch=='-')    f=-;
        ch=getchar();
    }
    while(isdigit(ch)){
        num=num*+ch-'';
        ch=getchar();
    }
    return num*f;
}

int n,m;
inline int count(int i){    return i&?i+:i-;    }
inline int calc(int i,int j){    return (i-)*m+j;    }
int dfn[maxn];
bool vis[maxn];
int list[maxn];
int Start,End;
int indl[maxn];
bool ext[maxn];
queue<int>f;

struct Pic{
    struct Edge{
        int next,to,val;
    }edge[maxm];
    int head[maxn],num;
    Pic(){memset(head,,sizeof(head));    num=;    }
    inline void addedge(int from,int to,int val){
        edge[++num]=(Edge){head[from],to,val};
        head[from]=num;
    }
    inline void add(int from,int to,int val){
        addedge(from,to,val);
        addedge(to,from,);
    }
    bool bfs(){
        memset(vis,,sizeof(vis));
        dfn[Start]=;    vis[Start]=;
        queue<int>q; q.push(Start);
        while(!q.empty()){
            int from=q.front();    q.pop();
            for(int i=head[from];i;i=edge[i].next){
                int to=edge[i].to;
                if(vis[to]||edge[i].val==)    continue;
                vis[to]=;    dfn[to]=dfn[from]+;
                q.push(to);
            }
        }
        return vis[End];
    }
    int dfs(int x,int val){
        if(x==End||val==)    return val;
        int flow=;    vis[x]=;
        for(int i=head[x];i;i=edge[i].next){
            int to=edge[i].to;
            if(edge[i].val==||dfn[to]!=dfn[x]+)    continue;
            int now=dfs(to,min(val,edge[i].val));
            edge[i].val-=now;    edge[count(i)].val+=now;    val-=now;    flow+=now;
            if(val<=)    break;
        }
        if(val!=flow)    dfn[x]=-;
        return flow;
    }
    inline int maxflow(){
        int ans=;
        while(bfs()){
            memset(vis,,sizeof(vis));
            for(int i=Start;i<=End;++i)    list[i]=head[i];
            int now=dfs(Start,0x7fffffff);
            if(now==)    break;
            ans+=now;
        }
        return ans;
    }
}Old,New;
int sco[][];
int sum;

int main(){
    n=read(),m=read();
    for(int i=;i<=n;++i)
        for(int j=;j<m;++j){
            int x=calc(i,j+);
            Old.addedge(x,calc(i,j),);
            indl[calc(i,j)]++;
            //Old.addedge(calc(i,j),x,0);
            //indl[x]++;
        }
    for(int i=;i<=n;++i)
        for(int j=;j<=m;++j){
            sco[i][j]=read();
            int x=read();
            for(int k=;k<=x;++k){
                int a=read()+,b=read()+;
                int opt=calc(a,b);
                Old.addedge(calc(i,j),opt,);
                indl[opt]++;
                //Old.addedge(opt,calc(i,j),0);
                //indl[calc(i,j)]++;
            }
        }
    for(int i=;i<=n*m;++i)
        if(indl[i]==){
            f.push(i);
            ext[i]=;
        }
    while(!f.empty()){
        int from=f.front();    f.pop();
        for(int i=Old.head[from];i;i=Old.edge[i].next){
            int to=Old.edge[i].to;
            indl[to]--;
            if(indl[to]==){
                ext[to]=;
                f.push(to);
            }
        }
    }
    End=n*m+;
    for(int i=;i<=n;++i)
        for(int j=;j<=m;++j){
            int ret=calc(i,j);
            if(ext[ret]==)    continue;
            if(sco[i][j]>)    sum+=sco[i][j];
            if(sco[i][j]>)    New.add(Start,ret,sco[i][j]);
            else            New.add(ret,End,-sco[i][j]);
            for(int k=Old.head[ret];k;k=Old.edge[k].next){
                int to=Old.edge[k].to;
                New.add(to,ret,0x7fffffff);
            }
        }
    int ans=New.maxflow();
    printf("%d",sum-ans);
    return ;
}