Dijkstra算法（严7.42）

最新推荐文章于 2025-10-29 23:51:47 发布

原创最新推荐文章于 2025-10-29 23:51:47 发布 · 1.6k 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#noj #数据结构

数据结构专栏收录该内容

50 篇文章

订阅专栏

本文介绍了一个基于邻接矩阵实现的Dijkstra算法程序，用于寻找图中从指定源点到其他各顶点的最短路径。程序首先读取图的顶点数量和边的数量，然后接收具体的顶点信息及边的权重，最后输出从源点到各顶点的最短路径。

Description

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

Input

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

Output

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

Sample Input

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