#include <stdio.h>
#include <stdlib.h>
#define CLAVE -1

typedef struct nodoDirectorio{
    int vertice;
    struct nodoAdyacente *lista;
    struct nodoDirectorio *enlace;
    int distancia;

} NodoGrafo;
typedef NodoGrafo* TipoDato;

typedef struct nodo
{
    TipoDato elemento;
    struct nodo *siguiente;
} Nodo;

void crearPila(Nodo **pila);
void insertar(Nodo **pila,TipoDato elemento);
TipoDato quitar(Nodo **pila);
int pilaVacia(Nodo *pila);

typedef struct nodoAdyacente
{
    struct nodoDirectorio *destino;
    struct nodoAdyacente *enlace;
} NodoLista;

void nuevoVertice(NodoGrafo **grafo, int vertice);
void arista(NodoGrafo *grafo, int org, int dst);
NodoGrafo* direccion(NodoGrafo *grafo,int vert);
void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[]);
int longitud=0;
int maximo=0;

int main()
{
    NodoGrafo* cabeza;
    cabeza = NULL;

  //  freopen("input.txt","r",stdin);
  //  freopen ("output.txt","w",stdout);
    int k,n,mayor=0,total=0;
    int nro;
    scanf("%d",&nro);
    NodoGrafo *vec[nro];

    int m[nro];

        int i,x,y;
    for(k=0;k<nro;k++){

        vec[k]=NULL;
        scanf("%d",&n);
        for( i = 1; i <= n; i++)
        {
            nuevoVertice(&vec[k],i);
        }
        for( i = 1; i <=n-1; i++)
        {
            scanf("%d%d",&x,&y);
            arista(vec[k],x,y);
            arista(vec[k],y,x);

         }
         longitud=0;
         maximo=0;
        for( i =1; i<= n;i++)
        {
            recorreProfundidad(vec[k],n,i,m);
            if(longitud>maximo){
                    maximo=longitud;
            }
        }

        total=total+maximo;
    }
    printf("%d",total);
        return 0;

}

void nuevoVertice(NodoGrafo **grafo, int vertice)
{
    NodoGrafo *nuevo;
    nuevo = (NodoGrafo*)malloc(sizeof(NodoGrafo));
    nuevo -> vertice = vertice;
    nuevo -> lista = NULL;
    nuevo -> enlace = *grafo;
    *grafo = nuevo;
}

void arista(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;
    NodoLista *ady;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        ady = (NodoLista*)malloc(sizeof(NodoLista));
        ady -> destino = v2;
        ady -> enlace = v1 -> lista;
        v1 -> lista = ady;
    }
}

NodoGrafo* direccion(NodoGrafo *grafo,int vert)
{
    NodoGrafo *aux;

    aux = grafo;

    while( aux -> vertice != vert && aux != NULL )
    {
        aux = aux -> enlace;
    }
    return aux;
}

void borrarArco(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        NodoLista *ady;
        NodoLista *a = NULL;
        ady = v1 -> lista;
        while(ady)
        {
            if(ady -> destino == v2)
            {
                if(a == NULL)
                    v1 -> lista = ady -> enlace;
                else
                    a -> enlace = ady -> enlace;
                free(ady);
                ady = NULL;
            }
            else
            {
                a = ady;
                ady = ady -> enlace;
            }
        }
    }
}

void crearPila(Nodo **pila)
{
    *pila = NULL;
}

int pilaVacia(Nodo *pila)
{
    return pila == NULL;
}

void insertar(Nodo **pila,TipoDato elemento)
{
    Nodo *nuevo;

    nuevo = (Nodo*)malloc(sizeof(Nodo));
    nuevo -> elemento = elemento;
    nuevo -> siguiente = *pila;
    (*pila) = nuevo;
}

TipoDato quitar(Nodo **pila)
{
    TipoDato tem;
    Nodo *q;

    if(pilaVacia(*pila))
    {
        puts(" Se intenta sacar un elemento en pila vacia");
        exit(1);
    }
     tem = (*pila) -> elemento;
    q = *pila;
    (*pila) = (*pila) -> siguiente;
    free(q);

    return tem;
}

void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[])
{
    NodoGrafo *v1,*v2,*z;
    NodoLista *ady;
    Nodo *pila;

    crearPila(&pila);
    int i;
    for( i = 0; i < n; i++)
    {
        m[i] = CLAVE;

    }
    m[v-1] = 0;
    v1 = direccion(grafo,v);
    insertar(&pila,v1);
    v1 -> distancia = 0;
    while(!pilaVacia(pila))
    {
        z = quitar(&pila);
        ady = z -> lista;
        while(ady != NULL)
        {
            int k;
            k = ady -> destino -> vertice - 1;
            if(m[k] == CLAVE)
            {
                insertar(&pila,ady->destino);
                m[k] = 1;
                ady -> destino -> distancia = z -> distancia + 1;
                if(ady -> destino -> distancia >longitud)
                   longitud=ady -> destino -> distancia ;

            }
                ady = ady -> enlace;

        }

    }
}


#include <stdio.h>
#include <stdlib.h>
#define CLAVE -1

typedef struct nodoDirectorio{
    int vertice;
    struct nodoAdyacente *lista;
    struct nodoDirectorio *enlace;
    int distancia;

} NodoGrafo;
typedef NodoGrafo* TipoDato;

typedef struct nodo
{
    TipoDato elemento;
    struct nodo *siguiente;
} Nodo;

void crearPila(Nodo **pila);
void insertar(Nodo **pila,TipoDato elemento);
TipoDato quitar(Nodo **pila);
int pilaVacia(Nodo *pila);

typedef struct nodoAdyacente
{
    struct nodoDirectorio *destino;
    struct nodoAdyacente *enlace;
} NodoLista;

void nuevoVertice(NodoGrafo **grafo, int vertice);
void arista(NodoGrafo *grafo, int org, int dst);
NodoGrafo* direccion(NodoGrafo *grafo,int vert);
void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[]);
int longitud=0;
int maximo=0;

int main()
{
    NodoGrafo* cabeza;
    cabeza = NULL;

    freopen("input.txt","r",stdin);
    freopen ("output.txt","w",stdout);
    int k,n,nro,mayor=0;
    scanf("%d",&nro);
    NodoGrafo *vec[nro];
    int m[n],total;

        int i,x,y;
    for(k=0;k<nro;k++){

        vec[n]=NULL;
        scanf("%d",&n);
        for( i = 1; i <= n; i++)
        {
            nuevoVertice(&vec[k],i);
        }
        for( i = 1; i <=n-1; i++)
        {
            scanf("%d%d",&x,&y);
            arista(cabeza,x,y);
            arista(cabeza,y,x);

        }
        for( i =1; i<= n;i++)
        {
            recorreProfundidad(cabeza,n,i,m);
            if(longitud>maximo)maximo=longitud;
        }

        total=+maximo;
    }
    printf("%d",total);
        return 0;

}

void nuevoVertice(NodoGrafo **grafo, int vertice)
{
    NodoGrafo *nuevo;
    nuevo = (NodoGrafo*)malloc(sizeof(NodoGrafo));
    nuevo -> vertice = vertice;
    nuevo -> lista = NULL;
    nuevo -> enlace = *grafo;
    *grafo = nuevo;
}

void arista(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;
    NodoLista *ady;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        ady = (NodoLista*)malloc(sizeof(NodoLista));
        ady -> destino = v2;
        ady -> enlace = v1 -> lista;
        v1 -> lista = ady;
    }
}

NodoGrafo* direccion(NodoGrafo *grafo,int vert)
{
    NodoGrafo *aux;

    aux = grafo;

    while( aux -> vertice != vert && aux != NULL )
    {
        aux = aux -> enlace;
    }
    return aux;
}

void borrarArco(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        NodoLista *ady;
        NodoLista *a = NULL;
        ady = v1 -> lista;
        while(ady)
        {
            if(ady -> destino == v2)
            {
                if(a == NULL)
                    v1 -> lista = ady -> enlace;
                else
                    a -> enlace = ady -> enlace;
                free(ady);
                ady = NULL;
            }
            else
            {
                a = ady;
                ady = ady -> enlace;
            }
        }
    }
}

void crearPila(Nodo **pila)
{
    *pila = NULL;
}

int pilaVacia(Nodo *pila)
{
    return pila == NULL;
}

void insertar(Nodo **pila,TipoDato elemento)
{
    Nodo *nuevo;

    nuevo = (Nodo*)malloc(sizeof(Nodo));
    nuevo -> elemento = elemento;
    nuevo -> siguiente = *pila;
    (*pila) = nuevo;
}

TipoDato quitar(Nodo **pila)
{
    TipoDato tem;
    Nodo *q;

    if(pilaVacia(*pila))
    {
        puts(" Se intenta sacar un elemento en pila vacia");
        exit(1);
    }
     tem = (*pila) -> elemento;
    q = *pila;
    (*pila) = (*pila) -> siguiente;
    free(q);

    return tem;
}

void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[])
{
    NodoGrafo *v1,*v2,*z;
    NodoLista *ady;
    Nodo *pila;

    crearPila(&pila);
    int i;
    for( i = 0; i < n; i++)
    {
        m[i] = CLAVE;

    }
    m[v-1] = 0;
    v1 = direccion(grafo,v);
    insertar(&pila,v1);
    v1 -> distancia = 0;
    while(!pilaVacia(pila))
    {
        z = quitar(&pila);
        ady = z -> lista;
        while(ady != NULL)
        {
            int k;
            k = ady -> destino -> vertice - 1;
            if(m[k] == CLAVE)
            {
                insertar(&pila,ady->destino);
                m[k] = 1;
                ady -> destino -> distancia = z -> distancia + 1;
                if(ady -> destino -> distancia >longitud)
                   longitud=ady -> destino -> distancia ;

            }
                ady = ady -> enlace;

        }

    }
}


#include <stdio.h>
#include <stdlib.h>
#define CLAVE -1

typedef struct nodoDirectorio{
    int vertice;
    struct nodoAdyacente *lista;
    struct nodoDirectorio *enlace;
    int distancia;

} NodoGrafo;

typedef NodoGrafo* TipoDato;

typedef struct nodo
{
    TipoDato elemento;
    struct nodo *siguiente;
} Nodo;

void crearPila(Nodo **pila);
void insertar(Nodo **pila,TipoDato elemento);
TipoDato quitar(Nodo **pila);
int pilaVacia(Nodo *pila);

typedef struct nodoAdyacente
{
    struct nodoDirectorio *destino;
    struct nodoAdyacente *enlace;
} NodoLista;

void nuevoVertice(NodoGrafo **grafo, int vertice);
void arista(NodoGrafo *grafo, int org, int dst);
NodoGrafo* direccion(NodoGrafo *grafo,int vert);
void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[]);

int total = 0;
int longitud = 0;

int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int nro;
    scanf("%d",&nro);
    NodoGrafo *vec[nro];
    int i,x,y,mayor = 0, k,total=0;
    for( k = 0; k < nro; k++)
    {
        vec[k] = NULL;

        int n;
        scanf("%d",&n);

        for( i = 1; i <= n; i++)
        {
            nuevoVertice(&vec[k],i);
        }
        for( i = 1; i <=n-1; i++)
        {
            scanf("%d%d",&x,&y);

            arista(vec[k],x,y);
            arista(vec[k],y,x);

        }
           int m[n];
            mayor = 0;
           longitud = 0;
        for( i = 1; i <= n; i++)
        {
            recorreProfundidad(vec[k],n,i,m);
            if(longitud > mayor){mayor = longitud;}
        }
        total = total + mayor;
    }
            printf("%d",total);

    return 0;

}
void nuevoVertice(NodoGrafo **grafo, int vertice)
{
    NodoGrafo *nuevo;
    nuevo = (NodoGrafo*)malloc(sizeof(NodoGrafo));
    nuevo -> vertice = vertice;
    nuevo -> lista = NULL;
    nuevo -> enlace = *grafo;
    *grafo = nuevo;
}
void arista(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;
    NodoLista *ady;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        ady = (NodoLista*)malloc(sizeof(NodoLista));
        ady -> destino = v2;
        ady -> enlace = v1 -> lista;
        v1 -> lista = ady;
    }
}

NodoGrafo* direccion(NodoGrafo *grafo,int vert)
{
    NodoGrafo *aux;

    aux = grafo;

    while( aux -> vertice != vert && aux != NULL )
    {
        aux = aux -> enlace;
    }
    return aux;

}

void crearPila(Nodo **pila)
{
    *pila = NULL;
}

int pilaVacia(Nodo *pila)
{
    return pila == NULL;
}

void insertar(Nodo **pila,TipoDato elemento)
{
    Nodo *nuevo;

    nuevo = (Nodo*)malloc(sizeof(Nodo));
    nuevo -> elemento = elemento;
    nuevo -> siguiente = *pila;
    (*pila) = nuevo;
}

TipoDato quitar(Nodo **pila)
{
    TipoDato tem;
    Nodo *q;

    if(pilaVacia(*pila))
    {
        puts(" Se intenta sacar un elemento en pila vacia");
        exit(1);
    }

    tem = (*pila) -> elemento;
    q = *pila;
    (*pila) = (*pila) -> siguiente;
    free(q);

    return tem;
}

