最短路径

Floyd 算法

要点：每次增加第k个点，比较经过第k个点的路径和不经过第k个点的路径的大小

Floyd 算法能够求出任意两个顶点的最短路径

核心代码 ，用领结矩阵来表示图比较方便

 

邻接矩阵 Edge[N][N]

 

Edge[i][j] = Edge[j][i] = -1;//初始化

 

Edge[i][i] = 0;

 

For（int k = 1; k < n-1; k++){

 

   For( int i = 1; i < n; i++){

 

      For(int j =1; j < n; j++){

 

        If(Edge[i][k] == -1|| Edge[k][j] == -1) continue; //不能通过k 点到达 

 

         If(Edge[i][j] == -1 || Edge[i][j] > Edge[i][k] + Edge[k][j])

 

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

 

}

 

}

 

}

 

Djistra  算法

Djistra 算法能够求出指定一点到任意一点的最短路径

用邻接表来表示图比较方便

 

#include <vector>  //链表

 

Srruct node{

 

Int next;  //下个顶点

 

Int cost; //花费

 

};

 

Vector<node> Edge[N]; //有n条链表，链表的数据结构是node ，对应n个顶点

 

Dji[N]; 到当前点的最短路径

 

Flag[N]; 是否已经选入了集合中

 

Whille(m--) //共m条边

 

Node tmp; //边 ab

 

Tmp.next = a;

 

Edge[b].push(tmp);

 

Tmp.next = b;

 

Edge[a].push(tmp);

 

取第一个点作为开始点

 

Dji[1] = 0; 

 

Flag[1] = true;

 

Newp = 1;

 

For(int i = 1; i < n; i++){ //共找n-1个点

 

      For（int j = 0; i < Edge[newp].size();j++) {// 找到与newp相连的点

 

           int a = Edge[newp][j].next;

 

           int c = Edge[newp][j].cost;  //到该点的花费

 

If(flag[a] == true) continue ; // 此点已经在最小生成树的集合中 

 

If( Dij[a] == -1 || Dij[a] > c + Dij[newp]) // {从1到该点不存在或经过newp点的路径短

 

      Dij[a] = Dij[newp] + c; //修改最短路径

 

      }

 

}

 

Int min = xxxxxxxx;

 

Int next;

 

For(int k = 1; k <=n; k++){

 

If(Dij[k] == -1 )continue;

 

If(flag[k] == true) continue;

 

  If(min > Dij[k]) //找到在最小生成树和不在最小生成树集合链接的最短边

 

      {

 

          Min = Dij[k];

 

          Next = k;

 

} 

 

    Newp = k; //将此边加入最小生成树的集合

 

}