两点间路径最短算法

‘壹’ 最短路径法如何计算

最短路径算法有三种，Floyd，dijkstra，Bellman_Ford。其中，Floyd适合用于计算每两点间的路径，dijkstra适合稀疏图，bellman则适合稠密图中的已知起点终点，计算最短路径的问题。时间复杂度，floyd算法为n立方，dijk为n平方，bellman为n平方，其中n是点数。dijk可用堆维护，时间复杂度可减至nlogn，而bellman可用队列维护，此方法于1994年被国人提出，命名比较土鳖叫SPFA(shortest path faster algorithm。。。)。至于如何计算，有了名字，搜一下就ok。

‘贰’ 求有向图两个顶点间的最短路径的方法，用简单语言或举例描述。

在交通网络中，常常会提出许多这样的问题：两地之间是否有路相通？在有多条通路的情况下，哪一条最近？哪一条花费最少等。交通网络可以用带权图表示，图中顶点表示域镇，边表示两城之间的道路，边上权值可表示两城镇间的距离，交通费用或途中所需的时间等。
以上提出的问题就是带权图中求最短路径的问题，即求两个顶点间长度最短的路径。
最短路径问题的提法很多。在这里仅讨论单源最短路径问题：即已知有向图(带权)，我们希望找出从某个源点S∈V到G中其余各顶点的最短路径。
例如：下图(有向图G14)，假定以v1为源点，则其它各顶点的最短路径如下表所示：

图 G14

从有向图可看出，顶点v1到v4的路径有3条：(v1,v2,v4)，(v1,v4)，(v1,v3,v2,v4 )，其路径长度分别为：15,20和10。因此v1到v4的最短路径为(v1,v3,v2,v4 )。
为了叙述方便，我们把路径上的开始点称为源点，路径的最后一个顶点为终点。
那么，如何求得给定有向图的单源最短路径呢？迪杰斯特拉(Dijkstra)提出按路径长度递增产生诸顶点的最短路径算法，称之为迪杰斯特拉算法。
迪杰斯特拉算法求最短路径的实现思想是：设有向图G=(V,E)，其中，V={1,2,…,n}，cost是表示G的邻接矩阵，cost[i][j] 表示有向边<i,j>的权。若不存在有向边<i,j>，则cost[i][j]的权为无穷大(这里取值为32767)。设S是一个集合，其中的每个元素表示一个顶点，从源点到这些顶点的最短距离已经求出。设顶点v1为源点，集合S的初态只包含顶点v1。数组dist记录从源点到其他各顶点当前的最短距离，其初值为dist[i]=cost[v1][i]，i=2,…,n。从S之外的顶点集合V-S 中选出一个顶点w，使dist[w]的值最小。于是从源点到达w只通过S 中的顶点，把w加入集合S中调整dist中记录的从源点到V-S中每个顶点v的距离：从原来的dist[v] 和dist[w]+cost[w][v]中选择较小的值作为新的dist[v]。重复上述过程，直到S中包含V中其余顶点的最短路径。
最终结果是：S记录了从源点到该顶点存在最短路径的顶点集合，数组dist记录了从源点到 V中其余各顶点之间的最短路径，path是最短路径的路径数组，其中path[i] 表示从源点到顶点i之间的最短路径的前驱顶点。

‘叁’ 求图中任意两点之间最短路径有什么算法

单源节点到其他任意节点的最短路径采用Dijkstra算法，任意两个节点之间的最短路径使用Floyd算法，这两个算法有很多地方可以找打。

‘肆’ 求A到B之间的最短路径，怎么获取

