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

use std::io::Read;

pub fn read_stdin() -> String {
    let mut s = String::new();
    ::std::io::stdin().read_to_string(&mut s).unwrap();
    s
}

pub trait Parse {
    fn to<T>(&mut self) -> T
    where
        T: std::str::FromStr;
}

impl<'a> Parse for std::str::SplitWhitespace<'a> {
    fn to<T>(&mut self) -> T
    where
        T: std::str::FromStr,
    {
        let word = self.next().unwrap();
        word.parse().ok().unwrap()
    }
}

fn factorization(x: u64) -> Vec<u64> {
    let mut base = x;
    let mut div = 2;
    let mut v = Vec::new();
    v.push(1);
    if x == 1 {
        return v;
    }

    let last = (base as f64).sqrt() as u64;
    while last >= div {
        if base % div == 0 {
            base /= div;
            v.push(div);
            continue;
        }
        div += 1;
    }
    if base != 1 {
        v.push(base);
    }
    v
}

fn main() {
    let source = read_stdin();
    let mut iter = source.split_whitespace();
    let n = iter.to();
    let mut v = factorization(n);
    v = v.into_iter().filter(|&x| x != 1).collect();

    let mut vv = Vec::with_capacity(2_u32.pow(v.len() as u32) as usize);
    vv.push(1);
    vv.push(v[0]);
    for i in 1..v.len() {
        let mut vvv = Vec::new();
        for x in vv.clone() {
            vvv.push(x);
            vvv.push(x * v[i]);
        }
        vv = vvv;
    }

    let mut out = Vec::new();
    for x in vv {
        out.push((x, n / x));
    }

    println!(
        "{}",
        out.into_iter()
            .map(|(a, b)| (a - 1) + (b - 1))
            .min()
            .unwrap()
    );
}