Problem: 2063C - Remove Exactly Two
Language: java

Solution 1 (runtime: 1968 ms):
import java.util.*;

public class RemoveExactlyTwo
{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int t = in.nextInt();

        while (t-- > 0) {
            int n = in.nextInt();


            ArrayList<Integer>[] arr = new ArrayList[n];

            HashSet<Integer>[] s = new HashSet[n];

            for (int i = 0; i < n-1; i++) {
                int x = in.nextInt()-1;
                int y = in.nextInt()-1;

                if(arr[x] == null) {arr[x] = new ArrayList<>(); s[x] = new HashSet<>();}
                if(arr[y] == null) {arr[y] = new ArrayList<>(); s[y] = new HashSet<>();}

                arr[x].add(y); arr[y].add(x);
                s[x].add(y); s[y].add(x);
            }

            Comparator<int[]> comparator = (a, b) -> Integer.compare(b[0], a[0]);

            PriorityQueue<int[]> pq = new PriorityQueue<>(comparator);

//            pq.add(new int[]{n,0});

            HashSet<Integer> vis = new HashSet<>();

            int ans = dfs(pq, 0, vis, s, arr);

            System.out.println(ans);

        }



    }

    public static int dfs(PriorityQueue<int[]> pq, int m, HashSet<Integer> vis, HashSet<Integer>[] s, ArrayList<Integer>[] arr)
    {
        vis.add(m);
        int v = s[m].size();

        int max = 0;

        if(pq.isEmpty()){
            max = 0;
        }
        else if(s[m].contains(pq.peek()[1])) {
            int[] a = pq.poll();
            max = v + a[0] - 2;
            if(!pq.isEmpty()) max = Math.max( v + a[0] - 2, v + pq.peek()[0] - 1);
            pq.add(a);
        }
        else if(!s[m].contains(pq.peek()[1]))
        {
            max = Math.max(max, v + pq.peek()[0] - 1);
        }

        pq.add(new int[]{v, m});

        for (int i = 0; i < arr[m].size(); i++) {
            if(vis.contains(arr[m].get(i))) continue;
            max = Math.max(max, dfs(pq,arr[m].get(i), vis, s, arr));
        }

        return max;

    }



    /*          ─────────▄▄───────────────────▄▄──
                ──────────▀█───────────────────▀█─
                ──────────▄█───────────────────▄█─
                ──█████████▀───────────█████████▀─
                ───▄██████▄─────────────▄██████▄──
                ─▄██▀────▀██▄─────────▄██▀────▀██▄
                ─██────────██─────────██────────██
                ─██───██───██─────────██───██───██
                ─██────────██─────────██────────██
                ──██▄────▄██───────────██▄────▄██─
                ───▀██████▀─────────────▀██████▀──
                ──────────────────────────────────
                   ────────────────────────────
                    ─────────────────────────
                     ──────█████████████───
                     ──────────────────────
                     ──────────────────────
     */
}


Solution 2 (runtime: 905 ms):
import java.io.*;
import java.util.*;

public class RemoveExactlyTwo {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);

        int tc = Integer.parseInt(br.readLine());

        while (tc-- > 0) {
            int N = Integer.parseInt(br.readLine());

            // if (N <)

            ArrayList<Integer>[] adj = new ArrayList[N];
            HashMap<Integer, Integer> degCnt = new HashMap<>();

            for (int i = 0; i < N; i++) {
                adj[i] = new ArrayList<>(); 
            }

            for (int i = 0; i < N-1; i++) {
                String s = br.readLine();
                StringTokenizer st1 = new StringTokenizer(s);

                int a = Integer.parseInt(st1.nextToken()) - 1;
                int b = Integer.parseInt(st1.nextToken()) - 1;

                adj[a].add(b);
                adj[b].add(a);
            }

            for (int i = 0; i < N; i++) {
                int deg = adj[i].size();
                degCnt.put(i, deg);
            }
            int res = 1;
            ArrayList<Integer> maxKeys = getBiggestKeys(degCnt);

            if (maxKeys.size() == 1) {
                res += degCnt.get(maxKeys.get(0)) - 1;
                degCnt.remove(maxKeys.get(0));

                for (int n : adj[maxKeys.get(0)]) {
                    degCnt.put(n, degCnt.get(n)-1);
                }

                res += degCnt.get(getBiggestKeys(degCnt).get(0)) - 1;
            } else {
                int max = degCnt.get(maxKeys.get(0));
                boolean done = false;
                for (int key : maxKeys) {
                    ArrayList<Integer> affected = adj[key];
                    int affectedCount = 0;
                    for (int v : affected) {
                        if (degCnt.get(v) == max) {
                            affectedCount++;
                        }
                    }

                    if (maxKeys.size() - affectedCount > 1) {
                        res = max * 2 - 1;
                        done = true;
                        break;
                    }
                }

                if (!done) {
                    res = max*2-2;
                }
            }

            pw.println(res);
        }

        pw.close();
    }

    static ArrayList<Integer> getBiggestKeys(HashMap<Integer, Integer> hm) {
        ArrayList<Integer> maxKeys = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : hm.entrySet()) {
            int key = entry.getKey();
            int val = entry.getValue();

            if (maxKeys.size() == 0 || val >= hm.get(maxKeys.get(0))) {
                if (maxKeys.size() == 0 || val > hm.get(maxKeys.get(0))) {
                    maxKeys.clear();
                    maxKeys.add(key);
                } else {
                    maxKeys.add(key);
                }
            }
        }
        return maxKeys;
    }
}