问题：从某顶点出发，沿图的边到达另一顶点所经过的路径中，各边上权值之和最小的一条路径——最短路径。解决最短路的问题有以下算法，Dijkstra算法，Bellman-Ford算法，Floyd算法和SPFA算法，另外还有着名的启发式搜索算法A*，不过A*准备单独出一篇，其中Floyd算法可以求解任意两点间的最短路径的长度。任意一个最短路算法都是基于这样一个事实：从任意节点A到任意节点B的最短路径不外乎2种可能，1是直接从A到B，2是从A经过若干个节点到B。
(1) 迪杰斯特拉(Dijkstra)算法按路径长度(看下面表格的最后一行，就是next点)递增次序产生最短路径。先把V分成两组：
S：已求出最短路径的顶点的集合
V-S=T：尚未确定最短路径的顶点集合
将T中顶点按最短路径递增的次序加入到S中，依据：可以证明V0到T中顶点Vk的最短路径，或是从V0到Vk的直接路径的权值或是从V0经S中顶点到Vk的路径权值之和（反证法可证，说实话，真不明白哦）。
(2) 求最短路径步骤
初使时令 S={V0},T={其余顶点}，T中顶点对应的距离值， 若存在<V0,Vi>，为<V0,Vi>弧上的权值（和SPFA初始化方式不同），若不存在<V0,Vi>，为Inf。
从T中选取一个其距离值为最小的顶点W(贪心体现在此处)，加入S(注意不是直接从S集合中选取，理解这个对于理解vis数组的作用至关重要)，对T中顶点的距离值进行修改：若加进W作中间顶点，从V0到Vi的距离值比不加W的路径要短，则修改此距离值（上面两个并列for循环，使用最小点更新）。
重复上述步骤，直到S中包含所有顶点，即S=V为止（说明最外层是除起点外的遍历）。

‘伍’ 网格中如何求任意两点间的最短路径 matlab算法

function [L,Z]=dijkstra(W,S,T)
%用 Dijkstra 算法求最短路径
% 算法
% 1. 对每个点I指定一个离点S的距离初始值L(I). 在始点S的值为零, 即L(S)=0，其它点的值为Inf.
% 2. 所有的点标记为未走访的. 置始点S为当前点C.
% 3. 对于当前点C, 考虑它的所有未走访的相邻点J, 并更新J的距离值为
% L(J)=min(L(J), L(C)+W(C,J))
% 4. 把当前点C标记为走访过的点. 走访过的点C的距离L(C)就是点S到C的最短距离, 而且以后不再检查走访过得点了.
% 5. 如果所有的点都是走访过的点, 完成. 不然, 把未走访的点中具有最小距离值的点作为下一个当前点C, 转
N=length(W(:,1));%顶点数
W(find(W==0))=inf;
L=Inf*ones(1,N);
L(S)=0;%L赋初值，在S点为0，其它点为Inf
C=S; %当前点为始点S
Q=1:N;% 未走访的顶点集
Z=S*ones(1,N);
Z(S)=0;% Z赋初值,因始点 S 无父亲点,故把 S 点的Z值改为0
for K=1:N % 更新 L 和 Z 的循环
Q=setdiff(Q,C); %Matlab自带函数，显示Q中除了C之外的点集，即当前点 C 未走访的点集
[L(Q),ind]=min([L(Q);L(C)+W(C,Q)]);%当前点C已走访了所有的相邻的未走访的点，找出与C相邻的距离最短的点，记录最短距离和结点的索引值，更新 L
%如果L(Q)
Z(Q(find(ind==2)))=C; %更新Z, 找出Q中索引值为2的结点，将其父亲结点更新为C,至此可以确定C已是走访过的点了
if T&C==T %若 C 点是终点 T, 不用再计算到其它未走访的点的最短路径.先判断C==T，再判断&
L=L(T); %最短路径长度；
road=T;%最短路径终点；
while T~=S%追溯最短路径上的点
T=Z(T); %从终点往前寻找其父亲结点
road=[road,T]; %从终点开始倒序记录最短路径上的结点
end
Z=road(length(road):-1:1); %颠倒次序；
return;
end;
[null, mC]=min(L(Q));
if null==Inf
% disp('到值是Inf的点的路不通！');
Z(find(L==Inf))=nan; %NaN或者nan都是“非数”的意思，“0/0”、“∞/∞”、“0*∞”都会产生这种结果
return;
else
C=Q(mC);% 把未走访的点集Q中与始点距离最近的点作为新的当前点C;
end
end
end

