ACM-模板-最短路

最短路算法

一、floyd算法主要用于求任意两点间的最短路径，也成最短最短路径问题。

求多源、无负权边的最短路。用矩阵记录图。时效性较差，时间复杂度O(V^3)。

模板：

//邻接矩阵

void floyd()
{
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(d[i][j]>d[i][k]+d[k][j])
                d[i][j] = d[i][k]+d[k][j];
            }
        }
    }
}

二、单源最短路径算法——dijkstra

  1、思想描述：当Q(一开始为所有节点的集合)非空时，不断地将Q中的最小值u取出，然后放到S（最短路径的节点的集合）集合中，然后遍历所有与u邻接的边，如果可以进行松弛，则对便进行相应的松弛。。。

优化版本就是加入堆排序的dijkstra

模板：

邻接矩阵版本

/**
 * 返回从v---->到target的最短路径
 */
int dijkstra(int v){
	int i;
	for(i = 1 ; i <= n ; ++i){//初始化
		s[i] = 0;//一开始，所有的点均为被访问过
		dis[i] = map[v][i];
	}
        dis[v] = 0; 
        s[v] = true;
	for(i = 1 ; i < n ; ++i){
		int min = inf;
		int pos;

		int j;
		for(j = 1 ; j <= n ; ++j){//寻找目前的最短路径的最小点
			if(!s[j] && dis[j] < min){
				min = dis[j];
				pos = j;
			}
		}

		s[pos] = 1;

		for(j = 1 ; j <= n ; j++){//遍历u的所有的邻接的边
			if(!s[j] && dis[j] > dis[pos] + map[pos][j]){
				dis[j] = dis[pos] + map[pos][j];//对边进行松弛
			}
		}
	}


	return dis[target];
}

struct node{
	int d, num;
	bool operator < (node i)const{
		return d > i.d;
	}
}t;
//堆优化的迪佳斯特拉算法
priority_queue <node> q;

void Dijkstra(){
	memset(d, 0x7f, sizeof d);
	d[s] = 0;
	t.num = s, t.d = 0;
	q.push(t);
	while(q.size()){
		t = q.top(); q.pop();
		int u = t.num;
		if(vis[u]) continue;
		vis[u] = 1;
		for(int j = 0; j < G[u].size(); j++){
			int e = G[u][j], v = E[e].v, w = E[e].w;
			if(d[v] > d[u]+w) {
				d[v] = d[u] + w;
				t.num = v, t.d = d[v];
				q.push(t);	
			}
		}
	}
}

三、使用bellman-ford算法

bellmen-ford算法介绍：

       思想：其实bellman-ford的思想和dijkstra的是很像的，其关键点都在于不断地对边进行松弛。而最大的区别就在于前者能作用于负边权的情况。其实现思路还是在求出最短路径后，判断此刻是否还能对边进行松弛，如果还能进行松弛，便说明还有负边权的边.

四、使用spfa算法

spfa只是对bellmen-ford进行队列优化

模板：

//邻接表

vector<int> G[M];
struct edge
{
    int u;
    int v;
    int w;
}E[M*M];
void spfa()
{
    memset(d,0x7f,sizeof(d));
    d[s] = 0;
    q.push(s);
    times[s] = inq[s] = 1;
    while(q.size())
    {
        int u = q.front();
        q.pop();
        inq[u] = 0;
        for(int i=0;i<G[i].size();i++)
        {
            int e = G[u][i];
            int v = E[e].v;
            int w = E[e].w;
            if(d[v]>d[u]+w)
            {
                d[v] = d[u]+w;
                if(!inq[v])
                {
                    q.push(v);
                    inq[v] = 1;
                    times[v]++;
                    if(times[v] == n) return 0;
                }
            }

        }
    }
}

//邻接矩阵版本