单源最短路径（贪心算法）

【问题描述】Dijkstra算法解决的是带权重的有向图上单源最短路径问题。所有边的权重都为非负值。设置顶点集合S并不断地作贪心选择来扩充这个集合。使用最小堆数据结构构造优先队列。第1个顶点为源。

【输入形式】在屏幕上输入顶点个数和连接顶点间的边的权矩阵。

【输出形式】从源到各个顶点的最短距离及路径。

【样例输入】

5

0 10 0 30 100

0 0 50 0 0

0 0 0 0 10

0 0 20 0 60

0 0 0 0 0

【样例输出】

10: 1->2

50: 1->4->3

30: 1->4

60: 1->4->3->5

【样例说明】

 输入：顶点个数为5。连接顶点间边的权矩阵大小为5行5列，位置[i,j]上元素值表示第i个顶点到第j个顶点的距离，0表示两个顶点间没有边连接。

 输出：每行表示源1到其余各顶点的最短距离及路径，冒号后有一空格。如果源1到该顶点没有路，则输出："inf: 1->u"，其中u为该顶点编号。

【评分标准】根据输入得到准确的输出。

代码实现：

#include <bits/stdc++.h>
using namespace std;
const int inf=1000000;//无穷大
int n,g[200][200],dis[200],pre[200],visit[200];

struct edge
{
    int u,v,d;//边的起点、终点、权值
    bool operator < (const edge &a) const
    {
        return d>a.d;
    }
};

 void dijkstra(int n)
 {
     
    priority_queue<edge> q;//优先队列
    int a=1,b=0;//a:顶点  b:边数
    for(int i=1;i<=n;i++)
    {
        if(i!=a)
        {
            pre[i]=a;
            dis[i]=g[a][i];
            q.push({a,i,g[a][i]});
        }
    }//从结点a:1开始
    while(!q.empty())
    {
        edge t=q.top();
        q.pop();
        int v=t.v;
        if(visit[v]) continue;
        visit[v]=1;
        b++;
        if(b==n-1) break;
        a=v;
        for(int i=1;i<=n;i++)
        {
            if(!visit[i]&&dis[a]+g[a][i]<dis[i])
            {
                dis[i]=dis[a]+g[a][i];
                pre[i]=a;
                q.push({a,i,dis[a]+g[a][i]});
            }
        }
    }
    
    for(int i=2;i<=n;i++)
    {
        if(dis[i]==inf)
        {
            cout<<"inf: 1->"<<i<<endl;
            continue;
        }//没有路，输出："inf: 1->u"
        
        stack<int> s;
        int t=i;
        while(t!=0)
        {
            s.push(t);
            t=pre[t];
        }
        cout<<dis[i]<<": "<<s.top();
        s.pop();
        while(!s.empty())
        {
            cout<<"->"<<s.top();
            s.pop();
        }
        cout<<endl;
    }
     
 }

int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
    {
        cin>>g[i][j];
        if(g[i][j]==0)
            g[i][j]=inf;
    }
    }
    dijkstra(n);
    return 0;
}