Problem:
Score : 500 points

Problem Statement

You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N.
You would like to sort this sequence in ascending order by repeating the following operation:

Choose an element in the sequence and move it to the beginning or the end of the sequence.

Find the minimum number of operations required.
It can be proved that it is actually possible to sort the sequence using this operation.

Constraints

1 \leq N \leq 2\times 10^5

(P_1,P_2,...,P_N) is a permutation of (1,2,...,N).

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
P_1
:
P_N

Output

Print the minimum number of operations required.

Sample Input 1

4
1
3
2
4

Sample Output 1

2

For example, the sequence can be sorted in ascending order as follows:

Move 2 to the beginning. The sequence is now (2,1,3,4).

Move 1 to the beginning. The sequence is now (1,2,3,4).

Sample Input 2

6
3
2
5
1
4
6

Sample Output 2

4

Sample Input 3

8
6
3
1
2
7
4
8
5

Sample Output 3

5

Solution in Rust (1.15.1) (judge verdict: Accepted)

use io::*;
use std::cmp::max;

fn main() {
    let con = read_string();
    let mut sc = Scanner::new(&con);

    let n: usize = sc.next();
    let ps: Vec<usize> = (0..n).map(|_| sc.next()).collect();

    let mut qs: Vec<(usize, usize)> = ps.into_iter().zip(0..n).collect();
    qs.sort();

    let mut prev = qs[0].1;
    let mut cur_len = 1;
    let mut max_len = 1;
    for i in 1..n {
        if prev <= qs[i].1 {
            cur_len += 1;
            max_len = max(max_len, cur_len);
        } else {
            cur_len = 1;
        }
        prev = qs[i].1;
    }

    println!("{}", n - max_len);

    // println!("{}", n - LongestIncreasingSubsequenceLength(&ps));
}

// fn CeilIndex(v: &[usize], mut l: i32, mut r: i32, key: usize) -> usize {
//     while r - l > 1 {
//         let m = l + (r - l) / 2;
//         if v[m as usize] >= key {
//             r = m;
//         } else {
//             l = m;
//         }
//     }

//     r as usize
// }

// fn LongestIncreasingSubsequenceLength(v: &[usize]) -> usize {
//     if v.len() == 0 {
//         return 0;
//     }

//     let mut tail = vec![0; v.len()];
//     let mut length = 1; // always points empty slot in tail

//     tail[0] = v[0];
//     for i in 1..v.len() {
//         if v[i] < tail[0] {
//             // new smallest value
//             tail[0] = v[i];
//         } else if v[i] > tail[length - 1] {
//             // v[i] extends largest subsequence
//             tail[length] = v[i];
//             length += 1;
//         } else {
//             // v[i] will become end candidate of an existing subsequence or
//             // Throw away larger elements in all LIS, to make room for upcoming grater elements than v[i]
//             // (and also, v[i] would have already appeared in one of LIS, identify the location and replace it)
//             let ix = CeilIndex(&tail, -1, length as i32 - 1, v[i]);
//             tail[ix] = v[i];
//         }
//     }

//     length
// }

//-----

pub mod io {
    use std;

    pub struct Scanner<'a> {
        iter: std::str::SplitWhitespace<'a>,
    }

    impl<'a> Scanner<'a> {
        pub fn new(s: &'a str) -> Scanner<'a> {
            Scanner {
                iter: s.split_whitespace(),
            }
        }

        pub fn next<T>(&mut self) -> T
        where
            T: std::str::FromStr,
            <T as std::str::FromStr>::Err: std::fmt::Debug,
        {
            let s = self.iter.next().unwrap();
            s.parse::<T>().unwrap()
        }
    }

    pub fn read_string() -> String {
        use std::io::Read;

        let mut s = String::new();
        std::io::stdin().read_to_string(&mut s).unwrap();
        s
    }

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