/*转载大牛的程序：
   先放着-_-
nlogn的最大上升子序列长度算法
　　传统的最大上升子序列采用n2的动态规划算法，就求解一个最大上升子序列的具体序列来说，
暂时找不到更快的算法，但是如果只需要求解这个序列的长度，则存在一个更快的算法，复杂度是nlog2n。

 

　　对于一个序列a[0]...a[n]，设F[i]表示到第i个数为止的最大上升子序列，我们考虑如这种情况，存
在0<=y<x<i=n，若满足

(1) y<x<i;

(2) a[x]<a[y]<a[i]; 

(3) |F[x]| == |F[y]|;

 (4) a[j] < a[x], y < j < x

　　则此时F[i]应该由F[x]扩展而来，因为可能存在z满足

(1) y<x<z<i; 

(2) a[x]<a[z]<a[y]<a[i]

(3) z < min{j | a[j]>a[y], j > x}

　　则此时用F[x]扩展得到F[i]将长于F[y]扩展得到的子序列。 由此可得出结论，原序列第i个元素之前最长
子序列的解可能存在很多，但我们只需要尽可能使得那个最长子序列的最后一个元素的值最小，就能向后扩展得
到原串最长子序列。

　　求解的过程依然是一个动态规划的过程，我们采用一个数组d[k]，来描述到状态i时长度为k的子序列最后一
个元素的最小值。从状态i-1转移到状态i时，a[i]的加入影响到数组中的d[k]，k满足

k = max{a[i]>d[j]} + 1

此时有

d[k] = min{d[k], a[i]}

　　由此我们会发现数组d一个明显的特征，即d是一个单调上升的序列，利用这个特性，我们可以采用二分法来
查找k的值，这样使得整体的时间复杂度从原来的n2变为nlog2n，但是在设计过程中应该要注意到数组d的首元素
和尾元素的处理。最后，我们所需要的值就是在末状态时d数组的最大下标值，这里值得注意的是数组d的下表的
最大值应该是在变化的——反观定义则可明显地得到这个特性。

　　一下是一段源代码，测试过一个小数据，设计中发现整个算法的难点在于二分法查找的设计。
*/

#include  < cstdio >
#include  < cstdlib >
#include  < climits >
#include  < iostream >
using namespace std;
#define MAX  1000
int  a[MAX];
 int  d[MAX];
 int  max_subsequence ( const   int  size )
{
     int  n;
    d[ n  =   0  ]  =  a[  0  ];
     for  (  int  i  =   1 ; i  <  size; i ++  )
         if  ( d[ n ]  <  a[ i ] )
            d[  ++ n ]  =  a[ i ];
         else   if  ( d[  0  ]  >  a[ i ] )
            d[  0  ]  =  a[ i ];
         else
        {
             int   left   =   0 ,  right   =  n,  mid   =  n  /   2 , key  =  a[ i ];
             while  (  left   <   right  ){
                 if  ( d[  mid  ]  ==  key )
                {
                     mid -- ;
                    break;
                }
                 if  ( d[  mid  ]  >  key )
                {
                     right   =   mid ;
                     mid   =  (  left   +   right  )  /   2 ;
                }
                 else   if  (  mid   >   left  )
                {
                     left   =   mid ;
                     mid   =  (  left   +   right  )  /   2 ;
                }
                 else
                    break;
            }
             if  ( d[  mid   +   1  ]  >  key )
                d[  mid   +   1  ]  =  key;
        
        }
    return n  +   1 ;
}

 int  main ( )
{
     int  n;
    scanf (  " %d " ,  & n );
     for  (  int  i  =   0 ; i  <  n; i ++  )
        scanf (  " %d " ,  & a[ i ] );
    printf (  " %d\n " , max_subsequence ( n ) );
   //   system (  " pause "  );
 return  0 ;
}