Dijkstra链路状态选路算法

 

步骤	N1	D(v),p(v)	D(w),p(w)	D(x),p(x)	D(y),p(y)	D(z),p(z)
0	u	2,u	5,u	1,u	无穷大	无穷大
1	ux	2,u	4,x		2,x	无穷大
2	uxy	2,u	3,y			4,y
3	uxyv		3,y			4,y
4	uxyvw					4,y
5	uxyvwz

 

D(o):随着算法进行本次迭代，从源节点到目的节点o的最低费用路径的费用。

p(o):从源节点到目的节点o沿着当前最低费用路径的前一节点（o的邻居）。

N1:节点子集，如果从源节点到目的节点o的最低费用路径已确知，o在N1中。

LS算法：

Initialization：

　　N1 = {u}

　　for all node o

　　　　if o is a neighbor of u

　　　　　　then D(o) = c(u,o)

　　　　else D(v) = 无穷大

Loop

　　find w not in N1 such that D(w) is a minium

　　add w to N1

　　update D(o) for each neighbor o of w  and not in N1:

　　　　　　D(o) = min(D(o), D(o) + c(w,o))

/* new cost to o is either old cost to o or known  least path cost to w plus cost from w to o*/

until N1 = N

 Java实现：

public class Dijkstra {

    private static int MAX = 1000;
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        dijkstra();
    }

    public static void dijkstra(){
        //图的邻接矩阵
        /* 节点到自身的距离为0，到非邻居节点的距离为MAX*/
        int[][] matrix = {
                {0,  2,  5,  1,  MAX,  MAX},
                {2,  0,  3,  2,  MAX,  MAX},
                {5,  3,  0,  3,  1,    5},
                {1,  2,  3,  0,  1,    MAX},
                {MAX,MAX,1,  1,  0,  2},
                {MAX,MAX,5,  MAX,2,  0}
                };
        
        int[] isVisited = new int[6];
        int[] dist = new int[6];
        int[] pre = new int[6];
        
        dist[0] = 0;
        isVisited[0] = 1;
        
        /* 初始化 距离向量*/
        for (int i = 1; i < dist.length; i++) {
            dist[i] = matrix[0][i];
            
            /* 当前最低费用路径的前一节点为0 */
            if (dist[i] < MAX) {
                pre[i] = 0;
            }
        }
        
        for(int j = 1; j < pre.length; j++){
            
            /* 需找前一次的最短路径的节点 */
            int minLen = MAX;
            int n = 0;
            for (int i = 1; i < dist.length; i++) {
                /* 未被确认的节点 */
                if (dist[i] < minLen && isVisited[i] == 0) {
                    minLen = dist[i];
                    /* 确定当前最低费用路径的前一节点*/
                    n = i; 
                }
            }
            
            /* 确认节点 */
            isVisited[n] = 1;
            /* 更新最短路径 */
            for(int i = 1; i < dist.length; i++){
                if (isVisited[i] == 0 && matrix[n][i] < MAX && dist[n] + matrix[n][i] < dist[i]) {
                    dist[i] = dist[n] + matrix[n][i];
                    pre[i] = n;
                }
            }
            
        }
        
        for (int i = 0; i < dist.length; i++) {
            System.out.print(dist[i] + " ");
        }
        System.out.println();
        
        int m = 5;
        System.out.print(5 + " ");
        while(pre[m] != 0){
            System.out.print(pre[m] + " ");
            m = pre[m];
        }
        System.out.print(0);
    }
}