F - Wormholes——最短路_spfa()算法+前向星

最新推荐文章于 2022-02-21 09:22:11 发布

原创最新推荐文章于 2022-02-21 09:22:11 发布 · 533 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#最短路 #spfa-算法 #前向星 #判断负环

知识体系同时被 3 个专栏收录

230 篇文章

订阅专栏

错误反思

228 篇文章

订阅专栏

数据结构-最短路径

19 篇文章

订阅专栏

本文探讨了最短路问题的SPFA算法结合前向星的数据结构进行求解。作者提醒注意全局变量避免重复定义，并指出memset()初始化时参数的正确使用。同时推荐相关题目进行实战练习。

Think:
1知识点：最短路_spfa()算法+前向星
2反思：全局变量不要重复定义，memset()初始化参数不要传错

建议参考题目分析

vjudge题目链接

以下为Accepted代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int inf = 0x3f3f3f3f;
const int N = 5e2 + 4;
const int M = 3e3 + 4;

struct node {
    int v;
    int w;
    int next;
}edge[M*2];

int n, cnt, head[N], dis[N], vis[N], num[N];

void add_edge(int u, int v, int w);
bool spfa(int x);

int main(){
    int T, m, wor, i, u, v, w;
    scanf("%d", &T);
    while(T--){
        cnt = 0;
        memset(head, -1, sizeof(head));
        scanf("%d %d %d", &n, &m, &wor);
        for(i = 1; i <= m; i++){
            scanf("%d %d %d", &u, &v, &w);
            add_edge(u, v, w);
            add_edge(v, u, w);
        }
        for(i = 1; i <= wor; i++){
            scanf("%d %d %d", &u, &v, &w);
            add_edge(u, v, -w);
        }
        bool flag = false;
        for(i = 1; i <= n; i++){
            if(spfa(i)){
                flag = true;
                break;
            }
        }
        if(flag)
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}
void add_edge(int u, int v, int w){
    edge[cnt].v = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}
bool spfa(int x){
    queue <int> q;
    while(!q.empty()){
        q.pop();
    }
    memset(dis, inf, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    memset(num, 0, sizeof(num));
    dis[x] = 0, vis[x] = 1;
    q.push(x);
    num[x]++;
    while(!q.empty()){
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for(int i = head[u]; ~i; i = edge[i].next){
            int v = edge[i].v;
            if(dis[u] + edge[i].w < dis[v]){
                dis[v] = dis[u] + edge[i].w;
                if(!vis[v]){
                    vis[v] = 1;
                    q.push(v);/*松弛点入队*/
                    num[v]++;
                }
                if(num[v] >= n){
                    return true;
                }
            }
        }
    }
    return false;
}