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

Previous submission (verdict: Wrong answer on test 12):
#include <bits/stdc++.h>
using namespace std;
 
typedef long long ll;
 
int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int t; 
    cin >> t;
    while(t--){
        int n; 
        cin >> n;
        // n vertices; el árbol tiene n-1 aristas.
        vector<vector<int>> adj(n+1);
        vector<int> deg(n+1,0);
        vector<pair<int,int>> edges;
 
        for (int i = 1; i <= n-1; i++){
            int u, v;
            cin >> u >> v;
            // Agregamos la arista en ambos sentidos.
            adj[u].push_back(v);
            adj[v].push_back(u);
            deg[u]++;
            deg[v]++;
            edges.push_back({u,v});
        }
 
        // Para cada vértice, ordenamos su lista de vecinos para poder hacer búsqueda binaria.
        for (int i = 1; i <= n; i++){
            sort(adj[i].begin(), adj[i].end());
        }
 
        // --- Caso 1: pares adyacentes ---
        // Para cada arista (u,v), la cantidad de componentes si se remueven u y v es:
        // deg(u) + deg(v) - 2.
        int bestAdj = -1;
        for(auto &e : edges){
            int u = e.first, v = e.second;
            int cand = deg[u] + deg[v] - 2;
            bestAdj = max(bestAdj, cand);
        }
 
        // --- Caso 2: pares NO adyacentes ---
        // Queremos maximizar (deg(u)+deg(v)-1) entre pares no adyacentes.
        // Primero, buscaremos la máxima suma deg(u)+deg(v) entre pares no adyacentes.
        int bestNonAdjSum = -1;
 
        // Creamos un vector con (grado, vértice) para ordenar por grado descendiente.
        vector<pair<int,int>> degList;
        degList.reserve(n);
        for (int i = 1; i <= n; i++){
            degList.push_back({deg[i], i});
        }
        sort(degList.begin(), degList.end(), [](auto &a, auto &b){
            return a.first > b.first;
        });
 
        // Usamos solo los primeros X vértices; X lo elegimos pequeño (por ejemplo, 1000) para que
        // la doble iteración sea eficiente.
        int X = min(n, 1000);
        for (int i = 0; i < X; i++){
            for (int j = i+1; j < X; j++){
                int u = degList[i].second;
                int v = degList[j].second;
                // Si u y v son adyacentes, los saltamos.
                if(binary_search(adj[u].begin(), adj[u].end(), v))
                    continue;
                int sum = deg[u] + deg[v];
                bestNonAdjSum = max(bestNonAdjSum, sum);
            }
        }
 
        // Si encontramos algún par no adyacente, su "valor" es (suma - 1).
        int candNonAdj = (bestNonAdjSum == -1 ? -1 : bestNonAdjSum - 1);
 
        // La respuesta final es el máximo entre la opción con vértices adyacentes y no adyacentes.
        int ans = max(bestAdj, candNonAdj);
        cout << ans << "\n";
    }
    return 0;
}


Submission (verdict: Wrong answer on test 12):
#include <bits/stdc++.h>
using namespace std;
 
typedef long long ll;
 
int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int t; 
    cin >> t;
    while(t--){
        int n; 
        cin >> n;
        vector<vector<int>> adj(n+1);
        vector<int> deg(n+1,0);
        vector<pair<int,int>> edges;
 
        // Lectura de las n-1 aristas.
        for (int i = 1; i <= n-1; i++){
            int u, v;
            cin >> u >> v;
            adj[u].push_back(v);
            adj[v].push_back(u);
            deg[u]++;
            deg[v]++;
            edges.push_back({u,v});
        }
 
        // Ordenamos las listas de adyacencia para cada vértice (para usar binary_search).
        for (int i = 1; i <= n; i++){
            sort(adj[i].begin(), adj[i].end());
        }
 
        // Caso 1: parejas adyacentes.
        int bestAdj = -1;
        for(auto &e : edges){
            int u = e.first, v = e.second;
            int cand = deg[u] + deg[v] - 2;
            bestAdj = max(bestAdj, cand);
        }
 
        // Caso 2: parejas NO adyacentes.
        int bestNonAdjSum = -1;
        vector<pair<int,int>> degList;
        degList.reserve(n);
        for (int i = 1; i <= n; i++){
            degList.push_back({deg[i], i});
        }
        // Ordenamos de mayor a menor grado.
        sort(degList.begin(), degList.end(), [](auto &a, auto &b){
            return a.first > b.first;
        });
 
        // Usamos los primeros X vértices; aumentamos X a min(n,2000) para mayor cobertura.
        int X = min(n, 2000);
        for (int i = 0; i < X; i++){
            for (int j = i+1; j < X; j++){
                int u = degList[i].second;
                int v = degList[j].second;
                // Si u y v son adyacentes, se salta.
                if(binary_search(adj[u].begin(), adj[u].end(), v))
                    continue;
                int sum = deg[u] + deg[v];
                bestNonAdjSum = max(bestNonAdjSum, sum);
            }
        }
 
        int candNonAdj = (bestNonAdjSum == -1 ? -1 : bestNonAdjSum - 1);
 
        int ans = max(bestAdj, candNonAdj);
        cout << ans << "\n";
    }
    return 0;
}