void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[])
{
    NodoGrafo *v1,*v2,*w;
    NodoLista *ady;
    Nodo *pila;

    crearPila(&pila);
    int i;
    int tiempos[n];
    for( i = 0; i < n; i++)
    {
        m[i] = CLAVE;
        tiempos[i] = 0;
    }
    m[v-1] = 0;

    v1 = direccion(grafo,v);
    insertar(&pila,v1);
    total = 0;
    v1 -> distancia = 0;
    while(!pilaVacia(pila))
    {

        w = quitar(&pila);
        ady = w -> lista;
        while(ady != NULL)
        {

            int k;
            k = ady -> destino -> vertice - 1;
            if(m[k] == CLAVE)
            {
                insertar(&pila,ady->destino);
                m[k] = 1;
                ady -> destino -> distancia = w -> distancia + 1;
                if(ady -> destino -> distancia > longitud)
                    longitud = ady -> destino -> distancia;

            }

            ady = ady -> enlace;
        }

    }

}


#include <stdio.h>
#include <stdlib.h>
#define CLAVE -1

typedef struct nodoDirectorio{
    int vertice;
    struct nodoAdyacente *lista;
    struct nodoDirectorio *enlace;
    int distancia;

} NodoGrafo;

typedef NodoGrafo* TipoDato;

typedef struct nodo
{
    TipoDato elemento;
    struct nodo *siguiente;
} Nodo;

void crearPila(Nodo **pila);
void insertar(Nodo **pila,TipoDato elemento);
TipoDato quitar(Nodo **pila);
int pilaVacia(Nodo *pila);

typedef struct nodoAdyacente
{
    struct nodoDirectorio *destino;
    struct nodoAdyacente *enlace;
} NodoLista;

void nuevoVertice(NodoGrafo **grafo, int vertice);
void arista(NodoGrafo *grafo, int org, int dst);
NodoGrafo* direccion(NodoGrafo *grafo,int vert);
void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[]);

int total = 0;
int longitud = 0;

int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int nro;
    scanf("%d",&nro);
    NodoGrafo *vec[nro];
    int i,x,y,mayor = 0, k,total=0;
    for( k = 0; k < nro; k++)
    {
        vec[k] = NULL;
        int n;
        scanf("%d",&n);

        for( i = 1; i <= n; i++)
        {
            nuevoVertice(&vec[k],i);
        }
        for( i = 1; i <=n-1; i++)
        {
            scanf("%d%d",&x,&y);
            arista(vec[k],x,y);
            arista(vec[k],y,x);
        }
           int m[n];
            mayor = 0;
           longitud = 0;
        for( i = 1; i <= n; i++)
        {
            recorreProfundidad(vec[k],n,i,m);
            if(longitud > mayor){ mayor = longitud;}
        }
        total = total + mayor;
    }
            printf("%d",total);

    return 0;

}
void nuevoVertice(NodoGrafo **grafo, int vertice)
{
    NodoGrafo *nuevo;
    nuevo = (NodoGrafo*)malloc(sizeof(NodoGrafo));
    nuevo -> vertice = vertice;
    nuevo -> lista = NULL;
    nuevo -> enlace = *grafo;
    *grafo = nuevo;
}
void arista(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;
    NodoLista *ady;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        ady = (NodoLista*)malloc(sizeof(NodoLista));
        ady -> destino = v2;
        ady -> enlace = v1 -> lista;
        v1 -> lista = ady;
    }
}

NodoGrafo* direccion(NodoGrafo *grafo,int vert)
{
    NodoGrafo *aux;

    aux = grafo;

    while( aux -> vertice != vert && aux != NULL )
    {
        aux = aux -> enlace;
    }
    return aux;

}

void crearPila(Nodo **pila)
{
    *pila = NULL;
}

int pilaVacia(Nodo *pila)
{
    return pila == NULL;
}

void insertar(Nodo **pila,TipoDato elemento)
{
    Nodo *nuevo;

    nuevo = (Nodo*)malloc(sizeof(Nodo));
    nuevo -> elemento = elemento;
    nuevo -> siguiente = *pila;
    (*pila) = nuevo;
}

TipoDato quitar(Nodo **pila)
{
    TipoDato tem;
    Nodo *q;

    if(pilaVacia(*pila))
    {
        puts(" Se intenta sacar un elemento en pila vacia");
        exit(1);
    }

    tem = (*pila) -> elemento;
    q = *pila;
    (*pila) = (*pila) -> siguiente;
    free(q);

    return tem;
}

void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[])
{
    NodoGrafo *v1,*v2,*w;
    NodoLista *ady;
    Nodo *pila;

    crearPila(&pila);
    int i;
    int tiempos[n];
    for( i = 0; i < n; i++)
    {
        m[i] = CLAVE;
        tiempos[i] = 0;
    }
    m[v-1] = 0;

    v1 = direccion(grafo,v);
    insertar(&pila,v1);
    total = 0;
    v1 -> distancia = 0;
    while(!pilaVacia(pila))
    {

        w = quitar(&pila);
        ady = w -> lista;
        while(ady != NULL)
        {

            int k;
            k = ady -> destino -> vertice - 1;
            if(m[k] == CLAVE)
            {
                insertar(&pila,ady->destino);
                m[k] = 1;
                ady -> destino -> distancia = w -> distancia + 1;
                if(ady -> destino -> distancia > longitud)
                    longitud = ady -> destino -> distancia;

            }

            ady = ady -> enlace;
        }

    }


#include <stdio.h>
#include <stdlib.h>
#define CLAVE -1

typedef struct nodoDirectorio{
    int vertice;
    struct nodoAdyacente *lista;
    struct nodoDirectorio *enlace;
    int distancia;

} NodoGrafo;
typedef NodoGrafo* TipoDato;

typedef struct nodo
{
    TipoDato elemento;
    struct nodo *siguiente;
} Nodo;

void crearPila(Nodo **pila);
void insertar(Nodo **pila,TipoDato elemento);
TipoDato quitar(Nodo **pila);
int pilaVacia(Nodo *pila);

typedef struct nodoAdyacente
{
    struct nodoDirectorio *destino;
    struct nodoAdyacente *enlace;
} NodoLista;

void nuevoVertice(NodoGrafo **grafo, int vertice);
void arista(NodoGrafo *grafo, int org, int dst);
NodoGrafo* direccion(NodoGrafo *grafo,int vert);
void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[]);
int longitud=0;
int maximo=0;

int main()
{
    NodoGrafo* cabeza;
    cabeza = NULL;

    freopen("input.txt","r",stdin);
    freopen ("output.txt","w",stdout);
    int k,n,mayor=0,total=0;
    int nro;
    scanf("%d",&nro);
    NodoGrafo *vec[nro];

    int m[nro];

        int i,x,y;
    for(k=0;k<nro;k++){

        vec[k]=NULL;
        scanf("%d",&n);
        for( i = 1; i <= n; i++)
        {
            nuevoVertice(&vec[k],i);
        }
        for( i = 1; i <=n-1; i++)
        {
            scanf("%d%d",&x,&y);
            arista(vec[k],x,y);
            arista(vec[k],y,x);

         }
         longitud=0;
         maximo=0;
        for( i =1; i<= n;i++)
        {
            recorreProfundidad(vec[k],n,i,m);
            if(longitud>maximo){
                    maximo=longitud;
            }
        }

        total=total+maximo;
    }
    printf("%d",total);
        return 0;

}

void nuevoVertice(NodoGrafo **grafo, int vertice)
{
    NodoGrafo *nuevo;
    nuevo = (NodoGrafo*)malloc(sizeof(NodoGrafo));
    nuevo -> vertice = vertice;
    nuevo -> lista = NULL;
    nuevo -> enlace = *grafo;
    *grafo = nuevo;
}

void arista(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;
    NodoLista *ady;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        ady = (NodoLista*)malloc(sizeof(NodoLista));
        ady -> destino = v2;
        ady -> enlace = v1 -> lista;
        v1 -> lista = ady;
    }
}

NodoGrafo* direccion(NodoGrafo *grafo,int vert)
{
    NodoGrafo *aux;

    aux = grafo;

    while( aux -> vertice != vert && aux != NULL )
    {
        aux = aux -> enlace;
    }
    return aux;
}

void borrarArco(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        NodoLista *ady;
        NodoLista *a = NULL;
        ady = v1 -> lista;
        while(ady)
        {
            if(ady -> destino == v2)
            {
                if(a == NULL)
                    v1 -> lista = ady -> enlace;
                else
                    a -> enlace = ady -> enlace;
                free(ady);
                ady = NULL;
            }
            else
            {
                a = ady;
                ady = ady -> enlace;
            }
        }
    }
}

void crearPila(Nodo **pila)
{
    *pila = NULL;
}

int pilaVacia(Nodo *pila)
{
    return pila == NULL;
}

void insertar(Nodo **pila,TipoDato elemento)
{
    Nodo *nuevo;

    nuevo = (Nodo*)malloc(sizeof(Nodo));
    nuevo -> elemento = elemento;
    nuevo -> siguiente = *pila;
    (*pila) = nuevo;
}

TipoDato quitar(Nodo **pila)
{
    TipoDato tem;
    Nodo *q;

    if(pilaVacia(*pila))
    {
        puts(" Se intenta sacar un elemento en pila vacia");
        exit(1);
    }
     tem = (*pila) -> elemento;
    q = *pila;
    (*pila) = (*pila) -> siguiente;
    free(q);

    return tem;
}

void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[])
{
    NodoGrafo *v1,*v2,*z;
    NodoLista *ady;
    Nodo *pila;

    crearPila(&pila);
    int i;
    for( i = 0; i < n; i++)
    {
        m[i] = CLAVE;

    }
    m[v-1] = 0;
    v1 = direccion(grafo,v);
    insertar(&pila,v1);
    v1 -> distancia = 0;
    while(!pilaVacia(pila))
    {
        z = quitar(&pila);
        ady = z -> lista;
        while(ady != NULL)
        {
            int k;
            k = ady -> destino -> vertice - 1;
            if(m[k] == CLAVE)
            {
                insertar(&pila,ady->destino);
                m[k] = 1;
                ady -> destino -> distancia = z -> distancia + 1;
                if(ady -> destino -> distancia >longitud)
                   longitud=ady -> destino -> distancia ;

            }
                ady = ady -> enlace;

        }

    }
}


#include <stdio.h>
#include <stdlib.h>
#define CLAVE -1

typedef struct nodoDirectorio{
    int vertice;
    struct nodoAdyacente *lista;
    struct nodoDirectorio *enlace;
    int distancia;

} NodoGrafo;
typedef NodoGrafo* TipoDato;

typedef struct nodo
{
    TipoDato elemento;
    struct nodo *siguiente;
} Nodo;

void crearPila(Nodo **pila);
void insertar(Nodo **pila,TipoDato elemento);
TipoDato quitar(Nodo **pila);
int pilaVacia(Nodo *pila);

typedef struct nodoAdyacente
{
    struct nodoDirectorio *destino;
    struct nodoAdyacente *enlace;
} NodoLista;

void nuevoVertice(NodoGrafo **grafo, int vertice);
void arista(NodoGrafo *grafo, int org, int dst);
NodoGrafo* direccion(NodoGrafo *grafo,int vert);
void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[]);
int longitud=0;
int maximo=0;

int main()
{
    NodoGrafo* cabeza;
    cabeza = NULL;

    freopen("input.txt","r",stdin);
    freopen ("output.txt","w",stdout);
    int k,n,nro,mayor=0;
    scanf("%d",&nro);
    NodoGrafo *vec[nro];
    int m[n];

        int i,x,y;
    for(k<0;k<nro;k++){

        vec[n]=NULL;
        scanf("%d",&n);
        for( i = 1; i <= n; i++)
        {
            nuevoVertice(&vec[k],i);
        }
        for( i = 1; i <=n-1; i++)
        {
            scanf("%d%d",&x,&y);
            arista(cabeza,x,y);
            arista(cabeza,y,x);

        }
        for( i =1; i<= n;i++)
        {
            recorreProfundidad(cabeza,n,i,m);
        }
        if(longitud>maximo)maximo=longitud;
        longitud=0;
    }
    printf("%d",longitud);
        return 0;

}

void nuevoVertice(NodoGrafo **grafo, int vertice)
{
    NodoGrafo *nuevo;
    nuevo = (NodoGrafo*)malloc(sizeof(NodoGrafo));
    nuevo -> vertice = vertice;
    nuevo -> lista = NULL;
    nuevo -> enlace = *grafo;
    *grafo = nuevo;
}

void arista(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;
    NodoLista *ady;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        ady = (NodoLista*)malloc(sizeof(NodoLista));
        ady -> destino = v2;
        ady -> enlace = v1 -> lista;
        v1 -> lista = ady;
    }
}

NodoGrafo* direccion(NodoGrafo *grafo,int vert)
{
    NodoGrafo *aux;

    aux = grafo;

    while( aux -> vertice != vert && aux != NULL )
    {
        aux = aux -> enlace;
    }
    return aux;
}

void borrarArco(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        NodoLista *ady;
        NodoLista *a = NULL;
        ady = v1 -> lista;
        while(ady)
        {
            if(ady -> destino == v2)
            {
                if(a == NULL)
                    v1 -> lista = ady -> enlace;
                else
                    a -> enlace = ady -> enlace;
                free(ady);
                ady = NULL;
            }
            else
            {
                a = ady;
                ady = ady -> enlace;
            }
        }
    }
}

void crearPila(Nodo **pila)
{
    *pila = NULL;
}

int pilaVacia(Nodo *pila)
{
    return pila == NULL;
}

void insertar(Nodo **pila,TipoDato elemento)
{
    Nodo *nuevo;

    nuevo = (Nodo*)malloc(sizeof(Nodo));
    nuevo -> elemento = elemento;
    nuevo -> siguiente = *pila;
    (*pila) = nuevo;
}

