import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;
import java.util.Map;
import java.util.Set;
public class ASSP {

    public final static int INFINITY=10000;
    public final static int EXPERIMENT=10;
    public static void union(int P[][],int x,int y)
    {
        link(P,findset(P,x),findset(P,y));
    }
    public static int min(int a,int b)
    {
        if(a<b) return a;
        else return b;
    }
    public static void link(int A[][],int indexA,int indexB)
    {
        if (indexA != indexB)
        {
        int oldParent,newParent;
        if(A[indexA][1] > A[indexB][1])
        {
            oldParent=A[indexB][0];
            A[indexA][1]=A[indexA][1]+A[indexB][1];
            A[indexB][0]=A[indexA][0];
            newParent=A[indexB][0];
            for(int i=0;i<A.length;i++)
            {
            if(A[i][0]==oldParent)
            {
                A[i][0] = newParent;
            }

        }


    }
    else if(A[indexB][1] >A[indexA][1] )
    {
        oldParent=A[indexA][0];
        A[indexB][1]=A[indexB][1]+A[indexA][1];
        A[indexA][0]=A[indexB][0];
        newParent=A[indexA][0];
        for(int i=0;i<A.length;i++)
        {
            if(A[i][0]==oldParent)
            {
                A[i][0] = newParent;
            }

        }
    }
    else
    {
        oldParent=A[indexB][0];
        A[indexA][1]=A[indexA][1]+A[indexB][1];
        A[indexB][0]=A[indexA][0];
        newParent=A[indexB][0];
        for(int i=0;i<A.length;i++)
        {
            if(A[i][0]==oldParent)
            {
                A[i][0] = newParent;
            }

        }
    }
        }
}
public static int findset(int A[][],int i)
{
    if(A[i][0] == i)
    {
        return i;
    }
    else
    {
        A[i][0]=findset(A,A[i][0]);
        return A[i][0];
    }
}
    public static int searchArray(int D[][],int x,int y)
    {
        int flag =0;
        if (D[x][y] == 1 || x == y)
        {
          flag =1;
        }
        return flag;
    }
    public static int totalsets(int A[][])
    {
        Set set1 = new HashSet();
        for(int i=0;i<A.length;i++)
        {
            set1.add(A[i][0]);

        }
        Iterator itr = set1.iterator();

        int sum=0;
        while(itr.hasNext()) {
          itr.next();
          sum=sum+1;

        }
        return sum;
    }
    public static void main(String[] args) {
        Random randomGenerator=new Random();
        int m=0;
        int MAX[]=new int[EXPERIMENT];
        for (m=0;m<EXPERIMENT;m++)
        {

        int n=100;//Points
        int E=4950;//Edges
        int a=0;


            int P[][]=new int[n][2];//Point Matrix

            for(int i=0;i<P.length;i++)
            {
            P[i][0]=i;//Parent
            P[i][1]=1;//Rank

            }
            int D[][]=new int[n][n];//Distance Matrix
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<n;j++)
                {
                    if (i == j)
                    {
                        D[i][j]=0;
                    }
                    else
                    {
                        D[i][j]=INFINITY;//Big Value or Infinity
                    }
                }
            }
        do{

         int x=randomGenerator.nextInt(n);//Find points
         int y=randomGenerator.nextInt(n);//Find points
         int flag=searchArray(D,x,y);
         if (flag == 0)
         {
             D[x][y]=1;
             D[y][x]=1;
             //System.out.println("x="+x+",y="+y);
             union(P,x,y);
             a++;

         }
        }
        while(a<E);
         //if
//      for(int i=0;i<P.length;i++)
//      {
//
//          System.out.println("Node"+i+", Parent"+P[i][0]+",Rank"+P[i][1]);//Rank
//
//
//      }
//      ////////////////////////////////
        int max=0;
        for(int k=0;k<n;k++)
        {
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<n;j++)
                {
                    D[i][j]=min(D[i][j],(D[i][k]+D[k][j]));

                    if(D[i][j] !=INFINITY)
                    {
                        if (D[i][j] >max)
                        {

                            max=D[i][j];
                        }
                    }

                }
            }

        }
        MAX[m]=max;
//      int total;
//      total=totalsets(P);
//      System.out.println(total);
/*      for(int i=0;i<n;i++)
        {
            System.out.println();
            for(int j=0;j<n;j++)
            {
                System.out.print(D[i][j]+" ");
            }
        }*/
        }//Experiment End
        System.out.println("Experiment  Diameter");
        for(m=0; m<EXPERIMENT; m++)
        {
            System.out.println(m+" "+MAX[m]);
        }

    } // main

} // ASSP