Problem: 2063C - Remove Exactly Two
Language: C++23 (GCC 14-64, msys2)


Submission (verdict: Wrong answer on test 2):
#define _CRT_SECURE_NO_WARNINGS
 
#include <cstring>
#include <bitset> 
#include <iostream>
#include <stdio.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <math.h>
#include <set>
#include <deque>
#include <cassert>
#include <utility>
#include <sstream>
#include <ostream>
#include <iomanip>
#include <algorithm>
#include <stack>
#include <random>
#include<functional>
#include<limits>
#include<tuple>
#include <unordered_set>
#include <fstream>
#include <numeric>
#include <cmath>
#include <cstdint>
#include <bits/stdc++.h>
using namespace std;
 
class big_integer {
    // основание системы счисления (1 000 000 000)
    static const int BASE = 1000000000;
 
    // внутреннее хранилище числа
    std::vector<int> _digits;
 
    // знак числа
    bool _is_negative;
 
    void _remove_leading_zeros();
    void _shift_right();
 
public:
    // класс-исключение, бросаемое при делении на ноль
    class divide_by_zero : public std::exception {};
    big_integer();
    big_integer(std::string);
    big_integer(signed char);
    big_integer(unsigned char);
    big_integer(signed short);
    big_integer(unsigned short);
    big_integer(signed int);
    big_integer(unsigned int);
    big_integer(signed long);
    big_integer(unsigned long);
    big_integer(signed long long);
    big_integer(unsigned long long);
 
    friend std::ostream& operator <<(std::ostream&, const big_integer&);
    operator std::string() const;
    const big_integer operator +() const;
    const big_integer operator -() const;
    const big_integer operator ++();
    const big_integer operator ++(int);
    const big_integer operator --();
    const big_integer operator --(int);
    friend bool operator ==(const big_integer&, const big_integer&);
    friend bool operator <(const big_integer&, const big_integer&);
    friend bool operator !=(const big_integer&, const big_integer&);
    friend bool operator <=(const big_integer&, const big_integer&);
    friend bool operator >(const big_integer&, const big_integer&);
    friend bool operator >=(const big_integer&, const big_integer&);
    friend const big_integer operator +(big_integer, const big_integer&);
    big_integer& operator +=(const big_integer&);
    friend const big_integer operator -(big_integer, const big_integer&);
    big_integer& operator -=(const big_integer&);
    friend const big_integer operator *(const big_integer&, const big_integer&);
    big_integer& operator *=(const big_integer&);
    friend const big_integer operator /(const big_integer&, const big_integer&);
    big_integer& operator /=(const big_integer&);
    friend const big_integer operator %(const big_integer&, const big_integer&);
    big_integer& operator %=(const big_integer&);
 
    bool odd() const;
    bool even() const;
    const big_integer pow(big_integer) const;
};
 
// создает длинное целое число со значением 0
big_integer::big_integer() {
    this->_is_negative = false;
}
 
// создает длинное целое число из C++-строки
big_integer::big_integer(std::string str) {
    if (str.length() == 0) {
        this->_is_negative = false;
    }
    else {
        if (str[0] == '-') {
            str = str.substr(1);
            this->_is_negative = true;
        }
        else {
            this->_is_negative = false;
        }
 
        for (long long i = str.length(); i > 0; i -= 9) {
            if (i < 9)
                this->_digits.push_back(atoi(str.substr(0, i).c_str()));
            else
                this->_digits.push_back(atoi(str.substr(i - 9, 9).c_str()));
        }
 
        this->_remove_leading_zeros();
    }
}
 
// удаляет ведущие нули
void big_integer::_remove_leading_zeros() {
    while (this->_digits.size() > 1 && this->_digits.back() == 0) {
        this->_digits.pop_back();
    }
 
    if (this->_digits.size() == 1 && this->_digits[0] == 0) this->_is_negative = false;
}
 
