交通咨询模拟系统实验报告完整版

交通咨询模拟系统实验

报告

HEN system office room 【HEN16H-HENS2AHENS8Q8-HENH1688】

一、问题描述

全国交通咨询模拟：处于对不同目的的旅客对交通工具有不同的要求。例如， 因

公出差的旅客希望在旅途中的时间尽可能短，出门旅游的游客则希望旅费尽可能省，而老年旅客则要求中转次数最少。编制一个全国城市间的交通咨询程序，为旅客提供两种或三种最优决策的交通咨询。

【基本要求】（1）提供对城市信息进行编辑（如：添加或删除）的功能。

（2）城市之间有两种交通工具：火车和飞机。提供对列车时刻表和 飞机航班进行编辑（增设或删除）的功能。

（3）提供两种最优决策：最快到达或最省钱到达。全程只考虑一种 交通工具。

（4）旅途中耗费的总时间应该包括中转站的等候时间。

（5）咨询以用户和计算机的对话方式进行。由用户输入起始站、终 点站、最优决策原则和交通工具，输出信息：最快需要多长时 间才能到达或者最少需要多少旅费才能到达，并详细说明依次

【测试数据】

1如下：

班次

逻辑结构拆分：

3、核心设计：细地了解。并且从中也可得知路线的添加即数据的存储是这个系统进行运作的一个基础。而为了便于数据的存储、添加、删除等操作，我选择了储存文件对这些数据进行了存储。将每个信息量放在不同的文件中，可以更有效、直观地对这些数据进行处理。

流程图中的7个主要功能模块在主函数中，采用输入选项进入子菜单，但是其他操作都是在路线添加好后进行的，并且为了每一项功能进行完后，系统可以及时回到主交互界面，我采用的是无限循环形式，即while （1）。

以邻接表作交通图的存储结构，表示边的结点内除含有邻接点的信息外，包括交通工具、路程中消耗的时间和花费以及出发和到达的时间等多项属性。

三、主控及功能模块层次结构： 1、模块说明：本系统分为个模块

1、）主函数

2、）添加城市

3、）查找城市并返回序号

4、）删除城市

5、）添加列车

6、）添加航班

7、）删除列车或航班

8、）找出最小费用路线

9、）初始化系统数据（读入内存） 10、）找出最快路线

11、）计算最快路线耗费的时间并打印 12、）计算最小费用路线 13、）主界面

14、）存储信息到文件 15、）退出、

2、下面是各模块示意图：

函数变量声明：

#include <>

#include <>

#define ERR 0

#define OK 1

#define Dij_MAXN 33

#define MAX_VERTEX_NUM 31

#define MAX_STRING_NUM 10

#define MAX_TRAFFIC_NUM 10

const char CityFile[] ="D:\\";

const char TrainFile[] ="D:\\";

const char FlightFile[] ="D:\\";

typedef short int CityType;

typedef struct TrafficNode

{

char name[MAX_STRING_NUM]; rainNum;

}

fprintf(fp,"%d\n",total);

