Codeforces Grakn Forces 2020 G. Clusterization Counting (R2700)

めちゃ好きだけど、実装重い

問題へのリンク

問題概要

頂点の重み付き無向完全グラフが与えられる。各 に対して、

• 頂点集合を 個の互いに disjoint な集合に分割する方法であって
• どの同族辺 (両端点が同一のグループに属する辺) の重みも、どの異族辺 (両端点が異なるグループに属する辺) の重みより小さい

というものの個数を 998244353 で割ったあまりを求めよ。

制約

• 

考えたこと

一見すると bit DP とかが必要になるように見える問題。でもこういうのはなんらかの探索順序が綺麗に入るはず。たとえばあらかじめソートすることができて、その順序に区間ごとに区切ればいいとか...

今回はそこまで単純ではないが、まずは

• 最小全域木を考えたときに
• 各グループはその部分木になることが必要

ということがいえる。最小全域木 を作ったときに、仮に 上で互いに隣接していない頂点部分集合 があって条件を満たしたとする。このとき、 上の点 と 上の点 とを結ぶパス を考える。このとき問題の条件から「 ( はパス 上の任意の辺)」を満たす必要がある。しかしこれは が最小全域木であることに反する (最小全域木の最適性条件から)。

さらに、各グループが最小全域木の任意の部分木でよいわけではなく、Kruskal 法における Union-Find のマージ過程を考えたときに、その部分木の部分が一時的に「クリーク」になっている必要がある。

実装上は、Union-Find のマージ過程を表す木を作るときに、「マージという行為」に対応するノードを追加していくと良さそう。つまり、マージ過程が 回走るので、 個の頂点の木を構築していく。

木 DP へ

以上より問題は「木を 個に分割する方法であって、各グループが部分木となるもの」を数え上げる問題へと帰着された。適当に根を決めて木 DP する。

• dp[ v ][ k ] := 頂点 v を根とする部分木において、頂点 v に対応するクリークを 個に分割する方法の個数

とする。k の部分の更新も考えると一見 の計算量になりそうだが、「二乗の木 DP」によって になる (NTT で畳み込む方法もあり)。

コード

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

struct UnionFind {
    vector<int> par;
    vector<int> alt, num;
    
    UnionFind(int n) : par(n, -1), alt(n, -1), num(n, 0) { 
        for (int i = 0; i < n; ++i) alt[i] = i;
    }
    int root(int x) {
        if (par[x] < 0) return x;
        else return par[x] = root(par[x]);
    }
    
    bool issame(int x, int y) {
        return root(x) == root(y);
    }
    
    bool merge(int x, int y, int id = -1) {
        x = root(x); y = root(y);
        if (x == y) {
            num[x]++;
            return false;
        }
        if (par[x] > par[y]) swap(x, y); // merge technique
        num[x] += num[y] + 1;
        par[x] += par[y];
        par[y] = x;
        if (id != -1) alt[x] = id;
        return true;
    }
    
    int size(int x) {
        return -par[root(x)];
    }

    int id(int x) {
        return alt[root(x)];
    }

    bool iscl(int x) {
        x = root(x);
        int s = size(x);
        return num[x] == s * (s-1) / 2;
    }    
};

// modint
template<int MOD> struct Fp {
    long long val;
    constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
        if (val < 0) val += MOD;
    }
    constexpr int getmod() const { return MOD; }
    constexpr Fp operator - () const noexcept {
        return val ? MOD - val : 0;
    }
    constexpr Fp operator + (const Fp& r) const noexcept { return Fp(*this) += r; }
    constexpr Fp operator - (const Fp& r) const noexcept { return Fp(*this) -= r; }
    constexpr Fp operator * (const Fp& r) const noexcept { return Fp(*this) *= r; }
    constexpr Fp operator / (const Fp& r) const noexcept { return Fp(*this) /= r; }
    constexpr Fp& operator += (const Fp& r) noexcept {
        val += r.val;
        if (val >= MOD) val -= MOD;
        return *this;
    }
    constexpr Fp& operator -= (const Fp& r) noexcept {
        val -= r.val;
        if (val < 0) val += MOD;
        return *this;
    }
    constexpr Fp& operator *= (const Fp& r) noexcept {
        val = val * r.val % MOD;
        return *this;
    }
    constexpr Fp& operator /= (const Fp& r) noexcept {
        long long a = r.val, b = MOD, u = 1, v = 0;
        while (b) {
            long long t = a / b;
            a -= t * b, swap(a, b);
            u -= t * v, swap(u, v);
        }
        val = val * u % MOD;
        if (val < 0) val += MOD;
        return *this;
    }
    constexpr bool operator == (const Fp& r) const noexcept {
        return this->val == r.val;
    }
    constexpr bool operator != (const Fp& r) const noexcept {
        return this->val != r.val;
    }
    constexpr bool operator < (const Fp& r) const noexcept {
        return this->val < r.val;
    }
    friend constexpr istream& operator >> (istream &is, Fp<MOD>& x) noexcept {
        is >> x.val;
        x.val %= MOD;
        if (x.val < 0) x.val += MOD;
        return is;
    }
    friend constexpr ostream& operator << (ostream &os, const Fp<MOD>& x) noexcept {
        return os << x.val;
    }
    friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
        if (n == 0) return 1;
        auto t = modpow(a, n / 2);
        t = t * t;
        if (n & 1) t = t * a;
        return t;
    }
};

const int MOD = 998244353;
using mint = Fp<MOD>;
using pint = pair<int,int>;
using Edge = pair<long long,pint>;
using Tree = vector<vector<int>>;

vector<vector<mint>> dp;
void rec(const Tree &G, const vector<bool> &ok, int v) {
    if (G[v].empty()) {
        dp[v] = {0, 1};
        return;
    }
    for (auto c : G[v]) rec(G, ok, c);
    vector<mint> dp2(1, 1), ndp2;
    for (auto c : G[v]) {
        ndp2.assign(dp2.size() + dp[c].size(), 0);
        for (int i = 0; i < dp2.size(); ++i)
            for (int j = 0; j < dp[c].size(); ++j)
                ndp2[i+j] += dp2[i] * dp[c][j];
        while (ndp2.back() == 0) ndp2.pop_back();
        swap(dp2, ndp2);
    }
    if (ok[v]) dp2[1] += 1;
    dp[v] = dp2;
}

void solve() {
    // build tree
    int N;
    cin >> N;
    vector<Edge> edges;
    for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) {
        long long a; cin >> a;
        if (i >= j) continue;
        edges.push_back(Edge(a, pint(i, j)));
    }
    sort(edges.begin(), edges.end());
    Tree G(N*2 - 1);
    int iter = N;
    UnionFind uf(N);
    vector<bool> ok(N*2-1);
    for (int v = 0; v < N; ++v) ok[v] = true;
    for (auto e : edges) {
        int u = e.second.first, v = e.second.second;
        if (uf.issame(u, v)) uf.merge(u, v);
        else {
            G[iter].push_back(uf.id(u)), G[iter].push_back(uf.id(v));
            uf.merge(u, v, iter);
            ++iter;
        }
        u = uf.root(u);
        if (uf.iscl(u)) ok[uf.id(u)] = true;
    }

    // DP
    dp.assign(iter, vector<mint>());
    rec(G, ok, iter-1);
    for (int k = 1; k <= N; ++k) {
        if (k > 1) cout << " ";
        cout << dp[iter-1][k];
    }
    cout << endl;
}

int main() {
    cin.tie(0); 
    ios::sync_with_stdio(false);
    solve();
}