收藏自大佬的文章,和白书上的写法。
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<V;u++){
if(!used[u]&&(v==-1||d[u]<d[v])) v=u;
}
if(v==-1) break;
used[v]=true;
for(int u=0;u<V;u++){
d[u]=min(d[u],d[v]+cost[v][u]);
}
}
}
priority_queue实现:
struct edge{int to,cost;};
typedef pair<int,int> P; //first是最短距离,second是顶点的编号
int V;
vector<edge> G[max_v];
int d[max_v];
void dijkstra (int s)
{
//通过指定great<P> 参数,堆按照first从小到大的顺序取出值
priority_queue<P,vector<P>,greater<P> > 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]<x.first) continue;
for(int i=0;i<G[v].size();i++){
edge e=G[v][i];
if(d[e.to]>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<V;k++){
for(int i=0;i<V;i++){
for(int j=0;j<V;j++){
d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}
}
}
}