spfa 算法模板

最新推荐文章于 2024-04-13 13:54:08 发布

betwater

最新推荐文章于 2024-04-13 13:54:08 发布

阅读量331

点赞数

分类专栏：算法模板文章标签：算法

本文链接：https://blog.csdn.net/betwater/article/details/52043250

版权

算法模板专栏收录该内容

46 篇文章 1 订阅

订阅专栏

#include <bits/stdc++.h>
#define MEM(a,x) memset(a , x , sizeof(a))
using namespace std;

typedef int weight_t;
const int SIZE_E = //1000000;  注意是双向边 题目的m条边 在mkEdge里面存了两条
const int SIZE_V = //1050;

int n;
int ECnt = 0;


struct edge_t{
    int v;
    weight_t w;
    edge_t *next;
}Edge[SIZE_E];

edge_t *V[SIZE_V];



void mkEdge(int const &a,int const &b,weight_t const &w){
    Edge[ECnt].v = b;
    Edge[ECnt].w = w;
    Edge[ECnt].next = V[a];
    V[a] = Edge+ECnt++;

    Edge[ECnt].v = a;
    Edge[ECnt].w = w;
    Edge[ECnt].next = V[b];
    V[b] = Edge+ECnt++;
}

weight_t D[SIZE_V];
bool flag[SIZE_V];
void spfa(int s){

    MEM(flag,0);
    fill(D,D+SIZE_V,INT_MAX);

    D[s] = 0;
    flag[s] = true;

    queue<int>q;
    q.push(s);

    while(!q.empty()){
        int u = q.front();
        q.pop();
        flag[u] = false;

        for(edge_t *p = V[u];p;p = p->next){

            int v = p->v;
            weight_t temp = D[u] + p->w;

            if (temp < D[v]){
                D[v] = temp;
                if (!flag[v]){
                    flag[v] = true;
                    q.push(v);
                }
            }
        }
    }
}
void init(){
    ECnt = 0;
    memset(V,0,sizeof(V));
    MEM(Edge,0);
}

使用邻接矩阵的存储方式

#include <bits/stdc++.h>
#define MEM(a,x) memset(a , x , sizeof(a))
using namespace std;

/**下标从1开始，只能存一条边
  *注意初始化
  */
typedef int weight_t;
const int SIZE_V  = 110;
int n;

weight_t Road[SIZE_V][SIZE_V];
///不能存多条边，所以存边要先判断
inline void mkEdge(int const &a,int const &b,weight_t const &w){
    Road[a][b] = Road[b][a] = w;
}
weight_t D[SIZE_V];
bool flag[SIZE_V];
void spfa(int s){

    MEM(flag,0);
    fill(D,D+SIZE_V,INT_MAX);
    D[s] = 0;
    flag[s] = true;

    queue<int>q;
    q.push(s);
    while(!q.empty()){
        int u = q.front();
        q.pop();
        flag[u] = false;
        for (int i = 1;i <= n;++i){
            ///注意是减法，初始化没边是int_max，加上D[u]会变成负数
            if ( D[i] - Road[u][i] > D[u] ){
                D[i] = Road[u][i]+D[u];
                if (!flag[i]){
                    flag[i] = true;
                    q.push(i);
                }
            }
        }
    }
}
void init(){
    for (int i = 0;i<= n;++i)for (int j = 0;j <= n;++j){
        Road[i][j] = INT_MAX;
    }
}