最短路径--Dijkstra算法

最短路径--Dijkstra算法

Dijkstra算法:原理就是：以某一个节点为源点，向到其他节点进行遍历，寻找源点到各节点的最短路径，

它需要对所有节点进行遍历，所有当节点较多时，效率比较低。

迪科斯彻算法使用了广度优先搜索解决非负权有向图的单源最短路径问题，算法最终得到一个最短路径树。

样例程序中是以V0为源点的

xxb2008 http://blog.csdn.net/xxb2008

循环次数			minDist[0]	minDist[1]	minDist[2]	minDist[3]	minDist[4]
初始	0	0	0	10	max	30	100
1	0,1	1	0	10	60	30	100
2	0,1,3	3	0	10	50	30	90
3	0,1,3,2	2	0	10	50	30	60
4	0,1,3,2,4	4	0	10	50	30	60
打印次序：		0, 10, 50, 30, 60
第一次循环：V0-V1为10，然后对比 V0-V2 和 V0-V1-V2最小离是多少；V0-V2为最大值MaxInt，V0-V1-V2的最小距离是10 + 50 = 60；  修复最小距离60。 第二次循环：找到最小值 30，然后对比 V0  直接到 【与V3有连线的各点VN（2,4）】的距离，和 V0-V4-VN的距离。修复V0到VN的最小距离

package graph.dijkstra;


/**
 * Created by xu on 14-3-15.
 */

class Node {
    String name;
    boolean isVisit;
}

public class Dijkstra {
    static int LENGTH = 5;
    static int WEIGHT = 1 << 30;


    int paths[][] = new int[LENGTH][LENGTH];
    Node nodes[] = new Node[LENGTH];

    public void init() {
        for (int i = 0; i < LENGTH; i++) {
            Node node = new Node();
            node.name = "V" + i;
            nodes[i] = node;
        }

        for (int i = 0; i < LENGTH; i++) {
            for (int j = 0; j < LENGTH; j++) {
                if (i == j) {
                    continue;
                }
                paths[i][j] = WEIGHT;
            }
        }

        //初始化边连线
        paths[0][1] = 10;
        paths[0][3] = 30;
        paths[0][4] = 100;

        paths[1][2] = 50;
        paths[2][4] = 10;

        paths[3][2] = 20;
        paths[3][4] = 60;
    }

    public void calc() {

        //从 0 节点开始遍历
        int minDist[] = new int[LENGTH]; //0到各节点的最小距离， 无连线的距离为最大值 WEIGHT;
        for (int i = 0; i < LENGTH; i++) {
            minDist[i] = paths[0][i];
        }

        nodes[0].isVisit = true;

        for (int x = 1; x < LENGTH; x++) {
            int min = WEIGHT; //从minDist选出最小距离边。且那个节点没有被访问过
            int minIndex = -1;
            for (int i = 0; i < LENGTH; i++) {
                if (!nodes[i].isVisit && minDist[i] < min) {
                    min = minDist[i];
                    minIndex = i;
                }

            }

        /* 1、选出最小距离节点V后。再看源节点V0 到 与 V 有连线的节点VN 的距离 会不会 比 VO 直接 到VN 的距离小。
            2、有就修正V0 到 VN 的距离。
        */
            if (minIndex > -1) {
                nodes[minIndex].isVisit = true;
                for (int i = 0; i < LENGTH; i++) {
                    if (!nodes[i].isVisit && (min + paths[minIndex][i]) < minDist[i]) { //注意：因为上面说了 无连线的距离为最大值 WEIGHT;
                        minDist[i] = min + paths[minIndex][i];
                    }
                }
            }

        }

        for (int i = 0; i < LENGTH; i++) {
            System.out.print(minDist[i]);
            System.out.print(", ");
        }

    }

    public static void main(String[] args) {
        Dijkstra dijkstra = new Dijkstra();
        dijkstra.init();
        dijkstra.calc();
    }
}