今日总结（工具类 线路转换&最短路径）

线路转换

package com.example.app_t.unilt;

import java.util.HashMap;
import java.util.Map;

public class ChangeChineseutils {
    private static Map<String, String> map = new HashMap<>();
    public static String getchinese(String num){
        map.put("20","S1号线");
        map.put("21","S2号主线");
        map.put("22","S2号支线");
        map.put("23","昌平线");
        map.put("24","大兴机场线");
        map.put("25","房山线");
        map.put("26","首都机场线");
        map.put("27","西郊线");
        map.put("28","燕房线");
        map.put("29","亦庄T1线");
        map.put("30","亦庄线");
        if(map.get(num)!=null){
            return map.get(num);
        }else {
            return num+"号线";
        }
    }

    public static void main(String[] args) {
        System.out.println(ChangeChineseutils.getchinese("19"));
    }
}

最短路径

package com.example.app_t.unilt;





import com.example.app_t.pojo.Route;

import java.util.*;


public class Graph {

    public static void main(String[] args) {
        Map<String, String> maps = new HashMap<>();
        //初始化map
        maps.put("a","1");
        maps.put("b","2");
        maps.put("c","3");
        maps.put("d","4");
        maps.put("e","5");
        Graph graph = new Graph(6);
        //初始化点位

        graph.addVertax("0");
        graph.addVertax("a");
        graph.addVertax("b");
        graph.addVertax("c");
        graph.addVertax("d");
        graph.addVertax("e");

        String[] str = new String[5];
        str[0]="b";
        str[1]="a c";
        str[2]="b d";
        str[3]="c e";
        str[4]="d";

        for (int i = 0; i < 5; i++) {
            String[] strs = new String[999];


            int num = 0;
            String str1 = " ";
            //分割临界站点
            for (int j = 0; j <= str[i].length(); j++) {
                if (j != str[i].length()) {
                    if (str[i].charAt(j) != ' ')
                        str1 += String.valueOf(str[i].charAt(j));
                    else {
                        strs[num] = str1;
                        num++;
                        str1 = "";
                    }
                } else {
                    strs[num] = str1;
                    num++;
                    str1 = "";
                }
            }

            //保存数量

            //初始化权值
            for (int j = 0; j < num; j++) {
                String value = maps.get(strs[j].trim());
                graph.addEdges(i+1, Integer.parseInt(value), 1);
            }
        }

        showEdges();
        //查询
        String str2 = graph.dijkStra(1, 5);
        System.out.println(str2);
        String[] strs = new String[396];
        int num = 0;
        String str1 = "";
        for (int i = 0; i <= str2.length(); i++) {
            if (i != str2.length()) {
                if (str2.charAt(i) != ' ')
                    str1 += String.valueOf(str2.charAt(i));
                else {
                    {
                        strs[num] = str1;
                        num++;
                        str1 = "";
                    }
                }
            } else {
                strs[num] = str1;
                num++;
                str1 = "";
            }
        }
        strs[0] = String.valueOf(num);

        for(int i=0;i<7;i++){
            System.out.println(strs[i]);
        }
    }

    public static String[] getOne(List<Route> l, int src, int end) {
        Graph graph = new Graph(31);
        for (int i = 0; i < 31; i++) {
            graph.addVertax(String.valueOf(i));
        }
        for (int i = 0; i < l.size(); i++) {
            graph.addEdges(Integer.parseInt(l.get(i).getId()), Integer.parseInt(l.get(i).getSite()), 1);
            graph.addEdges(Integer.parseInt(l.get(i).getId()), Integer.parseInt(l.get(i).getSite()), 1);
        }

        //showEdges();
        String str = graph.dijkStra(src, end);

        String[] strs = new String[31];
        int num = 0;
        String str1 = "";
        for (int i = 0; i <= str.length(); i++) {
            if(i!=str.length()) {
                if (str.charAt(i) != ' ' )
                    str1 += String.valueOf(str.charAt(i));
                else {
                    {strs[num]=str1;num++;str1="";}
                }
            }
            else {strs[num]=str1;num++;str1="";}
        }
        strs[0]= String.valueOf(num-1);
        //System.out.println(Arrays.toString(strs));
        return strs;
    }