TipoDato quitar(Nodo **pila)
{
    TipoDato tem;
    Nodo *q;

    if(pilaVacia(*pila))
    {
        puts(" Se intenta sacar un elemento en pila vacia");
        exit(1);
    }
     tem = (*pila) -> elemento;
    q = *pila;
    (*pila) = (*pila) -> siguiente;
    free(q);

    return tem;
}

void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[])
{
    NodoGrafo *v1,*v2,*z;
    NodoLista *ady;
    Nodo *pila;

    crearPila(&pila);
    int i;
    for( i = 0; i < n; i++)
    {
        m[i] = CLAVE;

    }
    m[v-1] = 0;
    v1 = direccion(grafo,v);
    insertar(&pila,v1);
    v1 -> distancia = 0;
    while(!pilaVacia(pila))
    {
        z = quitar(&pila);
        ady = z -> lista;
        while(ady != NULL)
        {
            int k;
            k = ady -> destino -> vertice - 1;
            if(m[k] == CLAVE)
            {
                insertar(&pila,ady->destino);
                m[k] = 1;
                ady -> destino -> distancia = z -> distancia + 1;
                if(ady -> destino -> distancia >longitud)
                   longitud=ady -> destino -> distancia ;

            }
                ady = ady -> enlace;

        }

    }
}


#include <stdio.h>
#include <stdlib.h>
#define CLAVE -1

typedef struct nodoDirectorio{
    int vertice;
    struct nodoAdyacente *lista;
    struct nodoDirectorio *enlace;
    int distancia;

} NodoGrafo;
typedef NodoGrafo* TipoDato;

typedef struct nodo
{
    TipoDato elemento;
    struct nodo *siguiente;
} Nodo;

void crearPila(Nodo **pila);
void insertar(Nodo **pila,TipoDato elemento);
TipoDato quitar(Nodo **pila);
int pilaVacia(Nodo *pila);

typedef struct nodoAdyacente
{
    struct nodoDirectorio *destino;
    struct nodoAdyacente *enlace;
} NodoLista;

void nuevoVertice(NodoGrafo **grafo, int vertice);
void arista(NodoGrafo *grafo, int org, int dst);
NodoGrafo* direccion(NodoGrafo *grafo,int vert);
void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[]);
int longitud=0;
int maximo=0;

int main()
{
    NodoGrafo* cabeza;
    cabeza = NULL;

    freopen("input.txt","r",stdin);
    freopen ("output.txt","w",stdout);
    int k,n,nro,mayor=0;
    scanf("%d",&nro);
    NodoGrafo *vec[nro];
    int m[n],total;

        int i,x,y;
    for(k=0;k<nro;k++){

        vec[k]=NULL;
        scanf("%d",&n);
        for( i = 1; i <= n; i++)
        {
            nuevoVertice(&vec[k],i);
        }
        for( i = 1; i <=n-1; i++)
        {
            scanf("%d%d",&x,&y);
            arista(vec[k],x,y);
            arista(vec[k],y,x);

        }
        for( i =1; i<= n;i++)
        {
            recorreProfundidad(vec[k],n,i,m);
            if(longitud>maximo)maximo=longitud;
        }

        total=+maximo;
    }
    printf("%d",total);
        return 0;

}

void nuevoVertice(NodoGrafo **grafo, int vertice)
{
    NodoGrafo *nuevo;
    nuevo = (NodoGrafo*)malloc(sizeof(NodoGrafo));
    nuevo -> vertice = vertice;
    nuevo -> lista = NULL;
    nuevo -> enlace = *grafo;
    *grafo = nuevo;
}

void arista(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;
    NodoLista *ady;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        ady = (NodoLista*)malloc(sizeof(NodoLista));
        ady -> destino = v2;
        ady -> enlace = v1 -> lista;
        v1 -> lista = ady;
    }
}

NodoGrafo* direccion(NodoGrafo *grafo,int vert)
{
    NodoGrafo *aux;

    aux = grafo;

    while( aux -> vertice != vert && aux != NULL )
    {
        aux = aux -> enlace;
    }
    return aux;
}

void borrarArco(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        NodoLista *ady;
        NodoLista *a = NULL;
        ady = v1 -> lista;
        while(ady)
        {
            if(ady -> destino == v2)
            {
                if(a == NULL)
                    v1 -> lista = ady -> enlace;
                else
                    a -> enlace = ady -> enlace;
                free(ady);
                ady = NULL;
            }
            else
            {
                a = ady;
                ady = ady -> enlace;
            }
        }
    }
}

void crearPila(Nodo **pila)
{
    *pila = NULL;
}

int pilaVacia(Nodo *pila)
{
    return pila == NULL;
}

void insertar(Nodo **pila,TipoDato elemento)
{
    Nodo *nuevo;

    nuevo = (Nodo*)malloc(sizeof(Nodo));
    nuevo -> elemento = elemento;
    nuevo -> siguiente = *pila;
    (*pila) = nuevo;
}

TipoDato quitar(Nodo **pila)
{
    TipoDato tem;
    Nodo *q;

    if(pilaVacia(*pila))
    {
        puts(" Se intenta sacar un elemento en pila vacia");
        exit(1);
    }
     tem = (*pila) -> elemento;
    q = *pila;
    (*pila) = (*pila) -> siguiente;
    free(q);

    return tem;
}

void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[])
{
    NodoGrafo *v1,*v2,*z;
    NodoLista *ady;
    Nodo *pila;

    crearPila(&pila);
    int i;
    for( i = 0; i < n; i++)
    {
        m[i] = CLAVE;

    }
    m[v-1] = 0;
    v1 = direccion(grafo,v);
    insertar(&pila,v1);
    v1 -> distancia = 0;
    while(!pilaVacia(pila))
    {
        z = quitar(&pila);
        ady = z -> lista;
        while(ady != NULL)
        {
            int k;
            k = ady -> destino -> vertice - 1;
            if(m[k] == CLAVE)
            {
                insertar(&pila,ady->destino);
                m[k] = 1;
                ady -> destino -> distancia = z -> distancia + 1;
                if(ady -> destino -> distancia >longitud)
                   longitud=ady -> destino -> distancia ;

            }
                ady = ady -> enlace;

        }

    }
}


typedef struct nodoDirectorio{
    int vertice;
    struct nodoAdyacente *lista;
    struct nodoDirectorio *enlace;
    int distancia;

} NodoGrafo;
typedef NodoGrafo* TipoDato;

typedef struct nodo
{
    TipoDato elemento;
    struct nodo *siguiente;
} Nodo;

void crearPila(Nodo **pila);
void insertar(Nodo **pila,TipoDato elemento);
TipoDato quitar(Nodo **pila);
int pilaVacia(Nodo *pila);

typedef struct nodoAdyacente
{
    struct nodoDirectorio *destino;
    struct nodoAdyacente *enlace;
} NodoLista;

void nuevoVertice(NodoGrafo **grafo, int vertice);
void arista(NodoGrafo *grafo, int org, int dst);
NodoGrafo* direccion(NodoGrafo *grafo,int vert);
void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[]);
int longitud=0;
int maximo=0;

int main()
{
    NodoGrafo* cabeza;
    cabeza = NULL;

    freopen("input.txt","r",stdin);
    freopen ("output.txt","w",stdout);
    int k,n,nro,mayor=0;
    scanf("%d",&nro);
    NodoGrafo *vec[nro];
    int m[n],total;

        int i,x,y;
    for(k<0;k<nro;k++){

        vec[n]=NULL;
        scanf("%d",&n);
        for( i = 1; i <= n; i++)
        {
            nuevoVertice(&vec[k],i);
        }
        for( i = 1; i <=n-1; i++)
        {
            scanf("%d%d",&x,&y);
            arista(cabeza,x,y);
            arista(cabeza,y,x);

        }
        for( i =1; i<= n;i++)
        {
            recorreProfundidad(cabeza,n,i,m);
            if(longitud>maximo)maximo=longitud;
        }

        total=+maximo;
    }
    printf("%d",total);
        return 0;

}

void nuevoVertice(NodoGrafo **grafo, int vertice)
{
    NodoGrafo *nuevo;
    nuevo = (NodoGrafo*)malloc(sizeof(NodoGrafo));
    nuevo -> vertice = vertice;
    nuevo -> lista = NULL;
    nuevo -> enlace = *grafo;
    *grafo = nuevo;
}

void arista(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;
    NodoLista *ady;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        ady = (NodoLista*)malloc(sizeof(NodoLista));
        ady -> destino = v2;
        ady -> enlace = v1 -> lista;
        v1 -> lista = ady;
    }
}

NodoGrafo* direccion(NodoGrafo *grafo,int vert)
{
    NodoGrafo *aux;

    aux = grafo;

    while( aux -> vertice != vert && aux != NULL )
    {
        aux = aux -> enlace;
    }
    return aux;
}

void borrarArco(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        NodoLista *ady;
        NodoLista *a = NULL;
        ady = v1 -> lista;
        while(ady)
        {
            if(ady -> destino == v2)
            {
                if(a == NULL)
                    v1 -> lista = ady -> enlace;
                else
                    a -> enlace = ady -> enlace;
                free(ady);
                ady = NULL;
            }
            else
            {
                a = ady;
                ady = ady -> enlace;
            }
        }
    }
}

void crearPila(Nodo **pila)
{
    *pila = NULL;
}

int pilaVacia(Nodo *pila)
{
    return pila == NULL;
}

void insertar(Nodo **pila,TipoDato elemento)
{
    Nodo *nuevo;

    nuevo = (Nodo*)malloc(sizeof(Nodo));
    nuevo -> elemento = elemento;
    nuevo -> siguiente = *pila;
    (*pila) = nuevo;
}

TipoDato quitar(Nodo **pila)
{
    TipoDato tem;
    Nodo *q;

    if(pilaVacia(*pila))
    {
        puts(" Se intenta sacar un elemento en pila vacia");
        exit(1);
    }
     tem = (*pila) -> elemento;
    q = *pila;
    (*pila) = (*pila) -> siguiente;
    free(q);

    return tem;
}

void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[])
{
    NodoGrafo *v1,*v2,*z;
    NodoLista *ady;
    Nodo *pila;

    crearPila(&pila);
    int i;
    for( i = 0; i < n; i++)
    {
        m[i] = CLAVE;

    }
    m[v-1] = 0;
    v1 = direccion(grafo,v);
    insertar(&pila,v1);
    v1 -> distancia = 0;
    while(!pilaVacia(pila))
    {
        z = quitar(&pila);
        ady = z -> lista;
        while(ady != NULL)
        {
            int k;
            k = ady -> destino -> vertice - 1;
            if(m[k] == CLAVE)
            {
                insertar(&pila,ady->destino);
                m[k] = 1;
                ady -> destino -> distancia = z -> distancia + 1;
                if(ady -> destino -> distancia >longitud)
                   longitud=ady -> destino -> distancia ;

            }
                ady = ady -> enlace;

        }

    }
}


#include <stdio.h>
#include <stdlib.h>
#define CLAVE -1

typedef struct nodoDirectorio{
    int vertice;
    struct nodoAdyacente *lista;
    struct nodoDirectorio *enlace;
    int distancia;

} NodoGrafo;
typedef NodoGrafo* TipoDato;

typedef struct nodo
{
    TipoDato elemento;
    struct nodo *siguiente;
} Nodo;

void crearPila(Nodo **pila);
void insertar(Nodo **pila,TipoDato elemento);
TipoDato quitar(Nodo **pila);
int pilaVacia(Nodo *pila);

typedef struct nodoAdyacente
{
    struct nodoDirectorio *destino;
    struct nodoAdyacente *enlace;
} NodoLista;

void nuevoVertice(NodoGrafo **grafo, int vertice);
void arista(NodoGrafo *grafo, int org, int dst);
NodoGrafo* direccion(NodoGrafo *grafo,int vert);
void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[]);
int longitud=0;
int maximo=0;

int main()
{
    NodoGrafo* cabeza;
    cabeza = NULL;

    freopen("input.txt","r",stdin);
    freopen ("output.txt","w",stdout);
    int k,n,nro,mayor=0;
    scanf("%d",&nro);
    NodoGrafo *vec[nro];
    int m[n],total;

        int i,x,y;
    for(k<0;k<nro;k++){

        vec[n]=NULL;
        scanf("%d",&n);
        for( i = 1; i <= n; i++)
        {
            nuevoVertice(&vec[k],i);
        }
        for( i = 1; i <=n-1; i++)
        {
            scanf("%d%d",&x,&y);
            arista(cabeza,x,y);
            arista(cabeza,y,x);

        }
        for( i =1; i<= n;i++)
        {
            recorreProfundidad(cabeza,n,i,m);
            if(longitud>maximo)maximo=longitud;
        }

        total=+maximo;
    }
    printf("%d",total);
        return 0;

}

void nuevoVertice(NodoGrafo **grafo, int vertice)
{
    NodoGrafo *nuevo;
    nuevo = (NodoGrafo*)malloc(sizeof(NodoGrafo));
    nuevo -> vertice = vertice;
    nuevo -> lista = NULL;
    nuevo -> enlace = *grafo;
    *grafo = nuevo;
}

void arista(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;
    NodoLista *ady;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        ady = (NodoLista*)malloc(sizeof(NodoLista));
        ady -> destino = v2;
        ady -> enlace = v1 -> lista;
        v1 -> lista = ady;
    }
}

