#include <bits/stdc++.h>
using namespace std;

int n;
vector<int> topo, group, group_size, memo;
vector<bool> visited;
vector<vector<int>> group_nodes, graph, r_graph, graph2;

void topoSort(int node) {
    visited[node] = true;
    for (int next : graph[node]) {
        if (!visited[next]) {
            topoSort(next);
        }
    }
    topo.push_back(node);
}

void dfs(int node, int group_id, vector<int>& comp) {
    group[node] = group_id;
    comp.push_back(node);
    for (int next : r_graph[node]) {
        if (group[next] == -1) {
            dfs(next, group_id, comp);
        }
    }
}

void dfs2(int node) {
    if (memo[node] != -1) return;
    memo[node] = 0;
    int sum = 0;
    for (int next : graph2[node]) {
        if (memo[next] == -1) {
            dfs2(next);
        }
        sum += memo[next];
    }
    memo[node] = sum + group_size[node];
}

int main()
{
    cin >> n;

    visited.assign(n + 1, false);
    group.assign(n + 1, -1);
    graph.assign(n + 1, vector<int>(0));
    r_graph.assign(n + 1, vector<int>(0));
    group_nodes.push_back(vector<int>(0));

    for (int i=1; i <= n; i++) {
        int u;
        cin >> u;
        graph[i].push_back(u);
        r_graph[u].push_back(i);
    }

    for (int i=1; i <= n; i++) {
        if (!visited[i]) {
            topoSort(i);
        }
    }

    reverse(topo.begin(), topo.end());
    int number_of_groups = 1;

    for (int node : topo) {
        if (group[node] == -1) {
            vector<int> components(0);
            dfs(node, number_of_groups++, components);
            group_nodes.push_back(components);
        }
    }

    group_size.assign(number_of_groups, 0);

    for (int g = 1; g < number_of_groups; g++) {
        group_size[g] = group_nodes[g].size();
    }

    graph2.assign(number_of_groups, vector<int>(0));
    memo.assign(number_of_groups, -1);

    for (int i=1; i <= n; i++) {
        for (int next : graph[i]) {
            if (group[i] != group[next]) {
                graph2[group[i]].push_back(group[next]);
            }
        }
    }

    int max_group = 0;

    for (int g = 1; g < number_of_groups; g++) {
        if (memo[g] == -1) {
            dfs2(g);
        }
        if (memo[g] > memo[max_group]) {
            max_group = g;
        }
    }

    cout << group_nodes[max_group][0] << ' ' << memo[max_group] << '\n';
}