Our Journey of Dalian Ends (最小费用最大流)

题意：
给定若干个城市，出发点为大连，目的地为西安，要求中途必须经过上海，并且图中每个城市只能经过一次，给出m条路(双向路)，走第i条路需要wi代价，求所有满足要求的方案中花费的最小代价，如果没有满足的方案，输出-1。

建图思路：
相当于求从大连到上海加上西安到上海花费的代价总和最小。所以就是最小费用最大流，点只可走一次，所以进行拆点，一个入点一个出点，每条路连接至相应的出点到入点，容量为1，花费为0。超级源点与大连、西安建边容量为1，花费为0，上海的入点作为超级汇点。如果最大流不为2，则表明没有满足的方案，否则最小费用即ans。

最小费用最大流思路：
（1）找到一条从源点到达汇点的“距离最短”的路径，“距离”使用该路径上的边的单位费用之和来衡量。
（2）然后找出这条路径上的边的容量的最小值ans，则当前最大流maxflow扩充ans，同时当前最小费用mincost扩充 ans*dis[T]。
（3）将这条路径上的每条正向边的容量都减少ans，每条反向边的容量都增加ans。
（4）重复（1）–（3）直到无法找到从源点到达汇点的路径。

最小费用最大流模板：

#define MAXN 4005  //点
#define MAXM 100000  //边
#define INF 0x3f3f3f3f
int S,T; //源点 汇点
struct Edge
{
    long long from,to,flow,worth,next; //结点，流量，费用，链表
    Edge() {}
    Edge(int fr,int ro,int fl,int wo,int ne)
    {
        from=fr,to=ro,flow=fl,worth=wo,next=ne;
    }
} edge[MAXM];

int head[MAXN]; // 建立链表
int top;  //边数
bool visque[MAXN]; //查看是否入队
int dis[MAXN]; //最小距离
int pre[MAXN],prx[MAXN]; //记录路线用于更新残量图
queue<int>q;
void init() //初始化
{
    memset(head,0,sizeof(head));
    top=2;//必须是2
}

void addEdge(int from,int to,int flow,int worth)  //建图
{
    edge[top]=Edge(from,to,flow,worth,head[from]);
    head[from]=top++;

    edge[top]=Edge(to,from,0,-worth,head[to]);    //反向弧
    head[to]=top++;
}

int bfs() //寻找最短路
{
    while(!q.empty()) q.pop(); //初始化队列
    for(int i=0; i<MAXN; i++) dis[i]=INF; //初始化距离
    q.push(S); //源点入队
    dis[S]=0;
    visque[S]=true;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u]; i; i=edge[i].next)
        {
            if(edge[i].flow>0 && (dis[u]+edge[i].worth)<dis[edge[i].to])  //更新最短路
            {
                dis[edge[i].to]=dis[u]+edge[i].worth;
                pre[edge[i].to]=u;
                prx[edge[i].to]=i;
                if(!visque[edge[i].to])
                {
                    visque[edge[i].to]=true;
                    q.push(edge[i].to);
                }
            }
        }
        visque[u]=false; //前面已经让u出队了所以这里要写一下
    }
    return dis[T]!=INF; //判断是否可以到达汇点
}

pair<int,long long> dfs()
{
    int u=T;
    long long ans = INF;
    while(u!=S) //找当前路中的最小流量
    {
        if(edge[prx[u]].flow<ans) ans=edge[prx[u]].flow;
        u=pre[u];
    }
    u=T;
    while(u!=S) //更新残量图
    {
        edge[prx[u]].flow -= ans;
        edge[prx[u]^1].flow += ans;
        u=pre[u];
    }
    pair<int,long long> mcmf(ans,ans*dis[T]);
    return mcmf;
}
pair<int,long long> solve()
{
    int maxflow=0;
    long long mincost=0;
    pair<int,long long> ans;
    while(bfs())
    {
        ans = dfs();
        mincost += ans.first;
        maxflow += ans.second;
    }
    ans.first = mincost;
    ans.second = maxflow;
    return ans;
}