最短路（Floyed、Dijkstra、Bellman-Ford、SPFA）

一、Floyed-Warshall算法

枚举中间点起点终点，对整个图进行松弛操作，就能得到整个图的多源最短路径；

例：POJ2240　　Arbitrage

Arbitrage is the use of discrepancies in currency exchange rates to transform one unit of a currency into more than one unit of the same currency. For example, suppose that 1 US Dollar buys 0.5 British pound, 1 British pound buys 10.0 French francs, and 1 French franc buys 0.21 US dollar. Then, by converting currencies, a clever trader can start with 1 US dollar and buy 0.5 * 10.0 * 0.21 = 1.05 US dollars, making a profit of 5 percent. 

Your job is to write a program that takes a list of currency exchange rates as input and then determines whether arbitrage is possible or not. 

Input

The input will contain one or more test cases. Om the first line of each test case there is an integer n (1<=n<=30), representing the number of different currencies. The next n lines each contain the name of one currency. Within a name no spaces will appear. The next line contains one integer m, representing the length of the table to follow. The last m lines each contain the name ci of a source currency, a real number rij which represents the exchange rate from ci to cj and a name cj of the destination currency. Exchanges which do not appear in the table are impossible. 
Test cases are separated from each other by a blank line. Input is terminated by a value of zero (0) for n.

Output

For each test case, print one line telling whether arbitrage is possible or not in the format "Case case: Yes" respectively "Case case: No".

Sample Input

3
USDollar
BritishPound
FrenchFranc
3
USDollar 0.5 BritishPound
BritishPound 10.0 FrenchFranc
FrenchFranc 0.21 USDollar

3
USDollar
BritishPound
FrenchFranc
6
USDollar 0.5 BritishPound
USDollar 4.9 FrenchFranc
BritishPound 10.0 FrenchFranc
BritishPound 1.99 USDollar
FrenchFranc 0.09 BritishPound
FrenchFranc 0.19 USDollar

0

Sample Output

Case 1: Yes
Case 2: No

Source

Ulm Local 1996

#include <iostream>
#include <cstdio>
#include <map>
using namespace std;
const int maxn=35;
int n,m;
map<string,int> N;
double dis[maxn][maxn];

int main()
{
    int kase=1;
    //freopen("Atext.in","r",stdin);
    while(cin >> n,n)
    {
        string a,b;
        double tmp;
        bool flag=false;
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                dis[i][j]=-1;
        for(int i=0;i<n;i++){
            cin >> a;
            N.insert(make_pair(a,i));
        }
        cin >> m;
        for(int i=0;i<m;i++)
        {
            cin >> a >> tmp >> b;
            dis[N[a]][N[b]]=tmp;        //邻接矩阵存边的信息;
        }
        for(int k=0;k<n;k++)
            for(int i=0;i<n;i++)
                for(int j=0;j<n;j++)
                if(i!=j&&j!=k&&k!=i&&dis[i][k]!=-1&&dis[k][j]!=-1)
                dis[i][j]=max(dis[i][k]*dis[k][j],dis[i][j]);
        /*for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
                cout << dis[i][j] << " ";
            cout << endl;
        }
        cout << endl;*/
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
            if(dis[i][j]*dis[j][i]>1)flag=1;
        printf("Case %d: %s\n",kase,flag?"Yes":"No");
        N.clear();
        kase++;
    }
    return 0;
}

附：Warshall算法的传递闭包

例：POJ2253　　Frogger

Description

Freddy Frog is sitting on a stone in the middle of a lake. Suddenly he notices Fiona Frog who is sitting on another stone. He plans to visit her, but since the water is dirty and full of tourists' sunscreen, he wants to avoid swimming and instead reach her by jumping. 
Unfortunately Fiona's stone is out of his jump range. Therefore Freddy considers to use other stones as intermediate stops and reach her by a sequence of several small jumps. 
To execute a given sequence of jumps, a frog's jump range obviously must be at least as long as the longest jump occuring in the sequence. 
The frog distance (humans also call it minimax distance) between two stones therefore is defined as the minimum necessary jump range over all possible paths between the two stones. 

You are given the coordinates of Freddy's stone, Fiona's stone and all other stones in the lake. Your job is to compute the frog distance between Freddy's and Fiona's stone. 

Input

The input will contain one or more test cases. The first line of each test case will contain the number of stones n (2<=n<=200). The next n lines each contain two integers xi,yi (0 <= xi,yi <= 1000) representing the coordinates of stone #i. Stone #1 is Freddy's stone, stone #2 is Fiona's stone, the other n-2 stones are unoccupied. There's a blank line following each test case. Input is terminated by a value of zero (0) for n.

Output

For each test case, print a line saying "Scenario #x" and a line saying "Frog Distance = y" where x is replaced by the test case number (they are numbered from 1) and y is replaced by the appropriate real number, printed to three decimals. Put a blank line after each test case, even after the last one.

Sample Input

2
0 0
3 4

3
17 4
19 4
18 5

0

Sample Output

Scenario #1
Frog Distance = 5.000

Scenario #2
Frog Distance = 1.414

Source

Ulm Local 1997

