最短路板子

Dijkstra算法（无负环）

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
typedef pair<int,int> P;//定义P为pair型
const int Max=1005;
const int inf=0x3f3f3f3f;
vector<P> e[Max];//e[]存图的容器
int dis[Max];//起始点到各个点的距离
void dij(int s,int n)
{
    memset(dis,inf,sizeof(dis));//初始化
    priority_queue<P,vector<P>,greater<P> > que;//优先队列
    dis[s]=0;//把起始点距离设置为0
    que.push(make_pair(0,s));//把一个pair型压入队列，pair型第一个为起点到此点距离，第二个为这个点的编号
    int mu;
    while(!que.empty())
    {
        P p=que.top();//定义一个同P型的p来接受队列里的数据
        que.pop();//弹出数据
        if(dis[p.second]<p.first) continue;
        mu=p.second;
        for(int i=0;i<e[mu].size();i++)//遍历e[mu]所连接的所有点
        {
           P& edge=e[mu][i];//构造一个和P相同类型的edge，并赋值
           if(dis[edge.first]>dis[mu]+edge.second)/*如果此时起点到点e[mu][i]的距离
           大于(此时想走的点mu的距离dis[mu]+点e[mu][i]到mu的距离edge,second)那么更新距离*/
           {
               dis[edge.first]=dis[mu]+edge.second;//更新距离
               que.push(make_pair(dis[edge.first],edge.first));
           }
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        e[u].push_back(make_pair(v,w));//这里路是双向的
        e[v].push_back(make_pair(u,w));
    }
    dij(1,n);//起点是1，总共有n个点；
}

 

spfa

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxn=1000005;
const int maxm=1000005;
struct node
{
    int v,w,next;
} edge[maxm];//存图
int edgehead[maxm];
int dis[maxn];//
int vis[maxn];//标记此点是否走过
int k,n,m;
int start=1;//起点
void addedge(int u,int v,int w)//链式前向星存图
{
    edge[k].v=v;
    edge[k].w=w;
    edge[k].next=edgehead[u];//对前驱结点的索引
    edgehead[u]=k++;
}
void init()//初始化
{
    memset(edge,0,sizeof(edge));
    memset(edgehead,0,sizeof(edgehead));
    memset(dis,inf,sizeof(dis));
    memset(vis,0,sizeof(vis));
    dis[start]=0;
    k=1;
}
void spfa()
{
    queue<int>que;
    vis[start]=1;//标记起点走过
    que.push(start);
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        vis[u]=0;
        for(int i=edgehead[u]; i; i=edge[i].next)//遍历与u点相连接的所有点
        {
            int v=edge[i].v;
            int w=edge[i].w;
            if(dis[v]>dis[u]+w)//如果到起点v时候的距离大于(起点到u的距离dis[u]+u与之间的距离w)进行更新
            {
                dis[v]=dis[u]+w;
                if(!vis[v])
                {
                    //vis数组不做访问条件，仅仅是判断入队的条件
                    que.push(v);
                    vis[v]=1;
                }
            }
        }
    }
}
int main()
{
    init();
    addedge(u,v,w);
}