图论总结。——四种求最短路算法

1）

       Floyd

       算法描述：等会

       实现：

            

 

void floyd（）

              {

                     for(int k=1;k<=n;k++)

                     for(int i=1;i<=n;i++)

                     for(int j=1;j<=n;j++)

                            if((a[i][j]>a[i][k]+a[k][j])&&(a[i][k])&&(a[k][j]))

                                   a[i][j]=a[i][k]+a[k][j];

              }

      

2）Dijkstra算法：

              认为这种算法是枚举每一个点。并用两个集合，一个存放已枚举过的点（初始只有顶点|V|）并不断在另一个存放未枚举点的集合中不断找最小权值的点进行松弛并将该点存入前一个集合中。

void dijkstra(int st);
{
for (int i=1;i<=n;i++) dis[i]=a[st,i];
memset(f,false,sizeof(f));
f[st]=true; dis[st]=0;
for (int i=1;i {
int min=1000000000, k=0;
for (int j=1;j<=n;j++)
if (!f[j] && (dis[j] if (k==0) return; //已经找不到了。
f[k]=true; //把k加入集合1；
for (int j=1;j<=n;j++) //三角形迭代，更新最短距离
if (!f[j] && (dis[k]+a[k][j] }
}

 

3  贝尔曼福德算法：

       算法思想：用边集数组枚举每一条边。不断进行松弛操作。

 

实现：

bool SP_Bellman(int s)
{
 memset(dis,10,sizeof(dis));
 dis[s]=0;
 
 for(int i=1;i<=n;i++)
 {
  rel=false;
  for(int j=1;j<=m*2+w;j++)
  if(dis[a[j].xx]+a[j].vv  {
   dis[a[j].yy]=a[j].vv+dis[a[j].xx];
   rel=true;
  }
 if (!rel) return 0;
 }
 return 1;
}

4)SPFA算法

 

SP_SPFA(G, s) //求单源s到其它点的最短距离
for i=1 to n do
dis[i] = ∞;vis[i] = false; // 初始化每点到s距离,不在队列
dis[s] = 0; //将dis[s]设为0
vis[s] = true; count = 1; //s放入队列
head = 0; tail = 0; q[0]=s; //队列头尾指针
while (count>0) do
v = q[head]; //队头节点v
for 每条边(v,i) //与v相连的每一条边
if( dis[v]+len[v][i] dis[i] = dis[v]+len[v][i]; //松驰dis[i]
if (vis[i] = false) //不在队列，则加入队列
vis[i] = true; count+1;
tail+1; q[tail] = i;
vis[v] =false;head+1;count-1; //v出队列