for (i=0;i

{

for (j=0;j

{

fprintf(fp,"%s %s %s ", AdjList[i].Train[j].name, CityName[i],

CityName[AdjList[i].Train[j].EndCity]);

fprintf(fp,"%2d:%2d %2d:%2d %d\n",

AdjList[i].Train[j].StartTime/60,

AdjList[i].Train[j].StartTime%60,

AdjList[i].Train[j].StopTime/60,

AdjList[i].Train[j].StopTime%60,

AdjList[i].Train[j].Cost);

}

}

fclose(fp);total=0;

fp=fopen(FlightFile,"w");

for (i=0;i

{

total+=AdjList[i].FlightNum;

}

fprintf(fp,"%d\n",total);

for (i=0;i

{

for (j=0;j

{

fprintf(fp,"%s %s %s ", AdjList[i].Flight[j].name, CityName[i],

CityName[AdjList[i].Flight[j].EndCity]);

fprintf(fp,"%2d:%2d %2d:%2d %d\n",

AdjList[i].Flight[j].StartTime/60,

AdjList[i].Flight[j].StartTime%60,

AdjList[i].Flight[j].StopTime/60,

AdjList[i].Flight[j].StopTime%60,

AdjList[i].Flight[j].Cost);

}

}

fclose(fp);return 1;

}

（4）添加城市：

int InsertCity (char *Name)

{

strcpy(CityName[CityNum],Name);

AdjList[CityNum].city=CityNum;

AdjList[CityNum].FlightNum=0;

AdjList[CityNum].TrainNum=0;

CityNum++;

return 1;

}

（5）删除城市：

int DelCity (char *Name)

{

int city,i,j;

city=SeekCity(Name);

for (i=city;i

{

strcpy(CityName[i],CityName[i+1]);

AdjList[i].FlightNum=AdjList[i+1].FlightNum;

AdjList[i].TrainNum=AdjList[i+1].TrainNum;

for (j=0;j

{

AdjList[i].Flight[j].Cost=AdjList[i+1].Flight[j].Cost;

AdjList[i].Flight[j].EndCity=AdjList[i+1].Flight[j].EndCity; strcpy(AdjList[i].Flight[j].name,AdjList[i+1].Flight[j].name); AdjList[i].Flight[j].StartTime=AdjList[i+1].Flight[j].StartTime;

AdjList[i].Flight[j].StopTime=AdjList[i+1].Flight[j].StopTime;

}

}

CityNum--;

return 1;

}

（6）添加火车路线：

int InsertTrain (char *train,char *StartCity,char *EndCity,int StartTime,int EndTime,int cost)

{

int i,j;

i=SeekCity(StartCity);

j=SeekCity(EndCity);

AdjList[i].Train[AdjList[i].TrainNum].Cost=cost;

AdjList[i].Train[AdjList[i].TrainNum].EndCity=j;

AdjList[i].Train[AdjList[i].TrainNum].StartTime=StartTime; AdjList[i].Train[AdjList[i].TrainNum].StopTime=EndTime;

strcpy(AdjList[i].Train[AdjList[i].TrainNum].name,train);

AdjList[i].TrainNum++;

return 1;

}

（7）添加航班路线：

int InsertFlight(char *flight,char *StartCity,char *EndCity,int StartTime,int EndTime,int cost)

{

int i,j;

i=SeekCity(StartCity);

j=SeekCity(EndCity);

AdjList[i].Flight[AdjList[i].FlightNum].Cost=cost;

AdjList[i].Flight[AdjList[i].FlightNum].EndCity=j;

AdjList[i].Flight[AdjList[i].FlightNum].StartTime=StartTime; AdjList[i].Flight[AdjList[i].FlightNum].StopTime=EndTime;

strcpy(AdjList[i].Flight[AdjList[i].FlightNum].name,flight); AdjList[i].FlightNum++;

return 1;

}

（8）删除路线：

int DelPath (char *name)

{

int i,j,flag=0;

for (i=0;i

{

for (j=0;j

if (strcmp(AdjList[i].Flight[j].name,name)==0)

{

flag=1;

break;

}

if (flag)

{

for (;j

{

AdjList[i].Flight[j].Cost=AdjList[i].Flight[j+1].Cost;

AdjList[i].Flight[j].EndCity=AdjList[i].Flight[j+1].EndCity; strcpy(AdjList[i].Flight[j].name,AdjList[i].Flight[j+1].name); AdjList[i].Flight[j].StartTime=AdjList[i].Flight[j+1].StartTime;

AdjList[i].Flight[j].StopTime=AdjList[i].Flight[j+1].StopTime;

}

AdjList[i].FlightNum--;

break;

}

for (j=0;j

if (strcmp(AdjList[i].Train[j].name,name)==0)

{

flag=1;break;

}

if (flag)

{

for (;j

{

AdjList[i].Train[j].Cost=AdjList[i].Train[j+1].Cost;

AdjList[i].Train[j].EndCity=AdjList[i].Train[j+1].EndCity;

strcpy(AdjList[i].Train[j].name,AdjList[i].Train[j+1].name);

AdjList[i].Train[j].StartTime=AdjList[i].Train[j+1].StartTime;

AdjList[i].Train[j].StopTime=AdjList[i].Train[j+1].StopTime;

}

AdjList[i].TrainNum--;

break;

}

}

return 1;

}

（9）打印最小费用路线：

void Dijkstra_Output(int matx[Dij_MAXN][Dij_MAXN],int

PreCity[Dij_MAXN],int p_end,int TravelType)

{

int track[Dij_MAXN];

int i=0,j,k,min,tmp,end,cost=0;

int startH, startM, endH, endM;rainNum;k++)

if

(AdjList[track[i]].Train[k].EndCity==end&&min>AdjList[track[i]].Train[k].C ost)

{

min=AdjList[track[i]].Train[k].Cost;

tmp=k;

}

printf("%s

",AdjList[track[i]].Train[tmp].name);

startH =

AdjList[track[i]].Train[tmp].StartTime/60 ;

startM =

AdjList[track[i]].Train[tmp].StartTime%60;

endH =

AdjList[track[i]].Train[tmp].StopTime/60 ;

endM =

AdjList[track[i]].Train[tmp].StopTime%60 ;

if( !(startH/10) )

{

printf("0");

}

printf("%d:",startH);

if( !(startM/10) )

{

printf("0");

}

printf("%d -- ",startM);

if( !(endH/10) )

{

printf("0");

}

printf("%d:",endH);

if( !(endM/10) )

{

printf("0");

}

printf("%d\n",endM);

rain[tmp].StartTime/60,AdjList[track[i]].Train[tmp].StartTime%60,AdjList[t rack[i]].Train[tmp].StopTime/60,AdjList[track[i]].Train[tmp].StopTime%60);

}

}

else

{

for(i--;i>0;i--)

{

printf("\n%s:",CityName[track[i]]);

end=track[i-1];min=32767;

for

(k=0;k

rain[k].EndCity改为

AdjList[track[i]].Flight[k].EndCity！

/*if

(AdjList[track[i]].Train[k].EndCity==end&&min>AdjList[track[i]].Flight[k]. Cost)

{ */

if

(AdjList[track[i]].Flight[k].EndCity==end&&min>AdjList[track[i]].Flight[k] .Cost)

{

min=AdjList[track[i]].Flight[k].Cost;

tmp=k;

}

printf("%s",AdjList[track[i]].Flight[tmp].name);

startH =

AdjList[track[i]].Flight[tmp].StartTime / 60 ;

startM =

AdjList[track[i]].Flight[tmp].StartTime % 60;

endH =

AdjList[track[i]].Flight[tmp].StopTime / 60 ;

endM =

AdjList[track[i]].Flight[tmp].StopTime % 60 ;

if( !(startH/10) )

{

printf("0");

}

printf("%d:",startH);

if( !(startM/10) )

{

printf("0");

}

printf("%d -- ",startM);

if( !(endH/10) )

{

printf("0");

}

printf("%d:",endH);

if( !(endM/10) )

{

printf("0");

}

printf("%d\n",endM);

light[tmp].StartTime /

60,AdjList[track[i]].Flight[tmp].StartTime %

60,AdjList[track[i]].Flight[tmp].StopTime /

60,AdjList[track[i]].Flight[tmp].StopTime % 60);

}

}

printf("\n%s: DESTINATION!",CityName[track[0]]);

printf("\nMin Cost : %d\n",cost);

}

（10）找出最小费用路线

void Dijkstra(int matx[Dij_MAXN][Dij_MAXN],int p_start,int p_end,int TravelType)

{

int PreCity[Dij_MAXN]; .\n");

return -1;

}

fscanf(fp,"%d",&CityNum);

for (i=0;i

{

fscanf(fp,"%s",&CityName[i]);

AdjList[i].city=i;

AdjList[i].TrainNum=0;

AdjList[i].FlightNum=0;

}

fclose(fp);

fp=fopen(TrainFile,"r");

if (!fp)

{

printf("\nError:Cannot Open Train File...\n"); return -1;

}

fscanf(fp,"%d",&num);

for (i=0;i

{

fscanf(fp,"%s",&stmp1);

fscanf(fp,"%s",&stmp2);

fscanf(fp,"%s",&stmp3);

j=SeekCity(stmp2);

AdjList[j].Train[AdjList[j].TrainNum].EndCity=SeekCity(stmp3);

strcpy(AdjList[j].Train[AdjList[j].TrainNum].name,stmp1); fscanf(fp,"%d:%d",&hour,&minute);

AdjList[j].Train[AdjList[j].TrainNum].StartTime=hour*60+minute;

fscanf(fp,"%d:%d",&hour,&minute);

AdjList[j].Train[AdjList[j].TrainNum].StopTime=hour*60+minute;

fscanf(fp,"%d",&cost);

AdjList[j].Train[AdjList[j].TrainNum].Cost=cost;

AdjList[j].TrainNum++;

}

fclose(fp);

fp=fopen(FlightFile,"r");

if (!fp)

{

printf("\nError:Cannot Open Flight File...\n");

return -1;

}

fscanf(fp,"%d",&num);

for (i=0;i

{

fscanf(fp,"%s",&stmp1);

fscanf(fp,"%s",&stmp2);

fscanf(fp,"%s",&stmp3);

j=SeekCity(stmp2);

AdjList[j].Flight[AdjList[j].FlightNum].EndCity=SeekCity(stmp3);

strcpy(AdjList[j].Flight[AdjList[j].FlightNum].name,stmp1);

fscanf(fp,"%d:%d",&hour,&minute);

AdjList[j].Flight[AdjList[j].FlightNum].StartTime=hour*60+minute;

fscanf(fp,"%d:%d",&hour,&minute);

AdjList[j].Flight[AdjList[j].FlightNum].StopTime=hour*60+minute;

fscanf(fp,"%d",&cost);

AdjList[j].Flight[AdjList[j].FlightNum].Cost=cost; AdjList[j].FlightNum++;

}

fclose(fp);

return 1;

}

（12）找出最快路线：

int SearchMinTime (CityType City,CityType EndCity,int CurTime,int curPathNo,int TravelType)

{

int i;

if (City==EndCity)

{

if (MinTime>CurTime-StartTime)

{

for (i=0;i<=curPathNo;i++)

{

MinPath[i].City=Path[i].City;

MinPath[i].TraNo=Path[i].TraNo;

curPath=curPathNo;

}

MinTime=CurTime-StartTime;

}

}

else

{

curPathNo++;

Path[curPathNo].City=City;

if (!TravelType)

{

for (i=0;i

{

if

((AdjList[City].Train[i].StartTime>=(CurTime%1440))&&(AdjList[City].Train[ i].StopTime+(CurTime/1440)*1440-StartTime

{

Path[curPathNo].TraNo=i;

SearchMinTime(AdjList[City].Train[i].EndCity,EndCity,AdjList[City].Train[i ].StopTime+(CurTime/1440)*1440,curPathNo,TravelType);

}

if

((AdjList[City].Train[i].StartTime<(CurTime%1440))&&(AdjList[City].Train[i ].StopTime+(CurTime/1440)*1440-StartTime

{

Path[curPathNo].TraNo=i;

SearchMinTime(AdjList[City].Train[i].EndCity,EndCity,AdjList[City].Train[i ].StopTime+(CurTime/1440+1)*1440,curPathNo,TravelType);

}

}

}

else

{

for (i=0;i

{

if

((AdjList[City].Flight[i].StartTime>=CurTime)&&(AdjList[City].Flight[i].St opTime+(CurTime/1440)*1440-StartTime

{

Path[curPathNo].TraNo=i;

SearchMinTime(AdjList[City].Flight[i].EndCity,EndCity,AdjList[City].Flight [i].StopTime+(CurTime/1440)*1440,curPathNo,TravelType);

}

if

((AdjList[City].Flight[i].StartTime

{

Path[curPathNo].TraNo=i;

SearchMinTime(AdjList[City].Flight[i].EndCity,EndCity,AdjList[City].Flight [i].StopTime+(CurTime/1440+1)*1440,curPathNo,TravelType);

}

}

}

}

return 1;

}

（13）计算最快路线所需时间并打印：

int CalcMinTime (int StartCity,int EndCity,int TravelType)

{

int i;

int startH, startM, endH, endM;ity=StartCity;

if (!TravelType)

{

for (i=0;i

{

Path[0].TraNo=i;

StartTime=AdjList[StartCity].Train[i].StartTime;

SearchMinTime(AdjList[StartCity].Train[i].EndCity,EndCity,AdjList[StartCit y].Train[i].StopTime,0,TravelType);

}

}

else

{

for (i=0;i

{

Path[0].TraNo=i;

StartTime=AdjList[StartCity].Flight[i].StartTime;

SearchMinTime(AdjList[StartCity].Flight[i].EndCity,EndCity,AdjList[StartCi ty].Flight[i].StopTime,0,TravelType);

}

}

if (MinTime==32767)

{

printf("\nNo access to that destination!");

return 0;

}

rain[MinPath[0].TraNo].StartTime;

light[MinPath[0].TraNo].StartTime;

printf("\nPath:\n");

for (i=0;i<=curPath;i++)

{

if (!TravelType)

printf("%s : %s

",CityName[MinPath[i].City],AdjList[MinPath[i].City].Train[MinPath[i].TraN o].name);

else

printf("%s : %s

",CityName[MinPath[i].City],AdjList[MinPath[i].City].Flight[MinPath[i].Tra No].name);

startH =

AdjList[MinPath[i].City].Train[MinPath[i].TraNo].StartTime / 60 ;

startM =

AdjList[MinPath[i].City].Train[MinPath[i].TraNo].StartTime % 60 ;

endH =

AdjList[MinPath[i].City].Train[MinPath[i].TraNo].StopTime / 60 ;

endM =

AdjList[MinPath[i].City].Train[MinPath[i].TraNo].StopTime % 60 ;

if( !(startH/10) )

{

printf("0");

}

printf("%d:",startH);

if( !(startM/10) )

{

printf("0");

}

printf("%d -- ",startM);

if( !(endH/10) )

{

printf("0");

}

printf("%d:",endH);

if( !(endM/10) )

{

printf("0");

}

printf("%d\n",endM);

rainNum)

{

min=32767;

end=AdjList[i].Train[j].EndCity;

while

(end==AdjList[i].Train[j].EndCity&&j

{

if (AdjList[i].Train[j].Cost

{

min=AdjList[i].Train[j].Cost;

}

j++;

}

ma[i][end]=min;

}

}

}

else

{

for (i=0;i

{

min=32767;j=0;

while (j

{

min=32767;

end=AdjList[i].Flight[j].EndCity;

while

(end==AdjList[i].Flight[j].EndCity&&j

{

if (AdjList[i].Flight[j].Cost

{

min=AdjList[i].Flight[j].Cost;

}

j++;

}

ma[i][end]=min;

}

}

}

Dijkstra(ma,StartCity,EndCity,TravelType);

return 1;

}

五、功能模块间函数的调用关系，如下图所示：