最短路算法模板(只有代码)

收藏自大佬的文章，和白书上的写法。

Dijkstra 算法：

int cost[max_v][max_v]; //cost[u][v]表示边e=(u,v)的权值(不存在这条边时设为INF)
int d[max_v]; //顶点s出发的最短路距离
bool used[max_v]; //已经使用过的图
int V; //顶点数

//求从起点出发到各个顶点的最短距离
void dijkstra (int s)
{
    fill(d,d+V,INF);
    fill(used,used+V,false);
    d[s]=0;
    while(true){
        int v=-1;
        for(int u=0;u

priority_queue实现：

struct edge{int to,cost;};
typedef pair P; //first是最短距离，second是顶点的编号
int V;
vector G[max_v];
int d[max_v];

void dijkstra (int s)
{
    //通过指定great
 参数，堆按照first从小到大的顺序取出值
    priority_queue,greater
 > que;
    fill(d,d+V,INF);
    d[s]=0;
    que.push(p(0,s));
    while(!que.empty()){
        P x=que.top(); que.pop();
        int v=x.second;
        if(d[v]d[v]+e.cost){
                d[e.to]=d[v]+e.cost;
                que.push(P(d[e.to],e.to));
            }
        }
    }
}

Bellmen_Ford算法：

const int maxnum=100;   //最大边数
const int maxint=9999;  //源点和某点不可达时的距离
 
//有向边的结构体
typedef struct Edge
{
    int Start; //有向边边的起始点
    int End;   //有向边的终点
    int Weight;//边的权重
}Edge;
 
Edge edge[maxnum];//有向边的数组
int dist[maxnum]; //距离数组
 
//节点的数目、边的数目、源节点的下标
int nodenum,edgenum,source;
 
//初始化函数
void Init()
{
    cin>>nodenum>>edgenum>>source;
 
    for(int i=1;i<=nodenum;i++)
        dist[i]=maxint;
 
    dist[source]=0;
 
    for(int i=1;i<=edgenum;i++)
    {
        cin >> edge[i].Start >> edge[i].End >> edge[i].Weight;
        if(source==edge[i].Start)
        {
            dist[edge[i].End]=edge[i].Weight;
        }
    }
}
 
//松弛函数
void Relax(int Start,int End,int Weight)
{
    if(dist[End]>dist[Start]+Weight)
        dist[End]=dist[Start]+Weight;
}
 
//贝尔曼福特函数
bool Bellman_Ford()
{
    for(int i=1;i<=nodenum-1;i++)
    {
        for(int j=1;j<=edgenum;j++)
        {
            Relax(edge[j].Start,edge[j].End,edge[j].Weight);
        }
    }
    bool flag=1;
    for(int i=1;i<=edgenum;i++)
    {
        //判断是否存在负回路
        if(dist[edge[i].End]>dist[edge[i].Start]+edge[i].Weight)
        {
            flag=0;
            break;
        }
    }
    return flag;
}

Floyd-Warshall算法：

int d[max_v][max_v]; //d[u][v]表示边e=(u,v)的权值(不存在时设为INF,不过d[i][i]=0)
int V; //顶点数

void warshall_floyd(){
    for(int k=0;k