实验4.2：用迪杰斯特拉算法求赋权图中的最短路径（可记录输出路径）

PE了很长时间，然后发现是栈没有初始化的缘故.......。代码中附加了另外一组测试用例

输出路径的思路就是压栈出栈。

Description

用迪杰斯特拉算法求一点到其余所有结点的最短路径。

Input

先输入一个小于100的正整数n,然后输入图的邻接矩阵（10000表示无穷大，即两点之间没有边），最后输入两个0到n-1的整数表示两个点。

Output

先用迪杰斯特拉算法求给定的第一个点到其余所有结点的最短路径。

然后在输出给定的两个点之间的最短路径（按顺序输出最短路径上的每一个点，每个数据占一行）。

Sample Input

4

0 2 10 10000

2 0 7 3

10 7 0 6

10000 3 6 0

0 2

Sample Output

0 

1

2

/*
6
0 10 10000 30 10000 10000
10000 0 50 10000 100 10000
10000 10000 0 10000 5 10000
10000 10000 20 0 60 10000
10000 10000 10000 10000 0 10
10000 10000 10000 10000 10000 0
*/
#include <stdio.h>
#include<stdlib.h>
typedef struct {
    int vexs[100];
    int arcs[100][100];
    int vexnum,arcnum;
}MGraph;
typedef struct{
    int elem[100];
    int top;
}stack;
void chushi(stack*s)
{
    s->top=-1;
}
int push(stack*s,int x)
{
    s->top++;
    s->elem[s->top]=x;
    return 1;
}
int pop(stack*s)
{
    if(s->top==-1)
    return 0;
    else{
        s->top--;
        return 1;
    }
}
int gettop(stack*s)
{
    if(s->top==-1)
        return 0;
    else{return s->elem[s->top];}
}
int isempty(stack*s)
{
    if(s->top==-1)return 1;
    else return 0;
}
typedef int sumlength[100];
typedef int path[100];
void creat(MGraph *G)
{   int i,j;
    scanf("%d",&(G->vexnum));
    for (i=0; i<G->vexnum; i++)
        {
        G->vexs[i]=i;
        }
    for ( i=0;i<G->vexnum;i++)
    {
     for(j=0;j<G->vexnum;j++)
        {
        scanf("%d",&G->arcs[i][j]);
        }
    }
}
void zuiduanlu(MGraph G,int v0,path*p,sumlength *D)
{
    int final[100];
    int i,v;
    for (v=0; v<G.vexnum;v++)
    {
        final[v]=0;
        (*D)[v]=G.arcs[v0][v];
        if((*D)[v]==10000)
        (*p)[v]=0;
        else(*p)[v]=v0;
    }
    (*D)[v0]=0;
    final[v0]=1;
    int k;
    int w;
    for(i=1;i<G.vexnum;i++)
    {
        int min=10000;
        for (w=0; w<G.vexnum; w++)
        {
            if (!final[w])
            {
                if ((*D)[w]<min)
                {
                    k=w;
                    min=(*D)[w];

                }
            }
        }
        final[k]=1;
        for ( w=0; w<G.vexnum;w++)
        {
            if (!final[w]&&(min+G.arcs[k][w]<(*D)[w]))
            {
                (*D)[w]=min+G.arcs[k][w];
                (*p)[w]=k;
            }
        }
    }
}
int main()
{
    MGraph G;
    path p;
    sumlength D;
    stack s;
    chushi(&s);
    int start,end;
    creat(&G);
    scanf("%d %d",&start,&end);
    zuiduanlu(G,start,&p,&D);
    while(end!=start)
    {
        push(&s,end);
        end=p[end];
    }
    push(&s,end);
    while(!isempty(&s))
    {
        printf("%d\n",gettop(&s));
        pop(&s);
    }
    return 0;
}