题目链接

题目

题目描述

Q国的监察院是一个神秘的组织。
这个组织掌握了整个帝国的地下力量，监察着Q国的每一个人。
监察院一共有N个成员，每一个成员都有且仅有1个直接上司，而他只听从其上直接司的命令。其中1号成员是监察院的院长，这个庞然大物的主人。
由于时代的进步，监察院议会决定升级组织的旧式通信器，安装最新的反侦测通信器。
他们拿出了M组线路方案，其中第i组线路方案可以用一个四元组(x[i]、y[i]、k[i]、w[i])描述，表示第x[i]号成员可以安装与y[i]号成员的直接通信线路，费用为w[i]；x[i]号成员的上司可以安装与y[i]号成员的上司的直接通信线路，费用为w[i]；x[i]号成员的上司的上司可以安装与y[i]号成员的上司的上司的直接通信线路，费用为w[i]； …… ；x[i]号成员的k[i] - 1级上司可以安装与y[i]号成员的k[i] - 1级上司的直接通信线路，费用为w[i]。（这k[i]条线路的费用独立计算）
如果一个集合内部的成员两两之间都可以通过直接或间接的通信线路进行通信，那么这个集合的所有成员可以成立一个特别行动组。
监察院想成立一个成员最多的特别行动组，同时他们想让安装线路的费用之和最小，
所以他们找到了Q国的天命者——你，请你帮助他们规划出最优的线路。

输入描述

第一行为2个正整数N、M。
第二行为N - 1个正整数L[i]，第i个正整数表示第i+1个成员的直接上司L[i]。
接下来M行每行四个正整数x[i]，y[i]，k[i]，w[i]。

输出描述

仅一行，为特别行动组成员人数的最大值和在此前提下安装线路的最小费用之和。

示例1

输入

5 3
1 1 2 2
5 4 3 10
1 3 1 5
2 4 2 3

输出

5 21

说明

设(u、v、w)表示一条u到v，费用为w的线路。
则一共有(5、4、10)、(2、2、10)、(1、1、10)、(1、3、5)、(2、4、3)、(1、2、3)共6条线路。
选择第1、4、5、6条线路，可以成立特别行动组{1、2、3、4、5}，费用之和为21

备注

对于100%的数据：
1 ≤ N、M ≤ 252501
1≤x[i]，y[i]，k[i]≤N，1≤L[i]≤i - 1，保证x[i]、y[i]号成员均至少有k[i]个上司，\(1≤w[i]≤10^9\) 。

题解

知识点：倍增，并查集。

这题的思路非常妙，是一个按批处理的最小生成树。由于给的边都是一批一批的，一个一个处理一定超时。但是，一批边可以通过边权、起边的两个端点、上升边数唯一确定，我们可以利用这个性质一批一批处理，就能省很多时间。

具体地说，可以设 \(e_i\) 表示有 \(2^i\) 条边的若干批边，随后我们将给定的每批边细分成 \(2\) 的幂次的若干批。例如一批边有 \(11\) 条，则可以分为 \(8,2,1\) 条边的批次，将其分别放在 \(e_3,e_1,e_0\) 即可。需要注意的是，起边端点也需要随之改动，因此还需要预处理向上跳跃的倍增。

然后，按边数从大到小遍历 \(e_i\) ，对边数相同的若干批边，采用类似最小生成树的做法，筛选留下的批次。直到处理完 \(e_0\) ，留在 \(e_0\) 的边就是我们需要的，即完成了按批处理的最小生成树。

其中，对于同一边数的若干批边，我们需要选出一些批次，使得连通性不变，但边权最小，类似最小生成树。因此按批次边的权重从小到大排列，用并查集维护连通性，类似kruskal算法。最后，留下的若干批次，我们需要继续细分，排除更多的边。例如， \(e_3\) 的处理完，留下的都是 \(2^3\) 边数的批次，需要细分成 \(2^2\) 存入 \(e_2\) 继续筛选。同样地，需要注意起边端点问题。

最终我们需要统计各个最小生成树的点数和边权和，选出连通点的数量最多的情况下边权和最小的答案。

时间复杂度 \(O(\log k(n + m(\log m +\log n)) + n\log n)\)

空间复杂度 \(O(m \log k + n \log n)\)

代码

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

struct Graph {
    struct edge {
        int v, nxt;
    };
    int idx;
    vector<int> h;
    vector<edge> e;

    Graph(int n = 0, int m = 0) { init(n, m); }

    void init(int n, int m) {
        idx = 0;
        h.assign(n + 1, 0);
        e.assign(m + 1, {});
    }

    void add(int u, int v) {
        e[++idx] = { v,h[u] };
        h[u] = idx;
    }
};

struct DSU {
    vector<int> fa;

    DSU(int n = 0) { init(n); }

    void init(int n) {
        fa.assign(n + 1, 0);
        iota(fa.begin(), fa.end(), 0);
    }

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

    bool same(int x, int y) { return find(x) == find(y); }

    void merge(int x, int y) { fa[find(x)] = find(y); }
};

const int N = 300000;
Graph g;

int f[27][N];
void dfs(int u, int fa) {
    f[0][u] = fa;
    for (int i = 1;i <= 20;i++)
        f[i][u] = f[i - 1][f[i - 1][u]];
    for (int i = g.h[u];i;i = g.e[i].nxt) {
        int v = g.e[i].v;
        dfs(v, u);
    }
}

struct node {
    int u, v, w;
    friend bool operator<(const node &a, const node &b) { return a.w < b.w; }
};
vector<node> e[27];


int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    g.init(n, n);
    for (int i = 2;i <= n;i++) {
        int u;
        cin >> u;
        g.add(u, i);
    }

    dfs(1, 0);

    for (int i = 1;i <= m;i++) {
        int u, v, k, w;
        cin >> u >> v >> k >> w;
        for (int i = 20;i >= 0;i--) {
            if (k & (1 << i)) {
                e[i].push_back({ u,v,w });
                u = f[i][u];
                v = f[i][v];
            }
        }
    }
    for (int i = 20;i >= 1;i--) {
        sort(e[i].begin(), e[i].end());
        DSU dsu(n);
        for (auto [u, v, w] : e[i]) {
            if (dsu.same(u, v)) continue;
            dsu.merge(u, v);
            e[i - 1].push_back({ u,v,w });
            e[i - 1].push_back({ f[i - 1][u],f[i - 1][v],w });
        }
    }
    sort(e[0].begin(), e[0].end());
    DSU dsu(n);
    vector<pair<int, ll>> node_ans(n + 1);
    for (auto [u, v, w] : e[0]) {
        if (dsu.same(u, v)) continue;
        dsu.merge(u, v);
        node_ans[dsu.find(u)].first++;
        node_ans[dsu.find(u)].second += w;
    }
    for (int i = 1;i <= n;i++) {
        if (dsu.find(i) != i) {
            node_ans[dsu.find(i)].first += node_ans[i].first;
            node_ans[dsu.find(i)].second += node_ans[i].second;
        }
    }
    vector<pair<int, ll>> ans;
    for (int i = 1;i <= n;i++) if (dsu.find(i) == i) ans.push_back(node_ans[i]);
    sort(ans.begin(), ans.end(), [&](pair<int, ll> a, pair<int, ll> b) {return a.first == b.first ? a.second < b.second : a.first>b.first;});
    cout << ans[0].first + 1 << ' ' << ans[0].second << '\n';
    return 0;
}