結果

問題 No.1976 Cut then Connect
ユーザー ForestedForested
提出日時 2022-06-10 22:25:45
言語 C++17
(gcc 13.2.0 + boost 1.83.0)
結果
AC  
実行時間 127 ms / 2,000 ms
コード長 8,564 bytes
コンパイル時間 1,660 ms
コンパイル使用メモリ 158,408 KB
実行使用メモリ 26,776 KB
最終ジャッジ日時 2023-08-16 02:40:35
合計ジャッジ時間 4,487 ms
ジャッジサーバーID
（参考情報） 		judge15 / judge13
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
4,380 KB
testcase_01 AC 2 ms
4,376 KB
testcase_02 AC 121 ms
25,460 KB
testcase_03 AC 58 ms
16,308 KB
testcase_04 AC 20 ms
7,900 KB
testcase_05 AC 51 ms
14,812 KB
testcase_06 AC 91 ms
20,712 KB
testcase_07 AC 52 ms
14,948 KB
testcase_08 AC 127 ms
26,776 KB
testcase_09 AC 105 ms
23,132 KB
testcase_10 AC 25 ms
8,924 KB
testcase_11 AC 124 ms
26,292 KB
testcase_12 AC 4 ms
4,376 KB
testcase_13 AC 93 ms
20,624 KB
testcase_14 AC 74 ms
19,372 KB
testcase_15 AC 75 ms
18,528 KB
testcase_16 AC 112 ms
24,456 KB
testcase_17 AC 32 ms
10,980 KB
testcase_18 AC 7 ms
4,836 KB
testcase_19 AC 84 ms
20,456 KB
testcase_20 AC 125 ms
26,428 KB
testcase_21 AC 65 ms
17,244 KB
testcase_22 AC 2 ms
4,380 KB
testcase_23 AC 2 ms
4,376 KB
testcase_24 AC 1 ms
4,380 KB
testcase_25 AC 2 ms
4,376 KB
testcase_26 AC 1 ms
4,376 KB
testcase_27 AC 1 ms
4,376 KB
testcase_28 AC 1 ms
4,376 KB
testcase_29 AC 2 ms
4,376 KB
testcase_30 AC 2 ms
4,376 KB
testcase_31 AC 1 ms
4,376 KB
testcase_32 AC 1 ms
4,380 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#ifndef LOCAL
#define FAST_IO
#endif

// ===== template.hpp =====
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#define OVERRIDE(a, b, c, d, ...) d
#define REP2(i, n) for (i32 i = 0; i < (i32) (n); ++i)
#define REP3(i, m, n) for (i32 i = (i32) (m); i < (i32) (n); ++i)
#define REP(...) OVERRIDE(__VA_ARGS__, REP3, REP2)(__VA_ARGS__)
#define PER(i, n) for (i32 i = (i32) (n) - 1; i >= 0; --i)
#define ALL(x) begin(x), end(x)

using namespace std;

using u32 = unsigned int;
using u64 = unsigned long long;
using u128 = __uint128_t;
using i32 = signed int;
using i64 = signed long long;
using i128 = __int128_t;
using f64 = double;
using f80 = long double;

template <typename T>
using Vec = vector<T>;

template <typename T>
bool chmin(T &x, const T &y) {
    if (x > y) {
        x = y;
        return true;
    }
    return false;
}
template <typename T>
bool chmax(T &x, const T &y) {
    if (x < y) {
        x = y;
        return true;
    }
    return false;
}

istream &operator>>(istream &is, i128 &x) {
    i64 v;
    is >> v;
    x = v;
    return is;
}
ostream &operator<<(ostream &os, i128 x) {
    os << (i64) x;
    return os;
}
istream &operator>>(istream &is, u128 &x) {
    u64 v;
    is >> v;
    x = v;
    return is;
}
ostream &operator<<(ostream &os, u128 x) {
    os << (u64) x;
    return os;
}

