Dijkstra算法 小白说明

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("\n");
    }
}