I am not good with markup that is used in codeforces (or anywhere else). So I am going the attach a piece of code in this comment which is a O(nlogn) implementation of DSU. This implementation uses LinkedList (can use vector in c++) to store which number belongs to which disjoint set. Instead of that, you can use a hashset to store this information. With this and some additional changes, you can easily implement the second operation. I'll leave the implementation to you.

import java.util.ArrayList;
import java.util.LinkedList;

class UnionFind {

    private int noOfComponents, n;
    private int component[], size[];
    private ArrayList<LinkedList<Integer>> members;

    public UnionFind(int p) {
        n = p;
        noOfComponents = n;
        component = new int[n + 1];
        size = new int[n + 1];
        members = new ArrayList<>();
        for (int i = 0; i <= n; i++) {
            component[i] = i;
            size[i] = 1;
            members.add(new LinkedList<Integer>());
            members.get(i).add(i);
        }
    }

    public int find(int k) {
        return component[k];
    }

    public void union(int a, int b) {
        a = find(a);
        b = find(b);
        if (a == b) {
            return;
        }
        if (size[a] > size[b]) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        LinkedList<Integer> membersofa = members.get(a);
        LinkedList<Integer> membersofb = members.get(b);
        for (int i = 0; i < size[a]; i++) {
            int member = membersofa.removeFirst();
            component[member] = component[b];
            membersofb.add(member);
        }
        size[b] = size[b] + size[a];
        noOfComponents--;
    }

    public int noOfComponents() {
        return noOfComponents;
    }
}