Flyod 算法(两两之间的最短路径)

Flyod 算法(两两之间的最短路径)
动态规划方法，通过相邻矩阵， 然后把最后的结果存在这么一个矩阵里面，(i,j),

#include <iostream>

#include <vector>

using namespace std;

#define M 301

#define LIM 200000000

int w[M][M],d[2][M][M];

 

void floyd(int g[M][M],int d[2][M][M],int n){

                int i,j,k;

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

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

                                                d[0][i][j]=g[i][j];

                                }

                                d[0][i][i]=0;

                }        //这里是令d[0]=g

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

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

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

                                                                int t1=k%2; int t2=(t1+1)%2;

                                                                d[t1][i][j]=d[t2][i][j]< d[t2][i][k]+d[t2][k][j]?d[t2][i][j]:d[t2][i][k]+d[t2][k][j];

                                                }

                }

}

2. DijStra算法(单源节点算法，一个到其他定点所有的算法)

#define M 101

#define LIM 20000000

 

int g[M][M],d[M],fd[2][M][M],gt[M][M],set[M];

inline void init(int d[M],int n,int s){  //初始化图

                int i;

                for(i=1;i<=n;i++)    d[i]=LIM;

                d[s]=0;

}

 

inline void relax(int d[M],int u,int v,int duv){

if(d[v]>d[u]+duv)   d[v]=d[u]+duv;

}

void dijkstra(int g[M][M],int d[M],int n,int s){ //n is |V| && s is the source

                init(d,n,s);

                int q[M],ql=1,qf=1; //队列

                int i;

                for(i=1;i<=n;i++) q[ql++]=i;

                while(qf!=ql){

                                int min=qf;

                                for(i=qf;i<ql;i++) if(d[q[i]]<d[q[min]]) min=i;

                                swap(q[qf],q[min]); //q[qf] is the min

                                int u=q[qf++];

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

                                                if(g[u][i]!=0) relax(d,u,i,g[u][i]);

                                }

                }

}

3. BellmanFord算法
  g[][],是一个矩阵图，用于表达有向图 点之间的权重。

inline void init(int d[M],int n,int s){  //初始化图

                int i;

                for(i=1;i<=n;i++)    d[i]=2000000000;

                d[s]=0;

}

 

inline void relax(int d[M],int u,int v,int duv){

                if(d[v]>d[u]+duv)   d[v]=d[u]+duv;

}

 

void bell_man(int g[M][M],int d[M],int n,int s){ //n个结点 s为源点

                int i,j,k;

                init(d,n,s);

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

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

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

                                                                if(g[i][j]!=0) relax(d,i,j,g[i][j]);

                                                }

                }

}