区域交通指南图
可用一个带权有向图表示某一区域的公交线路网，图中顶点表示区域内的重要场所，有向边表示已有的
公交线路，边上的权表示票价，要求：
1）用邻接矩阵作为图的存储结构；
2）能计算输入起点到所有其他顶点的最短路径及票价。
上面是题目,斑竹可以给个构思我吗?不知从何做起!所谓的有向边是单向的还是双向的?

你可以把无向边表示已有的线路
然后，没有的线路让他的权==0或者==MaxSize+1;
因为交通没有单向吧？？
到时候判断就可以了
首先建立一个图类
里面包括
节点类和边类
然后用K什么的算法或prim找最短路径

这个我做过，不明白的拿上来问
看看大家能不能帮忙

好思路,谢谢斑竹啦,不明再问吧.

求救：：：：
#define maxvex 100
#define max 32767
struct vertex
{int num;
char data;
}vertex;
typedef struct adjmax
{struct vertex vexs[maxvex];
int edges[maxvex][maxvex];
}adjmax;

adjmax creategraph(int n,int e)
{int i,j,k,w;
char b,t;
adjmax adj;
for(i=0;i<n;i++)
{printf("\tthe %d vertex's massege is:",i);
scanf("%c",&adj.vexs[i].data);
adj.vexs[i].num=i;
}
for(i=0;i<n;j++)
for(j=0;j<n;j++)
adj.edges[i][j]=0;
for(k=0;k<e;k++)
{
printf("input the %d edge's jumping-off point, the end-point and the dist",k);
scanf("%c,%c,%d",&b,&t,&w);
i=0;
while(i<n && adj.vexs[i].data!=t) i++;
if(i>=n)
{printf("input the jumping-off point is inexistent.\n");
exit(0);
}
j=0;
while(j<n && adj.vexs[j].data!=t) j++;
if(j>=n)
{printf("input the end point is inexistent.\n");
exit(1);
}
adj.edges[i][j]=w;
}return(adj);
}

void shortpath(cost,dist,path,n,v0)
int cost[maxvex][maxvex],dist[maxvex],path[maxvex],n,v0;
{int s[maxvex],u,vnum,w,wm;
for(w=1;w<n;w++)
{dist[w]=cost[v0][w];
if(cost[v0][w]<max)path[w]=v0;
}
for(w=1;w<=n;w++) s[w]=0;
s[v0]=1;
vnum=1;
while(vnum<n-1)
{wm=max;
u=v0;
for(w=1;w<=n;w++)
if(s[w]==0 && dist[w]<wm)
{u=w;wm=dist[w];
}
s[u]=1;vnum++;
for(w=1;w<=n;w++)
if(s[w]==0 && dist[u]+cost[u][w]<dist[w])
{dist[w]=dist[u]+cost[u][w];
path[w]=u;}
}
}

void printpath(dist,path,s,n,v0)
int dist[maxvex],path[maxvex],s[maxvex],n,v0;
{int i,k;
for(i=1;i<=n;i++)
if(s[i]==1)
{k=i;
while(k!=v0)
{printf("%d←",k);
k=path[k];
}
printf("%d",k);
printf("%d",dist[i]);
}
else
{printf("%d←%d",i,v0);
printf("∞");
}
}
main()
{adjmax g;
int n,e,v0;
int dist[maxvex],path[maxvex],s[maxvex];
printf("input the No. of vertex(n) and the No. of edges(e):");
scanf("%d,%d",&n,&e);
g=creategraph(n,e);
printf("input the headspring is: ");
scanf("%d",&v0);
shortpath(g.edges[][],dist[],path[],g.vexs[],v0);
printpath(g.edges[][],path[],s[],g.vexs[],v0);
}
我的程序是这样的，但是后两行错误啊，可以帮我看看吗？

#include<stdio.h>
#include<malloc.h>

#define MAX 5 //最大顶点数
#define Max_Edge 7//最大边数目

typedef char* vextype; //顶点类型
typedef float edgetype; //边类型

