[SMOJ2074]RP路

最新推荐文章于 2024-09-13 16:31:05 发布

原创最新推荐文章于 2024-09-13 16:31:05 发布 · 343 阅读

0 ·

CC 4.0 BY-SA版权

解题报告同时被 3 个专栏收录

136 篇文章

订阅专栏

SMOJ

97 篇文章

订阅专栏

并查集

10 篇文章

订阅专栏

本文介绍了一种针对RP树中路径优化的问题，提出了两种解决方法。第一种是通过枚举和LCA算法来直接计算最优解，但时间复杂度较高。第二种则是通过对连通分量的分析和使用并查集来高效求解，达到了线性的时间复杂度。

图1 RP树示意图

明确这样的一条事实：在一棵有 $n$ 个结点的树中，总的路径数为 $C_n^2$ ，即 $\frac{n\times(n-1)}{2}$ 。

做法一：（我在考场上的写法）

首先考虑如何统计一棵树中的 RP 路数量。

不难发现，对于一条路径的起始点 $u$ 和 $v$ （令 $u$ 的深度 < $v$ 的深度），如果它们之间是祖先-后代关系，那么判断该路径是否为 RP 路的方法就是统计 $u$ 到 $v$ 的路径上是否有 RP 边；否则结点 $u$ 、 $v$ 有 LCA 结点 $k$ ，则可以转化为判断 $k$ 到 $u$ 的路径和 $k$ 到 $v$ 的路径上是否有 RP 边。因此可以记 $f_i$ 为根结点到 $i$ 的路径上 RP 边的数量（前缀和思想），就可以求出 LCA 之后方便地判断路径的种类，即在 $O(N^2)$ 时间内可以算出所有RP路数量。

于是不难得到一种暴力算法：枚举被改变的 RP 边，之后重复上述操作，取一个最小值。这种做法的优点是非常直观，缺点是效率低下。

时间复杂度： $O(N^3)$
期望得分：20%
参考代码：（由于暴力做法比较显然，不再添加注释）

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>

using namespace std;

const int MAXN = 1e3;

struct EDGE {
    int to, typ, next;
    bool b;
    EDGE (): to(0), typ(0), next(0), b(false) {}
} edges[MAXN << 1];

int N, M;
int par[MAXN], dep[MAXN], lca[MAXN][MAXN];
int p[MAXN];

int head[MAXN];
void addedge(int u, int v, int t) {
    edges[M].to = v;
    edges[M].typ = t;
    edges[M++].next = head[u];
    head[u] = M - 1;
}

void dfs1(int root, int depth, int pre) {
    for (int i = head[root]; i != -1; i = edges[i].next) {
        int v = edges[i].to;
        if (v == pre) continue;
        edges[i].b = true;
        par[v] = root; dep[v] = dep[root] + 1;
        dfs1(v, depth + 1, root);
    }
}

void dfs2(int root) {
    for (int i = head[root]; i != -1; i = edges[i].next)
        if (edges[i].b) {
            int v = edges[i].to;
            p[v] = p[root] + edges[i].typ;
            dfs2(v);
        }
}

bool isRPpath(int u, int v) {
    if (lca[u][v] == u) return p[v] - p[u];
    else if (lca[u][v] == v) return p[u] - p[v];
    else return (p[u] - p[lca[u][v]]) + (p[v] - p[lca[u][v]]);
}

