单源最短路径算法模板（Dijkstra+BellmanFrod）

//最短路径算法模板
//前面两个结构体共用
#include<queue>
#include<vector>
#include<cstring>
#define maxn 99  //按最大节点数宏定义
#define INF 0xfffffff
using namespace std;
struct Edge  //节点结构体
{
int from;  //起始点
int to;   //终止点
int dist;   //起始点到终止点的距离
};
struct HeapNode  //队列节点结构体，用于入队
{
int d;   //该点到汇点的距离
int u;    //该点
bool operator <(const HeapNode& rhs) const
{
return d>rhs.d;   //优先队列，距离优先，距离值小的点在队头
}
};
/*Dijkstra算法求最短路径
时间复杂度：O(ElogE)
步骤：
1、初始化距离数组
2、设置所有点为未访问过
3、找出所有未访问过得点中距离最小的点，标记其为访问过
4、对操作（3）中所找到的点的相邻的边进行松弛
5、重复操作（3）和（4）直到所有点都访问过
*/
/*算法特点：
用于计算边权均为正的图的单源最短路径，若存在权为负的节点，则无法求解
*/
struct Dijkstra
{
int n,m;
vector<Edge> edges;  //点数和边数
vector<int> G[maxn];  //边列表，i边可连通到边G[i][j];
bool done[maxn];  //是否已永久标记
int d[maxn];   //s汇点到各点的距离
int p[maxn];   //最短路中的一条弧
void init(int n)   //析构函数，用完后“初始化”，便于下次使用
{
this->n=n;
for(int i=0;i<n;i++)G[i].clear();
edges.clear();
}
void AddEdge(int from,int to,int dist)  //构造函数，将值初“始化”为输入情况
{
edges.push_back((Edge){from,to,dist});
m=edges.size();
G[from].push_back(m-1);
}
void dijkstra(int s)//最短路径算法
{
priority_queue<HeapNode> Q;
for(int i=0;i<n;i++)d[i]=INF;//所有点到汇点的距离初始化为最大值
d[s]=0; //自身到自身的距离为0；
memset(done,0,sizeof(done)); //未处理任何定点，所有标记初始化为0
Q.push((HeapNode){0,s});
while(!Q.empty())
{
HeapNode x=Q.top();
Q.pop();
int u=x.u;
if(done[u])continue;
done[u]=true;
for(int i=0;i<G[u].size();i++)
{
Edge& e=edges[G[u][i]];
if(d[e.to]>d[u]+e.dist)
{
d[e.to]=d[u]+e.dist;
p[e.to]=G[u][i];
Q.push((HeapNode){d[e.to],e.to});
}
}
}
}
};
/*BellmanFrod算法求最短路径
时间复杂度：O（kE）
步骤：
1、初始化d数组，ds=0，di=INF
2、枚举每一条边，进行松弛操作
3、将操作（2）重复执行|v|-1次
4、枚举每一条边，看是否还能进行松弛操作，若能，说明原图存在负权环
*/
/*算法特点：
可用于计算存在权为负的边的图中的单源最短路径（当最短路径存在时）
*/
struct BellmanFrod
{
int n;
int m;
vector<Edge> edges;
vector<int>G[maxn];
bool inp[maxn];//点是否在队列中
double d[maxn];//s到各点的距离
int p[maxn]; //最短路上的一条弧
int cnt[maxn]; //进队次数
//如果某节点进队n次，可以判断存在负圈
void init(int n)
{
this->n=n;
for(int i=0;i<n;i++)G[i].clear();
edges.clear();
}
void AddEdge(int from,int to,double dist)
{
edges.push_back((Edge){from,to,dist});
m=edges.size();
G[from].push_back(m-1);
}
bool negtiveCycle()
{
queue<int> Q;
memset(inp,0,sizeof(inp));
memset(cnt,0,sizeof(cnt));
for(int i=0;i<n;i++)
{
d[i]=0;
inp[0]=true;
Q.push(i);
}
while(!Q.empty())
{
int u=Q.front();
Q.pop();
inp[u]=false;
for(int i=0;i<G[u].size();i++)
{
Edge& e=edges[G[u][i]];
if(d[e.to]>d[u]+e.dist)
{
d[e.to]=d[u]+e.dist;
p[e.to]=G[u][i];
if(!inp[e.to])
{
Q.push(e.to);
inp[e.to]=true;
if(++cnt[e.to]>n)return true;
}
}
}
}
return false;
}
};