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 Scala (2.11.7) (judge verdict: Wrong Answer)

import scala.io.StdIn._

object Main extends App {
  def div(n: Long, d: Int, divs: List[Long]): List[Long] = {
    if (d > 1000000) {
      (if (n == 1) divs else n :: divs)
    } else {
      (n % d) match {
        case 0 => div(n / d, d, d :: divs)
        case _ => div(n, d + 1, divs)
      }
    }
  }

  def mult(l: Long, r: Long, divs: List[Long]): (Long, Long) = {
    divs match {
      case Nil => (l, r)
      case x :: xs => if (l < r) mult(l * x, r, xs) else mult(l, r * x, xs)
    }
  }

  val (l, r) = mult(1, 1, div(readLong, 2, Nil))
  println(l + r - 2)
}