// печатает число в поток вывода
std::ostream& operator <<(std::ostream& os, const big_integer& bi) {
    if (bi._digits.empty()) os << 0;
    else {
        if (bi._is_negative) os << '-';
        os << bi._digits.back();
        char old_fill = os.fill('0');
        for (long long i = static_cast<long long>(bi._digits.size()) - 2; i >= 0; --i) os << std::setw(9) << bi._digits[i];
        os.fill(old_fill);
    }
 
    return os;
}
 
// сравнивает два числа на равенство
bool operator ==(const big_integer& left, const big_integer& right) {
    if (left._is_negative != right._is_negative) return false;
    if (left._digits.empty()) {
        if (right._digits.empty() || (right._digits.size() == 1 && right._digits[0] == 0)) return true;
        else return false;
    }
 
    if (right._digits.empty()) {
        if (left._digits.size() == 1 && left._digits[0] == 0) return true;
        else return false;
    }
 
    if (left._digits.size() != right._digits.size()) return false;
    for (size_t i = 0; i < left._digits.size(); ++i) if (left._digits[i] != right._digits[i]) return false;
 
    return true;
}
 
// возвращает копию переданного числа
const big_integer big_integer::operator +() const {
    return big_integer(*this);
}
 
// возвращает переданное число с другим знаком
const big_integer big_integer::operator -() const {
    big_integer copy(*this);
    copy._is_negative = !copy._is_negative;
    return copy;
}
 
// проверяет, является ли левый операнд меньше правого
bool operator <(const big_integer& left, const big_integer& right) {
    if (left == right) return false;
    if (left._is_negative) {
        if (right._is_negative) return ((-right) < (-left));
        else return true;
    }
    else if (right._is_negative) return false;
    else {
        if (left._digits.size() != right._digits.size()) {
            return left._digits.size() < right._digits.size();
        }
        else {
            for (long long i = left._digits.size() - 1; i >= 0; --i) {
                if (left._digits[i] != right._digits[i]) return left._digits[i] < right._digits[i];
            }
 
            return false;
        }
    }
}
 
// сравнивает два числа на неравенство
bool operator !=(const big_integer& left, const big_integer& right) {
    return !(left == right);
}
 
// проверяет, является ли левый операнд меньше либо равен правого
bool operator <=(const big_integer& left, const big_integer& right) {
    return (left < right || left == right);
}
 
// проверяет, является ли левый операнд больше правого
bool operator >(const big_integer& left, const big_integer& right) {
    return !(left <= right);
}
 
// проверяет, является ли левый операнд больше либо равен правого
bool operator >=(const big_integer& left, const big_integer& right) {
    return !(left < right);
}
 
// складывает два числа
const big_integer operator +(big_integer left, const big_integer& right) {
    if (left._is_negative) {
        if (right._is_negative) return -(-left + (-right));
        else return right - (-left);
    }
    else if (right._is_negative) return left - (-right);
    int carry = 0;
    for (size_t i = 0; i < std::max(left._digits.size(), right._digits.size()) || carry != 0; ++i) {
        if (i == left._digits.size()) left._digits.push_back(0);
        left._digits[i] += carry + (i < right._digits.size() ? right._digits[i] : 0);
        carry = left._digits[i] >= big_integer::BASE;
        if (carry != 0) left._digits[i] -= big_integer::BASE;
    }
 
    return left;
}
 
// прибавляет к текущему числу новое
big_integer& big_integer::operator +=(const big_integer& value) {
    return *this = (*this + value);
}
 
// префиксный инкремент
const big_integer big_integer::operator++() {
    return (*this += 1);
}
 
// преобразует число к строке
big_integer::operator std::string() const {
    std::stringstream ss;
    ss << *this;
    return ss.str();
}
 
// преобразует signed char к big_integer
big_integer::big_integer(signed char c) {
    if (c < 0) this->_is_negative = true;
    else this->_is_negative = false;
    this->_digits.push_back(std::abs(c));
}
 