    //这里是定点数n,顶点集合Vertax，边的集合edges,是否被访问过得标记符isvisited
    private int n;
    private int numberOfEdges;
    private double[] distance;
    private String[] path;
    private ArrayList<String> Vertax;
    private static int[][] edges;
    private boolean[] isVisited;

    public Graph(int n) {
        this.n = n;
        numberOfEdges = 0;
        Vertax = new ArrayList<>(n);
        edges = new int[n][n];
        isVisited = new boolean[n + 1];
        distance = new double[n];
        for (int i = 0; i < n; i++) {
            distance[i] = Double.POSITIVE_INFINITY;
        }

        path = new String[n];
        for (int i = 0; i < n; i++) {
            path[i] = "";
        }
    }

    //打印邻接表
    public static void showEdges() {
        for (int[] edse : edges
        ) {
            System.out.println(Arrays.toString(edse));
        }

    }

    //获取顶点数
    public int GetSizeOfGraph(ArrayList<String> Vertax) {
        return Vertax.size();
    }

    //添加顶点
    public void addVertax(String s) {
        Vertax.add(s);
    }

    //获取指定顶点的第一个相邻顶点
    public int getFirstCO(int index) {
        for (int i = 0; i < Vertax.size(); i++) {
            if (edges[index][i] > 0) return i;
        }
        return n;
    }

    //获取指定顶点的顺次相邻顶点
    public int getNextCO(int index, int firstCO) {
        for (int i = firstCO + 1; i < Vertax.size(); i++) {
            if (edges[index][i] > 0) return i;
        }
        return n;
    }

    //添加边
    public void addEdges(int e1, int e2, int weight) {
        edges[e1][e2] = weight;
        //edges[e2][e1] = weight;
        numberOfEdges++;
    }

    //获取边数
    public int getNumberOfEdges() {
        return numberOfEdges;
    }

    public String dijkStra(int index, int end) {

        //CO 是迭代所需坐标，headIndex为每次DIJKSTRA的启动顶点


        int CO;
        int headIndex = index;
        //
        //为初始点设置距初始点距离，自然为0
        distance[index] = 0;


        //之后为每个顶点做如下操作
        //1.设置本顶点为known，本点的距离和路径不用管，因为之前已经设计好
        //2.寻找本顶点的每个相邻顶点。对于unknown的顶点，比较沿本顶点到达的距离和其原本距离，若小于原本距离，则更新距离，更新路径
        //3.本顶点设置结束后，通过indexGet函数，找出当前unknown顶点中距离最小的顶点，将其作为下一个顶点执行步骤2

        while (!isVisited[headIndex]) {

            //CO为第一个没被visited的CO
            CO = getFirstCO(headIndex);
            while (isVisited[CO]) {
                CO = getNextCO(headIndex, CO);
            }

            //如果headIndex顶点没有未被访问过的相邻顶点，则获得顶点坐标为n，说明他是最后一个unknown节点，仅仅需要设置为known即可
            if (CO == n) {
                isVisited[headIndex] = true;
                //System.out.println("没找到坐标");
            }
            //通过循环将所有相邻顶点执行步骤2
            else {
                while (!isVisited[CO] && CO < n) {
                    isVisited[headIndex] = true;
                    double currentDis = distance[headIndex] + edges[headIndex][CO];
                    if (currentDis < distance[CO]) {
                        distance[CO] = currentDis;

                        path[CO] = path[headIndex] + " " + Vertax.get(headIndex);
                    }

                    CO = getNextCO(headIndex, CO);

                }
            }

            headIndex = indexGet(distance, isVisited);


        }
        for (int i = 0; i < n; i++) {
            path[i] = path[i] + " " + Vertax.get(i);
        }
        //System.out.println("开始节点： " + Vertax.get(index));
        return path[end];
    }

    //通过给定距离矩阵和访问矩阵，返回下一个需要的顶点
    public int indexGet(double[] distance, boolean[] isVisited) {
        int j = 0;
        double mindis = Double.POSITIVE_INFINITY;
        for (int i = 0; i < distance.length; i++) {
            if (!isVisited[i]) {
                if (distance[i] < mindis) {
                    mindis = distance[i];
                    j = i;
                }
            }
        }
        return j;
    }
}