#include <bits/stdc++.h>

using namespace std;

const int MAX_N = 100000 + 1;
const double PI = 3.14159265359;

struct Cylinder
{
    int r;
    int id;

    long long key() const
    {
        return 1LL * r;
    }

    bool operator < (const Cylinder &rhs) const
    {
        if (this->key() != rhs.key())
            return this->key() < rhs.key();
        else
            return this->id > rhs.id;
    }
};

Cylinder A[MAX_N];
long long dp[MAX_N];
long long tree[4 * MAX_N];
int N;

void update(int node, int l, int r, const int pos, const long long key)
{
    if (l == r)
        tree[node] = key;
    else
    {
        int m = (l + r) / 2;

        if (pos <= m)
            update(2 * node, l, m, pos, key);
        else
            update(2 * node + 1, m + 1, r, pos, key);

        tree[node] = max(tree[2 * node], tree[2 * node + 1]);
    }
}

long long query(int node, int l, int r, const int st, const int dr)
{
    if (st > dr)
        return 0;

    if (st <= l && r <= dr)
        return tree[node];
    else
    {
        int m = (l + r) / 2;
        long long ans = 0;

        if (st < m)
            ans = max(ans, query(2 * node, l, m, st, dr));

        if (m < dr)
            ans = max(ans, query(2 * node + 1, m + 1, r, st, dr));

        return ans;
    }
}

int main()
{
    ifstream in("scmax.in");
    ofstream out("scmax.out");

    ios_base::sync_with_stdio(false);

    in >> N;

    for (int i = 1; i <= N; ++i)
    {
        in >> A[i].r;
        A[i].id = i;
    }

    sort(A + 1, A + N + 1);

    for (int i = 1; i <= N; ++i)
    {
        dp[ A[i].id ] = query(1, 1, N, 1, A[i].id) + 1;
        update(1, 1, N, A[i].id, dp[ A[i].id ]);
    }

    //cout << fixed << setprecision(10);
    out << *max_element(dp + 1, dp + N + 1) << "\n";

    return 0;
}