// преобразует unsigned char к big_integer
big_integer::big_integer(unsigned char c) {
    this->_is_negative = false;
    this->_digits.push_back(c);
}
 
// преобразует signed short к big_integer
big_integer::big_integer(signed short s) {
    if (s < 0) this->_is_negative = true;
    else this->_is_negative = false;
    this->_digits.push_back(std::abs(s));
}
 
// преобразует unsigned short к big_integer
big_integer::big_integer(unsigned short s) {
    this->_is_negative = false;
    this->_digits.push_back(s);
}
 
// преобразует signed int к big_integer
big_integer::big_integer(signed int i) {
    if (i < 0) this->_is_negative = true;
    else this->_is_negative = false;
    this->_digits.push_back(std::abs(i) % big_integer::BASE);
    i /= big_integer::BASE;
    if (i != 0) this->_digits.push_back(std::abs(i));
}
 
// преобразует unsigned int к big_integer
big_integer::big_integer(unsigned int i) {
    this->_digits.push_back(i % big_integer::BASE);
    i /= big_integer::BASE;
    if (i != 0) this->_digits.push_back(i);
}
 
// преобразует signed long к big_integer
big_integer::big_integer(signed long l) {
    if (l < 0) this->_is_negative = true;
    else this->_is_negative = false;
    this->_digits.push_back(std::abs(l) % big_integer::BASE);
    l /= big_integer::BASE;
    if (l != 0) this->_digits.push_back(std::abs(l));
}
 
// преобразует unsigned long к big_integer
big_integer::big_integer(unsigned long l) {
    this->_digits.push_back(l % big_integer::BASE);
    l /= big_integer::BASE;
    if (l != 0) this->_digits.push_back(l);
}
 
// преобразует signed long long к big_integer
big_integer::big_integer(signed long long l) {
    if (l < 0) { this->_is_negative = true; l = -l; }
    else this->_is_negative = false;
    do {
        this->_digits.push_back(l % big_integer::BASE);
        l /= big_integer::BASE;
    } while (l != 0);
}
 
// преобразует unsigned long long к big_integer
big_integer::big_integer(unsigned long long l) {
    this->_is_negative = false;
    do {
        this->_digits.push_back(l % big_integer::BASE);
        l /= big_integer::BASE;
    } while (l != 0);
}
 
// постфиксный инкремент
const big_integer big_integer::operator ++(int) {
    *this += 1;
    return *this - 1;
}
 
// префиксный декремент
const big_integer big_integer::operator --() {
    return *this -= 1;
}
 
// постфиксный декремент
const big_integer big_integer::operator --(int) {
    *this -= 1;
    return *this + 1;
}
 
// вычитает два числа
const big_integer operator -(big_integer left, const big_integer& right) {
    if (right._is_negative) return left + (-right);
    else if (left._is_negative) return -(-left + right);
    else if (left < right) return -(right - left);
    int carry = 0;
    for (size_t i = 0; i < right._digits.size() || carry != 0; ++i) {
        left._digits[i] -= carry + (i < right._digits.size() ? right._digits[i] : 0);
        carry = left._digits[i] < 0;
        if (carry != 0) left._digits[i] += big_integer::BASE;
    }
 
    left._remove_leading_zeros();
    return left;
}
 
// вычитает из текущего числа новое
big_integer& big_integer::operator -=(const big_integer& value) {
    return *this = (*this - value);
}
 
// перемножает два числа
const big_integer operator *(const big_integer& left, const big_integer& right) {
    big_integer result;
    result._digits.resize(left._digits.size() + right._digits.size());
    for (size_t i = 0; i < left._digits.size(); ++i) {
        int carry = 0;
        for (size_t j = 0; j < right._digits.size() || carry != 0; ++j) {
            long long cur = result._digits[i + j] +
                left._digits[i] * 1LL * (j < right._digits.size() ? right._digits[j] : 0) + carry;
            result._digits[i + j] = static_cast<int>(cur % big_integer::BASE);
            carry = static_cast<int>(cur / big_integer::BASE);
        }
    }
 
    result._is_negative = left._is_negative != right._is_negative;
    result._remove_leading_zeros();
    return result;
}
 