‘陆’ 数学最短路径问题最方便的解法是什么

用于解决最短路径问题的算法被称做“最短路径算法” ，有时被简称作“路径算法” 。最常用 的路径算法有： Dijkstra 算法、 A*算法、 SPFA 算法、 Bellman-Ford 算法和 Floyd-Warshall 算法， 本文主要介绍其中的三种。 最短路径问题是图论研究中的一个经典算法问题，旨在寻找图（由结点和路径组成的）中两 结点之间的最短路径。 算法具体的形式包括： 确定起点的最短路径问题：即已知起始结点，求最短路径的问题。 确定终点的最短路径问题：与确定起点的问题相反，该问题是已知终结结点，求最短路径的 问题。 在无向图中该问题与确定起点的问题完全等同， 在有向图中该问题等同于把所有路径 方向反转的确定起点的问题。 确定起点终点的最短路径问题：即已知起点和终点，求两结点之间的最短路径。 全局最短路径问题：求图中所有的最短路径。 Floyd 求多源、无负权边的最短路。用矩阵记录图。时效性较差，时间复杂度 O(V^3)。 Floyd-Warshall 算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法， 可以正确处理有向图或负权的最短路径问题。 Floyd-Warshall 算法的时间复杂度为 O(N^3)，空间复杂度为 O(N^2)。 Floyd-Warshall 的原理是动态规划： 设 Di,j,k 为从 i 到 j 的只以(1..k)集合中的节点为中间节点的最短路径的长度。 若最短路径经过点 k，则 Di,j,k = Di,k,k-1 + Dk,j,k-1； 若最短路径不经过点 k，则 Di,j,k = Di,j,k-1。 因此，Di,j,k = min(Di,k,k-1 + Dk,j,k-1 , Di,j,k-1)。 在实际算法中，为了节约空间，可以直接在原来空间上进行迭代，这样空间可降至二维。 Floyd-Warshall 算法的描述如下： 1.for k ← 1 to n do 2.for i ← 1 to n do 3.for j ← 1 to n do 4.if (Di,k + Dk,j<Di,j) then 5.Di,j ← Di,k + Dk,j; 其中 Di,j 表示由点 i 到点 j 的代价，当 Di,j 为∞表示两点之间没有任何连接。 Dijkstra 求单源、无负权的最短路。时效性较好，时间复杂度为 O（V*V+E） 。 源点可达的话，O（V*lgV+E*lgV）=>O（E*lgV） 。 当是稀疏图的情况时，此时 E=V*V/lgV，所以算法的时间复杂度可为 O（V^2） 。若是斐波那 契堆作优先队列的话，算法时间复杂度，则为 O（V*lgV + E） 。 Bellman-Ford 求单源最短路，可以判断有无负权回路（若有，则不存在最短路） ，时效性较好，时间复杂 度 O（VE） 。 Bellman-Ford 算法是求解单源最短路径问题的一种算法。 单源点的最短路径问题是指：给定一个加权有向图 G 和源点 s，对于图 G 中的任意一点 v， 求从 s 到 v 的最短路径。 与 Dijkstra 算法不同的是，在 Bellman-Ford 算法中，边的权值可以为负数。设想从我们可以 从图中找到一个环路（即从 v 出发，经过若干个点之后又回到 v）且这个环路中所有边的权 值之和为负。那么通过这个环路，环路中任意两点的最短路径就可以无穷小下去。如果不处 理这个负环路，程序就会永远运行下去。而 Bellman-Ford 算法具有分辨这种负环路的能力。 SPFA是 Bellman-Ford 的队列优化，时效性相对好，时间复杂度 O（kE）（k<<V） 。 。 与 Bellman-ford 算法类似， SPFA 算法采用一系列的松弛操作以得到从某一个节点出发到达图 中其它所有节点的最短路径。所不同的是，SPFA 算法通过维护一个队列，使得一个节点的 当前最短路径被更新之后没有必要立刻去更新其他的节点， 从而大大减少了重复的操作次数。 SPFA 算法可以用于存在负数边权的图，这与 dijkstra 算法是不同的。 与 Dijkstra 算法与 Bellman-ford 算法都不同，SPFA 的算法时间效率是不稳定的，即它对于不 同的图所需要的时间有很大的差别。 在最好情形下，每一个节点都只入队一次，则算法实际上变为广度优先遍历，其时间复杂度 仅为 O(E)。另一方面，存在这样的例子，使得每一个节点都被入队(V-1)次，此时算法退化为 Bellman-ford 算法，其时间复杂度为 O(VE)。 SPFA 算法在负边权图上可以完全取代 Bellman-ford 算法， 另外在稀疏图中也表现良好。 但是 在非负边权图中，为了避免最坏情况的出现，通常使用效率更加稳定的 Dijkstra 算法，以及 它的使用堆优化的版本。通常的 SPFA 算法在一类网格图中的表现不尽如人意。 

