一个作业：求顶点数为500、1000、1500等等时，用迪杰斯特拉算法求的最短路径的时间，其中权值随机生成。
如题
 #include <stdio.h>
 #include <stdlib.h>                          //这是相关的代码
 #include <time.h>                          //我有几个问题：
 #include <stdbool.h>                      //第一个：在用邻接矩阵存储图时，初始化图的边的信息之后，
                                         //要给图中存在的边赋给一个随机的权值，怎么弄？（即代码中的红色部分）。
 #define MAX 999999                    //第二个：程序可以运行，但为什么当VEX_NUM的值不变时每次输出的结果不同
 #define VEX_NUM 600                 //有时是5毫秒、有时是10毫秒、后来干脆是0毫秒？？？
                                    //第三个：当VEX_NUM比较大时（如1000）会发生内存错误，那是不是说明这道
 typedef struct                    //题不能用这样的方法来解决？
 {                               //另外，后面的两个问题是不是因为第一个问题造成的？怎么解决啊？
     int vex[VEX_NUM];         //求帮助啊   
     int edgeifo[VEX_NUM][VEX_NUM];
     int vexnum,edgenum;
 }Graph;
 
void creategraph(Graph *G,int n,int e);
 void Dijkstra(Graph *G,int v);
 
int main(void)
 {
     clock_t start,end;
     Graph G;
 
    start=clock();
 
    creategraph(&G,600,599);
     Dijkstra(&G,0);
 
    end=clock();
 
    printf("运行时间为%d毫秒。\n",end-start);
     system("pause");
     return 0;
 }
 /*用邻接矩阵的方式构造图*/
 void creategraph(Graph *G,int n,int e)
 {
     int i,j,k;
     G->vexnum=n;
     G->edgenum=e;
 
    for(i=0;i<n;i++)
     {
         G->vex[i]=i;
     }
 
    for(i=0;i<n;i++)
     {
         for(j=0;j<n;j++)
             G->edgeifo[i][j]=MAX;     //初始化
     }

/*    for(k=0;k<e;k++)
     {
         ???
     }
 */
 }
 
void Dijkstra(Graph *G,int v)
 {
     bool S[VEX_NUM];
     int n=VEX_NUM;
     int dist[VEX_NUM];
     int prev[VEX_NUM];
     int i,j,k,mindist;
 
    for(i=0;i<n;i++)
     {
         dist[i]=G->edgeifo[v][i];
         S[i]=false;
         if(dist[i]==MAX)
             prev[i]=-1;
         else
             prev[i]=v;
     }
     dist[v]=0;
     S[v]=true;
 
    for(i=1;i<n;i++)
     {
         mindist=MAX;
         k=v;
         for(j=0;j<n;j++)
         {
             if((!S[j])&&dist[j]<mindist)
             {
                 k=j;
                 mindist=dist[j];
             }
             S[k]=true;
         }
         for(j=0;j<n;j++)
         {
             if((!S[j])&&G->edgeifo[k][j]<MAX)
             {
                 if(dist[k]+G->edgeifo[k][j]<dist[j])
                 {
                     dist[j]=dist[k]+G->edgeifo[k][j];
                     prev[j]=k;
                 }
             }
         }
     }
 }
 

[ 本帖最后由 任重道远 于 2015-10-3 12:26 编辑 ]

不太清楚。。。。。

没听说过这个算法，不过我想问一下你是存储像素信息还是什么？