UrbanHighwayNavigationSystem

项目名称 城市公路导航系统

杨腾泽，刘鑫成，李培毅，孙英皓

摘要： (1) 基于真实的公路数据建立导航地图模型，编制成格式简单的数据文件包括城市线路名称、站点名称。 (2)系统能够读取公路导航地图数据文件，建立公路模型，也能够将模型输出成数据文件，以便验证模型的正确性。 (3)通过人机交互的方式输入起点和终点站名称，系统给出路径长度最短的导航路径。 (4)能够读取不同的地铁导航地图进行功能测试。

1. 系统分析

通过各种算法，实现公路导航

1.1 问题描述

交通网络中常常提出这样的问题：从甲地到乙地之间是否有公路连通?在有多条通路的情况下，哪一条路最短?导航系统便可以解决这样的问题。与此同时，城市的扩建，新地点的添加，新道路的修建，需要导航系统具备添加新地点，添加新路线的功能。而受一些生态工程的实施，例如退耕还林还草，和自然条件的影响，本来存在的一些地点或道路需要删除或更改，此时导航图还应该及时的更新，以适应新的查找两点间最短路径的需要。 除此之外，用户的查找应是极为方便的，对于最短路线， 新添加的地点和路径以及删除的地点和路径的感知应是直观的，这样才能真正的给使用导航系统的人们提供方便。

1.2 可行性分析

明确解决问题的关键:最关路径算法。 核心数据结构：图。 核心算法:Dijkstra

确定解决问题的总体思路和方案:使用dijkxtra最短路径进行计算。

1.3 需求分析

（1）输入和输出

输入城市编号，即可显示该城市的具体信息，最短路径等。 功能：查找某一个城市的信息 输入：城市的编号 输出：城市的编号，名称以及简介

（2）数据字典

城市 = 城市编号 + 城市名称 + 城市介绍

（3）数据文件

系统中需要读取以下文件以获得城市的边信息数据

creat.cpp

功能：创建图结构
输入：给图中的点赋予该点的编号，名称以及简介
输出：无


function.cpp


功能：连接任意两个点
输入：两个点的编号
输出：无

menu.cpp

功能：输出所有的功能目录
输入：选择的功能编号
输出：返回一个值给main函数

short.cpp

功能：用Dijkstra算法求给出的一点到其余个点的最短路径 输入：源点 输出：地点的最短路程以及路径

功能：用floyd算法求给出的两点之间的最好费用 输入：出发地，目的地 输出：地点的最少费用以及路径

（4）参数设定

构建图结构给图中点位赋予编号，名称，简介

（5）地图信息修改功能

输入修改编号，即可对指定城市进行修改

功能：修改城市信息
输入：要修改的城市编号，以及修改后的城市信息
输出：无

2. 系统设计

2.1 概要设计

系统划分为几个模块，可以画模块图。

逐个说明每个模块的功能（输入、输出、做什么，这里不写怎么做）。

2.2 数据结构设计

首先，分析对比几种可选的数据结构设计方案。如图可以采用邻接矩阵，也可以采用邻接表，表示集合可以用普通的查找表，还可以用不相交集。给出每一种设计方案的特点（优势、不足等）。然后，综合考虑各种因素（空间、时间、乃至团队成员的水平等），给出你的选择。

（1）xxx结构

给出核心数据结构的设计，包括文字描述和示意图。讲清楚数据是如何组织的。多个数据结构，逐一列出。

（2）xxx结构

给出核心数据结构的设计，包括文字描述和示意图。讲清楚数据是如何组织的。

2.3 算法设计

首先，分析对比几种可选的算法设计方案。如是否排序，广度优先或深度优先搜索等。给出每一种设计方案的特点（优势、不足）。然后，综合考虑各种因素（空间、时间、乃至团队成员的水平等），给出你的选择。

（1）XXX算法

给出核心算法的设计，包括伪代码或流程图。多个核心算法，逐一列出。只列举解决问题的核心算法，重点讲清楚是如何解决问题的。

（2）XXX算法

给出核心算法的设计，包括伪代码或流程图。

3. 系统实现

采用C++、利用VSCode实现。

本程序首先是用户编辑界面，用户根据自己的需求编写地图，从而加入顶点的数组之中，创建的地图用邻接矩阵存储，在从主函数之中进行调用，实现对两个算法的调用。用户在输入顶点以及边的信息都会存储，在存储成功之后会提示用户存储成功，之后进入到菜单界面，菜单界面提供两种选择口合，分别可以调运Dijkstra和Floyd算法调用之后输入相应的口令以及要查询的城市编号， 算法会根据邻接矩阵存储的地图进行计算，求出最短路径。在以后使用完系统后，可输入口合 0，系统会结束一切运算，退出程序。

3.1 核心数据结构的实现

核心算法Dijkstra 算法floyd 项目文件结构可以设计为:

-CityRoadNav/

