#include <iostream>
#include <cmath>
#include <iomanip>
#include <cstring>

using namespace std;

#define DEBUG 0

const int
  MAX_DSIZE = 8,
  MAX_POINTS = 2 * MAX_DSIZE,
  MAX_DIST = 50;
const double
  INF = 1e100;

double
  best[1<<(MAX_POINTS-1)][MAX_POINTS];

int
  districts[MAX_DIST][MAX_DSIZE][2],
  dSizes[MAX_DIST],
  nDist;

double heldKarp(double distance[MAX_POINTS][MAX_POINTS],int nPoints) {

  for (int i=0;i<(1<<(nPoints-1));i++)
    for (int j=0;j<nPoints;j++)
      best[i][j] = INF;

  for (int visited=1;visited<(1<<(nPoints-1));visited++) {
    for (int last=0;last<nPoints-1;last++) {
      if (!(visited & (1 << last)))
        continue;

      if (visited == (1 << last)) {
        best[visited][last] = distance[nPoints-1][last];
      } else {
        int prev_visited = visited ^ (1 << last);
        for (int prev=0;prev<nPoints-1;prev++) {
          if (!(prev_visited & (1 << prev)))
            continue;
          best[visited][last] = min(
            best[visited][last],
            distance[last][prev] + best[prev_visited][prev]
          );
        }
      }
    }
  }

  double answer = INF;
  for (int last=0;last<nPoints-1;last++)
    answer = min(answer,
      distance[last][nPoints-1]+best[(1<<(nPoints-1))-1][last]);

  return answer;
}

void generateDistances(double dists[MAX_POINTS][MAX_POINTS],
                      int points[][2],int nPoints) {

  for (int r=0;r<nPoints;r++)
    for (int c=0;c<nPoints;c++)
      dists[r][c] = sqrt((points[r][0] - points[c][0]) *
                          (points[r][0] - points[c][0]) +
                        (points[r][1] - points[c][1]) *
                      (points[r][1] - points[c][1]));
}

//
//
//

int n, max_match; //n workers and n jobs
double lx[MAX_DIST/2], ly[MAX_DIST/2]; //labels of X and Y parts
int xy[MAX_DIST/2]; //xy[x] - vertex that is matched with x,
int yx[MAX_DIST/2]; //yx[y] - vertex that is matched with y
bool S[MAX_DIST/2], T[MAX_DIST/2]; //sets S and T in algorithm
double slack[MAX_DIST/2]; //as in the algorithm description
int slackx[MAX_DIST/2]; //slackx[y] such a vertex, that
// l(slackx[y]) + l(y) - w(slackx[y],y) = slack[y]
int pprev[MAX_DIST/2]; //array for memorizing alternating paths

double
  cost[MAX_DIST/2][MAX_DIST/2];

void init_labels()
{
memset(lx, 0, sizeof(lx));
memset(ly, 0, sizeof(ly));
for (int x = 0; x < n; x++)
for (int y = 0; y < n; y++)
lx[x] = max(lx[x], cost[x][y]);
}

void update_labels()
{
int x, y;
double delta = INF; //init delta as infinity
for (y = 0; y < n; y++) //calculate delta using slack
if (!T[y])
delta = min(delta, slack[y]);
for (x = 0; x < n; x++) //update X labels
if (S[x]) lx[x] -= delta;
for (y = 0; y < n; y++) //update Y labels
if (T[y]) ly[y] += delta;
for (y = 0; y < n; y++) //update slack array
if (!T[y])
slack[y] -= delta;
}

void add_to_tree(int x, int prevx)
//x - current vertex,prevx - vertex from X before x in the alternating path,
//so we add edges (prevx, xy[x]), (xy[x], x)
{
S[x] = true; //add x to S
pprev[x] = prevx; //we need this when augmenting
for (int y = 0; y < n; y++) //update slacks, because we add new vertex to S
if (lx[x] + ly[y] - cost[x][y] < slack[y])
{
slack[y] = lx[x] + ly[y] - cost[x][y];
slackx[y] = x;
}
}

