import java.util.*;

public class Tours_john
{
    public static final int MAX = 20;                 // max number of cities in a district
    public static final int MAXD = 50;                // max # of districts

    public static final double INF = 10000000.0;

    public static double[][] dists = new double[MAX][MAX];             // used to calculated TSP for a given district
    public static double[][] combined;                                 // TSP values for all possible fired/not-fired district matchings

    public static district[] districts = new district[MAXD];

    public static double calcEuclidean(point p1, point p2)
    {
        double dx = p1.x - p2.x;
        double dy = p1.y - p2.y;
        return Math.sqrt(dx*dx + dy*dy);
    }

    public static double buildTable(int n)
    {
        Queue<set> q = new LinkedList<>();
        double[][] table = new double[1<<(n-1)][n-1];
        int startv = n-1;

        for(int i=0; i<n-1; i++) {
            set s = new set();
            s.vals[0] = s.largest = i;
            s.size = 1;
            s.index = (1 << i);
            table[s.index][i] = dists[startv][i];
            int save = s.index;
            for(int val=s.largest+1; val<n-1; val++) {
                set news = new set(s);
                news.vals[news.size] = val;
                news.size++;
                news.largest = val;
                news.index = save | (1 << val);
                q.add(news);
            }
        }
        while (!q.isEmpty()) {
            set s = q.remove();
            for(int i=0; i<s.size; i++) {
                int endv = s.vals[i];
                int index = s.index - (1 << endv);
                double best = INF;
                for(int j=0; j<s.size; j++) {
                    if (j == i)
                        continue;
                    double val = table[index][s.vals[j]] + dists[endv][s.vals[j]];
                    if (val < best)
                        best = val;
                }
                table[s.index][endv] = best;
            }
            int save = s.index;
            for(int val=s.largest+1; val<n-1; val++) {
                set news = new set(s);
                news.vals[news.size] = val;
                news.size++;
                news.largest = val;
                news.index = save | (1 << val);
                q.add(news);
            }
        }
        double best = INF;
        int maxindex = (1 << (n-1)) - 1;
        for(int i=0; i<startv; i++) {
            if (table[maxindex][i] + dists[i][startv] < best)
                best = table[maxindex][i] + dists[i][startv];
        }
        return best;
    }

    public static double calcCombined(district d1, district d2)
    {
        int n1 = d1.size, n2 = d2.size;
        for(int i=0; i<n1; i++) {
            for(int j=0; j<i; j++) {
                dists[i][j] = dists[j][i] = calcEuclidean(d1.locs[i],  d1.locs[j]);
            }
        }
        for(int i=0; i<n2; i++) {
            for(int j=0; j<i; j++) {
                dists[n1+i][n1+j] = dists[n1+j][n1+i] = calcEuclidean(d2.locs[i],  d2.locs[j]);
            }
        }
        for(int i=0; i<n1; i++) {
            for(int j=0; j<n2; j++) {
                dists[i][n1+j] = dists[n1+j][i] = calcEuclidean(d1.locs[i], d2.locs[j]);
            }
        }
        return buildTable(n1+n2);
    }

