单源最短路径

给定一个带权有向图 G=(V,E)，其中每条边的权是一个实数，另外，还给定V中的一个顶点，称为源，现在要计算从源到其他各个顶点的最短路径长度。这里的路径长度是指路上各边权之和。这个问题称为单源最短路径问题。有3种算法计算单源最短路径， Dijkstra 、Bellman-Ford 、SPFA算法

1、 Dijkstra算法

该算法基于贪心思想，计算一个节点到其他所有节点的最短路径。算法要求不存在负权边，如果要计算带负权边的有向图的单源最短路径，用另外的2种方法。

将图中的所有的顶点分成2个集合，Va和Vb，如果源点S到某个顶点u的最短路已经确定，那么u就加入Va，最开始的时候Va只包含源点S，其余的点属于Vb，算法结束后，所有由源点S可到达的点属于Va，不可到达的点属于Vb。可以在求出最短路径长的同是记录最短路径，方法是记录终点的前一个点，这样只要倒着查回去就能确定整条最短路径。

具体步骤：

1)首先初始化，将源点S到图中各点的直接距离当做初始值记录为S到各点的最短距离，如果不能直接到达，记为INF，S到S的距离记为0

2)在所有Vb的点中找一个S到其路径长度最短的点u，将u从Vb中移除，加入到Va中。

3)由确定的u点更新S到Vb中没一点v的距离，如果  s->u+u->v   小于  s->v  那么就更新这个距离

4)重复步骤 2、3，直到 Vb中已经没有点或者Vb中的点不能够到达源点S

其实Dijkstra和Prim算法非常相像，只是由于问题不同，实现过程的计算内容不同，前者计算路径长度，后者比较边的长短。

算法实现：

package com.langsin.duisort;

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
/*
测试用例：
 7 5
0 1 100
0 2 30
0 4 10
2 1 60
2 3 60
3 1 10
4 3 50
0    //源点
 */
public class Test {
    static Scanner sc=new Scanner(System.in);
    static int edge,node;   //边数，顶点数
    static int [][] map=new int [20][20];
    static boolean[] visited=new boolean [20];          //为true属于Va，为false属于Vb
    static int [] dest=new int [20];            //记录该位置到源点的最短路径
    static int [] pre=new int [20];             //记录该位置的上一个结点
    public static void main(String[] args) {
        edge=sc.nextInt();
        node=sc.nextInt();
        for(int i=0;i<=node;i++)
            for(int j=0;j<=node;j++)
                map[i][j]=10000;    //初始化为无穷大
        int f ,t ,w;                //边 f->t  权值为w
        for(int i=0;i<edge;i++){
            f=sc.nextInt();
            t=sc.nextInt();
            w=sc.nextInt();
            map[f][t]=w;
        }
        //输入源点S
        int s=sc.nextInt(); 
        Dijkstra(node,s);
     
    }
    
    public static void Dijkstra(int n,int u){
        for(int i=0;i<n;i++)
        {
            if(i!=u){
            dest[i]=map[u][i];
            visited[i]=false;
            pre[i]=u;
            }
        }
        dest[u]=0;
        visited[u]=true;
       
        int k=-1,mini=1000;
      
        for(int i=0;i<n-1;i++){    //循环n-1次
            mini=1000;k=-1;
            for(int j=0;j<n;j++){
                if(visited[j]==false&&dest[j]<mini){  //在Vb中取一个到源点的距离最小的点k
                    mini=dest[j];
                    k=j;
                }
            }
            if(k==-1)  return;   //没有可扩展的点
            visited[k]=true;
            for(int j=0;j<n;j++){
                //对于每个与k相邻的在Vb中的点j,更新s到j的最短路径
                if(visited[j]==false&&map[k][j]!=10000&&dest[j]>dest[k]+map[k][j]){
                    dest[j]=dest[k]+map[k][j];
                    pre[j]=k;
                }
            }
        }
    }
}

 考虑：如何找最短路径！