Problem:
Score : 500 points

Problem Statement

You are given a sequence with N integers: A = \{ A_1, A_2, \cdots, A_N \}.
For each of these N integers, we will choose a color and paint the integer with that color. Here the following condition must be satisfied:

If A_i and A_j (i < j) are painted with the same color, A_i < A_j.

Find the minimum number of colors required to satisfy the condition.

Constraints

1 \leq N \leq 10^5

0 \leq A_i \leq 10^9

Input

Input is given from Standard Input in the following format:

N
A_1
:
A_N

Output

Print the minimum number of colors required to satisfy the condition.

Sample Input 1

5
2
1
4
5
3

Sample Output 1

2

We can satisfy the condition with two colors by, for example, painting 2 and 3 red and painting 1, 4, and 5 blue.

Sample Input 2

4
0
0
0
0

Sample Output 2

4

We have to paint all the integers with distinct colors.

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

pub fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

pub fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

pub fn read_vec2<T: std::str::FromStr>(n: usize) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}

pub fn read_col<T: std::str::FromStr>(n: usize) -> Vec<T> {
    (0..n).map(|_| read()).collect()
}

struct BBag {
    v: Vec<i32>,
}

impl BBag {
    fn new() -> BBag {
        BBag {
            v: vec![-1, 1000000001],
        }
    }

    fn push_back(&mut self, a: i32) {
        self.v.pop();
        self.v.push(a);
        self.v.push(1000000001);
    }

    fn min_gt_id(&self, a: i32, l: usize, r: usize) -> Option<usize> {
        if l + 1 == r {
            if r == self.v.len() - 1 {
                None
            } else {
                Some(r)
            }
        } else {
            let m = (l + r) / 2;
            if self.v[m] <= a {
                self.min_gt_id(a, m, r)
            } else {
                self.min_gt_id(a, l, m)
            }
        }
    }

    fn insert(&mut self, a: i32) {
        match self.min_gt_id(a, 0, self.v.len() - 1) {
            None => {
                self.push_back(a);
            }
            Some(i) => {
                self.v[i] = a;
            }
        }
    }

    fn mlen(&self) -> usize {
        self.v.len() - 2
    }
}

fn main() {
    let n: usize = read();
    let a: Vec<i32> = read_col(n);
    let mut bag = BBag::new();

    for i in (0..n).rev() {
        bag.insert(a[i]);
    }

    println!("{:?}", bag.mlen());
}