ACM/ICPC 之 两道dijkstra练习题(ZOJ1053(POJ1122)-ZOJ1053)

　　两道较为典型的单源最短路径问题，采用dijkstra解法

　　本来是四道练习题，后来发现后面两道用dijkstra来解的话总觉得有点冗余了，因此暂且分成三篇博客（本篇以及后两篇）。

---

ZOJ1053(POJ1122)-FDNY to the Rescue!

 //POJ1122-ZOJ1053
 //dijkstra-需要记录路径
 //给出n个路口的邻接矩阵，求给定多个火警到失火点的时间及任一路径
 //注意输入最后一行时，cin.getline需要两次，猜测需要接受邻接矩阵最后一行其他字符后再接受下一行（有误请指出）
 //POJ1122:Time:16Ms    Memory:208K    (单组数据)
 //ZOJ1053:Time:0Ms    Memory:276K    (多组数据，中间空一行)
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<algorithm>
 using namespace std;

 #define MAX 21
 #define INF 0x3f3f3f3f

 struct FD {    //FDNY
     int d;    //到失火点的距离
     int num;    //FD编号
     friend bool operator < (FD fd1, FD fd2) { return fd1.d < fd2.d; }
 }fd[MAX];

 int n;
 int road[MAX][MAX];    //有向图-road[i][j]:从i到j的距离
 int d[MAX];
 int fa[MAX];
 bool v[MAX];

 void dijkstra(int x)
 {
     memset(v, false, sizeof(v));
     v[x] = true;
     for (int i = ; i <= n; i++)
     {
         d[i] = road[i][x];
         fa[i] = x;
     }
     for (int i = ; i <= n; i++)
     {
         int mind = INF;
         int k;
         for (int j = ; j <= n; j++)
             if (!v[j] && mind > d[j])
             {
                 mind = d[j];
                 k = j;
             }
         if (mind == INF) return;
         v[k] = true;
         for (int j = ; j <= n; j++)
             if (!v[j] && d[j] > d[k] + road[j][k])
             {
                 d[j] = d[k] + road[j][k];
                 fa[j] = k;
             }
     }
 }

 int main()
 {
     int T;
     scanf("%d", &T);
     char str[*MAX];
     cin.getline(str,*MAX);
     while (T--)
     {
         scanf("%d", &n);
         for (int i = ; i <= n; i++)
             for (int j = ; j <= n; j++)
             {
                 scanf("%d", &road[i][j]);
                 if (road[i][j] == -) road[i][j] = INF;
             }
         cin.getline(str,  * MAX);
         cin.getline(str,  * MAX);

         dijkstra(str[] - '');
         printf("Org\tDest\tTime\tPath\n");
         int lenfd = ;
         int len = strlen(str);
         for (int i = ; i < len; i += )
         {
             fd[lenfd].num = str[i] - '';
             fd[lenfd++].d = d[str[i] - ''];
         }

         sort(fd, fd + lenfd);
         for (int i = ; i < lenfd; i++)
         {
             printf("%d\t%d\t%d\t%d", fd[i].num, str[] - '', fd[i].d, fd[i].num);
             int x = fd[i].num;
             while (fa[x] != x)
                 printf("\t%d", x = fa[x]);
             printf("\n");
         }
         if(T) printf("\n");
     }
     return ;
 }

---

ZOJ1053-Transport Goods

 //dijkstra-松弛变形
 //题意中的cost请理解为Goods的代价(即消耗Goods的比例)，可以比作路上会因各种情况损失货物的比例
 //博主用的是普通的最短路，不过WA了好几发，初始化-去重-松弛处理都有过问题(做了几个小时啊...)
 //可以转化为最长路，精度比博主会更好，不过针对此题并无必要
 //Time:0Ms    Memory:360K
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 using namespace std;

 #define MAX 105
 #define INF 0x7f7f7f7f

 int n, m;
 double cost[MAX][MAX];
 double d[MAX], w[MAX];
 bool v[MAX];

 void dijkstra()
 {
     memset(v, false, sizeof(v));
     v[n] = true;
     for (int i = ; i < n; i++)
         d[i] = cost[i][n];
     for (int i = ; i <= n; i++)
     {
         double mind = ;    //以1为上界
         int k;
         for (int j = ; j < n; j++)
         {
             if (!v[j] && mind > d[j])
             {
                 mind = d[j];
                 k = j;
             }
         }
         if (mind > )    return;
         v[k] = true;
         for (int j = ; j < n; j++)    //松弛
             if (!v[j] && cost[k][j] <  && d[j] >  - ( - d[k]) * ( - cost[k][j]))
                 d[j] =  - ( - d[k]) * ( - cost[k][j]);
     }
 }

 int main()
 {
     //freopen("in.txt", "r", stdin);
     //freopen("out.txt", "w", stdout);
     while (scanf("%d%d", &n, &m) != EOF)
     {
         memset(cost, INF, sizeof(cost));
         memset(w, , sizeof(w));
         for (int i = ; i < n; i++)
             scanf("%lf", &w[i]);
         for (int j = ; j < m; j++)
         {
             int x, y;
             double r;
             scanf("%d%d%lf", &x, &y, &r);
             if (cost[x][y] > r)        //去重
                 cost[y][x] = cost[x][y] = r;
         }
         dijkstra();
         for (int i = ; i < n; i++)
             if (d[i] < )
                 w[n] += ( - d[i]) * w[i];
         printf("%.2f\n", w[n]);
     }
     return ;
 }