uva 10594 Data Flow

最小费用最大流：无向图（所以必须用邻接表）+当流量为D时的最小费用（即限制流量在D，求最大流）

题意：就是给你一个无向图，给出所有的无向边和它们的单位费用（题中说了不会有平行边），然后给出D,K，K是指每条无向边的容量固定为K，然后问当流量为D时最小费用是多少，如果流量无法得到D这个数值，那么就输出Impossible.  解决这个问题的方法就是限制流量，加一个新的源点（或者汇点，道理一样），增加一条有向边，就是新的源点指向原本的源点，这条有向边的容量就是D，费用是0，然后求新源点到汇点的最小费用最大流，可以知道，求出来的最大流一定是小于等于D的（同样是最大水流取决于最细水管的道理，水流必须从新的源点出发，必须而且只能经过新源点指向原本源点的那条有向边，所以最大流量只能小于等于这条有向边的容量D）

然后就是邻接表建图的问题

对于最大流问题，没有存在的有向边我们用cap[u][v]=0表示容量为0，而最小费用问题中即便不存在的边我们也要用cost[v][u]=-cost[u][v]表示取反的费用，所以最小费中一个有向边要变为两条来处理，所以一个无向边要变成两个有向边，再变两条，也就是一条无向边变为四条有向边处理

然后就是白书中介绍的求最小费用最大流问题的模板   SPFA+增广   不过要注意邻接表和邻接矩阵记录路径的方法不同，而且增广时也有区别，具体看代码

 

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const long long INF=1000000000000000000;
#define N 110
#define M 5010
struct edge
{
    int u,v,next;
    long long cost,flow;
}e[M*4];
int n,m,s,t;
long long D,K,F,C;
long long d[N];
int edgenum;   //最终边集数组里面的边的条数
int first[N],p[N];
void add(int u , int v ,long long c , long long f)
{
    e[edgenum].u=u;
    e[edgenum].v=v;
    e[edgenum].cost=c;
    e[edgenum].flow=f;
    e[edgenum].next=first[u];
    first[u]=edgenum;
    edgenum++;  //边集数组当前的下标
}

void print_graph()
{
    for(int i=0; i<=n; i++)
    {
        printf("%d:_______________\n",i);
        for(int k=first[i]; k!=-1; k=e[k].next)
            printf("%d\\%lld\\%lld\n",e[k].v,e[k].cost,e[k].flow);
    }
    printf("**********\n");
    return ;
}
void SPFA()
{
    queue <int> q;
    int vis[N];
    for(int i=0; i<=n; i++) 
    d[i]=INF; 
    memset(vis,0,sizeof(vis));
    memset(p,-1,sizeof(p)); 
    d[s]=0; vis[s]=1;
    q.push(s);

    while(!q.empty())
    {
        int u=q.front(); vis[u]=0; q.pop();
        for(int k=first[u]; k!=-1; k=e[k].next) //遍历点u的邻接表
        {
            int v=e[k].v;
            long long c=e[k].cost , f=e[k].flow;
            if( f && d[u]+c < d[v])
            {
                p[v]=k; 
                //邻接表的记录方法是记录点v但是所对应的边k，就可以知道该边的所有信息了
                d[v]=d[u]+c;
                if(!vis[v])
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return ;
}
int mincost_maxflow()
{
    F=C=0;
    while(1)
    {
        SPFA();
        if(d[t]==INF)  break;
        
        long long a=INF;
        for(int k=p[t]; k!=-1; k=p[e[k].u]) //这里的k是指第k条边，不再是邻接矩阵里面的顶点
            if(e[k].flow<a) a=e[k].flow;
        for(int k=p[t]; k!=-1; k=p[e[k].u]) //增广，这里的k是指第k条边，不再是邻接矩阵里面的顶点
        {
            e[k].flow-=a;  
            e[k^1].flow+=a;  //因为之前的add函数的排列顺序才能这样使用位运算
        }

        F+=a;
        C+=a*d[t];
        //printf("a=%lld  d[t]=%lld  F=%lld   C=%lld\n",a,d[t],F,C);
    }
    //printf("F=%lld   C=%lld\n",F,C);
    return F==D?C:-1;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        int uu[M],vv[M]; long long cc[M];
        for(int i=1; i<=m; i++)  //先临时保存无向边
            scanf("%d%d%lld",&uu[i],&vv[i],&cc[i]);
        scanf("%lld%lld",&D,&K);
        edgenum=0; //为方便后面的位运算，边集数组要从下标0开始保存
        memset(first,-1,sizeof(first));  //所以first数组初始化为-1
        for(int i=1; i<=m; i++)  //处理所有的无向边
        {//下面4个add函数里面的参数这样排列是必要的，不要搞乱
            add(uu[i] , vv[i] , cc[i] , K);  //有向边<u,v>,费用c，容量K
            add(vv[i] , uu[i] , -cc[i] , 0);  //其反向，费用取反，容量为0
            add(vv[i] , uu[i] , cc[i] , K);  //有向边<v,u>,费用c，容量K
            add(uu[i] , vv[i] , -cc[i] , 0);  //其反向，费用取反，容量为0
        }
        add(0,1,0,D);
        add(1,0,0,0);
        //最后要加上一个有向边<0,1>，和它的反向，即先添加的一个源点
        //容量限制为D，费用为0
        //print_graph();  //测试函数
        s=0;  t=n;
        mincost_maxflow();
        if(F==D) //最小费用最大流
            printf("%lld\n",C);
        else
            printf("Impossible.\n");
    }
    return 0;
}