《信息学奥赛一本通·高手专项训练》集训 Day 10

luckydrawbox · 2022-08-10 19:41:48 · 个人记录

并查集

\color{#FFC116}\text{A. 最低热量}

题目

小明将学校中的所有地点编号为 1 到 n，其中起点被编号为 S，终点被编号为 T。

学校中有 m 条连接两个点的双向道路，保证从任意一个点可以通过道路到达学校中的所有点。每条路都有一个温度 t，及通过一条路所需的时间 c，在温度为 t 的路径跑单位时间，就会使她的热量增加 t。

在经过的所有道路中最高温度最低的前提下，使小明到达终点时的热量最低（从起点出发时，小明的热量为 0），输出此时小明经过路径的最高温度和小明到达终点时的热量。

题解

我们先考虑前提——最高温度最低，但必须满足 S 和 T 是联通的，于是我们可以枚举最高温度，把新符合条件的边加进来，用并查集维护其连通性，知道找到最小的最高温度。

然后直接跑最短路求答案即可。

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;
long long read() {
    long long x = 0, f = 1;
    char ch = getchar();
    while (!isdigit(ch)) {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (isdigit(ch)) {
        x = x * 10 + ch - 48;
        ch = getchar();
    }
    return x * f;
}
void write(long long x) {
    if (x < 0)
        putchar('-'), x = -x;
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
}
const int N = 5e5 + 10, M = 1e6 + 10;
int n, m, S, T, l, r;
int head[N], ver[M << 1], nxt[M << 1], te[M << 1], tot = 1;
ll ce[M << 1], d[N], v[N], ans;
int fa[N];
vector<int> e[N];
int get(int x) { return fa[x] == x ? x : fa[x] = get(fa[x]); }
void add(int a, int b, int t, ll c) {
    ver[++tot] = b;
    te[tot] = t;
    ce[tot] = c;
    nxt[tot] = head[a];
    head[a] = tot;
}
void Dijkstra(int mid) {
    memset(d, 0x3f, sizeof(d));
    memset(v, 0, sizeof(v));
    priority_queue<pair<ll, int> > q;
    q.push(make_pair(0, S));
    d[S] = 0;
    while (q.size()) {
        int x = q.top().second;
        q.pop();
        if (v[x])
            continue;
        v[x] = 1;
        for (int i = head[x]; i; i = nxt[i]) {
            if (te[i] > mid)
                continue;
            int y = ver[i];
            ll cost = (ll)te[i] * ce[i];
            if (d[y] > d[x] + cost) {
                d[y] = d[x] + cost;
                q.push(make_pair(-d[y], y));
            }
        }
    }
    ans = d[T];
}
int main() {
    freopen("running.in", "r", stdin);
    freopen("running.out", "w", stdout);
    n = read();
    m = read();
    for (int i = 1; i <= n; i++) fa[i] = i;
    for (int i = 1; i <= m; i++) {
        int a, b, t;
        ll c;
        a = read();
        b = read();
        t = read();
        c = read();
        add(a, b, t, c);
        add(b, a, t, c);
        r = max(r, t);
        e[t].push_back(tot);
    }
    S = read();
    T = read();
    for (l = 0; l <= r; l++) {
        for (int j = 0; j < e[l].size(); j++) {
            fa[get(ver[e[l][j]])] = get(ver[e[l][j] ^ 1]);
        }
        if (get(S) == get(T))
            break;
    }
    Dijkstra(l);
    write(l);
    putchar(' ');
    write(ans);
    return 0;
}

\color{#52C41A}\text{B. 一道树论}

题目

小 W 现在有一个点集 S 和一颗树，树上有 n 个点和 n-1 条有边权的无向边。

但是小 W 很好奇，如果他想要断掉一些边，使得点集 S 内的点两两不连通，怎么做才能使要断掉的边的边权和最小呢？

他把这个问题丢给了你，想让你来回答，你只用告诉他要断的边的边权和是多少即可。

但他又觉得太简单了，所以他会一个个把 S 这些点以某个顺序插入 S 中（初始 S 为空），你要在每次插入后都回答他这个问题。

题解

删除边不好维护，我们可以把顺序倒过来改成加边，用并查集维护点的连通性。

为了使删除的边的边权和最小，反过来就要使加入的边的边权和最大，因此将边从大到小排序，逐条考虑。

对于一条要加入的边 u\leftrightarrow v，我们考虑它最晚得在原序中什么时候加入，因为加入后集合 V_u,V_v 就连通了，所以他最晚加入的时间就是两个集合中最早被加入到集合 S 的点被加入的时间的最大值。

最后通过边加入的时间计算答案即可。

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;
long long read() {
    long long x = 0, f = 1;
    char ch = getchar();
    while (!isdigit(ch)) {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (isdigit(ch)) {
        x = x * 10 + ch - 48;
        ch = getchar();
    }
    return x * f;
}
void write(long long x) {
    if (x < 0)
        putchar('-'), x = -x;
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
}
const int N = 5e5 + 10;
int n, a[N], fa[N], ti[N], d[N], mx[N];
int head[N], ver[N << 1], nxt[N << 1], v[N << 1], tim[N << 1], tot = 1;
ll edge[N << 1], ans[N];
int get(int x) { return fa[x] == x ? x : fa[x] = get(fa[x]); }
void add(int x, int y, ll z) {
    ver[++tot] = y;
    edge[tot] = z;
    nxt[tot] = head[x];
    head[x] = tot;
}
bool cmp(int x, int y) { return edge[2 * x] > edge[2 * y]; }
int main() {
    freopen("tree.in", "r", stdin);
    freopen("tree.out", "w", stdout);
    n = read();
    for (int i = 1; i < n; i++) {
        int x, y;
        ll z;
        x = read();
        y = read();
        z = read();
        add(x, y, z);
        add(y, x, z);
    }
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        ti[a[i]] = i;
        fa[i] = i;
        d[i] = i;
    }
    sort(d + 1, d + n, cmp);
    for (int i = 1; i < n; i++) {
        int u = get(ver[d[i] * 2]), v = get(ver[d[i] * 2 + 1]);
        tim[d[i]] = max(ti[u], ti[v]);
        ti[u] = min(ti[u], ti[v]);
        fa[v] = u;
        ans[tim[d[i]]] += edge[d[i] * 2];
    }
    for (int i = 1; i <= n; i++) {
        ans[i] += ans[i - 1];
        write(ans[i]);
        putchar('\n');
    }
    return 0;
}

\color{#52C41A}\text{C. 树上除法}

题目

给出一棵包含 n 个点的树，每条边有一个权值。你需要维护这棵树，共 Q 次操作，操作有两种：

\color{#52C41A}\text{A. 路径统计}

题目

给出一个包含 n 个点 m 条边的无向连通图，有如下定义：

• 定义一条路径的价值为路径上最小边的权值。
• 定义 \text{dist}(i,j) 为起点为 i，终点为 j 的所有路径中，价值最大的路径的价值。

现在，给出一个 k，请你求出第 k 大的 \text{dist}(i,j)。

题解

为了使路径价值最大，我们求该图的最大生成树，建出其 \text{Kruskal} 重构树，重构树里任意两个子节点的 \text{lca} 都是这两点间路径的最小边的权值，即 \text{dist}(i,j)，按顺序累计对数知道第 k 大即可。

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;
long long read() {
    long long x = 0, f = 1;
    char ch = getchar();
    while (!isdigit(ch)) {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (isdigit(ch)) {
        x = x * 10 + ch - 48;
        ch = getchar();
    }
    return x * f;
}
void write(long long x) {
    if (x < 0)
        putchar('-'), x = -x;
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
}
const int N = 2e5 + 10, M = 4e5 + 10;
int n, m, fa[N], tot, dist[N];
int h1[N], v1[M << 1], n1[M << 1], e1[M << 1], t1 = 1;
ll k, sl[N], sr[N], sze[N];
void add1(int x, int y, int z) {
    v1[++t1] = y;
    e1[t1] = z;
    n1[t1] = h1[x];
    h1[x] = t1;
}
void init() {
    for (int i = 1; i <= 2 * n; i++) fa[i] = i;
    for (int i = 1; i <= n; i++) sze[i] = 1;
}
int get(int x) { return fa[x] == x ? x : fa[x] = get(fa[x]); }
struct Kruskal_rebuild {
    pair<int, pair<int, int> > a[M];
    int m;
    void ask(int n) {
        m = 0;
        tot = n;
        init();
        for (int i = 1; i <= n; i++) {
            for (int j = h1[i]; j; j = n1[j]) {
                int y = v1[j], z = e1[j];
                if (i < y)
                    a[++m] = (make_pair(z, make_pair(i, y)));
            }
        }
        sort(a + 1, a + m + 1);
        for (int i = 1; i <= m; i++) {
            int u = a[i].second.first;
            int v = a[i].second.second;
            if (get(u) != get(v)) {
                int w = ++tot;
                sze[w] = sze[get(u)] + sze[get(v)];
                sl[w] = sze[get(u)];
                sr[w] = sze[get(v)];
                fa[get(u)] = w;
                fa[get(v)] = w;
                dist[w] = -a[i].first;
            }
        }
    }
} tu;
int main() {
    freopen("path.in", "r", stdin);
    freopen("path.out", "w", stdout);
    n = read();
    m = read();
    k = ((ll)n) * ((ll)n - 1) / 2 - read();
    for (int i = 1; i <= m; i++) {
        int x, y, z;
        x = read();
        y = read();
        z = -read();
        add1(x, y, z);
        add1(y, x, z);
    }
    tu.ask(n);
    for (int i = tot; i > n; i--) {
        k -= (ll)sl[i] * (ll)sr[i];
        if (k < 0) {
            cout << dist[i];
            return 0;
        }
    }
    return 0;
}

\color{#3498DB}\text{B. 黑白之树}

题目

给出一个包含 n 个点 m 条边的无向带权连通图，点的编号为 0\sim n-1，每条边是黑色或白色。

请你求一棵最小权的恰好有 k 条白色边的生成树。题目保证有解。

题解

P2619 [国家集训队]Tree I

设 \text{g}(x) 表示恰好选 x 条白边得到的最小生成树的权值，显然这是一个下凸包，因为一定存在最优的一个 x_0，对于任意 x_1<x_0<x_2，有 \text{g}(x_1)\le \text{g}(x_0),\text{g}(x_2)\le \text{g}(x_0)。这满足 \text{wqs} 二分的条件，于是我们可以二分白点权值的变化值，即斜率，用 \text{Kruskal} 求出其去这个下凸包的切点，可得到相应的 k'，再选择二分的边界变化即可。

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;
long long read() {
    long long x = 0, f = 1;
    char ch = getchar();
    while (!isdigit(ch)) {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (isdigit(ch)) {
        x = x * 10 + ch - 48;
        ch = getchar();
    }
    return x * f;
}
void write(long long x) {
    if (x < 0)
        putchar('-'), x = -x;
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
}
const int N = 5e4 + 10, M = 1e5 + 10;
int n, m, k, fa[N], ans;
int head[N], ver[M << 1], nxt[M << 1], col[M << 1], edge[M << 1], tot;
void add(int x, int y, int c, int z) {
    ver[++tot] = y;
    col[tot] = c;
    edge[tot] = z;
    nxt[tot] = head[x];
    head[x] = tot;
}
void init() {
    for (int i = 1; i <= n; i++) fa[i] = i;
}
int get(int x) { return fa[x] == x ? x : fa[x] = get(fa[x]); }
void merge(int x, int y) { fa[get(x)] = get(y); }
struct Kruskal {
    pair<pair<int, int>, pair<int, int> > a[M];
    int m, ans, cnt;
    void ask(int n, int mid) {
        m = ans = cnt = 0;
        init();
        for (int i = 1; i <= n; i++) {
            for (int j = head[i]; j; j = nxt[j]) {
                int y = ver[j], c = col[j], z = edge[j];
                if (i < y)
                    a[++m] = (make_pair(make_pair(z + c * mid, c), make_pair(i, y)));
            }
        }
        sort(a + 1, a + m + 1);
        for (int i = 1; i <= m; i++) {
            int u = a[i].second.first;
            int v = a[i].second.second;
            if (get(u) != get(v)) {
                merge(u, v);
                cnt += a[i].first.second;
                ans += a[i].first.first;
            }
        }
    }
} tu;
int main() {
    freopen("tree.in", "r", stdin);
    freopen("tree.out", "w", stdout);
    n = read();
    m = read();
    k = read();
    for (int i = 1; i <= m; i++) {
        int x, y, c, z;
        x = read() + 1;
        y = read() + 1;
        z = read();
        c = 1 - read();
        add(x, y, c, z);
        add(y, x, c, z);
    }
    int l = -101, r = 101;
    while (l < r) {
        int mid = (l + r) >> 1;
        tu.ask(n, mid);
        if (tu.cnt <= k) {
            ans = tu.ans - k * mid;
            r = mid;
        } else
            l = mid + 1;
    }
    cout << ans << endl;
    return 0;
}

\color{#3498DB}\text{C. 生成树约数}

题目

给出一个包含 n 个点 m 条边的无向连通图，定义一个生成树的权值为该生成树上所有边权的最大公约数，请你求出该图中所有生成树权值的最小公倍数。

题解

如果我们把所有边权都唯一分解，那么可以发现每个质数对答案的贡献是互不干预的，于是我们可以对每个质数分开计算，这样，公约数和公倍数的计算就变成了对质数因子个数的取 \min 和 \max。

那么对于质数 p 来说，原图的所有生成树的权值的最小公倍数就为原图的最大瓶颈生成树的权值最小的点的权值，注意这里的权值已改为 p 因子的个数。

而最大生成树一定是最大瓶颈生成树，所以对于每个质数求相应的最大生成树再计算贡献即可。

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;
long long read() {
    long long x = 0, f = 1;
    char ch = getchar();
    while (!isdigit(ch)) {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (isdigit(ch)) {
        x = x * 10 + ch - 48;
        ch = getchar();
    }
    return x * f;
}
void write(long long x) {
    if (x < 0)
        putchar('-'), x = -x;
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
}
const int N = 1e3 + 10, M = 1e5 + 10;
int n, m, fa[N];
vector<pair<ll, pair<int, int> > > e[M];
ll np, prime[M], fac[M], ans = 1;
int get(int x) { return fa[x] == x ? x : fa[x] = get(fa[x]); }
void sieve() {
    for (int i = 2; i < (1 << 15); i++) {
        if (!fac[i]) {
            fac[i] = i;
            prime[++np] = i;
        }
        for (int j = 1; j <= np; j++) {
            if (prime[j] > fac[i] || prime[j] * i + 1 > (1 << 15))
                break;
            fac[prime[j] * i] = prime[j];
        }
    }
}
ll qmi(ll a, ll b) {
    ll ans = 1;
    while (b) {
        if (b & 1)
            ans *= a;
        a *= a;
        b >>= 1;
    }
    return ans;
}
struct Kruskal {
    int m;
    void ask(int n, ll y) {
        m = 0;
        for (int i = 1; i <= n; i++) {
            fa[i] = i;
        }
        sort(e[prime[y]].begin(), e[prime[y]].end());
        for (int i = 0; i < e[prime[y]].size(); i++) {
            int u = e[prime[y]][i].second.first;
            int v = e[prime[y]][i].second.second;
            if (get(u) != get(v)) {
                fa[get(u)] = get(v);
                m++;
                if (m == n - 1) {
                    ans *= qmi(prime[y], -e[prime[y]][i].first);
                    break;
                }
            }
        }
    }
} tu;
int main() {
    freopen("divisor.in", "r", stdin);
    freopen("divisor.out", "w", stdout);
    n = read();
    m = read();
    sieve();
    for (int i = 1; i <= m; i++) {
        int x, y;
        ll z;
        x = read();
        y = read();
        z = read();
        for (ll j = 1; prime[j] * prime[j] <= z; j++)
            if (z % prime[j] == 0) {
                ll cnt = 0;
                while (z % prime[j] == 0) {
                    z /= prime[j];
                    cnt++;
                }
                e[prime[j]].push_back(make_pair(-cnt, make_pair(x, y)));
            }
        if (z > 1)
            e[z].push_back(make_pair(-1, make_pair(x, y)));
    }
    for (int i = 1; i <= np; i++) tu.ask(n, i);
    write(ans);
    return 0;
}