Description

编写程序，实现以邻接表作存储结构，求从源点到其余各顶点的最短路径的Dijkstra算法。

Input

第一行输入顶点数n和边数m；第二行输入顶点信息；分m行输入m对顶点vi，vj（表示由顶点vi到顶点vj（i不等于j）的边）以及该弧的权值。(0<m,n<100)

Output

输出从源点到其余各顶点的最短路径（不可达用-1表示）。

• Sample Input 

  6 11
  1 2 50
  1 3 10
  1 5 45
  2 3 15
  2 5 10
  3 1 20
  3 4 15
  4 2 20
  4 5 35
  5 4 30
  6 4 3 

• Sample Output

  1 3 10
  1 4 25
  1 2 45
  1 5 45
  1 6 -1

#include <stdio.h>
#include <stdlib.h>
#define INF 10000

typedef struct
{
    int vexs[100];
    int arcs[100][100];
    int vexnum,arcnum;
}ALGraph;

int Getinfo(ALGraph &G,int j)
{
    int i=0;
    for (i=0;i<G.vexnum; i++)
    {
        if (G.vexs[i]==j)
        {
            return i;
        }
    }
    return -1;
}
void create(ALGraph &G, int vex, int arc)
{   int i,j;
    G.vexnum = vex;
    G.arcnum = arc;
    for (i = 0; i < G.vexnum; i++)
    {
        G.vexs[i] = i + 1;
    }
    for(i=0; i<G.vexnum; i++)
    {
        for(j=0; j<G.vexnum; j++)
        {
            G.arcs[i][j] = INF;
        }
    }
    for(i = 0;i < G.arcnum;i++)
    {
        int v1,v2,w;
        scanf("%d %d %d",&v1,&v2,&w);
        int m=Getinfo(G, v1);
        int n=Getinfo(G, v2);
        G.arcs[m][n]=w;
    }
}
void Dijkstra(ALGraph &G,int v0,int *dist)
{
    int visited[100];
    int i,j;
    for(i=0; i<G.vexnum; i++)
    {
        visited[i]=0;
        dist[i]=G.arcs[v0][i];
    }
    dist[v0]=0;
    visited[v0]=1;
    int k;
    for(i=1;i<G.vexnum;i++)
    {
        int mindist = INF;
        for(j=0; j<G.vexnum; j++)
        {
            if(!visited[j])
            {
                if(dist[j]<mindist)
                {
                    k = j;
                    mindist = dist[j];
                }
            }
        }
        visited[k]=1;
        for(j=0; j<G.vexnum; j++)
        {
            if (!visited[j]&&(mindist+G.arcs[k][j]<dist[j]))
            {
                dist[j]=mindist+G.arcs[k][j];

            }
        }
    }
}

void BubbleSort(ALGraph &G, int *dist)
{
    int i,j,temp;
    for(i=1; i<G.vexnum; i++)
    {
      for(j=1;j<G.vexnum-i;j++)
      {
          if(dist[j]>dist[j+1])
          {
              temp=dist[j];
              dist[j]=dist[j+1];
              dist[j+1]=temp;
              temp=G.vexs[j];
              G.vexs[j]=G.vexs[j+1];
              G.vexs[j+1]=temp;
          }
      }
    }
}

void print(ALGraph &G,int *dist)
{
    int i,j;
    for(i=1; i<G.vexnum; i++)
    {
        if(dist[i]!=INF)
        {
            printf("%d %d %d \n",G.vexs[0],G.vexs[i],dist[i]);
        }
        else
        {
            printf("%d %d -1 \n",G.vexs[0],G.vexs[i]);
        }
    }
}
int main()
{
    ALGraph G;
    int dist[100];
    int i,j;
    int vex,arc;
    scanf("%d %d",&vex,&arc);
    create(G,vex,arc);
    Dijkstra(G, 0, dist);
    BubbleSort(G,dist);
    print(G,dist);
    return 0;
}

要求用邻接表……然而我死活调不出来……就投机用了这个QAQ