NodoGrafo* direccion(NodoGrafo *grafo,int vert)
{
    NodoGrafo *aux;

    aux = grafo;

    while( aux -> vertice != vert && aux != NULL )
    {
        aux = aux -> enlace;
    }
    return aux;
}

void borrarArco(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        NodoLista *ady;
        NodoLista *a = NULL;
        ady = v1 -> lista;
        while(ady)
        {
            if(ady -> destino == v2)
            {
                if(a == NULL)
                    v1 -> lista = ady -> enlace;
                else
                    a -> enlace = ady -> enlace;
                free(ady);
                ady = NULL;
            }
            else
            {
                a = ady;
                ady = ady -> enlace;
            }
        }
    }
}

void crearPila(Nodo **pila)
{
    *pila = NULL;
}

int pilaVacia(Nodo *pila)
{
    return pila == NULL;
}

void insertar(Nodo **pila,TipoDato elemento)
{
    Nodo *nuevo;

    nuevo = (Nodo*)malloc(sizeof(Nodo));
    nuevo -> elemento = elemento;
    nuevo -> siguiente = *pila;
    (*pila) = nuevo;
}

TipoDato quitar(Nodo **pila)
{
    TipoDato tem;
    Nodo *q;

    if(pilaVacia(*pila))
    {
        puts(" Se intenta sacar un elemento en pila vacia");
        exit(1);
    }
     tem = (*pila) -> elemento;
    q = *pila;
    (*pila) = (*pila) -> siguiente;
    free(q);

    return tem;
}

void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[])
{
    NodoGrafo *v1,*v2,*z;
    NodoLista *ady;
    Nodo *pila;

    crearPila(&pila);
    int i;
    for( i = 0; i < n; i++)
    {
        m[i] = CLAVE;

    }
    m[v-1] = 0;
    v1 = direccion(grafo,v);
    insertar(&pila,v1);
    v1 -> distancia = 0;
    while(!pilaVacia(pila))
    {
        z = quitar(&pila);
        ady = z -> lista;
        while(ady != NULL)
        {
            int k;
            k = ady -> destino -> vertice - 1;
            if(m[k] == CLAVE)
            {
                insertar(&pila,ady->destino);
                m[k] = 1;
                ady -> destino -> distancia = z -> distancia + 1;
                if(ady -> destino -> distancia >longitud)
                   longitud=ady -> destino -> distancia ;

            }
                ady = ady -> enlace;

        }

    }
}


#include <stdio.h>
#include <stdlib.h>
#define CLAVE -1

typedef struct nodoDirectorio{
    int vertice;
    struct nodoAdyacente *lista;
    struct nodoDirectorio *enlace;
    int distancia;

} NodoGrafo;
typedef NodoGrafo* TipoDato;

typedef struct nodo
{
    TipoDato elemento;
    struct nodo *siguiente;
} Nodo;

void crearPila(Nodo **pila);
void insertar(Nodo **pila,TipoDato elemento);
TipoDato quitar(Nodo **pila);
int pilaVacia(Nodo *pila);

typedef struct nodoAdyacente
{
    struct nodoDirectorio *destino;
    struct nodoAdyacente *enlace;
} NodoLista;

void nuevoVertice(NodoGrafo **grafo, int vertice);
void arista(NodoGrafo *grafo, int org, int dst);
NodoGrafo* direccion(NodoGrafo *grafo,int vert);
void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[]);
int longitud=0;
int maximo=0;

int main()
{
    NodoGrafo* cabeza;
    cabeza = NULL;

   // freopen("input.txt","r",stdin);
    //freopen ("output.txt","w",stdout);
    int k,n,mayor=0,total=0;
    int nro;
    scanf("%d",&nro);
    NodoGrafo *vec[nro];

    int m[nro];

        int i,x,y;
    for(k=0;k<nro;k++){

        vec[k]=NULL;
        scanf("%d",&n);
        for( i = 1; i <= n; i++)
        {
            nuevoVertice(&vec[k],i);
        }
        for( i = 1; i <=n-1; i++)
        {
            scanf("%d%d",&x,&y);
            arista(vec[k],x,y);
            arista(vec[k],y,x);

        }
        for( i =1; i<= n;i++)
        {
            recorreProfundidad(vec[k],n,i,m);
            if(longitud>maximo){maximo=longitud;}
        }

        total=total+maximo;
    }
    printf("%d",total);
        return 0;

}

void nuevoVertice(NodoGrafo **grafo, int vertice)
{
    NodoGrafo *nuevo;
    nuevo = (NodoGrafo*)malloc(sizeof(NodoGrafo));
    nuevo -> vertice = vertice;
    nuevo -> lista = NULL;
    nuevo -> enlace = *grafo;
    *grafo = nuevo;
}

void arista(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;
    NodoLista *ady;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        ady = (NodoLista*)malloc(sizeof(NodoLista));
        ady -> destino = v2;
        ady -> enlace = v1 -> lista;
        v1 -> lista = ady;
    }
}

NodoGrafo* direccion(NodoGrafo *grafo,int vert)
{
    NodoGrafo *aux;

    aux = grafo;

    while( aux -> vertice != vert && aux != NULL )
    {
        aux = aux -> enlace;
    }
    return aux;
}

void borrarArco(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        NodoLista *ady;
        NodoLista *a = NULL;
        ady = v1 -> lista;
        while(ady)
        {
            if(ady -> destino == v2)
            {
                if(a == NULL)
                    v1 -> lista = ady -> enlace;
                else
                    a -> enlace = ady -> enlace;
                free(ady);
                ady = NULL;
            }
            else
            {
                a = ady;
                ady = ady -> enlace;
            }
        }
    }
}

void crearPila(Nodo **pila)
{
    *pila = NULL;
}

int pilaVacia(Nodo *pila)
{
    return pila == NULL;
}

void insertar(Nodo **pila,TipoDato elemento)
{
    Nodo *nuevo;

    nuevo = (Nodo*)malloc(sizeof(Nodo));
    nuevo -> elemento = elemento;
    nuevo -> siguiente = *pila;
    (*pila) = nuevo;
}

TipoDato quitar(Nodo **pila)
{
    TipoDato tem;
    Nodo *q;

    if(pilaVacia(*pila))
    {
        puts(" Se intenta sacar un elemento en pila vacia");
        exit(1);
    }
     tem = (*pila) -> elemento;
    q = *pila;
    (*pila) = (*pila) -> siguiente;
    free(q);

    return tem;
}

void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[])
{
    NodoGrafo *v1,*v2,*z;
    NodoLista *ady;
    Nodo *pila;

    crearPila(&pila);
    int i;
    for( i = 0; i < n; i++)
    {
        m[i] = CLAVE;

    }
    m[v-1] = 0;
    v1 = direccion(grafo,v);
    insertar(&pila,v1);
    v1 -> distancia = 0;
    while(!pilaVacia(pila))
    {
        z = quitar(&pila);
        ady = z -> lista;
        while(ady != NULL)
        {
            int k;
            k = ady -> destino -> vertice - 1;
            if(m[k] == CLAVE)
            {
                insertar(&pila,ady->destino);
                m[k] = 1;
                ady -> destino -> distancia = z -> distancia + 1;
                if(ady -> destino -> distancia >longitud)
                   longitud=ady -> destino -> distancia ;

            }
                ady = ady -> enlace;

        }

    }
}


#include <stdio.h>
#include <stdlib.h>
#define CLAVE -1

typedef struct nodoDirectorio{
    int vertice;
    struct nodoAdyacente *lista;
    struct nodoDirectorio *enlace;
    int distancia;

} NodoGrafo;

typedef NodoGrafo* TipoDato;

typedef struct nodo
{
    TipoDato elemento;
    struct nodo *siguiente;
} Nodo;

void crearPila(Nodo **pila);
void insertar(Nodo **pila,TipoDato elemento);
TipoDato quitar(Nodo **pila);
int pilaVacia(Nodo *pila);

typedef struct nodoAdyacente
{
    struct nodoDirectorio *destino;
    struct nodoAdyacente *enlace;
} NodoLista;

void nuevoVertice(NodoGrafo **grafo, int vertice);
void arista(NodoGrafo *grafo, int org, int dst);
NodoGrafo* direccion(NodoGrafo *grafo,int vert);
void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[]);

int total = 0;
int longitud = 0;

int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int nro;
    scanf("%d",&nro);
    NodoGrafo *vec[nro];
    int i,x,y,mayor = 0, k,total=0;
    for( k = 0; k < nro; k++)
    {
        vec[k] = NULL;

        int n;
        scanf("%d",&n);

        for( i = 1; i <= n; i++)
        {
            nuevoVertice(&vec[k],i);
        }
        for( i = 1; i <=n-1; i++)
        {
            scanf("%d%d",&x,&y);

            arista(vec[k],x,y);
            arista(vec[k],y,x);

        }
           int m[n];
            mayor = 0;
           longitud = 0;
        for( i = 1; i <= n; i++)
        {
            recorreProfundidad(vec[k],n,i,m);
            if(longitud > mayor)
            mayor = longitud;
        }
        total = total + mayor;
    }
            printf("%d",total);

    return 0;

}
void nuevoVertice(NodoGrafo **grafo, int vertice)
{
    NodoGrafo *nuevo;
    nuevo = (NodoGrafo*)malloc(sizeof(NodoGrafo));
    nuevo -> vertice = vertice;
    nuevo -> lista = NULL;
    nuevo -> enlace = *grafo;
    *grafo = nuevo;
}
void arista(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;
    NodoLista *ady;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        ady = (NodoLista*)malloc(sizeof(NodoLista));
        ady -> destino = v2;
        ady -> enlace = v1 -> lista;
        v1 -> lista = ady;
    }
}

NodoGrafo* direccion(NodoGrafo *grafo,int vert)
{
    NodoGrafo *aux;

    aux = grafo;

    while( aux -> vertice != vert && aux != NULL )
    {
        aux = aux -> enlace;
    }
    return aux;

}

void crearPila(Nodo **pila)
{
    *pila = NULL;
}

int pilaVacia(Nodo *pila)
{
    return pila == NULL;
}

void insertar(Nodo **pila,TipoDato elemento)
{
    Nodo *nuevo;

    nuevo = (Nodo*)malloc(sizeof(Nodo));
    nuevo -> elemento = elemento;
    nuevo -> siguiente = *pila;
    (*pila) = nuevo;
}

TipoDato quitar(Nodo **pila)
{
    TipoDato tem;
    Nodo *q;

    if(pilaVacia(*pila))
    {
        puts(" Se intenta sacar un elemento en pila vacia");
        exit(1);
    }

    tem = (*pila) -> elemento;
    q = *pila;
    (*pila) = (*pila) -> siguiente;
    free(q);

    return tem;
}

void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[])
{
    NodoGrafo *v1,*v2,*w;
    NodoLista *ady;
    Nodo *pila;

    crearPila(&pila);
    int i;
    int tiempos[n];
    for( i = 0; i < n; i++)
    {
        m[i] = CLAVE;
        tiempos[i] = 0;
    }
    m[v-1] = 0;

    v1 = direccion(grafo,v);
    insertar(&pila,v1);
    total = 0;
    v1 -> distancia = 0;
    while(!pilaVacia(pila))
    {

        w = quitar(&pila);
        ady = w -> lista;
        while(ady != NULL)
        {

            int k;
            k = ady -> destino -> vertice - 1;
            if(m[k] == CLAVE)
            {
                insertar(&pila,ady->destino);
                m[k] = 1;
                ady -> destino -> distancia = w -> distancia + 1;
                if(ady -> destino -> distancia > longitud)
                    longitud = ady -> destino -> distancia;

            }

            ady = ady -> enlace;
        }

    }

}


#include <stdio.h>
#include <stdlib.h>
int uniones(int x, int f, int a[100][100], int b[100], int p[100]);
int main()
{
     int n, k, sum = 0, i, j;
     FILE *in, *ou;

     in = fopen("input.txt", "r");
     ou = fopen("output.txt", "w");

     fscanf(in, "%d", &n);

     for (i = 0; i < n; i++) {
      int a[100][100];
      int p[100] = {0};
      int m = 0;

      fscanf(in, "%d", &k);

      for (j = 0; j < k - 1; j++) {
           int x, y;

           fscanf(in, "%d %d", &x, &y);

           x--;
           y--;

           a[x][p[x]++] = y;
           a[y][p[y]++] = x;
      }

      for (j = 0; j < k; j++) {
           int b[100] = {0};
           int c = uniones(j, 0, a, b, p);

           if (c > m) m = c;
      }

      sum += m;
     }

     fprintf(ou, "%d\n", sum);

     fclose(in);
     fclose(ou);

     return 0;
}

int uniones(int x, int f, int a[100][100], int b[100], int p[100])
{
     int a1 = 0, a2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = uniones(a[x][i], 1, a, b, p) + 1;

           if (m > a1) {
            a2 = a1;
            a1 = m;
           } else if (m > a2) {
            a2 = m;
           }
      }
     }

     if (f == 0) {
      return a1 + a2;
     } else {
      return a1;
     }
}


 #include <stdlib.h>
 #include <stdio.h>
 #include <memory.h>
 #define maxn 110
 int first[maxn],v[maxn*2],next[maxn*2];
 int len,e;

 void init(){
     e = 0;
     memset(first,-1,sizeof(first));
 }

 void add_edge(int a,int b){
     v[e] = b;
     next[e] = first[a];
     first[a] = e++;
 }

 int dfs(int u,int fa){
     int ret = 0,maxdep,i;
     for(i = first[u];i != -1;i = next[i]){
         if(v[i] == fa)  continue;
         maxdep = dfs(v[i],u);
         len = max(len,ret + maxdep + 1);
         ret = max(ret,maxdep + 1);
     }
     return ret;
 }
