最短路模板

Dijkstra算法（邻接矩阵版本）

#include <queue>
#include <utility>//pair的头文件
using namespace std;

const int inf=0x3fffffff;
typedef pair<int,int> pii;//第一维为dis值，第二维为对应的结点编号

void Dijkstra(int st){//用于计算正权图上的单源最短路，st为起点
    int i,x;
	pii t;
	priority_queue<pii,vector<pii>,greater<pii> > q;
    for(i=1;i<=n;i++)//dis[i]表示起点到点i的距离,n为点的个数，初始化为大数
        dis[i]=inf;
    dis[st]=0;//起点到自己的距离为0
	q.push(make_pair(dis[st],st));//起点入队
	while(!q.empty()){
		t=q.top();
		q.pop();
		x=t.second;
		if(t.first!=dis[x])//已经算过，则忽略
			continue;
		for(i=1;i<=n;i++){
			if(dis[i]>dis[x]+w[x][i]){//w[x][i]是邻接矩阵，需要初始化什么的
				dis[i]=dis[x]+w[x][i];
				//p[i]=x;记录路径
				q.push(make_pair(dis[i],i));//将新的dis值入队
			}
		}
	}
}

Dijkstra算法（邻接表版本）

#include <vector>
#include <queue>
#include <utility>
using namespace std;

const int inf=0x3fffffff;
typedef pair<int,int> Edge;//表示边，第一维是边的权值，第二维是邻接点的编号
vector<Edge> AdList[MAXN];//用vector实现邻接表
//AdList[i].clear();AdList[i].push_back(t);AdList[i].size();vector的基本操作

void Dijkstra(int src){
    int i,x,temp;
    Edge t;
    priority_queue<Edge,vector<Edge>,greater<Edge> > q;
    for(i=1;i<=n;i++)
        dis[i]=inf;
    dis[src]=0;
    q.push(make_pair(dis[src],src));
    while(!q.empty()){
        t=q.top();
        q.pop();
        x=t.second;
        if(t.first!=dis[x])
            continue;
		temp=AdList[x].size();//邻接点的个数
        for(i=0;i<temp;i++){
            if(dis[AdList[x][i].second]>dis[x]+AdList[x][i].first){
                dis[AdList[x][i].second]=dis[x]+AdList[x][i].first;
				//p[AdList[x][i].second]=x;记录路径
                q.push(make_pair(dis[AdList[x][i].second],AdList[x][i].second));
            }
        }
    }
}

SPFA算法（邻接矩阵版本）

#include <queue>
using namespace std;

const int inf=0x3fffffff;

void SPFA(int st){//不存在负回路时求存在负权边的最短路径，st为起点
    int i,x;
    memset(vis,0,sizeof(vis));//所有点都没有优化过
    for(i=1;i<=n;i++)//数组dis记录n个结点的最短路径估计值,初始化为大数
        dis[i]=inf;
	dis[st]=0;//起点的最短路径值为0
	queue<int> q;//队列保存待优化的结点
    q.push(st);//起点入队
    while(!q.empty()){
        x=q.front();
        q.pop();
        vis[x]=0;
        for(i=1;i<=n;i++){
            if (dis[i]>dis[x]+w[x][i]){//w是邻接矩阵，需要初始化
                dis[i]=dis[x]+w[x][i];
                //p[i]=x;记录路径
                if(!vis[i]){
                    vis[i]=1;
                    q.push(i);//修改过的结点入队
                }
            }
        }
    }
}

SPFA算法（邻接表版本）

#include <vector>
#include <queue>
#include <utility>
using namespace std;

const int inf=0x3fffffff;
typedef pair<int,int> Edge;//表示边，第一维是边的权值，第二维是邻接点的编号
vector<Edge> AdList[MAXN];//用vector实现邻接表
//AdList[i].clear();AdList[i].push_back(t);AdList[i].size();vector的基本操作

void SPFA(int src){//不存在负回路时求存在负权边的最短路径，st为起点
    int i,x,t;
    memset(vis,0,sizeof(vis));//所有点都没有优化过
    for(i=1;i<=N;i++)//数组dis记录n个结点的最短路径估计值,初始化为大数
        dis[i]=inf;
	dis[src]=0;//起点的最短路径值为0
	queue<int> q;//队列保存待优化的结点的编号
    q.push(src);//起点入队
    while(!q.empty()){
        x=q.front();
        q.pop();
        vis[x]=0;
		t=AdList[x].size();
        for(i=0;i<t;i++){
            if (dis[AdList[x][i].second]>dis[x]+AdList[x][i].first){
                dis[AdList[x][i].second]=dis[x]+AdList[x][i].first;
                //p[AdList[x][i].second]=x;记录路径
                if(!vis[AdList[x][i].second]){
                    vis[AdList[x][i].second]=1;
                    q.push(AdList[x][i].second);//修改过的结点入队
                }
            }
        }
    }
}

Floyd算法

void Floyd(){
	//计算每对顶点间的最短路径，允许存在权值为负的边，但不能有权值为负的回路
	//dis[i][j]表示从顶点i到顶点j的最短路径
	//调用之前要初始化，dis[i][i]=0，其它dis值为一个大数，但不能太大
	//然后再输入题目给的一些dis值
	//n为点数
	int i,j,k;
	for(k=1;k<=n;k++){
		for(i=1;i<=n;i++){
			for(j=1;j<=n;j++){
				if(dis[i][j]>dis[i][k]+dis[k][j])
					dis[i][j]=dis[i][k]+dis[k][j];
			}
		}
	}
}