template <typename F, typename Comp = less<>>
Vec<i32> sort_index(i32 n, F f, Comp comp = Comp()) {
    Vec<i32> idx(n);
    iota(ALL(idx), 0);
    sort(ALL(idx), [&](i32 i, i32 j) -> bool {
        return comp(f(i), f(j));
    });
    return idx;
}

[[maybe_unused]] constexpr i32 INF = 1000000100;
[[maybe_unused]] constexpr i64 INF64 = 3000000000000000100;

#ifdef FAST_IO
__attribute__((constructor)) void fast_io() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(10);
}
#endif
// ===== template.hpp =====

#ifdef DEBUGF
#include  "cpl/template/debug.hpp"
#else
#define DBG(x) (void) 0
#endif

// ===== graph.hpp =====

#include <utility>
#include <vector>
#include <numeric>
#include <cassert>

template <typename Edge>
class Graph {
    std::vector<std::vector<Edge>> edges;

public:
    Graph() : edges() {}
    Graph(int v) : edges(v) {
        assert(v >= 0);
    }
    
    std::vector<int> add_vertices(int n) {
        int v = (int) edges.size();
        std::vector<int> idx(n);
        std::iota(idx.begin(), idx.end(), v);
        edges.resize(edges.size() + n);
        return idx;
    }

    template <typename... T>
    void add_directed_edge(int from, int to, T &&...val) {
        assert(from >= 0 && from < (int) edges.size());
        assert(to >= 0 && to < (int) edges.size());
        edges[from].emplace_back(Edge(to, std::forward<T>(val)...));
    }

    template <typename... T>
    void add_undirected_edge(int u, int v, const T &...val) {
        assert(u >= 0 && u < (int) edges.size());
        assert(v >= 0 && v < (int) edges.size());
        edges[u].emplace_back(Edge(v, val...));
        edges[v].emplace_back(Edge(u, val...));
    }

    int size() const {
        return (int) edges.size();
    }

    const std::vector<Edge> &operator[](int v) const {
        assert(v >= 0 && v < (int) edges.size());
        return edges[v];
    }

    std::vector<Edge> &operator[](int v) {
        assert(v >= 0 && v < (int) edges.size());
        return edges[v];
    }
};

struct UnweightedEdge {
    int to;

    UnweightedEdge(int t) : to(t) {}
    
    explicit operator int() const {
        return to;
    }

    using Weight = std::size_t;
    Weight weight() const {
        return 1;
    }
};

template <typename T>
struct WeightedEdge {
    int to;
    T wt;

    WeightedEdge(int t, const T &w) : to(t), wt(w) {}

    explicit operator int() const {
        return to;
    }

    using Weight = T;
    Weight weight() const {
        return wt;
    }
};

// ===== graph.hpp =====
// ===== rerooting.hpp =====

#include <optional>
#include <queue>
#include <utility>
#include <vector>

template <typename G, typename T, typename Apply, typename Merge>
T rerooting_sub1(
    const G &g,
    const T &id,
    const Apply &ap,
    const Merge &me,
    int v,
    int p,
    std::vector<std::vector<std::optional<T>>> &dp) {
    T acc = id;
    for (int i = 0; i < (int) g[v].size(); ++i) {
        if ((int) g[v][i] != p) {
            T val = rerooting_sub1(g, id, ap, me, (int) g[v][i], v, dp);
            dp[v][i] = ap(val, v, g[v][i]);
            acc = me(acc, *dp[v][i]);
        }
    }
    return acc;
}

