图论中的经典算法,分为:SSSP(单源最短路径)和APSP(所有点对之间的最短路径)。
SSSP是指在具有V个顶点,E条边的图G中,从某一顶点Vi出发,到其余任意一顶点Vj的最短路径。
常用算法为:Dijkstra算法,Bellman-Ford算法和SPFA算法。
Dijkstra算法:假设图为不带负权的有向图或无向图,利用贪心的策略,每次新扩展一个距离最短的点,再以这个为中间点,更新其他所有点的距离。感觉和最小生成树的Prim算法差不多,最小生成树的博文请点这里。记住:这个算法只适用于非负权值的有向图最优路径问题。
算法流程,假设s为源,map[u,v]为点u和v之间的边的权值,保存在Dist[]中。
开始初始化源的距离Dist[s]为0,其他的点距离设为无穷大,同时把所有的点的状态设为没有被访问过。然后循环n-1次:
在没有被访问过的点中取一距离最小的点u,并将其状态设为已被访问。然后对于每个与u相邻的点v,如果Dist[u]+map[u,v]<Dist[v],那么把Dist[v]更新成更短的距离Dist[u]+map[u,v]。此时到点v的最短路径上,前一个节点即为u。这个时候对于任意的u,dist[u]就是s到u的距离。
还是以例题讲解,见NYOJ 115(城市平乱),标准的Diskstra算法,模板见代码,我把那个最大值设为0x7fffffff错了好多次,总是会出现负数:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAX=1010;
const int Inf=100010;
#define min(a,b) a<b?a:b
#define CLR(arr,val) memset(arr,val,sizeof(arr))
int num,n,m,P,Q,force[MAX],visit[MAX],Dist[MAX],map[MAX][MAX];
void Dijkstra(int pos) //计算点S到其它顶点的最短路径,保存在Dist[]数组中
{ CLR(visit,0);
for(int i=1;i<=m;i++)
Dist[i]=map[pos][i];
Dist[pos]=0;
visit[pos]=1;
for(int i=1;i<m;i++)
{ int Min=Inf;
for(int j=1;j<=m;j++)
if(!visit[j]&&Min>Dist[j]) Min=Dist[pos=j];
visit[pos]=1;
for(int j=1;j<=m;j++)
if(!visit[j]) Dist[j]=min(Dist[j],Dist[pos]+map[pos][j]);//更新点pos到任意位置的最短距离,看直接到j,和通过pos到j的距离那个小
}
}
int main()
{ scanf("%d",&num);
while(num--)
{ for(int i=0;i<MAX;i++)
fill(map[i],map[i]+MAX,Inf);
scanf("%d%d%d%d",&n,&m,&P,&Q);
for(int i=1;i<=n;i++)
scanf("%d",&force[i]);
for(int i=1;i<=P;i++)
{ int u,v,w;
scanf("%d%d%d",&u,&v,&w);
map[u][v]=map[v][u]=w;
}
int Min=Inf;
Dijkstra(Q);
for(int i=1;i<=n;i++)
Min=min(Min,Dist[force[i]]);
printf("%d\n",Min);
}
return 0;
}
这个算法可以使用STL中的优先队列进行优化,具体见标准程序。
#include<iostream>
#include<climits>
#include<cstring>
#include<cstdio>
#include<vector>
#include<iterator>
#include<queue>
using namespace std;
const int MAX=1010;
int len[MAX];
bool visited[MAX];
int n,m,p,q,a,b,d;
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > dq;
struct Node
{
Node(int num,int dis):num(num),dis(dis){}
int num,dis;
};
void Dijkstra(vector<vector<Node> >& g) //优先队列实现Dijkstra
{
pair<int,int> tp;
while(!dq.empty())
{
tp=dq.top();dq.pop();
if(tp.second==q-1) return; //剪枝
if(tp.first!=len[tp.second]) continue;
visited[tp.second]=true;
for(int j=0;j!=g[tp.second].size();++j)
if(tp.first+g[tp.second][j].dis<len[g[tp.second][j].num])
{
len[g[tp.second][j].num]=tp.first+g[tp.second][j].dis;
dq.push(make_pair(len[g[tp.second][j].num],g[tp.second][j].num));
}
}
}
int main()
{
int t;
cin>>t;
while(t--)
{
while(!dq.empty()) dq.pop();
cin>>n>>m>>p>>q;
vector<vector<Node> > g(m);
for(int i=0;i!=g.size();i++) len[i]=INT_MAX;
for(int i=0;i!=n;i++)
{
cin>>a;
len[a-1]=0;
dq.push(make_pair(0,a-1));
}
for(int i=0;i!=p;++i)
{
scanf("%d%d%d",&a,&b,&d);
g[a-1].push_back(Node(b-1,d));
g[b-1].push_back(Node(a-1,d));
}
Dijkstra(g);
cout<<len[q-1]<<endl;
memset(len,0,sizeof(len));
memset(visited,0,sizeof(visited));
}
return 0;
}
算法2,Bellman-Ford算法:这个算法可以判断图中是否有负权回路,同时该算法也可以用来求解负权情况下的单源最短路径问题。
假设Dist[pos]表示pos到其它顶点的最短距离,然后采用松弛技术,对每条边(Vi,Vj)进行|V|-1次松弛操作,每次Dist[Vi]+(Vi,Vj)<Dist[Vj]时,更新Dist[Vj]的值为Dist[Vi]+(Vi,Vj),|V|-1次松弛操作后,如果还存在Dist[Vi]+(Vi,Vj)<Dist[Vj],表示图中存在负权回路,返回错误信息,否则Dist[Vj]表示到源点pos最短距离。
初始化的时候将除源点外的所有顶点的最短距离设为d[v] 赋值为∞, 源点d[s] =0;
要注意的是这个题目是无向图,注意双向连通,不然的话得不出结果的,我就是这样做了好久~~~具体见代码:
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAX=1010;
const int MAXN=200001;
const int Inf=1000000;
#define min(a,b) a<b?a:b
int num,n,m,P,Q,Dist[MAX],force[MAX],map[MAX][MAX];
struct Graph{
void Copy(Graph &G1,Graph &G2)
{ G1.u=G2.v,G1.v=G2.u,G1.w=G2.w;
}
int u,v,w;
}G[MAXN],g;
bool Bellman_Ford()
{ fill(Dist,Dist+MAX,Inf);
Dist[Q]=0;
for(int i=1;i<m;i++)//循环m-1次
for(int j=1;j<=2*P;j++)
Dist[G[j].v]=min(Dist[G[j].v],Dist[G[j].u]+G[j].w);//松弛操作
for(int i=1;i<=2*P;i++)
if(Dist[G[i].v]>Dist[G[i].u]+G[i].w) return false;//这个题目不用判断,不会出现负权回路
return true;
}
int main()
{ scanf("%d",&num);
while(num--)
{ scanf("%d%d%d%d",&n,&m,&P,&Q);
for(int i=1;i<=n;i++)
scanf("%d",&force[i]);
for(int i=1;i<=P;i++)
{ scanf("%d%d%d",&G[2*i].u,&G[2*i].v,&G[2*i].w);
g.Copy(G[2*i-1],G[2*i]);//无向图求最短路径,注意双向性
}
Bellman_Ford();
int Min=Inf;
for(int i=1;i<=n;i++)
Min=min(Min,Dist[force[i]]);
printf("%d\n",Min);
}
return 0;
}
算法3,SPFA算法,后面的博文中有。