POJ_2387 Til the Cows Come Hom 【最短路】

一、题目

POJ2387

二、分析

Bellman-Ford算法

　该算法是求单源最短路的，核心思想就是不断去更新到起点的最短距离，更新的前提是没有负边。如果有负边需要手动控制循环次数。

Dijkstra算法

　同样是单源最短路，它的核心是

　(1) 找到最短距离已经确定的顶点，再从该顶点出发，更新与它相邻的点的最短距离。

　(2) 对于最短距离已经确定的点不再更新。

Floyd算法

　可以求解任意两点之间的最短距离。但是这题会TLE。

三、AC代码

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <vector>
 5 #include <fstream>
 6 using namespace std;
 7 const int MAXN = 2e3+14;
 8 const int INF = 0x3f3f3f3f;
 9 struct edge
10 {
11     int from, to, cost;
12 }E[MAXN<<1];
13 int T, N, C;
14 int dist[MAXN];
15 void Bellman_Ford()
16 {
17     memset(dist, INF, sizeof(dist));
18     dist[1] = 0;
19     while(1)
20     {
21         bool flag = 0;
22         for(int i = 0; i < C; i++)
23         {
24             if(dist[E[i].from] != INF && dist[E[i].to] > dist[E[i].from] + E[i].cost)
25             {
26                 dist[E[i].to] = dist[E[i].from] + E[i].cost;
27                 flag = 1;
28             }
29         }
30         if(!flag)
31             break;
32     }
33 }
34 int main()
35 {
36     //freopen("in.txt", "r", stdin);
37     scanf("%d%d", &T, &N);
38     C = 0;
39     int a, b ,c;
40     for(int i = 0; i < T; i++)
41     {
42         scanf("%d%d%d", &a, &b, &c);
43         E[C].from = a, E[C].to = b, E[C].cost = c;
44         C++;
45         E[C].from = b, E[C].to = a, E[C].cost = c;
46         C++;
47     }
48     Bellman_Ford();
49     printf("%d\n", dist[N]);
50     return 0;
51 }

Bellman_Ford

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <vector>
 5 #include <fstream>
 6 #include <vector>
 7 #include <queue>
 8 using namespace std;
 9 typedef pair<int, int> P;
10 const int MAXN = 2e3+14;
11 const int INF = 0x3f3f3f3f;
12 struct edge
13 {
14     int from, to, cost;
15     edge(int f, int t, int c)
16     {
17         from = f, to = t, cost = c;
18     }
19 };
20 vector<edge> G[MAXN];
21 priority_queue<P> pq;
22 int T, N;
23 int dist[MAXN];
24
25 void Dijkstra(int s)
26 {
27     memset(dist, INF, sizeof(dist));
28     dist[s] = 0;
29     pq.push(P(0, s));
30     while(!pq.empty())
31     {
32         P p = pq.top();
33         pq.pop();
34         int v = p.second;
35         if(dist[v] < p.first)
36             continue;
37         for(int i = 0; i < G[v].size(); i++)
38         {
39             edge e = G[v][i];
40             if(dist[e.to] > dist[v] + e.cost)
41             {
42                 dist[e.to] = dist[v] + e.cost;
43                 pq.push(P(dist[e.to], e.to));
44             }
45
46         }
47     }
48 }
49
50 int main()
51 {
52     //freopen("in.txt", "r", stdin);
53     scanf("%d%d", &T, &N);
54     int a, b ,c;
55     for(int i = 0; i < T; i++)
56     {
57         scanf("%d%d%d", &a, &b, &c);
58         G[a].push_back(edge(a, b, c));
59         G[b].push_back(edge(b, a, c));
60     }
61     Dijkstra(1);
62     printf("%d\n", dist[N]);
63     return 0;
64 }

Dijkstra