Problem: 2063C - Remove Exactly Two
Language: c++17 

Solution 1 (runtime: 608 ms):
#include <bits/stdc++.h>
using namespace std;

#define MAX_N 200005

vector<int> adj[MAX_N];
vector<int> subtreeSize(MAX_N);

void dfs(int node, int parent) {
    subtreeSize[node] = 1;
    for (int neighbor : adj[node]) {
        if (neighbor != parent) {
            dfs(neighbor, node);
            subtreeSize[node] += subtreeSize[neighbor];
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        
        // Clear adjacency list and subtree sizes
        for (int i = 0; i < n; i++) adj[i].clear();
        fill(subtreeSize.begin(), subtreeSize.begin() + n, 0);
        
        // Reading the tree edges
        for (int i = 0; i < n - 1; i++) {
            int u, v;
            cin >> u >> v;
            u--; v--; // Convert to 0-indexed
            adj[u].push_back(v);
            adj[v].push_back(u);
        }
        
        // Calculate subtree sizes using DFS from node 0
        dfs(0, -1);
        
        // The maximum components possible by removing two vertices
        int maxComponents = 0;
        
        // Try removing each pair of nodes (this is an approximation)
        for (int i = 0; i < n; i++) {
            // Mark the node as removed
            vector<int> visited(n, 0);
            visited[i] = 1; // Remove node i
            int components = 0;

            // Count components after removing the node
            for (int j = 0; j < n; j++) {
                if (!visited[j]) {
                    components++;
                    dfs(j, -1); // DFS from unvisited node
                }
            }
            
            maxComponents = max(maxComponents, components);
        }
        
        cout << maxComponents << "\n";
    }
    
    return 0;
}


Solution 2 (runtime: 827 ms):
#include <bits/stdc++.h>
using namespace std;
 
#define MOD 1000000007
#define maxn 100000000000017    
#define endl "\n"
#define mk make_pair
#define pll pair<ll, ll>
#define vll vector<ll>
#define vld vector<ld>
#define vpll vector<ppl>
#define ff first
#define ss second
 
typedef long long ll;
typedef long double ld;
 
 
#define o(...) if(local=='L') {__f(#__VA_ARGS__, __VA_ARGS__); cout<<endl;}
 
#define Ns 1000007
 
char local = 'O';
 
////////////////#####################INPUT###############///////////////////////
 
template <typename T>
void read(T &p)
{
    cin >> p;
}
 
template <typename T, typename T1>
void read(pair<T, T1> &p)
{
    read(p.ff);
    read(p.ss);
}
 
template <typename T>
void read(T arr[], ll n)
{
    for (ll i = 0; i < n; i++)
    {
        read(arr[i]);
    }
}
 
template <typename T>
void read(vector<T> &arr)
{
    for (ll i = 0; i < arr.size(); i++)
    {
        read(arr[i]);
    }
}
 
 
////////////////#####################OUPUT###############///////////////////////
 
template <typename T>
void out(T& n)
{
    cout << n;
}
 
template <typename T, typename T1>
void out(pair<T, T1> &p)
{
    cout << "(";
    out(p.ff);
    cout << ",";
    out(p.ss);
    cout << ")";
}
 
template <typename T>
void out(T arr[], ll n)
{
    for (ll i = 0; i < n; i++)
    {
        out(arr[i]);
        cout << " ";
    }
}
 
template <typename T>
void out(vector<T> &arr)
{
 
    cout << "[ ";
    for (ll i = 0; i < arr.size(); i++)
    {
        out(arr[i]);
        if (i!=arr.size()-1)
            cout << ", ";
    }
    cout << " ]" << endl;
 
}
 
 
 
template <typename T>
void out(set<T> &arr)
{
    for (auto i:arr)
    {
        out(i);
        cout << " ";
    }
}

template <typename T>
void out(multiset<T> &arr)
{
    for (auto i:arr)
    {
        out(i);
        cout << " ";
    }
}
 
template <typename T, typename T1>
void out(map<T,T1> &m)
{
    for (auto i:m)
    {
        out(i.first);
        cout<<" -> ";
        out(i.second);
        cout<<", ";
    }
}
 
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
    cout << name << " : ";
    out(arg1);
}
 
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
    const char *comma = strchr(names + 1, ',');
    cout.write(names, comma - names) << " : ";
    out(arg1);
    cout << " | ";
    __f(comma + 1, args...);
}
 
 
////////////////////////////////////END TEMPLATE//////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

// vector<bool> p(1e7 + 1, true);

// (a / b) % mod
long long power_mod(long long a, long long b, long long mod)
{
    long long ans = 1;
    while (b) {
        if (b & 1) ans = (ans * a) % mod;
        a = (a * a) % mod;
        b >>= 1;
    }
    return ans;
}

long long gcd(long long a, long long b)
{
    if(b == 0)
        return a;
    else
        return gcd(b, a % b);
}

long long n_sum(long long a, long long n, long long d) {
    return n * a + n * (n - 1) * d / 2;
}

struct edge {
    int to, a, b;

    edge(int _to, int _a, int _b): to(_to), a(_a), b(_b) {}
};

unsigned int highbit(unsigned int x){
	x |= x >> 1;
	x |= x >> 2;
	x |= x >> 4;
	x |= x >> 8;
	x |= x >> 16;
	return x - (x >> 1);
}

void calc() {

}

void init() {
}

void solve() {
    int n;
    cin >> n;

    vector<vector<int>> g(n);
    vector<int> d(n, 0);
    set<pair<int, int>> ds;
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        cin >> u >> v;
        g[u - 1].push_back(v - 1);
        g[v - 1].push_back(u - 1);
        ++d[u - 1];
        ++d[v - 1];
    }
    for (int i = 0; i < n; i++) {
        ds.insert({d[i], i});
    }
    // cout << "tot size: " << ds.size() << endl;

    int ans = 0;
    for (int i = 0; i < n; i++) {
        ds.erase({d[i], i});
        for (int j : g[i]) {
            ans = max(ans, d[i] + d[j] - 2);
            ds.erase({d[j], j});
        }
        if (!ds.empty()) {
            ans = max(ans, d[i] + (*ds.rbegin()).first - 1);
        }
        for (int j : g[i]) {
            ds.insert({d[j], j});
        }
        ds.insert({d[i], i});
    }

    cout << ans << endl;
}

int main()
{
 
    // #ifdef L
    //     local = 'L';
    //     time_t start, end;
    //     time(&start);
    //     freopen("input.txt", "r", stdin);
    //     freopen("output.txt", "w", stdout);
    // #endif
 
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
 
 
    ll t1;
    
    t1 = 1;
 
    cin>>t1;
 
    calc();

    while (t1--) {
        solve();
    }
 
    
 
    #ifdef L
    time(&end);
    double time_taken = double(end - start);
    cout << endl
        << endl
        << endl
        << "Time taken by program is : " << fixed
        << time_taken << setprecision(6);
    cout << " sec " << endl;
    #endif
}