// домножает текущее число на указанное
big_integer& big_integer::operator *=(const big_integer& value) {
    return *this = (*this * value);
}
 
// сдвигает все разряды на 1 вправо (домножает на BASE)
void big_integer::_shift_right() {
    if (this->_digits.size() == 0) {
        this->_digits.push_back(0);
        return;
    }
    this->_digits.push_back(this->_digits[this->_digits.size() - 1]);
    for (size_t i = this->_digits.size() - 2; i > 0; --i) this->_digits[i] = this->_digits[i - 1];
    this->_digits[0] = 0;
}
 
// делит два числа
const big_integer operator /(const big_integer& left, const big_integer& right) {
    if (right == 0) throw big_integer::divide_by_zero();
    big_integer b = right;
    b._is_negative = false;
    big_integer result, current;
    result._digits.resize(left._digits.size());
    for (long long i = static_cast<long long>(left._digits.size()) - 1; i >= 0; --i) {
        current._shift_right();
        current._digits[0] = left._digits[i];
        current._remove_leading_zeros();
        int x = 0, l = 0, r = big_integer::BASE;
        while (l <= r) {
            int m = (l + r) / 2;
            big_integer t = b * m;
            if (t <= current) {
                x = m;
                l = m + 1;
            }
            else r = m - 1;
        }
 
        result._digits[i] = x;
        current = current - b * x;
    }
 
    result._is_negative = left._is_negative != right._is_negative;
    result._remove_leading_zeros();
    return result;
}
 
// делит текущее число на указанное
big_integer& big_integer::operator /=(const big_integer& value) {
    return *this = (*this / value);
}
 
// возвращает остаток от деления двух чисел
const big_integer operator %(const big_integer& left, const big_integer& right) {
    big_integer result = left - (left / right) * right;
    if (result._is_negative) result += right;
    return result;
}
 
// присваивает текущему числу остаток от деления на другое число
big_integer& big_integer::operator %=(const big_integer& value) {
    return *this = (*this % value);
}
 
// проверяет, является ли текущее число нечетным
bool big_integer::odd() const {
    if (this->_digits.size() == 0) return false;
    return this->_digits[0] & 1;
}
 
// проверяет, является ли текущее число четным
bool big_integer::even() const {
    return !this->odd();
}
 
// возводит текущее число в указанную степень
const big_integer big_integer::pow(big_integer n) const {
    big_integer a(*this), result(1);
    while (n != 0) {
        if (n.odd()) result *= a;
        a *= a;
        n /= 2;
    }
    return result;
}
 
template <typename T>
std::string toString(T val)
{
    std::ostringstream oss;
    oss << val;
    return oss.str();
}
 
template<typename T>
T fromString(const string s)
{
    std::istringstream iss(s);
    T res;
    iss >> res;
    return res;
}
 
//операции 
long long normp(long long b, long long Mod) { return ((b % Mod) + Mod) % Mod; } // остаток от деления по mod
 
 
//int i = 5;
//bitset<16> bitset = i;
//// 'to_string' вернет строку std::string формата '000...0111'
//cout << "Binary : " << bitset.to_string<char, char_traits<char>, allocator<char> >() << endl;
//- супер быстрое чтение. -> Scanner.
struct Scanner {
    char buffer[1 << 16];
    int pos;
    int size;
    int c;
    Scanner() : pos(0), size(0) { nextChar(); }
    void nextChar() {
        if (pos == size) {
            size = int(fread(buffer, sizeof(char), sizeof(buffer) / sizeof(char), stdin));
            pos = 0;
            if (size == 0) {
                c = -1;
                return;
            }
        }
        assert(pos < size);
        c = buffer[pos] & 0xFF;
        pos++;
    }
 
