最短路径

引用一下某机构的PPT

无权图BFS算法很简单，到达顶点经过几轮最短路径就是几，不详细说明。

Dijkstra
解决单源最短路径的问题。
dijkstra的算法实现和prim最小生成树的思想很像。

此处未给出path数组的信息，待更新

//G全局变量；数组d为源点到各点的最短路径长度，s为起点
Dijkstra(G,d[],s)
{
    初始化;
    for (循环n次)//每次找到一个最短路径
    {
        u = 使d[u]最小的还未被访问的顶点的编号;//中转点，松弛操作的点
        记u已被访问;
        for(从u除法能到达的所有顶点v)
            if v未被访问 && 以u为中介点使s到顶点v的最短距离d[v]更优
                优化d[v];
    }
}

//邻接矩阵版
int n,G[MAXV][MAXV];//
int d[MAXV];//起点到各点的最短路径长度
bool vis[MAXV] = {false};//标记数组

void Dijkstra(int s){//s start
	fill(d,d + MAXV,INF);//fill函数将整个d数组赋为INF
	 d[s]  = 0;//起点到大自身的距离是0 
	 int ans = 0;//边权之和
	 for(int i = 0; i <n;i++){
	 	int u = -1,MIN = INF;//u使d[u]最小，MIN存放最小的d[u]
		 for(int j =0;j < n;j++){//找到为访问的顶点中d[]最小的
		 	if(vis[j] == false && d[j] < MIN){
		 		u = j;
		 		MIN = d[j];
			 } 
		 } 
		 //找不到小于INF的d[u]，剩下的顶点和集合s不连通
		 if(u = -1) return;
		 vis[u] = true;
		 for(int v =0 ;v < n;v ++){
		 	//v未访问且u能达到v且以u为中介点可以使距离集合s更近
			 if(vis[v] == false && G[u][v] != INF && d[u] + G[u][v] < d[v]){
			 	d[v] = d[u] + G[u][v];//d[v] 值更新 
			 } 
		 } 
	 } 	
	
} 

邻接表版

//邻接表版
int n,G[MAXV][MAXV];//
int d[MAXV];//七点到大各点的最短路径长度
bool vis[MAXV] = {false};//标记数组

void Dijkstra(int s){//s start
fill(d,d + MAXV,INF);//fill函数将整个d数组赋为INF
	 d[s]  = 0;//七点到大自身的距离是0 
	 int ans = 0;//边权之和
	 for(int i = 0; i <n;i++){
	 	int u = -1,MIN = INF;//u使d[u]最小，MIN存放最小的d[u]
		 for(int j =0;j < n;j++){//找到为访问的顶点中d[]最小的
		 	if(vis[j] == false && d[j] < MIN){
		 		u = j;
		 		MIN = d[j];
			 } 
		 } 
		 //找不到小于INF的d[u]，剩下的顶点和集合s不连通
		 if(u = -1) return;
		 vis[u] = true;//标记u已访问
		  for(int j = 0;j < Adj[u].size();j++){
		 	int v = Adj[u][i].v;//通过邻接表直接获得u能到达的顶点v 
			 if(vis[v] == false && Adj[u][j].dis < d[v]){
			 	//v未访问且u能达到v且以u为中介点可以使距离集合s更近
			 	d[v] = Adj[u][j].dis;//d[v] 值更新 
			 } 
		 } 
	 } 		
} 

Bellma-Ford 算法
Dijkstra算法在计算negtive-cost-edge时会陷入循环，Bellma-Ford算法不会
代码先码上了，现在害不想看。

Bellman-Ford(G,d[],s)
{
    for (循环n-1次)
    {
       for(each edge u->v)
           if(d[u]+lenth[u->v] < d[v])
           {
               d[v] = d[u] + length[u->v]; //松弛操作
           }
    }
    for(each edge u->v)
        if(d[u]+lenth[u->v] < d[v])
        {
            d[v] = d[u] + length[u->v]; //如果仍然可以被1松弛，说明有负环
            return false;
        }
    }
    return true;
}

struct Node{
	int v,dis;//v为邻接边的目标顶点,dis为邻接边的边权 
}; 