‘柒’ 最短路径的两点怎么找

最短路径的两点可以通过一个定义两点之间直线最短来决定最短的路径。

地理信息系统简称GIS，是一种以采集、存储、管理、分析和描述地球表面与地理分布有关数据的空间信息系统。它能显示数据的空间分布，并具有强大的空间查询、分析、模拟、统计和预测等功能。故寻求两点之间最短、最快或景点最多的路径可应用GIS的查询和分析功能。

最短路径介绍

最短路径问题是图论研究中的一个经典算法问题， 旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。 算法具体的形式包括：确定起点的最短路径问题 - 即已知起始结点，求最短路径的问题。

确定终点的最短路径问题 - 与确定起点的问题相反，该问题是已知终结结点，求最短路径的问题。在无向图中该问题与确定起点的问题完全等同，在有向图中该问题等同于把所有路径方向反转的确定起点的问题。

‘捌’ 找最短路径的方法

1），深度或广度优先搜索算法（解决单源最短路径）
从起始结点开始访问所有的深度遍历路径或广度优先路径，则到达终点结点的路径有多条，取其中路径权值最短的一条则为最短路径。
给定一个带权有向图G=（V,E），其中每条边的权是一个实数。另外，还给定V中的一个顶点，称为
源。
现在要计算从源到其他所有各顶点的最短路径长度。这里的长度就是指路上各边权之和。这个问题通
常称为单源最短路径 问题。
从起始结点开始访问所有的深度遍历路径或广度优先路径，则到达终点结点的路径有多条，取其中路
径权值最短的一条则为最短路径

‘玖’ C语言求两点之间的最短路径

#include<graphics.h>
#include<stdio.h>
# define n 6
# define NULL 0
#define UP 72
#define DOWN 80
#define ESC 27
#define Enter 13
int i1=0,j1=3,m1=0,n1=0;
int start=0;
char str2[][100]={"THE INTRODUTION OF THE ROUTINE !",
"AUGMENT THE RELATIVE DATA !",
"SEARCH FOR THE INFORMATION !",
"QUIT THE ROUTINE !"};
char str3[][100]={"THE ROUTINE WAS PROGRAMED IN ",
" 2006--07--10",
"PROGRAMER : ",
"CAO JUN BIN "};

int dd[n+1][n+1], pp[n+1][n+1],a[n];
typedef struct
{int number;<br> int edge[n+1][n+1];<br> }graph;
graph g;
int maxdist=2000,mindist;
struct viewpoint
{int x;<br> int y;<br> int number;<br> char inf[10];<br> }bd[n];

struct point
{int number;<br> int x_1;<br> int y_1;<br> }point[n];
typedef struct point f;
struct path
{int V1;<br> int V2;<br> int length;<br> }p[n*n/2];

