队列优化并使用邻接表存储的Bellman-Ford算法模板解决最短路径存在负权边问题

#include<stdio.h>
int main()
{
    int n,m,i,j,k;
    int u[8],v[8],w[8];
    int first[6],next[8];
    int dis[6]={0},book[6]={0};
    int que[101]={0},head=1,tail=1;
    int inf=99999999;

    scanf("%d%d",&n,&m);//n表示顶点个数，m表示边的条数 
    //初始化dis数组，这里是1号顶点到其余各个顶点的初始路程 
    for(i=1;i<=n;i++)
        dis[i]=inf;
    dis[1]=0;

    for(i=1;i<=n;i++)
        book[i]=0;//初始都不在队列中 

    for(i=1;i<=n;i++)
        first[i]=-1;//初始每个顶点都没有边 
    //建立邻接表 
    for(i=1;i<=m;i++)
    {
        scanf("%d%d%d",&u[i],&v[i],&w[i]);
        next[i]=first[u[i]];
        first[u[i]]=i;
    }

    que[tail]=1;//1号顶点入队 
    tail++;
    book[1]=1;//标记1号顶点入队 
    while(head<tail)
    {
        k=first[que[head]];//当前需要处理的队首顶点 
        while(k!=-1)//扫描当前顶点所有的边 
        {
            if(dis[v[k]]>dis[u[k]]+w[k])//判断是否松弛成功 
            {
                dis[v[k]]=dis[u[k]]+w[k];//更新顶点1到顶点v[k]的路程 
                if(book[v[k]]==0)//v[k]不在队列中 
                {
                    que[tail]=v[k];//将v[k]加入队列 
                    tail++;
                    book[v[k]]=1;//标记v[k]已经入队 
                }
            }
            k=next[k];//遍历邻接表 
        }
        book[que[head]]=0;//出队 
        head++;
    }
    for(i=1;i<=n;i++)//输出1号顶点到其余各个顶点的最短路径 
        printf("%d ",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
result:0 2 5 9 9
*/