华为上机测试题（地铁换乘-java）

PS:自己写的，自测试OK，供大家参考。

/*

高级题样题：地铁换乘
描述：已知2条地铁线路，其中A为环线，B为东西向线路，线路都是双向的。经过的站点名分别如下，两条线交叉的换乘点用T1、T2表示。
编写程序，任意输入两个站点名称，输出乘坐地铁最少需要经过的车站数量（含输入的起点和终点，换乘站点只计算一次）。
地铁线A（环线）经过车站：A1 A2 A3 A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18
地铁线B（直线）经过车站：B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15
输入：输入两个不同的站名
输出：输出最少经过的站数,含输入的起点和终点，换乘站点只计算一次
输入样例：A1 A3
输出样例：3

(注意：按照题示，A1 A3结果为3，所以A1 A1结果就应该为1，依此。)
*/

 import java.util.Scanner;

 public class Station {

     static String strA = "A1 A2 A3 A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18";
     static String strB = "B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15";

     static String[] SA = strA.split(" ");
     static String[] SB = strB.split(" ");

     static int LENSA = SA.length;
     static int LENSB = SB.length;

     static int indexT1SA = getIndexofSA("T1");    //"T1"车站在A线路上的数组下标
     static int indexT1SB = getIndexofSB("T1");    //"T1"车站在B线路上的数组下标
     static int indexT2SA = getIndexofSA("T2");    //"T2"车站在A线路上的数组下标
     static int indexT2SB = getIndexofSB("T2");    //"T2"车站在B线路上的数组下标

     public static void main(String[] args) {

         int step = 0;
         System.out.println("请输入\"始发站\"（空格）\"终到站\"(例如：A1 B4（回车结束）)：");
         Scanner sc = new Scanner(System.in);
         String[] strArray = sc.nextLine().split(" ");

         String x = strArray[0].toUpperCase();
         String y = strArray[1].toUpperCase();

         System.out.println("go:"+x);
         System.out.println("to:"+y);

         sc.close();

         step = getMinStep(x, y) + 1;
         System.out.println("经过的最少车站数："+step);
     }

     private static int getMinStep(String x, String y) {

         if(('A' != x.charAt(0))&&('A' != y.charAt(0)))
         {
             //在地铁B线路上
             return min(stepBtoB(x, y), stepT1orT2(x, y));
         }
         else if(('B' != x.charAt(0))&&('B' != y.charAt(0)))
         {
             //在地铁A线路上
             return min(stepAtoA(x, y), stepT1orT2(x, y));
         }
         else
         {
             //A到B，或者B到A
             return stepT1orT2(x, y);
         }
     }

     //从T1或者T2站换乘，s1到s2的最短距离
     private static int stepT1orT2(String s1, String s2) {
         int lenXtoT1 = steptoT1(s1);
         int lenXtoT2 = steptoT2(s1);
         int lenYtoT1 = steptoT1(s2);
         int lenYtoT2 = steptoT2(s2);

         int lineT1 = lenXtoT1 + lenYtoT1;
         int lineT2 = lenXtoT2 + lenYtoT2;

         return min(lineT1, lineT2);
     }

     //到T1的最短距离
     private static int steptoT1(String s) {

         if("T1".equals(s))
         {
             return 0;
         }
         else if("T2".equals(s))
         {
             return min(stepAtoA("T1", "T2"), stepBtoB("T1", "T2"));
         }
         else if('A' == s.charAt(0))    //s是A线路上的车站
         {
             //找到s站在SA的下标
             int indexSSA = getIndexofSA(s);

             //不换乘，s到T1最短路程
             int line1 = min(mod(indexSSA, indexT1SA), LENSA-mod(indexSSA, indexT1SA));
             //不换乘，s到T2最短路程
             int line2 = min(mod(indexSSA, indexT2SA), LENSA-mod(indexSSA, indexT2SA));

             return min(line1, line2+min(stepAtoA("T1", "T2"), stepBtoB("T1", "T2")));
         }
         else if('B' == s.charAt(0))    //s是B线路上的车站
         {
             //找到s站在SB的下标
             int indexSSB = getIndexofSB(s);

             //不换乘，s到T1最短路程
             int line1 = mod(indexSSB, indexT1SB);
             //不换乘，s到T2最短路程
             int line2 = mod(indexSSB, indexT2SB);

             return min(line1, line2+min(stepAtoA("T1", "T2"), stepBtoB("T1", "T2")));
         }
         else
         {
             System.out.println("车站名有误，请检查！");
             return -1;
         }
     }

     //s到T2的最短距离
     private static int steptoT2(String s) {

         if("T2".equals(s))
         {
             return 0;
         }
         else if("T1".equals(s))
         {
             return min(stepAtoA("T1", "T2"), stepBtoB("T1", "T2"));
         }
         else if('A' == s.charAt(0))    //s是A线路上的车站
         {
             //找到s站在SA的下标
             int indexSSA = getIndexofSA(s);

             //不换乘，s到T1最短路程
             int line1 = min(mod(indexSSA, indexT1SA), LENSA-mod(indexSSA, indexT1SA));
             //不换乘，s到T2最短路程
             int line2 = min(mod(indexSSA, indexT2SA), LENSA-mod(indexSSA, indexT2SA));

             return min(line2, line1+min(stepAtoA("T1", "T2"), stepBtoB("T1", "T2")));
         }
         else if('B' == s.charAt(0))    //s是B线路上的车站
         {
             //找到s站在SB的下标
             int indexSSB = getIndexofSB(s);

             //不换乘，s到T1最短路程
             int line1 = mod(indexSSB, indexT1SB);
             //不换乘，s到T2最短路程
             int line2 = mod(indexSSB, indexT2SB);

             return min(line2, line1+min(stepAtoA("T1", "T2"), stepBtoB("T1", "T2")));
         }
         else
         {
             System.out.println("车站名有误，请检查！");
             return -1;
         }
     }

     //A到A，不换乘
     private static int stepAtoA(String s1, String s2) {
         if(('B' == s1.charAt(0))||('B' == s2.charAt(0)))
         {
             System.out.println("输入不是A线路上的站点，请检查！");
             return -1;
         }

         //找到s1站，在A线路上的数组下标
         int indexS1SA = getIndexofSA(s1);

         //找到s2站，在A线路上的数组下标
         int indexS2SA = getIndexofSA(s2);

         //不换乘，s1到s2的最短距离
         return min(mod(indexS1SA, indexS2SA), LENSA-mod(indexS1SA, indexS2SA));
     }

     //B到B，不换乘
     private static int stepBtoB(String s1, String s2) {
         if(('A' == s1.charAt(0))||('A' == s2.charAt(0)))
         {
             System.out.println("输入不是B线路上的站点，请检查！");
             return -1;
         }

         //找到s1站，在B线路上的数组下标
         int indexS1SB = getIndexofSB(s1);

         //找到s2站，在B线路上的数组下标
         int indexS2SB = getIndexofSB(s2);

         //不换乘，s1到s2的最短距离
         return mod(indexS1SB, indexS2SB);
     }

     private static int min(int a, int b)
     {
         return a<b?a:b;
     }

     private static int getIndexofSA(String str)
     {
         for(int index = 0; index < LENSA; index++)
         {
             if(str.equals(SA[index]))
             {
                 return index;
             }
         }

         return -1;
     }

     private static int getIndexofSB(String str)
     {
         for(int index = 0; index < LENSB; index++)
         {
             if(str.equals(SB[index]))
             {
                 return index;
             }
         }

         return -1;
     }

     private static int mod(int a, int b)
     {
         if(a < b)
         {
             return b-a;
         }
         else
         {
             return a-b;
         }
     }
 }