//Dijkstra算法
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        String fileName = "demo.txt";
        Character startPoint = 'A';
        Character endPoint = 'E';
        File file = new File(fileName);
        BufferedReader reader = null;
        String tempString = null;
        HashMap<Character, ArrayList<TwoTuple<Character, Integer>>> connects = new HashMap<>();
        try {
            reader = new BufferedReader(new FileReader(file));
            while (null != (tempString = reader.readLine())) {
                String[] tempStrSplit = tempString.split(" ");
                TwoTuple<Character, Integer> tempTwoTuple = new TwoTuple<>(tempStrSplit[1].charAt(0), Integer.parseInt(tempStrSplit[2]));
                if (connects.containsKey(tempStrSplit[0].charAt(0))) { //连接集合已经含有该点出边
                    ArrayList<TwoTuple<Character, Integer>> tempArr = connects.get(tempStrSplit[0].charAt(0));
                    tempArr.add(tempTwoTuple);
                    connects.replace(tempStrSplit[0].charAt(0), tempArr);
                } else { //连接集合未含该点出边
                    ArrayList<TwoTuple<Character, Integer>> tempArr = new ArrayList<>();
                    tempArr.add(tempTwoTuple);
                    connects.put(tempStrSplit[0].charAt(0), tempArr);
                }
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        TwoTuple<Character[], Integer> res = DijkstraMethod(connects, startPoint, endPoint); //获得最短路径结果
        System.out.println("Path :"); //打印最短路径结果
        for (int i = 0; i < res.fst.length - 1; i++) {
            System.out.print(res.fst[i] + " -> ");
        }
        System.out.println(res.fst[res.fst.length - 1]);
        System.out.println("Length :");
        System.out.println(res.snd);
    }
    public static TwoTuple<Character[], Integer> DijkstraMethod(HashMap<Character, ArrayList<TwoTuple<Character, Integer>>> source, Character startPoint, Character endPoint) {
        ArrayList<Character> open = new ArrayList<>();
        ArrayList<Character> closed = new ArrayList<>();
        HashSet<Character> points = new HashSet<>( );
        source.forEach((k, v) -> { //获得所有点集
            points.add(k);
            v.forEach(x -> {
                points.add(x.fst);
            });
        });
        Character[] allPoints = new Character[points.size()];
        Character[] fatherPoints = new Character[points.size()];
        int[] dists = new int[points.size()];
        int[] distRes = new int[points.size()];
        int k = 0;
        for (Iterator<Character> iterator = points.iterator(); iterator.hasNext(); ) { //将点集转化为字符数组形式
            Character thisChar = iterator.next();
            open.add(thisChar); //添加开集
            allPoints[k] = thisChar; //初始化节点数组
            fatherPoints[k] = thisChar; //初始化父节点数组
            dists[k] = Integer.MAX_VALUE; //初始化距离数组
            k++;
        }
        k = findIndex(allPoints, startPoint);
        dists[k] = 0;
        int tempIndex = 0;
        while (open.contains(endPoint)) { //开集有终点则一直继续寻找轨迹
            k = findMinNumIndex(dists); //找到当前距离最小节点
            open.remove(allPoints[k]); //从开集中移除
            closed.add(allPoints[k]); //加入闭集
            distRes[k] = dists[k]; //将最终距离存储
            dists[k] = -1; //距离置为-1，不参与最小值判断
            if (allPoints[k].equals(endPoint)) { //若终点被移除，则停止迭代
                break;
            }
            ArrayList<TwoTuple<Character, Integer>> thisPointConnect = source.get(allPoints[k]);
            for (int i = 0; i < thisPointConnect.size(); i++) {
                tempIndex = findIndex(allPoints, thisPointConnect.get(i).fst);
                if (distRes[k] + thisPointConnect.get(i).snd < dists[tempIndex]) { //符合更新条件
                    fatherPoints[tempIndex] = allPoints[k];
                    dists[tempIndex] = distRes[k] + thisPointConnect.get(i).snd;
                }
            }
        }
        //输出路径和距离
        k = findIndex(allPoints, endPoint);
        ArrayList<Character> output = new ArrayList<>();
        output.add(endPoint);
        while (!allPoints[k].equals(startPoint)) {
            output.add(fatherPoints[k]);
            k = findIndex(allPoints, fatherPoints[k]);
        }
        Character[] outChars = new Character[output.size()];
        for (int i = 0; i < output.size(); i++) {
            outChars[i] = output.get(output.size() - 1 - i);
        }
        k = findIndex(allPoints, endPoint);
        TwoTuple<Character[], Integer> res = new TwoTuple<>(outChars, distRes[k]);
        return res;
    }
    public static int findIndex(Character[] chars, Character charOne) {
        for (int i = 0; i < chars.length; i++) {
            if (chars[i].equals(charOne)) {
                return i;
            }
        }
        return -1;
    }
    public static int findMinNumIndex(int[] ints) {
        int minNum = Integer.MAX_VALUE;
        int minNumIndex = 0;
        for (int i = 0; i < ints.length; i++) {
            if (ints[i] < minNum && ints[i] >= 0) {
                minNum = ints[i];
                minNumIndex = i;
            }
        }
        return minNumIndex;
    }
}
class TwoTuple<K, V> {
    public final K fst;
    public final V snd;
    TwoTuple(K k, V v){
        fst = k;
        snd = v;
    }
}