void mainmenu ();
void con();
void choosepoint() ;
void interface();
void interface1();
void again();
void drawbuilding();
void drawedge();
void floyd(graph g,int m, int dd[n+1][n+1],int pp[n+1][n+1]);
void display(int i,int j,int pp[n+1][n+1],int dd[n+1][n+1]);
void drawpath();
void buildingmap( );
void pathmap( );
main()
{ int gdriver=9,gmode=2;
initgraph(&gdriver,&gmode,"c:\\TURBOC2");
mainmenu();
}

void mainmenu ()
{int a,flag=1,i,j;<br> char c; char str[10];<br> setbkcolor(BLACK);<br> setcolor(LIGHTGRAY);<br> rectangle(20,20,600,475);<br> settextstyle(4,0,4);<br> setcolor(LIGHTRED);<br> outtextxy(160,70,"THE MAIN MENU ");<br> settextstyle(3,0,1);<br> setcolor(CYAN);<br> outtextxy(160,160,str2[0]);<br> outtextxy(160,200,str2[1]);<br> outtextxy(160,240,str2[2]);<br> outtextxy(160,280,str2[3]);<br> while(flag){ c=getch();<br> switch(c){case DOWN:i1++;j1++;<br> m1=i1%4;n1=j1%4;<br> con();break;<br> case UP :if(i1==-1)i1=3;if(j1==-1)j1=3;<br> m1=i1%4;n1=j1%4;a=m1;m1=n1;n1=a;<br> con();<br> i1--;j1--;break;<br> case ESC :flag=0;break;<br> case Enter:cleardevice();<br> if(m1==0){interface1();getch();cleardevice();<br> mainmenu();<br> }

if(m1==1){ setbkcolor(BLACK);
setcolor(YELLOW);
rectangle(20,20,600,475);
rectangle(30,30,590,465) ;
setcolor(LIGHTRED);
settextstyle(3,0,1);
setcolor(LIGHTRED);
outtextxy(160,160,"PLESE CHOOSE THE SEVICE !");
outtextxy(120,200," AUGMENT THE INFORMATION OF THE BUILDING (B)!");
outtextxy(120,240," AUGMENT THE INFORMATION OF THE BUILDING (P) !");
switch(getch()){case'B':{cleardevice();buildingmap();cleardevice();};break;
case 'P':{cleardevice();pathmap();cleardevice();};break;
default: cleardevice();mainmenu();}
}
if(m1==2){
interface();
getch();}
if(m1==3){exit(0);<br> }
}

}

}
void con()
{setcolor(YELLOW);<br> outtextxy(160,160+m1*40,str2[m1]);<br> setcolor(CYAN);<br> outtextxy(160,160+n1*40,str2[n1]);<br> }
void interface()
{ int i,j;
char str[10];
setbkcolor(BLACK);
setcolor(LIGHTGRAY);
rectangle(20,20,600,100);
rectangle (20,20,600,470);
rectangle (20,100,450,470) ;
rectangle(20,350,450,470);
rectangle(20,100,300,350);
settextstyle(3,0,3);
outtextxy(200,30,"WELCOME TO");
outtextxy(120,60,"NORTHEAST DIANLI UNIVERSITY!") ;
outtextxy(460,200,"FROM : ___");
outtextxy(485,250,"TO : ___");
settextstyle(2,0,5);
rectangle(475,315,535,335);
rectangle(475,365,535,385);
outtextxy(455,150,"(PLEASE INPUT!)");
outtextxy(175,360,"THE RESULT !");
outtextxy(500,320,"F");
outtextxy(500,370,"Q");
outtextxy(480,400,"Input");
outtextxy(460,420, "the number 1-->6");
setcolor(RED);
drawbuilding();
drawedge();
i=0;
while(i<'1'||i>'6') i=getch();
sprintf(str,"%c",i);
outtextxy(560,205,str);
while(j<'1'||j>'6') j=getch();
sprintf(str,"%c",j);
outtextxy(560,255,str);
i=i-48;j=j-48;
floyd(g,n,dd[n+1][n+1],pp[n+1][n+1]);
display (i,j,pp[n+1][n+1], dd[n+1][n+1]);
drawpath( );
}
void interface1()
{
setbkcolor(BLACK);
setcolor(YELLOW);
rectangle(20,20,600,475);
rectangle(30,30,590,465) ;
settextstyle(4,0,4);
setcolor(LIGHTRED);

settextstyle(3,0,1);
setcolor(LIGHTRED);
outtextxy(160,160,str3[0]);
outtextxy(160,200,str3[1]);
outtextxy(210,240,str3[2]);
outtextxy(210,280,str3[3]);

}

