POJ 2987 Firing （最大权闭合子图Dinic)

题意：公司打算裁员，裁掉某些员工可以获得正收益，而裁掉某些员工会遭受损失。并且员工之间往往存在一定的关系，当某个员工被裁掉之后，在他的关系之下的所有员工都必须被裁掉。现在要求如何裁员才能获得最大收益。

题解：s->正权， 负权->t。  ans = 正权和 - maxflow, 或者 ans = 正权和 - 没有被裁的正权和 - abs(被裁的负权和） （ 正边权进入最小割表示该人没被炒，非正边权进入最小割表示该人被炒）。至于边权放大什么的就不是很理解了····
#include <algorithm>
#include <iostream>
using namespace std;

#define MAX 40000
#define INF 99999999999999999
#define min(a,b) (a<b?a:b)

struct Edge
{
int st, ed;
int next;
__int64 flow;
} edge[MAX*10];

int head[MAX], out[MAX];
int stk[MAX], que[MAX];
int leve[MAX];
bool vis[MAX];
int E, src, sink;

void add_edge ( int u, int v, __int64 flw )
{
edge[E].st = u;
edge[E].ed = v;
edge[E].flow = flw;
edge[E].next = head[u];
head[u] = E++;

edge[E].st = v;
edge[E].ed = u;
edge[E].flow = 0;
edge[E].next = head[v];
head[v] = E++;
}

bool dinic_bfs()
{
memset(leve,-1,sizeof(leve));
int front, rear, u, v, i;
front = rear = 0;
que[rear++] = src;
leve[src] = 0;
while ( front != rear )
{
u = que[front];
front = ( front + 1 ) % MAX;
for ( i = head[u]; i != -1; i = edge[i].next )
{
v = edge[i].ed;
if ( edge[i].flow > 0 && leve[v] == -1 )
{
leve[v] = leve[u] + 1;
que[rear] = v;
rear = ( rear + 1 ) % MAX;
}
}
}
return leve[sink] != -1;
}

__int64 Dinic ()
{
__int64 maxFlow = 0;
while ( dinic_bfs() )
{
int top = 0, u = src, i;
for ( i = src; i <= sink; i++ ) out[i] = head[i];

while ( out[src] != -1 )
{
if ( u == sink )
{
__int64 dd = INF;
for ( i = top - 1; i >= 0; i-- )
dd = min ( edge[stk[i]].flow, dd );
for ( i = top - 1; i >= 0; i-- )
{
edge[stk[i]].flow -= dd;
edge[stk[i]^1].flow += dd;
if ( edge[stk[i]].flow == 0 ) top = i;
}
maxFlow += dd;
u = edge[stk[top]].st;
}
else if ( out[u] != -1 && edge[out[u]].flow > 0 && leve[u] + 1 == leve[edge[out[u]].ed] )
{
stk[top++] = out[u];
u = edge[out[u]].ed;
}
else
{
while ( top > 0 && u != src && out[u] == -1 )
u = edge[stk[--top]].st;
out[u] = edge[out[u]].next;
}
}
}
return maxFlow;
}

int dfs ( int u )
{
vis[u] = true;
int cnt = 1;
for ( int i = head[u]; i != -1; i = edge[i].next )
if ( ! vis[edge[i].ed] && edge[i].flow > 0 )
cnt += dfs(edge[i].ed);
return cnt;
}

int main()
{
__int64 sum = 0;
int n, m, u, v, b;
scanf("%d%d",&n,&m);
E = src = 0;
sink = n + 1;
memset(head,-1,sizeof(head));

for ( int i = 1; i <= n; i++ )
{
scanf("%d",&b);
if ( b > 0 )
{
sum += b;
add_edge ( src, i, b );
}
else add_edge ( i, sink, -b );
}

while ( m-- )
{
scanf("%d%d",&u,&v);
add_edge ( u, v, INF );
}

memset(vis,0,sizeof(vis));
__int64 maxFlow = Dinic();
int cnt = dfs ( src );
printf("%d %I64d\n", cnt - 1, sum - maxFlow );
return 0;
}

#include <algorithm>
#include <iostream>
using namespace std;

#define MAX 60000
#define INF 9999999999999
#define min(a,b) ((a)<(b)?(a):(b))

struct Edge
{
int st, ed;
int flow;
int next;
} edge[MAX*3];

int head[MAX], out[MAX];
int stk[MAX], que[MAX];
int leve[MAX], vis[MAX];
int E, src, sink;

void add_edge ( int u, int v, __int64 flw )
{
edge[E].st = u;
edge[E].ed = v;
edge[E].flow = flw;
edge[E].next = head[u];
head[u] = E++;

edge[E].st = v;
edge[E].ed = u;
edge[E].flow = 0;
edge[E].next = head[v];
head[v] = E++;
}

__int64 Dinic()
{
__int64 maxFlow = 0;
int front, rear, top;
int cur, u, i;
while ( 1 )
{
for ( i = src; i <= sink; i++ ) leve[i] = -1;
front = rear = leve[src] = 0;
que[rear++] = src;

while ( front != rear )
{
u = que[front];
front = ( front + 1 ) % MAX;
for ( i = head[u]; i != -1; i = edge[i].next)
{
if ( edge[i].flow > 0 && leve[edge[i].ed] == -1 )
{
leve[edge[i].ed] = leve[u] + 1;
que[rear]= edge[i].ed;
rear = ( rear + 1 ) % MAX;
}
}
}
if ( leve[sink] == -1 ) break;
for ( i = src; i <= sink; i++ ) out[i] = head[i];

top = 0;
while ( 1 )
{
if ( top == 0 )
{
for ( cur = out[src]; cur != -1; cur = edge[cur].next )
if ( edge[cur].flow > 0 && out[edge[cur].ed] != -1 && leve[edge[cur].ed] == 1 )
break;

if ( cur < 0 ) break;
stk[top++] = cur;
out[src] = edge[cur].next;

}
u = edge[stk[top-1]].ed;

if ( u == sink )
{
__int64 dd = INF, index = -1;
for ( i = top - 1; i >= 0; i-- )
{
if ( dd >= edge[stk[i]].flow )
{
dd = edge[stk[i]].flow;
index = i;
}
}
maxFlow += dd;

for ( i = 0; i < top; i++ )
{
edge[stk[i]].flow -= dd;
edge[stk[i]^1].flow += dd;
}
top = index;
}
else
{
for( cur = out[u]; cur != -1; cur = edge[cur].next )
if ( edge[cur].flow && out[edge[cur].ed] != -1 && leve[u] + 1 == leve[edge[cur].ed] )
break;

if ( cur != -1 )
{
stk[top++] = cur;
out[u] = edge[cur].next;
}
else
{
out[u] = -1;
top--;
}
}
}
}
return maxFlow;
}

int dfs ( int u )
{
vis[u] = true;
int v, i, cnt = 1;
for ( i = head[u]; i != -1; i = edge[i].next )
{
v = edge[i].ed;
if ( ! vis[v] && edge[i].flow > 0 )
cnt += dfs(v);
}
return cnt;
}

int main()
{
__int64 sum = 0;
int n, m, u, v, b;
scanf("%d%d",&n,&m);

E = src = 0;
sink = n + 1;
memset(head,-1,sizeof(head));

for ( int i = 1; i <= n; i++ )
{
scanf("%d",&b);
if ( b > 0 )
{
sum += b;
add_edge ( src, i, b );
}
else add_edge ( i, sink, -b );
}

while ( m-- )
{
scanf("%d%d",&u,&v);
add_edge ( u, v, INF );
}

memset(vis,0,sizeof(vis));
__int64 maxFlow = Dinic();
int cnt = dfs ( src ) - 1;
printf("%d %I64d\n", cnt, sum - maxFlow);
return 0;
}