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: Accepted)

use std::io::Read;
use std::cmp::min;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();

    let answer = solve(&buf);

    println!("{}", answer);
}

fn solve(input: &str) -> String {
    let mut iterator = input.split_whitespace();

    let n: u64 = iterator.next().unwrap().parse().unwrap();

    let x_max: u64 = (n as f64).sqrt() as u64;

    let mut ans = n - 1;

    let mut x: u64 = 2;
    while x <= x_max {
        if n % x != 0 {
            x += 1;
            continue;
        }
        let y: u64 = n / x;
        if x > y {
            break;
        }
        ans = min(ans, x + y - 2);
        x += 1;
    }

    return format!("{}", ans);
}

#[test]
fn test() {
    assert_eq!(
        solve(
            r"10"
        ),
        "5"
    );
    assert_eq!(
        solve(
            r"50"
        ),
        "13"
    );
    assert_eq!(
        solve(
            r"10000000019"
        ),
        "10000000018"
    );
}