单源最短路径算法模板（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;     } };