2022牛客暑期训练营图论算法解析-优快云博客

本文链接：https://blog.youkuaiyun.com/ACM_admin/article/details/126097722

本文介绍了2022年牛客暑期多校训练营的图论问题，包括如何求解前缀和后缀最近公共祖先（LCA），并提供了使用倍增法的解决方案。此外，还讨论了城市路径规划问题，提出了利用无向图求最短路的策略，可以类比Dijkstra算法，并给出了问题的分析和思路。

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

"蔚来杯"2022牛客暑期多校训练营3

文章目录

"蔚来杯"2022牛客暑期多校训练营3

A.Ancestor

题目链接

省流：求出前缀 $l c a$ 和后缀 $l c a$ ,尝试删除一个点后通过合并前后缀 $l c a$ 得到剩余点的 $l c a$ ，判断并统计答案

我们可以很容易地观察到，对于多个点 $x_1,x_2...x_n$ 的 $l c a$ ，他们是可以合并的，可以类比对一堆数取 $ma x$ ，先后顺序是没有关系的

lca(a, b, c, d) = lca(lca(a, b, c), d) = lca(lca(a, b), lca(c, d));

然后这个题我们的思路就是枚举哪个点被删去，如果删去后符合要求，就把答案加一

就是把 $x_1$ 到 $x_{i-1}$ 的 $l c a$ 和 $x_{i+1}$ 到 $x_n$ 的 $l c a$ 先求出来，然后求这两个 $l c a$ 的最近公共祖先

例如这张图片， $9$ 为根节点，我们要求 $4$ $5$ $6$ $0$ 的最近公共祖先，那可以先求lca $(4, 5)$ 得到 $2$ ,再求lca $(6, 0)$ 得到 $1$ ，最后求lca $(2, 1)$ 得到 $9$

所以我们对于 $x$ 数组，分别求出 $A$ 树和 $B$ 树上的前缀、后缀 $l c a$ 。然后要删掉 $x_i$ ，那剩下的 $l c a$ 就是lca(prelca(i-1),suflca(i+1))

倍增求 $l c a$ 或者树链剖分都可，倍增好写，树链剖分功能多且常数小

有两棵树，所以我们直接用 $nam es p a ce$ 隔离一下，然后写完一套就直接复制就行了，函数和数组名都不用改（~~方便、快捷、安全~~）

如果嫌代码太长，可以看看

#pragma region
#pragma endregion

相关内容

代码：


// 2022/07/29 周五 10:46:50.54 
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = a, i##end = b; i <= i##end; ++i)
#define per(i, b, a) for (int i = a, i##end = b; i >= i##end; --i)
typedef long long LL;
#define endl '\n'
const int LIM = 1e5 + 10;
int n, k;
int x[LIM];
namespace A {
vector<int> e[LIM];
int val[LIM];
int dep[LIM], sz[LIM], son[LIM], fa[LIM];
void dfs1(int f, int u) {
    dep[u] = dep[f] + 1;
    sz[u] = 1;
    fa[u] = f;
    for (int v : e[u]) {
        dfs1(u, v);
        if (sz[son[u]] < sz[v]) son[u] = v;
    }
}
int top[LIM], dfn[LIM], dfncnt;
void dfs2(int u, int t) {
    dfn[u] = ++dfncnt;
    top[u] = t;
    if (!son[u]) return;
    dfs2(son[u], t);
    for (int v : e[u]) {
        if (v == son[u]) continue;
        dfs2(v, v);
    }
}
int lca(int a, int b) {
    while (top[a] != top[b]) {
        if (dep[top[a]] < dep[top[b]]) swap(a, b);
        a = fa[top[a]];
    }
    return dep[a] < dep[b] ? a : b;
}
int prelca[LIM], suflca[LIM];
void build() {
    dfs1(0, 1);
    dfs2(1, 1);
    prelca[1] = x[1];
    rep(i, 2, k) prelca[i] = lca(prelca[i - 1], x[i]);
    suflca[k] = x[k];
    per(i, 1, k - 1) suflca[i] = lca(suflca[i + 1], x[i]);
    // for (int i = 1; i <= k; ++i) cerr << prelca[i] << " \n"[i == k];
    // for (int i = 1; i <= k; ++i) cerr << suflca[i] << " \n"[i == k];
}
int del(int i) {
    if (i == 1) return val[suflca[2]];
    if (i == k) return val[prelca[k - 1]];
    return val[lca(prelca[i - 1], suflca[i + 1])];
}
}  // namespace A
namespace B {
vector<int> e[LIM];
int val[LIM];
int dep[LIM], sz[LIM], son[LIM], fa[LIM];
void dfs1(int f, int u) {
    dep[u] = dep[f] + 1;
    sz[u] = 1;
    fa[u] = f;
    for (int v : e[u]) {
        dfs1(u, v);
        if (sz[son[u]] < sz[v]) son[u] = v;
    }
}
int top[LIM], dfn[LIM], dfncnt;
void dfs2(int u, int t) {
    dfn[u] = ++dfncnt;
    top[u] = t;
    if (!son[u]) return;
    dfs2(son[u], t);
    for (int v : e[u]) {
        if (v == son[u]) continue;
        dfs2(v, v);
    }
}
int lca(int a, int b) {
    while (top[a] != top[b]) {
        if (dep[top[a]] < dep[top[b]]) swap(a, b);
        a = fa[top[a]];
    }
    return dep[a] < dep[b] ? a : b;
}
int prelca[LIM], suflca[LIM];
void build() {
    dfs1(0, 1);
    dfs2(1, 1);
    prelca[1] = x[1];
    rep(i, 2, k) prelca[i] = lca(prelca[i - 1], x[i]);
    suflca[k] = x[k];
    per(i, 1, k - 1) suflca[i] = lca(suflca[i + 1], x[i]);
    // for (int i = 1; i <= k; ++i) cerr << prelca[i] << " \n"[i == k];
    // for (int i = 1; i <= k; ++i) cerr << suflca[i] << " \n"[i == k];
}
int del(int i) {
    if (i == 1) return val[suflca[2]];
    if (i == k) return val[prelca[k - 1]];
    return val[lca(prelca[i - 1], suflca[i + 1])];
}
}  // namespace B
void solve() {
    cin >> n >> k;
    rep(i, 1, k) cin >> x[i];
    x[0] = x[1], x[k + 1] = x[k];
    rep(i, 1, n) cin >> A::val[i];
    rep(i, 2, n) {
        int f;
        cin >> f;
        A::e[f].push_back(i);
    }
    rep(i, 1, n) cin >> B::val[i];
    rep(i, 2, n) {
        int f;
        cin >> f;
        B::e[f].push_back(i);
    }
    A::build(), B::build();

    int ans = 0;
    rep(i, 1, k) {
        if (A::del(i) > B::del(i)) {
            ++ans;
        }
    }
    cout << ans;
}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    int t = 1;
    // cin >> t;
    rep(i, 1, t) solve();
}

