uva 10806 Dijkstra, Dijkstra.

题意：固定起点1和终点n，从1到n，再从n回到1，去和回的路上相同的边只能用一次，求两次的和最短，如果去的时候不能去到终点或者回的时候回不到起点那么就输出Back to jail，否则输出两次和的最小值（此图是无向图，不会有重边，边的权值在大于1小于1000）

两种理解

一种思路是最小费用最大流

另一种是最短路不唯一且两条或者多条最短路由共用边 ，或者最短路与次短路有共用边

我先写的是第二种思路，最小费用最大流还没写，明天补上，并且补上思路

 

第二种做法是，把无向图当做有向图处理，拆成两条边，先从1到n做一次最短路，并且要记录这条有向路径。最短路结束后，记录下最短路的值d[t],如果为d[t]=INF(t=n)说明图都不连通，从起点娶不到终点。

如果连通能去到，那么把这条路径上的边的值都取相反数，并且删除它的相反边，即赋值为INF

即  u--->v  是去的时候路径的其中有向边，那么g[u][v]=-g[u][v];  g[v][u]=INF;

然后从n到1再运行一遍最短路，因为这次有些边是负值，所以dij不能用，可以用spfa，所以我的代码两次都是spfa，写一个就行了，有些人是先写一个dij再写一个spfa也可以的

如果这次最短路d[t]=INF（此时的t=1），说明回不去了，那么失败

 

很多人见到题目，就是直接1到n一次最短路，n到1一次最短路，再求和，但是这样是错的，我也是这样做，WA

那么这个算法的正确性是什么呢

如果从1到n有两（多）条最短路，并且有些最短路没有共用边，即完全分离的，那么去的时候用 一条，回的时候用一条，互不干扰，最后的和就是最短路*2

同样的，如果只有1条最短路和次短路（1条和多条都无所谓），而且他们没有共用边，那么去的时候用最短路，回的时候用次短路，互不干扰。最后的和是最短路+次短路

但是，不幸的是，可能有两次最短路，但是却有共用边，那么去的时候肯定会用掉这条共用边，因为回来的时候不能再用这条共用边，那么是不是应该完全放弃另一条没有用过的最短路而另寻路径呢？不是的，而是可以用一个最好的方法，就是消去那条共用边的权（想想为什么来时候的边权要取反）

可以这样理解，两条最短路，都可以看成 前部分+共用边+后部分 ， 这里前部分和后部分都是独立的，没有共用的，那么综合两次的走法，其实可以变为 最短路1的前部分+最短路2的后部分，为去的路径，最短路2的后部分+最短路1的前部分，为回的路径，这样子，相当于交换了路径，但是我们并不关心路径，我们只关心两次和最小，这样并不改变和，而且还消掉了共用边的权，其实相当于两次走都没有进过共用边

所以这样的和为 最短路*2-所有共用边的权

 

同样，所过最短路和次短路有共用边，那么同样是相当于交叉了两次的路径，但是并不改变权和，而且消去了共用边的权

代码

#include <cstdio>

#include <cstring>

#include <queue>

#define INF 0x3f3f3f3f

#define N 220

using namespace std;

int g[N][N],d[N],path[N],vis[N],n,m,s,t;

int sum;



void spfa()

{

    queue <int> q;

    for(int i=1; i<=n; i++)

    {d[i]=INF; vis[i]=0; path[i]=s;}

    d[s]=0; q.push(s); vis[s]=1;

    while(!q.empty())

    {

        int u;

        u=q.front(); q.pop(); vis[u]=0;

        for(int v=1; v<=n; v++)

            if(d[u]+g[u][v]<d[v])

            {

                d[v]=d[u]+g[u][v];

                path[v]=u;

                if(!vis[v])

                {  q.push(v); vis[v]=1;  }

            }

    }

    return ;

}

void change(int v)

{

    int u=path[v];

    g[u][v]=-g[u][v];  //来时候的路径权取反

    g[v][u]=INF;      //消除方向边

    if(u==s) return ;

    change(u);

}

int main()

{

    while(scanf("%d",&n)!=EOF && n)

    {

        scanf("%d",&m);

        memset(g,0x3f,sizeof(g));

        for(int i=1; i<=m; i++)

        {

            int u,v,w;

            scanf("%d%d%d",&u,&v,&w);

            g[u][v]=g[v][u]=w;

        }

        s=1; t=n;

        spfa();

        sum=d[t];

        if(d[t]==INF)  //第一次都不能去到终点，说明图不连通

        {

            printf("Back to jail\n");

            continue;

        }

        change(t);  //修改路径上的权和消除反向路径

        s=n; t=1;

        spfa();   //第二次运行最短路

        if(d[t]==INF)

            printf("Back to jail\n");

        else

            printf("%d\n",sum+d[t]);

    }

    return 0;

}

 

