Problem:
Score : 300 points

Problem Statement

Takahashi is standing on a multiplication table with infinitely many rows and columns.

The square (i,j) contains the integer i \times j. Initially, Takahashi is standing at (1,1).

In one move, he can move from (i,j) to either (i+1,j) or (i,j+1).

Given an integer N, find the minimum number of moves needed to reach a square that contains N.

Constraints

2 \leq N \leq 10^{12}

N is an integer.

Input

Input is given from Standard Input in the following format:

N

Output

Print the minimum number of moves needed to reach a square that contains the integer N.

Sample Input 1

10

Sample Output 1

5

(2,5) can be reached in five moves. We cannot reach a square that contains 10 in less than five moves.

Sample Input 2

50

Sample Output 2

13

(5, 10) can be reached in 13 moves.

Sample Input 3

10000000019

Sample Output 3

10000000018

Both input and output may be enormous.

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class Main {
	public static void main(String[] args) throws Exception {

		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		long N = Long.parseLong(reader.readLine());
		long N_keep = N;
		long A_keep = 2;
		ArrayList<Long> list = new ArrayList();
		boolean sosuu = false;
		boolean flag = false;
		for (long A = A_keep; A <= Math.sqrt(N); A++) {
			if (N % A == 0) {
				flag = true;
				break;
			}
		}
		if (!flag) {
			sosuu = true;
			System.out.println(N - 1);
		}
		
		if (!sosuu) {
			while (N_keep > 1) {
				for (long A = A_keep; A <= N_keep; A++) {
					if (N_keep % A == 0) {
						N_keep = N_keep / A;
						list.add(A);
						break;
					}
				}
				//System.out.println("N_keep=" + N_keep);    ////////////////
			}
			//System.out.println(list.toString());   ///////////////
			Long min = Long.MAX_VALUE;
			for (int i = 0; i < list.size() - 1; i++) {
				long a_mul = 1;
				for (int a = 0; a <= i; a++) {
					a_mul *= list.get(a);
				}
				long b_mul = N / a_mul;
				if (a_mul + b_mul < min) {
					min = a_mul + b_mul;
				}
			}
			System.out.println(min - 2);
		}
		

		//		for (int i = 0; i < list.size(); i++) {
		//			for (int k = i; k < list.size(); k++) {
		//				if (list.get(i) * list.get(k) == N && list.get(i) + list.get(k) < min) {
		//					min = list.get(i) + list.get(k);
		//				}
		//			}
		//		}
		//		System.out.println(min - 2);
	}
}