void again()
{int i;<br> if(start==0) {for (i=0;i<300;i++) delay(1000);}
}

void drawbuilding()
{ int i,a;char str[10];
FILE *fp;
if ((fp=fopen("map.dat","r"))==NULL)
{
printf("Can not open the file of map.dat.\n");
exit(0);
}

for(i=0;i<n;i++)
{fread(&bd[i],sizeof(struct viewpoint),1,fp);<br> point[i].number=bd[i].number;<br> point[i].x_1=bd[i].x;<br> point[i].y_1=bd[i].y;<br><br> setcolor(RED);<br> a=bd[i].number;<br> sprintf(str,"%d",a);<br> again();<br> circle(bd[i].x,bd[i].y,8);<br> setcolor(LIGHTGRAY);<br> outtextxy(bd[i].x-2,bd[i].y-5,str);<br> outtextxy(310,i*30+120,str);<br> outtextxy(325,i*30+120,":");<br> outtextxy(340,i*30+120,bd[i].inf);<br> again();<br> }

fclose(fp);

}

void drawedge()
{ FILE *fp;char str[10];
int i,j,x1,x2,y1,y2,a;
if((fp=fopen("pmap.dat","r"))==NULL)
{ printf ("can't open the file\n");
exit(0);
}

for (i=0;i<=n;i++)
{for (j=0;j<=n;j++)<br> g.edge[i][j]=maxdist;}
for(j=1;j<=n;j++)
g.edge[j][j]=0;
while(!feof(fp))
{ fread(&p[i],sizeof(struct path),1,fp);
if(p[i].V1!=0)
{
{g.edge[p[i].V1][p[i].V2]=p[i].length;<br> g.edge[p[i].V2][p[i].V1]=p[i].length;<br> }
setcolor(LIGHTBLUE);
for(j=0;j<n;j++)
{if(p[i].V1-point[j].number==0)<br> {x1=point[j].x_1;<br> y1=point[j].y_1;<br> }
}

for(j=0;j<n;j++)
{if(p[i].V2==point[j].number)<br> { x2=point[j].x_1;<br> y2=point[j].y_1;<br> }

}
line(x1,y1,x2,y2);
setcolor(LIGHTGRAY);
a=p[i].length;
sprintf(str,"%d",a);
outtextxy((x1+x2)/2,(y1+y2)/2,str);
again();
}
}

fclose(fp);
start=1;
}

