算法设计： 四、贪心算法（1. 单源最短路径问题）—— java实现 - 算法分析

贪心算法

贪心算法是指，在对问题求解时，总是做出在当前看来是最好的选择。也就
是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。

贪心算法思路：

1. 建立数学模型来描述问题；
2. 把求解的问题分成若干个子问题；
3. 对每一子问题求解，得到子问题的局部最优解；
4. 把子问题的解局部最优解合成原来解问题的一个解

利用贪心算法解题，需要注意两个问题：

1. 问题是否适合用贪心法求解。用贪心法解题很方便，但它的适用范围很小，
   判断一个问题是否适合用贪心法求解，目前还没有一个通用的方法，在信息学竞
   赛中，需要凭个人的经验来判断。
2. 确定了可以用贪心算法之后，如何选择一个贪心标准，才能保证得到问题的
   最优解。在选择贪心标准时，我们要对所选的贪心标准进行验证才能使用，不要
   被表面上看似正确的贪心标准所迷惑。

单源最短路径问题

给定带权有向图 G=(V,E)，其中每条边的权是非负实数。另外，还给定 V 中的
一个顶点，称为源。现在要计算从源到所有其它各顶点的最短路长度。这里路的
长度是指路上各边权之和。

求解思想：解最短路径的狄斯奎诺（Dijkstra）算法

（1）采用二维数组邻接矩阵的形式储存图并将图初始化；
（2）选择其中一个顶点作为计算最短路径的起点。
（3）构造一个一维数组 dis[n]，其中 n 是顶点个数，dis 用来记录最短路径
距离。初始化 dis，其值为图中各点到起点的直接距离（即邻接顶点记为其权值，
不相邻的顶点记为∞）；
（4）每次在 dis 数组中找出最小值，该值就是起点到该点的最短路径距离，
（可以将该点加一个标志位已记录该点路径已确定）；
（5）在加入了一个新的确定了点之后就需要更新 dis 数组，看其余点能否通
过这个确定的点到达起始点且距离能够更短。
（6）重复 4、5 步，直到所有点都找到了最短路径。

源码：

public class Dijkstra {
    static int M=10000;//(此路不通)
    static String[] path;  //存放从start到其他各点的最短路径的字符串表示,便于打印路径 ;
    public static void main(String[] args) {
        // 用二维数组保存单源有向图数据，g[i][j]表示i->j的距离
        int[][] g = {
                {0,10,M,30,100},
                {M,0,50,M,M},
                {M,M,0,M,10},
                {M,M,20,0,60},
                {M,M,M,M,0}
        };
        int start=0;  //表示从节点0开始
        int[] shortPath = Dijsktra(g,start);       
        for(int i = 1;i < shortPath.length;i++)
             System.out.println("从"+(start+1)+"出发到"+(i+1)+"的最短距离为："+shortPath[i]);
        System.out.println("=========================");
        for(int i=1;i<path.length;i++){
       	 System.out.println("从"+(start+1)+"出发到"+(i+1)+"的最短路径为："+path[i]);
        }

    } 
    public static int[] Dijsktra(int[][] g,int start){
         //接受一个有向图的权重矩阵，和一个起点编号start（从0编号，顶点存在数组中）
        //返回一个数组，表示从start到它的最短路径长度
        int n = g.length;        //顶点个数
        int[] shortPath = new int[n];    //存放从start到其他各点的最短路径
        path=new String[n]; //存放从start到其他各点的最短路径的字符串表示
        for(int i=0;i<n;i++)
        path[i]=new String((start+1)+"-->"+(i+1));
        boolean[] s=new boolean[n];//顶点放入或不放入的标志
        //初始化，第一个顶点求出
        shortPath[start] = 0; 
        s[start] = true;   //第一个定点放入
        for(int count = 1;count <= n - 1;count++)  //要加入n-1个顶点
        {
            int k = -1;    //选出一个距离初始顶点start最近的未标记顶点
            int dmin = Integer.MAX_VALUE;
            for(int i = 0;i < n;i++)
            {
                if(s[i] == false && g[start][i] < dmin)
                {
                    dmin = g[start][i];
                   
                    k = i;
                }                      
            }         
            //将新选出的顶点标记为已求出最短路径，且到start的最短路径就是dmin
            shortPath[k] = dmin;
            s[k] = true; 
            //以k为中间点，修正从start到未访问各点的距离
            for(int i = 0;i < n;i++)
            {   
                if(s[i] == false && g[start][k] + g[k][i] < g[start][i]){
                     g[start][i] = g[start][k] + g[k][i];                   
                     path[i]=path[k]+"-->"+(i+1);                    
                }                
            }       
        }
             
         return shortPath;
    }
}

算法分析

时间复杂性：O(n²)

算法需要 工作空间：O(n)