int max(int n1,int n2){
    return (n1<n2)?n2:n1;
}

 int main(){
     fopen("input.txt", "r");
     fopen("output.txt", "w");
     int n,m;
     while(scanf("%d",&n) != EOF){
         int ans = 0;
         while(n--){
             scanf("%d",&m);
             init();
             len = 0;
             int i;
             for(i = 0;i < m-1;i++){
                 int a,b;
                 scanf("%d%d",&a,&b);
                 add_edge(a,b);
                 add_edge(b,a);
             }
             dfs(1,-1);
             ans += len;
         }
         printf("%d\n",ans);
    }
}


 #include <stdlib.h>
 #include <stdio.h>
 #include <memory.h>
 #define maxn 110
 int first[maxn],v[maxn*2],next[maxn*2];
 int len,e;

 void init(){
     e = 0;
     memset(first,-1,sizeof(first));
 }

 void add_edge(int a,int b){
     v[e] = b;
     next[e] = first[a];
     first[a] = e++;
 }

 int dfs(int u,int fa){
     int ret = 0,maxdep,i;
     for(i = first[u];i != -1;i = next[i]){
         if(v[i] == fa)  continue;
         maxdep = dfs(v[i],u);
         len = max(len,ret + maxdep + 1);
         ret = max(ret,maxdep + 1);
     }
     return ret;
 }
int max(int n1,int n2){
    return (n1<n2)?n2:n1;
}

 int main(){
     FILE *ptrIn=fopen("input.txt", "r");
     FILE *ptrOu=fopen("output.txt", "w");
     int n,m;
     while(fscanf(ptrIn,"%d",&n) != EOF){
         int ans = 0;
         while(n--){
             fscanf(ptrIn,"%d",&m);
             init();
             len = 0;
             int i;
             for(i = 0;i < m-1;i++){
                 int a,b;
                 fscanf(ptrIn,"%d%d",&a,&b);
                 add_edge(a,b);
                 add_edge(b,a);
             }
             dfs(1,-1);
             ans += len;
         }
         fprintf(ptrOu,"%d",ans);
    }
}


#include <stdlib.h>
#include <stdio.h>
#include <memory.h>
#define maxn 110
int primero[maxn],v[maxn*2],siguiente[maxn*2];
int len,e;
void init();
void add_edge(int a,int b);
int max(int n1,int n2);
int dfs(int u,int fa);

int main(){
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    int n,m;
    while(fscanf(ptrIn,"%d",&n) != EOF){
        int ans = 0;
        while(n--){
            fscanf(ptrIn,"%d",&m);
            init();
            len = 0;
            int i;
            for(i = 0;i < m-1;i++){
                int a,b;
                fscanf(ptrIn,"%d%d",&a,&b);
                add_edge(a,b);
                add_edge(b,a);
            }
            dfs(1,-1);
            ans += len;
        }
        fprintf(ptrOu,"%d",ans);
    }
}

void init(){
    e = 0;
    memset(primero,-1,sizeof(primero));
}

void add_edge(int a,int b){
    v[e] = b;
    siguiente[e] = primero[a];
    primero[a] = e++;
}

int dfs(int u,int fa){
    int ret = 0,maxdep,i;
    for(i = primero[u];i != -1;i = siguiente[i]){
        if(v[i] == fa)
            continue;
        maxdep = dfs(v[i],u);
        len = max(len,ret + maxdep + 1);
        ret = max(ret,maxdep + 1);
    }
    return ret;
}

int max(int n1,int n2){
   return (n1<n2)?n2:n1;
}


#include <stdio.h>
#include <string.h>
#include <stdlib.h>

FILE *ifp, *ofp ;
int i, j, n, m, edge[101][101], count[101], from, to, length ;

int max(int x, int y)
{
	return (x > y ? x : y) ;
}

int height(int root, int from)
{
	int i, result = 0 ;

	for (i = 0 ; i < count[root] ; i++)
	{
		if (edge[root][i] != from)
		{
			result = max(result, 1 + height(edge[root][i], root)) ;
		}
	}

	return result ;
}

int diameter(int root, int from)
{
	int highest1 = 0 ;
	int highest2 = 0 ;
	int i, h     = 0 ;

	for (i = 0 ; i < count[root] ; i++)
	{
		if (edge[root][i] != from)
		{
			h = height(edge[root][i], root) + 1 ;

			if (h > highest1)
			{
				highest2 = highest1 ;
				highest1 = h ;
			}
			else if (h > highest2)
			{
				highest2 = h ;
			}
		}
	}

	h = highest1 + highest2 ;

	for (i = 0 ; i < count[root] ; i++)
	{
		if (edge[root][i] != from)
		{
			h = max(h, diameter(edge[root][i], root)) ;
		}
	}

	return h ;
}

int main(void)
{
	ifp = fopen("input.txt", "r") ;
	ofp = fopen("output.txt", "w") ;

	fscanf(ifp, "%d", &n) ;

	for (i = 0 ; i < n ; i++)
	{
		for (j = 1 ; j <= 100 ; j++)
		{
			count[j] = 0 ;
		}

		fscanf(ifp, "%d", &m) ;

		for (j = 1 ; j < m ; j++)
		{
			fscanf(ifp, "%d %d", &from, &to) ;

			edge[from][count[from]++] = to ;
			edge[to][count[to]++]     = from ;
		}

		length += diameter(1, 0) ;
	}

	fprintf(ofp, "%d", length) ;

	fclose(ifp) ;
	fclose(ofp) ;

	return 0 ;
}


#include <stdio.h>
#include <string.h>
#include <stdlib.h>

FILE *ifp, *ofp ;
int i, j, n, m, edge[101][101], count[101], from, to, length ;

int max(int x, int y)
{
	return (x > y ? x : y) ;
}

int height(int root, int from)
{
	int i, result = 0 ;

	for (i = 0 ; i < count[root] ; i++)
	{
		if (edge[root][i] != from)
		{
			result = max(result, 1 + height(edge[root][i], root)) ;
		}

	}

	return result ;
}

int diameter(int root)
{
	int highest1 = 0 ;
	int highest2 = 0 ;
	int i, h     = 0 ;

	for (i = 0 ; i < count[root] ; i++)
	{
		h = height(edge[root][i], root) + 1 ;

		if (h > highest1)
		{
			highest2 = highest1 ;
			highest1 = h ;
		}
		else if (h > highest2)
		{
			highest2 = h ;
		}
	}

	return highest1 + highest2 ;
}

int main(void)
{
	ifp = fopen("input.txt", "r") ;
	ofp = fopen("output.txt", "w") ;

	fscanf(ifp, "%d", &n) ;

	for (i = 0 ; i < n ; i++)
	{
		for (j = 1 ; j <= 100 ; j++)
		{
			count[j] = 0 ;
		}

		fscanf(ifp, "%d", &m) ;

		for (j = 1 ; j < m ; j++)
		{
			fscanf(ifp, "%d %d", &from, &to) ;

			edge[from][count[from]++] = to ;
			edge[to][count[to]++]     = from ;
		}

		length += diameter(1) ;
	}

	fprintf(ofp, "%d", length) ;

	fclose(ifp) ;
	fclose(ofp) ;

	return 0 ;
}


#include <stdio.h>
#define MAX 110
int prim[MAX], sig[MAX*2],v[MAX*2];
int lenthg, t;
int busquedaNodo(int ,int );

void inicio();
void NewNodo(int x, int z);
int maximo(int x1,int x2);
int main(){
    FILE *ptrInput=fopen("input.txt", "r");
    FILE *ptrOutput=fopen("output.txt", "w");
    int n, m;
    while(fscanf(ptrInput,"%d",&n)!=EOF){
        int R=0;
        while(n--){
            fscanf(ptrInput, "%d", &m);
            inicio();
            lenthg=0;
            int i;
            for(i=0; i<m-1; i++){
                int a, b;
                fscanf(ptrInput, "%d%d", &a, &b);
                NewNodo(a, b);
                NewNodo(b, a);
            }
            busquedaNodo(1, -1);
             R+=lenthg;
        }
        fprintf(ptrOutput, "%d" , R);
    }
}
int maximo(int x1,int x2){
   return (x1<x2)?x2:x1;
}
int busquedaNodo(int c,int f){
    int r=0, maxi, i;
    for(i=prim[c]; i!=-1; i=sig[i]){
        if(v[i]==f) continue;
        maxi=busquedaNodo(v[i],c);
        lenthg=maximo(lenthg, r+maxi+1);
        r=maximo(r, maxi+1);
    }
    return r;
}
void inicio(){
    t=0;
    memset(prim, -1, sizeof(prim));
}
void NewNodo(int x, int z){
    v[t]=z;
    sig[t]=prim[x];
    prim[x]=t++;
}


#include <stdio.h>
#define MAX 110
int prim[MAX], sig[MAX*2],v[MAX*2];
int lenthg, t;
int busquedaNodo(int ,int );

void inicio();
void NewNodo(int x, int z);
int maximo(int x1,int x2);
int main(){
    FILE *ptrInput=fopen("input.txt", "r");
    FILE *ptrOutput=fopen("output.txt", "w");
    int n, m;
    while(fscanf(ptrInput,"%d",&n)!=EOF){
        int R=0;
        while(n--){
            fscanf(ptrInput, "%d", &m);
            inicio();
            lenthg=0;
            int i;
            for(i=0; i<m-1; i++){
                int a, b;
                fscanf(ptrInput, "%d%d", &a, &b);
                NewNodo(a, b);
                NewNodo(b, a);
            }
            busquedaNodo(1, -1);
             R+=l;
        }
        fprintf(ptrOutput, "%d" , R);
    }
}
int maximo(int x1,int x2){
   return (x1<x2)?x2:x1;
}
int busquedaNodo(int c,int f){
    int r=0, maxi, i;
    for(i=prim[c]; i!=-1; i=sig[i]){
        if(v[i]==f) continue;
        maxi=busqNodo(v[i],c);
        lenthg=maximo(lenthg, r+maxi+1);
        r=maximo(r, maxi+1);
    }
    return r;
}
void inicio(){
    t=0;
    memset(prim, -1, sizeof(prim));
}
void NewNodo(int x, int z){
    v[t]=z;
    sig[t]=prim[x];
    prim[x]=t++;
}


#include <stdlib.h>
#include <stdio.h>
#include <memory.h>
#define N 110

int raiz[N],nodo[N*2],siguiente[N*2];
int longitud,e;
void inicializar();
void agregar_nodo(int ,int );
int mayor(int ,int );
int bus_profundidad(int ,int );

int main(){
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    int n,m,v,a;
    while(fscanf(ptrIn,"%d",&n) != EOF){
        int res;
        res = 0;
        while(n--){
            fscanf(ptrIn,"%d",&m);
            inicializar();
            longitud;
            longitud = 0;
            int i;
            for(i = 0;i < m-1;i++){
                fscanf(ptrIn,"%d%d",&v,&a);
                agregar_nodo(v,a);
                agregar_nodo(a,v);
            }
            bus_profundidad(1,-1);
            res += longitud;
        }
        fprintf(ptrOu,"%d",res);
    }
    return 0;
}

void inicializar(){
    e = 0;
    memset(raiz,-1,sizeof(raiz));
}

void agregar_nodo(int a,int b){
    nodo[e] = b;
    siguiente[e] = raiz[a];
    raiz[a] = e++;
}

int bus_profundidad(int u,int g){
    int r,max,i;
    r = 0;
    for(i = raiz[u];i != -1;i = siguiente[i]){
        if(nodo[i] == g){
            continue;
        }
        max = bus_profundidad(nodo[i],u);
        longitud = mayor(longitud,r + max + 1);
        r = mayor(r,max + 1);
    }
    return r;
}

int mayor(int x,int y){
   if(x<y){
        return y;
   }
   else{
        return x;
   }
}


#include <stdio.h>
#include <stdlib.h>
#define  size 100

//prototipo de la funcion
int pbusqueda(int x, int f, int vector1[size][size], int vector2[size], int vector3[size]);

int main()
{
     int n, k, sum = 0, i, j;
     FILE *fp1, *fp2;
    //abre los archivos de texto
     fp1 = fopen("input.txt", "r");
     fp2 = fopen("output.txt", "w");
     fscanf(fp1, "%d", &n);
     for (i = 0; i < n; i++) {
      int vector1[size][size];
      int vector3[size] = {0};
      int m = 0;
      fscanf(fp1, "%d", &k);
      for (j = 0; j < k - 1; j++) {
           int x, y;
            //lee los ndos
           fscanf(fp1, "%d %d", &x, &y);
           x--; y--;
           vector1[x][vector3[x]++] = y;
           vector1[y][vector3[y]++] = x;
      }
      for (j = 0; j < k; j++) {
           int vector2[size] = {0}; //cera el vector
            int c = pbusqueda(j, 0, vector1, vector2, vector3);
           if (c > m) m = c;
      }
      sum += m;
     }
     fprintf(fp2, "%d\n", sum);
     fclose(fp1);
     fclose(fp2);
     return 0;
}

int pbusqueda(int x, int f, int vector1[size][size], int vector2[size], int vector3[size])
{
     int m1 = 0, m2 = 0, i;
     vector2[x] = 1;
     for (i = 0; i < vector3[x]; i++) {
      if (vector2[vector1[x][i]] == 0) {
           int m = pbusqueda(vector1[x][i], 1, vector1, vector2, vector3) + 1;
           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }
     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }
}


