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 Python (3.4.3) (judge verdict: Time Limit Exceeded)

# import sys
import numpy as np
# sys.setrecursionlimit(200000)

def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr


N = list(map(int, input().split(" ")))[0]

so = []
for n, i in (factorization(N)):
    for _ in range(i):
        so.append(n)
so = np.sort(so)[::-1]

l = len(so)

res = []

for i in range(1, 2 ** len(so) - 1):
    b = list(map(int, list(bin(i)[2:])))
    index = np.array([0] * (l - len(b)) + b, np.bool)
    A = np.cumprod(so[index])[-1]
    B = np.cumprod(so[~index])[-1]
    res.append(A + B - 2)

print(np.min(list(res) + [N - 1]))