# USACO 2016 Dec Gold

## Problem 1. Moocast

Farmer John’s N cows (1≤N≤1000) want to organize an emergency “moo-cast” system for broadcasting important messages among themselves.

Instead of mooing at each-other over long distances, the cows decide to equip themselves with walkie-talkies, one for each cow. These walkie-talkies each have a limited transmission radius, but cows can relay messages to one-another along a path consisting of several hops, so it is not necessary for every cow to be able to transmit directly to every other cow.

The cows need to decide how much money to spend on their walkie-talkies. If they spend $X, they will each get a walkie-talkie capable of transmitting up to a distance of X−−√. That is, the squared distance between two cows must be at most X for them to be able to communicate.

Please help the cows determine the minimum integer value of X such that a broadcast from any cow will ultimately be able to reach every other cow.

INPUT FORMAT (file moocast.in):

The first line of input contains N.

The next N lines each contain the x and y coordinates of a single cow. These are both integers in the range 0…25,000.

OUTPUT FORMAT (file moocast.out):

Write a single line of output containing the integer X giving the minimum amount the cows must spend on walkie-talkies.

SAMPLE INPUT:

```
4
1 3
5 4
7 2
6 1
```

SAMPLE OUTPUT:

```
17
```

Problem credits: Richard Peng

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

const int MaX = 100001;
int N, M;
vector<pair<int, int>> cows(MaX);
vector<int> parent(MX);
int find(int x) {
if (x == parent[x]) {
return x;
}
else {
return parent[x] = find(parent[x]);
}
}
void mergeCows(int a, int b) {
int c = find(a);
int d = find(b);
if (a < b) {
parent[d] = c;
}
else {
parent[c] = d;
}
}
struct line {
int a;
int b;
int w;
};
int main() {
setIO("moocast");
cin >> N;
F0R(i, N) {
cin >> cows[i].f >> cows[i].s;
parent[i] = i;
}
vector<line> edges;
F0R(i, N) {
F0R(j, i) {
if (i != j) {
edges.push_back({i, j, ((abs(cows[i].f - cows[j].f) * abs(cows[i].f - cows[j].f)) +
(abs(cows[i].s - cows[j].s) * abs(cows[i].s - cows[j].s)))});
}
}
}
sort(all(edges), [](line a, line b) {return a.w < b.w;});
int ans = 0;
F0R(i, edges.size()) {
if (find(edges[i].a) != find(edges[i].b)) {
mergeCows(edges[i].a, edges[i].b);
ans = max(edges[i].w, ans);
}
}
cout << ans;
}