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 Kotlin (1.0.0) (judge verdict: Wrong Answer)

fun main(args: Array<String>) {
    val n = readLine()?.toLong() ?: return
    fun isPrime(n: Long): Boolean {
        if (n == 2L) {
            return true
        }
        if (n % 2L == 0L) {
            return false
        }
        for (i in 3L until Math.sqrt(n.toDouble()).toLong() + 1 step 2L) {
            if (n % i == 0L) {
                return false
            }
        }
        return true
    }

    fun listFactors(n: Long): List<Long> {
        var number = n
        val factors = mutableListOf<Long>(1)
        while (number % 2 == 0L) {
            factors.add(2)
            number /= 2
        }
        var factor = 3L
        while (number > 1) {
            if (number % factor == 0L) {
                factors.add(factor)
                number /= factor
            } else {
                factor += 2L
            }
        }
        return factors
    }
    if (isPrime(n)) {
        println("${n - 1}")
        return
    }
    var factors = listFactors(n).toMutableList()
    while (factors.size > 2) {
        val next = mutableListOf<Long>()
        0.until(factors.size / 2).forEach {
            val a = factors[it]
            val b = factors[factors.size - 1 - it]
            next.add(a * b)
        }
        if (factors.size % 2 == 1) {
            next.add(factors[factors.size / 2])
        }
        next.sort()
        factors = next
    }
    println("${factors[0] - 1 + factors[1] - 1}")
}