//lp1 arañas-2015
#include <stdio.h>
#include <stdlib.h>

int main()
{
     int n, k, sum = 0, i, j;
     FILE *fp1, *fp2;
    //abre los archivos de texto
     fp1 = fopen("input.txt", "r");
     fp2 = fopen("output.txt", "w");
     fscanf(fp1, "%d", &n);
     for (i = 0; i < n; i++) {
      int vector1[100][100];
      int vector3[100] = {0};
      int m = 0;

      fscanf(fp1, "%d", &k);

      for (j = 0; j < k - 1; j++) {
           int x, y;
           fscanf(fp1, "%d %d", &x, &y);
           x--; y--;
           vector1[x][p[x]++] = y;
           vector1[y][p[y]++] = x;
      }

      for (j = 0; j < k; j++) {
           int vector1[100] = {0};
           int c = pbusqueda(j, 0, vector1, b, p);

           if (c > m) m = c;
      }
      sum += m;
     }

     fprintf(fp2, "%d\n", sum);

     fclose(fp1);
     fclose(fp2);

     return 0;
}

//algoritmo de busqueda de nodos aleatorio
int pbusqueda(int x, int f, int vector1[100][100], int vector2[100], int vector3[100])
{
     int m1 = 0, m2 = 0, i;
     vector2[x] = 1;
     for (i = 0; i < vector3[x]; i++) {
      if (vector2[vector1[x][i]] == 0) {
           int m = pbusqueda(vector1[x][i], 1, vector1, vector2, vector3) + 1;
           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }
     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }
}


#include<stdio.h>

int grafo[200][200];
int n,k,l,i,j,a,b,t,m,s;
int v[200];

void f(int j,int p)
{
    int i;
    if(v[j])
    return;
    v[j]=1;
    if(p>m)
    m=p;
    for(i=1;i<=k;i++)
    {
        if(grafo[j][i])
            f(i,p+1);
    }
    v[j]=0;
}

int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        for(j=0;j<110;j++)
            for(l=0;l<110;l++)
                grafo[j][l]=0;
        scanf("%d",&k);
        m=0;
        for(j=1;j<k;j++)
        {
            scanf("%d%d",&a,&b);
            grafo[a][b]=grafo[b][a]=1;
        }
        for(j=1;j<=k;j++)
            f(j,0);
        t+=m;
    }
    printf("%d",t);
}


#include <stdlib.h>
#include <stdio.h>
#include <memory.h>
#define maxn 110
int first[maxn],v[maxn*2],sgte[maxn*2];
int len,e;
void init();
void add_edge(int a,int b);
int max(int n1,int n2);
int dfs(int u,int fa);

int main(){
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    int n,m;
    while(fscanf(ptrIn,"%d",&n) != EOF){
        int ans = 0;
        while(n--){
            fscanf(ptrIn,"%d",&m);
            init();
            len = 0;
            int i;
            for(i = 0;i < m-1;i++){
                int a,b;
                fscanf(ptrIn,"%d%d",&a,&b);
                add_edge(a,b);
                add_edge(b,a);
            }
            dfs(1,-1);
            ans += len;
        }
        fprintf(ptrOu,"%d",ans);
    }
}

void init(){
    e = 0;
    memset(first,-1,sizeof(first));
}

void add_edge(int a,int b){
    v[e] = b;
    sgte[e] = first[a];
    first[a] = e++;
}

int dfs(int u,int fa){
    int ret = 0,maxdep,i;
    for(i = first[u];i != -1;i = sgte[i]){
        if(v[i] == fa)
            continue;
        maxdep = dfs(v[i],u);
        len = max(len,ret + maxdep + 1);
        ret = max(ret,maxdep + 1);
    }
    return ret;
}

int max(int n1,int n2){
   return (n1<n2)?n2:n1;
}


#include<stdio.h>
#include<stdlib.h>
#include<memory.h>
int n,m;
int edge[102][102],siz[102],next[102];
int gao(int a,int fa){
	int b,c=0,d;
	if(siz[a]==1&&fa!=0) {next[a]=0;return 0;}
	for(b=0;b<siz[a];b++)
	if(edge[a][b]!=fa)
	{
		d=gao(edge[a][b],a)+1;
		if(d>c) {c=d;next[a]=edge[a][b];}
	}
	return c;
}
int main(){
	int a,b,c,d,e,f,ans=0;
	scanf("%d",&n);
	for(a=0;a<n;a++)
	{
		scanf("%d",&m);
		memset(edge,0,sizeof edge);
		memset(siz,0,sizeof siz);
		memset(next,0,sizeof next);
		for(b=1;b<m;b++)
		{
		scanf("%d%d",&d,&e);
		edge[d][siz[d]]=e;
		edge[e][siz[e]]=d;
		siz[d]++;
		siz[e]++;
	    }
	    c=gao(1,0);
	    b=1;
	    while(next[b]!=0) b=next[b];
	    c=gao(b,0);
	    ans+=c;
	}
	printf("%d\n",ans);
	return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<memory.h>
int n,m;
int edge[102][102],siz[102],next[102];
int gao(int a,int fa){
	int b,c=0,d;
	if(siz[a]==1&&fa!=0) {next[a]=0;return 0;}
	for(b=0;b<siz[a];b++)
	if(edge[a][b]!=fa)
	{
		d=gao(edge[a][b],a)+1;
		if(d>c) {c=d;next[a]=edge[a][b];}
	}
	return c;
}
int main(){
	freopen("input.txt","r",stdin);
	freopen("output.txt","w",stdout);
	int a,b,c,d,e,f,ans=0;
	scanf("%d",&n);
	for(a=0;a<n;a++)
	{
		scanf("%d",&m);
		memset(edge,0,sizeof edge);
		memset(siz,0,sizeof siz);
		memset(next,0,sizeof next);
		for(b=1;b<m;b++)
		{
		scanf("%d%d",&d,&e);
		edge[d][siz[d]]=e;
		edge[e][siz[e]]=d;
		siz[d]++;
		siz[e]++;
	    }
	    c=gao(1,0);
	    b=1;
	    while(next[b]!=0) b=next[b];
	    c=gao(b,0);
	    ans+=c;
	}
	printf("%d\n",ans);
	fclose(stdin);
	fclose(stdout);
	return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 100

int u[N+N+10],v[N+N+10];
int head[N+10],next[N+N+10];
int l,vis[N+10];
int queue[N+N+10],dis[N+N+10];

int bfs(int u, int f){
    int front,rear,d,t,max,p;
    memset(vis, 0, sizeof(vis));
    front=rear=0;
    queue[rear]=u;
    dis[rear]=0;
    vis[u]=1;
    ++rear;
    max=0;
    p=u;
    while(front<rear){
        u=queue[front];
        d=dis[front];
        if(max<d){
            max=d;
            p=u;
        }
        ++front;
        /*
        printf("%d: ", u);
        */
        for(t=head[u]; t!=-1; t=next[t])
            if(!vis[v[t]]){
                vis[v[t]]=1;
                /*
                printf("%d ", v[t]);
                */
                queue[rear]=v[t];
                dis[rear]=d+1;
                ++rear;
            }
        /*
        putchar('\n');
        */
    }
    /*
    printf("%d ", max);
    */
    if(f)
        l+=max;
    return p;
}

int main(void){
    int n,k,i;
    FILE *fin,*fout;
#ifndef ONLINE_JUDGE
    fin=fopen("120F.in", "rb");
    fout=stdout;
#else
    fin=fopen("input.txt", "rb");
    fout=fopen("output.txt", "wb");
#endif
    l=0;
    fscanf(fin, "%d", &n);
    while(n--){
        memset(head, -1, sizeof(head));
        fscanf(fin, "%d", &k);
        for(i=0; i<((k-1)<<1); i+=2){
            fscanf(fin, "%d%d", u+i, v+i);
            u[i+1]=v[i];
            v[i+1]=u[i];
            next[i]=head[u[i]];
            head[u[i]]=i;
            next[i+1]=head[u[i+1]];
            head[u[i+1]]=i+1;
        }
        i=bfs(u[0], 0);
        bfs(i, 1);
    }
    fprintf(fout, "%d\n", l);
    fclose(fin);
    fclose(fout);
    exit(0);
}


#include <stdio.h>

struct arbol
{
    struct arbol *izquierdo;
    struct arbol *derecho;
    int dato;
}

int main()
{
    struct arbol *cabeza;

    int n;
    scanf("%d",&n);

    int* v[n];

    int i;
    int nro,vertice;
    int j;

    for( i = 1; i <= n; i++)
    {
        scanf("%d",&nro);
        for( j = 1; j<=nro; j++)
        {
            scanf("%d",&vertice);
            agregar(vertice,&v[n]);
        }
        for( j =1; j<=nro; j++)
        {
            busqProf
    }


#include <stdio.h>
void recorrerProfundidad( int a[100][100], int n, int v, int m[]);

int total = 0;
int maximo = 0;
int main()
{

    int aranas;
    scanf("%d",&aranas);
    int i;
    int k;
    for( i = 1; i <= aranas; i++)
    {
        int n;
        scanf("%d",&n);
        int ady[n][n];
        int j;
        for( j = 0; j < n; j++)
        {
            for( k = 0; k < n; k++)
            {
                ady[j][k] = 0;
            }
        }

        int a,b;
        for( j = 1; j <= n - 1; j++)
        {
            scanf("%d%d",&a,&b);
            ady[a-1][b-1] = 1;
            ady[b-1][a-1] = 1;
        }

        int v;
        int max = 0;
        int m[n];
        total = 0;
        for( v = 0; v < n; v++)
        {
            for( j = 0; j < n; j++)
            {
                m[j] = 99;
            }

            recorrerProfundidad(ady,n,v,m);

            printf("\n%d\n",total);
            if( total > max)
            {
                max = total;
            }
            total = 0;
        }
        maximo = maximo + max;
    }

    printf("%d",maximo);
}

void recorrerProfundidad( int a[][100], int n, int v, int m[])
{
    int u;
    m[v] = 0;

    for( u = 0; u < n; u++)
    {
        if( a[v][u] && m[u] == 99 )
        {
            printf("a[%d][%d] = %d\nm[%d] = %d\n",v,u,a[v][u],u,m[u]);

            recorrerProfundidad(a,n,u,m);
        }
    }
}


#include <stdio.h>
#include <stdlib.h>
#define CLAVE 9999

typedef struct nodoDirectorio{
    int vertice;
    struct nodoAdyacente *lista;
    struct nodoDirectorio *enlace;
    int distancia;

} NodoGrafo;

typedef NodoGrafo* TipoDato;

typedef struct nodo
{
    TipoDato elemento;
    struct nodo *siguiente;
} Nodo;

void crearPila(Nodo **pila);
void insertar(Nodo **pila,TipoDato elemento);
TipoDato quitar(Nodo **pila);
int pilaVacia(Nodo *pila);

typedef struct nodoAdyacente
{
    struct nodoDirectorio *destino;
    struct nodoAdyacente *enlace;
} NodoLista;

void nuevoVertice(NodoGrafo **grafo, int vertice);
void arista(NodoGrafo *grafo, int org, int dst);
NodoGrafo* direccion(NodoGrafo *grafo,int vert);
void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[]);

int total = 0;
int max = 0;

int main()
{
    freopen("input.txt","r",stdin);

	freopen("output.txt","w",stdout);
    NodoGrafo *cabeza;
    cabeza = NULL;
    int aranas;
    scanf("%d",&aranas);
    NodoGrafo *mat[aranas];
    int x = 0;
    int k;
    for( k = 0; k < aranas; k++)
    {
        mat[k] = NULL;

        int n;
        scanf("%d",&n);

        int i,a,b;
        for( i = 1; i <= n; i++)
        {
            nuevoVertice(&mat[k],i);
        }
        for( i = 1; i <=n-1; i++)
        {
            scanf("%d%d",&a,&b);

            arista(mat[k],a,b);
            arista(mat[k],b,a);

        }
           int m[n];
           int maximo = 0;
           max = 0;
        for( i = 1; i <= n; i++)
        {
            recorreProfundidad(mat[k],n,i,m);
            if(max > maximo)
            maximo = max;
        }
        x = x + maximo;
    }
            printf("%d",x);

    return 0;

}

void nuevoVertice(NodoGrafo **grafo, int vertice)
{
    NodoGrafo *nuevo;
    nuevo = (NodoGrafo*)malloc(sizeof(NodoGrafo));
    nuevo -> vertice = vertice;
    nuevo -> lista = NULL;
    nuevo -> enlace = *grafo;
    *grafo = nuevo;
}

void arista(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;
    NodoLista *ady;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        ady = (NodoLista*)malloc(sizeof(NodoLista));
        ady -> destino = v2;
        ady -> enlace = v1 -> lista;
        v1 -> lista = ady;
    }
}

NodoGrafo* direccion(NodoGrafo *grafo,int vert)
{
    NodoGrafo *aux;

    aux = grafo;

    while( aux -> vertice != vert && aux != NULL )
    {
        aux = aux -> enlace;
    }
    return aux;

}

void borrarArco(NodoGrafo *grafo, int org, int dst)
{
    NodoGrafo *v1,*v2;

    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);

    if( v1 && v2 )
    {
        NodoLista *ady;
        NodoLista *a = NULL;
        ady = v1 -> lista;
        while(ady)
        {
            if(ady -> destino == v2)
            {
                if(a == NULL)
                    v1 -> lista = ady -> enlace;
                else
                    a -> enlace = ady -> enlace;
                free(ady);
                ady = NULL;
            }
            else
            {
                a = ady;
                ady = ady -> enlace;
            }
        }
    }
}

void crearPila(Nodo **pila)
{
    *pila = NULL;
}

int pilaVacia(Nodo *pila)
{
    return pila == NULL;
}

void insertar(Nodo **pila,TipoDato elemento)
{
    Nodo *nuevo;

    nuevo = (Nodo*)malloc(sizeof(Nodo));
    nuevo -> elemento = elemento;
    nuevo -> siguiente = *pila;
    (*pila) = nuevo;
}

TipoDato quitar(Nodo **pila)
{
    TipoDato tem;
    Nodo *q;

    if(pilaVacia(*pila))
    {
        puts(" Se intenta sacar un elemento en pila vacia");
        exit(1);
    }

    tem = (*pila) -> elemento;
    q = *pila;
    (*pila) = (*pila) -> siguiente;
    free(q);

    return tem;
}

void recorreProfundidad(NodoGrafo *grafo,int n, int v, int m[])
{
    NodoGrafo *v1,*v2,*w;
    NodoLista *ady;
    Nodo *pila;

    crearPila(&pila);
    int i;
    int tiempos[n];
    for( i = 0; i < n; i++)
    {
        m[i] = CLAVE;
        tiempos[i] = 0;
    }
    m[v-1] = 0;

    v1 = direccion(grafo,v);
    insertar(&pila,v1);
    total = 0;
    v1 -> distancia = 0;
    while(!pilaVacia(pila))
    {

        w = quitar(&pila);
     //   printf("Nodo %d visitado\n",w -> vertice);
        ady = w -> lista;
        while(ady != NULL)
        {

            int k;
            k = ady -> destino -> vertice - 1;
            if(m[k] == CLAVE)
            {
                insertar(&pila,ady->destino);
                m[k] = 1;
                ady -> destino -> distancia = w -> distancia + 1;
                if(ady -> destino -> distancia > max)
                    max = ady -> destino -> distancia;

            }

            ady = ady -> enlace;
        }

    }

}


#include <stdio.h>
void recorrerProfundidad( int a[][3], int n, int v, int m[]);

int total = 0;
int maximo = 0;
int main()
{

    int aranas;
    scanf("%d",&aranas);
    int i;
    int k;
    for( i = 1; i <= aranas; i++)
    {
        int n;
        scanf("%d",&n);
        int ady[n][n];
        int j;
        for( j = 0; j < n; j++)
        {
            for( k = 0; k < n; k++)
            {
                ady[j][k] = 0;
            }
        }

        int a,b;
        for( j = 1; j <= n - 1; j++)
        {
            scanf("%d%d",&a,&b);
            ady[a-1][b-1] = 1;
            ady[b-1][a-1] = 1;
        }

        int v;
        int max = 0;
        int m[n];
        for( v = 0; v < n; v++)
        {
            for( j = 0; j < n; j++)
            {
                m[j] = 99;
            }

            recorrerProfundidad(ady,n,v,m);

            if( total > max)
            {
                max = total;
            }
            total = 0;
        }
        maximo = maximo + max;
    }

    printf("%d",maximo);
}

void recorrerProfundidad( int a[][3], int n, int v, int m[])
{
    int u;
    m[v] = 0;

    for( u = 0; u < n; u++)
    {
        if( a[v][u] && m[u] == 99 )
        {
            ++total;
            recorrerProfundidad(a,n,u,m);
        }
    }
}


#include <stdio.h>
#include <stdlib.h>

int main()
{
     int n, k, sum = 0, i, j;
     FILE *fila1, *fila2;

     fila1 = fopen("entrada.txt", "r");
     fila2 = fopen("salida.txt", "w");

     fscanf(fila1, "%d", &n);

     for (i = 0; i < n; i++) {
      int a[100][100];
      int p[100] = {0};
      int m = 0;

      fscanf(fila1, "%d", &k);

      for (j = 0; j < k - 1; j++) {
           int x, y;

           fscanf(fila1, "%d %d", &x, &y);

           x--; y--;

           a[x][p[x]++] = y;
           a[y][p[y]++] = x;
      }

      for (j = 0; j < k; j++) {
           int b[100] = {0};
           int c = dfs(j, 0, a, b, p);

           if (c > m) m = c;
      }

      sum += m;
     }

     fprintf(fila2, "%d\n", sum);

     fclose(fila1);
     fclose(fila2);

     return 0;
}

int dfs(int x, int f, int a[100][100], int b[100], int p[100])
{
     int m1 = 0, m2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = dfs(a[x][i], 1, a, b, p) + 1;

           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }

     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }
}