• CityRoadNav.vcxproj // Visual Studio项目文件
• CityRoadNav.vcxproj.filters
• CityRoadNav.slnSource Files/ // 源代码目录
• CityNetwork.cpp // 城市网络类,存储城市数据及邻接矩阵
• CityNetwork.h
• Dijkstra.cpp // Dijkstra算法类,实现最短路径搜索
• Dijkstra.h
• DynamicProgramming.cpp // 动态规划算法类,实现最优路径搜索
• DynamicProgramming.h
• main.cpp // 主程序
• ...Header Files/ // 头文件目录
• ... Resources/ // 资源文件目录
• CityInfo.txt // 城市信息及邻接矩阵

如以下代码，采用迪杰斯特拉算法实现求取路径最短值

int Ppath2(MatGrath &G,int path[],int i,int v)  //前向递归查找路径上的顶点
{
    int k;
    k=path[i];
    if (k==v)
        return k;          //找到了起点则返回
    Ppath2(G,path,k,v);            //找顶点k的前一个顶点
    printf("%s->",G.vexs[k].sight);//输出顶点k
 
}
 
 
int danyuan(MatGrath &G,int v)//求两点之间的最短路径
{
    int dist[MAXV],path[MAXV];
    int s[MAXV];
    int mindis,i,j,u;
    for (i=1; i<=G.vexnum; i++)
    {
        dist[i]=G.arc[v][i].length;      //距离初始化
        s[i]=0;                     //s[]置空
        if (G.arc[v][i].length<INF)      //路径初始化
            path[i]=v;
        else
            path[i]=-1;
    }
    s[v]=1;
    path[v]=0;              //源点编号v放入s中
    for (i=1; i<=G.vexnum; i++)               //循环直到所有顶点的最短路径都求出
    {
        mindis=INF;                 //mindis置最小长度初值
        for (j=1; j<=G.vexnum; j++)       //选取不在s中且具有最小距离的顶点u
            if (s[j]==0 && dist[j]<mindis)
            {
                u=j;
                mindis=dist[j];
            }
        s[u]=1;                     //顶点u加入s中
        for (j=1; j<=G.vexnum; j++)       //修改不在s中的顶点的距离
            if (s[j]==0)
                if (G.arc[u][j].length<INF && dist[u]+G.arc[u][j].length<dist[j])
                {
                    dist[j]=dist[u]+G.arc[u][j].length;
                    path[j]=u;
                }
    }
 
    for(i=1; i<=G.vexnum; i++)
        if (s[i]==1&&v!=i)
        {
            printf(" 从%s到%s的最短路径长度为:%d米\t路径为:",G.vexs[v].sight,G.vexs[i].sight,dist[i]);
            printf("%s->",G.vexs[v].sight);    //输出路径上的起点
            Ppath2(G,path,i,v);    //输出路径上的中间点
            printf("%s\n",G.vexs[i].sight);   //输出路径上的终点
        }
 
 
}

int Ppath1(MatGrath &G,int path[][MAXV],int v,int w)       //前向递归查找路径上的顶点
{
    int k;
    k=path[v][w];
    if (k==-1) return 0;  //找到了起点则返回
    Ppath1(G,path,v,k);    //找顶点i的前一个顶点k
    printf("%s->",G.vexs[k].sight);
    Ppath1(G,path,k,w);    //找顶点k的前一个顶点j
}

如下采用floyd算法求给出的两点之间的最少费用

void ShortestMoney(MatGrath &G,int v,int w)//求花费最少的路径
{
   int A[MAXV][MAXV],path[MAXV][MAXV];
   int i,j,k;
   for (i=0; i<G.vexnum; i++)
       for (j=0; j<G.vexnum; j++)
       {
           A[i][j]=G.arc[i][j].money;
           path[i][j]=-1;  //i到j没有边
       }
   for (k=0; k<G.vexnum; k++)
   {
       for (i=0; i<G.vexnum; i++)
           for (j=0; j<G.vexnum; j++)
               if (A[i][j]>A[i][k]+A[k][j])
               {
                   A[i][j]=A[i][k]+A[k][j];
                   path[i][j]=k;
               }
   }



   if (A[v][w]==INF)
   {
       if (v!=w)
           printf("从%d到%d没有路径\n",v,w);
   }
   else
   {
       printf("  从%s到%s路径费用:%d元人民币 路径:",G.vexs[v].sight,G.vexs[w].sight,A[v][w]);
       printf("%s->",G.vexs[v].sight);    //输出路径上的起点
       Ppath1(G,path,v,w);    //输出路径上的中间点
       printf("%s\n",G.vexs[w].sight);   //输出路径上的终点
   }

}

3.2 核心算法的实现

主函数可以分为以下几个模块:

1. 数据读取模块:读取CityInfo.txt文件,构建城市网络,存储在邻接矩阵中。
2. 用户交互模块:提供用户交互界面,获取用户位置信息及路径查询请求。
3. 位置确定模块:通过城市名称获取城市在邻接矩阵中的位置序号,以供路径查询使用。
4. 路径查询模块:选择Dijkstra算法或动态规划算法计算路径,并返回路径信息。
5. 路径显示模块:将计算得到的路径用可视化方式显示给用户。