void augment() //main function of the algorithm
{
if (max_match == n) return; //check wether matching is already perfect
int x, y, root; //just counters and root vertex
int q[MAX_DIST/2], wr = 0, rd = 0; //q - queue for bfs, wr,rd - write and read
//pos in queue
memset(S, false, sizeof(S)); //init set S
memset(T, false, sizeof(T)); //init set T
memset(pprev, -1, sizeof(pprev)); //init set prev - for the alternating tree
for (x = 0; x < n; x++) //finding root of the tree
if (xy[x] == -1)
{
q[wr++] = root = x;
pprev[x] = -2;
S[x] = true;
break;
}
for (y = 0; y < n; y++) //initializing slack array
{
slack[y] = lx[root] + ly[y] - cost[root][y];
slackx[y] = root;
}
//second part of augment() function
while (true) //main cycle
{
while (rd < wr) //building tree with bfs cycle
{
x = q[rd++]; //current vertex from X part
for (y = 0; y < n; y++) //iterate through all edges in equality graph
if (cost[x][y] == lx[x] + ly[y] && !T[y])
{
if (yx[y] == -1) break; //an exposed vertex in Y found, so
//augmenting path exists!
T[y] = true; //else just add y to T,
q[wr++] = yx[y]; //add vertex yx[y], which is matched
//with y, to the queue
add_to_tree(yx[y], x); //add edges (x,y) and (y,yx[y]) to the tree
}
if (y < n) break; //augmenting path found!
}
if (y < n) break; //augmenting path found!
update_labels(); //augmenting path not found, so improve labeling
wr = rd = 0;
for (y = 0; y < n; y++)
//in this cycle we add edges that were added to the equality graph as a
//result of improving the labeling, we add edge (slackx[y], y) to the tree if
//and only if !T[y] && slack[y] == 0, also with this edge we add another one
//(y, yx[y]) or augment the matching, if y was exposed
if (!T[y] && slack[y] == 0)
{
if (yx[y] == -1) //exposed vertex in Y found - augmenting path exists!
{
x = slackx[y];
break;
}
else
{
T[y] = true; //else just add y to T,
if (!S[yx[y]])
{
q[wr++] = yx[y]; //add vertex yx[y], which is matched with
//y, to the queue
add_to_tree(yx[y], slackx[y]); //and add edges (x,y) and (y,
//yx[y]) to the tree
}
}
}
if (y < n) break; //augmenting path found!
}
if (y < n) //we found augmenting path!
{
max_match++; //increment matching
//in this cycle we inverse edges along augmenting path
for (int cx = x, cy = y, ty; cx != -2; cx = pprev[cx], cy = ty)
{
ty = xy[cx];
yx[cy] = cx;
xy[cx] = cy;
}
augment(); //recall function, go to step 1 of the algorithm
}
}//end of augment() function

double hungarian()
{
double ret = 0; //weight of the optimal matching
max_match = 0; //number of vertices in current matching
memset(xy, -1, sizeof(xy));
memset(yx, -1, sizeof(yx));
init_labels(); //step 0
augment(); //steps 1-3
for (int x = 0; x < n; x++) //forming answer there
ret += cost[x][xy[x]];
return ret;
}

//
//
//