    public static void main(String [] args)
    {
        Scanner in = new Scanner(System.in);
        int d;
        d = in.nextInt();;
        double beforeLength = 0.0;
        for(int i=0; i<d; i++) {
            int n = in.nextInt();
            districts[i] = new district(n);
            for(int j=0; j<districts[i].size; j++) {
                districts[i].locs[j].x = in.nextInt();
                districts[i].locs[j].y = in.nextInt();
                for(int k=0; k<j; k++) {
                    dists[j][k] = dists[k][j] = calcEuclidean(districts[i].locs[j], districts[i].locs[k]);
                }
            }
            beforeLength += buildTable(districts[i].size);
        }
//        System.out.println(beforeLength);
        combined = new double[d/2][d/2];
        for(int i=0; i<d/2; i++) {
            for(int j=d/2; j<d; j++) {
                combined[i][j-d/2] = calcCombined(districts[i], districts[j]);
 //System.out.print(combined[i][j-d/2] + " ");
            }
 //System.out.println();
        }

        Graph g = new Graph();
   		Matching match = new Matching();
		g.build(combined);
		g.initPrices();
		for(int i=0; i<d/2; i++) {
//g.print();
			Path p = g.nextAugmentingPath();
//if (i == n-1) g.print();
			match.update(p);
			g.rebuild(p);
			g.updatePrices();
		}
//		System.out.println(match);
		double afterLength = 0.0;
		for(int i=0; i<d/2; i++) {
            int row = match.first.elementAt(i).vnum - 1;
            int col = match.second.elementAt(i).vnum - 1 - d/2;
            afterLength += combined[row][col];
		}
//System.out.println(afterLength);
		System.out.printf("%.6f %.6f\n", beforeLength, afterLength);
	}
}

class point
{
    public double x, y;
};

class district
{
    public int size;
    public point[] locs;

    district(int n)
    {
        size = n;
        locs = new point[size];
        for(int i=0; i<n; i++)
            locs[i] = new point();
    }
};

class set{
    public int[] vals;
    public int size;
    public int largest;
    public int index;

    set()
    {
        vals = new int[Tours_john.MAX];
    }

    set(set s)
    {
        vals = new int[Tours_john.MAX];
        size = s.size;
        largest = s.largest;
        index = s.index;
        for(int i=0; i<size; i++)
            vals[i] = s.vals[i];
    }
};

class Vertex
{
	public String name;
	public List<Edge> adj;
	public int vnum;
	public double price;
	public double dist;
	public Vertex prev;
	public boolean visited;

	public Vertex(String nm, int n)
	{
		name = nm;
		adj = new LinkedList<Edge>();
		vnum = n;
		price = dist = Graph.INFINITY;
		prev = null;
	}

	public String toString()
	{
		return name;
	}

	public void updatePrice()
	{
		price += dist;
	}

	public void reset()
	{
		dist = Graph.INFINITY;
		prev = null;
		visited = false;
	}
}

class Edge
{
	public Vertex dest;
	public double cost;
	public double reducedCost;

	public Edge(Vertex d, double c)
	{
		dest = d;
		cost = c;
	}

	public void setReduced(double srcPrice)
	{
		reducedCost = cost + srcPrice - dest.price;
	}
}

class Path
{
	public int length;
	public Vertex[] path;

	public Path(int max)
	{
		path = new Vertex[max];
		length = 0;
	}

	public void build(Vertex v)
	{
		if (v == null)
			return;
		build(v.prev);
		path[length++] = v;
	}

	public String toString()
	{
		String s = path[0].name;
		for(int i=1; i<length; i++) {
			s += " " + path[i].name;
		}
		return s;
	}
}

class Graph
{
	public static final double INFINITY = Double.MAX_VALUE;

	private Vertex[] vertices;
	private int n;
	private int nVert;

	public void build(double[][] matrix)
	{
		n = matrix.length;
		nVert = 2*n+2;

		vertices = new Vertex[nVert];
		vertices[0] = new Vertex("s", 0);
		for(int i=0; i<n; i++) {
			vertices[i+1] = new Vertex("D" + (i+1), i+1);
			vertices[i+n+1] = new Vertex("D" + (i+n+1), i+n+1);
		}
		vertices[nVert-1] = new Vertex("t", nVert-1);

		for(int i=0; i<n; i++) {
			addEdge(0, i+1, 0.0);
			addEdge(i+n+1, nVert-1, 0.0);
		}
		for(int i=0; i<n; i++) {
			for(int j=0; j<n; j++) {
				addEdge(i+1, j+n+1, matrix[i][j]);
			}
		}
	}

