链接:click here
题意:从2~n-1这几个点中任意去掉一个点,使得从1到n的最短路径最大,如果任意去掉一个点1~n无通路输出Inf。
去年这道题现场是队友1A过的,感觉好NB,当时还不会最短路问题,只是脑子里大概有这么个印象,做了之发现数据比较水,今天看了一下Dijkstra 和Floyd,用两种算法实现了一下:
题目描述有点长,但是搞清楚了,就很容易了,因为数据实在很水,算是最短路入门训练的一道题了
Dijkstra 算法
(1)令S={源点s + 已经确定了最短路径的顶点vi}
(2) 对任一未收录的顶点v,定义dist[v]为s到v的最
短路径长度,但该路径仅经过S中的顶点。即路径 的最小长度
(3) 若路径是按照递增(非递减)的顺序生成的,则
(4)真正的最短路必须只经过S中的顶点
(5)每次从未收录的顶点中选一个dist最小的收录(贪心)
(6)增加一个v进入S,可能影响另外一个w的dist值!
(7)dist[w] = min{dist[w], dist[v] + <v,w>的权重}
代码:
/*单源最短路问题(Dijkstra),适合没有负边的情况下,在Bellman-Ford算法中,如果d[i]还不是最短距离的话,
那么即使进行d[j]=d[i]+(从i到j的边的权值)的更新,d[j]也不会变成最短距离,而且,即使d[i]没有变化,
每一次循环也要检查一遍从i 出发的所有边,这显然是浪费时间的,因此,相对Bellman-Ford做了如下修改:
(1) 找到最短距离已经确定的顶点,从他出发更新相邻顶点的最短路径。(2) 不再考虑(1) 情况。
那么 如何找“最短距离已经确定的顶点”?在最开始时,只有起点的最短距离是确定的,而在尚未使用的顶点中,距离d[i]最小的顶点就是
已经确定的顶点,这是因为由于不存在负边的情况,所以d[i]在以后的更新中不会减小,这就是算法的由来
*/
/* time :0ms
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxn_v=35;
int V,m; //顶点数
int cost[maxn_v][maxn_v]; //cost[u][v]表示边e=(u,v)的权值
int d[maxn_v]; //顶点s出发的最短距离
bool used[maxn_v]; //已经使用过的图
void init() //初始化
{
for(int i=0; i<maxn_v; i++)
for(int j=0; j<maxn_v; j++)
{
if(i==j) cost[i][j]=0;
else cost[i][j]=inf;
}
}
void input() //将点,边存入图中
{
int u,v,quan;
for(int i=0; i<m; i++)
{
scanf("%d %d %d",&u,&v,&quan);
cost[u][v]=cost[v][u]=quan; //因为是无向图,权值一样
}
}
int dijkstra(int s) //求出从s出发到各个顶点的最短距离
{
for(int i=0; i<maxn_v; i++)
d[i]=inf; //d[0]=0,其他d[i]=Inf;
memset(used,false,sizeof(used));
used[s]=true;
d[1]=0;
while(true)
{
int v=-1;
for(int u=0; u<V; u++) //尚未使用过的顶点中选择一个距离最小的点
{
if(!used[u] &&(v==-1||d[u]<d[v]))
v=u;
}
if(v==-1) break;
used[v]=true;
for(int u=1; u<=V; u++)
d[u]=min(d[u],d[v]+cost[v][u]);
}
return d[V];
}
void solve()
{
int ans=-1;
for(int i=2; i<V; i++)
{
int t=dijkstra(i);
if(t==inf) //不符合
{
printf("Inf\n");
return ;
}
else ans=max(ans,t); //依次更新
}
printf("%d\n",ans);
}
int main()
{
while(~scanf("%d %d",&V,&m),V+m)
{
init();
input();
solve();
}
return 0;
}
/*Floyd - Warshall算法
求解所有两点间的最短路的问题叫做任意两点间的最短路问题, 用Dp的思想来模拟一下过程:
只使用顶点0~ k 的和i,j的情况下,记录i 到j 的最短路径为 d[k+1][i][j],k=-1时,认为只使用了i,j
所以d[0][i][j]=cost[i][j]; 接下来把只使用顶点0~k的问题归纳为到只使用0~k-1上。
只使用0~k时,分i到j的最短路为经过顶点k和不经过顶点k两种问题来讨论。
不经过的情况下:
d[k][i][j]=d[k-1][i][j],
经过的情况下:
d[k][i][j]=d[k-1][i][k]+d[k-1][k][j];
结合起来就是:d[k][i][j]=min(d[k-1][i][j],d[k-1][i][k]+d[k-1][k][j]);
可以在O(n^3)的时间复杂度里求解所有两点间的最短距离,跟Dijkstra 算法比较,Floyd - Warshall
可以处理边是负数的情况,而要判断图中是否有负圈,只需检查是否存在d[i][i]是负数的顶点就可以。
*/
/*time:15ms
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 35;
const int Inf = 1e8;
int V; //顶点数
int m, D[N][N];
int G[N][N]; //G[u][v] 表示边e=(u,v)的权值(不存在时设为INF,记G[i][i]=0;)
int solve(int x)
{
for(int i=1; i<=V; i++)
{
for(int j=1; j<=V; j++)
{
if(i==x||j==x) G[i][j]=Inf;
else G[i][j]=D[i][j];
}
}
for(int k=1; k<=V; k++)
{
for(int i=1; i<=V; i++)
{
for(int j=1; j<=V; j++)
G[i][j]=min(G[i][j],G[i][k]+G[k][j]);
}
}
return G[1][V];
}
void input()
{
for(int i=1; i<=V; i++)
{
for(int j=1; j<=V; j++)
D[i][j]=(i==j)?0:Inf;
}
}
void init()
{
for(int i=0; i<m; i++)
{
int u,v,quan;
scanf("%d%d%d",&u,&v,&quan);
D[u][v]=min(D[u][v],quan);
D[v][u]=D[u][v];
}
}
void output()
{
int ans=0;
for(int i=2; i<V; i++)
{
ans=max(ans,solve(i));
}
if(ans==Inf) puts("Inf");
else printf("%d\n", ans);
}
int main()
{
while(~scanf("%d%d",&V,&m),V+m)
{
input();
init();
output();
}
return 0;
}