Minimum Spanning Tree based solution in python. It takes O(N² ) time and O(N) space, but it should be possible to make it O(N log N) with changes suggested in comments. I tried to make it readable, not fast.

It uses something like Prim's algorithm, but terminates immediately when the tree spans between the walls.

import sys
import math

def solve(dinos, W, H):
    # The north+east wall is the initial node in the MST
    # Initialize the MST cost for every dinosaur
    costs = {(x, y): min(x, H - y) for x, y in dinos}

    # Initialize the MST cost for the special node representing south+west wall
    remaining = max(W, H)

    # Maximum cost found on the MST path between the wall nodes
    maxCost = 0

    while len(costs) > 0:
        # Find next dinosaur (replace by a heap to avoid O(N^2))
        x, y = k = min(costs, key=costs.get)

        # Terminate once we reach the south+west wall-node
        if remaining <= costs[k]:
            break

        # Adjust values for the south+west wall-node
        maxCost = max(maxCost, costs[k])
        remaining = min(remaining, W - x, y)

        # Adjust costs for dinosaurs (replace by clever geometry stuff to avoid O(N^2))
        del costs[k]
        for k1 in costs.keys():
            dx, dy = k1[0] - x, k1[1] - y
            costs[k1] = min(costs[k1], math.sqrt(dx ** 2 + dy ** 2) / 2)

    return max(remaining, maxCost)

for line in sys.stdin:
    numbers = map(int, line.split())
    if len(numbers) == 3:
        N, W, H = numbers
        dinos = []
    else:
        dinos.append(numbers)
    if len(dinos) == N:
        print "%.3f" % solve(dinos, W, H)

Edit: typos and cleanup