template <typename G, typename T, typename Apply, typename Merge>
void rerooting_sub2(
    const G &g,
    const T &id,
    const Apply &ap,
    const Merge &me,
    int root,
    std::vector<std::vector<std::optional<T>>> &dp) {
    std::queue<std::pair<int, T>> que;
    que.emplace(root, id);
    while (!que.empty()) {
        auto [v, val] = que.front();
        que.pop();
        std::vector<T> acc_l(g[v].size() + 1);
        acc_l[0] = id;
        int emp_idx = -1;
        for (int i = 0; i < (int) g[v].size(); ++i) {
            if (!(bool) dp[v][i]) {
                dp[v][i] = ap(val, v, g[v][i]);
                emp_idx = i;
            }
            acc_l[i + 1] = me(acc_l[i], *dp[v][i]);
        }
        T acc_r = id;
        for (int i = (int) g[v].size() - 1; i >= 0; --i) {
            if (i != emp_idx) {
                que.emplace((int) g[v][i], me(acc_l[i], acc_r));
            }
            acc_r = me(*dp[v][i], acc_r);
        }
    }
}

// Apply: Fn(T, int, E) -> T
// Merge: Fn(T, T) -> T
template <typename G, typename T, typename Apply, typename Merge>
std::vector<T>
rerooting(const G &g, const T &id, const Apply &ap, const Merge &me) {
    std::vector<std::vector<std::optional<T>>> dp(g.size());
    for (int i = 0; i < (int) g.size(); ++i) {
        dp[i].resize(g[i].size(), std::nullopt);
    }
    rerooting_sub1(g, id, ap, me, 0, 0, dp);
    rerooting_sub2(g, id, ap, me, 0, dp);
    std::vector<T> buf(g.size(), id);
    for (int i = 0; i < (int) g.size(); ++i) {
        for (std::optional<T> &val : dp[i]) {
            buf[i] = me(buf[i], std::move(*val));
        }
    }
    return buf;
}

template <typename G, typename T, typename Apply, typename Merge>
std::vector<std::vector<T>>
rerooting_raw(const G &g, const T &id, const Apply &ap, const Merge &me) {
    std::vector<std::vector<std::optional<T>>> dp(g.size());
    for (int i = 0; i < (int) g.size(); ++i) {
        dp[i].resize(g[i].size(), std::nullopt);
    }
    rerooting_sub1(g, id, ap, me, 0, 0, dp);
    rerooting_sub2(g, id, ap, me, 0, dp);
    std::vector<std::vector<T>> buf(g.size());
    for (int i = 0; i < (int) g.size(); ++i) {
        buf[i].reserve(g[i].size());
        for (const std::optional<T> &val : dp[i]) {
            buf[i].emplace_back(*val);
        }
    }
    return buf;
}
// ===== rerooting.hpp =====

int main() {
    i32 n;
    cin >> n;
    Graph<i32> g(n);
    map<pair<i32, i32>, pair<i32, i32>> edge_id;
    REP(e, n - 1) {
        i32 u, v;
        cin >> u >> v;
        --u;
        --v;
        edge_id[pair<i32, i32>(u, v)] = pair<i32, i32>(g[u].size(), g[v].size());
        g.add_undirected_edge(u, v);
    }
    
    using Value = pair<i32, i32>;
    const Value id(0, 0);
    const auto me = [](const Value &x, const Value &y) -> Value {
        if (x.first == -1) {
            return y;
        } else if (y.first == -1) {
            return x;
        } else {
            return Value(max(x.first, y.first), max({x.second, y.second, x.first + y.first}));
        }
    };
    const auto ap = [](Value x, i32 v, i32 e) -> Value {
        if (x.first == -1) {
            return x;
        } else {
            return Value(x.first + 1, x.second);
        }
    };
    
    Vec<Vec<Value>> dp = rerooting_raw(g, id, ap, me);
    
    i32 ans = INF;
    for (auto [e, id] : edge_id) {
        Value comp0 = dp[e.first][id.first];
        Value comp1 = dp[e.second][id.second];
        DBG(e.first);
        DBG(e.second);
        DBG(comp0.first);
        DBG(comp0.second);
        DBG(comp1.first);
        DBG(comp1.second);
        chmin(ans, max({comp0.second, comp1.second, (comp1.second + 1) / 2 + (comp0.second + 1) / 2 + 1}));
    }
    cout << ans << '\n';
}
0