#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long ll;
const int maxn=205;
struct node{
    int x,y;
}N[maxn];
int con[maxn][maxn],n;
double G[maxn][maxn];
void floyed()       //枚举所有边进行松弛;
{
    for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)    //松弛为最大边的最小值;
            G[i][j]=min(G[i][j],max(G[i][k],G[k][j]));
}
int main()
{
    int kase=0;
    while(~scanf("%d",&n),n)
    {
        for(int i=0;i<n;i++)
            scanf("%d%d",&N[i].x,&N[i].y);
        for(int i=0;i<n;i++)        //这样对称的邻接矩阵只须计算一半
            for(int j=i+1;j<n;j++)
                G[i][j]=G[j][i]=(double)sqrt(double(N[i].x-N[j].x)*(N[i].x-N[j].x)+double(N[i].y-N[j].y)*(N[i].y-N[j].y));
        floyed();
        printf("Scenario #%d\n",++kase);
        printf("Frog Distance = %.3lf\n\n",G[0][1]);
    }
    return 0;
}

二、Dijkstra算法

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
const int maxn=1005;
const int inf=0x3f3f3f3f;
int n;
struct node{
    int x,y;
}N[maxn];
bool vis[maxn];
double G[maxn][maxn],d[maxn];       //邻接矩阵
void Dijkstra()
{
    fill(vis,vis+n,false);
    fill(d,d+n,inf);
    d[0]=0;
    while(true)
    {
        int v=-1;
        for(int i=0;i<n;i++)
            if(!vis[i]&&(v==-1||d[i]<d[v]))     //从尚未使用过的顶点中选取一个最小值；
                v=i;
        if(v==-1)
            break;
        vis[v]=true;
        for(int i=0;i<n;i++)
            d[i]=min(d[i],max(d[v],G[v][i]));   //源点到各点的最长边的最小值;
    }
}
int main()
{
    int kase=0;
    while(~scanf("%d",&n),n)
    {
        for(int i=0;i<n;i++)
            scanf("%d%d",&N[i].x,&N[i].y);
        for(int i=0;i<n;i++)        //这样对称的邻接矩阵只须计算一半
            for(int j=i+1;j<n;j++)
                G[i][j]=G[j][i]=(double)sqrt(double(N[i].x-N[j].x)*(N[i].x-N[j].x)+double(N[i].y-N[j].y)*(N[i].y-N[j].y));
        Dijkstra();
        printf("Scenario #%d\n",++kase);
        printf("Frog Distance = %.3f\n\n",d[1]);
    }
    return 0;
}

三、Bellman-Ford算法

四、SPFA算法（Shortest Path Faster Algorithm）

队列优化的bellman-ford；

例：POJ1874　　畅通工程续

Problem Description

某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。

现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。

 

Input

本题目包含多组数据，请处理到文件结束。
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0～N-1编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0<=A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。
再接下一行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。

 

Output

对于每组数据，请在一行里输出最短需要行走的距离。如果不存在从S到T的路线，就输出-1.

 

Sample Input

3 3
0 1 1
0 2 3
1 2 1
0 2
3 1
0 1 1
1 2

 

Sample Output

2
-1

 

Author

linle

 

Source

2008浙大研究生复试热身赛（2）——全真模拟

解法1：spfa　　2.floyed　　3.dijkstra

#include <iostream>
#include <queue>
#include <cstdio>
#include <vector>
using namespace std;
const int maxn=205;
const int inf=0x3f3f3f3f;
typedef pair<int,int> p;
vector<p>E[maxn];//邻接表;
int n,m,d[maxn],inq[maxn];      //d[maxn]到源点的最短距离,inq[maxn]在队列里的元素;
void init()
{
    for(int i=0;i<n;i++)E[i].clear();
    for(int i=0;i<n;i++)inq[i]=0;
    for(int i=0;i<n;i++)d[i]=inf;
}
void spfa(int x)
{
    queue<int> que;
    que.push(x),d[x]=0,inq[x]=1;
    while(!que.empty())
    {
        int now=que.front();
        que.pop();
        inq[now]=0;
        for(int i=0;i<E[now].size();i++)
        {
            int v=E[now][i].first;
            if(d[v]>d[now]+E[now][i].second)
            {
                d[v]=d[now]+E[now][i].second;
                if(inq[v]==0){
                    inq[v]=1;
                    que.push(v);
                }
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        int a,b,c;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            E[a].push_back(p(b,c));
            E[b].push_back(p(a,c));
        }
        scanf("%d%d",&a,&b);
        spfa(a);
        if(d[b]==inf)
            cout << -1 << endl;
        else
            cout << d[b] << endl;
    }
    return 0;
}

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=205;
const int inf=0x3f3f3f3f;
int n,m,maze[maxn][maxn];

void floyed()
{
    for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
            if(i!=j&&j!=k&&k!=i)
            maze[i][j]=min(maze[i][j],maze[i][k]+maze[k][j]);
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        int a,b,c;
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
            {
                if(i!=j)
                maze[i][j]=inf;
            }
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            maze[a][b]=min(c,maze[a][b]);//处理解决重边问题;
            maze[b][a]=min(c,maze[b][a]);
        }
        scanf("%d%d",&a,&b);
        floyed();
        if(maze[a][b]==inf)
            cout << -1 << endl;
        else
            cout << maze[a][b] <<endl;
    }
    return 0;
}

//自我整理：最短路径的这三个算法，就像BFS一样;
//spfa:每次把发生更新的点作为当前到该点的最短路径，都入队列视为下一次遍历开始的源点;
//dijkstra:每次只取所有发生更新的点，即所有当前最短路径中里离源点最近的点作为下一次开始的源点，前面的值都视为已确定的最短路径