void floyd(graph g,int m,int dd[n+1][n+1],int pp[n+1][n+1])
{int i,j,k,w;<br><br>for(i=0;i<=m;i++)<br> {for(j=0;j<=m;j++)<br> dd[i][j]=maxdist;}

for(i=0;i<=m;i++)
{for(j=0;j<=m;j++)<br> pp[i][j]=0;<br> }
for(i=1;i<=m;i++)
{ for(j=1;j<=m;j++)
{dd[i][j]=g.edge[i][j];<br> if(dd[i][j]<maxdist&dd[i][j]!=0)<br> pp[i][j]=j;<br> else<br> pp[i][j]=-1;<br><br> } }
for(k=1;k<=m;k++)
for(i=1;i<=m;i++)
for(j=1;j<=m;j++)
if(dd[i][j]>(dd[i][k]+dd[k][j]))
{
dd[i][j]=dd[i][k]+dd[k][j];
pp[i][j]=k;
pp[j][i]=k;
}
}
void display(int i,int j,int pp[n+1][n+1],int dd[n+1][n+1])
{
int pre,flag,k,w=40;int m=0;
int str[10];
pre=k=j;
do { pre=pp[i][pre];
if(pre!=k)
sprintf(str,"%d",k);
outtextxy(120+w,390,str);

outtextxy(130+w,390,"<--");
a[m]=k;
m=m+1;
w=w+40;
k=pre;
pre=pp[i][pre];
flag=pre;
}while(flag!=k) ;

sprintf(str,"%d",flag);
outtextxy(120+w,390,str);
a[m]=flag;
outtextxy(130+w,390,"<--");
sprintf(str,"%d",i);
outtextxy(160+w,390,str);
a[m+1]=i;
a[m+2]=NULL;

outtextxy(60,390,"THE WAY IS:");
outtextxy(60,420,"THE SHORTEST WAY IS :");
sprintf(str,"%d",dd[i][j]);
outtextxy(240,420,str);

}
void drawpath( )
{ int i,j,x1,x2,y1,y2;
char l;
setcolor(RED);
for(i=0;i<n;i++)
{if(a[i+1]!=NULL)<br> { again();<br> for(j=0;j<n;j++)<br> {if(a[i]-point[j].number==0)<br> {x1=point[j].x_1;<br> y1=point[j].y_1;<br> }
}

for(j=0;j<n;j++)
{if(a[i+1]==point[j].number)<br> { x2=point[j].x_1;<br> y2=point[j].y_1;<br> }

}
line(x1,y1,x2,y2);

}
}
i=0;
while(i!='Q'&i!='F'&i!='q'&i!='f') i=getch();
switch(i)
{ case 'Q': {cleardevice();<br> mainmenu();};break;
case 'q': {cleardevice();<br> mainmenu();};break;
case 'F': {cleardevice();interface();};break;
case 'f': {cleardevice();interface();};break;
}
}

void buildingmap( )
{ FILE *fp;
int i;
setbkcolor(BLACK);
setcolor(YELLOW);
rectangle(100,40,450,475);
rectangle(110,50,440,465) ;

setcolor(LIGHTRED);
settextstyle(2,0,4);
setcolor(LIGHTRED); if((fp=fopen("ss1-map","ab"))==NULL)
{ printf ("can't open the file\n");
exit(0);
}
outtextxy(160,100,"Please input the information of the building! ");
for(i=0;i<n;i++)
{ outtextxy(160,100+20*(i+1),"<--input data:" );
scanf("%d,%d,%d,%s\n",&bd[i].x,&bd[i].y,&bd[i].number,bd[i].inf );
if(fwrite(&bd[i],sizeof(struct viewpoint),1,fp)!=1)
printf("file write error\n");
}
fclose(fp);
if(getch()=='Q') {cleardevice();mainmenu();}
}
void pathmap()
{FILE *fp;<br> int i;<br> cleardevice();<br> setbkcolor(BLACK);<br> rectangle(100,40,450,475);<br> rectangle(110,50,440,465) ;<br><br> setcolor(LIGHTRED);<br> settextstyle(2,0,4);<br> if((fp=fopen("pp1-map","ab"))==NULL)<br> { printf ("can't open the file\n");<br> exit(0);<br> }
fseek(fp,0L,2);
outtextxy(160,100,"Please input the information of the building! ");
for(i=0;i<(n*n/2);i++)
{ outtextxy(160,100+20*(i+1),"<--input data:" );
scanf("%d,%d,%d\n",&p[i].V1,&p[i].V2,&p[i].length );
if(fwrite(&p[i],sizeof(struct path),1,fp)!=1)
printf("file write error\n");
}
fclose(fp);
if(getch()=='Q') {cleardevice();mainmenu();}
}