Dijkstra算法_最短路径_L2-001. 紧急救援

作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

输入格式：

输入第一行给出4个正整数N、M、S、D，其中N（2<=N<=500）是城市的个数，顺便假设城市的编号为0~(N-1)；M是快速道路的条数；S是出发地的城市编号；D是目的地的城市编号。第二行给出N个正整数，其中第i个数是第i个城市的救援队的数目，数字间以空格分隔。随后的M行中，每行给出一条快速道路的信息，分别是：城市1、城市2、快速道路的长度，中间用空格分开，数字均为整数且不超过500。输入保证救援可行且最优解唯一。

输出格式：

第一行输出不同的最短路径的条数和能够召集的最多的救援队数量。第二行输出从S到D的路径中经过的城市编号。数字间以空格分隔，输出首尾不能有多余空格。

输入样例：

4 5 0 3

20 30 40 10

0 1 1

1 3 2

0 3 3

0 2 2

2 3 2

输出样例：

2 60

0 1 3

这道题说白了就是寻找最短路径,但是由于pat平台很蠢，很蠢很蠢，对JAVA支持很差，跑一个syso都要100ms！这种算法题你要我200ms做完？
迫于无奈 用java和C分别实现了一边，效率不提了

这两个代码的核心思路是完全一样的，pat这个平台对于java，有的时候还需要用BufferedReader来接受，用scanner会超时，我真的是无话可说。

 import java.io.BufferedReader;

 import java.io.IOException;

 import java.io.InputStreamReader;

 import java.util.Arrays;

 public class Main {

     static int MAXVEX ;

     static int INFINITY = 65535;

     static int[] Pathmatirx;

     static int[] ShortPathTable;

     static int[][] graph;

     static int[] Spnum;

     static int[] nums;

     static int[] values;

     public static void main(String[] args) throws IOException {

         BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in));

         String[] string = bReader.readLine().split(" ");

         int n = Integer.parseInt(string[0]);

         int m = Integer.parseInt(string[1]);

         int s = Integer.parseInt(string[2]);

         int d = Integer.parseInt(string[3]);

         nums = new int[n];

         MAXVEX = n;

         Pathmatirx = new int[MAXVEX];

         ShortPathTable = new int[MAXVEX];

         graph = new int[MAXVEX][MAXVEX];

         Spnum = new int[MAXVEX];

         for (int i = 0; i < MAXVEX; i++) {

             Arrays.fill(graph[i], INFINITY);

             graph[i][i] = 0;

         }

         string = bReader.readLine().split(" ");

         for (int i = 0; i < n; i++) {

             nums[i] = Integer.parseInt(string[i]);

         }

         for (int i = 0; i < m; i++) {

             string = bReader.readLine().split(" ");

             int t1 = Integer.parseInt(string[0]);

             int t2 = Integer.parseInt(string[1]);

             int t3 = Integer.parseInt(string[2]);

             graph[t1][t2] = t3;

         }

         for (int i = 0; i < MAXVEX; i++) {

             for (int j = 0; j < MAXVEX; j++) {

                 if (graph[i][j]==INFINITY&&graph[j][i]!=INFINITY) {

                     graph[i][j] = graph[j][i];

                 }

             }

         }

         Dijkstra(s);

         System.out.print(Spnum[d]+" ");

         System.out.print(values[d]);

         System.out.println("");

         StringBuilder st = new StringBuilder(s+"");

         st.append(" "+d);

         while (Pathmatirx[d]!=0) {

           st.insert(1, " "+Pathmatirx[d]);

           d = Pathmatirx[d];

         }

         System.out.print(st.toString());

     }

     public static void Dijkstra(int v0) {

         int v,w,k = 0,min;

         values = new int[MAXVEX];

         int[] res = new int[MAXVEX];    //判断是否已经保存最短路径

         for (int i = 0; i < MAXVEX; i++) {

             ShortPathTable[i] = graph[v0][i];

             if (i!=v0) {

                 values[i] = nums[i]+nums[v0];

             }

         }

         Arrays.fill(Spnum, 1);

         res[v0] = 1;//v0->v0 v0最短路径就是自己

         values[v0] = nums[v0];

         for (int i = 0; i < MAXVEX; i++) {

             if (i == v0) {

                 continue;

             }

             min = INFINITY;

             for (int j = 0; j < MAXVEX; j++) {

                 if (res[j]==0&&ShortPathTable[j]<min) { //最短路径还未找出 且权值最小

                     k = j;  //保存离i节点最近的节点

                     min = ShortPathTable[j];

                 }

             }

             //这个循环结束后 暂时的最短路径保存下来 但是只有离i节点最近的节点加入了res

             res[k] = 1;

             for (int j = 0; j < MAXVEX; j++) {

                 //如果节点没有加入res 且现有的路径比之前找到过的小 就更新

                 //若节点未联通 graph[k][j]和ShorPath[j]都是65535

                 if (res[j] == 0&&(min+graph[k][j])<ShortPathTable[j]) {

                     ShortPathTable[j] = min+graph[k][j];

                     values[j] = values[k]+nums[j];

                     Spnum[j] = Spnum[k];

                     Pathmatirx[j] = k;

                 }else if ((res[j] == 0&&(min+graph[k][j])==ShortPathTable[j])) {

                     Spnum[j] +=Spnum[k];

                     if (values[j]<values[k]+nums[j]) {

                         values[j]=values[k]+nums[j];

                         Pathmatirx[j] = k;  //这个要放在里面 若是又更好的路径 就更换前置节点

                     }

                 }

             }

         }

     }

 }

 #include <cstdio>

 #include <algorithm>

 using namespace std;

 int const MAX = ;

 int const INF = 0x3fffffff;

 int graph[MAX][MAX], val[MAX], dis[MAX], totval[MAX], pathnum[MAX], path[MAX];

 bool vis[MAX];

 int n, m, s, d;

 void Dijkstra(int v0)

 {

     for (int i = ; i < n; i++)

     {

         dis[i] = graph[v0][i];

         totval[i] = val[i] + val[v0];

         pathnum[i] = ;

         vis[i] = false;

         path[i] = v0;

     }

     vis[v0] = true;

     totval[v0] = val[v0];

     for (int i = ; i < n; i++)

     {

         if (i == v0)

         {

             continue;

         }

         int min = INF;

         int k = ;

         for (int j = ; j < n; j++)

         {

             if (vis[j] == false && min > dis[j])

             {

                 min = dis[j];

                 k = j;

             }

         }

         vis[k] = true;

         for (int i = ; i < n; i++)

         {

             if (vis[i] == false)

             {

                 if (min + graph[k][i] < dis[i])

                 {

                     dis[i] = min + graph[k][i];

                     pathnum[i] = pathnum[k];

                     totval[i] = totval[k] + val[i];

                     path[i] = k;

                 }

                 else if (min + graph[k][i] == dis[i])

                 {

                     pathnum[i] += pathnum[k];

                     if (totval[i] < totval[k] + val[i])

                     {

                         totval[i] = totval[k] + val[i];

                         path[i] = k;

                     }

                 }

             }

         }

     }

 }

 int main()

 {

     scanf("%d %d %d %d", &n, &m, &s, &d);

     for (int i = ; i < n; i++)

     {

         scanf("%d", &val[i]);

     }

     for (int i = ; i < n; i++)

     {

         for (int j = ; j < n; j++)

         {

             graph[i][j] = INF;

         }

         graph[i][i] = ;

     }

     for (int i = ; i < m; i++)

     {

         int t1, t2, t3;

         scanf("%d %d %d", &t1, &t2, &t3);

         graph[t1][t2] = t3;

         graph[t2][t1] = t3;

     }

     Dijkstra(s);

     printf("%d %d\n", pathnum[d], totval[d]);

     int t = d;

     int index = ;

     int res[MAX];

     while (t != s)

     {

         res[index++] = t;

         t = path[t];

     }

     res[index++] = s;

     for (int i = index - ; i > ; i--) {

         printf("%d ", res[i]);

     }

     printf("%d\n", res[]);

 }

以前一直想参加PAT,看上去那么的高大上,虽然每届只有千把人参加,但是现在看看这个比赛对于java的不友好,还是算了吧.

巴特西

Dijkstra算法_最短路径_L2-001. 紧急救援

最新文章

热门文章