poj 2135 最小费用最大流模板题

题目：http://poj.org/problem?id=2135

题意：

给出一个无向图，找两条不同的路从1到n。

分析：

对于此题,拿过来一看，想了一下，因为来回不可以走相同的边，所以可以做两次最短路，中间记录最短路径，做完第一次后把最短路径删掉，然后再做一次最短路，这不就可以了吗？于是很快敲完，然后交WA，然后反复看代码，以为代码出错了，但是找了半天bug，代码绝对没错啊！画了一遍图，发现整个思路就是错的，因为删完边后，可能从s到t就不连通了，就算连通，也有可能不是最短路了。还得用最小费用最大流来做啊！

方法：

因为每条边只能经过一次，可以设置这条边的容量是1，费用就是长度。然后增加一个源点s和一个汇点t，从s到1结点连一条容量是2费用是0的弧，对于汇点t也是一样，这样就构建好了一个最小费用最大流的图了。但是需要注意的是，题目给出的是无向图，所以建边的时候要正反两个方向各键一次。

最小费用最大流：

#include<iostream>
#include <algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
typedef long long ll;
const int INF=100000000;
const int N=1005;
struct edge
{
    int from,to,cap,flow,cost;
    edge(int u,int v,int c,int f,int co):from(u),to(v),cap(c),flow(f),cost(co){}
};
struct MCMF
{
    int n,m;
    vector<edge>edges;
    vector<int>g[N];
    int inq[N];
    int d[N];
    int p[N];
    int a[N];
    void init(int n){
        this->n=n;
        for(int i=0;i<=n;i++)g[i].clear();
        edges.clear();
    }
    void addedge(int from,int to,int cap,int cost){
        edges.push_back(edge(from,to,cap,0,cost));
        edges.push_back(edge(to,from,0,0,-cost));
        m=edges.size();
        g[from].push_back(m-2);
        g[to].push_back(m-1);
    }
    bool spfa(int s,int t,int &flow,int &cost){
        for(int i=0;i<=n;i++)d[i]=INF;
        memset(inq,0,sizeof(inq));
        d[s]=0;inq[s]=1;p[s]=0;a[s]=INF;
        queue<int>q;
        q.push(s);
        while(!q.empty()){
            int u=q.front();q.pop();
            inq[u]=0;
            for(int i=0;i<g[u].size();i++){
                edge &e=edges[g[u][i]];
                if(e.cap>e.flow&&d[e.to]>d[u]+e.cost){
                    d[e.to]=d[u]+e.cost;
                    p[e.to]=g[u][i];
                    a[e.to]=min(a[u],e.cap-e.flow);
                    if(!inq[e.to]){q.push(e.to);inq[e.to]=1;}
                }
            }
        }
        if(d[t]==INF)return 0;
        flow+=a[t];
        cost+=d[t]*a[t];
        for(int u=t;u!=s;u=edges[p[u]].from){
            edges[p[u]].flow+=a[t];
            edges[p[u]^1].flow-=a[t];
        }
        return 1;
    }
    int MincoatMaxflow(int s,int t,int& cost){
        int flow=0;cost=0;
        while(spfa(s,t,flow,cost));
        return flow;
    }
};
int main()
{
    int m,n;
    MCMF mcmf;
    scanf("%d%d",&n,&m);
    mcmf.init(n+1);
    while(m--){
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        mcmf.addedge(u,v,1,w);
        mcmf.addedge(v,u,1,w);
    }
    mcmf.addedge(0,1,2,0);
    mcmf.addedge(n,n+1,2,0);
    n++;
    int cost=0;
    int ans=mcmf.MincoatMaxflow(0,n,cost);
    cout<<cost<<endl;
    return 0;
}

dijkstra最短路：

WA：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
const int INF=1e8;
const int INF2=1e9;
const int N=1005;
struct edge
{
    int from,to,dis;
    edge(int u,int v,int d):from(u),to(v),dis(d){}
};
struct node
{
    int d,u;
    node(int d,int u):d(d),u(u){}
    bool operator < (const node &rhs)const{
        d>rhs.d;
    }
};
struct Dijkstra
{
    int n,m;
    vector<edge>edges;
    vector<int>g[N];
    bool vis[N];
    int d[N],p[N];
    void init(int n){
        this->n=n;
        for(int i=0;i<=n;i++)g[i].clear();
        edges.clear();
    }
    void addedge(int from,int to,int dis){
        edges.push_back(edge(from,to,dis));
        m=edges.size();
        g[from].push_back(m-1);
    }
    int dijkstra(int s){
        priority_queue<node>q;
       // memset(d,0x3f3f,sizeof(d));
        for(int i=0;i<=n;i++)d[i]=INF;
        d[s]=0;
        memset(vis,0,sizeof(vis));

        q.push(node(0,s));
        while(!q.empty()){
            node x=q.top();q.pop();
            int u=x.u;
            if(vis[u])continue;
            vis[u]=1;
            for(int i=0;i<g[u].size();i++){
                edge &e=edges[g[u][i]];
                if(d[e.to]>d[u]+e.dis){
                    d[e.to]=d[u]+e.dis;
                    p[e.to]=g[u][i];
                    q.push(node(d[e.to],e.to));
                }
            }
        }
        cout<<d[n]<<endl;
        return d[n];
    }
    void deledge(int s,int t)
    {
        for(int u=t;u!=s;u=edges[p[u]].from){
            edges[p[u]].dis=INF2;
        }
    }
};
int main()
{
    int n,m;
   // freopen("f.txt","r",stdin);
    scanf("%d%d",&n,&m);
    Dijkstra dij;
    dij.init(n);
    int u,v,w;
    while(m--){
        scanf("%d%d%d",&u,&v,&w);
        dij.addedge(u,v,w);
        dij.addedge(v,u,w);
    }
    int ans=dij.dijkstra(1);
    dij.deledge(1,n);
    ans+=dij.dijkstra(1);
    printf("%d\n",ans);
    return 0;
}