最大权闭合子图

先来题目链接

http://hihocoder.com/problemset/problem/1398

分析：

这是一个很有意思的算法，真心佩服搞出这种算法的人。。宛如天上的繁星，我等只能仰视。

概念：

简单割：割(S,T)中每一条割边都与s或者t关联，这样的割叫做简单割。

此时的最小割 一定是简单割

很简单，因为如果不跟S，T相连，那么容量就变成正无穷了

闭合子图：给定一个有向图，从中选择一些点组成一个点集V。对于V中任意一个点，其后续节点都仍然在V中

简单割一定和一个闭合子图对应 ，因为都在S 或 T 集合中

最小割就是最大权的闭合子图

首先有割的容量C(S,T)=T中所有正权点的权值之和+S中所有负权点的权值绝对值之和。

闭合子图的权值W=S中所有正权点的权值之和-S中所有负权点的权值绝对值之和。

则有C(S,T)+W=T中所有正权点的权值之和+S中所有正权点的权值之和=所有正权点的权值之和。

所以W=所有正权点的权值之和-C(S,T)

结论：最大权闭合子图的权值等于所有正权点之和减去最小割

做法：

首先建立源点s和汇点t，将源点s与所有权值为正的点相连，容量为权值；

将所有权值为负的点与汇点t相连，容量为权值的绝对值； 

权值为0的点不做处理；同时将原来的边容量设置为无穷大

#include <cstdio>
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
static const int INF = 1e9;
static const int MAXN = 100000;
struct Edge
{
    int from,to,cap,flow;
    Edge(int f,int t,int c,int ff)
        :from(f),to(t),cap(c),flow(ff) {};
};
vector<Edge> edges;
vector<int> G[MAXN];
int N,M,S,T,i,j;
int iter[MAXN],level[MAXN];
bool vis[MAXN];

void add_edge(int from,int to,int cap)
{
    edges.push_back(Edge(from, to, cap, 0 ));
    edges.push_back(Edge(to, from, 0, 0));
    int sz = edges.size();
    G[from].push_back(sz-2);//¼Ç¼ÔÚEdge ÀïÃæµÄλÖÃ
    G[to].push_back(sz-1);
}



bool BFS( )
{
//	printf("!\n");
    memset(vis,false,sizeof(vis));
    level[S] = 0;
    vis[S] = 1;
    queue<int>Q;
    Q.push(S);
    while(!Q.empty())
    {
        int u = Q.front();
        Q.pop();
        for(int i = 0 ; i < G[u].size() ; ++i)
        {
            Edge& e = edges[G[u][i]];
            if(!vis[e.to]&&e.cap > e.flow)
            {
                vis[e.to] = 1;
                level[e.to] = level[u] + 1;
                Q.push(e.to);
            }
        }
    }
    return vis[T];
}

int DFS(int u,int a)
{
//	printf("@\n");
    if(u == T || a == 0)
        return a;
    int f, flow = 0;
    for(int& i = iter[u]; i < (int)G[u].size(); ++i)
    {
        Edge& e = edges[G[u][i]];
        if(level[e.to] == level[u] + 1 && (f = DFS(e.to, min(a,e.cap - e.flow))) > 0 )
        {
            e.flow += f;
            edges[G[u][i]^1].flow -= f;
            flow += f;
            a -= f;
            if( a == 0 )break;
        }
    }
    return flow;
}
int Dinic( )
{
    int res = 0 ;
    while(BFS())
    {
        memset(iter,0,sizeof(iter));
        res += DFS(S,INF);
    }
    return res;
}
void Init()
{
    S = 0;
    T = N+M+1;
    for(int i = 0; i <= T; ++i)
        G[i].clear();
    edges.clear();
}
bool Solve( )
{
    cin >> N >> M ;
    Init( );
    int sum = 0 ;
    for(int i = 1 ; i <= M ; ++i)
    {
        int b ;
        cin >> b;
        add_edge(N+i,T,b);
    }
    for(int i = 1 ; i <= N ; ++i)
    {
        int a ;
        cin >> a;
        sum += a;
        add_edge(S,i,a);
        int x;
        cin >> x;
        while( x-- )
        {
            int b;
            cin >> b;
            add_edge(i,N+b,1e9);
        }
    }
    cout << sum - Dinic() << endl;
}
int main( )
{
    Solve();
}