核心算法Dijkstra 算法floyd

如以下代码，采用迪杰斯特拉算法实现求取路径最短值

int Ppath2(MatGrath &G,int path[],int i,int v)  //前向递归查找路径上的顶点
{
    int k;
    k=path[i];
    if (k==v)
        return k;          //找到了起点则返回
    Ppath2(G,path,k,v);            //找顶点k的前一个顶点
    printf("%s->",G.vexs[k].sight);//输出顶点k
 
}
 
 
int danyuan(MatGrath &G,int v)//求两点之间的最短路径
{
    int dist[MAXV],path[MAXV];
    int s[MAXV];
    int mindis,i,j,u;
    for (i=1; i<=G.vexnum; i++)
    {
        dist[i]=G.arc[v][i].length;      //距离初始化
        s[i]=0;                     //s[]置空
        if (G.arc[v][i].length<INF)      //路径初始化
            path[i]=v;
        else
            path[i]=-1;
    }
    s[v]=1;
    path[v]=0;              //源点编号v放入s中
    for (i=1; i<=G.vexnum; i++)               //循环直到所有顶点的最短路径都求出
    {
        mindis=INF;                 //mindis置最小长度初值
        for (j=1; j<=G.vexnum; j++)       //选取不在s中且具有最小距离的顶点u
            if (s[j]==0 && dist[j]<mindis)
            {
                u=j;
                mindis=dist[j];
            }
        s[u]=1;                     //顶点u加入s中
        for (j=1; j<=G.vexnum; j++)       //修改不在s中的顶点的距离
            if (s[j]==0)
                if (G.arc[u][j].length<INF && dist[u]+G.arc[u][j].length<dist[j])
                {
                    dist[j]=dist[u]+G.arc[u][j].length;
                    path[j]=u;
                }
    }
 
    for(i=1; i<=G.vexnum; i++)
        if (s[i]==1&&v!=i)
        {
            printf(" 从%s到%s的最短路径长度为:%d米\t路径为:",G.vexs[v].sight,G.vexs[i].sight,dist[i]);
            printf("%s->",G.vexs[v].sight);    //输出路径上的起点
            Ppath2(G,path,i,v);    //输出路径上的中间点
            printf("%s\n",G.vexs[i].sight);   //输出路径上的终点
        }
 
 
}

int Ppath1(MatGrath &G,int path[][MAXV],int v,int w)       //前向递归查找路径上的顶点
{
    int k;
    k=path[v][w];
    if (k==-1) return 0;  //找到了起点则返回
    Ppath1(G,path,v,k);    //找顶点i的前一个顶点k
    printf("%s->",G.vexs[k].sight);
    Ppath1(G,path,k,w);    //找顶点k的前一个顶点j
}

如下采用floyd算法求给出的两点之间的最少费用

void ShortestMoney(MatGrath &G,int v,int w)//求花费最少的路径
{
   int A[MAXV][MAXV],path[MAXV][MAXV];
   int i,j,k;
   for (i=0; i<G.vexnum; i++)
       for (j=0; j<G.vexnum; j++)
       {
           A[i][j]=G.arc[i][j].money;
           path[i][j]=-1;  //i到j没有边
       }
   for (k=0; k<G.vexnum; k++)
   {
       for (i=0; i<G.vexnum; i++)
           for (j=0; j<G.vexnum; j++)
               if (A[i][j]>A[i][k]+A[k][j])
               {
                   A[i][j]=A[i][k]+A[k][j];
                   path[i][j]=k;
               }
   }



   if (A[v][w]==INF)
   {
       if (v!=w)
           printf("从%d到%d没有路径\n",v,w);
   }
   else
   {
       printf("  从%s到%s路径费用:%d元人民币 路径:",G.vexs[v].sight,G.vexs[w].sight,A[v][w]);
       printf("%s->",G.vexs[v].sight);    //输出路径上的起点
       Ppath1(G,path,v,w);    //输出路径上的中间点
       printf("%s\n",G.vexs[w].sight);   //输出路径上的终点
   }

}

4. 系统测试

描述测试的思路和方法。比如，先用小数据量进行测试，再用真实数据进行测试。

测试应考虑到输入数据的特殊情况。

给出若干测试用例，包括输入、预期结果、运行结果或是否通过测试。运行结果和预期结果一致，为通过测试。

5. 总结

概况项目和完成情况。

遇到的问题和解决方法。

个人小结：

杨腾泽：

刘鑫成：本次的系统研发研活动，让我体验到了程序开发的复杂性与程序开发成功的自豪感，一个项目的完成离不开一个团队的团结协作，在进行项目时，需要对其进行反复的纠错和改进，在更改和发现中不断地改进和提升自，从而丰富自己。这次团队体验，让我能够初步地体会到一个团队间的分工协作的重要性，成员分工以及项目领导者的重要性，让我受益匪浅

李培毅：

孙英皓：

参考文献

列出参考的文献资料，根据情况自行添加。

[1] 严蔚敏, 吴伟民. 数据结构（C语言版）. 北京: 清华大学出版社, 2007.