J-Journey

题目链接

题目大意：

$N I O$ 和 $Des p r a d o$ 是好朋友，并且他们住在同一个城市。然而，每次 $N I O$ 去拜访 $Des p r a d o 2$ 的时候，总是会在等红灯这件事上花太多时间。 $N I O$ 对此十分沮丧。现在在城市里有 $n$ 个路口， $N I O$ 每次在十字路口直走、左转或者往回走，都需要等红灯，只有在路口右转才不用等红灯。

$N I O$ 讨厌等红灯，所以他想要知道需要等红灯的最少次数，你能帮他吗？

分析和思路：

若我们将右转的代价记为 $0$ ，其他转向记为 $1$ ，则从初始路径 $< s 1, s 2 >$ 到路径 $< t 1, t 2 >$ 的过程，相当于在一张边权全为 $0$ 和 $1$ 的无向图上求最短路。

经典例题参考算法进阶指南——电路维修。一般做法是双端队列 $BFS$ ，若边权是 $1$ ，则点入队的时候由队尾入队，若边权为 $0$ ，则点入队的时候由队首入队。这两种不同的入队方式对应的是广搜时队列的二段性。这里我们也可以直接用一个优先队列来进行最短路的求解，求解过程类似堆优化的 $D ijk s t r a$ 。

在本题，我们将路径抽象为点，我们每次到十字路口的时候，选择对应的路径，并在他们之间建一条边，并更新两点（路径）之间的距离（代价）。

参考代码：

#include <iostream>
#include <deque>
#define x first 
#define y second
using namespace std;
const int N = 5e5 + 10, INF = 0x3f3f3f3f;
typedef pair<int, int> PII;
int g[N][4];
int dist[N][4]; 
bool st[N][4];

int main() {
    ios::sync_with_stdio(false); 
    cin.tie(nullptr); cout.tie(nullptr);
    int n; cin >> n; 
    for(int i = 1; i <= n; i ++ ) for(int j = 0; j < 4; j ++ ) {
        cin >> g[i][j]; dist[i][j] = INF;
    }
    int s1, s2, t1, t2;
    cin >> s1 >> s2 >> t1 >> t2;
    
    deque<PII> q;
    q.push_front({s1, s2});
    
    for(int i = 0; i < 4; i ++ ) {
        if(g[s1][i] == s2) {dist[s1][i] = 0; break;}
    }

    while(q.size()) {
        PII t = q.front(); q.pop_front();
        int cur, x, y, distance;
        x = t.x; y = t.y; 
        for(int i = 0; i < 4; i ++ ) {
            if(g[x][i] == y) {cur = i; break;} 
        }
        distance = dist[x][cur];
        if(st[x][cur]) continue;
        st[x][cur] = true;
        for(int i =0; i < 4; i ++ )
            if(g[y][i] == x) {
                cur = (i + 1) % 4; break;
            }
        for(int i = 0; i < 4; i ++ ) {
            if(g[y][i] == 0) continue;
            int d = distance+ + (i != cur);
            if(d < dist[y][i]) {
                dist[y][i] = d;
                if(i != cur) q.push_back({y, g[y][i]});
                else q.push_front({y, g[y][i]});
            }
        }
    }
    for(int i = 0; i < 4; i ++ ) {
        if(g[t1][i] == t2) {
            if(dist[t1][i] == INF) cout << -1;
            else cout << dist[t1][i];
        }
    }
    return 0;
}