solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
map<int, int> M;
int n, ans = 0;
scanf("%d", &n);
M[0] = 0;
for (i = 1; i <= n; ++i) {
scanf("%d", &j);
map<int, int>::iterator it = M.lower_bound(j);
k = (--it)->second + 1;
for (++it; it != M.end();) {
if (it->second <= k)
M.erase(it++);
else
break;
}
M[j] = k;
ans = max(ans, k);
}
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, i, x, b[110000];
void modify(int x, int y) {
for (; x <= n; x += x & -x) b[x] = ((b[x]) > (y) ? (b[x]) : (y));
}
int get(int x) {
int ans = 0;
for (; x; x -= x & -x) ans = ((ans) > (b[x]) ? (ans) : (b[x]));
return ans;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &x);
modify(x, get(x) + 1);
}
printf("%d\n", get(n));
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline string tostr(const T &x) {
stringstream ss;
ss << x;
return ss.str();
}
const double EPS = 1e-6;
const int INF = 1000 * 1000 * 1000;
const char CINF = 102;
const long long LINF = INF * 1ll * INF;
const long double PI = 3.1415926535897932384626433832795;
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
unsigned int gcd(unsigned int a, unsigned int b) {
return a ? gcd(b % a, a) : b;
}
int P[110000];
int D[110000];
int n;
int main(int argc, char **argv) {
cin >> n;
for (int i = 0; i < (n); ++i) {
cin >> P[i];
D[i + 1] = INF;
}
D[n + 1] = INF;
D[0] = -INF;
for (int i = 0; i < (n); ++i) {
*lower_bound(D, D + n, P[i]) = P[i];
}
int r = 0;
while (D[r] != INF) ++r;
--r;
cout << r;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int increasingSubsequece2(int a[], int n) {
vector<int> temp;
vector<int>::iterator v;
temp.push_back(a[0]);
for (int i = 1; i < n; ++i) {
if (a[i] > temp.back())
temp.push_back(a[i]);
else {
v = upper_bound(temp.begin(), temp.end(), a[i]);
*v = a[i];
}
}
return temp.size();
}
int bit[1000005] = {0};
void update(int i, int val) {
while (i < 1000005) {
bit[i] = max(bit[i], val);
i += (i & (-i));
}
}
int query(int i) {
int ans = 0;
while (i > 0) {
ans = max(ans, bit[i]);
i -= (i & -i);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cout << increasingSubsequece2(a, n) << '\n';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int n, w[100001], i, a, B, E, M, SZ;
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a);
if (!i) {
w[++SZ] = a;
continue;
}
if (w[SZ] < a) {
w[++SZ] = a;
continue;
}
B = 1, E = SZ;
while (B <= E) {
M = (B + E + 1) >> 1;
if (w[M] > a && a > w[M - 1]) {
break;
}
if (w[M] < a)
B = M + 1;
else
E = M - 1;
}
w[M] = a;
}
printf("%d\n", SZ);
}
| 8 | CPP |
#include <bits/stdc++.h>
int vt[100005], it[100005];
int n;
void update(int pos, int val) {
int u = pos;
while (u <= n) {
if (it[u] < val) it[u] = val;
u = u + (u & (-u));
}
}
int query(int pos) {
int u = pos;
int res = 0;
while (u >= 1) {
if (it[u] > res) res = it[u];
u = u - (u & (-u));
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int tmp;
scanf("%d", &tmp);
vt[tmp] = i;
}
for (int i = 1; i <= n; i++) it[i] = 0;
for (int i = 1; i <= n; i++) {
int tmp = query(vt[i]);
update(vt[i], tmp + 1);
}
printf("%d", query(n));
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 131334;
int d[MAXN + 1];
const int INF = 1e9;
int main() {
int n;
scanf("%d", &n);
vector<int> a(n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
d[0] = -INF;
for (int i = 1; i <= n; ++i) d[i] = INF;
for (int i = 0; i < n; i++) {
int j = int(upper_bound(d, d + n, a[i]) - d);
if (d[j - 1] < a[i] && a[i] < d[j]) d[j] = a[i];
}
int ans = 0;
for (int i = 0; i < n + 1; ++i)
if (d[i] != INF) ans = i;
cout << ans;
puts("");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[100001], f[100001];
int calc(int now) {
int will = 0;
for (; now; now -= now & (-now)) will = max(will, f[now]);
return (will);
}
inline void insert(int x, int y) {
for (int now = x; now <= n; now += now & (-now)) f[now] = max(f[now], y);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int ans = 0;
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; i++) {
int now = calc(a[i] - 1) + 1;
ans = max(now, ans);
insert(a[i], now);
}
printf("%d\n", ans);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, arr[500000], fen[500000];
void update(int index, int val) {
while (index <= n) {
fen[index] = max(fen[index], val);
index += index & -index;
}
}
int query(int index) {
int sum = 0;
while (index > 0) {
sum = max(fen[index], sum);
index -= index & -index;
}
return sum;
}
int main() {
int i, ans = 0;
cin >> n;
for (i = 0; i < n; i++) cin >> arr[i];
for (i = 0; i < n; i++) {
update(arr[i], query(arr[i]) + 1);
}
cout << query(n);
}
| 8 | CPP |
#include <bits/stdc++.h>
const int MAXN = 100000;
int a[MAXN + 1];
int que[MAXN + 1], len;
int main() {
int n;
int i;
int high, low, median;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
len = 1;
for (i = 1; i <= n; ++i) {
high = len;
low = 0;
while (high - low > 1) {
median = (high + low) >> 1;
if (que[median] > a[i])
high = median;
else
low = median;
}
if (low + 1 == len)
que[len++] = a[i];
else if (que[low + 1] > a[i])
que[low + 1] = a[i];
}
printf("%d", len - 1);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int inp[100003], m[100003];
int main() {
int n, i, l, lo, hi, mid;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &inp[i]);
l = 0;
for (i = 0; i < n; i++) {
lo = 0;
hi = l;
while (lo < hi) {
mid = (lo + hi + 1) / 2;
if (m[mid] < inp[i])
lo = mid;
else
hi = mid - 1;
}
if (lo == l) {
l = lo + 1;
m[l] = inp[i];
} else if (inp[i] < m[lo + 1])
m[lo + 1] = inp[i];
}
printf("%d\n", l);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline void sfr(int *a) {
char c = 0;
while (c < 33) c = fgetc(stdin);
*a = 0;
while (c > 33) {
*a = *a * 10 + c - '0';
c = fgetc(stdin);
}
}
inline void sfp(int a) {
char c[1000];
sprintf(c, "%d", a);
puts(c);
}
int A[100010];
int L[100010];
int main() {
int n;
cin >> n;
;
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
int m = 0;
for (int i = 0; i < n; i++) {
int j = lower_bound(L, L + m, A[i]) - L;
L[j] = A[i];
if (j == m) m += 1;
}
sfp(m);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, top, temp;
int stack[100001];
cin >> n;
top = 0;
stack[0] = -1;
for (i = 0; i < n; i++) {
cin >> temp;
if (temp > stack[top]) {
stack[++top] = temp;
} else {
int low = 1, high = top;
int mid;
while (low <= high) {
mid = (low + high) / 2;
if (temp > stack[mid]) {
low = mid + 1;
} else {
high = mid - 1;
}
}
stack[low] = temp;
}
}
cout << top << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod7 = 1000000007;
const long long mod9 = 1000000009;
const int linf = 2000000000;
const long long llinf = 1000000000000000000ll;
ifstream in("series.in");
ofstream out("series.out");
int tr[400004];
int arr[100001];
int ans[100001];
int x, key;
void Set(int v, int L, int R) {
if (L == R)
tr[v] = key;
else {
int m = (L + R) / 2;
if (m >= x)
Set(v * 2, L, m);
else
Set(v * 2 + 1, m + 1, R);
tr[v] = max(tr[v * 2], tr[v * 2 + 1]);
}
}
int get(int v, int l, int r, int L, int R) {
if (l > r) return 0;
if (L == l && R == r) return tr[v];
int m = (L + R) >> 1;
return max(get(v * 2, l, min(m, r), L, m),
get(v * 2 + 1, max(l, m + 1), r, m + 1, R));
}
int main() {
int n, answer = 1;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> arr[i];
for (int i = 1; i <= n; ++i) {
x = arr[i];
ans[i] = get(1, 1, x - 1, 1, n) + 1;
key = ans[i];
Set(1, 1, n);
answer = max(ans[i], answer);
}
cout << answer;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100514], top;
void truli() {
scanf("%d", &n);
int x;
top = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (a[top - 1] < x) {
a[top++] = x;
continue;
}
int t = -1;
for (int bt = 20; bt >= 0; bt--) {
if (t + (1 << bt) < top && a[t + (1 << bt)] < x) t += (1 << bt);
}
a[t + 1] = x;
}
printf("%d\n", top);
}
int main() {
truli();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void online_judge() {}
long long a[2000001];
void go() {
long long n;
cin >> n;
long long a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
vector<long long> v;
for (int i = 0; i < n; ++i) {
long long lb = lower_bound(v.begin(), v.end(), a[i]) - v.begin();
if (lb == v.size()) {
v.push_back(a[i]);
} else {
v[lb] = a[i];
}
}
cout << v.size();
}
int main() {
cin.tie(0), ios_base ::sync_with_stdio(0);
online_judge();
go();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int vt[111111];
int a[111111];
int maxlen;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
vt[0] = 0;
maxlen = 0;
for (int i = 1; i <= n; i++) {
if (vt[maxlen] < a[i]) {
maxlen++;
vt[maxlen] = a[i];
continue;
}
int l, r, mid;
l = 0;
r = maxlen;
while (l < r) {
mid = (l + r) / 2;
if (vt[mid] < a[i])
l = mid + 1;
else
r = mid;
}
if (vt[l] > a[i]) vt[l] = a[i];
}
cout << maxlen;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T b, T p, T M) {
long long int ret = 1;
for (; p > 0; p >>= 1) {
if (p & 1) ret = (ret * b) % M;
b = (b * b) % M;
}
return (T)ret;
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
return a * b / gcd<T>(a, b);
}
template <class T>
inline T power(T b, T p) {
long long int x = 1;
while (p--) x *= b;
return x;
}
const long long int mod = 1e9 + 7;
const int siz = 202;
const long long int lim = 1e16;
int arr[100010];
int longestIncreasingSubsequence(int len) {
vector<int> V;
for (int i = 1; i <= len; i++) {
int pos = upper_bound(V.begin(), V.end(), arr[i]) - V.begin();
if (pos < V.size())
V[pos] = arr[i];
else
V.push_back(arr[i]);
}
return V.size();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> arr[i];
cout << longestIncreasingSubsequence(n) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
class xdt {
public:
int T[100005];
int lowbit(int i) { return i & -i; }
void update(int p, int v) {
for (; p < 100005; p += lowbit(p))
if (T[p] >= v)
return;
else
T[p] = v;
}
int max(int R) {
int ans = 0;
for (; R > 0; R -= lowbit(R))
if (ans < T[R]) ans = T[R];
return ans;
}
} T;
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
T.update(a, T.max(a) + 1);
}
cout << T.max(100004) << endl;
return 0;
}
| 8 | CPP |
from bisect import bisect_left, bisect_right, insort
R = lambda: map(int, input().split())
n, arr = int(input()), list(R())
dp = []
for i in range(n):
idx = bisect_left(dp, arr[i])
if idx >= len(dp):
dp.append(arr[i])
else:
dp[idx] = arr[i]
print(len(dp)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int func(int *a, int n) {
vector<int> temp(n + 1, 1000000000);
for (int i = 0; i < n; i++)
*lower_bound(temp.begin(), temp.end(), a[i]) = a[i];
for (int i = 0; i <= n; i++)
if (temp[i] == 1000000000) return i;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
cout << func(a, n) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int i, j, k, l, m, n, a[1000000];
int main() {
int top;
scanf("%d", &n);
a[0] = -1;
top = 0;
for (i = 0; i < n; i++) {
scanf("%d", &m);
if (m > a[top])
a[++top] = m;
else {
int high = top, low = 1, mid;
while (low <= high) {
mid = (high + low) / 2;
if (m > a[mid]) {
low = mid + 1;
} else {
high = mid - 1;
}
}
a[low] = m;
}
}
printf("%d\n", top);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
void PLAY() {
cout << fixed << setprecision(10);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int n;
int arr[100005];
int idx(vector<int> &a, int l, int r, int val) {
while (r - l > 1) {
int mid = l + (r - l) / 2;
if (a[mid] >= val)
r = mid;
else
l = mid;
}
return r;
}
int LIS() {
vector<int> v(n, 0);
int ret = 1;
v[0] = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] < v[0])
v[0] = arr[i];
else if (arr[i] > v[ret - 1])
v[ret++] = arr[i];
else
v[idx(v, -1, ret - 1, arr[i])] = arr[i];
}
return ret;
}
int main() {
PLAY();
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
cout << LIS() << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int ft[100005];
int N;
inline int II() {
int n;
scanf("%d", &n);
return n;
}
void update(int k, int delta) {
for (++k; k <= N; k += (k & (-k))) ft[k] = max(ft[k], delta);
}
int sum(int k) {
int ans = 0;
for (++k; k != 0; k -= (k & (-k))) ans = max(ans, ft[k]);
return ans;
}
int sum(int a, int b) { return sum(b) - sum(a - 1); }
int main() {
N = II();
int ans = 0;
for (int i = 0; i < N; i++) {
int u = II();
int val = 0;
for (int b = u; b; b -= (b & (-b))) val = max(val, ft[b]);
val++;
ans = max(ans, val);
for (int b = u; b <= N; b += (b & (-b))) ft[b] = max(ft[b], val);
}
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int n, arr[200005], dp[200005];
int b_search(int h, int l, int b) {
int mid;
while (l < h) {
mid = (l + h) / 2;
if (b > dp[mid]) {
l = mid + 1;
} else
h = mid;
}
return h;
}
int LIS(int x) {
int len = 1;
dp[0] = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] < dp[0]) {
dp[0] = arr[i];
} else if (arr[i] > dp[len - 1]) {
dp[len++] = arr[i];
} else {
int p = b_search(len - 1, 0, arr[i]);
dp[p] = arr[i];
}
}
return len;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
int ans = LIS(n);
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct segTree {
int n;
vector<int> t;
segTree(int n) : n(n), t(2 * n, 0) {}
void upd(int v, int x) {
t[v += n] = x;
for (v >>= 1; v; v >>= 1) t[v] = max(t[v * 2], t[v * 2 + 1]);
}
int get(int l, int r) {
int ret = 0;
for (l += n, r += n; l <= r; l = (l + 1) >> 1, r = (r - 1) >> 1) {
if (l & 1) ret = max(ret, t[l]);
if (!(r & 1)) ret = max(ret, t[r]);
}
return ret;
}
};
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i], a[i]--;
segTree t(n);
vector<int> dp(n);
for (int i = 0; i < n; i++) {
dp[i] = 1 + t.get(0, a[i]);
t.upd(a[i], dp[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) ans = max(ans, dp[i]);
cout << ans;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Warstwa {
Warstwa() {}
Warstwa(int a) : v(1, a) {}
vector<int> v;
bool operator<(const Warstwa& dane) const {
return v[int((v).size()) - 1] < dane.v[int((dane.v).size()) - 1];
}
};
void zrob_test() {
vector<Warstwa> t;
int n;
cin >> n;
while (n--) {
int a;
cin >> a;
__typeof(t.begin()) w = (t.begin());
w = upper_bound(t.begin(), t.end(), Warstwa(a - 1));
if (w == t.end())
t.push_back(Warstwa(a));
else
w->v.push_back(a);
}
cout << int((t).size()) << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
zrob_test();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100010], b[100010];
int binary(int i, int k) {
if (a[i] < b[1]) return 1;
int h, j;
for (h = 1, j = k; h != j - 1;) {
if (b[k = (h + j) / 2] < a[i])
h = k;
else
j = k;
}
return j;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
b[1] = a[1];
int cnt = 1;
for (int i = 2; i <= n; i++) {
if (a[i] > b[cnt])
b[++cnt] = a[i];
else
b[binary(i, cnt)] = a[i];
}
printf("%d\n", cnt);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 29;
const double dinf = 1e30;
const long long linf = 1LL << 55;
const int N = 111111;
int rec[N];
int a[N], n;
int bs(int pos, int x) {
int l = 0, r = pos;
int res;
while (l <= r) {
int mid = (l + r) >> 1;
if (a[rec[mid]] < x)
res = mid, l = mid + 1;
else
r = mid - 1;
}
return res;
}
int main() {
while (cin >> n) {
for (int i = 1; i <= n; i++) cin >> a[i];
rec[0] = 0;
int ans = 0;
for (int i = 1; i <= n; i++) {
int res = bs(ans, a[i]);
if (res == ans) ans++;
rec[res + 1] = i;
}
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1000 * 100 + 10;
int n;
int d[Maxn];
int num[Maxn];
int L = 1;
void input() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> num[i];
}
int find_ind(int begin, int end, int j) {
if (end == begin + 1) {
return begin;
}
int mid = (begin + end) / 2;
if (num[d[mid]] < num[j]) {
return find_ind(mid, end, j);
} else
return find_ind(begin, mid, j);
}
int main() {
input();
d[1] = 1;
int x;
for (int i = 2; i <= n; i++) {
x = find_ind(0, L + 1, i);
if (d[x + 1] != 0 && num[d[x + 1]] > num[i]) d[x + 1] = i;
if (x == L) {
L++;
d[L] = i;
}
}
cout << L << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, x;
vector<int> v;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
int a = lower_bound(v.begin(), v.end(), x) - v.begin();
if (a == v.size())
v.push_back(x);
else
v[a] = x;
}
printf("%d\n", v.size());
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 100 + 10, mod = 100000007;
int a[N];
int n;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> ans;
for (int i = 0; i < n; i++) {
int val = a[i];
int pos = lower_bound(ans.begin(), ans.end(), val) - ans.begin();
if (pos < int(ans.size()))
ans[pos] = val;
else
ans.push_back(val);
}
cout << int(ans.size()) << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005, INF = 1e9;
int dp[MAXN], a[MAXN];
void solve() {
int n, i;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i <= n; i++) {
dp[i] = INF;
}
dp[0] = 0;
for (i = 0; i < n; i++) {
int offset = upper_bound(dp, dp + n, a[i]) - dp;
dp[offset] = a[i];
}
int ans = 0;
for (i = 1; i <= n; i++) {
if (dp[i] < INF) {
ans = i;
}
}
printf("%d", ans);
}
int main() {
int t;
t = 1;
while (t) {
t--;
solve();
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[110000];
int sol[110000], pos;
int solve(int n) {
int bs = 0, i;
pos = 0;
sol[0] = -1;
for (i = 0; i < n; i++) {
if (a[i] > sol[pos]) {
pos++;
sol[pos] = a[i];
if (pos > bs) bs = pos;
continue;
}
int npos = lower_bound(sol, sol + pos, a[i]) - sol;
sol[npos] = a[i];
}
return bs;
}
int main() {
int n, i;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
printf("%d\n", solve(n));
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long inf = LLONG_MAX;
long double pi = 3.1415926536;
int ans(std::vector<int>& v) {
if (v.size() == 0) return 0;
std::vector<int> tail(v.size(), 0);
int length = 1;
tail[0] = v[0];
for (int i = 1; i < v.size(); i++) {
auto b = tail.begin(), e = tail.begin() + length;
auto it = lower_bound(b, e, v[i]);
if (it == tail.begin() + length)
tail[length++] = v[i];
else
*it = v[i];
}
return length;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int tt = 1;
while (tt--) {
long long n, x = 0, m = 0, y = 0, k = inf;
cin >> n;
vector<int> v(n, 0);
for (long long i = 0; i < n; i++) {
cin >> x;
v[i] = x;
}
cout << ans(v) << '\n';
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy[] = {0, -1, 0, 1, -1, 1, 1, -1};
template <class T>
inline bool get(T& n) {
char c, mul = 1;
n = 0;
while (!isdigit(c = getchar_unlocked()) && (c != EOF) && (c != '-'))
;
if (c == EOF) return false;
if (c == '-') {
c = getchar_unlocked();
mul = -1;
}
for (; isdigit(c); c = getchar_unlocked()) n = n * 10 + c - '0';
n *= mul;
return true;
}
inline void get(char& c) {
while (isspace(c = getchar_unlocked()))
;
}
int main() {
int n, x;
get(n);
set<int> s;
for (int(i) = 0, _ = (n); (i) < _; ++i) {
get(x);
pair<set<int>::iterator, bool> it = s.insert(x);
if (it.second) {
++it.first;
if (it.first != s.end()) s.erase(it.first);
}
}
printf("%d\n", s.size());
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void FastInputOutput() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
bool isPrime(long long n) {
for (long long i = 2; i * i <= n; ++i)
if (n % i == 0) return false;
return n > 1;
}
int lucky[] = {4, 7, 44, 47, 74, 77, 444, 447, 474, 477, 744, 747, 774, 777};
bool luckNumner(int n) {
for (int i = 0; i < 12; ++i) {
if (n % lucky[i] == 0) return true;
}
return false;
}
vector<pair<int, pair<int, int> > > pls;
int cov(int h, int m, int s) { return (h * 60 + m) * 60 + s; }
int cm[86399 + 4];
void gen() {
for (int i = 0; i < 24; ++i)
for (int j = 0; j < 60; ++j)
for (int k = 0; k < 60; ++k)
if (i / 10 == k % 10 && i % 10 == k / 10 && j % 10 == j / 10)
cm[cov(i, j, k)] = 1;
for (int i = 0; i < 86399 + 4; ++i) cm[i] += cm[i - 1];
}
const int N = 1e5 + 5;
int a[N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
vector<int> ls;
for (int i = 0; i < n; ++i) {
int idx = lower_bound(ls.begin(), ls.end(), a[i]) - ls.begin();
if (idx == ls.size())
ls.push_back(a[i]);
else
ls[idx] = min(ls[idx], a[i]);
}
cout << ls.size() << "\n";
}
| 8 | CPP |
import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
def CeilIndex(A, l, r, key):
while (r - l > 1):
m = l + (r - l)//2
if (A[m] >= key):
r = m
else:
l = m
return r
def lis(A, size):
tailTable = [0 for i in range(size + 1)]
len = 0 # always points empty slot
tailTable[0] = A[0]
len = 1
for i in range(1, size):
if (A[i] < tailTable[0]):
tailTable[0] = A[i]
elif (A[i] > tailTable[len-1]):
tailTable[len] = A[i]
len+= 1
else:
tailTable[CeilIndex(tailTable, -1, len-1, A[i])] = A[i]
return len
n,=I()
p=I()
an=1
print(lis(p,n))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
int Set(int N, int pos) { return N = N | (1 << pos); }
int reSet(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
using namespace std;
int n, k;
vector<int> A;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &k);
int id = lower_bound(A.begin(), A.end(), k) - A.begin();
if (id == A.size())
A.push_back(k);
else
A[id] = k;
}
printf("%d\n", A.size());
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(false);
int t = 1;
while (t--) solve();
return 0;
}
int INF = 1000000000;
int d[101010];
int a[101010];
void solve() {
int n;
cin >> n;
if (n == 1) {
cout << 1 << endl;
return;
}
for (int i = 0; i < n; ++i) cin >> a[i];
d[0] = -INF;
for (int i = 1; i <= n + 5; ++i) d[i] = INF;
for (int i = 0; i < n; i++) {
int j = int(upper_bound(d, d + n, a[i]) - d);
if (d[j - 1] < a[i] && a[i] < d[j]) d[j] = a[i];
}
int x = 0;
for (int i = 0;; ++i) {
if (d[i] == INF) {
cout << i - 1 << endl;
return;
}
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100020;
int m, n;
int a[maxN], s[maxN];
int find(int v) {
int inf = 1;
int sup = m;
int res = 1;
while (inf <= sup) {
int mid = (inf + sup) >> 1;
if (v >= s[mid]) {
res = mid;
inf = mid + 1;
} else
sup = mid - 1;
}
return res;
}
int main() {
ios ::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int j;
m = 1;
s[1] = a[1];
for (int i = 2; i <= n; i++) {
if (a[i] <= s[1])
s[1] = a[i];
else if (a[i] >= s[m]) {
s[++m] = a[i];
} else {
j = find(a[i]) + 1;
s[j] = a[i];
}
}
cout << m << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int n = 0;
int plc[100008];
int bit[100008];
void add(int x, int vl) {
int k = 1;
while (x <= n) {
if (x & k) {
if (bit[x] < vl) bit[x] = vl;
x += k;
}
k += k;
}
}
int calc(int x) {
int ret = 0;
int k = 1;
while (x) {
if (x & k) {
if (bit[x] > ret) ret = bit[x];
x -= k;
}
k += k;
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int as;
scanf("%d", &as);
plc[as] = i;
}
int sol = 0;
for (int i = 1; i <= n; i++) {
int ksol = calc(plc[i] - 1) + 1;
if (sol < ksol) sol = ksol;
add(plc[i], ksol);
}
printf("%d\n", sol);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100004], L[100004], I[100004];
int LIS(int a[], int n) {
I[0] = -2000000000;
for (int i = 1; i <= n; i++) I[i] = 2000000000;
int len = 0;
for (int i = 0; i < n; i++) {
int low, high, mid;
low = 0, high = len;
while (low <= high) {
mid = (low + high) / 2;
if (I[mid] < a[i])
low = mid + 1;
else
high = mid - 1;
}
I[low] = a[i];
if (len < low) len = low;
}
return len;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
cout << LIS(a, n) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, len, arr[100001], table[100001];
int hi, lo, mid, ans;
cin >> n;
for (i = 1; i <= n; i++) cin >> arr[i];
len = 1;
table[1] = arr[1];
for (i = 2; i <= n; i++) {
if (arr[i] < table[1])
table[1] = arr[i];
else if (arr[i] > table[len]) {
len++;
table[len] = arr[i];
} else {
lo = 1;
hi = len;
ans = -1;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (table[mid] < arr[i]) {
if (ans == -1 || ans < mid) ans = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
if (ans != -1) table[ans + 1] = arr[i];
}
}
cout << len << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int main() {
int n, m, i, as = 0;
scanf("%d", &n);
while (n--) {
scanf("%d", &i);
m = lower_bound(a.begin(), a.end(), i) - a.begin();
if (m == a.size())
a.push_back(i);
else
a[m] = i;
}
printf("%d\n", a.size());
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
const int inf = 1000000000;
int n, m = 1, i, x, l, r, h, a[100100];
int main() {
a[1] = inf;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &x);
l = 0;
r = m;
while (l < r) {
h = (l + r) / 2;
if (a[h] > x)
r = h;
else
l = h + 1;
}
a[r] = x;
if (r == m) a[++m] = inf;
}
printf("%d\n", m - 1);
return 0;
}
| 8 | CPP |
# Python program to find
# length of longest
# increasing subsequence
# in O(n Log n) time
# Binary search (note
# boundaries in the caller)
# A[] is ceilIndex
# in the caller
def CeilIndex(A, l, r, key):
while (r - l > 1):
m = l + (r - l)//2
if (A[m] >= key):
r = m
else:
l = m
return r
def Lis(A, size):
# Add boundary case,
# when array size is one
tailTable = [0 for i in range(size + 1)]
len = 0 # always points empty slot
tailTable[0] = A[0]
len = 1
for i in range(1, size):
if (A[i] < tailTable[0]):
# new smallest value
tailTable[0] = A[i]
elif (A[i] > tailTable[len-1]):
# A[i] wants to extend
# largest subsequence
tailTable[len] = A[i]
len+= 1
else:
# A[i] wants to be current
# end candidate of an existing
# subsequence. It will replace
# ceil value in tailTable
tailTable[CeilIndex(tailTable, -1, len-1, A[i])] = A[i]
return len
# Driver program to
# test above function
a=int(input())
z=list(map(int,input().split()))
print(Lis(z,a))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 10;
int n, a[maxN], best[maxN], len;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int x = lower_bound(best, best + len, a[i]) - best;
best[x] = a[i];
if (x == len) len++;
}
cout << len;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long UNDEF = -1;
const long long INF = 1e18;
template <typename T>
inline bool chkmax(T& aa, T bb) {
return aa < bb ? aa = bb, true : false;
}
template <typename T>
inline bool chkmin(T& aa, T bb) {
return aa > bb ? aa = bb, true : false;
}
static char stdinBuffer[1024];
static char* stdinDataEnd = stdinBuffer + sizeof(stdinBuffer);
static const char* stdinPos = stdinDataEnd;
void readAhead(size_t amount) {
size_t remaining = stdinDataEnd - stdinPos;
if (remaining < amount) {
memmove(stdinBuffer, stdinPos, remaining);
size_t sz = fread(stdinBuffer + remaining, 1,
sizeof(stdinBuffer) - remaining, stdin);
stdinPos = stdinBuffer;
stdinDataEnd = stdinBuffer + remaining + sz;
if (stdinDataEnd != stdinBuffer + sizeof(stdinBuffer)) *stdinDataEnd = 0;
}
}
int rint() {
readAhead(16);
int x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
char rch() {
readAhead(16);
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
char ans = *stdinPos;
++stdinPos;
return ans;
}
long long rlong() {
readAhead(32);
long long x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
const int mn = 1e5 + 4;
int x[mn], p[mn], m[mn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n = rint();
for (int i = 0; i < n; i++) x[i] = rint();
int l = 0;
for (int i = 0; i <= n - 1; i++) {
int lo = 1;
int hi = l;
while (lo <= hi) {
int mid = (lo + hi + 1) >> 1;
if (x[m[mid]] < x[i])
lo = mid + 1;
else
hi = mid - 1;
}
int newl = lo;
p[i] = m[newl - 1];
m[newl] = i;
if (newl > l) l = newl;
}
printf("%d\n", l);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n;
int st[N], top;
int main() {
scanf("%d", &n);
st[top = 0] = 0;
for (int i = 0, x; i < n; ++i) {
scanf("%d", &x);
int l = 0, r = top, mid;
while (r > l) {
mid = l + r + 1 >> 1;
if (st[mid] < x)
l = mid;
else
r = mid - 1;
}
if (r == top) top++;
st[r + 1] = x;
}
printf("%d\n", top);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 17;
const int INF = (1 << 30);
const double PI = acos(-1.0);
const double EPS = (1e-6);
int n, a[MAXN], ans, d[MAXN];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
d[0] = -INF;
for (int i = 1; i <= n; ++i) d[i] = INF;
for (int i = 1; i <= n; i++) {
int j = int(upper_bound(d, d + n + 1, a[i]) - d);
if (d[j - 1] < a[i] && a[i] < d[j]) d[j] = a[i];
}
int ans = 1;
for (int i = 1; i <= n; i++)
if (d[i] != INF) ans = i;
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
const int MAXN = 100000;
int P[MAXN + 1];
int tree[MAXN + 1] = {0};
int max(int x) {
int ret = 0, i;
for (i = x; i; i -= (i & -i))
if (ret < tree[i]) ret = tree[i];
return ret;
}
void relax(int x, int val) {
int i;
for (i = x; i <= MAXN; i += (i & -i))
if (tree[i] < val) tree[i] = val;
}
int main() {
int n, i;
int val, ans;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", P + i);
ans = 0;
for (i = 1; i <= n; ++i) {
val = 1 + max(P[i] - 1);
if (ans < val) ans = val;
relax(P[i], val);
}
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, a[N], c[N];
inline void C(int w, int x) {
for (; w <= n; w += w & -w)
if (x > c[w]) c[w] = x;
}
inline int Q(int w) {
int ans = 0;
for (; w; w -= w & -w)
if (c[w] > ans) ans = c[w];
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
C(a[i], Q(a[i]) + 1);
}
printf("%d\n", Q(n));
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << endl; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << endl;
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
const int fx[] = {+1, -1, +0, +0};
const int fy[] = {+0, +0, +1, -1};
long long Set(long long &N, long long pos) { return N = N | (1ll << pos); }
long long Reset(long long &N, long long pos) { return N = N & ~(1ll << pos); }
bool check(long long N, long long pos) { return (bool)(N & (1ll << pos)); }
void INITIALIZE() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
inline long long add(long long a, long long b) {
return (a + b >= 1000000007) ? (a + b - 1000000007) : (a + b);
}
inline long long sub(long long a, long long b) {
return (a - b < 0) ? (a - b + 1000000007) : (a - b);
}
inline long long mul(long long a, long long b) {
return (a * 1ll * b) % 1000000007;
}
void Binary(long long x) {
for (int i = 31; i >= 0; i--) {
if ((1 << i) & x)
cerr << "1";
else
cerr << "0";
}
cerr << "\n";
}
long long ncr(long long n, long long r) {
long long ans = 1;
if (r > n - r) r = n - r;
for (long long i = 1; i <= r; i++) {
ans *= (n - i + 1), ans /= i;
}
return ans;
}
long long pow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % 1000000007;
b >>= 1;
a = (a * a) % 1000000007;
}
return res;
}
const long long mxn = 1e5 + 5;
vector<long long> bit(mxn);
long long n;
void update(long long pos, long long val) {
for (; pos <= n; pos += pos & -pos) bit[pos] = max(bit[pos], val);
}
long long query(long long pos) {
long long ans = 0;
for (; pos; pos -= pos & -pos) ans = max(ans, bit[pos]);
return ans;
}
void solve() {
cin >> n;
long long mx = 0;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
long long koita = query(x);
mx = max(mx, koita + 1);
update(x, koita + 1);
}
cout << mx << endl;
}
int main() {
INITIALIZE();
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int f[101000], dp[101000], a[101000];
int n;
int tot;
int find(int x) {
int l = 0, r = tot;
int ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (f[mid] <= x) {
ans = max(mid, ans);
l = mid + 1;
} else
r = mid - 1;
}
return ans;
}
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < (n); (i)++) scanf("%d", &a[i]);
memset(dp, 0, sizeof(dp));
tot = 0;
for (int i = 0; i < n; i++) {
int j = find(a[i]);
dp[i] = j + 1;
if (j + 1 > tot) {
tot++;
f[j + 1] = a[i];
} else
f[j + 1] = min(f[j + 1], a[i]);
}
int ans = 0;
for (int(i) = 0; (i) < (n); (i)++) ans = max(ans, dp[i]);
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
int n;
int Sequence[100010];
int L[100010];
int I[100010];
void takeInput() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &Sequence[i]);
}
int LisNlogK() {
int i;
I[0] = -inf;
for (i = 1; i <= n; i++) I[i] = inf;
int LisLength = 0;
for (i = 0; i < n; i++) {
int low, high, mid;
low = 0;
high = LisLength;
while (low <= high) {
mid = (low + high) / 2;
if (I[mid] < Sequence[i])
low = mid + 1;
else
high = mid - 1;
}
I[low] = Sequence[i];
if (LisLength < low) LisLength = low;
}
return LisLength;
}
int main() {
takeInput();
int result = LisNlogK();
cout << result << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[100010], lis[100010], m;
int main() {
scanf("%d", &n);
for (int i = 0; i < (n); i++) scanf("%d", a + i);
lis[m++] = 0;
for (int i = 0; i < (n); i++) {
if (a[i] > lis[m - 1])
lis[m++] = a[i];
else
*lower_bound(lis, lis + m, a[i]) = a[i];
}
printf("%d\n", m - 1);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, a[N], t[N], sol;
void upd(int i, int v) {
for (; i <= n; i += i & -i) t[i] = max(t[i], v);
}
int get(int i) {
int s = 0;
for (; i; i -= i & -i) s = max(s, t[i]);
return s;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
int x = get(a[i] - 1) + 1;
sol = max(sol, x);
upd(a[i], x);
}
printf("%d\n", sol);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1LL << 60;
long long int n, m, k, x, y, z;
int mod = 1e9 + 7;
long long int add(long long int a, long long int b) {
if (a + b >= mod) return a + b - mod;
return a + b;
}
long long int sub(long long int a, long long int b) {
if (a < b) return a - b + mod;
return a - b;
}
long long int mul(long long int a, long long int b) {
return 1LL * a * b % mod;
}
int power(int a, int b) {
if (b < 0) return 0;
int re = 1;
while (b) {
if (b & 1) {
re = mul(re, a);
}
a = mul(a, a);
b >>= 1;
}
return re;
}
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.second < b.second);
}
bool sortbyfi(
const pair<long long int, pair<long long int, long long int>> &a,
const pair<long long int, pair<long long int, long long int>> &b) {
return (a.first > b.first);
}
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
pq;
long long int bs(vector<long long int> v, long long int x) {
long long int hi = v.size() - 1, lo = 0;
while (hi >= lo) {
long long int mid = lo + (hi - lo) / 2;
if (v[mid] == x)
return 1;
else if (v[mid] < x)
lo = mid + 1;
else
hi = mid - 1;
}
return 0;
}
bool paired(char a, char b) {
if (a == '[' and b == ']') return true;
if (a == '{' and b == '}') return true;
if (a == '(' and b == ')') return true;
if (a == '<' and b == '>') return true;
return false;
}
bool cmp(pair<long long int, vector<long long int>> a,
pair<long long int, vector<long long int>> b) {
return a.first > b.first;
}
long long int dp[200005] = {0};
void update1(long long int idx, long long int val) {
while (idx <= 100000) {
dp[idx] = max(dp[idx], val);
idx += idx & -idx;
}
}
long long int pref1(long long int idx) {
long long int ans = 0;
while (idx > 0) {
ans = max(dp[idx], ans);
idx -= idx & -idx;
}
return ans;
}
long long int bit[200005] = {0};
void update(long long int idx, long long int val) {
while (idx <= 100000) {
bit[idx] += val;
idx += idx & -idx;
}
}
long long int pref(long long int idx) {
long long int ans = 0;
while (idx > 0) {
ans += bit[idx];
idx -= idx & -idx;
}
return ans;
}
long long int rsum(long long int l, long long int r) {
return pref(r) - pref(l - 1);
}
long long int nextPowerOf2(long long int n) {
long long int count = 0;
if (n && !(n & (n - 1))) return n;
while (n != 0) {
n >>= 1;
count += 1;
}
return 1 << count;
}
void Birdperson() {
cin >> n;
long long int a[n];
for (int i = 0; i < (n); ++i) cin >> a[i];
memset(dp, 0, sizeof(dp));
long long int ans = 0;
for (int i = 0; i < (n); ++i) {
long long int j = pref1(a[i]) + 1;
ans = max(ans, j);
update1(a[i], j);
}
cout << ans << "\n";
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
long long int cnt = 1;
while (cnt <= t) {
Birdperson();
cnt++;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
struct Fenwick {
int a[200000];
Fenwick() {
for (int i = 0; i < 200000; ++i) a[i] = 0;
}
void update(int i, int c) {
for (; i < 200000; i |= i + 1) {
a[i] = max(c, a[i]);
}
}
int query(int i) {
int ret = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) ret = max(ret, a[i]);
return ret;
}
} fenwick;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
fenwick.update(a[i], fenwick.query(a[i]) + 1);
}
printf("%d", fenwick.query(n));
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int INF = 1e6;
long long int n, m;
long long int CeilIndex(std::vector<long long int>& vector, long long int l,
long long int r, long long int key) {
while (r - l > 1) {
long long int m = l + (r - l) / 2;
if (vector[m] >= key)
r = m;
else
l = m;
}
return r;
}
long long int LongestIncreasingSubsequenceLength(
std::vector<long long int>& vector) {
if (vector.size() == 0) return 0;
std::vector<long long int> tail(vector.size(), 0);
long long int length = 1;
tail[0] = vector[0];
for (size_t i = 1; i < vector.size(); i++) {
if (vector[i] < tail[0])
tail[0] = vector[i];
else if (vector[i] > tail[length - 1])
tail[length++] = vector[i];
else
tail[CeilIndex(tail, -1, length - 1, vector[i])] = vector[i];
}
return length;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int i, j, k, x, y, z, N;
cin >> n;
vector<long long int> a(n);
for (i = 0; i < n; i++) cin >> a[i];
cout << LongestIncreasingSubsequenceLength(a);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
const long long linf = 1LL << 62;
const unsigned long long ulinf = 1ULL << 63;
const double eps = 0.000001;
const double pi = 3.14159265358979323846;
template <class T>
T abs(T a) {
return a >= 0 ? a : -a;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T mod(T a, T b) {
return (a % b + b) % b;
}
long long powmod(long long a, long long b, long long c) {
if (b == 0) return 1;
long long ret = powmod(a, b >> 1, c);
ret = ret * ret % c;
if (b & 1) ret = ret * a % c;
return ret;
}
template <class T>
void maxe(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void mine(T &a, T b) {
if (a > b) a = b;
}
int iszero(double a) { return abs(a) <= eps; }
template <class T>
void geti(T &a) {
a = 0;
T b = 1;
char c = getchar();
if (c == '-')
b = -1;
else
a = c - 48;
while ((c = getchar()) != ' ' && c != '\n') a = a * 10 + c - 48;
a *= b;
}
void fileio_in_out() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
void fileio_txt() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
const int N = 111111;
const int M = 18;
int test;
int n, m, k, ans;
int a[N], b[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i] = inf;
}
b[0] = -inf;
for (int i = 1; i <= n; i++) {
int l = 0, r = i, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (a[i] > b[mid])
l = mid;
else
r = mid - 1;
}
if (a[i] < b[l + 1]) {
b[l + 1] = a[i];
maxe(ans, l + 1);
}
}
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, m, n;
cin >> n;
vector<int> d(n);
vector<int> g(n);
for (i = 0; i < n; ++i) {
cin >> d[i];
}
g[0] = d[0];
int l, r, len = 1;
for (i = 1; i < n; ++i) {
l = 0;
r = len;
while (l < r) {
int m = l + (r - l) / 2;
if (d[i] < g[m])
r = m;
else if (d[i] == g[m])
l = m;
else
l = m + 1;
}
if (l == len) len++;
g[l] = d[i];
}
cout << len << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int nm = 100002;
int n, m;
int a[nm];
int b[nm], startof[nm];
void nhap() {
scanf("%d", &n);
int i;
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
}
int find(int i) {
int l, r, mid, kq;
l = 0;
r = m;
do {
mid = (l + r) / 2;
if (a[startof[mid]] > a[i]) {
kq = mid;
l = mid + 1;
} else
r = mid - 1;
} while (l <= r);
return (startof[kq]);
}
void xuli() {
b[0] = 0;
b[n] = 1;
startof[1] = n;
startof[0] = n + 1;
a[n + 1] = n + 1;
m = 1;
int i, j;
for (i = n - 1; i >= 1; --i) {
j = find(i);
b[i] = b[j] + 1;
if (b[i] > m) {
m = b[i];
startof[m] = i;
} else {
if (a[i] > a[startof[b[i]]]) startof[b[i]] = i;
}
}
printf("%d", m);
}
int main() {
nhap();
xuli();
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100001], bit[100001];
int n, Max = 0, now;
void updateBIT(int x, int k) {
while (x <= n) {
if (bit[x] < k)
bit[x] = k;
else
break;
x += x & (-x);
}
}
void AskBIT(int x) {
while (x > 0) {
if (bit[x] > now) now = bit[x];
x -= x & (-x);
}
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
bit[i] = 0;
}
for (i = 1; i <= n; i++) {
now = 0;
AskBIT(a[i] - 1);
if (now + 1 > Max) Max = now + 1;
updateBIT(a[i], now + 1);
}
cout << Max;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long d[100005];
long a[100005];
bool f = true;
unsigned long long z = 0;
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long i = 1; i <= n + 1; i++) {
d[i] = 110000000;
}
d[1] = a[1];
for (long i = 2; i <= n; i++) {
long l = 1, r = i;
if (d[1] > a[i]) {
d[1] = a[i];
continue;
}
while (l < r) {
long m = l + (r - l) / 2;
if (d[m] >= a[i])
r = m;
else
l = m + 1;
}
d[r] = a[i];
}
for (long i = 1; i <= n + 1; i++) {
z = i - 1;
if (d[i] == 110000000) break;
}
cout << z;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, t, ans, c[500000], table[500000], maxx;
vector<pair<int, int> > a;
void Array_Compression() {
sort(a.begin(), a.end());
int dem = 1;
t = n;
c[a[0].second] = 1;
for (int i = 1; i <= a.size() - 1; i++) {
if (a[i].first > a[i - 1].first) dem++;
c[a[i].second] = dem;
}
maxx = dem;
}
int Get(int k) {
int res = 0;
while (k > 0) {
res = max(res, table[k]);
k -= (k & (-k));
}
return (res);
}
void Update(int x, int y) {
while (x <= n) {
table[x] = max(table[x], y);
x += (x & (-x));
}
}
void Process() {
for (int i = 1; i <= maxx; i++) {
int f = Get(c[i] - 1) + 1;
Update(c[i], f);
}
for (int i = 1; i <= maxx; i++) ans = max(table[i], ans);
printf("%d", ans);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int k;
scanf("%d", &k);
a.push_back(make_pair(k, i));
}
Array_Compression();
Process();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
template <typename T>
inline T Abs(T x) {
return (x >= 0) ? x : -x;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
inline string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
template <typename T>
inline int bit(T mask, int b) {
return (b >= 0 && (mask & (T(1) << b)) != 0) ? 1 : 0;
}
inline int nextInt() {
int x;
if (scanf("%d", &x) != 1) throw;
return x;
}
inline long long nextInt64() {
long long x;
if (scanf("%lld", &x) != 1) throw;
return x;
}
inline double nextDouble() {
double x;
if (scanf("%lf", &x) != 1) throw;
return x;
}
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int MAXN = 100100;
int tree[MAXN], n;
int getMax(int x) {
int ans = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) ans = max(ans, tree[x]);
return ans;
}
void update(int x, int value) {
for (; x < n; x = (x | (x + 1))) tree[x] = max(value, tree[x]);
}
int main() {
n = nextInt();
int ans = 0;
for (int i = 0; i < (int)(n); i++) {
int x = nextInt();
int value = getMax(x - 1) + 1;
ans = max(ans, value);
update(x, value);
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inv = 1000000000;
const int minv = -1000000000;
;
const int max_n = 100010;
int n;
int a[max_n + 1];
int M[max_n + 1];
int lis;
int binsrc(int l, int r, int ref) {
if (l + 1 == r)
return r;
else {
int mid = (l + r) / 2;
if (M[mid] >= ref)
return binsrc(l, mid, ref);
else
return binsrc(mid, r, ref);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
fill(M, M + n + 1, inv);
M[0] = minv;
lis = 0;
for (int i = 0; i < n; ++i) {
int x = binsrc(0, n, a[i]);
M[x] = a[i];
lis = max(lis, x);
}
printf("%d\n", lis);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long c = 2e5 + 5;
long long arr[c], tail[c], n;
long long bs(long long l, long long r, long long key) {
long long mid;
while (r - l > 1) {
mid = l + (r - l) / 2;
if (tail[mid] >= key)
r = mid;
else
l = mid;
}
return r;
}
long long lis() {
long long length = 1;
tail[0] = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] < tail[0])
tail[0] = arr[i];
else if (arr[i] > tail[length - 1]) {
tail[length] = arr[i];
length++;
} else
tail[bs(0, length - 1, arr[i])] = arr[i];
}
return length;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
cout << lis() << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, tot = 0, a[100005], d[100005];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
if (a[i] > d[tot]) {
d[++tot] = a[i];
continue;
}
int l = 0;
int r = tot;
while (l <= r) {
int mid = (l + r) / 2;
if (d[mid] > a[i]) {
r = mid - 1;
} else {
l = mid + 1;
}
}
d[l] = a[i];
}
printf("%d\n", tot);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int tree[10000100];
int arr[10100];
int query(int i) {
int res = 0;
while (i > 0) {
res = max(tree[i], res);
i -= i & (-i);
}
return res;
}
void update(int i, int n, int val) {
while (i <= n) {
tree[i] = max(tree[i], val);
i += i & (-i);
}
}
void init(int n) {
for (int i = 1; i <= n; i++) {
tree[i] = 0;
}
for (int i = 0; i < n; i++) {
update(i, n, arr[i]);
}
}
int main() {
int n;
int u, v, w, x;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> u;
update(u, n, query(u) + 1);
}
cout << query(n);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int lis_nlogn(vector<int>& v) {
vector<int> len(v.size() + 1, 1e9);
len[0] = -1e9;
int mx = 0;
for (int i = 0; i < (int)v.size(); i++) {
int l = lower_bound(len.begin(), len.end(), v[i]) - len.begin();
mx = max(mx, l);
len[l] = v[i];
}
return mx;
}
int main() {
int n;
scanf("%d", &n);
vector<int> v(n);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
printf("%d", lis_nlogn(v));
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
const int N = 2e5 + 3;
using namespace std;
int CeilIndex(std::vector<int>& v, int l, int r, int key) {
while (r - l > 1) {
int m = l + (r - l) / 2;
if (v[m] >= key)
r = m;
else
l = m;
}
return r;
}
int LongestIncreasingSubsequenceLength(std::vector<int>& v) {
if (v.size() == 0) return 0;
std::vector<int> tail(v.size(), 0);
int length = 1;
tail[0] = v[0];
for (size_t i = 1; i < v.size(); i++) {
if (v[i] < tail[0])
tail[0] = v[i];
else if (v[i] > tail[length - 1])
tail[length++] = v[i];
else
tail[CeilIndex(tail, -1, length - 1, v[i])] = v[i];
}
return length;
}
vector<int> v;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i <= n - 1; i++) cin >> a[i];
int ans = LongestIncreasingSubsequenceLength(a);
cout << ans;
}
| 8 | CPP |
from bisect import *
s, n = [0], input()
for i in map(int, input().split()):
if i > s[-1]: s.append(i)
else: s[bisect_right(s, i)] = i
print(len(s) - 1) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int lft[3 * maxn], rht[3 * maxn], M[3 * maxn];
void build(int n, int l, int r) {
lft[n] = l, rht[n] = r;
if (l == r) return;
int mid = (l + r) >> 1;
build(n << 1, l, mid);
build(n << 1 | 1, mid + 1, r);
}
void upd(int n, int k, int x) {
int mid = (lft[n] + rht[n]) >> 1;
if (lft[n] == rht[n]) {
M[n] = max(M[n], x);
return;
}
if (k <= mid)
upd(n << 1, k, x);
else
upd(n << 1 | 1, k, x);
M[n] = max(M[n << 1], M[n << 1 | 1]);
}
int get(int n, int l, int r) {
int mid = (lft[n] + rht[n]) >> 1;
if (lft[n] == l && rht[n] == r) {
return M[n];
}
if (r <= mid)
return get(n << 1, l, r);
else if (l > mid)
return get(n << 1 | 1, l, r);
else
return max(get(n << 1, l, mid), get(n << 1 | 1, mid + 1, r));
}
int main() {
int n, i, ans = 0;
scanf("%d", &n);
build(1, 1, n);
while (n--) {
int x, t = 1;
scanf("%d", &x);
if (x > 1) t = max(t, get(1, 1, x - 1) + 1);
ans = max(ans, t);
upd(1, x, t);
}
printf("%d\n", ans);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> v;
v.reserve(n);
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
auto it = lower_bound(v.begin(), v.end(), x);
if (it == v.end())
v.push_back(x);
else
*it = x;
}
cout << v.size() << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
set<int> s;
for (int i = 0; i < n; i++) {
if (s.lower_bound(a[i]) != s.end()) {
s.erase(s.lower_bound(a[i]));
}
s.insert(a[i]);
}
cout << s.size();
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[131072];
int s[131072];
int ts = 0;
int binsearch(int k) {
int l = 0, r = ts, mid, ans = 0;
while (l <= r) {
mid = (l + r) / 2;
if (s[mid] < k) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) {
int t = binsearch(a[i]);
s[t + 1] = a[i];
if (t == ts) ts++;
}
printf("%d\n", ts);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int r[110000];
int main() {
int n, len = 0;
scanf("%d", &n);
for (int i = 0, j; i < n; ++i) {
scanf("%d", &j);
int pos = lower_bound(r, r + len, j) - r;
r[pos] = j;
if (len == pos) len++;
}
cout << len << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const double pi = acos(-1.0);
const int rms = (1 << 18) - 1;
const int hrms = rms / 2;
const int size = 200 * 1000;
int rmq[rms + 1];
int n;
int a[size];
int ans[size];
void change(int ps, int val) {
ps += hrms;
rmq[ps] = val;
while (ps > 1) {
ps /= 2;
rmq[ps] = max(rmq[ps * 2], rmq[ps * 2 + 1]);
}
}
int rss(int v, int i, int j, int lb, int rb) {
if (rb < i || lb > j) return 0;
if (lb >= i && rb <= j) return rmq[v];
return max(rss(v * 2, i, j, lb, (lb + rb) / 2),
rss(v * 2 + 1, i, j, (lb + rb) / 2 + 1, rb));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
ans[i] = rss(1, 1, a[i], 1, hrms + 1) + 1;
change(a[i], ans[i]);
}
cout << rss(1, 1, n, 1, hrms + 1) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
using pill = pair<int, ll>;
using vvi = vector<vi>;
ll gcd(ll a, ll b) {
ll t;
while ((t = a % b) != 0) {
a = b;
b = t;
}
return b;
}
ll fast_exp(ll base, ll n, ll m) {
if (n == 0) return 1;
ll t = fast_exp(base, n / 2, m);
if (n % 2 == 0)
return (t * t) % m;
else
return (((t * t) % m) * base) % m;
}
bool is_set(int i, ll mask) { return (mask >> i) & 1; }
int count_bits(ll mask) {
int ans = 0;
for (int i = 0; i < 64; ++i)
if (is_set(i, mask)) ++ans;
return ans;
}
int first_bit(ll mask) {
int i = 0;
while (i < 64)
if (is_set(i++, mask)) return i - 1;
return -1;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
vi v;
v.push_back(a[0]);
for (int i = 1; i < n; ++i) {
if (a[i] < v[0])
v[0] = a[i];
else if (a[i] > v.back())
v.push_back(a[i]);
else
*upper_bound(v.begin(), v.end(), a[i]) = a[i];
}
cout << v.size() << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e6 + 5;
int n, bit[oo], res;
void maxi(int &x, int y) {
if (x < y) x = y;
}
void adj(int x, int val) {
for (; x < oo; x += x & -x) maxi(bit[x], val);
}
int get(int x) {
int ans = 0;
for (; x > 0; x -= x & -x) maxi(ans, bit[x]);
return ans;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
adj(x, get(x - 1) + 1);
}
cout << get(n);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int a[maxn];
int g[maxn];
int d[maxn];
int n;
struct SegTree {
int maxv[maxn * 3];
int ql, qr;
int query(int o, int L, int R) {
if (ql > qr) return 0;
int M = L + (R - L) / 2, ans = 0;
if (ql <= L && R <= qr) return maxv[o];
if (ql <= M) ans = max(ans, query(o * 2, L, M));
if (M < qr) ans = max(ans, query(o * 2 + 1, M + 1, R));
return ans;
}
int p, v;
void update(int o, int L, int R) {
int M = L + (R - L) / 2;
if (L == R)
maxv[o] = v;
else {
if (p <= M)
update(o * 2, L, M);
else
update(o * 2 + 1, M + 1, R);
maxv[o] = max(maxv[o * 2], maxv[o * 2 + 1]);
}
}
} tree;
struct FT {
int C[maxn];
inline int lowbit(int x) { return x & -x; }
int mmax(int x) {
int ret = 0;
while (x > 0) {
ret = max(ret, C[x]);
x -= lowbit(x);
}
return ret;
}
void add(int x, int d) {
while (x <= n) {
C[x] = max(C[x], d);
x += lowbit(x);
}
}
void init() { memset(C, 0, sizeof(C)); }
} ft;
int main(int argc, char *argv[]) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
ft.init();
for (int i = 1; i <= n; i++) {
d[i] = ft.mmax(a[i] - 1) + 1;
ft.add(a[i], d[i]);
}
int ans = 1;
for (int i = 1; i <= n; i++) ans = max(ans, d[i]);
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100100];
int d[100100];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i <= n; i++) {
d[i] = 100100;
}
d[0] = 0;
for (int i = 0; i < n; i++) {
int l = 0;
int r = n - 1;
while (l < r) {
int m = (l + r + 1) / 2;
if (d[m] > a[i]) {
r = m - 1;
} else {
l = m;
}
}
d[r + 1] = a[i];
}
int ans = 0;
for (int i = 0; i <= n; i++) {
if (d[i] < 100100) {
ans = i;
}
}
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int A[100001];
vector<int> L;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
L.push_back(A[0]);
vector<int>::iterator pos;
for (int i = 1; i < n; i++) {
pos = upper_bound(L.begin(), L.end(), A[i]);
if (pos == L.end()) {
L.push_back(A[i]);
} else {
int idx = pos - L.begin();
L[idx] = A[i];
}
}
printf("%d", L.size());
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
T abs(T x) {
return x < 0 ? -x : x;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
int find(int x, int *a, int n) {
int res = 0;
for (int i = x; 0 < i; i -= i & -i) res = max(res, a[i]);
return res;
}
void modify(int x, int v, int *a, int n) {
for (int i = x; i <= n; i += i & -i) a[i] = max(a[i], v);
}
int main(int argc, char **argv) {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int a[n + 1];
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
modify(x, find(x - 1, a, n) + 1, a, n);
}
cout << find(n, a, n) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100009;
int maxup[MAXN];
int main() {
int n, tmp, maxl = 0;
int *ptr;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> tmp;
ptr = upper_bound(maxup, maxup + maxl, tmp);
*ptr = tmp;
if (ptr == maxup + maxl) maxl++;
}
cout << maxl << '\n';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, A[222222], tree[222222], f[222222];
void ins(int x, int val) {
for (int z = x; z <= 200000; z += z & -z) tree[z] = max(tree[z], val);
}
int ask(int r) {
int res = 0;
for (int z = r; z; z -= z & -z) res = max(res, tree[z]);
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%d", &A[i]);
int ans = 0;
for (int i = 1; i <= n; ++i) {
f[i] = ask(A[i] - 1) + 1;
ins(A[i], f[i]);
ans = max(ans, f[i]);
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
def CeilIndex(A, l, r, key):
while (r - l > 1):
m = l + (r - l)//2
if (A[m] >= key):
r = m
else:
l = m
return r
def lis(A, size):
tailTable = [0 for i in range(size + 1)]
len = 0
tailTable[0] = A[0]
len = 1
for i in range(1, size):
if (A[i] < tailTable[0]):
tailTable[0] = A[i]
elif (A[i] > tailTable[len-1]):
tailTable[len] = A[i]
len+= 1
else:
tailTable[CeilIndex(tailTable, -1, len-1, A[i])] = A[i]
return len
n,=I()
p=I()
an=1
print(lis(p,n))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
int a, b, c, d, n, m, k;
int mas[100003];
int fen[100003];
inline void upd(int first, int val) {
for (; first <= n; first |= first + 1) fen[first] = max(fen[first], val);
}
inline int fnd(int first) {
int ans = 0;
for (; first >= 0; first = (first & (first + 1)) - 1)
ans = max(ans, fen[first]);
return ans;
}
int main() {
scanf("%d", &n);
for (int _n((n)-1), i(0); i <= _n; i++) {
scanf("%d", &mas[i]);
--mas[i];
}
int ans = 0;
for (int _n((n)-1), i(0); i <= _n; i++) {
int cur = fnd(mas[i]) + 1;
ans = max(ans, cur);
upd(mas[i], cur);
}
printf("%d\n", ans);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
int cnt[MAXN + 10], MX;
void add(int a, int v) {
while (a <= MX) {
cnt[a] = max(cnt[a], v);
a += (a & (-a));
}
}
int get(int a) {
int res = 0;
while (a > 0) {
res = max(res, cnt[a]);
a -= (a & (-a));
}
return res;
}
int main(void) {
int n;
scanf("%d", &n);
vector<int> p(n);
for (int i = 0; i < (n); ++i) {
scanf("%d", &p[i]);
}
MX = n + 1;
int res = 0;
for (int i = 0; i < (n); ++i) {
int b = get(p[i] - 1);
res = max(res, b + 1);
add(p[i], b + 1);
}
printf("%d\n", res);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int it[200041], n, io;
int down(int x) {
int s = 0, rs = x;
while (x <= n * 2) {
s = max(it[x], s);
x += x & (-x);
}
return s;
}
void up(int x, int u) {
while (x > 0) {
it[x] = max(it[x], u);
x -= x & (-x);
}
}
int main() {
int i, a[100005], o = 0, co;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = n - 1; i >= 0; i--) {
co = down(a[i]);
up(a[i], co + 1);
o = max(co + 1, o);
}
cout << o << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100005], d[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
d[0] = -1000000000;
for (int i = 1; i <= n + 2; ++i) d[i] = 1000000000;
for (int i = 0; i < n; i++) {
int j = int(upper_bound(d, d + n + 1, a[i]) - d);
if (d[j - 1] < a[i] && a[i] < d[j]) d[j] = a[i];
}
for (int i = n; i >= 0; --i)
if (d[i] != 1000000000) {
printf("%d\n", i);
break;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100500];
int v[100500];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
v[0] = -1;
int ans = 0;
for (int i = 0; i < n; i++) {
int l = 0, r = ans + 1;
while (r - l > 1) {
int j = (l + r) / 2;
if (v[j] < a[i])
l = j;
else
r = j;
}
v[l + 1] = a[i];
if (l + 1 > ans) ans = l + 1;
}
cout << ans;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110000;
int n, h[MAXN], a[MAXN];
int lowbit(int x) { return x & -x; }
int ask(int pos) {
int res = 0;
for (int i = pos; i; i -= lowbit(i)) {
res = max(res, h[i]);
}
return res;
}
void ins(int pos, int val) {
for (int i = pos; i <= n; i += lowbit(i)) {
h[i] = max(h[i], val);
}
}
int f[MAXN], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int ans = 0;
for (int i = 1; i <= n; i++) {
f[i] = ask(a[i] - 1) + 1;
ans = max(ans, f[i]);
ins(a[i], f[i]);
}
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
vector<string> form(string a, char s) {
a += s;
vector<string> v;
string b;
for (int i = (0); i < (int)(a.size()); ++i) {
if (a[i] == s) {
v.push_back(b);
b = "";
} else
b += a[i];
}
return v;
}
vector<int> formint(string a, char s) {
vector<int> v;
vector<string> w = form(a, s);
for (int i = (0); i < (int)(w.size()); ++i) v.push_back(toInt(w[i]));
return v;
}
const int inf = 99999999;
int lis_fast(const vector<int>& a) {
const int n = a.size();
vector<int> A(n, inf);
vector<int> id(n);
for (int i = 0; i < n; ++i) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
int m = *max_element(id.begin(), id.end());
return m + 1;
}
int main(void) {
int n;
scanf("%d", &n);
vector<int> v(n);
for (int i = (0); i < (int)(n); ++i) cin >> v[i];
int res = lis_fast(v);
cout << res << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000009;
const int N = 100010;
int a[N], dp[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) dp[i] = INF;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
int l = 0, r = i - 1;
while (l < r) {
int mid = (l + r + 1) / 2;
if (dp[mid] <= a[i])
l = mid;
else
r = mid - 1;
}
dp[l + 1] = a[i];
}
int ans = 0;
for (int i = n; i >= 1; i--)
if (dp[i] < INF) {
ans = i;
break;
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
"""
http://codeforces.com/problemset/problem/341/B
"""
from typing import List
from bisect import bisect_right
class Solution:
def patienceSort(self, a: List[int]) -> int:
# patience sort can find longest increasing subsequence in O(NlogN)
# https://en.wikipedia.org/wiki/Patience_sorting
n = len(a)
piles = [n + 1 for i in range(n)] # To find length of LIS, we're only interested in the top card of each pile
nextPileIdx = 0
for i in a:
idx = bisect_right(piles, i, 0, nextPileIdx)
piles[idx] = i
if idx >= nextPileIdx:
nextPileIdx += 1
return nextPileIdx
def maxIndependentSetSize(self, a: List[int]) -> int:
return self.patienceSort(a)
if __name__ == "__main__":
n = int(input().strip())
a = list(map(int, input().strip().split()))
s = Solution()
print(s.maxIndependentSetSize(a))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[100002], dp[100001];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
fill(dp, dp + n, 1);
int t = 1;
for (int i = 1; i < n; i++) {
int lo = 0, up = t - 1;
int x = 1;
while (up >= lo) {
int d = (up + lo) / 2;
if (a[d] <= a[i]) {
if (dp[d] > x - 1) {
x = dp[d] + 1;
}
lo = d + 1;
} else
up = d - 1;
}
lo = 0;
up = t - 1;
bool flag = false;
while (up >= lo) {
int d = (up + lo) / 2;
if (x == dp[d]) {
a[d] = min(a[i], a[d]);
flag = true;
break;
}
if (x > dp[d])
lo = d + 1;
else
up = d - 1;
}
if (!flag) {
dp[t] = x;
a[t++] = a[i];
}
}
int maxIn = 0;
for (int i = 0; i < n; i++)
if (dp[i] > dp[maxIn]) maxIn = i;
cout << dp[maxIn] << endl;
return 0;
}
| 8 | CPP |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.