typedef struct{
vextype vexs[MAX]; //顶点数组
edgetype edges[Max_Edge][Max_Edge]; //邻接矩阵
int v,e;//当前的边数，顶点数目
float prices[MAX];//到没个顶点的票价
int path[MAX];//在最短路径中，到达该顶点前的顶点号
}Graph;

void init(Graph* g){//初始化图
int count = 0;
//初始化顶点
while(count < MAX){
printf("input vex :<eg:hotal>\n");
g->vexs[count] = (char*)malloc(50 * sizeof(char));//给顶点count分配50个字符的长度
scanf("%s",g->vexs[count]);// 存储顶点信息
printf("站点: %s \n", g->vexs[count]);
count++;
g->v++;
}
count = 0;//将计数器重新置为0
//初始化边
for(int i = 0; i < Max_Edge; i++){
for(int j = 0; j < Max_Edge; j++){
g->edges[i][j] = 0;
}
}
while(count < Max_Edge){
int i,j;
float w;
printf("input edges and its weight :<eg: 1, 2, 5.0>\n");
scanf("%d, %d, %f" , &i, &j, &w);
g->edges[i][j] = w;//使用权重表示i ->j的票价
printf("%d -> %d 票价 %f\n",i,j,g->edges[i][j]);
count++;
}
}

/*
* 根据初始点位置，寻找到其他所有结点的最短路径，以及票价
* 由于票价没有负数，采用Dijstra算法
*/

//函数声明
int getMin(float prices[MAX],int* s);
bool isFull(int s[MAX]);

void search(Graph* g, int i){
int s[MAX] = {0,0,0,0,0}; //记录目前到达源点距离最小顶点集合
int flag = i;//初始化为i
s[i] = 1;//将源结点添加到集合中
//初始化到各个顶点的票价
for(int k = 0; k < MAX; k++){
if(k == i)
g->prices[k] = 0;
else
g->prices[k] = 10000;//表示无穷大
}
while(!isFull(s)){
for(int j = 0; j < MAX; j++){
if(s[j] == 1)//不计算在s集合中的结点
continue;
if(g->edges[flag][j] > 1){//j与flag相邻
if(((float)g->edges[flag][j] + g->prices[flag]) < g->prices[j]){
g->prices[j] = g->edges[flag][j] + g->prices[flag];//更新prices
g->path[j] = flag;
printf("g->prices[j] %f\n",g->prices[j]);
}
}
}
flag = getMin(g->prices,s);//返回在i步长里面，和源节点距离最小的顶点编号
s[flag] = 1;//记录该结点号
}
}

//冒泡求出最小的票价数
int getMin(float* prices,int* s){
int flag = 0;
for(int i = 0; i < MAX; i++){
if((prices[flag] == 0) || (s[flag] == 1)){
flag++;
continue;
}
else if((prices[i] !=0) && (s[i] != 1)){
if(prices[flag] < prices[i])
continue;
else
flag = i;
}
}
return flag;
}

//判断是否记录结点集合s是否满
bool isFull(int s[MAX]){
bool flag = 0;
int count = 0;
for(int i = 0; i < MAX; i++){
if(s[i] == 1)
count++;
if(count == MAX)
flag = 1;
}
return flag;
}

//获取最短路径
void getPath(int or,int start,Graph g){//此处可以采用一个栈来处理方法问题
int cstart = start;
printf("路径：");
while(1){
if(cstart == or){
printf("%s ",g.vexs[cstart]);
break;
}else{
printf("%s <- ",g.vexs[cstart]);
cstart = g.path[cstart];
}
}
}

void main(){
Graph g;
printf("-------------init()------------------\n");
init(&g);
search(&g,0);
printf("-----------------result---------------\n");
for(int l = 0; l < MAX; l++){
printf("顶点 %s 到达顶点 %s 的最少花费是%f ：\n", g.vexs[0], g.vexs[l], g.prices[l]);
printf("\n");
}
for(int k = 0; k < MAX; k++){
printf("顶点 %s 到达顶点 %s 的", g.vexs[0], g.vexs[k]);
getPath(0,k,g);
printf("\n");
}

}

程序没有进行压力测试，仅仅供参考！！

恩恩,好的,谢谢啦,剩下的交给我吧,