/*

Tarjan算法

复杂度O(N+M)

*/

#include<iostream>

#include<stdio.h>

#include<string.h>

using namespace std;

const int MAXN=;//点数

const int MAXM=;//边数

struct Edge{

    int to,next;

}edge[MAXM];

int head[MAXN],tot;

int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];//Belong数组的值是1~scc

int Index,top;

int scc;//强连通分量的个数

bool Instack[MAXN];

int num[MAXN];//各个强连通分量包含点的个数，数组编号1~scc

//num数组不一定需要，结合实际情况

void addedge(int u,int v){

    edge[tot].to=v;

    edge[tot].next=head[u];

    head[u]=tot++;

}

void Tarjan(int u){

    int v;

    Low[u]=DFN[u]=++Index;

    Stack[top++]=u;

    Instack[u]=true;

    for(int i=head[u];i!=-;i=edge[i].next){

        v=edge[i].to;

        if(!DFN[v]){

            Tarjan(v);

            if(Low[u]>Low[v])Low[u]=Low[v];

        }

        else if(Instack[v]&&Low[u]>DFN[v])

            Low[u]=DFN[v];

    }

    if(Low[u]==DFN[u]){

        scc++;

        do{

            v=Stack[--top];

            Instack[v]=false;

            Belong[v]=scc;

            num[scc]++;

        }

        while(v!=u);

    }

}

void solve(int N){

    memset(DFN,,sizeof(DFN));

    memset(Instack,false,sizeof(Instack));

    memset(num,,sizeof(num));

    Index=scc=top=;

    for(int i=;i<=N;i++)

        if(!DFN[i])

            Tarjan(i);

}

void init(){

    tot=;

    memset(head,-,sizeof(head));

}

int main(){

    int N;

    int v;

    int indegree[MAXN],outdegree[MAXN];//强连通分量的入度，强连通分量的出度

    int in0,out0;//入度为0的强连通分量个数，出度为0的...

    while(~scanf("%d",&N)){

        init();

        memset(indegree,,sizeof(indegree));

        memset(outdegree,,sizeof(outdegree));

        in0=out0=;

        for(int u=;u<=N;++u){

            while(scanf("%d",&v)){

                if(v==)break;

                addedge(u,v);

            }

        }

        solve(N);

        if(scc==)printf("1\n0\n");//只有一个强连通 分量

        else{

            //枚举所有的边，统计强连通分量的入度、出度

            for(int i=;i<=N;++i){

                for(int j=head[i];j!=-;j=edge[j].next){

                    if(Belong[i]!=Belong[edge[j].to]){

                        ++indegree[Belong[edge[j].to]];

                        ++outdegree[Belong[i]];

                    }

                }

            }

            //强连通分量的入度为0的个数，出度为0的个数

            for(int i=;i<=scc;++i){

                if(indegree[i]==)++in0;

                if(outdegree[i]==)++out0;

            }

            if(in0>out0)printf("%d\n%d\n",in0,in0);

            else printf("%d\n%d\n",in0,out0);

        }

    }

    return ;

}