oj.uz

Submission #434683

# Submission time Handle Problem Language Result Execution time Memory
434683 2021-06-21T14:46:17 Z KoD Mousetrap (CEOI17_mousetrap) C++17
0 / 100
 1305 ms 68824 KB 
#include <bits/stdc++.h>

template <class T> using Vec = std::vector<T>;

template <class F> struct RecLambda : private F {
    explicit RecLambda(F&& f) : F(std::forward<F>(f)) {}
    template <class... Args> decltype(auto) operator() (Args&&... args) const {
        return F::operator()(*this, std::forward<Args>(args)...);
    }
};

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int N, T, M;
    std::cin >> N >> T >> M;
    T -= 1;
    M -= 1;
    Vec<Vec<int>> graph(N);
    for (int i = 0; i < N - 1; ++i) {
        int a, b;
        std::cin >> a >> b;
        a -= 1;
        b -= 1;
        graph[a].push_back(b);
        graph[b].push_back(a);
    }
    Vec<int> parent(N, -1);
    RecLambda([&](auto&& dfs, const int u) -> void {
        for (const int v : graph[u]) {
            if (parent[u] != v) {
                parent[v] = u;
                dfs(v);
            }
        }
    })(T);
    if (graph[M].size() == 1) {
        assert(false);
    }
    Vec<int> dp(N, -1);
    Vec<char> used(N);
    const auto down = RecLambda([&](auto&& dfs, const int u) -> int {
        if (dp[u] != -1) {
            return dp[u];
        }
        Vec<int> cand;
        for (const int v : graph[u]) {
            if (v != parent[u] and !used[v]) {
                cand.push_back(dfs(v));
            }
        } 
        std::sort(cand.rbegin(), cand.rend());
        if (cand.size() <= 1) {
            return dp[u] = (int) cand.size();
        }
        return dp[u] = cand[1] + (int) cand.size();
    });
    Vec<int> cut(N);
    RecLambda([&](auto&& dfs, const int u) -> void {
        for (const int v : graph[u]) {
            if (parent[u] != v) {
                cut[v] += cut[u];
                if (u != T) {
                    cut[v] += (int) graph[u].size() - 2;
                }
                dfs(v);
            }
        }
    })(T);
    std::cout << RecLambda([&](auto&& dfs, const int u) -> int {
        if (u == T) {
            return 0;
        }
        used[u] = true;
        int dmax = 0;
        for (const int v : graph[u]) {
            if (parent[u] != v and !used[v]) {
                dmax = std::max(dmax, down(v) + 1);
            }
        }
        return std::min(dmax + cut[u] + 2, std::max(down(u) + cut[u], dfs(parent[u]) + 1));
    })(M) << '\n';
    return 0;
}

Subtask #1
0 / 20.0

# Verdict Execution time Memory Grader output
1 Runtime error 1 ms 460 KB Execution killed with signal 6
2 Halted 0 ms 0 KB -

Subtask #2
0 / 25.0

# Verdict Execution time Memory Grader output
1 Correct 461 ms 67952 KB Output is correct
2 Correct 385 ms 61072 KB Output is correct
3 Correct 1305 ms 68824 KB Output is correct
4 Incorrect 613 ms 34600 KB Output isn't correct
5 Halted 0 ms 0 KB -

Subtask #3
0 / 20.0

# Verdict Execution time Memory Grader output
1 Runtime error 1 ms 460 KB Execution killed with signal 6
2 Halted 0 ms 0 KB -

Subtask #4
0 / 35.0

# Verdict Execution time Memory Grader output
1 Runtime error 1 ms 460 KB Execution killed with signal 6
2 Halted 0 ms 0 KB -