macro_rules! parse_list {
  ($t: ty) => ({
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).unwrap();
    let list: Vec<$t> = line.split_whitespace()
                            .map(|w| w.parse::<$t>().unwrap()).collect();
    list
  })
}

macro_rules! parse_line {
  ($($t: ty),+) => ({
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).unwrap();
    let mut iter = line.split_whitespace();
    ($(iter.next().unwrap().parse::<$t>().unwrap()),+)
  })
}


fn binary_search(min_end: &Vec<u32>, n: u32) -> Option<usize>{
    if min_end.len() == 0 {
        return None;
    }

    let (mut l, mut r) : (usize, usize) = (0, min_end.len() - 1);
    while l + 1 < r{
        let mid = (l + r) / 2;
        if n <= min_end[mid]{
            r = mid;
        }
        else{
            l = mid;
        }
    }
    if n <= min_end[l]{
        return Some(l);
    }
    else if n <= min_end[r]{
        return Some(r);
    }
    return None;
}

fn main(){
    let _n = parse_line!(usize);
    let seq = parse_list!(u32);

    let mut min_end : Vec<u32> = Vec::new();
    for &x in seq.iter(){
        match binary_search(&min_end, x){
            Some(i) => {min_end[i] = x;},
            None => {min_end.push(x);},
        }
    }
    println!("{}", min_end.len());
}