	public void rebuild(Path p)
	{
		Edge e = findEdge(p.path[0], p.path[1]);
		vertices[0].adj.remove(e);
		for(int i=1; i<p.length-2; i++) {
			e = findEdge(p.path[i], p.path[i+1]);
			vertices[p.path[i].vnum].adj.remove(e);
			addEdge(p.path[i+1].vnum, p.path[i].vnum, -e.cost);
		}
		e = findEdge(p.path[p.length-2], p.path[p.length-1]);
		vertices[p.path[p.length-2].vnum].adj.remove(e);
	}

	public void addEdge(int i, int j, double cost)
	{
		Vertex v = vertices[i];
		Vertex w = vertices[j];
		v.adj.add(new Edge(w, cost));
	}

	public Edge findEdge(Vertex v, Vertex w)
	{
		for(Edge e : v.adj) {
			if (e.dest == w) {
				return e;
			}
		}
		return null;
	}

	public void initPrices()
	{
		vertices[0].price = 0.0;
		for(int i=1; i<=n; i++) {
			vertices[i].price = 0.0;
			for(Edge e : vertices[i].adj) {
				if (e.cost < vertices[e.dest.vnum].price)
					vertices[e.dest.vnum].price = e.cost;
			}
		}
		vertices[nVert-1].price = 0.0;
	}

	public Vertex getMinDistVertex()
	{
		Vertex ans = null;
		for(int i=0; i<nVert; i++) {
			Vertex v = vertices[i];
			if(!v.visited && (ans == null || v.dist < ans.dist))
				ans = v;
		}
		return ans;
	}

	public Path nextAugmentingPath()
	{
		for(int i=0; i<nVert; i++) {
			double p = vertices[i].price;
			for(Edge e : vertices[i].adj)
				e.setReduced(p);
			vertices[i].reset();				// prepare for Dijsktra's
		}
//print();
		vertices[0].dist = 0.0;
		for(int i=0; i<nVert; i++) {
			Vertex v = getMinDistVertex();
//System.out.println(i + ", " + v + " " + v.dist + " " + v.prev);
			v.visited = true;
			for(Edge e : v.adj) {
				Vertex w = e.dest;
				if (!w.visited && v.dist + e.reducedCost < w.dist) {
					w.dist = v.dist + e.reducedCost;
					w.prev = v;
				}
			}
		}

		Path p = new Path(nVert);
		p.build(vertices[nVert-1]);
		return p;
	}

	public void updatePrices()
	{
		for(int i=1; i<=2*n; i++) {
			vertices[i].price += vertices[i].dist;
		}
	}

	public void print()
	{
		for(int i=0; i<nVert; i++) {
			Vertex v = vertices[i];
			System.out.println(v.name + ": " + v.vnum + ", " + v.price);
			for( Edge e : v.adj) {
				System.out.println("  " + e.dest.name + "," + e.cost + "->" + e.reducedCost);
			}
		}
	}
}

class Matching
{
	public Vector<Vertex> first;
	public Vector<Vertex> second;

	public Matching()
	{
		first = new Vector<Vertex>();
		second = new Vector<Vertex>();
	}

	public void update(Path p)
	{
		first.add(p.path[1]);
		second.add(p.path[2]);
//System.out.println("add " + p.path[1] + "-" + p.path[2]);
		for(int i=2; i<p.length-2; i+=2) {
//System.out.println("remove " + p.path[i+1] + "-" + p.path[i]);
			int j = first.indexOf(p.path[i+1]);
			first.remove(j);
			second.remove(j);
			first.add(p.path[i+1]);
			second.add(p.path[i+2]);
//System.out.println("add " + p.path[i+1] + "-" + p.path[i+2]);
		}
	}

	public String toString()
	{
		String ans = "";
		for(int i=0; i<first.size(); i++)
			ans += first.elementAt(i).name + "-" + second.elementAt(i).name + "\n";
		return ans;
	}
}