【bzoj1565】[NOI2009]植物大战僵尸 最大权闭合图+拓扑排序

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

这题水了…

若想选某个点u，必须选保护它的点v。求在这种情况下的一个最大子图。那么u向v连边，就是一个最大权闭合图问题了，可以最小割解决。
别忘了同行还有一个保护关系：右边的保护左边的。

难点在去环……先反向建图，然后把拓扑排序失败剩下的点（也就是环了）及它们的出边所指向的点全部删掉，然后把剩下的点建图跑网络流。

#include<cstring>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
using namespace std;

const int INF = 1000000010;
const int SZ = 1000010;

int head[SZ],nxt[SZ],tot = 1,n,m;

struct edge{
    int t,d;
}l[SZ];

void build(int f,int t,int d)
{
    l[++ tot].t = t;
    l[tot].d = d;
    nxt[tot] = head[f];
    head[f] = tot;
}

void insert(int f,int t,int d)
{
    build(f,t,d); build(t,f,0);
}

int deep[SZ];
queue<int> q;

bool bfs(int s,int e)
{
    memset(deep,0,sizeof(deep));
    while(q.size()) q.pop();
    deep[s] = 1;
    q.push(s);
    while(q.size())
    {
        int u = q.front(); q.pop();
        for(int i = head[u];i;i = nxt[i])
        {
            int v = l[i].t;
            if(!deep[v] && l[i].d)
            {
                deep[v] = deep[u] + 1;
                q.push(v);
                if(v == e) return true;
            }
        }
    }
    return false;
}

int dfs(int u,int flow,int e)
{
    if(u == e || flow == 0) return flow;
    int rest = flow;
    for(int i = head[u];i;i = nxt[i])
    {
        int v = l[i].t;
        if(deep[v] == deep[u] + 1 && l[i].d)
        {
            int f = dfs(v,min(l[i].d,rest),e);
            if(f > 0)
            {
                l[i].d -= f;
                l[i ^ 1].d += f;
                rest -= f;
                if(rest == 0) break;
            }
            else deep[v] = 0;
        }
    }
    return flow - rest;
}

int dinic(int s,int e)
{
    int ans = 0;
    while(bfs(s,e)) ans += dfs(s,INF,e);
    return ans; 
}

int getnode(int x,int y)
{
    return (x - 1) * m + y;
}

int ind[SZ];
vector<int> g[SZ];
queue<int> que;
bool inq[SZ];

void dfs(int u)
{
    inq[u] = 0;
    for(int i = 0;i < g[u].size();i ++)
        if(inq[g[u][i]]) dfs(g[u][i]);
}

void topsort()
{
    for(int i = 1;i <= n * m;i ++)
        if(!ind[i]) que.push(i);
    while(que.size())
    {
        int u = que.front(); que.pop();
        inq[u] = 1;
        for(int i = 0;i < g[u].size();i ++)
            if(!-- ind[g[u][i]])
                que.push(g[u][i]);
    }
    for(int i = 1;i <= n * m;i ++)
        if(!inq[i]) dfs(i);
}

int ff[SZ],tt[SZ],dd[SZ],tot_sum = 0;
int cost[SZ];

int main()
{
    scanf("%d%d",&n,&m);
    int S = n * m + 1,T = n * m + 2;
    for(int i = 1;i <= n;i ++)
    {
        for(int j = 1;j <= m;j ++)
        {
            int x;
            scanf("%d",&x);
            cost[getnode(i,j)] = x;
            if(x > 0)
            {
                ff[++ tot_sum] = S;
                tt[tot_sum] = getnode(i,j);
                dd[tot_sum] = x;
            }
            else
            {
                ff[++ tot_sum] = getnode(i,j);
                tt[tot_sum] = T;
                dd[tot_sum] = -x;
            }
            int k;
            scanf("%d",&k);
            while(k --)
            {
                int x,y;
                scanf("%d%d",&x,&y);
                x ++; y ++;
                ff[++ tot_sum] = getnode(x,y);
                tt[tot_sum] = getnode(i,j);
                dd[tot_sum] = INF;
                g[getnode(i,j)].push_back(getnode(x,y));
                ind[getnode(x,y)] ++;   
            }
        }
    }
    for(int i = 1;i <= n;i ++)
    {
        for(int j = 1;j < m;j ++)
        {
            ff[++ tot_sum] = getnode(i,j);
            tt[tot_sum] = getnode(i,j + 1);
            dd[tot_sum] = INF;
            g[getnode(i,j + 1)].push_back(getnode(i,j));
            ind[getnode(i,j)] ++;
        }
    }

    topsort();

    int sum = 0;

    for(int i = 1;i <= n * m;i ++)
        if(inq[i] && cost[i] > 0)
            sum += cost[i];

    inq[S] = inq[T] = 1;

    for(int i = 1;i <= tot_sum;i ++)
        if(inq[tt[i]])
            insert(ff[i],tt[i],dd[i]);

    printf("%d\n",sum - dinic(S,T));
    return 0;
}