int main(void) {
    freopen("2074.in", "r", stdin);
    freopen("2074.out", "w", stdout);
    scanf("%d", &N);
    memset(head, -1, sizeof head);
    for (int i = 1; i < N; i++) {
        int A, B, C; scanf("%d%d%d", &A, &B, &C);
        addedge(A, B, C);
        addedge(B, A, C);
    }

    dfs1(1, 0, 0);
    for (int i = 1; i < N; i++)
        for (int j = i + 1; j <= N; j++) {
            int u = i, v = j;
            while (dep[u] != dep[v])
                if (dep[u] > dep[v]) u = par[u]; else v = par[v];
            if (u == v)
                if (dep[i] < dep[j]) lca[i][j] = lca[j][i] = i; else lca[i][j] = lca[j][i] = j;
            else {
                while (u != v) { u = par[u]; v = par[v]; }
                lca[i][j] = lca[j][i] = u;
            }
        }

    memset(p, 0, sizeof p);
    int ans = 0; dfs2(1);
    for (int i = 1; i < N; i++)
        for (int j = i + 1; j <= N; j++) ans += isRPpath(i, j);
    for (int i = 0; i < M; i++) {
        if (!edges[i].b || !edges[i].typ) continue;
        edges[i].typ = 0;
        p[1] = 0; dfs2(1);
        int c = 0;
        for (int j = 1; j < N; j++)
            for (int k = j + 1; k <= N; k++)
                c += isRPpath(j, k);
        ans = min(ans, c);
        edges[i].typ = 1;
    }
    printf("%d\n", ans);
    return 0;
}

做法二：

我们不妨来分析题目的用意，最小化 RP 路的数量。显然一条路径要么是非 RP 路，要么是 RP 路。因此题目实际上等价于“最大化非 RP 路数量”。

非 RP 路有什么特征呢？如果多画几棵 RP 树进行计算，不难发现，可以将一些相邻的由非 RP 边连接的结点缩成一个“非 RP 连通分量”之后得到一棵新树，则非 RP 路一定是连接同一个连通分量内两个结点的路径，也就意味着如果某个连通分量内有 $k$ 个结点，这个连通分量对总的非RP路数量的贡献为 $\frac{k\times(k-1)}{2}$ 。

图2 连通分量

连通分量有什么意义呢？我们知道，每个连通分量都是极大的连通子图，不能再向里面加入结点，则连接连通分量之间的 RP 边都是“桥”，若将其变为非 RP 边，则两个连通分量之间的结点得到沟通，新增的每条非 RP 路，起点和终点分别在两个连通分量中，即如果两个连通分量中分别有 $k_1$ 和 $k_2$ 个结点，将会新增 $k_1\times k_2$ 条非RP路。既然要使非 RP 路数量最大，则要只需找到一条使 $k_1\times k_2$ 最大的“桥”即可。

求连通分量可以用 dfs 实现，也可以用并查集更方便。

时间复杂度： $O(N)$
期望得分：100%
参考代码：

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>

using namespace std;

const long long MAXN = 1e6 + 100;

long long N;
long long A[MAXN], B[MAXN], C[MAXN];
long long par[MAXN];

unsigned long long cnt[MAXN];

long long find(long long root) { return par[root] == root ? root : par[root] = find(par[root]); }

int main(void) {
    freopen("2074.in", "r", stdin);
    freopen("2074.out", "w", stdout);
    scanf("%d", &N);
    for (long long i = 1; i <= N; i++) par[i] = i;
    for (long long i = 1; i < N; i++) {
        scanf("%d%d%d", &A[i], &B[i], &C[i]);
        if (!C[i]) par[find(A[i])] = find(B[i]); //利用并查集，基于非 RP 性维护连通分量
    }

    memset(cnt, 0, sizeof cnt); 
    for (long long i = 1; i <= N; i++) ++cnt[find(i)]; //统计每个连通分量中结点个数

    unsigned long long ans = (long long)(N * (N - 1)) / 2; //设全部为 RP 路
    for (long long i = 1; i <= N; i++)
        ans -= ((long long)cnt[i] * (cnt[i] - 1)) / 2; //相应减去在同一连通分量内部的非 RP 路的数量
    if (!ans) { puts("0"); return 0; } //特判（其实不加也无所谓）

    unsigned long long k = 0;
    for (long long i = 1; i < N; i++) { //考虑被变为非 RP 边的 RP 边
        long long pa = find(A[i]), pb = find(B[i]);
        if (pa != pb && (long long)cnt[pa] * cnt[pb] > k) k = (long long)cnt[pa] * cnt[pb];
    }
//  prlong longf("%lld\n", ans - k);
    cout << ans - k << endl; //再减去最多能增加的两个连通分量之间的非 RP 路的数量
    return 0;
}