图论trainning-part-1 A. 最短路

A. 最短路

Time Limit: 1000ms

Memory Limit: 32768KB

64-bit integer IO format: %I64d      Java class name: Main

 

在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？

 

Input

输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间走过这条路。
输入保证至少存在1条商店到赛场的路线。

 

Output

对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间

 

Sample Input

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

Sample Output

3
2


解题：最短路。。。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <climits>
#include <vector>
#include <queue>
#include <cstdlib>
#include <string>
#include <set>
#define LL long long
#define INF 0x3f3f3f
using namespace std;
int mp[110][110],d[110],n,m;
bool vis[110];
void dij(){
    int i,j,theMin,index;
    for(i = 0; i <= n; i++)
        d[i] = INF>>1;
    d[1] = 0;
    memset(vis,false,sizeof(vis));
    for(i = 0; i < n; i++){
        theMin = INF;
        for(j = 1; j <= n; j++){
            if(!vis[j] && theMin > d[j]) theMin = d[index = j];
        }
        vis[index] = true;
        if(index == n) break;
        for(j = 1; j <= n; j++){
            if(!vis[j] && d[j] > d[index]+mp[index][j])
                d[j] = d[index] + mp[index][j];
        }
    }
}
int main(){
    int i,j,u,v,w;
    while(scanf("%d%d",&n,&m),n||m){
        for(i = 0; i <= n; i++)
        for(j = 0; j <= n; j++)
            mp[i][j] = INF;
        for(i = 0; i < m; i++){
            scanf("%d%d%d",&u,&v,&w);
            mp[u][v] = mp[v][u] = w;
        }
        dij();
        printf("%d
",d[n]);
    }
    return 0;
}

优先队列版Dijkstra

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <queue>
#include <climits>
#include <algorithm>
#include <cmath>
#define LL long long
#define INF 0x3f3f3f
using namespace std;
#define pii pair<int,int>
const int maxn = 102;
struct arc {
    int to,w;
};
int n,m;
vector<arc>g[maxn];
bool done[maxn];
int d[maxn];
priority_queue<pii,vector< pii >,greater< pii > >q;
void dj() {
    int i,j;
    for(i = 1; i <= n; i++) {
        done[i] = false;
        d[i] = INF;
    }
    d[1] = 0;
    while(!q.empty()) q.pop();
    q.push(make_pair(d[0],1));
    while(!q.empty()) {
        pii u =q.top();
        q.pop();
        int x = u.second;
        if(done[x]) continue;
        done[x] = true;
        for(i = 0; i < g[x].size(); i++) {
            j = g[x][i].to;
            if(d[j] > d[x] + g[x][i].w) {
                d[j] = d[x]+g[x][i].w;
                q.push(make_pair(d[j],j));
            }
        }
    }

}
int main() {
    int i,j,u,v,w;
    while(scanf("%d%d",&n,&m),n||m) {
        for(i = 1; i <= n; i++)
            g[i].clear();
        for(i = 0; i < m; i++) {
            scanf("%d%d%d",&u,&v,&w);
            g[u].push_back((arc) {v,w});
            g[v].push_back((arc) {u,w});
        }
        dj();
        printf("%d
",d[n]);
    }
    return 0;
}

Bellman—Ford算法：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <queue>
#include <climits>
#include <algorithm>
#include <cmath>
#define LL long long
#define INF 0x3f3f3f
using namespace std;
#define pii pair<int,int>
const int maxn = 10010;
struct arc {
    int u,v,w;
} g[maxn];
int n,m,cnt;
int d[maxn];
void bf() {
    int i,j;
    for(i = 1; i <= n; i++)
        d[i] = INF;
    d[1] = 0;
    bool flag;
    for(i = 1; i < n; i++) {
        flag = true;
        for(j = 0; j < cnt; j++)
            if(d[g[j].v] > d[g[j].u]+g[j].w){
                 d[g[j].v] = d[g[j].u]+g[j].w;
                 flag = false;
            }
        if(flag) break;
    }
}
int main() {
    int i,u,v,w;
    while(scanf("%d%d",&n,&m),n||m) {
        for(cnt = i = 0; i < m; i++) {
            scanf("%d%d%d",&u,&v,&w);
            g[cnt++] = (arc) {u,v,w};
            g[cnt++] = (arc) {v,u,w};
        }
        bf();
        printf("%d
",d[n]);
    }
    return 0;
}

spfa算法版：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <queue>
#include <climits>
#include <algorithm>
#include <cmath>
#define LL long long
#define INF 0x3f3f3f
using namespace std;
#define pii pair<int,int>
const int maxn = 1001;
struct arc {
    int to,w;
};
vector<arc>g[maxn];
queue<int>q;
int n,m,d[maxn];
bool done[maxn];
void spfa() {
    int i,j;
    for(i = 1; i <= n; i++){
        d[i] = INF;
        done[i] = false;
    }
    d[1] = 0;
    while(!q.empty()) q.pop();
    done[1] = true;
    q.push(1);
    while(!q.empty()){
        int temp = q.front();
        q.pop();
        done[temp] = false;
        for(i = 0; i < g[temp].size(); i++){
            j = g[temp][i].to;
            if(d[j] > d[temp]+g[temp][i].w){
                d[j] = d[temp]+g[temp][i].w;
                if(!done[j]){
                    q.push(j);
                    done[j] = true;
                }
            }
        }
    }

}
int main() {
    int i,u,v,w;
    while(scanf("%d%d",&n,&m),n||m) {
        for(i = 1; i <= n; i++)
            g[i].clear();
        for(i = 0; i < m; i++) {
            scanf("%d%d%d",&u,&v,&w);
            g[u].push_back((arc){v,w});
            g[v].push_back((arc){u,w});
        }
        spfa();
        printf("%d
",d[n]);
    }
    return 0;
}