#include <iostream>
#include <fstream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <queue>
#include <limits>
#include <stdexcept>
using namespace std;
typedef pair<double, double> Soldier, Shelter;
const double kInfinite = 1e50;
const double kEpsilon = 1e-6;
int cmp(double a, double b) {
if (a + kEpsilon < b)
return -1;
if (b + kEpsilon < a)
return 1;
return 0;
}
bool equal(double a, double b) {
return cmp(a, b) == 0;
}
class SimpleGraph {
public:
SimpleGraph(int size):
size_(size),
edges_(size) {
}
void addEdge(int from, int to) {
edges_[from].push_back(to);
}
bool didInvertChain(int from, int to) {
queue<int> Q;
Q.push(from);
vector<int> parent(size_, -1);
parent[from] = from;
while (!Q.empty()) {
int node = Q.front();
Q.pop();
if (node == to)
break;
for (auto &next : edges_[node])
if (parent[next] == -1) {
parent[next] = node;
Q.push(next);
}
}
if (parent[to] == -1)
return false;
for (int node = to; node != from; node = parent[node]) {
vector<int> &where = edges_[parent[node]];
where.erase(find(where.begin(), where.end(), node));
edges_[node].push_back(parent[node]);
}
return true;
}
const vector<int>& edges(int node) const {
return edges_[node];
}
private:
int size_;
vector< vector<int> > edges_;
};
class BipartiteGraph {
public:
BipartiteGraph(int size_l, int size_r):
size_l_(size_l),
size_r_(size_r),
edges_(size_l),
leftMatch(size_l, -1),
rightMatch(size_r, -1),
costLeft(size_l, 0),
costRight(size_r, 0) {
}
void addEdge(int from, int to, double distance) {
edges_[from].push_back({to, distance});
}
double minimumWeightMatching() {
if (size_l_ != size_r_)
throw new runtime_error("Graph is not regular");
int steps = size_l_;
while (steps) {
vector<bool> usedLeft(size_l_, false), usedRight(size_r_, false);
vector<double> tillEdge(size_r_, kInfinite);
queue<int> Q;
for (int i = 0; i < size_l_; ++i)
if (leftMatch[i] == -1) {
usedLeft[i] = true;
Q.push(i);
}
auto updateRight = [&](int node) {
usedRight[node] = true;
tillEdge[node] = kInfinite;
// go left if possible
if (rightMatch[node] != -1) {
usedLeft[rightMatch[node]] = true;
Q.push(rightMatch[node]);
}
};
do {
while (!Q.empty()) {
int node = Q.front();
Q.pop();
// pass the graph
for (auto &next : edges_[node])
if (not usedRight[next.to]) {
if (equal(costLeft[node] + costRight[next.to], next.distance)
&& next.to != leftMatch[node])
updateRight(next.to);
else
tillEdge[next.to] = min(tillEdge[next.to],
next.distance - costLeft[node] - costRight[next.to]);
}
}
int nextChange = min_element(tillEdge.begin(), tillEdge.end()) - tillEdge.begin();
double change = tillEdge[nextChange];
// we're still stuck here, let's extend
for (int i = 0; i < size_l_; ++i) {
if (usedLeft[i])
costLeft[i] += change;
if (usedRight[i])
costRight[i] -= change;
else if (!equal(tillEdge[i], kInfinite))
tillEdge[i] -= change;
}
if (rightMatch[nextChange] == -1)
break;
updateRight(nextChange);
} while (true);
// yey we got a new edge
used = vector<bool>(size_l_, false);
for (int i = 0; i < size_l_; ++i)
if (leftMatch[i] == -1)
if (match(i))
--steps;
}
// and lucky for us the sum of y's is the answer
double answer = 0;
for (int i = 0; i < size_l_; ++i)
answer += costLeft[i] + costRight[i];
return answer;
}
private:
class Edge {
public:
Edge(int _to, double _distance):
to(_to), distance(_distance) {}
int to;
double distance;
};
// hopcroft-karp style
bool match(int node) {
if (used[node])
return false;
used[node] = true;
for (auto &next : edges_[node])
if (equal(costLeft[node] + costRight[next.to], next.distance)) {
if (rightMatch[next.to] == -1) {
rightMatch[next.to] = node;
leftMatch[node] = next.to;
return true;
}
if (match(rightMatch[next.to])) {
rightMatch[next.to] = node;
leftMatch[node] = next.to;
return true;
}
}
return false;
}
int size_l_, size_r_;
vector< vector<Edge> > edges_;
vector<int> leftMatch, rightMatch;
vector<double> costLeft, costRight;
vector<bool> used;
};
int main() {
ifstream cin("adapost.in");
ofstream cout("adapost.out");
int N; cin >> N;
vector<Soldier> A(N);
vector<Shelter> B(N);
for (int i = 0; i < N; ++i)
cin >> A[i].first >> A[i].second;
for (int i = 0; i < N; ++i)
cin >> B[i].first >> B[i].second;
vector< vector<double> > distance(N, vector<double>(N, 0));
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
distance[i][j] = sqrt((A[i].first - B[j].first) * (A[i].first - B[j].first) +
(A[i].second - B[j].second) * (A[i].second - B[j].second));
vector< pair<int, int> > pairs(N * N);
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
pairs[i * N + j] = {i, j};
sort(pairs.begin(), pairs.end(), [&](pair<int, int> A, pair<int, int> B) {
return distance[A.first][A.second] < distance[B.first][B.second];
});
SimpleGraph G(2 * N + 2);
for (int i = 0; i < N; ++i) {
G.addEdge(2 * N, i); // source to soldier
G.addEdge(i + N, 2 * N + 1); // shelter to sink
}
int matches = 0;
double maxDistance = 0;
for (auto &pair: pairs) {
G.addEdge(pair.first, pair.second + N);
while (G.didInvertChain(2 * N, 2 * N + 1)) // we invert a chain between the source and sink
// at most one new chain can appear when we add an edge
++matches;
if (matches == N) {
maxDistance = distance[pair.first][pair.second];
break;
}
}
cout.setf(ios::fixed, ios::floatfield);
cout.precision(5);
cout << maxDistance << " ";
BipartiteGraph M(N, N);
for (int i = 0; i < N; ++i) {
for (auto &next : G.edges(i))
if (next != 2 * N) // if it's not a source edge
M.addEdge(i, next - N, distance[i][next - N]);
for (auto &prev : G.edges(i + N))
if (prev != 2 * N + 1) // if it's not a sink edge
M.addEdge(prev, i, distance[prev][i]);
}
cout << M.minimumWeightMatching() << "\n";
}