#include <bits/stdc++.h>
//#include <cstdlib>
//#include<iostream>
//#include<fstream>
//#include<vector>
//#include<algorithm>

using namespace std;

void dfs(int vertex, vector<vector<int>>& adjlist, int* vertices, int numberGroups)
{
    if (vertices[vertex] != -1)
    {
        return;
    }

    vertices[vertex] = numberGroups;
    for (int i = 0; i < adjlist[vertex].size(); i++)
    {
        dfs(adjlist[vertex][i], adjlist, vertices, numberGroups);
    }
}

/*
 * Complete the componentsInGraph function below.
 */
vector<int> componentsInGraph(int n, vector<vector<int>>& gb)
{
    std::cout << "Vliza" << std::endl;

    vector<vector<int>> adjList;
    adjList.resize(2 * n);

    std::cout << "Sled reserve" << std::endl;

    for (int i = 0; i < adjList.size(); i++)
    {
        adjList[i] = vector<int>();
    }

    std::cout << "Sled for-a" << std::endl;

    for (int i = 0; i < gb.size(); i++)
    {
        adjList[gb[i][0] - 1].push_back(gb[i][1] - 1);
        adjList[gb[i][1] - 1].push_back(gb[i][0] - 1);
    }

    for (int i = 0; i < adjList.size(); i++)
    {
        std::cout << i << " ";
        for (int j = 0; j < adjList[i].size(); j++)
        {
            std::cout << adjList[i][j] << " ";
        }
        std::cout << std::endl;
    }

    int* vertices = new int[adjList.size()];
    for (int i = 0; i < adjList.size(); i++)
    {
        if(adjList[i].empty())
        {
            vertices[i] = -2;
        }
        else
        {
            vertices[i] = -1;
        }
    }

    int numberGroups = 0;
    for (int i = 0; i < adjList.size(); i++)
    {
        if (vertices[i] == -1)
        {
            dfs(i, adjList, vertices, numberGroups);
            ++numberGroups;
        }
    }

    std::cout << numberGroups << std::endl;

    int* groups = new int[numberGroups];
    for (int i = 0; i < numberGroups; i++)
    {
        groups[i] = 0;
    }

    for (int i = 0; i < adjList.size(); i++)
    {
        //how many nodes are there in each group
        groups[vertices[i]]++;
    }

    /*for (int i = 0; i < numberGroups; i++)
    {
        if (groups[i] == 1)
        {
            groups[i] = 0;
        }
    }*/

    int min = groups[0];
    int max = groups[0];
    for (int i = 0; i < numberGroups; i++)
    {
        if (groups[i] < min)
        {
            min = groups[i];
        }

        if (groups[i] > max)
        {
            max = groups[i];
        }
    }

    vector<int> results;

    results.push_back(min);
    results.push_back(max);

    return results;
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    int n;
    cin >> n;
    cin.ignore(numeric_limits<streamsize>::max(), '\n');

    vector<vector<int>> gb(n);

    for (int gb_row_itr = 0; gb_row_itr < n; gb_row_itr++)
    {
        gb[gb_row_itr].resize(2);

        for (int gb_column_itr = 0; gb_column_itr < 2; gb_column_itr++)
        {
            cin >> gb[gb_row_itr][gb_column_itr];
        }

        cin.ignore(numeric_limits<streamsize>::max(), '\n');
    }

    vector<int> result = componentsInGraph(n, gb);

    for (int SPACE_itr = 0; SPACE_itr < result.size(); SPACE_itr++)
    {
        fout << result[SPACE_itr];

        if (SPACE_itr != result.size() - 1)
        {
            fout << " ";
        }
    }

    fout << "\n";

    fout.close();
}