最短路（Bellman队列优化）

#include<iostream>
#include<queue>
#include<cstdio>
#define dif 9999
using namespace std;
queue<int> q;
struct haha{
    int u;
    int v;
    int w;
}e[100];
int book[100],dis[100];//分别用来标记顶点是否入队和源点到每个点的距离
int next[100],first[100];//这两个数组用来存储边的访问顺序。
//first意思是起点，next意思以该点为起点的下一条边。
//next中存的是边的序号，索引是边的序号；first中存的也是边的顺序，索引是点的序号。
//如果一个顶点一条出边，那first中会有m个值，next中全是-1,
//如果某个顶点有多个出边，first中的非-1与next中非-1加起来是m，这两个动态互补。
//first存的是边的访问顺序
//next存的是两条起点相同的的边的访问顺序
int main(){
    //邻接表读入图
    int n,m;
    int i,j,w;
    cin >> n >> m;
    for(i=1;i<=m;i++)
        first[i]=-1;
    for(i=1;i<=n;i++)
        dis[i]=dif;
    for(i=1;i<=m;i++){
        cin >> e[i].u >> e[i].v >> e[i].w;
        next[i]=first[e[i].u];//如果此刻的第i个边的起点是第一次读入，那第i个next值为-1
        //如果是第二次读到，那这个点第一次的first已经存了那个边的序号，意思是访问完这个边，回到next值的那个边
        first[e[i].u]=i;//如果是新的起点，值的序号是新的
        //若是旧的起点，那更新这个起点的边的序号。
    }
    //用队列依次松弛
    book[1]=1; q.push(1); dis[1]=0;
    int k;
    while(!q.empty()){
        k=first[q.front()];
        while(k!=-1){
            if(dis[e[k].v]>dis[e[k].u]+e[k].w){
                dis[e[k].v]=dis[e[k].u]+e[k].w;
                if(book[e[k].v]==0){
                    q.push(e[k].v);
                    book[e[k].v]=1;
                }
            }
            k=next[k];
        }
        book[q.front()]=0;
        q.pop();
    }
    for(i=1;i<=n;i++)
        printf("%5d",dis[i]);
    return 0;
}
/*
5 7
1 2 2
1 5 10
2 3 3
2 5 7
3 4 4
4 5 5
5 3 6
*/