class Solution {
public:
    struct DSU
    {
        vector <int> sz , parent;
        int n;
        DSU(int n)
        {
            this->n = n;
            sz.resize(n);
            parent.resize(n);
            for(int i = 1; i < n; i++)
            {
                sz[i] = 1;
                parent[i] = i;
            }
        }

        int find_parent(int u)
        {
            if(u == parent[u])
                return u;
            return parent[u] = find_parent(parent[u]);
        }

        void merge(int u , int v)
        {
            if(sz[u] < sz[v])
                swap(u , v);
            sz[u] += sz[v];
            parent[v] = u;
        }

        bool is_cyclic(int u , int v)
        {
            int x = find_parent(u);
            int y = find_parent(v);
            if(x == y)
            {
                //parent[v] = v;
                return true;
            }
            merge(x , y);
            return false;

        }
    };
    int makeConnected(int n, vector<vector<int>>& connections) {
        DSU dsu(n + 1);
        int extra = 0;
        for (auto& pc  : connections)
        {
            int u = pc[0] , v = pc[1];
            bool is_cyclic = dsu.is_cyclic(u , v);
            if(is_cyclic)
                extra++;
        }
        int ans = 0;
        for(int i = 1; i < n; i++)
        {
            if(dsu.parent[i] == i)
                ans++;
        }
        if(extra >= ans - 1)
            return ans - 1;
        return -1;
    }
};