hdu 2544 最短路 解题报告

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2544

题目意思：给出 n 个路口和 m 条路，每一条路需要 c 分钟走过。问从路口 1 到路口 n 需要的最短时间是多少。

这题是最短路的入门题，从理解d-i--j---k（wg自创的，呵呵）到默打到修改，搞左两日终于好了，哈哈哈~~~太感动了。

第一次错是 少了Dijkstra()函数中的 for (j = 1; j <= n; j++) 。

第二次错是把vis[k=j]=1 写在了 if (!vis[j] && dist[j] < mini) 里面。

好好总结自己的错误，以后应该能避免了。（做完郑多燕后，灵感翻来了，成日系实验室里对住堆恶心的实验报告兼做5成功，有种令人想死的感觉，忽略忽略）

顺便帮大家普及下科学知识，经过我的搜罗，

   dijkstra /ˈdɛɪkstra/

别读成 d  - i - j -k 了

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 using namespace std;

 #define INF 100000000
 const int maxn =  + ;
 int dist[maxn], map[maxn][maxn], vis[maxn];
 int n, m;

 void Init()
 {
     int i, j, st, en, cost;
     for (i = ; i <= n; i++)
         dist[i] = (i ==  ?  : INF);
     memset(vis, , sizeof(vis));
     for (i = ; i <= n; i++)
     {
         for (j = ; j <= n; j++)
             map[i][j] = INF;  // 这样也行：map[i][j] = map[j][i] = (i == j ? 0 : INF);
     }
     for (i = ; i <= m; i++)
     {
         scanf("%d%d%d", &st, &en, &cost);
         map[st][en] = map[en][st] = cost;   // 建立邻接矩阵
     }
 }

 void Dijkstra()
 {
     int i, j, k, mini;
     for (i = ; i <= n; i++)
     {
         mini = INF;
         for (j = ; j <= n; j++)   // 这个循环是用来找出与第i个点最近的点（当然是直接有边相连）
         {
             if (!vis[j] && dist[j] < mini)
             {
                 mini = dist[j];
                 k = j;
             }
         }
         vis[k] = ;     // 如果把这句放在上面的if里面，就会把有些不该被标记已经过的点置1了，实质只需要置距离i点最短的那个点
         for (j = ; j <= n; j++)
         {
             if (dist[j] > mini + map[k][j])   // mini其实就是dist[k],mini + map[k][j]表示绕过k点走到j点的路径会不会比直接不绕过k要短
                 dist[j] = mini + map[k][j];  // dist[j] = dist[k]+ map[k][j;
         }
     }
 }

 int main()
 {
     while(scanf("%d%d", &n, &m) && (m || n))
     {
         Init();
         Dijkstra();
         printf("%d\n", dist[n]);
     }
     return ;
 }

邻接表 + 优先队列 + dijkstra （好强大，^_^）

http://mindlee.net/2011/11/18/shortest-paths-algorithm/

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <climits>   // 定义各种数据类型最值得常量，如下面的INF_MAX: 2147483647
 #include <queue>
 using namespace std;

 const int NV =  + ;
 const int NE = 2e4 + ;

 int n, m;

 struct Dijkstra
 {
     int n, size;
     int dis[NV], head[NV];
     int mark[NV];

     struct node
     {
         int v, dis;
         node() {}
         node(int V, int DIS): v(V), dis(DIS){}
         friend bool operator < (const node a, const node b)
         {
             return a.dis > b.dis;   // 结构体中，dis小的优先级高
         }
     };

     struct edge
     {
         int v, w, next;
         edge() {}
         edge(int V, int W, int NEXT): v(V), w(W), next(NEXT) {}
     }E[NE];

     inline void init(int vx)
     {
         n = vx, size = ;
         memset(head, -, sizeof(int)*(vx+));
     }

     inline void insert(int u, int v, int w)
     {
         E[size] = edge(v, w, head[u]);  // E[size]. v = u, E[size].w = v, E[size].next = head[u]
         head[u] = size++;
     }

 /*    void print()  // 打印每个点的邻接表
     {
         for (int i = 0; i < n; i++)
         {
             printf("%d: ", i);
             for (int j = head[i]; j != -1; j = E[j].next)
             {
                 printf(" %d", E[j].v);
             }
             printf("\n");
         }
     }
 */
     int dijkstra(int src, int des)   // src: 0  des: n-1
     {
         node first, next;
         priority_queue<node> Q;
         for (int i = ; i <= n; i++)
         {
             dis[i] = INT_MAX;
             mark[i] = false;
         }
         dis[src] = ;
         Q.push(node(src, ));   // 把起始点入队

         while (!Q.empty())
         {
             first = Q.top();
             Q.pop();
             mark[first.v] = true;

             for (int i = head[first.v]; i != -; i = E[i].next)
             {
                 if (!mark[E[i].v])
                 {
                     next = node(E[i].v, first.dis + E[i].w);
                     if (next.dis < dis[next.v])
                     {
                         dis[next.v] = next.dis;
                         Q.push(next);
                     }
                 }
             }      // end for
         }     // end while
         return dis[des];
     }     // end dijkstra
 }G;

 int main()
 {
     while (scanf("%d%d", &n, &m) != EOF && (m + n))
     {
         G.init(n);
         while (m--)
         {
             int u, v, w;
             scanf("%d%d%d", &u, &v, &w);
             G.insert(u-, v-, w);
             G.insert(v-, u-, w);
         }
     //    G.print();
         printf("%d\n", G.dijkstra(, n-));
     }
     return ;
 }

Spfa + 邻接矩阵

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <queue>
 using namespace std;

 const int INF = 1e9;
 const int maxn =  + ;
 int dist[maxn], map[maxn][maxn];
 bool mark[maxn];
 int N, M;

 int Spfa()
 {
     for (int i = ; i <= N; i++)
     {
         mark[i] = false;
         dist[i] = INF;
     }
     queue<int> Q;
     dist[] = ;
     mark[] = true;
     Q.push();

     while (!Q.empty())
     {
         int first = Q.front();
         Q.pop();
         mark[first] = false;

         for (int i = ; i <= N; i++)
         {
             if (dist[first] + map[first][i] < dist[i])
             {
                 if (!mark[i])
                 {
                     Q.push(i);
                     mark[i] = true;    // mark 写在dist[i] 下一行也能过
                 }
                 dist[i] = dist[first] + map[first][i];
                 //  mark[i] = true;
             }
         }
     }
     return dist[N];
 }

 int main()
 {
     while (scanf("%d%d", &N, &M) != EOF && (N+M))
     {
         int A, B, C;
         for (int i = ; i <= N; i++)
         {
             map[i][i] = INF;
             for (int j = i+; j <= N; j++)
                 map[i][j] = map[j][i] = INF;    // 双向边！！！
         }
         while (M--)
         {
             scanf("%d%d%d", &A, &B, &C);
             map[A][B] = map[B][A] = C;
         }
         printf("%d\n", Spfa());
     }
     return ;
 }

顺便写写：1874

scanf("%d%d", &st, &en);    // st：起点  en：终点
for (int i = 0; i < n; i++)
{
dist[i] = map[st][i];     // 构建起点到其他点之间的距离，INF代表不可达
}

输出注意下即可：printf("%d\n", dist[en] == INF ? -1 : dist[en]);