Problem:
Score : 300 points

Problem Statement

You are given an integer N.

Find a triple of positive integers h, n and w such that 4/N = 1/h + 1/n + 1/w.

If there are multiple solutions, any of them will be accepted.

Constraints

It is guaranteed that, for the given integer N, there exists a solution such that h,n,w \leq 3500.

Inputs

Input is given from Standard Input in the following format:

N

Outputs

Print a triple of positive integers h, n and w that satisfies the condition, in the following format:

h n w

Sample Input 1

2

Sample Output 1

1 2 2

4/2 = 1/1 + 1/2 + 1/2.

Sample Input 2

3485

Sample Output 2

872 1012974 1539173474040

It is allowed to use an integer exceeding 3500 in a solution.

Sample Input 3

4664

Sample Output 3

3498 3498 3498

Solution in C# (Mono 4.6.2.0) (judge verdict: Runtime Error)

using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
class Solve{
    public Solve(){}
    StringBuilder sb;
    ReadData re;
    public static int Main(){
        new Solve().Run();
        return 0;
    }
    void Run(){
        sb = new StringBuilder();
        re = new ReadData();
        Calc();
        Console.Write(sb.ToString());
    }
    void Calc(){
        int N = re.i();
        double[] A = new double[N];
        double[] B = new double[N];
        double[] C = new double[N];
        for(int i=0;i<N;i++){
            double a = re.i();
            double b = re.i();
            double c = re.i();
            A[i] = a;
            B[i] = b;
            C[i] = c;
        }
        int[] O = new int[N];
        for(int i=0;i<N;i++){
            O[i] = i;
        }
        {
            double[] X = new double[N];
            for(int i=0;i<N;i++){
                X[i] = A[i]/B[i];
            }
            Array.Sort(X,O);
            int[] O2 = new int[N];
            for(int i=0;i<N;i++){
                O2[O[i]] = i;
            }
            O = O2;
        }
        double bf = -1000000000;
        double bl = 1000000000;
        int M = (N*(N-1)/2+1)/2;
        while(bf + 0.000000001 <= bl){
            double bc = (bf+bl)/2;
            double[] Y = new double[N];
            int[] O2 = new int[N];
            for(int i=0;i<N;i++){
                Y[i] = (C[i]-A[i]*bc)/B[i];
                O2[i] = i;
            }
            Array.Sort(Y,O2);
            BIT bit = new BIT(N);
            int count = 0;
            for(int i=N-1;i>=0;i--){
                count += bit.Sum(O[O2[i]]);
                bit.Add(O[O2[i]]);
            }
            if(count >= M){
                bl = bc;
            }
            else{
                bf = bc;
            }
        }
        sb.Append((bf+bl)/2+" ");
        for(int i=0;i<N;i++){
            O[i] = i;
        }
        {
            double[] Y = new double[N];
            for(int i=0;i<N;i++){
                Y[i] = B[i]/A[i];
            }
            Array.Sort(Y,O);
            int[] O2 = new int[N];
            for(int i=0;i<N;i++){
                O2[O[i]] = i;
            }
            O = O2;
        }
        bf = -10000000000000;
        bl = 10000000000000;
        while(bf + 0.000000001 <= bl){
            double bc = (bf+bl)/2;
            double[] X = new double[N];
            int[] O2 = new int[N];
            for(int i=0;i<N;i++){
                X[i] = (C[i]-B[i]*bc)/A[i];
                O2[i] = i;
            }
            Array.Sort(X,O2);
            BIT bit = new BIT(N);
            int count = 0;
            for(int i=N-1;i>=0;i--){
                count += bit.Sum(O[O2[i]]);
                bit.Add(O[O2[i]]);
            }
            if(count >= M){
                bl = bc;
            }
            else{
                bf = bc;
            }
        }
        sb.Append((bf+bl)/2+"\n");
    }
}
struct BIT{
    int[] A;
    public BIT(int N){
        A = new int[N+1];
    }
    public void Add(int v){
        v++;
        while(v < A.Length){
            A[v]++;
            v += v & (-v);
        }
    }
    public int Sum(int v){
        v++;
        int C = 0;
        while(v > 0){
            C += A[v];
            v -= v & (-v);
        }
        return C;
    }
}
class ReadData{
    string[] str;
    int counter;
    public ReadData(){
        counter = 0;
    }
    public string s(){
        if(counter == 0){
            str = Console.ReadLine().Split(' ');
            counter = str.Length;
        }
        counter--;
        return str[str.Length-counter-1];
    }
    public int i(){
        return int.Parse(s());
    }
    public long l(){
        return long.Parse(s());
    }
    public double d(){
        return double.Parse(s());
    }
    public int[] ia(int N){
        int[] ans = new int[N];
        for(int j=0;j<N;j++){
            ans[j] = i();
        }
        return ans;
    }
    public int[] ia(){
        str = Console.ReadLine().Split(' ');
        counter = 0;
        int[] ans = new int[str.Length];
        for(int j=0;j<str.Length;j++){
            ans[j] = int.Parse(str[j]);
        }
        return ans;
    }
    public long[] la(int N){
        long[] ans = new long[N];
        for(int j=0;j<N;j++){
            ans[j] = l();
        }
        return ans;
    }
    public long[] la(){
        str = Console.ReadLine().Split(' ');
        counter = 0;
        long[] ans = new long[str.Length];
        for(int j=0;j<str.Length;j++){
            ans[j] = long.Parse(str[j]);
        }
        return ans;
    }
    public double[] da(int N){
        double[] ans = new double[N];
        for(int j=0;j<N;j++){
            ans[j] = d();
        }
        return ans;
    }
    public double[] da(){
        str = Console.ReadLine().Split(' ');
        counter = 0;
        double[] ans = new double[str.Length];
        for(int j=0;j<str.Length;j++){
            ans[j] = double.Parse(str[j]);
        }
        return ans;
    }
    public List<int>[] g(int N,int[] f,int[] t){
        List<int>[] ans = new List<int>[N];
        for(int j=0;j<N;j++){
            ans[j] = new List<int>();
        }
        for(int j=0;j<f.Length;j++){
            ans[f[j]].Add(t[j]);
            ans[t[j]].Add(f[j]);
        }
        return ans;
    }
    public List<int>[] g(int N,int M){
        List<int>[] ans = new List<int>[N];
        for(int j=0;j<N;j++){
            ans[j] = new List<int>();
        }
        for(int j=0;j<M;j++){
            int f = i()-1;
            int t = i()-1;
            ans[f].Add(t);
            ans[t].Add(f);
        }
        return ans;
    }
    public List<int>[] g(){
        int N = i();
        int M = i();
        List<int>[] ans = new List<int>[N];
        for(int j=0;j<N;j++){
            ans[j] = new List<int>();
        }
        for(int j=0;j<M;j++){
            int f = i()-1;
            int t = i()-1;
            ans[f].Add(t);
            ans[t].Add(f);
        }
        return ans;
    }
}
public static class Define{
    public const long mod = 1000000007;
}
public static class Debug{
    public static void Print(double[,,] k){
        for(int i=0;i<k.GetLength(0);i++){
            for(int j=0;j<k.GetLength(1);j++){
                for(int l=0;l<k.GetLength(2);l++){
                    Console.Write(k[i,j,l]+" ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }
    public static void Print(double[,] k){
        for(int i=0;i<k.GetLength(0);i++){
            for(int j=0;j<k.GetLength(1);j++){
                Console.Write(k[i,j]+" ");
            }
            Console.WriteLine();
        }
    }
    public static void Print(double[] k){
        for(int i=0;i<k.Length;i++){
            Console.WriteLine(k[i]);
        }
    }
    public static void Print(long[,,] k){
        for(int i=0;i<k.GetLength(0);i++){
            for(int j=0;j<k.GetLength(1);j++){
                for(int l=0;l<k.GetLength(2);l++){
                    Console.Write(k[i,j,l]+" ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }
    public static void Print(long[,] k){
        for(int i=0;i<k.GetLength(0);i++){
            for(int j=0;j<k.GetLength(1);j++){
                Console.Write(k[i,j]+" ");
            }
            Console.WriteLine();
        }
    }
    public static void Print(long[] k){
        for(int i=0;i<k.Length;i++){
            Console.WriteLine(k[i]);
        }
    }
    public static void Print(int[,,] k){
        for(int i=0;i<k.GetLength(0);i++){
            for(int j=0;j<k.GetLength(1);j++){
                for(int l=0;l<k.GetLength(2);l++){
                    Console.Write(k[i,j,l]+" ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }
    public static void Print(int[,] k){
        for(int i=0;i<k.GetLength(0);i++){
            for(int j=0;j<k.GetLength(1);j++){
                Console.Write(k[i,j]+" ");
            }
            Console.WriteLine();
        }
    }
    public static void Print(int[] k){
        for(int i=0;i<k.Length;i++){
            Console.WriteLine(k[i]);
        }
    }
}