最短路径纯贪心算法。

 

    Dijkstra算法,书上其实说的很简洁,仔细看,仔细思考是会理解的.但要先理解几条引论和推理.

    而自己思考的思路在不需要任何推理只从贪心思路出发,和Dijkstra有所不同,但本质一样,那么自己按照理解,试着慢慢讲下.

一,问题:

从某个源点,到其他各点的最短路径.

注意,不要想成某一个点,到某个点的最短路径.这样的话不太好推导出思路。

某个源点,到其他各点的最短路径.这样的思路反而好推导出，反正所有点都计算出来了。某点到某点就是其中一条而已。，

二,分析.

先抛弃书中所有关于最短路径的引理,定理,公理....

先看图.

　　要找到从0点.到所有点的最短路径.

　　假如,小明,站在0点.他很渴,天气很热,再不喝水要渴死,而每个其他点,都有一瓶水,点和点之间的交通工具还不一样,有的是汽车,有的还必须走路. 

　　假设这里的权值代表两点之间所花费的时间,比如0 ~3中间的数字6, 表示.从0到3要6个小时的慢车.

　　打开地图一看,到底哪个是最短啊.他想喝3点的水,发现要9个小时. 居然比 先到2,再到4, 7个小时还长,那么去4吧.你当小明傻啊.到了2点,不喝水,还去4点.

　　所以小明得到一个常识,对于第一瓶水,需要中转点而到达的目的点肯定不是花费时间最少的,最起码可以喝那个中转站的水.

　　直连的点话,看看哪个点花费的时间少.  1点最少,只要3个小时.

　　废话少说,小明直接从0做车到1,花费3个小时,喝到了第一瓶水,刚喝完水,小明被时光机, 卟的一声,居然传回了0点.(因为我们要从0开始,找出到所有点的最短路径,所以小明被传送了.)

　　因为小明还是很渴,天气依然很热,再不喝水要渴死.

　　那么下一个最近的点在哪里?

　　小明开始思索, 1点是和0直连最近的.已经被我喝掉了.那么舍去1点,第二近的直连点是不是最近的呢?

　　先看看.发现了是6点.要4个小时.

　　其他直连点先全部抛弃,因为这个时候6点是直连点最近的了.

　　还有没有比4个小时更短的?有,是之前的1点,只要3个小时,但喝掉了.

　　小明思索一会,有答案了,唯一可能的是,如果原来1点,离它很近的地方有顶点.那么有可能比6点近.

　　看看地图,1可以到4和5.时间是5和8. 总时间就是 3+5和3+8.明显比4个小时长.

　　小明马上又坐车从0点到了6点.喝光水,毫无疑问, 卟的一声小明被时光机,又传回了0点.

　　不过有了上次的思考.

　　小明有了初步总结.

　　下一个最近的可能是2种方案中找一个

　　　　1)和0直连的点,但要除去1,和6.也就是和0直连的 第3近的点.

　　　　2)从最早的的1点出发,所能到达的点,虽然上次排除了,但说不定这次和第3近的点有的一拼.

　　正要查地图的时候.小明突然想到. 6点是第二近的点.说不定从6点出发,也有比 直连第3近的点更短呢.

　　终于,小明整理出了一个方案. 

　　用一个数组MinRD[]  ,存放已知最短路径.

　　用另外一个数组noGet[],存放 所有点 减去 所有最短路径的终点.

　　每次从最短路径MinRD[]中,查询每条最短路径的终点. 再写下这些终点,到 未曾到达的点的权直.再找出最小的.

　　　　这里要想明白, 假如有一条最短路径经过了好几个点,如 0->1->3->6->7. 小明最后一次喝掉了7点的水,

          也意味着,他之前喝掉了6点的水,也就是0->1->3->6是一个最短路径,    

          0->1->3->6->7是从0->1->3->6这个最短路径,由6顶点和其他最短路径的顶点通过残酷的比较中选出 来的.   

          这其实就是最优路径的的一个引论,最短路径,中间的路径也是最短路径.喝水喝出了引论.

　　不厌其烦的,我要写下每次程序运行的过程.

1)第一次找水.

已知最短路径

0                      这个是原点,默认放入.

还未到达过的

1,2,3,4,5,6

只有一个终点0. 从终点出发,和还未到达过的点组成弧,找到最断的.

比较 v(0,1),v(0,2),,v(0,3),v(0,4),v(0,5),v(0,6)

0->1最短,加入到最短路径集合中.

2)

已知最短路径

0

0->1

还未到达过的

2,3,4,5,6

第一个最短路径的终点是0.第二条最短路径的终点是1

从终点0和1出发,和还未到达过的点组成弧,找到最断的.

比较  v(0,2),,v(0,3),v(0,4),v(0,5),v(0,6),

        v(1,2),v(1,3),v(1,4),v(1,5),v(1,6)

0->6 最短,加入到最短路径集合中

3)

已知最短路径

0,                     

0->1                第一次找到的.

0->6                第二次找到的.

还未到达过的

2,3,4,5

比较  v(0,2),,v(0,3),v(0,4),v(0,5)

        v(1,2),v(1,3),v(1,4),v(1,5)

