Problem: 2063C - Remove Exactly Two
Language: C++17 (GCC 7-32)


Submission (verdict: Wrong answer on test 2):
#include <bits/stdc++.h>
using namespace std;

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define ll long long int
#define ull unsigned long long int

#define M1 1000000007
#define M2 998244353
#define nl "\n"

template<class T> using ordered_set = __gnu_pbds::tree<T, __gnu_pbds::null_type, less<T>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>;
template<class T> using ordered_multiset = __gnu_pbds::tree<T, __gnu_pbds::null_type, less_equal<T>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>;

template<class T> using reverse_ordered_set = __gnu_pbds::tree<T, __gnu_pbds::null_type, greater<T>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>;
template<class T> using reverse_ordered_multiset = __gnu_pbds::tree<T, __gnu_pbds::null_type, greater_equal<T>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>;

// A.find_by_order(a)     Iterator to the first element of array A, where (Ai=a)
// A.order_of_key(a)      Number of elements type(less/greater) than a

ll binExp(ll x, ll n, ll m){ ll ans = 1; while (n) { if (n & 1) ans = ans * x % m; x = x * x % m; n >>= 1; } return ans;}
ll modAdd(ll a, ll b, ll m){ return (a % m + b % m) % m; }
ll modSub(ll a, ll b, ll m){ return ((a % m - b % m) + m) % m; }
ll modMul(ll a, ll b, ll m){ return (a % m * b % m) % m; }
ll modInverse(ll A, ll m){ return binExp(A, m - 2, m); }
ll modDiv(ll a, ll b, ll m) { return modMul(a % m, modInverse(b % m, m), m) % m ;}
ll fact(ll n, ll m){ if (n == 0) return 1; ll ans = 1; for (ll i = 2; i <= n; i++) ans = modMul(ans, i, m); return ans; }
ll fact(ll n){ if (n == 0) return 1; ll ans = 1; for (ll i = 2; i <= n; i++) ans *= i; return ans; }
string toBinary(ll n){ string b = ""; for (ll i = 59; i >= 0; i--) { ll k = n >> i; if (k & 1) b += '1'; else b += '0'; } return b; }
ll toDecimal(string &s) { ll ans = 0; vector<ll> pow(60, 1); for (int i = 1; i < 60; i++) pow[i] = pow[i-1] * 2; for (ll i = 59; i >= 0; i--) { if (s[i] == '1') ans += pow[59 - i]; } return ans; }
void computeFactors(ll n, vector<ll> &f){ for (ll i = 1; i <= sqrt(n); i++) { if(n % i == 0){ f.push_back(i); if(i != (n / i)) f.push_back(n / i); }}}

class DSU{
    vector<ll> size;
    vector<ll> par;

public:
    DSU(ll n){
        size.resize(n, 1);
        par.resize(n);
        for (int i = 0; i < n; i++)
            par[i] = i;
    }

    ll findUParent(ll x){
        if(x == par[x])
            return x;
        par[x] = findUParent(par[x]);
        return par[x];
    }

    void makeUnion(ll a, ll b){
        ll parentA = findUParent(a);
        ll parentB = findUParent(b);
        if(parentA != parentB){
            if(size[parentA] < size[parentB]){
                par[parentA] = parentB;
                size[parentB] += size[parentA];
            }else{
                par[parentB] = parentA;
                size[parentA] += size[parentB];
            }
        }
    }
};

ll solve(ll t, ll T)
{
    ll n;
    cin >> n;
    
    vector<vector<ll>> adj(n);
    vector<ll> degree(n, 0);
    ll a, b;
    for (int i = 0; i < (n-1); i++){
        cin >> a >> b;
        a--;
        b--;
        adj[a].push_back(b);
        adj[b].push_back(a);
        degree[a]++;
        degree[b]++;
    }

    if(n == 2){
        cout << 0 << nl;
        return 0;
    }

    vector<ll> leaf;
    for(int i = 0; i < n; i++){
        if(degree[i] == 1){
            leaf.push_back(i);
        }
    }

    vector<ll> connected_leaf(n, 0);
    for(auto it:leaf){
        for(auto it1:adj[it]){
            connected_leaf[it1]++;
        }
    }

    vector<pair<ll,ll>> leafFreq;
    for(int i = 0; i < n; i++){
        leafFreq.push_back({connected_leaf[i], i});
    }

    sort(leafFreq.rbegin(), leafFreq.rend());
    set<ll> rem;
    for(int i = 0; i < 2; i++){
        rem.insert(leafFreq[i].second);
    }

    DSU dsu(n);
    for(int i = 0; i < n; i++){
        for(auto it:adj[i]){
            if(i < it && rem.find(i) == rem.end() && rem.find(it) == rem.end()){
                dsu.makeUnion(i, it);
            }
        }
    }

    set<ll> parents;
    for(int i = 0; i < n; i++){
        if(rem.find(i) == rem.end()){
            parents.insert(dsu.findUParent(i));
        }
    }
    cout << parents.size() << nl;

    return 0;
}

int main()
{
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    ll T = 1;
    cin >> T;
    for(int t = 1; t <= T; t++)
        solve(t, T);
    return 0;
}