华为2017实习生上机笔试_当出差遇上大雾_Java编程

Posted 2020-09-30

出差问题：

1、共有6个城市，某员工现从5号城市，到endCity出差；

2、如果一个城市遇上大雾，则该城市（既不能到达，也不能离开）；

3、给定距离矩阵useHours[][6] = {

0,2,10,5,3,INF,

INF,0,12,INF,INF,10,

INF,INF,0,INF,7,INF,

2,INF,INF,0,2,INF,

4,INF,INF,1,0,INF,

3,INF,1,INF,2,0,};

其中单位为小时，INF为1000小时

4、输入：目的地和大雾城市；

5、输出最短路径长度和路径，无法到达输出-1；

实例：

输入：

2

4

输出：

6

[5 1 2]

 java编程

import java.util.*;

 public class Main {

     private static int INF = 1000;

 

      private static Integer[][] dist;

      private static Integer[][] path;

 

      private static List<Integer> result = new ArrayList<Integer>();

 //调试

     public static void printMatrix(Integer[][] matrix) {

         for (int i = 0; i < matrix.length; i++) {

             for (int j = 0; j < matrix.length; j++)

                 System.out.print(matrix[i][j] + " ");

             System.out.println();

         }

     }

 //设置雾城市

     private static void setFog(int[][] matrix, int city) {

         for (int i = 0; i < matrix.length; i++) {

             matrix[i][city] = matrix[city][i] = INF;

         }

     }

 

     public static void main(String[] args) {

 

         int size = 6;

 

         int begin = 4;

         Scanner scan = new Scanner(System.in);

         int end = Integer.parseInt(scan.nextLine()) - 1;

         int foggy = Integer.parseInt(scan.nextLine()) - 1;

         scan.close();

 

         int[][] matrix = { { 0, 2, 10, 5, 3, INF },

                 { INF, 0, 12, INF, INF, 10 }, { INF, INF, 0, INF, 7, INF },

                 { 2, INF, INF, 0, 2, INF }, { 4, INF, INF, 1, 0, INF },

                 { 3, INF, 1, INF, 2, 0 } };

         init(size);

         //没有雾

         if (foggy != -1)

             setFog(matrix, foggy);

 //调用弗洛伊德

         floyd(matrix);

 

         findPath(begin, end);

         System.out.println(dist[begin][end]);

         for (int i = 0; i < result.size(); i++)

             result.set(i, result.get(i) + 1);

         if (dist[begin][end] == INF)

             result.removeAll(result);

         System.out.println(result);

     }

 //在path数组里找路径

     public static void findPath(int i, int j) {

         int ci = i, ccj = j;

         while (path[i][j] != -1) {

             int cj = path[i][j];

             result.add(cj);

             i = cj;

         }

         result.add(0, ci);

         result.add(ccj);

     }

 

     public static void floyd(int[][] matrix) {

         int size = matrix.length;

         for (int i = 0; i < size; i++)

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

                 path[i][j] = -1;

                 dist[i][j] = matrix[i][j];

             }

         for (int k = 0; k < size; k++) {

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

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

                     if (dist[i][k] != INF && dist[k][j] != INF

                             && dist[i][k] + dist[k][j] < dist[i][j]) {

                         dist[i][j] = dist[i][k] + dist[k][j];

                         path[i][j] = k;

                     }

                 }

             }

         }

     }

 //初始化两个数组

     public static void init(int size) {

         path = new Integer[size][size];

         dist = new Integer[size][size];

     }

 }