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

浏览数：29 / 时间：2015年06月08日

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，依此。)
*/

  1 import java.util.Scanner;
  2 
  3 public class Station {
  4 
  5     static String strA = "A1 A2 A3 A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18";
  6     static String strB = "B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15";
  7     
  8     static String[] SA = strA.split(" ");
  9     static String[] SB = strB.split(" ");
 10     
 11     static int LENSA = SA.length;
 12     static int LENSB = SB.length;
 13     
 14     public static void main(String[] args) {
 15         
 16         int step = 0;
 17         System.out.println("请输入\"始发站\"（空格）\"终到站\"(例如：A1 B4（回车结束）)：");
 18         Scanner sc = new Scanner(System.in);
 19         String[] strArray = sc.nextLine().split(" ");
 20         
 21         String x = strArray[0].toUpperCase();
 22         String y = strArray[1].toUpperCase();
 23         
 24         System.out.println("go:"+x);
 25         System.out.println("to:"+y);
 26         
 27         sc.close();
 28         
 29         step = getMinStep(x, y) + 1;//实际最小步数应该为getMinStep(x, y)，此处按题示要求，所以结果加1
 30         System.out.println("经过的最少车站数："+step);
 31     }
 32 
 33     private static int getMinStep(String x, String y) {
 34         
 35         if((‘A‘ != x.charAt(0))&&(‘A‘ != y.charAt(0)))
 36         {
 37             //在地铁B线路上，不用换乘，已经包含T1到T2
 38             return stepBtoB(x, y);
 39         }
 40         else if((‘B‘ != x.charAt(0))&&(‘B‘ != y.charAt(0)))
 41         {
 42             //在地铁A线路上
 43             return stepAtoA(x, y);
 44         }
 45         else
 46         {
 47             //A到B，或者B到A
 48             return stepT1orT2(x, y);
 49         }
 50     }
 51 
 52     //从T1或者T2站换乘，s1到s2的最短距离
 53     private static int stepT1orT2(String s1, String s2) {
 54         int lenXtoT1 = steptoT1(s1);
 55         int lenXtoT2 = steptoT2(s1);
 56         int lenYtoT1 = steptoT1(s2);
 57         int lenYtoT2 = steptoT2(s2);
 58         
 59         int lineT1 = lenXtoT1 + lenYtoT1;
 60         int lineT2 = lenXtoT2 + lenYtoT2;
 61         
 62         return min(lineT1, lineT2);
 63     }
 64 
 65     //到T1的最短距离
 66     private static int steptoT1(String s) {
 67         
 68         if(‘A‘ == s.charAt(0))
 69         {
 70             //找到s站在SA的下标
 71             int i = getIndexofSA(s);
 72             
 73             //找到"T1"站在SA的下标
 74             int j = getIndexofSA("T1");
 75             
 76             //找到"T2"站在SA的下标
 77             int k = getIndexofSA("T2");
 78             
 79             //不换乘，s到T1最短路程
 80             int line1 = min(mod(i, j), LENSA-mod(i, j));
 81             //不换乘，s到T2最短路程
 82             int line2 = min(mod(i, k), LENSA-mod(i, k));
 83             
 84             return min(line1, line2+stepBtoB("T1", "T2"));
 85         }
 86         else
 87         {
 88             return stepBtoB(s, "T1");
 89         }
 90     }
 91 
 92     //到T2的最短距离
 93     private static int steptoT2(String s) {
 94 
 95         if(‘A‘ == s.charAt(0))
 96         {
 97             //找到s站在SA的下标
 98             int i = getIndexofSA(s);
 99             
100             //找到"T1"站在SA的下标
101             int j = getIndexofSA("T1");
102             
103             //找到"T2"站在SA的下标
104             int k = getIndexofSA("T2");
105             
106             //不换乘，s到T1最短路程
107             int line1 = min(mod(i, j), LENSA-mod(i, j));
108             //不换乘，s到T2最短路程
109             int line2 = min(mod(i, k), LENSA-mod(i, k));
110             
111             return min(line1+stepBtoB("T1", "T2"), line2);
112         }
113         else
114         {
115             return stepBtoB(s, "T2");
116         }
117     }
118 
119     //A到A，有可能会从T1或者T2中转
120     private static int stepAtoA(String s1, String s2) {
121         if((‘B‘ == s1.charAt(0))||(‘B‘ == s2.charAt(0)))
122         {
123             System.out.println("输入不是A线路上的站点，请检查！");
124             return -1;
125         }
126         
127         //找到s1站在SA的下标
128         int i = getIndexofSA(s1);
129         
130         //找到s2站在SA的下标
131         int j = getIndexofSA(s2);
132         
133         //不换乘，s1到s2的最短距离
134         int line1 = min(mod(i, j), LENSA-mod(i, j));
135         
136         //从T1或者T2站换乘，s1到s2的最短距离
137         int line2 = stepT1orT2(s1, s2);
138         
139         return min(line1, line2);
140     }
141 
142     //B到B
143     private static int stepBtoB(String s1, String s2) {
144         if((‘A‘ == s1.charAt(0))||(‘A‘ == s2.charAt(0)))
145         {
146             System.out.println("输入不是B线路上的站点，请检查！");
147             return -1;
148         }
149         
150         //找到s1站在SB的下标
151         int i = getIndexofSB(s1);
152         
153         //找到s2站在SB的下标
154         int j = getIndexofSB(s2);
155         
156         //取两数之模
157         return mod(i, j);
158     }
159     
160     private static int min(int a, int b)
161     {
162         return a<b?a:b;
163     }
164 
165     private static int getIndexofSA(String str)
166     {
167         for(int index = 0; index < LENSA; index++)
168         {
169             if(str.equals(SA[index]))
170             {
171                 return index;
172             }
173         }
174         
175         return -1;
176     }
177 
178     private static int getIndexofSB(String str)
179     {
180         for(int index = 0; index < LENSB; index++)
181         {
182             if(str.equals(SB[index]))
183             {
184                 return index;
185             }
186         }
187         
188         return -1;
189     }
190     
191     private static int mod(int a, int b)
192     {
193         if(a < b)
194         {
195             return b-a;
196         }
197         else
198         {
199             return a-b;
200         }
201     }
202 }