蓝桥杯真题 - 推导部分和 - 题解

题目链接：https://www.lanqiao.cn/problems/2094/learning/

个人评价：难度 3 星（满星：5）
前置知识：前缀和，并查集，宽度优先搜索

---

整体思路

1. 首先把原数组转化为前缀和数组，只要求出原数组的差分信息就能得到区间和信息；
2. 把前缀和数组的每一位看成有向图上的一个点，若 $sum[r]-sum[l-1]=x$，则认为节点 $l-1$ 到节点 $r$ 有一条权值为 $x$ 的边，节点 $r$ 到节点 $l-1$ 有一条权值为 $-x$ 的边；
3. 通过题目给出的 $l_i,r_i,S_i$ 部分和信息建有向图，从有向图上任意一点开始，设该点值为 $0$，做宽度优先搜索，边搜索边计算出对应点与起点的差分关系；
4. 只有在同一连通块内的点才有差分关系，能计算出部分和，不同连通块之间无法做差分求部分和，因此对于每次询问 $l,r$，需要先判断 $l-1$ 与 $r$ 是否在同一连通块内，可使用并查集 $O(1)$ 判断连通块。

过题代码

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
const int maxn = 100000 + 100;
LL INF = 0x3f3f3f3f3f3f3f3f;
struct Node {
    int idx;
    LL sum;

    Node() {}
    Node(int i, LL s) {
        idx = i;
        sum = s;
    }
};

int n, m, q, l, r;
LL s;
int fa[maxn];
LL sum[maxn];
vector<Node> G[maxn];
queue<int> que;

// 并查集模板代码
void init() {
    for (int i = 0; i <= n; ++i) {
        fa[i] = i;
    }
}

int Find(int x) {
    return x == fa[x] ? x : fa[x] = Find(fa[x]);
}

void unit(int x, int y) {
    fa[Find(x)] = Find(y);
}

// 从节点 s 开始宽度优先搜索
void bfs(int s) {
    sum[s] = 0;
    que.push(s);
    while (!que.empty()) {
        int tmp = que.front();
        que.pop();
        for (Node &node : G[tmp]) {
            if (sum[node.idx] != INF) {
                // 如果已经搜索，就不再次进队列搜索
                continue;
            }
            sum[node.idx] = sum[tmp] + node.sum;
            que.push(node.idx);
        }
    }
}

int main () {
#ifdef ExRoc
    freopen("test.txt", "r", stdin);
#endif // ExRoc
    ios::sync_with_stdio(false);

    cin >> n >> m >> q;
    init();
    for (int i = 0; i < m; ++i) {
        cin >> l >> r >> s;
        --l;
        // 建图
        G[l].push_back(Node(r, s));
        G[r].push_back(Node(l, -s));

        // 用并查集放到同一个连通块内
        unit(l, r);
    }

    // 所有点都初始化为 INF 值
    memset(sum, 0x3f, sizeof(sum));
    for (int i = 0; i <= n; ++i) {
        if (sum[i] == INF) {
            bfs(i);
        }
    }

    while (q--) {
        cin >> l >> r;
        --l;
        if (Find(l) != Find(r)) {
            // 不在同一连通块内无法推导部分和
            cout << "UNKNOWN" << endl;
        } else {
            cout << sum[r] - sum[l] << endl;
        }
    }

    return 0;
}