Double Shortest Paths CSU - 1506-最小費用流

題目：

題目地址

題目大意：

有兩個人要從點1走到點n；給出路徑之間第一個人走所需要的費用和第二個人走所需要的費用（第二個人如果走的路是第一個人走過的,那麼就在第一個人所需的 費用上再加上第二次的費用）
求兩個人一共所需要的最小費用！

思路：

比賽的時候翻書看到費用流就感覺很像，可惜從來沒學過也沒寫過費用流，照着模板敲也因爲不理解費用流(qaq所以有幾個地方需要更改也不知道)根本跑不出結果。

別人的解釋：

兩點之間建兩條邊，分別爲 容量1費用d 和 容量1費用d+a。由於模板求的是最小費用最大流，而本題需要限制流量爲2，所以需要另設源點和匯點(容量爲2) 來限制流量.

代碼：

(這是用spfa增廣的算法,先當模板湊合用，稍微理解一點點用法了)

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
using namespace std;
typedef long long ll;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int maxn = 6789;
int T,n,m;

struct Edge
{
    int to,next,cap,flow,cost;
    Edge(){}
    Edge(int _to,int _next,int _cap,int _flow,int _cost)
    {
        to=_to;next=_next;cap=_cap;flow=_flow;cost=_cost;
    }
}e[maxn];

int tot;
int head[maxn];//鄰接表存圖專用
int pre[maxn]; //儲存前驅頂點
int dis[maxn]; //儲存到源點s的距離
bool vis[maxn];//是否被放進隊列中,spfa專用
int N;//節點總個數,節點編號從0~N-1

void init(int n)
{
    tot=0;
    N=n+2;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int cap,int cost)
{
    e[tot]=Edge(v,head[u],cap,0,cost);
    head[u]=tot++;

    e[tot]=Edge(u,head[v],0,0,-cost);
    head[v]=tot++;
}

bool spfa(int s,int t)//spfa增廣
{
    queue<int>q;
    for (int i=0;i<N;i++)
    {
        dis[i]=INF;
        vis[i]=false;
        pre[i]=-1;
    }
    dis[s]=0;
    vis[s]=true;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=false;
        for(int i=head[u];i!=-1;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i].cap>e[i].flow&&dis[v]>dis[u]+e[i].cost)
            {
                dis[v]=dis[u]+e[i].cost;
                pre[v]=i;
                if(!vis[v])
                {
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
    if(pre[t]==-1)
        return false;
    else
        return true;
}

//返回的是最大流,cost存的是最小費用
int minCostMaxflow(int s, int t, int &cost)
{
    int flow=0;
    cost=0;
    while(spfa(s,t))
    {
        int Min=INF;
        for (int i=pre[t];i!=-1;i=pre[e[i^1].to])
        {
            if(Min>e[i].cap-e[i].flow)
                Min=e[i].cap-e[i].flow;
        }
        for(int i=pre[t];i!=-1;i=pre[e[i^1].to])
        {
            e[i].flow+=Min;
            e[i^1].flow-=Min;
            cost+=e[i].cost*Min;
        }
        flow+=Min;
    }
    return flow;
}

int main()
{
    int n,m;
    int no=0;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init(n);
        int s=0,t=n+1;
        //建立一個超源點和超匯點0,n+1
        //因爲0到1和n到n+1這兩條邊肯定會走兩次,於是cap設爲2,費用設爲0
        add_edge(s,1,2,0);
        add_edge(n,t,2,0);
        for(int i=1;i<=m;i++)
        {
            int u,v,a,b;
            scanf("%d%d%d%d",&u,&v,&a,&b);
            add_edge(u,v,1,a);//因爲一條邊只能一個人走,於是cap(容量)置爲1
            add_edge(u,v,1,a+b);
        }
        int ans=0;
        minCostMaxflow(s,t,ans);
        printf("Case %d: %d\n",++no,ans);
    }
    return 0;
}