HDU3251 Being a Hero（最小割）

题目大概一个国家n个城市由m条单向边相连，摧毁每条边都有一个费用。现在你可以选择所给的f个城市中的若干个，每个城市选择后都有一定的价值，但首都1号城市必须到达不了你选择的城市，因为你可能需要摧毁一些边，这样你的获利就是选择城市的价值和减摧毁边的总花费。问，最大的获利是多少以及摧毁哪些边。

如此建容量网络：首都作为源点，原图中单向边的容量设为摧毁边的费用，所有可以选择的城市与汇点相连容量为选择该城市能获得的价值。

这样这个容量网络的S-T割，就能把首都划分到S集合要选择的划分到T集合二者分开，且其最小割就是最小的需要的耗费，耗费由摧毁边的费用和不选择某城市失去的价值组成，最大获利就是f个城市的价值和-最小割。

题目还要求最小割边集的割边，从源点floodfill得到的就是S集合的点，而所有一个端点在S集合另一端点在T集合的边就是最小割边集中的割边。

#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
#define INF (1<<30)
#define MAXN 1111
#define MAXM 220000

struct Edge{
    int id,v,cap,flow,next;
}edge[MAXM];
int vs,vt,NE,NV;
int head[MAXN];

void addEdge(int id,int u,int v,int cap){
    edge[NE].id=id; edge[NE].v=v; edge[NE].cap=cap; edge[NE].flow=0;
    edge[NE].next=head[u]; head[u]=NE++;
    edge[NE].id=id; edge[NE].v=u; edge[NE].cap=0; edge[NE].flow=0;
    edge[NE].next=head[v]; head[v]=NE++;
}

int level[MAXN];
int gap[MAXN];
void bfs(){
    memset(level,-1,sizeof(level));
    memset(gap,0,sizeof(gap));
    level[vt]=0;
    gap[level[vt]]++;
    queue<int> que;
    que.push(vt);
    while(!que.empty()){
        int u=que.front(); que.pop();
        for(int i=head[u]; i!=-1; i=edge[i].next){
            int v=edge[i].v;
            if(level[v]!=-1) continue;
            level[v]=level[u]+1;
            gap[level[v]]++;
            que.push(v);
        }
    }
}

int pre[MAXN];
int cur[MAXN];
int ISAP(){
    bfs();
    memset(pre,-1,sizeof(pre));
    memcpy(cur,head,sizeof(head));
    int u=pre[vs]=vs,flow=0,aug=INF;
    gap[0]=NV;
    while(level[vs]<NV){
        bool flag=false;
        for(int &i=cur[u]; i!=-1; i=edge[i].next){
            int v=edge[i].v;
            if(edge[i].cap!=edge[i].flow && level[u]==level[v]+1){
                flag=true;
                pre[v]=u;
                u=v;
                //aug=(aug==-1?edge[i].cap:min(aug,edge[i].cap));
                aug=min(aug,edge[i].cap-edge[i].flow);
                if(v==vt){
                    flow+=aug;
                    for(u=pre[v]; v!=vs; v=u,u=pre[u]){
                        edge[cur[u]].flow+=aug;
                        edge[cur[u]^1].flow-=aug;
                    }
                    //aug=-1;
                    aug=INF;
                }
                break;
            }
        }
        if(flag) continue;
        int minlevel=NV;
        for(int i=head[u]; i!=-1; i=edge[i].next){
            int v=edge[i].v;
            if(edge[i].cap!=edge[i].flow && level[v]<minlevel){
                minlevel=level[v];
                cur[u]=i;
            }
        }
        if(--gap[level[u]]==0) break;
        level[u]=minlevel+1;
        gap[level[u]]++;
        u=pre[u];
    }
    return flow;
}

bool vis[MAXN];
void dfs(int u){
    vis[u]=1;
    for(int i=head[u]; i!=-1; i=edge[i].next){
        int v=edge[i].v;
        if(vis[v] || edge[i].cap==edge[i].flow) continue;
        dfs(v);
    }
}
int ans[100100];
int main(){
    int t,n,m,f,a,b,c;
    scanf("%d",&t);
    for(int cse=1; cse<=t; ++cse){
        scanf("%d%d%d",&n,&m,&f);
        vs=1; vt=0; NV=n+1; NE=0;
        memset(head,-1,sizeof(head));
        for(int i=1; i<=m; ++i){
            scanf("%d%d%d",&a,&b,&c);
            addEdge(i,a,b,c);
        }
        int tot=0;
        while(f--){
            scanf("%d%d",&a,&b);
            tot+=b;
            addEdge(0,a,vt,b);
        }
        printf("Case %d: %d
",cse,tot-ISAP());
        memset(vis,0,sizeof(vis));
        dfs(vs);
        tot=0;
        for(int i=0; i<NE; i+=2){
            int u=edge[i^1].v,v=edge[i].v;
            if(vis[u] && !vis[v] && edge[i].id) ans[tot++]=edge[i].id;
        }
        printf("%d",tot);
        for(int i=0; i<tot; ++i) printf(" %d",ans[i]);
        putchar('
');
    }
    return 0;
}