Dijkstra、Dij + heap、Floyd、SPFA、 SPFA + SLF Template

 Dijkstra in Adjacency matrix :

int Dijkstra(int src,int tec, int n){

    bool done[1005];

    int d[1005];

    memset(done,0,sizeof(done));



    map[0][src] = 0;//巧妙之处，加入超级源点0

    

    for(int i = 0;i <= n;i++)

        d[i] = (i == src ? 0 : 1000000);

    for(int i = 0;i <= n;i++){//最多执行n+1次操作

        int minx,minn = 1000000;

        for(int j = 0;j <= n;j++)//先找到d[]最小的点

            if(!done[j] && d[j] < minn){

                minn = d[j];

                minx = j;

            }

        done[minx] = 1;//将该点加入集合

        if(minx == ter)   return d[minx];

        for(int j = 0;j <= n;j++){//再更新所有的d[]

            if(!done[j] && d[minx] + map[minx][j] < d[j]){

                d[j] = d[minx] + map[minx][j];

            }

        }

    }

    return -1;//如果没有找到到终点的路径，返回-1

}

---

 

Dijkstra in Adjacency list :

int dijkstra(int src,int ter){//src源点,ter终点

    vist[src] = 1;

    dist[src] = 0;

    for(int i = head[src];i != -1;i = edge[i].pre ){

            dist[edge[i].cur] = edge[i].w;      //dist[x]保存从源点到节点x当前最短距离

    }

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

        int cur = 0,Min = inf;

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

            if(!vist[j] && dist[j] < Min){

                Min = dist[j];

                cur = j;

            }

        }

        vist[cur] = 1;

        if(cur == ter)    return dist[cur];

        //当ter被标记为访问过时，说明当前dist[ter]已经为src到ter的最短距离

        for(int j = head[cur];j != -1;j = edge[j].pre ){

            int to = edge[j].cur;

            if(!vist[to]){

                dist[to] = min(dist[to],dist[cur] + edge[j].w);

            }

        }

    }

    return dist[ter];

}

---

 

Dijkstra + heap :

int dijkstra(int src,int ter){

    vist[src] = 1;

    dist[src] = 0;

    priority_queue<node>q;

    /*

    struct node{

    int v,dist;//顶点和距离

    node(int vv,int ddist){v=vv,dist=ddist;}

    bool operator<(const node &A)const{return dist > A.dist;}//最小优先

    };

    */

    q.push(node(src,0));

    int cur = src;

    for(int i = 0;i < n;i ++){

        for(int j = head[cur];j != -1;j = edge[j].pre ){

            int to = edge[j].cur;

            if(!vist[to] && dist[to]>dist[cur]+edge[j].w){

                dist[to] = dist[cur] + edge[j].w;

                q.push(node(to,dist[to]));

            }

        }

        while(!q.empty()&&vist[q.top().v]){

            q.pop();

        }

        cur = q.top().v;q.pop();

        vist[cur] = 1;

        if(cur == ter)break;

    }

    return dist[ter];

}

---

 

Floyd ：

简单描述一下Floyd：首先我们需要一个邻接矩阵

（所谓邻接矩阵是一个 n*n 的矩阵, 第i行第j列的值为value 表示i点到j点的距离为value

.若i到j点不可达时我们可以使value=inf）

注意传递闭包的概念, 得到一个传递闭包至多将任意两点松弛n次。

第一层for是用k点去松弛, 第二层和第三层for是对于任意两点i、j。

#define inf 1000000000

// init***************

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

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

        dp[i][j] = inf;

//****************

//--------------Floyd: 

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

    for(int i = 1; i <= n; i++)if(i!=k && dp[i][k] != inf)

        for(int j = 1; j <= n; j++)if(j!=i && j!=k)

            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);

//--------------

for(int i = 1; i <= n; i++) dp[i][i] = 0;

 

---

 SPFA：

1、注意对于最短路中存在负权判定：对于spfa算法

当某个点入队列（入队列的意义就是该点被松弛了(更新)）次数>n次，

就说明该点在负权上（可以简单证明一个点至多被更新n次(n为图中的顶点数)）。

2、优先队列：出队的元素不是在队尾的元素，

而是队列中最小的元素（我们有时可以在队列中存储结构体元素，只需重载运算符即可）。

struct node{

	int x, y;

	bool operator<(const node&a) const

	{ if(a.x==x) return a.y<y;  return a.x<x; } //根据x,y值比较node结构体的大小

};

3、状态压缩：当某些状态只有true or false,时我们可以用一个整数来表示这个状态。

示例：

有3块不同的蛋糕编号1、2、3, 被老鼠啃过, 那么蛋糕只有2种状态, 我们用0表示没有被啃过, 1表示被啃过。

显然我们可以得到所有状态：000、001、010、011、100、101、110、111.

而上述二进制数对应的整数为 [0, 2^3) . （如二进制011 = 整数3表示 第2、3块蛋糕被啃过，第一块蛋糕没有被啃过）

我们可以用 for(int i = 0; i < (1<<3); i++) 来遍历所有的状态。

把多个事物的状态利用二进制含义压缩为一个整数称为状态压缩。

4、利用优先队列优化最短路时, 我们可以先出队距离起点最近的点, 则若出队的为终点显然我们已经得到了一条最短路了。

---

 

SPFA in Adjacency list :

The LONGEST PATH:

struct node{

    int u,v,val,next;

} Edge[MAXN];

void addEdge(int u,int v,int val){

    Edge[cnt].u=u;

    Edge[cnt].v=v;

    Edge[cnt].val=val;

    Edge[cnt].next=head[u];

    head[u]=cnt++;

}

int spfa(){

    //for(int i=src;i<=ter;i++) dis[i]=-INF;

    queue<int>q;

    q.push(src);

    vis[src]=1;

    dis[src]=0;

    while(!q.empty()){

        int u=q.front();

        q.pop();

        vis[u]=0;

        for(int i=head[u]; i!=-1; i=Edge[i].next){

            int v=Edge[i].v;

            if(dis[v]<dis[u]+Edge[i].val){

                dis[v]=dis[u]+Edge[i].val;

                if(!vis[v]){

                    vis[v]=1;

                    q.push(v);

                }

            }

        }

    }

    return dis[ter];

}

---

 

SPFA + SLF in Adjacency list :

The LONGEST PATH:

int spfa(int src,int ter){

    //for(int i=src;i<=ter;i++) dis[i]=-INF;

    deque<int>q;

    q.push_back(src);

    vis[src] = 1;//标记当前顶点是否在队列中

    dis[src] = 0;

    while(!q.empty()){

        int u = q.front();

        q.pop_front();

        vis[u] = 0;

        for(int i = head[u];i != -1;i = Edge[i].next){

            int v = Edge[i].v;

            if(dis[v] < dis[u] + Edge[i].val){//松弛

                dis[v] = dis[u] + Edge[i].val;

                if(!vis[v]){

                    vis[v] = 1;

                    if(!q.empty()&&dis[v]<dis[q.front()])//SLF优化

                        q.push_front(v);

                    else q.push_back(v);

                }

            }

        }

    }

    return dis[ter];

}