地铁票价计算程序

根据某市地铁线路图写一个地铁票价计算程序
 
需求描述： 

1.计费规则：最低2元，超过5站以上每站加收0.5元，换乘重新起算，例如L1先坐4站，换乘L2再坐6站，结果就是2+2.5=5.5元
 
2.程序启动以后读取输入文件（in.txt），内容格式如：
 
L2-8,L2-2
 
X3,L3-8
 
....
 
每行表示一次行程，起点站和终点站之间用逗号分隔，行数不限
 
4.系统按最短路径方案（尽量少换乘且站数少，假设乘 客换乘一次用的时间相当于坐4个站）规划路线，计算票价，并把路线和票价输出到文件(out.txt)，内容格式如：
 
L2-8,L2-2=2.5:L2-8,L2-7,L2-6,L2-5,L2-4,L2-3,L2-2
 
X3,L3-8=4:X3,X4,L3-8
 
....
 
等号后面的表示票价和路径
 


地铁线路图如下：共有5条线路，X开头的站点表示 换乘车站

package com.test.test;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test3 {
    static Map<Integer,Station> stationMap=new HashMap<Integer,Station>();
    public static void main(String[] args) {
        
        
        Station station1=new Station(1,"1号线第一站",true,false);
        Station station2=new Station(1,"1号线第二站",false,false);
        station1.setNextStation(station2);
        Station station3=new Station(1,"第三站",false,true);
        station3.addTransferStations(2);
        station2.setNextStation(station3);
        Station station4=new Station(1,"1号线第四站",true,false);
        station3.setNextStation(station4);
        
        
        Station station21=new Station(2,"2号线第一站",true,false);
        Station station22=new Station(2,"2号线第二站",false,false);
        station21.setNextStation(station22);
        Station station23=new Station(2,"第三站",false,true);
        station23.addTransferStations(1);
        station22.setNextStation(station23);
        Station station24=new Station(2,"2号线第四站",true,false);
        station23.setNextStation(station24);
        
        stationMap.put(1, station1);
        stationMap.put(1, station21);
        
        int n=getPosition(station1, "1号线第一站", "1号线第四站", 0);
        System.out.println(n);
    }
    
    /**
     * 计算站点间距离
     * @param station
     * @param start
     * @param end
     * @param stationNum 前面已经经过几站
     * @return
     */
    public static int getPosition(Station station,String start,String end,int stationNum){
        Iterator<Station> it=station.iterator();
        Station startStation=null;
        while(it.hasNext()){//找到起始站
            Station s=it.next();
            if(s.getStationName().equals(start)){
                startStation=s;
                break;
            }
        }
        Station next=startStation.getNextStation();
        int num=1;
        while(!next.getStationName().equals(end)){
            next=next.getNextStation();
            if(next==null){
                return -1;//不可达
            }
            if(next.isTransfer){//如果是换成站
                //循环所以可以换成的路线 递归调用getPosition
            }else{//如果不是换成站
                
            }
            num++;
        }
        return stationNum+num;
    }

    /**
     * 站点类
     * @author Administrator
     *
     */
    static class Station implements Iterable<Station>{
        private int lineNum;//几号线
        private String stationName;//站名
        private boolean isStartOrEnd;//是否是首站或末站
        private boolean isTransfer;//是否是换乘站
        private Station nextStation;//該号线的下一站
        private Station preStation;//上一站
        private Set<Integer> transferStations;//可以换乘那几号线
        
        public Station(int lineNum,String stationName,boolean isStartOrEnd,boolean isTransfer){
            this.lineNum=lineNum;
            this.stationName=stationName;
            this.isStartOrEnd=isStartOrEnd;
            this.isTransfer=isTransfer;
        }
        
        public int getLineNum() {
            return lineNum;
        }

        public void setLineNum(int lineNum) {
            this.lineNum = lineNum;
        }

        public String getStationName() {
            return stationName;
        }

        public void setStationName(String stationName) {
            this.stationName = stationName;
        }

        public boolean isStartOrEnd() {
            return isStartOrEnd;
        }

        public void setStartOrEnd(boolean isStartOrEnd) {
            this.isStartOrEnd = isStartOrEnd;
        }

        public boolean isTransfer() {
            return isTransfer;
        }

        public void setTransfer(boolean isTransfer) {
            this.isTransfer = isTransfer;
        }

        public Station getNextStation() {
            return nextStation;
        }

        public void setNextStation(Station nextStation) {
            this.nextStation = nextStation;
        }

        public Station getPreStation() {
            return preStation;
        }

        public void setPreStation(Station preStation) {
            this.preStation = preStation;
        }

        public Set<Integer> getTransferStations() {
            return transferStations;
        }

        public void addTransferStations(Integer transferStation) {
            if(transferStations==null){
                transferStations=new HashSet<Integer>();
            }
            transferStations.add(transferStation);
        }
        

        @Override
        public String toString() {
            return "开始站---> [lineNum=" + lineNum + ", stationName="
                    + stationName + ", isStartOrEnd=" + isStartOrEnd
                    + ", isTransfer=" + isTransfer + "]";
        }

        @Override
        public Iterator<Station> iterator() {
            return new  StationIterator(this);
        }
        
    }
    
    static class StationIterator implements Iterator<Station>{
        private Station station;
        public StationIterator(Station station){
            this.station=station;
        }
        @Override
        public boolean hasNext() {
            return station!=null;
        }

        @Override
        public Station next() {
            Station temp=station;
            this.station=temp.getNextStation();
            return temp;
        }

        @Override
        public void remove() {
            
        }
        
    }

}

package org.train.test;
import java.util. * ;
public class Main {

    public static void main(String args[]) {
        Scanner cin = new Scanner(System. in );
        String station = "A1 A2 A3 A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18 B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15";
        String[] stations = station.split(" ");
        int length = stations.length;
        int[][] arr = new int[length][length];
        HashMap < String,
        Integer > stationMap = new HashMap < String,
        Integer > ();
        for (int i = 0; i < stations.length; i++) {
            stationMap.put(stations[i], i);
        }
        for (int i = 0; i < length; i++) {
            for (int j = 0; j < length; j++) {
                if (i == j) {
                    arr[i][j] = 0;
                } else {
                    arr[i][j] = 1000;
                }
            }
        }
        for (int i = 0; i < length - 1; i++) {
            arr[i][i + 1] = 1;
            arr[i + 1][i] = 1;
        }
        arr[9][25] = 0;
        arr[14][31] = 0;
        arr[25][9] = 0;
        arr[31][14] = 0;
        arr[stationMap.get("A18")][stationMap.get("B1")] = 1000;
        arr[stationMap.get("B1")][stationMap.get("A18")] = 1000;

        arr[stationMap.get("A1").intValue()][stationMap.get("A18").intValue()] = 1;

        //Floyd算法求解
        for (int k = 0; k < length; k++) {
            for (int i = 0; i < length; i++) {
                for (int j = 0; j < length; j++) {
                    if ((arr[i][k] + arr[k][j]) < arr[i][j]) {
                        arr[i][j] = arr[i][k] + arr[k][j];
                    }
                }
            }
        }

        while (cin.hasNext()) {
            String state1 = cin.next();
            String state2 = cin.next();

            int i = stationMap.get(state1);
            int j = stationMap.get(state2);

            System.out.println(arr[i][j] + 1);
        }
    }

}