图的结构建立和最短路径算法

在程序调试上，我还是摸不到门道，每次调试都花费了很长时间，也许就像老师说的内功不足吧，没关系，慢慢来，欲速则不达。

今早终于把这学期的最后一次数据结构实验《图的结构建立和最短路径算法》调试完成，接下来就是课程设计了......

#include <stdio.h>
#include <string.h>

#define INFINITY    65534
#define MAX_CITY    25

typedef struct ArcCell
{
  int    adj;    // 权值类型
}ArcCell,AdjMatrix[MAX_CITY][MAX_CITY];

typedef struct
{
  char    city[MAX_CITY][15];      // 顶点向量
  AdjMatrix  arcs[3];          // 邻接矩阵
  int      vexnum,arcnum[3];      // 当前顶点数和弧数
}MGraph;

int    LocateVex(char *citys);
void  CreatMGraph();
void  ShortestPathFloyd();

MGraph G;
int D[3][MAX_CITY][MAX_CITY],P[3][MAX_CITY][MAX_CITY][MAX_CITY];

void Memu()
{
  printf("\n\t\t\t************************\n");
  printf("\t\t\t1.查询两个城市\n\n");
  printf("\t\t\t2.查询一个城市到其它城市\n\n");
  printf("\t\t\t0.退出\n\n");
  printf("\t\t\t************************\n");
}

void main()
{
  int    v,w,u,n,choose;
  char city1[15],city2[15];

  Memu();
  CreatMGraph();      // 以邻接矩阵建立图的信息
  ShortestPathFloyd();
  printf("\t\t\t选择操作：");
  scanf("%d",&choose);

        while(1)
  {
    switch(choose)
    {
      case 1:
        printf("\t\t\t请输入两城市：");
        scanf("%s%s",city1,city2);
        v=LocateVex(city1);
        w=LocateVex(city2);
        if (D[1][v][w] != INFINITY)
        {
          printf("\t\t\t最少花费：%d\n",D[1][v][w]);
          printf("\t\t\t最短路径：%d\n",D[2][v][w]);
        
          for(u=1,n=0;u<=G.vexnum;u++)
            if(P[1][v][w][u]&&u!=v&&u!=w)
            {
              if (n == 0)
                printf("\t\t\t途经城市：");
              printf("%s ",G.city[u]);
              n++;
            }
            if(n == 0)
              printf("\t\t\t这两个城市相邻\n");
            printf("\n");
        }
        else
          printf("\t\t\t从%s到不了%s\n",city1,city2);
        break;
      case 2:
        printf("\t\t\t请输入要查寻的城市：");
        scanf("%s",city1);
        v=LocateVex(city1);
        for(w=1; w <= G.vexnum; w++)
        {
          if(w != v)
          {
                 if (D[1][v][w] != INFINITY)
            {
              printf("\n\t\t\t%d. %s到%s:\n",w,city1,G.city[w]);
                                printf("\t\t\t最少花费：%d\n",D[1][v][w]);
                    printf("\t\t\t最短路径：%d\n",D[2][v][w]);
            }
          }
        }
        break;
      case 0:
        goto loop;
    }
    Memu();
    printf("\t\t\t选择操作：");
    scanf("%d",&choose);
  }
loop:
  ;
}

int LocateVex(char *citys)
{
  int i=0;
  for (i=1;i <= G.vexnum; i++)
    if(!strcmp(citys,G.city[i]))
      return i;
  if(i>G.vexnum)
  {
    ++G.vexnum;
         strcpy(G.city[G.vexnum],citys);
         return G.vexnum;
  }
  return 0;
}

void CreatMGraph()
{
  int i,k,u,v,w,expense,course;
  char city1[15],city2[15],citys[50];
  FILE *fp;

  // 初始化邻接矩阵
  G.vexnum=0;
  G.arcnum[0]=0;
  G.arcnum[1]=0;
  G.arcnum[2]=0;
  for (k=0;k < 3;k++)
    for (v=0;v < MAX_CITY;v++)
                        for (w=0;w < MAX_CITY;w++)
      {        
        D[k][v][w]=INFINITY;
        G.arcs[k][v][w].adj=INFINITY;
        for (u=0;u<MAX_CITY;u++)
          P[k][v][w][u]=0;
      }
        
  for (i=0;i < MAX_CITY;++i)
    strcpy(G.city[i],"\0");
  printf("\n\t\t\t请输入存放数据文件名：");
  scanf("%s",citys);
  fp=fopen(citys,"rb");

  while (!feof(fp))
  {
    fscanf(fp,"%s%s%d%d",city1,city2,&expense,&course);
    v=LocateVex(city1);
    w=LocateVex(city2);
    G.arcs[1][v][w].adj=expense;
    G.arcs[2][v][w].adj=course;
    G.arcnum[1]++;
    G.arcnum[2]++;
        }
}

// 弗洛伊德算法求最短路径
void ShortestPathFloyd()
{
  int v,w,k,u,i;
  for (v=1; v <= G.vexnum; v++)
    for (w=1; w <= G.vexnum; w++)
      for(k=1; k <= 2; k++)
      {
        D[k][v][w]=G.arcs[k][v][w].adj;
        if(D[k][v][w] < INFINITY)
        {
          P[k][v][w][v]=1;
          P[k][v][w][w]=1;
        }
      }
  for(u=1; u <= G.vexnum; u++)
    for(v=1; v <= G.vexnum; v++)
      for(w=1; w <= G.vexnum; w++)
        for(k=1; k <= 2; k++)
        {
          if(D[k][v][u]+D[k][u][w] < D[k][v][w])
          {
            D[k][v][w] = D[k][v][u] + D[k][u][w];
            for (i=1; i <= G.vexnum; i++)
              P[k][v][w][i] = P[k][v][u][i] || P[k][u][w][i];
          }
        }
}