Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

有理式最大化

N 個の異なる自然数が与えられる。その中から異なる４つを選んで、それらを $A$, $B$, $C$, $D$ としたとき、次の数式

$\frac{A + B}{C - D}$

の最大値を求めたい。

N 個の異なる自然数が与えられたとき、その中から異なる４つを選んで、上の数式の最大値を求めるプログラムを作成せよ。

Input

入力は以下の形式で与えられる。

N
a1 a2 ... aN

１行目に自然数の個数 N (4 ≤ N ≤ 1000) が与えられる。２行目に各自然数の値 ai (1 ≤ ai ≤ 108) が与えられる。ただし、同じ自然数が重複して現れることはない（i ≠ j について ai ≠ aj)。

Output

与えられた N 個の自然数に対して、上の数式の最大値を実数で出力する。ただし、誤差がプラスマイナス 10-5 を超えてはならない。

Sample Input 1

10
1 2 3 4 5 6 7 8 9 10

Sample Output 1

19.00000

入力例１では、$A=9$, $B=10$, $C=2$, $D=1$ などの組み合わせで最大になる。

Sample Input 2

5
22 100 42 3 86

Sample Output 2

9.78947

入力例２では、$A=100$, $B=86$, $C=22$, $D=3$ などの組み合わせで最大になる。

Sample Input 3

6
15 21 36 10 34 5

Sample Output 3

18.00000

入力例３では、$A=21$, $B=15$, $C=36$, $D=34$ などの組み合わせで最大になる。

Sample Input 4

4
100000 99999 8 1

Sample Output 4

28571.285714

Solution in JAVA (judge verdict: Wrong Answer)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

import static java.lang.Integer.parseInt;

/**
 * Maximization of Relational Expression
 */
public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line;
		String[] words;

		int n = parseInt(br.readLine());

		long[] a = Arrays.stream(br.readLine().split(" "))
				.mapToLong(Long::parseLong)
				.sorted()
				.toArray();

		Map<Long, List<int[]>> max = new HashMap<>();
		Map<Long, List<int[]>> min = new HashMap<>();

		for (int i = 0; i < n; i++) {
			for (int j = i + 1; j < n; j++) {
				max.putIfAbsent(a[j] + a[i], new ArrayList<>());
				max.get(a[j] + a[i]).add(new int[]{j, i});
				min.putIfAbsent(a[j] - a[i], new ArrayList<>());
				min.get(a[j] - a[i]).add(new int[]{j, i});
			}
		}

		Set<Double> ans = new TreeSet<>();

		for (long _max : max.keySet()) {
			for (long _min : min.keySet()) {
				outer:
				for (int[] __max : max.get(_max)) {
					for (int[] __min : min.get(_min)) {
						if (__max[0] != __min[0]
								&& __max[0] != __min[1]
								&& __max[1] != __min[0]
								&& __max[1] != __min[1]) {
							ans.add((double) _max / _min);
							break outer;
						}
					}
				}
			}
		}

		System.out.println(ans.stream().max(Comparator.naturalOrder()).get());

	}
}