贪心算法（又称贪婪算法Greedy）：在对问题求解时，总是做出在当前看来是最好的选择。仅是在某种意义上的局部最优解。贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。

可用贪心算法求解的问题一般有两个重要性质：

1、贪心选择性质

在当前状态下做出最好选择，即局部最优选择，然后再去解决做出这个选择后产生的响应的子问题，通常以自顶向下的方式进行，以迭代的方式做出相继的贪心选择，每做一次贪心选择就将所求问题简化为规模更小的子问题。而在动态规划算法中，每步所做的选择往往依赖于相关子问题的解(自底向上)。

2、最优子结构性质

当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。

在此先提出背包问题，与0-1背包问题类似，所不同的是选择物品i装入背包时，可以选择i的一部分而不是全部。这样背包问题可以用贪心算法求解：将物品单位重量价值由高到低的顺序依次放入背包，直到背包被装满。而对于0-1背包问题，贪心选择之所以不能得到最优解是因为在这种情况下，它无法保证最终能将背包装满，部分闲置的背包空间使每千克背包空间的价值降低了。

单源最短路径贪心算法实现：

public class MaxSum 
{
static int MAX_SIZE=6;
public static void dijkstra(int v,float[][]a,float[]dist,int[]prev)
{
   int n=dist.length-1;
   if(v<1||v>n)return;
   boolean []s=new boolean[n+1];
  
   for(int i=1;i<=n;i++)
   {
    dist[i]=a[v][i];
    s[i]=false;
    if(dist[i]==Float.MAX_VALUE)
     prev[i]=0;
    else
     prev[i]=v;
   }
   dist[v]=0;s[v]=true;
   for(int i=1;i<n;i++)
   {
    float temp=Float.MAX_VALUE;
    int u=v;
    for(int j=1;j<=n;j++)
     if((!s[j])&&(dist[j]<temp))
     {
      u=j;
      temp=dist[j];
     }
    s[u]=true;
    for(int j=1;j<=n;j++)
     if((!s[j])&&(a[u][j]<Float.MAX_VALUE))
     {
      float newdist=dist[u]+a[u][j];
      if(newdist<dist[j])
      {
       dist[j]=newdist;
       prev[j]=u;
      }
     }
   }
}
public static void main(String args[])
{
   float a[][]=new float[MAX_SIZE][MAX_SIZE];float[]dist=new float[MAX_SIZE];int []prev=new int[MAX_SIZE];
   for(int i=0;i<6;i++)
    for(int j=0;j<6;j++)
     a[i][j]=Float.MAX_VALUE;
   a[1][2]=10;
   a[1][4]=30;
   a[1][5]=100;
   a[2][3]=50;
   a[3][5]=10;
   a[4][3]=20;
   a[4][5]=60;
   int v=1;//假设从顶点1处出发
  
   dijkstra(v,a,dist,prev);
  
   System.out.println("从1出发到2、3、4、5的最短路径依次是:");
   for(int j=2;j<6;j++)
   {
    System.out.println(dist[j]);
   }
  
   int z=prev[5],y=prev[z],x=prev[y];
   System.out.println("从1到5最短路径经过的点为：");
   System.out.print(x+" "+y+" "+z+" "+"5");

}

}

运行结果：

本文出自 “闲庭信步、” 博客，请务必保留此出处http://macxiao.blog.51cto.com/9606147/1588385

Dijkstra单源最短路径(贪心选择)