　　　v(6,2),v(6,3),v(6,4),v(6,5)

最优路径终点0,1,6,

0->6->5 和 0->2 一样,

根据程序判断顺序,会加入其中一个,下次查找会加入另外一个. 也可以修改程序,让他们一次加入

  c  代码如下(代码可读性一般)

struct Minroads
{
    int *road;
    int length;
    int cost;
};


int main()
{
    //临街矩阵，直接写出，就不用程序生成了，数字表示2点间弧的权直，-1表示2点不能直达。
    int matrix[7][7]={
    0,3,5,9,-1,6,4,
    3,0,-1,-1,8,5,-1,
    5,-1,0,-1,2,-1,-1,
    9,-1,-1,0,-1,-1,-1,
    -1,8,2,-1,0,-1,-1,
    6,5,-1,-1,-1,0,1,
    4,-1,-1,-1,-1,1,0
    };

    struct Minroads MinRD[7];//初始化最短路径数组
    int i=0;
    for(i=0;i<7;i++)
    {
        MinRD[i].road=malloc(sizeof(int)*7);
        MinRD[i].road[0]=0;
        MinRD[i].cost=0;
        MinRD[i].length=0;
    }

    int noGet[7]={0,1,2,3,4,5,6};//初始化未曾到达的顶点集合。


    MinRD[0].road[0]=0;//把源点自己（起点）作为第一条最短路径加入最短路径集合（包含1个顶。权直和为0）
    MinRD[0].length=1;
    MinRD[0].cost=0;

    noGet[0]=-1;// 简单的把到达的点，标记为-1，0加入就把索引为0的数值改为-1。当nouse的元素全部为-1。那就全部到达。
    int get_count=1;//



    //从每条已知的最短路径出发，走一步看看。比较所有产生的新路径，看看谁最短。
    //程序描述就是找出 ，minrd中，每个road的权直，加上，这条road的顶点到noGet中所有顶点的权直中最小的。
    while(get_count<7)
    {
        int i_noget,i_shortest;
        int temp_short=0x7fffffff;//int 是有符号数，最高位为0，表示最大正数，
        int temp_s, tmep_d;
        for(i_shortest=0;i_shortest<7;i_shortest++)//所有最短路径
        {
            if(MinRD[i_shortest].length!=0)//
            {
                for(i_noget=0;i_noget<7;i_noget++)//未曾到达的顶点
                {
                    if(noGet[i_noget]!=-1)
                    {
                        int x;
                        x=MinRD[i_shortest].road[MinRD[i_shortest].length-1];//最短路径的顶点
                        int y=noGet[i_noget];
                        int newshort;
                        if(matrix[x][y]!=-1)
                        {
                            newshort=MinRD[i_shortest].cost+matrix[x][y];
                        }
                        else
                        {
                            newshort=0x7fffffff;
                        }
                        if(newshort<=temp_short)
                        {
                            temp_short=newshort;
                            temp_s=i_shortest;
                            tmep_d=i_noget;
                        }
                    }
                }
            }
        }


        int i_copy;
        for(i_copy=0;i_copy<MinRD[temp_s].length;i_copy++)
        {
            MinRD[get_count].road[i_copy]=MinRD[temp_s].road[i_copy];
        }
        MinRD[get_count].road[i_copy]=tmep_d;

        MinRD[get_count].length=MinRD[temp_s].length+1;
        MinRD[get_count].cost+=temp_short;

        noGet[tmep_d]=-1;

        get_count++;
    }

    int i_print;
    for(i=0;i<7;i++)
    {
        for(i_print=0;i_print<MinRD[i].length;i_print++)
        {
            if(i_print!=MinRD[i].length-1)
            {
                printf("%d->",MinRD[i].road[i_print]);
            }
            else
            {
                printf("%d",MinRD[i].road[i_print]);
            }

        }
        printf("  cost:%d",MinRD[i].cost);
        printf("
");
    }
}

结果:

再次注意这里

0->6->5.这条最优路径找出来的话。上面必定有0->6这条最优路径。

闭着眼睛想一下，0->6->5是最优的话，没有理由，0—>6不是。如果0->6不是，而是0->x.那么,0->x->5,肯定比0->6->5更短。

Dijkstra(迪杰斯特拉)，是每次加入一条最短路径，那么更新   每个未处理的点    到     最短路径的顶点集合  的最短路径直。 选出最小的那个直。

注意当加入第一个原点的时候,本身的权直就相当于更新过一遍.

因为更新过,

能体现出动态调整的思路。

而我们的思路

体现的是贪心算法的思路。省掉了更新的步骤,每次重新计算所有的点.所以导致比Dijkstra运算量稍微大点。

不过自己推导出来，并能理解的，总感觉更亲切。

下篇看看怎么更容易理解的方式写出Dijkstra

几年后翻回来看。其实自己的想出来的思路，完全正确。就是贪心思路。

而Dijkstra是贪心+动态。当年用贪心想到就结束了。没有继续优化，保存中间值，否则就是Dijkstra算法了。

夸奖一下自己很难吗？比心。