Problem: 2063C - Remove Exactly Two
Language: C++20 (GCC 13-64)


Submission (verdict: Wrong answer on test 2):
/* === INCLUDES === ---------------------------------------------------------- */
#include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;

/* === UTILITY === ----------------------------------------------------------- */
#ifdef _LOCAL_
#define SHOW(x)                                                                                                        \
        {                                                                                                              \
                cerr << "[" #x "]: " << (x) << "\n";                                                                   \
        }
#define SHOW_EACH(x)                                                                                                   \
        {                                                                                                              \
                bool _head = true;                                                                                     \
                cerr << "[" #x "]: {";                                                                                 \
                for (auto _iter : (x)) {                                                                               \
                        if (_head) {                                                                                   \
                                _head = false;                                                                         \
                        } else {                                                                                       \
                                cerr << ", ";                                                                          \
                        }                                                                                              \
                        cerr << _iter;                                                                                 \
                }                                                                                                      \
                cerr << "}" << "\n";                                                                                   \
        }
#define SHOW_RANGE(x, l, r)                                                                                            \
        {                                                                                                              \
                bool _head = true;                                                                                     \
                cerr << "[" #x "]: {";                                                                                 \
                for (auto _iter = (l); _iter <= (r); ++_iter) {                                                        \
                        if (_head) {                                                                                   \
                                _head = false;                                                                         \
                        } else {                                                                                       \
                                cerr << ", ";                                                                          \
                        }                                                                                              \
                        cerr << (x)[_iter];                                                                            \
                }                                                                                                      \
                cerr << "}" << "\n";                                                                                   \
        }
#else
#define SHOW(x)
#define SHOW_EACH(x)
#define SHOW_RANGE(x, l, r)
#endif    // _LOCAL_

/* === MACROS === -------------------------------------------------------------*/
#define FASTIO                                                                                                         \
        ios::sync_with_stdio(false);                                                                                   \
        cin.tie(0), cout.tie(0)
#define MULTICASE                                                                                                      \
        int _T;                                                                                                        \
        cin >> _T;                                                                                                     \
        while (_T--)
#define LL long long
#define IMAX 2147483647
#define LLMAX 9223372036854775807LL
#define endl "\n"

////////////////////////////////// ┏━━━━━━━━━┓ //////////////////////////////////
////////////////////////////////// ┣━╸ ┏━━━╸ ┃ //////////////////////////////////
////////////////////////////////// ┃ ┏━┻━━━━━┫ //////////////////////////////////
////////////////////////////////// ┃ ┣━━━━━╸ ┃ //////////////////////////////////
////////////////////////////////// ┃ ┃ ╺━━━━━┫ //////////////////////////////////
////////////////////////////////// ┣━┻━━━━━┳━┫ //////////////////////////////////
////////////////////////////////// ┃ ╻ ╻ ╺━┫ ┃ //////////////////////////////////
////////////////////////////////// ┣━╋━╋━┳━┫ ┃ //////////////////////////////////
////////////////////////////////// ┃ ╹ ╹ ┃ ┃ ┃ //////////////////////////////////
////////////////////////////////// ┃ ╻ ╻ ┃ ┃ ┃ //////////////////////////////////
////////////////////////////////// ┣━┻━┻━┻━┻━┫ //////////////////////////////////
////////////////////////////////// ┣━╸ ╺┳╸ ╺━┫ //////////////////////////////////
////////////////////////////////// ┣━╸ ╺┻╸ ╺━┫ //////////////////////////////////
////////////////////////////////// ┣━┳━┳━┳━┳━┫ //////////////////////////////////
////////////////////////////////// ┣━┛ ┗━┛ ┗━┫ //////////////////////////////////
////////////////////////////////// ┣━━━━━━━━━┫ //////////////////////////////////
////////////////////////////////// ┣╸ ╺━━━╸ ╺┫ //////////////////////////////////
////////////////////////////////// ┣━━━┓ ┏━━━┫ //////////////////////////////////
////////////////////////////////// ┃ ╻ ╹ ╹ ╻ ┃ //////////////////////////////////
////////////////////////////////// ┣━┻━━━━━┻━┫ //////////////////////////////////
////////////////////////////////// ┣━━━╸ ┏━━━┫ //////////////////////////////////
////////////////////////////////// ┃ ╺━━━┛ ╻ ┃ //////////////////////////////////
////////////////////////////////// ┗━━━━━━━┻━┛ //////////////////////////////////



int n;
vector<vector<int>> g;

vector<int> d1, d2;

bool dfs(int u, int fa)
{
        d1[u] = g[u].size() - 1;
        d2[u] = 0;
        bool self = true;
        for (auto v : g[u]) {
                if (v == fa) {
                        continue;
                }
                bool far = dfs(v, u);
                d2[u] = max(d2[u], (int)g[u].size() + d1[v] - far);
                if (d1[v] >= d1[u]) {
                        d1[u] = d1[v];
                        self = false;
                }
        }
        // SHOW(u)
        // SHOW(d1[u])
        // SHOW(d2[u])
        return self;
}

void ChromicChlorideHexahydrate()
{
        cin >> n;
        g.assign(n + 5, {});
        d1.assign(n + 5, 0);
        d2.assign(n + 5, 0);
        for (int i = 1; i <= n - 1; i++) {
                int u, v;
                cin >> u >> v;
                g[u].push_back(v);
                g[v].push_back(u);
        }
        dfs(1, -1);
        cout << d2[1] << endl;
}

signed main()
{
        FASTIO;
        MULTICASE ChromicChlorideHexahydrate();
}