123

README.md

@@ -123,53 +123,125 @@ typedef struct
 
 ## 3.1 核心数据结构的实现
 
-利用循环结构实现查找某一个城市的信息
-如下：
-        int search(MatGrath &G)
-        {   int a;
-            int flag=1;
-            printf("请输入您要查询的城市编号\n");
-            scanf("%d",&a);
-            while(flag)
-            {
-              if(a<=0||a>G.vexnum)
-              {
-                  printf("编号不存在，请重新输入\n");
-                  scanf("%d",&a);
-              }
-              else
-              {   flag=0;
+核心算法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
+ 
+}
  
-                 printf("编号 景点名称         简介                                                      \n");
-                 printf(" %-4d %-16s%-58s\n",G.vexs[a].no,G.vexs[a].sight,G.vexs[a].introduction);
-                 ;
-              }
+ 
+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];
             }
-            return 0;
+        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);   //输出路径上的终点
         }
  
-
-利用深度遍历实现输出城市信息
-如下：
  
-         bool visited[MAXV];
-        int DFS(MatGrath &G,int m)//深度优先搜索
+}
+
+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++)
         {
-            int i;
-            printf("%d %s %s\n",G.vexs[m].no,G.vexs[m].sight,G.vexs[m].introduction);
-            visited[m]=true;
-            for(i=1;i<=G.vexnum;i++)
-            {
-                if(G.arc[m][i].length!=INF&&visited[i]==false)
+            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])
                 {
-                   DFS(G,i);
+                    A[i][j]=A[i][k]+A[k][j];
+                    path[i][j]=k;
                 }
+    }
  
-            }
-         return 0;
-        }
  
+ 
+    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 核心算法的实现