vector<Node> Adj[MAXV];
int n;
int d[MAXV];

bool Bellman(int s){
	fill(d,d+MAXV,INF);
	d[s] = 0;//s到自身的距离为0
	for(int i = 0; i <n -1 ;i ++){//执行n-1轮操作 
		for(int u = 0;u < n;u++){//每轮操作都遍历所有边 
			for(int j = 0;j < Adj[u].size() ;j ++){
				int v = Addj[u][j].v;//邻接边的顶点
				int dis = Adj[u][j].dis;//邻接边的边权
				if(d[u] + dis < d[v]){
					d[v] = d[u] + dis;
				}
			}
		}
	}
	//判断负环
	 	for(int u = 0;u < n;u++){//每轮操作都遍历所有边 
			for(int j = 0;j < Adj[u].size() ;j ++){
				int v = Addj[u][j].v;//邻接边的顶点
				int dis = Adj[u][j].dis;//邻接边的边权
				if(d[u] + dis < d[v]){
					return false;//说明图中有从源点可达的负环 
				}
			}
		}
		return true;//数组d的所有值都已达到最优 
} 

SPFA算法
SPFA算法时对BF算法的优化
借助队列

queu<int> Q;
源点s入队;
while(队列非空)
{
    取出队首元素u;
    fro(u的所有邻接边u->)v{
        if(d[u]+ dis < d[v])
            d[v] = d[u] + dis;
            if(v当前不在队列)
                v入队;
                if(v的如对次数大于n-1)
                    说明有可达负环,return;
    }
}

vector<Node> Adj[MAXV];
int n,d[MAXV],num[MAXV];
bool inq[MAXV];//顶点是否在队列中 

bool SPFA(int s){
	//初始化部分
	meset(inq,false,sizeof(inq));
	meset(num,0,sizeof(num));
	fill(d,d+MAXV,INF);
	//源点入队部分
	 queue<int> Q;
	 Q.push(s);
	 inq[s] = true;
	 num[s]++;
	 d[s] = 0;
	 //主体部分
	 while(!Q.empty()){
	 	int u = Q.front();
	 	Q.pop();
	 	inq[u] = false;
	 	//遍历u的所有邻接边v
		 for(int j = 0;j < Adj[u].size();j++){
		 	int v = Adj[u][j].v;
		 	int dis = Adj[u][j].dis;
		 	//松弛操作
			 if(d[u] + dis < d[v]){
			 	d[v] = d[u] + dis;
			 	if(!inq[v]){
			 		Q.push(v);//v入队
					 inq[v] = true;
					 num[v] ++ ;
					 if(num[v] >= n) return false;//有可达 负环 
				 }
			 } 
		 } 
	}
	return false; 
} 

Foryd算法
Ford算法需要2个数组，一个存放结点距离的信息，一个存放路径的前驱结点。

枚举顶点k属于[1,n] 
	以顶点k作为中介点,枚举所有顶点对i和j(i属于[1,n],j属于[1,n])
		如果dis[i][k] + dis[k][j] < dis[i][j] 成立
			赋值dis[i][j] =  dis[i][k] + dis[k][j]; 

全源最短路径

枚举顶点 k 属于 [1,n]
	以顶点k为中介点，而迷局所有顶点对i和j(i belong [1,n]  j [1,n])
		如果dis[i][k] + dis[k][j]  < dis [i][j] 成立
			赋值dis[i][j] = dis [i][k] + dis[k][j]   

#include <stdio.h>
#include <algorithm>
using namespace std;
const int INF = 1000000000;
const int MAXV = 200;
int n,m;//n顶点数，m边数
int dis[MAXV][MAXV];//dis[i][j] 表示顶点i和顶点j1的最短距离


void Floyd(){
	for(int k = 0;k < n;k ++){
		for(int i = 0;i < n; i++){
			for(int j = 0;j < n;j++){
				if(dis[i][k] != INF && dis[k][j] != INF && dis[i][k] + dis[k][j]  < dis [i][j] ) {
					dis[i][j] = dis [i][k] + dis[k][j]   ;
				}
			}	
		}
	}
}