hdu 4067 最小费用最大流

/*
题意：给出一个有n个点m条边的有向图，现在要从图中删去一些边使得图满足以下条件：
1.图中只有一个入口(s)和一个出口(t)
2.所以边都是单向的(这个原图已经保证了)
3.对入口(s)而言，其出度=入度+1
4.对出口(t)而言，其入度=出度+1
5.对入口(s)、出口(t)以外的点，其入度=出度
而对图中每条边，保留这条边或者删去这条边都有相应的花费，分别为a、b，求使得该图满足条件的最小花费。
解法：
   重新为每个边建立权值！
   1.如果有边（u,v,a,b) 并且a<=b，那么建立边（v,u,1，b-a) sum+=a,如果要恢复此边需花费 b-a 的费用；in[u]++,out[v]++;
   2.如果有边（u,v,a,b) 并且a>b，那么建立边（u,v,1，a-b) sum+=b,如果要删除此边需花费 a-b 的费用；
   3.另需t和s 建立一条虚边，in[s]++,out[t]++;
   最后建立一个超级源点S 和超级汇点T,则如果对于点 i in[i]>out[i] 那么建立边（S,i,in[i]-out[i]，0);
   相反 建立边（i,T,out[i]-in[i]，0);
   最小费用最大流后，如果max_flow=到汇点t所有容量只和 答案即为：sum+max_flow;
   否则 impossible；
*/

#include<iostream>
#include<algorithm>
#include<memory.h>
#include<queue>
#include<cstdio>
using namespace std;
const int M=202;
const int MAXN=8802;
const int inf=1<<19;
int pre[MAXN];          // pre[v] = k：在增广路上，到达点v的边的编号为k
int dis[MAXN];          // dis[u] = d：从起点s到点u的路径长为d
int vis[MAXN];         // inq[u]：点u是否在队列中
int path[MAXN];
int head[MAXN];
int n,m,NE,sink,tot,ans,max_flow,in[M],out[M];
struct node
{
    int u,v,cap,cost,next;
} Edge[MAXN];
void addEdge(int u,int v,int cap,int cost)
{
    Edge[NE].u=u;
    Edge[NE].v=v;
    Edge[NE].cap=cap;
    Edge[NE].cost=cost;
    Edge[NE].next=head[u];
    head[u]=NE++;
    Edge[NE].v=u;
    Edge[NE].u=v;
    Edge[NE].cap=0;
    Edge[NE].cost=-cost;
    Edge[NE].next=head[v];
    head[v]=NE++;
}
int SPFA(int s,int t)                   //  源点为0，汇点为sink。
{
    int i;
    for(i=s;i<=t;i++) dis[i]=inf;
    memset(vis,0,sizeof(vis));
    memset(pre,-1,sizeof(pre));
    dis[s] = 0;
    queue<int>q;
    q.push(s);
    vis[s] =1;
    while(!q.empty())        //  这里最好用队列，有广搜的意思，堆栈像深搜。
    {
        int u =q.front();
        q.pop();
        for(i = head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].v;
            if(Edge[i].cap >0&& dis[v] > dis[u] + Edge[i].cost)
            {
                dis[v] = dis[u] + Edge[i].cost;
                pre[v] = u;
                path[v]=i;
                if(!vis[v])
                {
                    vis[v] =1;
                    q.push(v);
                }
            }
        }
        vis[u] =0;
    }
    if(pre[t]==-1)
        return 0;
    return 1;
}
void end(int s,int t)
{
    int u, p,sum = inf;
    for(u=t; u!=s; u=pre[u])
    {
        sum = min(sum,Edge[path[u]].cap);
    }
    max_flow+=sum;
    for(u = t; u != s; u=pre[u])
    {
        Edge[path[u]].cap -= sum;
        Edge[path[u]^1].cap += sum;
        ans += sum*Edge[path[u]].cost;     //  cost记录的为单位流量费用，必须得乘以流量。
    }
}
int main()
{
    int i,j,k,cas,s,t,u,v,a,b,tt=1;
    cin>>cas;
    while(cas--)
    {
        scanf("%d%d%d%d",&n,&m,&s,&t);
        NE=0,tot=0,ans=0;
        max_flow=0;
        int S=0,T=n+1,sum=0;
        memset(head,-1,sizeof(head));
        memset(in,0,sizeof(in));
        in[s]++,--in[t];
        for(i=1;i<=m;i++)
        {
            scanf("%d%d%d%d",&u,&v,&a,&b);
            if(a<=b)
            {
                in[u]--,in[v]++;
                addEdge(v,u,1,b-a);
                sum+=a;
            }
            else addEdge(u,v,1,a-b),sum+=b;
        }
        for(i=1;i<=n;i++)
        {
            if(in[i]>0) addEdge(S,i,in[i],0);
            if(in[i]<0) addEdge(i,T,-in[i],0),tot+=-in[i];
        }
        while(SPFA(S,T))
        {
            end(S,T);
        }
        if(max_flow==tot)
        printf("Case %d: %d\n",tt++,sum+ans);
        else printf("Case %d: impossible\n",tt++);
    }
    return 0;
}