#include <stdio.h>
#include <stdlib.h>

//funtions
int buscar(int x, int f, int a[100][100], int b[100], int p[100]);

int main()
{
     int n, k, sum = 0, i, j;
     FILE *fila1, *fila2;

     fila1 = fopen("input.txt", "r");
     fila2 = fopen("output.txt", "w");

     fscanf(fila1, "%d", &n);

     for (i = 0; i < n; i++) {
      int a[100][100];
      int p[100] = {0};
      int m = 0;

      fscanf(fila1, "%d", &k);

      for (j = 0; j < k - 1; j++) {
           int x, y;

           fscanf(fila1, "%d %d", &x, &y);

           x--; y--;

           a[x][p[x]++] = y;
           a[y][p[y]++] = x;
      }

      for (j = 0; j < k; j++) {
           int b[100] = {0};
           int c = buscar(j, 0, a, b, p);

           if (c > m) m = c;
      }

      sum += m;
     }

     fprintf(fila2, "%d\n", sum);

     fclose(fila1);
     fclose(fila2);

     return 0;
}
int buscar(int x, int f, int a[100][100], int b[100], int p[100])
{
     int m1 = 0, m2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = buscar(a[x][i], 1, a, b, p) + 1;

           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }

     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }
}


#include <stdio.h>
#include <string.h>
#include <stdlib.h>

FILE *ifp, *ofp ;
int i, j, n, m, edge[101][101], count[101], from, to, length ;

int max(int x, int y)
{
    return (x > y ? x : y) ;
}

int height(int root, int from)
{
    int i, result = 0 ;

    for (i = 0 ; i < count[root] ; i++)
    {
        if (edge[root][i] != from)
        {
            result = max(result, 1 + height(edge[root][i], root)) ;
        }
    }

    return result ;
}

int diameter(int root, int from)
{
    int highest1 = 0 ;
    int highest2 = 0 ;
    int i, h     = 0 ;

    for (i = 0 ; i < count[root] ; i++)
    {
        if (edge[root][i] != from)
        {
            h = height(edge[root][i], root) + 1 ;

            if (h > highest1)
            {
                highest2 = highest1 ;
                highest1 = h ;
            }
            else if (h > highest2)
            {
                highest2 = h ;
            }
        }
    }

    h = highest1 + highest2 ;

    for (i = 0 ; i < count[root] ; i++)
    {
        if (edge[root][i] != from)
        {
            h = max(h, diameter(edge[root][i], root)) ;
        }
    }

    return h ;
}

int main(void)
{
    ifp = fopen("input.txt", "r") ;
    ofp = fopen("output.txt", "w") ;

    fscanf(ifp, "%d", &n) ;

    for (i = 0 ; i < n ; i++)
    {
        for (j = 1 ; j <= 100 ; j++)
        {
            count[j] = 0 ;
        }

        fscanf(ifp, "%d", &m) ;

        for (j = 1 ; j < m ; j++)
        {
            fscanf(ifp, "%d %d", &from, &to) ;

            edge[from][count[from]++] = to ;
            edge[to][count[to]++]     = from ;
        }

        length += diameter(1, 0) ;
    }

    fprintf(ofp, "%d", length) ;

    fclose(ifp) ;
    fclose(ofp) ;

    return 0 ;
}


#include <cstdio>
#include <cstring>
#define maxn 110
int primero[maxn],v[maxn*2],siguiente[maxn*2];
int len,e;
inline int max(int a,int b){
    return a > b ? a : b;
}

void init(){
    e = 0;
    memset(primero,-1,sizeof(primero));
}

void agregar_borde(int a,int b){
    v[e] = b;
    siguiente[e] = primero[a];
    primero[a] = e++;
}

int dfs(int u,int fa){
    int ret = 0,maxdep;
    for(int i = primero[u];i != -1;i = siguiente[i]){
        if(v[i] == fa)  continue;
        maxdep = dfs(v[i],u);
        len = max(len,ret + maxdep + 1);
        ret = max(ret,maxdep + 1);
    }
    return ret;
}

int main(){
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    int n,m;
    while(scanf("%d",&n) != EOF){
        int ans = 0;
        while(n--){
            scanf("%d",&m);
            init();
            len = 0;
            for(int i = 0;i < m-1;i++){
                int a,b;
                scanf("%d%d",&a,&b);
                agregar_borde(a,b);
               agregar_borde(b,a);
            }
            dfs(1,-1);
            ans += len;
        }
        printf("%d\n",ans);
    }
}


#include <stdio.h>
#include <string.h>
#include <stdlib.h>

FILE *ifp, *ofp ;
int i, j, n, m, borde[101][101], contador[101], desde, hacia, longitud ;

int max(int x, int y)
{
    return (x > y ? x : y) ;
}

int altura(int root, int desde)
{
    int i, result = 0 ;

    for (i = 0 ; i < contador[root] ; i++)
    {
        if (borde[root][i] != desde)
        {
            resultado = max(resultado, 1 + altura(borde[root][i], root)) ;
        }
    }

    return resultado ;
}

int diametro(int root, int desde)
{
    int mayor1 = 0 ;
    int mayor2 = 0 ;
    int i, h     = 0 ;

    for (i = 0 ; i < contador[root] ; i++)
    {
        if (borde[root][i] != desde)
        {
            h = altura(borde[root][i], root) + 1 ;

            if (h > mayor1)
            {
                mayor2 = mayor1 ;
                mayor1 = h ;
            }
            else if (h > mayor2)
            {
                mayor2 = h ;
            }
        }
    }

    h = mayor1 + mayor2 ;

    for (i = 0 ; i < contador[root] ; i++)
    {
        if (borde[root][i] != desde)
        {
            h = max(h, diametro(borde[root][i], root)) ;
        }
    }

    return h ;
}

int main(void)
{
    ifp = fopen("input.txt", "r") ;
    ofp = fopen("output.txt", "w") ;

    fscanf(ifp, "%d", &n) ;

    for (i = 0 ; i < n ; i++)
    {
        for (j = 1 ; j <= 100 ; j++)
        {
            contador[j] = 0 ;
        }

        fscanf(ifp, "%d", &m) ;

        for (j = 1 ; j < m ; j++)
        {
            fscanf(ifp, "%d %d", &desde, &hacia) ;

            borde[desde][contador[hacia]++] = hacia ;
            borde[hacia][contador[hacia]++]     = desde ;
        }

        largo += diametro(1, 0) ;
    }

    fprintf(ofp, "%d", largo) ;

    fclose(ifp) ;
    fclose(ofp) ;

    return 0 ;
}


#include <stdio.h>
#include <stdlib.h>
int uniones(int x, int f, int a[100][100], int b[100], int p[100]);
int main()
{
     int n, k, sum = 0, i, j;
     FILE *in, *ou;

     in = fopen("input.txt", "r");
     ou = fopen("output.txt", "w");

     fscanf(in, "%d", &n);

     for (i = 0; i < n; i++) {
      int a[100][100];
      int p[100] = {0};
      int m = 0;

      fscanf(in, "%d", &k);

      for (j = 0; j < k - 1; j++) {
           int x, y;

           fscanf(in, "%d %d", &x, &y);

           x--;
           y--;

           a[x][p[x]++] = y;
           a[y][p[y]++] = x;
      }

      for (j = 0; j < k; j++) {
           int b[100] = {0};
           int c = uniones(j, 0, a, b, p);

           if (c > m) m = c;
      }

      sum += m;
     }

     fprintf(ou, "%d\n", sum);

     fclose(in);
     fclose(ou);

     return 0;
}

int uniones(int x, int f, int a[100][100], int b[100], int p[100])
{
     int a1 = 0, a2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = uniones(a[x][i], 1, a, b, p) + 1;

           if (m > a1) {
            a2 = a1;
            a1 = m;
           } else if (m > a2) {
            a2 = m;
           }
      }
     }

     if (f == 0) {
      return a1 + a2;
     } else {
      return a1;
     }
}


#include<stdio.h>

int dfs(int x, int f, int a[100][100], int b[100], int p[100]);
int n;

int main()
{
    int i,j,h,m,b,z,suma,k;
    suma=0;
    z=0;
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    fscanf(ptrIn,"%i",&n);
    for(m=0;m<n;m++){
        int G[100][100];
        int p[100]={0};
        fscanf(ptrIn,"%i",&b);
        for(i=0;i<b-1;i++)
        {
            fscanf(ptrIn,"%i%i", &h, &j);
            h--;
            j--;
            G[h][p[h]++]=j;
            G[j][p[j]++]=h;
        }
        for(i=0;i<n;i++){
            int visited[100] = {0};
            k=dfs(j,0,G,visited,p);
            if(k>z)
                z=k;
        }
        suma+=z;
    }
     fprintf(ptrOu,"%i\n",suma);
     fclose(ptrOu);
     fclose(ptrIn);
}

int dfs(int x, int f, int a[100][100], int b[100], int p[100])
{
     int m1 = 0, m2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = dfs(a[x][i], 1, a, b, p) + 1;

           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }

     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }


