最小费用路算法模板

步骤0：初始可行0流
步骤1：如果不存在最小费用流，则计算结束，已经找到最小费用流；否则，用最短路算法(由于存在负圈，只能采用SPFA或者Bellman-Ford算法)在残留网络中找到源点到终点的最小费用可增广路，转步骤2。
步骤2：沿找到的最小费用可增广路增流，并转步骤1 。
int maxData = 10000000;
bool final[105];       //SPFA算法中标识结点是否在队列中
int d[105];
int flow[105][105];
int capacity[105][105];
int kcost[105][105];
int pre[105];
int ncount;         //代表结点个数
//残留网络中从源点到汇点的最小费用路是残留网络中从源点到汇点的以费用为权的最短路
void SPFA(int src)
{
    queue<int> myqueue;
    int i,j;
    memset(final,0,sizeof(final));
    memset(pre,-1,sizeof(pre));
    myqueue.push(src);
    for(i=0;i<=ncount;++i)      //SPFA算法与Dij不同，SPFA初始化时将除源点以外所有点的最短距离初始化无穷大,ncount为结点总数
    {
        d[i] = maxData;
    }
    d[src] = 0;        //源点最短距离设置成0
    final[src] = true;
    while(!myqueue.empty())     //SPFA算法可入队列多次
    {
        int frontint = myqueue.front();myqueue.pop();
        final[frontint] = false;
        for(i=0;i<=ncount;++i)
        {
            if(capacity[frontint][i]>flow[frontint][i] && d[i]>d[frontint]+kcost[frontint][i])     //c[u][v]>f[u][v]说明<u,v>之间流量可以进行增加
            {
                d[i] = d[frontint]+kcost[frontint][i];
                pre[i] = frontint;             //修改前驱
                if(!final[i])
                {
                    final[i] = true;
                    myqueue.push(i);
                }
            }
        }
    }
}
void minCost(int src,int des)
{
    int minAdd = maxData;
    int p;
    while(1)
    {
        SPFA(src);
        if(pre[des]==-1)           //表示已无增广路
            break;
        minAdd = maxData;
        p = des;
        while(pre[p]!=-1)
        {
            minAdd = min(minAdd,(capacity[pre[p]][p]-flow[pre[p]][p])); //求的增广路的可增流量
            p = pre[p];
        }
        p = des;
        while(pre[p]!=-1)         //沿着最小费用路进行增广
        {
            flow[pre[p]][p] += minAdd;
            flow[p][pre[p]] -= minAdd;
            p = pre[p];
        }   
    }   
}
int main()
{
    int src,des;
    int flowcost;          
    src = 0;            //超级源点
    des = N+M+1;        //超级汇点
   
    memset(capacity,0,sizeof(capacity));  //容量
    memset(kcost,0,sizeof(kcost));
    memset(flow,0,sizeof(flow));    //初始化可行流为0
  
    for(i=1;i<=M;++i)     
    {
        for(j=1;j<=N;++j)
        {
            kcost[i][j+M] = cost[t][i][j];
            kcost[j+M][i] = -kcost[i][j+M];   //负费用，表示回流会减小费用（千万别忘了）             
        }
    }
    minCost(src,des);
    for(i=1;i<=M;++i)
    {
        for(j=1;j<=N;++j)
        {
            flowcost += kcost[i][j+M]*flow[i][j+M]; //最小费用
        }
    }          
    printf("%d\n",flowcost);
    return 0;
}

 

转载于:https://www.cnblogs.com/north_dragon/archive/2010/05/30/1747690.html