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 Ruby (2.3.3) (judge verdict: Runtime Error)

def subtract_once(seruhu, values)
    counts = values.inject(Hash.new(0)) { |h, v| h[v] += 1; h }
    seruhu.reject { |e| counts[e] -= 1 unless counts[e].zero? }
end

def cc144
    n = gets.chomp.to_i

    m = Math.sqrt(n).to_i
    if m * m == n
        puts (m-1) * 2
        exit
    end

    require 'Prime'
    if Prime.prime?(n)
        puts n-1
        exit
    end

    x = []
    Prime.prime_division(n).each do |m|
        m[1].times do
            x.push(m[0])
        end
    end

    mi = 1000000000001
    a = []
    b = []
    (0..x.length).inject([]) do |ret, m|
        ret.push(*x.combination(m))
    end.each do |y|
        z = subtract_once(x, y)
        next unless y.length+z.length == x.length

        yy = y.inject(1) {|sum, m| sum *= m}
        zz = z.inject(1) {|sum, m| sum *= m}
        cm = (yy - zz).abs
        next if cm == 0

        mi = [mi, cm].min
        if cm == mi
            a = yy
            b = zz
        end
    end

    puts (a-1) + (b-1)
end

cc144