题意：固定起点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; }