Bellman-Ford算法

#include <iostream>

#include <vector>

using namespace std;

#define NUMV 10

typedef struct
{

 int u , v , w ;

}Edge ;

vector<Edge> edge ;

Edge info ;

int dist[NUMV] ;


int n ;

bool bford(int v0) 

{
 for(int i = 0; i < n; i ++)
  dist[i] = MAXN ;

  dist[v0] = 0 ;//初始化时，v0的dist为零。
 for(int i = 1; i < n; i ++)
  for(int j = 0; j < (int)edge.size(); j ++)
 {
  if(dist[edge[j].u] != MAXN && dist[edge[j].v] > dist[edge[j].u] + edge[j].w)
  { // dist[edge[j].u] != MAXN 的作用是避免带负权值的边使得不能相通的边变得相通了，例如
   //dist[edge[j].u] == MAXN ,  edge[j].w < 0 ,dist[edge[j].v] > dist[edge[j].u] + edge[j].w 成立，那就不能用
   //dist[edge[j].v] == MAXN 来判断源点到v不通 。
   dist[edge[j].v] = dist[edge[j].u] + edge[j].w ;
   path[edge[j].v] = edge[j].u ;
  }
 }

 for(int j = 0; j < (int)edge.size; j ++)
   if(dist[edge[j].u] != MAXN && dist[edge[j].v] > dist[edge[j].u] + edge[j].w)
     return false ;
  return true ;
}
int main()
{


}

 

bellman-ford算法是对dijkstra算法的不足进行的优化，dijkstra算法不能够处理带负权值的图，因为dijkstra算法每次都是选最小的一条边，存在负权值的话，就不行了。所以bellman-ford发明了bellman-ford算法。

算法原理是：对于每个点u都绕过k条边从i到达u（k= 1 ,2 , 3 ....n - 1）。而最后的结果是绕过n-1条变的结果。

上面的代码是用容器做的。最简单但是复杂都比较大的做法，也在这里写下。

bool bellman-ford(int v)
{
 for(int i = 0; i < n; i ++)
 {
  if（i ！= v）
  dist[i] = MAXN ;
else
   dist[i] = 0 ;
  path[i] = -1 ;
 }
 for(int k = 1; k < n; k ++)
  for(int u = 0; u < n; u ++)
    if(u != v)
     for(int i = 0; i < n; i ++)
      if(dist[i] != MAXN && dist[u] > dist[i] + edge[i][u])
 {
  
  dist[u] = dist[i] + edge[i][u] ;
  
  path[u] = i ;
 }
 
 for(int i = 0; i < n; i ++)
   for(int j = 0; j < n; j ++)
    if(dist[j] > dist[i] + edge[i][j])
     return false ;
 return true ;
}