BAPC 2014 Preliminary B Failing Components [ Dijkstra算法 + 堆优化 ]

Originum

于 2018-07-29 18:16:28 发布

阅读量385

点赞数

CC 4.0 BY-SA版权

分类专栏： ACM 图论最短路堆文章标签： ACM Dijkstra 堆最短路图论

本文链接：https://blog.youkuaiyun.com/Originum/article/details/81272325

ACM 同时被 3 个专栏收录

24 篇文章

订阅专栏

图论

4 篇文章

订阅专栏

最短路

3 篇文章

订阅专栏

本文介绍如何使用Dijkstra算法结合优先队列优化解决一个关于故障零件在系统内传播的问题，通过实例代码展示了如何计算故障影响范围及所需时间。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：

B. Failing Components

题意概括：

有n个零件，分别用1-n的编号给出。其中一个零件(b)的故障会导致另一个零件(a)的故障，两事件中间有延时，不是同时发生(在b发生故障后s秒的时间后a才故障)。给出初始的故障零件编号c，问最终有多少个零件发生故障，与故障都发生所需的时间。

题解思路：

[Dijkstra算法+堆优化]

不难看出就是最短路问题，边权都为正，用Dijkstra就可以，但是还需要用优先队列优化，复杂度达到O(ElogE)。其中求出原点到其他所有点的最短路径，就是算法中的dist数组存储的值，若值为INF则表示无法到达改点(该零件不会故障)，dist值非INF的点的个数便为最终会发生故障零件的个数。这些点中路径最长的一个(dist的最大值)便为故障都发生所需的时间。

AC代码：

#include <stdio.h>
#include <queue>
#include <vector>
#include <algorithm>
#include <memory.h>
using namespace std;

const int INF = 0x3f3f3f3f;           //INF的数值要适中，太大会溢出，太小会误判
const int MAXN = 1e4 + 10;

//用了kuangbin的板子
struct qnode    
{
    int v;
    int c;
    qnode(int _v = 0, int _c = 0): v(_v), c(_c) {}
    bool operator < (const qnode &r)const
    {
        return c > r.c;
    }
};

struct Edge   
{
    int v, cost;
    Edge(int _v = 0, int _cost = 0): v(_v), cost(_cost) {}
};

vector<Edge>E[MAXN];
bool vis[MAXN];
int dist[MAXN];

void Dijkstra(int n, int start) //点的编号从1开始,有n个点
{
    memset(vis, false, sizeof(vis)); //初始化vis
    for (int i = 1; i <= n; i ++) dist[i] = INF;  //初始化dist
    priority_queue<qnode>que;
    while (!que.empty())
        que.pop();
    dist[start] = 0;
    que.push(qnode(start, 0));
    qnode tmp;
    while (!que.empty())
    {
        tmp = que.top(); que.pop();
        int u = tmp.v;
        if (vis[u]) continue;
        vis[u] = true;
        for (int i = 0; i < E[u].size(); i ++)
        {
            int v = E[tmp.v][i].v;
            int cost = E[u][i].cost;
            if (!vis[v] && dist[v] > dist[u] + cost)
            {
                dist[v] = dist[u] + cost; que.push(qnode(v, dist[v]));
            }
        }
    }
}

void addedge(int u, int v, int w)//起点、终点、权重
{
    E[u].push_back(Edge(v, w));
}

int main() {
    int N;
    scanf("%d", &N);
    while (N --) {
        int n, d, c;
        scanf("%d%d%d", &n, &d, &c);
        for (int i = 0; i <= n; i ++) E[i].clear();  //每次都要初始化vector<Edge>E[MAXN];
        for (int i = 0; i < d; i ++) {
            int a, b, s;
            scanf("%d%d%d", &a, &b, &s);
            addedge(b, a, s);
        }
        Dijkstra(n, c);
        int ans = -INF, cnt = 0;
        for (int i = 1; i <= n; i ++) {
            if (dist[i] != INF) {
                cnt ++;
                ans = max(ans, dist[i]);
            }
        }
        printf("%d %d\n", cnt, ans);
    }
}