#include<stdio.h>

int DFS(int);
int G[100][100],visited[100], n;    //n is no of vertices and graph is sorted in array G[10][10]

void main()
{
    int i,j,h,m,b,k=0;
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    for(i=0;i<100;i++)
        visited[i]=0;
    while(fscanf(ptrIn,"%i",&n) != EOF){
    while(n--){
    scanf("%i",&b);
        for(i=0;i<b-1;i++)
        {
            scanf("%i%i", &h, &j);
            G[h][j]=1;
        }
      for(i=0;i<n;i++){
           k+=DFS(i);
        }
    }
    }
     fprintf(ptrOu,"%i",k);
}

int DFS(int i)
{
    int j,k=0;
    k++;
    visited[i]=1;
    for(j=0;j<n;j++)
       if(!visited[j]&&G[i][j]==1){
            DFS(j);
       }
    return k;
}


#include<stdio.h>

int dfs(int x, int f, int a[100][100], int b[100], int p[100]);
int G[100][100],visited[100]={0}, n, p[100]={0};

int main()
{
    int i,j,h,m,b,z,suma,k=0;
    suma=0;
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    fscanf(ptrIn,"%i",&n);
     z=0;
    for(m=0;m<n;m++){
        fscanf(ptrIn,"%i",&b);
        for(i=0;i<b-1;i++)
        {
            fscanf(ptrIn,"%i%i", &h, &j);
            h--;
            j--;
            G[h][p[h++]]=j;
            G[j][p[j++]]=h;
        }
        for(i=0;i<n;i++){
            k=dfs(j,0,G,visited,p);
            if(k>z)
                z=k;
        }
        suma+=z;
    }
     fprintf(ptrOu,"%i",suma);
     fclose(PtrIn);
     fclose(PtrOu);
     return 0;
}

int dfs(int x, int f, int a[100][100], int b[100], int p[100])
{
     int m1 = 0, m2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = dfs(a[x][i], 1, a, b, p) + 1;

           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }

     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }
}


#include<stdio.h>

int dfs(int x, int f, int a[100][100], int b[100], int p[100]);
int G[100][100],visited[100]={0}, n, p[100]={0},k;

int main()
{
    int i,j,h,m,b,z,suma,k;
    suma=0;
    z=0;
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    fscanf(ptrIn,"%i",&n);
    for(m=0;m<n;m++){
        fscanf(ptrIn,"%i",&b);
        for(i=0;i<b-1;i++)
        {
            fscanf(ptrIn,"%i%i", &h, &j);
            h--;
            j--;
            G[h][p[h]++]=j;
            G[j][p[j]++]=h;
        }
        for(i=0;i<n;i++){
            k=dfs(j,0,G,visited,p);
            if(k>z)
                z=k;
        }
        suma+=z;
    }
     printf(ptrOu,"%i",suma);
     fclose(ptrOu);
     fclose(ptrIn);
}

int dfs(int x, int f, int a[100][100], int b[100], int p[100])
{
     int m1 = 0, m2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = dfs(a[x][i], 1, a, b, p) + 1;

           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }

     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }
}


#include<stdio.h>

int DFS(int);
int G[100][100],visited[100], n;    //n is no of vertices and graph is sorted in array G[10][10]

void main()
{
    int i,j,h,m,b,k=0;
    scanf("%d",&n);
    for(i=0;i<n;i++)
        visited[i]=0;
    for(m=0;m<n;m++){
    scanf("%i",&b);
        for(i=0;i<b-1;i++)
        {
            scanf("%i%i", &h, &j);
            G[h][j]=1;
        }
      for(i=0;i<n;i++){
           k+=DFS(i);
        }
    }
    printf("%i", k);
}

int DFS(int i)
{
    int j,k=0;
    k++;
    visited[i]=1;
    for(j=0;j<n;j++)
       if(!visited[j]&&G[i][j]==1){
            DFS(j);
       }
    return k;
}


#include<stdio.h>

int DFS(int);
int G[100][100],visited[100]={0}, n,k, p[100]={0};

void main()
{
    int i,j,h,m,b,z,suma,k=0;
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    fscanf(ptrIn,"%i",&n);
    for(m=0;m<n;m++){
            z=0;
        fscanf(ptrIn,"%i",&b);
        for(i=0;i<b-1;i++)
        {
            fscanf(ptrIn,"%i%i", &h, &j);
            h--;
            j--;
            G[h][p[h++]]=j;
            G[j][p[j++]]=h;
        }
        for(i=0;i<n;i++){
            int k=dfs(j,0,G,visited,p);
            if(k>b)
                z=k;
        }
        suma+=z;
    }
     fprintf(ptrOu,"%i",k);
}

int dfs(int x, int f, int a[100][100], int b[100], int p[100])
{
     int m1 = 0, m2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = dfs(a[x][i], 1, a, b, p) + 1;

           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }

     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }
}


#include<stdio.h>

int dfs(int x, int f, int a[100][100], int b[100], int p[100]);
int visited[100]={0}, n,k;

int main()
{
    int i,j,h,m,b,z,suma,k;
    suma=0;
    z=0;
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    fscanf(ptrIn,"%i",&n);
    for(m=0;m<n;m++){
        int z = 0;
        int G[100][100];
        int p[100]={0};
        fscanf(ptrIn,"%i",&b);
        for(i=0;i<b-1;i++)
        {
            fscanf(ptrIn,"%i%i", &h, &j);
            h--;
            j--;
            G[h][p[h]++]=j;
            G[j][p[j]++]=h;
        }
        for(i=0;i<n;i++){
            k=dfs(j,0,G,visited,p);
            if(k>z)
                z=k;
        }
        suma+=z;
    }
     fprintf(ptrOu,"%i\n",suma);
     fclose(ptrOu);
     fclose(ptrIn);
}

int dfs(int x, int f, int a[100][100], int b[100], int p[100])
{
     int m1 = 0, m2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = dfs(a[x][i], 1, a, b, p) + 1;

           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }

     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }
}


#include<stdio.h>

int DFS(int);
int G[100][100],visited[100], n;    //n is no of vertices and graph is sorted in array G[10][10]

void main()
{
    int i,j,h,m,b,k=0;
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    for(i=0;i<100;i++)
        visited[i]=0;
    while(fscanf(ptrIn,"%i",&n) != EOF){
    while(n--){
    scanf("%i",&b);
        for(i=0;i<b-1;i++)
        {
            fscanf(ptrIn,"%i%i", &h, &j);
            G[h][j]=1;
        }
      for(i=0;i<n;i++){
           k+=DFS(i);
        }
    }
    }
     fprintf(ptrOu,"%i",k);
}

int DFS(int i)
{
    int j,k=0;
    k++;
    visited[i]=1;
    for(j=0;j<n;j++)
       if(!visited[j]&&G[i][j]==1){
            DFS(j);
       }
    return k;
}


#include <stdio.h>
#include <stdlib.h>
int dfs(int x, int f, int a[100][100], int b[100], int p[100]);

int main()
{
     int n, k, suma = 0, i, j;
     FILE *IN, *OUT;

     IN = fopen("input.txt", "r");
     OUT = fopen("output.txt", "w");

     fscanf(IN, "%d", &n);

     for (i = 0; i < n; i++) {
      int Grafo[100][100];
      int visitado[100] = {0};
      int m = 0;

      fscanf(IN, "%d", &k);

      for (j = 0; j < k - 1; j++) {
           int x, y;

           fscanf(IN, "%d %d", &x, &y);

           x--; y--;

           Grafo[x][visitado[x]++] = y;
           Grafo[y][visitado[y]++] = x;
      }

      for (j = 0; j < k; j++) {
           int aux[100] = {0};
           int z = dfs(j, 0, Grafo, aux, visitado);

           if (z > m) m = z;
      }

      suma += m;
     }

     fprintf(OUT, "%d\n", suma);

     fclose(IN);
     fclose(OUT);

     return 0;
}

int dfs(int x, int f, int a[100][100], int b[100], int p[100])
{
     int m1 = 0, m2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = dfs(a[x][i], 1, a, b, p) + 1;

           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }

     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }
}


#include<stdio.h>

int DFS(int);
int G[100][100],visited[100]={0}, n;

void main()
{
    int i,j,h,m,b,k=0;
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    while(fscanf(ptrIn,"%i",&n) != EOF){
    while(n--){
    scanf("%i",&b);
        for(i=0;i<b-1;i++)
        {
            fscanf(ptrIn,"%i%i", &h, &j);
            G[h][j]=1;
        }
      for(i=0;i<n;i++){
           k+=DFS(i);
        }
    }
    }
     fprintf(ptrOu,"%i",k);
}

int DFS(int i)
{
    int j,k=0;
    k++;
    visited[i]=1;
    for(j=0;j<n;j++)
       if(!visited[j]&&G[i][j]==1){
            DFS(j);
       }
    return k;
}


#include<stdio.h>

int dfs(int x, int f, int a[100][100], int b[100], int p[100]);
int G[100][100],visited[100]={0}, n, p[100]={0},k;

int main()
{
    int i,j,h,m,b,z,suma,k;
    suma=0;
    z=0;
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    fscanf(ptrIn,"%i",&n);
    for(m=0;m<n;m++){
        int z = 0;
        fscanf(ptrIn,"%i",&b);
        for(i=0;i<b-1;i++)
        {
            fscanf(ptrIn,"%i%i", &h, &j);
            h--;
            j--;
            G[h][p[h]++]=j;
            G[j][p[j]++]=h;
        }
        for(i=0;i<n;i++){
            k=dfs(j,0,G,visited,p);
            if(k>z)
                z=k;
        }
        suma+=z;
    }
     fprintf(ptrOu,"%i\n",suma);
     fclose(ptrOu);
     fclose(ptrIn);
}

int dfs(int x, int f, int a[100][100], int b[100], int p[100])
{
     int m1 = 0, m2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = dfs(a[x][i], 1, a, b, p) + 1;

           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }

     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }
}


#include<stdio.h>

int dfs(int x, int f, int a[100][100], int b[100], int p[100]);
int G[100][100],visited[100]={0}, n, p[100]={0},k;

int main()
{
    int i,j,h,m,b,z,suma,k;
    suma=0;
    z=0;
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    fscanf(ptrIn,"%i",&n);
    for(m=0;m<n;m++){
        fscanf(ptrIn,"%i",&b);
        for(i=0;i<b-1;i++)
        {
            fscanf(ptrIn,"%i%i", &h, &j);
            h--;
            j--;
            G[h][p[h]++]=j;
            G[j][p[j]++]=h;
        }
        for(i=0;i<n;i++){
            k=dfs(j,0,G,visited,p);
            if(k>z)
                z=k;
        }
        suma+=z;
    }
     printf(ptrOu,"%i\n",suma);
     fclose(ptrOu);
     fclose(ptrIn);
}

int dfs(int x, int f, int a[100][100], int b[100], int p[100])
{
     int m1 = 0, m2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = dfs(a[x][i], 1, a, b, p) + 1;

           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }

     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }
}


#include<stdio.h>

int dfs(int x, int f, int a[100][100], int b[100], int p[100]);
int G[100][100],visited[100]={0}, n, p[100]={0};

int main()
{
    int i,j,h,m,b,z,suma,k;
    suma=0;
    z=0;
    FILE *ptrIn=fopen("input.txt", "r");
    FILE *ptrOu=fopen("output.txt", "w");
    fscanf(ptrIn,"%i",&n);
    for(m=0;m<n;m++){
        fscanf(ptrIn,"%i",&b);
        for(i=0;i<b-1;i++)
        {
            fscanf(ptrIn,"%i%i", &h, &j);
            h--;
            j--;
            G[h][p[h++]]=j;
            G[j][p[j++]]=h;
        }
        for(i=0;i<n;i++){
            k=dfs(j,0,G,visited,p);
            if(k>z)
                z=k;
        }
        suma+=z;
    }
     fprintf(ptrOu,"%i",suma);
     return 0;
}

int dfs(int x, int f, int a[100][100], int b[100], int p[100])
{
     int m1 = 0, m2 = 0, i;

     b[x] = 1;

     for (i = 0; i < p[x]; i++) {
      if (b[a[x][i]] == 0) {
           int m = dfs(a[x][i], 1, a, b, p) + 1;

           if (m > m1) {
            m2 = m1;
            m1 = m;
           } else if (m > m2) {
            m2 = m;
           }
      }
     }

     if (f == 0) {
      return m1 + m2;
     } else {
      return m1;
     }
}


#include <stdio.h>
#include <stdlib.h>
int dfs(int x, int f, int a[100][100], int b[100], int p[100]);

int main()
{
     int n, k, suma = 0, i, j;
     FILE *IN, *OUT;

     IN = fopen("input.txt", "r");
     OUT = fopen("output.txt", "w");

     fscanf(IN, "%d", &n);

     for (i = 0; i < n; i++) {
      int Grafo[100][100];
      int visitado[100] = {0};
      int m = 0;

      fscanf(IN, "%d", &k);

      for (j = 0; j < k - 1; j++) {
           int x, y;

           fscanf(IN, "%d %d", &x, &y);

           x--; y--;

           Grafo[x][visitado[x]++] = y;
           Grafo[y][visitado[y]++] = x;
      }

      for (j = 0; j < k; j++) {
           int aux[100] = {0};
           int z = dfs(j, 0, Grafo, aux, visitado);

           if (z > m) m = z;
      }

      suma += m;
     }

     fprintf(OUT, "%d\n", suma);

     fclose(IN);
     fclose(OUT);

     return 0;
}