double stableMarriage(double dists[MAX_DIST/2][MAX_DIST/2],int nDist) {
  int
    rOrder[MAX_DIST/2][MAX_DIST/2],
    cOrder[MAX_DIST/2][MAX_DIST/2],
    rChoice[MAX_DIST/2],
    cChoice[MAX_DIST/2],
    q[MAX_DIST/2],qH=-1,qT=0,qC=0,
    i,j,k,tmp;
  double
    total=0;

  for (i=0;i<nDist;i++)
    for (j=0;j<nDist;j++)
      rOrder[i][j] = cOrder[i][j] = j;

  for (i=0;i<nDist;i++) {
    for (j=1;j<nDist;j++) {
      tmp = rOrder[i][j];
      for (k=j-1;k>=0&&dists[i][rOrder[i][k]] > dists[i][rOrder[i][tmp]];k--)
        rOrder[i][k+1] = rOrder[i][k];
      rOrder[i][k+1] = tmp;
    }
  }

  for (i=0;i<nDist;i++) {
    for (j=1;j<nDist;j++) {
      tmp = cOrder[i][j];
      for (k=j-1;k>=0&&dists[cOrder[i][k]][i] > dists[cOrder[i][tmp]][i];k--)
        cOrder[i][k+1] = cOrder[i][k];
      cOrder[i][k+1] = tmp;
    }
  }
/*
  for (i=0;i<nDist;i++) {
    for (j=0;j<nDist;j++)
      cout << setw(10) << dists[i][j];
    cout << endl;
  }
  for (i=0;i<nDist;i++) {
    for (j=0;j<nDist;j++)
      cout << setw(10) << rOrder[i][j];
    cout << endl;
  }
  for (i=0;i<nDist;i++) {
    for (j=0;j<nDist;j++)
      cout << setw(10) << cOrder[i][j];
    cout << endl;
  }
*/
  for (i=0;i<nDist;i++)
    rChoice[i] = cChoice[i] = -1;

  for (i=0;i<nDist;i++)
    q[i] = i;
  qC = nDist;

  while (qC > 0) {
    qH = ++qH % (MAX_DIST/2);
    qC--;
    tmp = q[qH];
    rChoice[tmp]++;
    if (cChoice[rOrder[tmp][rChoice[tmp]]] == -1) {
      cChoice[rOrder[tmp][rChoice[tmp]]] = tmp;
    } else {
      for (i=0;cOrder[rOrder[tmp][rChoice[tmp]]][i] != tmp;i++);
      for (j=0;cOrder[rOrder[tmp][rChoice[tmp]]][j] !=
        cChoice[rOrder[tmp][rChoice[tmp]]];j++);
      if (i < j) {
        q[qT] = cChoice[rOrder[tmp][rChoice[tmp]]];
        cChoice[rOrder[tmp][rChoice[tmp]]] = tmp;
      } else {
        q[qT] = tmp;
      }
      qT = ++qT % (MAX_DIST/2);
      qC++;
    }
  }

  for (i=0;i<nDist;i++)
    total += dists[i][rOrder[i][rChoice[i]]];

  return total;
}

int main(void) {
  double
    dists[MAX_POINTS][MAX_POINTS],
    mergedDists[MAX_DIST/2][MAX_DIST/2],
    total = 0,
    totalAfter;
  int
    mergedPoints[MAX_POINTS][2];

  cin >> nDist;
  for (int i=0;i<nDist;i++) {
    cin >> dSizes[i];
    for (int j=0;j<dSizes[i];j++)
      cin >> districts[i][j][0] >> districts[i][j][1];
    generateDistances(dists,districts[i],dSizes[i]);
    total += heldKarp(dists,dSizes[i]);
  }

  for (int i=0;i<nDist/2;i++) {
    for (int j=0;j<dSizes[i];j++) {
      mergedPoints[j][0] = districts[i][j][0];
      mergedPoints[j][1] = districts[i][j][1];
    }
    for (int j=nDist/2;j<nDist;j++) {
      for (int k=0;k<dSizes[j];k++) {
        mergedPoints[k+dSizes[i]][0] = districts[j][k][0];
        mergedPoints[k+dSizes[i]][1] = districts[j][k][1];
      }
      generateDistances(dists,mergedPoints,dSizes[i]+dSizes[j]);
//      mergedDists[i][j-nDist/2] = heldKarp(dists,dSizes[i]+dSizes[j]);
      cost[i][j-nDist/2] = heldKarp(dists,dSizes[i]+dSizes[j]);
    }
  }

  double mm = 0;
  for (int i=0;i<nDist/2;i++)
    for (int j=0;j<nDist/2;j++)
      mm = max(mm,cost[i][j]);
  for (int i=0;i<nDist/2;i++)
    for (int j=0;j<nDist/2;j++)
      cost[i][j] = mm - cost[i][j];

//  totalAfter = stableMarriage(mergedDists,nDist/2);
n = nDist / 2;
totalAfter = (mm * nDist) / 2 - hungarian();
  cout << fixed << setprecision(6);
  cout << total << ' ' << totalAfter << endl;

  return 0;
}