Problem:
Longest Increasing Subsequence

For a given sequence A = {a0, a1, ... , an-1}, find the length of the longest increasing subsequnece (LIS) in A.

An increasing subsequence of A is defined by a subsequence {ai0, ai1, ... , aik} where 0 ≤ i0 < i1 < ... < ik < n and ai0 < ai1 < ... < aik.

Input

n
a0
a1
:
an-1

In the first line, an integer n is given. In the next n lines, elements of A are given.

Output

The length of the longest increasing subsequence of A.

Constraints

1 ≤ n ≤ 100000

0 ≤ ai ≤ 109

Sample Input 1

5
5
1
3
2
4

Sample Output 1

3

Sample Input 2

3
1
1
1

Sample Output 2

1

Solution in Scala (judge verdict: Accepted)

import java.util.Scanner

object Main extends App { 
  val sc = new Scanner(System.in)
  val N = sc.nextInt()
  val seq = (for (i <- 1 to N) yield sc.nextInt).toList

  class DP(n:Int, seq:List[Int]) {
    val Inf = Int.MaxValue >> 1
    val memo = Array.fill(n)(Inf)

    def find(x:Int):Int = {
      def iter(l:Int,r:Int):Int = {
        if (l+1==r || l==r) l
        else {
          val i = (l + r) >> 1
          (x - memo(i)) match {
            case d if d  < 0 => iter(l, i)
            case d if d == 0 => i
            case d if d  > 0 => iter(i, r)
          }
        }
      }
      iter(0, n-1)
    }

    def solver():Int = {
      for (e <- seq) {
        val i = find(e)
        if (memo(i) < e) memo(i+1) = e else memo(i) = e
      }
      memo.filter(_!=Inf).length
    }
  }

  val dp = new DP(N, seq)

  println(dp.solver())
}