明天再补上最小费用最大流的思想和代码

最小费用最大流：由于题目规定了起点和终点分别为1和n，所以我们另外设置一个源点和汇点0和n+1，0到1有一条有向边，n到n+1有一条有向边，这两条边的容量都是2，单位费用都是0

另外，题目给的边（无向边），全部拆成两条有向边，容量都是1，单位费用就是原本给的边权。然后求新源点0到新汇点n+1的最小费用最大流，如果最后最大流量为2，那么原问题成功，输出最小费用，最小费用即原问题的解。如果最大流量小于2，那么原问题失败，输出Back to jail

这个算法的正确性是什么呢？其实，原图的边，容量都设置为1，就起到了“每条边只走一次的要求”，因为每次增广后，某些边一定会满流，不会再经过，而从0出发到n+1，如果最后流量为2，那说明其实有两条路径能到达n+1，而从0到n+1，是必须经过1和n的，（别忘了我们怎么设置的那两条特殊的有向边和他们的容量）。而最小费用最大流是用费用来求解最短路，所以我们把边权设置为费用，这样一求，就等价于原问题了

 

#include <cstdio>

#include <cstring>

#include <queue>

using namespace std;

#define N 110

#define M 10010*4

#define INF 0x3f3f3f3f

struct edge

{int u,v,cap,cost,f,next;}e[M];

//一条有向边的信息有两个顶点，容量，费用，流量，指针

int d[N],first[N],p[M];

int C,F,n,m;



void add(int k,int u,int v,int cap,int cost,int f)

{

    e[k].u=u; e[k].v=v; 

    e[k].cap=cap;  e[k].cost=cost; e[k].f=f;

    e[k].next=first[u];

    first[u]=k;

}



void spfa(int s ,int t)

{//在还没有达到边的容量的条件下，以边权作为费用来寻找源点到汇点的最短路

    queue<int>q;

    int vis[N];

    memset(d,0x3f,sizeof(d));   d[s]=0;

    memset(vis,0,sizeof(vis));  vis[s]=1;

    memset(p,-1,sizeof(p));

    q.push(s);

    while(!q.empty())

    {

        int u,v,cap,cost,f;

        u=q.front(); q.pop(); vis[u]=0;

        for(int k=first[u]; k!=-1; k=e[k].next)

        {

            v=e[k].v; cap=e[k].cap; cost=e[k].cost; f=e[k].f;

            if(f<cap && d[u]+cost<d[v])

            {

                d[v]=d[u]+cost;

                p[v]=k;

                if(!vis[v])

                { q.push(v); vis[v]=1; }

            }

        }

    }

    return ;

}

void mincost_maxflow()

{

    int s,t;

    s=0; t=n+1;  //求从0到n+1的最小费用最大流

    C=F=0;

    while(1)

    {

        spfa(s,t);  //找最短路

        if(d[t]==INF)  //汇点不可达，说明已经达到了最小费用最大流

            break;

        int min=INF;  //保存最小残余流量

        for(int i=p[t]; i!=-1; i=p[e[i].u])  //沿路径返回

        {

            int cap=e[i].cap , f=e[i].f;

            min=min<cap-f ? min : cap-f;

        }



        for(int i=p[t]; i!=-1; i=p[e[i].u]) //增广

        {

            e[i].f+=min;

            e[i^1].f-=min;

        }



        F+=min;

        C+=d[t]*min;

    }



}

int main()

{

    while(scanf("%d",&n) && n)

    {

        scanf("%d",&m); m*=4;

        memset(first,-1,sizeof(first));

        for(int i=0; i<m; i+=4)

        {

            int u,v,w;

            scanf("%d%d%d",&u,&v,&w);

            //无向图最小费用最大流，1条边要当做4条处理

            add(i,u,v,1,w,0);

            add(i+1,v,u,0,-w,0);

            add(i+2,v,u,1,w,0);

            add(i+3,u,v,0,-w,0);

        }

        //一条有向边0-->1

        add(m,0,1,2,0,0);

        add(++m,1,0,0,0,0);

        //一条有向边n-->n+1

        add(++m,n,n+1,2,0,0);

        add(++m,n+1,n,0,0,0);



        mincost_maxflow();

        if(F==2) 

            printf("%d\n",C);

        else

            printf("Back to jail\n");

    }

    return 0;

}