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];
}
}
}
}