最短路
Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 49834 Accepted Submission(s): 21933
Problem Description
在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的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条商店到赛场的路线。
输入保证至少存在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
复习最短路
Dijkstra:
//Dijkstra
#include <stdio.h>
#include <string.h>
int map[105][105];
int dist[105];
bool vis[105];
int N, M;
void dijkstra()
{
dist[1] = 0;
int v;
while (true)
{
v = 0;
for (int u = 1; u <= N; u++)
{
if (!vis[u] && dist[u] < dist[v])
{
v = u;
}
}
if (v == 0) break;
vis[v] = true;
for (int u = 1; u <= N; u++)
{
if (!vis[u] && dist[v] + map[v][u] < dist[u])
{
dist[u] = dist[v] + map[v][u];
}
}
}
}
int main()
{
int A, B, C, i;
while (scanf("%d%d", &N, &M) && (N && M))
{
memset(map, 0x3f, sizeof(map));
memset(dist, 0x3f, sizeof(dist));
memset(vis, false, sizeof(vis));
for (i = 0; i < M; i++)
{
scanf("%d%d%d", &A, &B, &C);
if (C < map[A][B])
{
map[A][B] = map[B][A] = C;
}
}
dijkstra();
printf("%d\n", dist[N]);
}
return 0;
}
Floyd:
//Floyd
#include <stdio.h>
#include <string.h>
int map[105][105];
int N, M;
void floyd()
{
for (int k = 1; k <= N; k++)
{
for (int i = 1; i <= N; i++)
{
for (int j = 1; j <= N; j++)
{
map[i][j] = map[i][j] < map[i][k] + map[k][j] ? map[i][j] : map[i][k] + map[k][j];
}
}
}
}
int main()
{
int A, B, C, i;
while (scanf("%d%d", &N, &M) && (N && M))
{
memset(map, 0x3f, sizeof(map));
for (i = 1; i <= N; i++)
{
map[i][i] = 0;
}
for (i = 0; i < M; i++)
{
scanf("%d%d%d", &A, &B, &C);
if (C < map[A][B])
{
map[A][B] = map[B][A] = C;
}
}
floyd();
printf("%d\n", map[1][N]);
}
return 0;
}
Bellman-Ford:
//Bellman-Ford
#include <stdio.h>
#include <string.h>
struct edge {
int from, to, cost;
} es[20005];
int dist[105];
int N, M;
void Bellman_Ford()
{
memset(dist, 0x3f, sizeof(dist));
dist[1] = 0;
bool update = true;
while(update)
{
update = false;
for (int i = 0; i < 2 * M; i++)
{
edge e = es[i];
if (dist[e.from] + e.cost < dist[e.to])
{
dist[e.to] = dist[e.from] + e.cost;
update = true;
}
}
}
}
int main()
{
while(scanf("%d%d", &N, &M) && (N && M))
{
for(int i = 0; i < M; i++)
{
scanf("%d%d%d", &es[i].from, &es[i].to, &es[i].cost);
es[i + M].from = es[i].to;
es[i + M].to = es[i].from;
es[i + M].cost = es[i].cost;
}
Bellman_Ford();
printf("%d\n", dist[N]);
}
return 0;
}
优先队列优化的Dijkstra :
//优先队列优化的Dijkstra
#include <stdio.h>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
struct edge {
int to, cost;
} e;
typedef pair<int, int> P;
int N, M;
vector<edge> map[105];
int dist[105];
priority_queue<P, vector<P>, greater<P> > Q;
void dijkstra()
{
dist[1] = 0;
Q.push(P(0, 1));
while (!Q.empty())
{
P p = Q.top();
Q.pop();
int v = p.second;
if (dist[v] < p.first) continue;
for (int i = 0; i < map[v].size(); i++)
{
e = map[v][i];
if (dist[e.to] > dist[v] + e.cost)
{
dist[e.to] = dist[v] + e.cost;
Q.push(P(dist[e.to], e.to));
}
}
}
}
int main()
{
int A, B, C, i;
while (scanf("%d%d", &N, &M) && (N && M))
{
for (i = 1; i <= N; i++)
{
map[i].clear();
}
fill(dist, dist + N + 1, 0x3f3f3f3f);
for (i = 0; i < M; i++)
{
scanf("%d%d%d", &A, &B, &C);
e.cost = C;
e.to = B;
map[A].push_back(e);
e.to = A;
map[B].push_back(e);
}
dijkstra();
printf("%d\n", dist[N]);
}
return 0;
}
SPFA :
//SPFA
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
using namespace std;
int to[20005], cost[20005];
int first[105], nex[20005];
int dist[105], outqueue[105];
bool vis[105];
queue<int> Q;
int N, M;
bool spfa()
{
Q.push(1);
vis[1] = true;
dist[1] = 0;
while (!Q.empty())
{
int v = Q.front();
Q.pop();
vis[v] = false;
outqueue[v]++;//判断是否存在负圈
if (outqueue[v] > N) return false;
for (int u = first[v]; u != -1; u = nex[u])//广搜每条边
{
if (dist[v] + cost[u] < dist[to[u]])//对点进行松弛
{
dist[to[u]] = dist[v] + cost [u];
if (!vis[to[u]])
{
Q.push(to[u]);
vis[to[u]] = true;
}
}
}
}
return true;
}
int main()
{
int A, B, C, i;
while(scanf("%d%d", &N, &M) && (N && M))
{
memset(nex, -1, sizeof(nex));
memset(first, -1, sizeof(first));
memset(dist, 0x3f, sizeof(dist));
memset(vis, false, sizeof(vis));
memset(outqueue, 0, sizeof(outqueue));
for (i = 0; i < M; i++)
{
scanf("%d%d%d", &A, &B, &C);
to[2 * i] = B;
cost[2 * i] = C;
nex[2 * i] = first[A];
first[A] = 2 * i;
to[2 * i + 1] = A;
cost[2 * i + 1] = C;
nex[2 * i + 1] = first[B];
first[B] = 2 * i + 1;
}
spfa();
printf("%d\n", dist[N]);
}
return 0;
}