最基础图论总结(Spfa与Dijkstra)

1.Floyd

　　Floyd是先枚举转接点，从而达到更新最小值的目的。到后期好像O(n^3) 像闹着玩一样，但在一些n<=100的环境下还是很好用的。。。

inline void Floyd(int x){
    memset(dis,88,sizeof(dis));
    for(register int i=1,x,y;i<=m;++i){
        scanf("%d%d",&x,&y);
        scanf("%d",dis[x][y]);dis[y][x]=dis[x][y];
    }
    for(register int i=1;i<=n;++i) dis[i][i]=0;
    for(register int k=1;k<=n;++k){
        for(register int i=1;in;++i){
            for(register int j=1;jn;++j){
                if(dis[i][k]+dis[k][j]<dis[i][j]) dis[i][j]=dis[i][k]+dis[k][j];
            }
        }
    }
}

2.Dijkstra

　　Dijkstra在图论问题中主要的优点是较稳定，不会被特殊设计的测试点卡掉，还可以记录路径（噩梦。。。）下面为堆优化的代码。

inline void dijkstra(int x) {
    priority_queue<node> q;
    q.push_back(node{0, s});
    for(register int i=1;i<=n;++i)  dis[i]=100000000;
    dis[x]=0;
    memset(judge,0,sizeof(judge));
    while(!q.empty()){
        node xx=q.top(); q.pop();
        int to=xx.to;
        if(judge[to]) continue;//如果这个点已经被提出过了，直接抛弃 （适用于那种松弛之后重复放入队列的点）
        judge[to]=true;
        for(register int i=0;i<q[to].size();++i){
            Edge& e = edges(q[to][i]);
            if(e.dist+dis[to]<dis[e.to]&&dis[to]<100000000) {
                dis[e.to]=e.dist+dis[to];
                p[e.to]=G[to][i]; //记录路径
                q.push_back(Edge(dis[e.to], e.to));//把松弛过后点的d值重新放入队列
            }
        }
    }
}

3.Spfa

　　Spfa是笔者比较青睐的算法。Spfa可以在压队的过程中判断是否存在环，还可以处理负环。

inline void Spfa(int x){
    queue<int> q;
    memset(dis,88,sizeof(dis));
    memset(judge,0,sizeof(judge);
    dis[x]=0;
    q.push(x);
    while(q.size()){
        int xx=q.front(); q.pop;
        for(register int i=first[xx];i;i=a[i].next){
            int to=a[i].to;
            if(dis[to]+a[i].w<dis[xx]){
                dis[xx]=dis[to]+a[i].w;
                if(!judge[to]){
                    q.push(to); judge[to]=1;
                    nums[y]++;//记录加入次数 
                    if(nums[y]>n)   return 0;
                    //如果这个点加入超过n次，说明存在负圈，直接返回 
                }
            }
        }
    }
}