    int nextint() {
        while (c == ' ' || c == '\n' || c == '\r' || c == '\t') {
            nextChar();
        }
        assert('0' <= c && c <= '9');
        int n = c - '0';
        nextChar();
        while ('0' <= c && c <= '9') {
            int d = c - '0';
            nextChar();
            n = n * 10 + d;
        }
        return n;
    }
};
 
//std::cout<<std::fixed<<std::setprecision(3)<<123.423432<<std::endl;
typedef long long ll;
struct pair_hash {
    inline std::size_t operator()(const std::pair<int, int>& v) const {
        return v.first * 31 + v.second;
    }
};

bool checkchet(int a, int b) { return (a & 1) ^ (b & 1); }
 
const int mod = 1e9;
long long gcd(long long a, long long b) {
    while (b > 0) {
        a %= b;
        swap(a, b);
    }
    return a;
}
long long lcm(int a, int b){
    return ( a * b ) / gcd(a, b);
}
 
 
ll sub(int a, int b, int mod){ // вычитание по модулю
    if(a - b < 0){
        return (a - b) + mod;
    } else{
        return a - b;
    }
}
 
ll mul(int a, int b, int mod){//умножение по модулю
    return (a * b) % mod;
}
//memset(mas, count_mas, size_mas*sizeof(int));
 
#define ull unsigned long long
  

#define all(a) a.begin(), a.end()
#define FOR(a, n) for(int i = 0 ; i < n ; i++) {int x; cin>>x; a[i] = x;}

struct segmentree{
    vector<ll> t;
    vector<ll> a;
    ll n;
    ll Neutral = (1 << 32) - 1;
    segmentree(ll _n, vector<ll> _a) : n(_n), a(_a){
        t.resize(4 * n);
        build(0, 0, n);
    }
    void build(ll i, ll l, ll r){
        if(l + 1 == r){
            t[i] = a[l];
            return;
        }
        ll m = (r + l) / 2;
        build(i * 2 + 1, l, m);
        build(i * 2 + 2, m, r);
        t[i] = (t[i * 2 + 1] & t[i * 2 + 2]);
    }

    int get(ll i, ll l, ll r, ll ql, ll qr){
        if (ql >= r || qr <= l){
            return this->Neutral;
        } 
        if(ql <= l && qr >= r){
            return t[i];
        }
        ll m = (r + l) / 2;
        ll res1 = get(i *2 + 1, l, m, ql, qr);
        ll res2 = get(i * 2 + 2, m, r, ql, qr);
        return (res1 & res2);
    }
};

//std::cout<<std::fixed<<std::setprecision(3)<<123.423432<<std::endl;

#define pii pair<int, int>

struct Node{
    int it; int count;
};

signed main() {
	//freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(false);
    cout.tie(nullptr);
    cin.tie(nullptr);
    int t;
    cin>>t;
    while(t--){
        int n; cin>>n;
        int result =1;
        vector<Node> a_mas(n);
        for(int i =0; i < n ;i++){
            a_mas[i] = {i, 0};
        }
        vector<vector<int>> graph(n);
        for(int i =0; i < n - 1; i++){
            int a, b; cin>>a>>b; a--, b--;
            a_mas[a].count+=1; a_mas[b].count += 1;
            graph[a].push_back(b);
            graph[b].push_back(a);
        }
        vector<Node> prom = a_mas;
        sort(all(prom), [](Node a, Node b){
            return a.count > b.count;
        });
        result += prom[0].count - 1;
        a_mas[prom[0].it] = {0, 0};
        for(int i : graph[prom[0].it]){
            a_mas[i].count -= 1;
        }
        sort(all(a_mas), [](Node a, Node b){
            return a.count > b.count;
        });
        result += a_mas[0].count - 1; 
        cout<<result<<"\n";
    }
    return 0;
}