HDU 3061：Battle（最大权闭合图）

http://acm.hdu.edu.cn/showproblem.php?pid=3061

题意：中文题意。

思路：和上一题神似啊，比上一题还简单，重新看了遍论文让我对这个理解更加深了。

闭合图：如果某个点在图中的话，那么这个点的后继点全部都要在图中。

对应至题目，这里的必须攻占b以后才能攻占a，那么是a依赖于b。如果a在图中的话，那么b必定在图中（因为a是依赖于b的），所以是a连向b（而不是b连向a）。

这里总结一下做最大权闭合图的套路：把权值为正的点与超级源点S相连，容量为该权值，把权值为负的点与超级汇点T相连，容量为该权值的绝对值，然后点与点之间的连边是，如果a依赖于b，那么a连一条边向b，容量为INF。如果要求删除的点数的话，从S开始DFS，残余网络中的点即删除的点。因为删除的点的集合是从S出发可以达到的并且不能达到T的点集（即割分成的两个集（S集和T集）的S集）。

 #include <cstdio>

 #include <cstring>

 #include <queue>

 #include <algorithm>

 using namespace std;

 #define N 510

 #define INF 0x3f3f3f3f

 typedef long long LL;

 struct Edge {

     int v, nxt, cap;

 } edge[];

 int head[N], cur[N], dis[N], pre[N], gap[N], vis[N], S, T, tot;

 void Add(int u, int v, int cap) {

     edge[tot] = (Edge) {v, head[u], cap}; head[u] = tot++;

     edge[tot] = (Edge) {u, head[v], }; head[v] = tot++;

 }

 int BFS() {

     memset(dis, INF, sizeof(dis));

     memset(gap, , sizeof(gap));

     queue<int> que; que.push(T);

     dis[T] = ; gap[]++;

     while(!que.empty()) {

         int u = que.front(); que.pop();

         for(int i = head[u]; ~i; i = edge[i].nxt) {

             int v = edge[i].v;

             if(dis[v] < INF) continue;

             dis[v] = dis[u] + ;

             gap[dis[v]]++;

             que.push(v);

         }

     }

 }

 LL ISAP(int n) {

     BFS();

     memcpy(cur, head, sizeof(cur));

     int u = pre[S] = S, i, flow, index; LL ans = ;

     while(dis[S] < n) {

         if(u == T) {

             flow = INF;

             for(i = S; i != T; i = edge[cur[i]].v)

                 if(flow > edge[cur[i]].cap) flow = edge[cur[i]].cap, index = i;

             for(i = S; i != T; i = edge[cur[i]].v)

                 edge[cur[i]].cap -= flow, edge[cur[i]^].cap += flow;

             u = index; ans += flow;

         }

         for(i = cur[u]; ~i; i = edge[i].nxt) if(edge[i].cap >  && dis[edge[i].v] +  == dis[u]) break;

         if(~i) {

             cur[u] = i; pre[edge[i].v] = u; u = edge[i].v;

         } else {

             int md = n + ;

             if(--gap[dis[u]] == ) break;

             for(i = head[u]; ~i; i = edge[i].nxt)

                 if(edge[i].cap >  && dis[edge[i].v] < md) md = dis[edge[i].v], cur[u] = i;

             gap[dis[u] = md + ]++;

             u = pre[u];

         }

     }

     return ans;

 }

 int main() {

     int n, m;

     while(~scanf("%d%d", &n, &m)) {

         S = , T = n + ;

         LL sum = ; int u, v; tot = ;

         memset(head, -, sizeof(head));

         memset(vis, , sizeof(vis));

         for(int i = ; i <= n; i++) {

             int w; scanf("%d", &w);

             if(w > ) Add(S, i, w), sum += w;

             else Add(i, T, -w);

         }

         for(int i = ; i <= m; i++) {

             int u, v;

             scanf("%d%d", &u, &v);

             Add(u, v, INF);

         }

         LL ans = ISAP(T + );

         printf("%lld\n", sum - ans);

     }

     return ;

 }