solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e5 + 5);
int a[N], dp[N], t[4 * N], sz;
int max(int l, int r, int L, int R, int v) {
if (r <= L || R <= l) return 0;
if (l <= L && R <= r) return t[v];
int mid = (L + R) / 2;
return max(max(l, r, L, mid, v * 2), max(l, r, mid, R, v * 2 + 1));
}
void upd(int v, int val) {
v += sz - 1;
while (v) {
t[v] = max(val, t[v]);
v /= 2;
}
}
int main() {
int n, res = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
dp[i] = 1;
}
sz = 1;
while (sz < n) sz <<= 1;
for (int i = 0; i < n; i++) {
dp[i] = max(1, a[i], 1, sz + 1, 1) + 1;
res = max(res, dp[i]);
upd(a[i], dp[i]);
}
cout << res << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const int maxn = 1 << 17;
const int inf = 1000000007;
const int mod = 1000000007;
int n;
int a[maxn], d[maxn];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
memset(d, 127, sizeof(d));
d[0] = -1;
for (int i = 0; i < n; i++) {
int j = lower_bound(d, d + n + 1, a[i]) - d;
d[j] = a[i];
}
for (int i = n; i >= 0; i--) {
if (d[i] < 1e9) {
cout << i << endl;
break;
}
}
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][2] = {0};
void update1(long long int idx, long long int val, long long int pos) {
while (idx <= 100000) {
dp[idx][pos] += val;
dp[idx][pos] %= 1000000007;
idx += idx & -idx;
}
}
long long int pref1(long long int idx, long long int pos) {
long long int ans = 0;
while (idx > 0) {
ans += dp[idx][pos];
ans %= 1000000007;
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);
}
void Birdperson() {
cin >> n;
set<long long int> s;
for (int i = 0; i < (n); ++i) {
cin >> x;
s.insert(x);
auto it = s.upper_bound(x);
if (it != s.end()) s.erase(it);
}
cout << (int)s.size() << "\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;
const int N = 100050;
int dp[N], n, mx[N << 2], a[N];
void update(int p, int add, int l, int r, int rt) {
if (l == r) {
mx[rt] = add;
return;
}
int m = (l + r) >> 1;
if (p <= m)
update(p, add, l, m, rt << 1);
else
update(p, add, m + 1, r, rt << 1 | 1);
mx[rt] = max(mx[rt << 1], mx[rt << 1 | 1]);
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return mx[rt];
int m = (l + r) >> 1;
int ret = 0;
if (L <= m) ret = max(ret, query(L, R, l, m, rt << 1));
if (R > m) ret = max(ret, query(L, R, m + 1, r, rt << 1 | 1));
return ret;
}
int main() {
scanf("%d", &n);
int ans = 0;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
int ret = query(1, a, 1, n, 1);
dp[a] = ret + 1;
ans = max(ans, dp[a]);
update(a, dp[a], 1, n, 1);
}
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
const long double eps = 1e-07;
int n;
int a[200000];
int d[200000];
int main() {
scanf("%d", &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 l = 0;
int r = n;
while (r - l > 2) {
int m = (l + r) / 2;
if (d[m] < a[i]) {
l = m;
} else
r = m;
}
for (int j = r; j >= l; --j)
if (d[j] < a[i]) {
d[j + 1] = a[i];
break;
}
}
int ans = -inf;
for (int i = 1; i <= n; ++i)
if (d[i] != inf) ans = max(ans, i);
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
while (cin >> n) {
int a[100000];
vector<int> v;
for (int i = 0; i != n; ++i) cin >> a[i];
int MaxV[100005];
MaxV[1] = a[0];
int nmaxv = 1;
for (int i = 1; i != n; ++i) {
int u = 1, v = nmaxv;
while (u <= v) {
int mid = (u + v) >> 1;
if (MaxV[mid] < a[i])
u = mid + 1;
else
v = mid - 1;
}
nmaxv = max(nmaxv, v + 1);
MaxV[v + 1] = a[i];
}
cout << nmaxv << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int fena[100005], fenn;
void initfen() { memset(fena, 0, sizeof(fena)); }
int fengetmax(int inx) {
int ret = 0;
for (int i = inx; i > 0; i -= (i & (-i))) ret = max(ret, fena[i]);
return ret;
}
void fenset(int inx, int val) {
for (int i = inx; i <= fenn; i += (i & (-i))) fena[i] = max(fena[i], val);
}
void doit() {
int tn, ret = 0, cmax = 0;
cin >> fenn;
initfen();
for (int i = 0; i < fenn; i++) {
cin >> tn;
cmax = fengetmax(tn);
fenset(tn, cmax + 1);
ret = max(ret, cmax + 1);
}
cout << ret << endl;
return;
}
int main() {
doit();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000 + 5;
const int MOD = 1000 * 1000 * 1000 + 7;
const long double EPS = 1e-8;
int n;
vector<int> a;
vector<int> f;
int ans;
void change(int x, int d) {
for (int i = x; i < n; i = i | (i + 1)) f[i] = max(f[i], d);
}
int get(int x) {
int res = 0;
for (int i = x; i >= 0; i = (i & (i + 1)) - 1) res = max(res, f[i]);
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i], --a[i];
f.resize(n);
for (int i = 0; i < n; ++i) {
int x = get(a[i]) + 1;
change(a[i], x);
ans = max(ans, x);
}
cout << ans << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
unsigned long long gcd(unsigned long long a, unsigned long long b) {
return (b == 0 ? a : gcd(b, a % b));
}
long long x, y, z, n, m, r, l, k, a, h, d;
char c;
vector<int> v;
vector<int> tail;
int bs(int l, int r, int key) {
while (r - l > 1) {
int m = l + (r - l) / 2;
if (tail[m] >= key)
r = m;
else
l = m;
}
return r;
}
int dfs() {
if (v.size() == 0) return 0;
tail.clear();
tail.resize(v.size());
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[bs(-1, length - 1, v[i])] = v[i];
}
return length;
}
void solve() {
cin >> n;
for (int i = 0; i < n; i++) cin >> x, v.push_back(x);
cout << dfs();
}
int main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
solve();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int n, BIT[100001], arr[100001];
void insert(long long int x, long long int val) {
for (; x <= n; x += (x & (-x))) BIT[x] = max(BIT[x], val);
}
long long int query(long long int x) {
long long int sum = 0;
for (; x > 0; x -= (x & (-x))) sum = max(sum, BIT[x]);
return sum;
}
int main() {
long long int i, j, k;
cin >> n;
for (i = 0; i < n; ++i) cin >> arr[i];
k = 0;
for (i = 0; i < n; ++i) {
j = query(arr[i]) + 1;
k = max(k, j);
insert(arr[i], j);
}
cout << k << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, a[100005], lis[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
long long len = 0;
for (long long i = 0; i < n; i++) {
long long pos = lower_bound(lis, lis + len, a[i]) - lis;
lis[pos] = a[i];
if (pos + 1 > len) len = pos + 1;
}
cout << len << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005];
int s[100005], top;
void work() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (i = 1; i <= n; ++i) {
if (a[i] > s[top])
s[++top] = a[i];
else {
j = upper_bound(s + 1, s + top + 1, a[i]) - s;
s[j] = a[i];
}
}
cout << top << endl;
}
int main() {
work();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000;
int g[maxn];
int n;
int a[maxn];
int lowbit(int x) { return x & (-x); }
void update(int x, int f) {
while (x <= n) {
g[x] = max(g[x], f);
x += lowbit(x);
}
}
int getmax(int x) {
int ans = 0;
while (x > 0) {
ans = max(ans, g[x]);
x -= lowbit(x);
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
memset(g, 0, sizeof(g));
int ans = 0;
for (int i = 1; i <= n; ++i) {
int f = getmax(a[i]) + 1;
ans = max(ans, f);
update(a[i], f);
}
cout << ans << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, L;
int vals[100001];
int m[100000];
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &vals[i]);
m[i] = 100000;
}
vals[100000] = 1 << 30;
L = 0;
for (int i = 0; i < N; i++) {
int lb = 0, ub = L;
while (ub - lb > 1) {
int mid = (ub + lb) / 2;
if (vals[m[mid]] < vals[i])
lb = mid;
else
ub = mid - 1;
}
int j = 0;
for (int t = lb; t <= ub; t++)
if (vals[m[t]] < vals[i]) j = t;
if (j == L || vals[i] < vals[m[j + 1]]) {
m[j + 1] = i;
L = max(L, j + 1);
}
}
printf("%d\n", L);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dp[1000009];
int LIS(vector<int> a) {
int maxi = 1;
int sz = a.size();
vector<int> d(sz + 1, 100000000);
for (int i = int(0); i <= int(sz - 1); i++) {
vector<int>::iterator it = lower_bound(d.begin(), d.end(), a[i]);
*it = a[i];
dp[i] = (it - d.begin()) + 1;
maxi = max(maxi, dp[i]);
}
return maxi;
}
int main() {
memset(dp, 0, sizeof(dp));
int n;
scanf("%d", &n);
vector<int> a(n);
for (int i = int(0); i <= int(n - 1); i++) scanf("%d", &a[i]);
int ans = LIS(a);
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int a[100011];
int b[100011];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) gn(a[i]);
for (int i = 0; i < 100011; i++) b[i] = 0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
int pos = upper_bound(b, b + 100011, a[i]) - b;
b[pos] = a[i];
}
for (int i = 0; i < 100011; i++)
if (b[i] == 0x3f3f3f3f) return cout << i << endl, 0;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int oo = (1 << 31) - 1;
int arr[100010];
int main() {
int N, lis, v, p;
scanf("%d", &N);
arr[0] = oo;
lis = 1;
for (int i = 0; i < N; i++) {
scanf("%d", &v);
p = lower_bound(arr, arr + lis, v) - arr;
arr[p] = v;
if (p == lis) lis++;
}
printf("%d\n", lis);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int r[100100], n;
int sum(int x) {
int ans = 0;
for (; x >= 0; x = ((x & (x + 1)) - 1)) ans = max(r[x], ans);
return ans;
}
void modify(int x, int y) {
for (; x <= n; x = (x | (x + 1))) r[x] = max(r[x], y);
}
int res, mas[100100];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &mas[i]);
int d = sum(mas[i] - 1);
modify(mas[i], d + 1);
res = max(res, d + 1);
}
cout << res << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, h[200005], f[200005], stk[200005], top, ans;
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &h[i]);
}
void work() {
for (int i = 1; i <= n; i++) {
int res = 0;
for (int x = h[i]; x; x -= (x & -x)) res = max(res, f[x]);
for (int x = h[i]; x <= n; x += (x & -x)) f[x] = max(f[x], res + 1);
}
int res = 0;
for (int x = n; x; x -= (x & -x)) res = max(res, f[x]);
printf("%d\n", res);
}
int main() {
init();
work();
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, N;
int bit[100009], ar[1000009];
void update(int idx, int val) {
while (idx <= n) {
bit[idx] = max(bit[idx], val);
idx += (idx & -idx);
}
}
int query(int index) {
int ans = 0;
while (index > 0) {
ans = max(ans, bit[index]);
index -= index & (-index);
}
return ans;
}
int main() {
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
int temp = query(a);
temp++;
ans = max(ans, temp);
update(a, temp);
}
cout << ans << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N;
int A[100002], D[100002];
int result;
int AIB[100002];
void update(int pos, int val) {
for (; pos <= 100000; pos += pos & -pos) AIB[pos] = max(AIB[pos], val);
}
int query(int pos) {
int resnow = 0;
for (; pos >= 1; pos -= pos & -pos) resnow = max(resnow, AIB[pos]);
return resnow;
}
int main() {
cin >> N;
for (int i = 1; i <= N; ++i) cin >> A[i];
for (int i = 1; i <= N; ++i) {
D[i] = query(A[i] - 1) + 1;
update(A[i], D[i]);
result = max(result, D[i]);
}
cout << result << '\n';
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct _ {
ios_base::Init i;
_() {
cin.sync_with_stdio(0);
cin.tie(0);
}
} _;
set<int> s;
int main() {
int n, a;
cin >> n;
for (int i = (0); i < ((n)); i++) {
cin >> a;
pair<typeof(s.begin()), bool> r = s.insert(a);
if (r.second) {
if (++(r.first) != s.end()) {
s.erase(r.first);
}
}
}
cout << s.size() << endl;
return 0;
}
| 8 | CPP |
import sys,math as mt
import heapq as hp
import collections as cc
import math as mt
import itertools as it
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()
l=I()
print(lis(l,n)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> Q;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a;
cin >> a;
int pos = upper_bound(Q.begin(), Q.end(), a) - Q.begin();
if (pos == Q.size())
Q.push_back(a);
else
Q[pos] = a;
}
printf("%d\n", (int)Q.size());
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int d[100005];
int find(int l, int r, int x) {
if (l == r) return l;
int mid = (l + r) >> 1;
if (d[mid] > x)
return find(l, mid, x);
else
return find(mid + 1, r, x);
}
int main() {
int n;
scanf("%d", &n);
d[0] = -1;
int temp = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x >= d[temp])
d[++temp] = x;
else
d[find(1, temp, x)] = x;
}
printf("%d\n", temp);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
int n, m;
int a[N], b[N];
int LIS() {
int len = 1;
b[1] = a[1];
for (int i = 2; i <= n; ++i) {
if (a[i] > b[len])
b[++len] = a[i];
else {
int j = lower_bound(b + 1, b + 1 + len, a[i]) - b;
b[j] = a[i];
}
}
return len;
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
cout << LIS() << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> d, a;
int n, t;
int main() {
cin >> n;
while (n--) cin >> t, a.push_back(t);
for (auto i : a)
if (lower_bound(d.begin(), d.end(), i) == d.end())
d.push_back(i);
else
*lower_bound(d.begin(), d.end(), i) = i;
cout << d.size();
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[100100], N;
int solve() {
vector<int> v;
for (int i = 0; i < N; i++) {
vector<int>::iterator it = upper_bound(v.begin(), v.end(), arr[i]);
if (it == v.end())
v.push_back(arr[i]);
else
*it = arr[i];
}
return v.size();
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) cin >> arr[i];
cout << solve() << '\n';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, p;
int arr[100010];
int lis[100010];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
lis[i] = n + 1;
}
for (int i = 0; i < n; i++) {
int idx = lower_bound(lis, lis + p + 1, arr[i]) - lis;
lis[idx] = arr[i];
if (idx == p) p++;
}
cout << p << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100009], g[100009], d[100009];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) g[i] = 0x7fffffff;
for (int i = 0; i < n; i++) {
int k = lower_bound(g + 1, g + n + 1, a[i]) - g;
d[i] = k;
g[k] = a[i];
}
int ans = 0;
for (int i = 0; i < n; i++) ans = max(ans, d[i]);
printf("%d", ans);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3fLL;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 1e5 + 10;
int n, dp[maxn], a[maxn];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int ans = 0;
memset(dp, INF, sizeof(dp));
for (int i = 0; i < n; i++) {
int pos = lower_bound(dp, dp + n, a[i]) - dp;
dp[pos] = a[i];
ans = max(ans, pos + 1);
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wall"
#pragma GCC diagnostic ignored "-Wextra"
#pragma GCC diagnostic ignored "-Wconversion"
using namespace std;
const int N = 1005, OO = 0x3f3f3f3f;
int arr[100001], n, idx;
vector<int> lis;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", arr + i);
lis.push_back(arr[0]);
for (int i = 1; i < n; i++) {
idx = lower_bound(lis.begin(), lis.end(), arr[i]) - lis.begin();
if (idx == lis.size())
lis.push_back(arr[i]);
else
lis[idx] = arr[i];
}
printf("%d", lis.size());
}
| 8 | CPP |
#include <bits/stdc++.h>
int inp[100002];
int res[100002];
int dp[100002];
int dpn;
int min(int a, int b) { return (a < b) ? a : b; }
int max(int a, int b) { return (a > b) ? a : b; }
int main() {
int n, i, s, e, m, r = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", inp + i);
}
res[0] = 1;
dp[0] = inp[0];
dpn = 0;
for (i = 1; i < n; i++) {
if (inp[i] < dp[0]) {
dp[0] = inp[i];
res[i] = 1;
} else if (inp[i] > dp[dpn]) {
dpn++;
dp[dpn] = inp[i];
res[i] = dpn + 1;
} else {
s = 0;
e = dpn + 1;
while (e - s > 1) {
m = (s + e) / 2;
(dp[m] < inp[i]) ? s = m : e = m;
}
res[i] = s + 2;
dp[s + 1] = min(dp[s + 1], inp[i]);
}
}
for (i = 0; i < n; i++) {
r = max(r, res[i]);
}
printf("%d", r);
}
| 8 | CPP |
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 LongestIncreasingSubsequenceLength(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
N = int(input())
List = [int(x) for x in input().split()]
print(LongestIncreasingSubsequenceLength(List,N))
| 8 | PYTHON3 |
""" Python 3 compatibility tools. """
from __future__ import division, print_function
import itertools
import sys
import os
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
input = raw_input
range = xrange
filter = itertools.ifilter
map = itertools.imap
zip = itertools.izip
def is_it_local():
script_dir = str(os.getcwd()).split('/')
username = "dipta007"
return username in script_dir
def READ(fileName):
if is_it_local():
sys.stdin = open(f'./{fileName}', 'r')
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
if not is_it_local():
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
def input1(type=int):
return type(input())
def input2(type=int):
[a, b] = list(map(type, input().split()))
return a, b
def input3(type=int):
[a, b, c] = list(map(type, input().split()))
return a, b, c
def input_array(type=int):
return list(map(type, input().split()))
def input_string():
s = input()
return list(s)
##############################################################
#Given a list of numbers of length n, this routine extracts a
#longest increasing subsequence.
#
#Running time: O(n log n)
#
# INPUT: a vector of integers
# OUTPUT: a vector containing the longest increasing subsequence
def lower_bound(nums, target):
l, r = 0, len(nums) - 1
res = len(nums)
while l <= r:
mid = int(l + (r - l) / 2)
if nums[mid] >= target:
res = mid
r = mid - 1
else:
l = mid + 1
return res
def upper_bound(nums, target):
l, r = 0, len(nums) - 1
res = len(nums)
while l <= r:
mid = int(l + (r - l) / 2)
if nums[mid] > target:
r = mid - 1
res = mid
else:
l = mid + 1
return res
def LIS(v, STRICTLY_INCREASING = False):
best = []
dad = [-1 for _ in range(len(v))]
for i in range(len(v)):
if STRICTLY_INCREASING:
item = (v[i], 0)
pos = lower_bound(best, item)
item.second = i
else:
item = (v[i], i)
pos = upper_bound(best, item)
if pos == len(best):
dad[i] = -1 if len(best) == 0 else best[-1][1]
best.append(item)
else:
dad[i] = -1 if pos == 0 else best[pos-1][1]
best[pos] = item
# print(pos, best)
# ret = []
i = best[-1][1]
cnt = 0
while i >= 0:
# ret.append(v[i])
cnt += 1
i = dad[i]
# ret.reverse()
return cnt
def main():
n = input1()
v = input_array()
print(LIS(v))
pass
if __name__ == '__main__':
READ('in.txt')
main() | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long INF = (long long)1 << 62;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 5;
int n, a[maxn];
vector<int> v;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
v.push_back(a[0]);
for (int i = 1; i < n; i++) {
auto t = lower_bound(v.begin(), v.end(), a[i]);
int it = t - v.begin();
if (it == ((int)(v).size()))
v.push_back(a[i]);
else if (a[i] < v[it])
v[it] = a[i];
}
cout << ((int)(v).size()) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int maxm = 310;
const int N = 20010;
const int INF = 0x3f3f3f3f;
const int mod = 1000000007;
int n, m;
int a[maxn];
int dp[maxn];
int d[maxn];
int sc(int x, int right) {
int left = 1;
int mid;
int ret = 0;
while (left <= right) {
mid = (left + right) >> 1;
if (x > d[mid]) {
ret = mid;
left = mid + 1;
} else {
right = mid - 1;
}
}
return ret;
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
d[1] = a[1];
int len = 1;
for (i = 2; i <= n; i++) {
int x;
if (d[len] < a[i]) {
x = ++len;
} else {
x = sc(a[i], len) + 1;
}
d[x] = a[i];
}
printf("%d\n", len);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e6;
int a[maxn], T[maxn * 2], dp[maxn];
int n;
int findMax(int l, int r) {
l += n - 1;
r += n - 1;
int res = 0;
while (l <= r) {
if (l & 1) res = max(res, T[l]);
if (!(r & 1)) res = max(res, T[r]);
l = (l + 1) >> 1;
r = (r - 1) >> 1;
}
return res;
}
void update(int v, int x) {
v += n - 1;
T[v] = max(T[v], x);
while (v > 1) {
v >>= 1;
T[v] = max(T[v + v], T[v + v + 1]);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int ans = 0;
for (int i = 0; i < n; ++i) {
dp[i] = findMax(1, a[i] - 1) + 1;
update(a[i], dp[i]);
ans = max(ans, dp[i]);
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 1e5 + 10;
const int MOD = 1e9 + 7;
const long double eps = 1e-12;
int n, d[N], a[N], mp[N], dp[N], fen[N], ans;
void upd(int ind, int val) {
while (ind < N) fen[ind] = max(fen[ind], val), ind += ind & -ind;
}
int get(int ind) {
int ret = 0;
while (ind > 0) ret = max(ret, fen[ind]), ind -= ind & -ind;
return ret;
}
int main() {
n = in();
for (int i = 0; i < n; i++) a[i] = in(), mp[i] = a[i];
sort(mp, mp + n);
for (int i = 0; i < n; i++) a[i] = lower_bound(mp, mp + n, a[i]) - mp + 1;
dp[0] = 1;
d[a[0]] = 1;
upd(a[0], 1);
for (int i = 1; i < n; i++) {
int x = a[i];
dp[i] = get(x) + 1;
upd(x, dp[i]);
ans = max(ans, dp[i]);
}
cout << ans;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int BIT[10000001];
int A[10000001], maxVal = 10000001;
int query(int x) {
int ans = 0;
while (x > 0) {
ans = max(ans, BIT[x]);
x -= (x & -x);
}
return ans;
}
void update(int x, int value) {
while (x <= maxVal) {
BIT[x] = max(BIT[x], value);
x += (x & -x);
}
}
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> A[i];
}
int ans = 0;
for (int i = 0; i < N; i++) {
int temp = query(A[i]);
ans = max(ans, temp + 1);
update(A[i], temp + 1);
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int A[100005];
set<int> st;
int main() {
int i, ans, n;
while (scanf("%d", &n) != EOF) {
st.clear();
set<int>::iterator it;
for (i = 1; i <= n; i++) {
scanf("%d", &A[i]);
if (st.size()) {
it = st.lower_bound(A[i]);
if (it != st.end()) {
st.erase(it);
}
}
st.insert(A[i]);
}
printf("%d\n", st.size());
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
int n, a[maxn], dp[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
dp[0] = 0;
for (int i = 1; i <= n; i++) dp[i] = 2 * n;
for (int i = 1; i <= n; i++) {
int p = upper_bound(dp, dp + 1 + n, a[i]) - dp;
dp[p] = a[i];
}
int len = 0;
for (int i = 1; i <= n; i++)
if (dp[i] <= n)
len++;
else
break;
printf("%d\n", len);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = LLONG_MAX;
const long long N = 1e5 + 10;
long long CeilIndex(std::vector<long long> &v, long long l, long long r,
long long key);
long long LongestIncreasingSubsequenceLength(std::vector<long long> &v);
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; cin >> a[i++])
;
cout << LongestIncreasingSubsequenceLength(a) << endl;
return 0;
}
long long CeilIndex(std::vector<long long> &v, long long l, long long r,
long long key) {
while (r - l > 1) {
long long m = l + (r - l) / 2;
if (v[m] >= key)
r = m;
else
l = m;
}
return r;
}
long long LongestIncreasingSubsequenceLength(std::vector<long long> &v) {
if (v.size() == 0) return 0;
std::vector<long long> tail(v.size(), 0);
long long length = 1;
tail[0] = v[0];
for (long long 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;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int inf = 1e9 + 10;
int a[N], dp[N];
bool isVal(int x, int y) { return (y < dp[x]); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[n - i];
fill(dp, dp + N, -inf);
dp[0] = 0;
dp[1] = a[1];
for (int i = 2; i <= n; i++) {
int l = 0, r = n + 1;
while (r - l > 1) {
int mid = (l + r) / 2;
if (isVal(mid, a[i]))
l = mid;
else
r = mid;
}
dp[l + 1] = a[i];
}
int ans = 1;
for (int i = 1; i <= n; i++)
if (dp[i] != -inf) ans = i;
cout << ans;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100001];
int A[100001];
int main() {
scanf("%d", &n);
for (int i = int(0); i < int(n); i++) scanf("%d", a + i);
vector<int> A(n, 12345678);
vector<int> id(n);
for (int i = int(0); i < int(n); i++) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
cout << *max_element(id.begin(), id.end()) + 1 << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void find_lis(vector<int> &a, vector<int> &b) {
vector<int> p(a.size());
int u, v;
if (a.empty()) return;
b.push_back(0);
for (size_t i = 1; i < a.size(); i++) {
if (a[b.back()] < a[i]) {
p[i] = b.back();
b.push_back(i);
continue;
}
for (u = 0, v = b.size() - 1; u < v;) {
int c = (u + v) / 2;
if (a[b[c]] < a[i])
u = c + 1;
else
v = c;
}
if (a[i] < a[b[u]]) {
if (u > 0) p[i] = b[u - 1];
b[u] = i;
}
}
for (u = b.size(), v = b.back(); u--; v = p[v]) b[u] = v;
}
int a[100010];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0), cerr << "";
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> seq(a, a + sizeof(a) / sizeof(a[0]));
vector<int> lis;
find_lis(seq, lis);
cout << lis.size();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010, INF = ~0U >> 2;
int n, A[MAXN], D[MAXN], res;
void init() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
}
void solve() {
D[0] = -INF;
int l, r, mid, x;
res = 0;
for (int i = 0; i < n; i++) {
x = A[i];
if (x > D[res])
D[++res] = x;
else {
l = 0;
r = res;
while (l < r) {
mid = l + r + 1 >> 1;
if (x > D[mid])
l = mid;
else
r = mid - 1;
}
D[l + 1] = x;
}
}
}
void pri() { printf("%d\n", res); }
int main() {
init();
solve();
pri();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int tree[4 * MAXN];
void build_tree(int v, int tl, int tr) {
if (tl == tr) {
tree[v] = 0;
return;
}
int mid = (tl + tr) / 2;
build_tree(2 * v, tl, mid);
build_tree(2 * v + 1, mid + 1, tr);
tree[v] = 0;
}
int get_max_tree(int v, int tl, int tr, int l, int r) {
if (tl > r || tr < l) return 0;
l = max(tl, l);
r = min(tr, r);
if (tl == l && tr == r) return tree[v];
int mid = (tl + tr) / 2;
return max(get_max_tree(2 * v, tl, mid, l, r),
get_max_tree(2 * v + 1, mid + 1, tr, l, r));
}
void modify(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
tree[v] = val;
return;
}
int mid = (tl + tr) / 2;
if (pos <= mid)
modify(2 * v, tl, mid, pos, val);
else
modify(2 * v + 1, mid + 1, tr, pos, val);
tree[v] = max(tree[2 * v], tree[2 * v + 1]);
}
int main(void) {
int N, a;
cin >> N;
build_tree(1, 1, N);
for (int i = 1; i <= N; i++) {
cin >> a;
int best = max(1, get_max_tree(1, 1, N, 1, a) + 1);
modify(1, 1, N, a, best);
}
cout << get_max_tree(1, 1, N, 1, N) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
int n, a[110000];
vector<int> d;
int main() {
cin >> n;
d.push_back(-1000000007);
for (int i = (1); i < (n + 2); ++i) d.push_back(1000000007);
for (int i = (0); i < (n); ++i) scanf("%d", &a[i]);
int j;
for (int i = (0); i < (n); ++i) {
j = (upper_bound(d.begin(), d.end(), a[i]) - d.begin());
if (d[j - 1] < a[i] && a[i] < d[j]) d[j] = a[i];
}
j = 0;
while (d[j + 1] != 1000000007) j++;
cout << j << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MX = 300000;
int n, arr[MX], bit[MX], ans = 0, lis;
void update(int x, int V) {
while (x <= n) {
bit[x] = max(bit[x], V);
x += x & -x;
}
}
int get(int x) {
int ret = 0;
while (x > 0) {
ret = max(ret, bit[x]);
x -= x & -x;
}
return ret;
}
int main() {
scanf("%d", &n);
memset(bit, 0, sizeof(bit));
for (int j = 1; j <= n; j++) {
scanf("%d", &arr[j]);
lis = get(arr[j]) + 1;
update(arr[j] + 1, lis);
ans = max(ans, lis);
}
cout << ans << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> a;
int ft[1000000];
int get_max(int pos) {
if (pos == 0) return 0;
return max(ft[pos], get_max(pos - (pos & (-pos))));
}
void upt_max(int pos, int val) {
if (pos >= 1000000) return;
ft[pos] = max(ft[pos], val);
upt_max(pos + (pos & (-pos)), val);
}
int ans;
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < a.size(); ++i) {
int t = get_max(a[i] - 1) + 1;
ans = max(ans, t);
upt_max(a[i], t);
}
cout << ans << '\n';
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, A[123457], T[4 * 123457];
int res;
int sum(int x) {
int ans = 0;
while (x > 0) {
ans = ans > T[x] ? ans : T[x];
x -= (x & -x);
}
return ans;
}
void up(int x, int val) {
while (x <= n) {
T[x] = max(T[x], val);
x += (x & -x);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i];
}
up(A[1], 1);
for (int i = 2; i <= n; i++) {
int a = sum(A[i]);
up(A[i], a + 1);
res = res > a + 1 ? res : a + 1;
}
cout << res;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
int n, a[100005], h[100005];
int main() {
int ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
h[i + 1] = INF;
int lo = 0, hi = i;
while (lo < hi) {
int m = (lo + hi + 1) / 2;
if (a[i] > h[m])
lo = m;
else
hi = m - 1;
}
ans = max(ans, ++lo);
h[lo] = a[i];
}
printf("%d\n", ans);
if (0) {
int b[10];
for (int i = 0; i < n; i++) a[i] = i;
do {
set<int> e[200];
for (int i = 0; i < n; i++) b[i] = a[i];
bool ok = true;
while (ok) {
ok = false;
for (int i = 1; i < n; i++) {
if (b[i - 1] > b[i]) {
ok = true;
e[b[i - 1]].insert(b[i]);
e[b[i]].insert(b[i - 1]);
swap(b[i - 1], b[i]);
}
}
}
int mask = (1 << n) - 1, ans = 0, tag = 0;
for (int s = 0; s <= mask; s++) {
ok = true;
int cnt = __builtin_popcount(s);
if (cnt <= ans) continue;
for (int i = 0; i < n; i++)
if (s & 1 << i)
for (int j = 0; j < i; j++)
if (s & 1 << j)
if (e[i].count(j) || e[j].count(i)) i = j = n, ok = false;
if (ok) {
ans = cnt;
tag = s;
}
}
printf("result = %d for list", ans);
for (int i = 0; i < n; i++) printf(" %d", a[i]);
printf(", set =");
for (int i = 0; i < n; i++)
if (tag & 1 << i) printf(" %d", i);
puts("");
} while (next_permutation(a, a + n));
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int INP, AM, REACHEOF;
const int BUFSIZE = (1 << 12) + 17;
char BUF[BUFSIZE + 1], *inp = BUF;
const int MN = 100111;
int n, a[MN], f[MN], bit[MN];
int get(int u) {
int res = 0;
for (int x = u; x > 0; x -= ((x) & (-(x)))) res = max(res, bit[x]);
return res;
}
void update(int u, int k) {
for (int x = u; x <= n; x += ((x) & (-(x)))) bit[x] = max(bit[x], k);
}
int main() {
ios ::sync_with_stdio(false);
while (cin >> n) {
for (int i = (1), _b = (n); i <= _b; i++) cin >> a[i];
memset(bit, 0, sizeof bit);
int res = 0;
for (int i = (1), _b = (n); i <= _b; i++) {
f[i] = get(a[i]) + 1;
update(a[i], f[i]);
res = max(res, f[i]);
}
cout << res << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = atan(1.0);
const int N = 100001;
int n;
int tree[N * 4];
int query(int node, int l, int r, int ll, int rr) {
if (l > rr || r < ll || r < l || rr < ll) return 0;
if (l >= ll && r <= rr) return tree[node];
int mid = (l + r) >> 1;
int n1 = query(node << 1, l, mid, ll, rr);
int n2 = query(node << 1 | 1, mid + 1, r, ll, rr);
return max(n1, n2);
}
void insert(int node, int l, int r, int idx) {
if (l == r) {
tree[node] = query(1, 1, n, 1, idx - 1) + 1;
return;
}
int mid = (l + r) >> 1;
if (idx <= mid)
insert(node << 1, l, mid, idx);
else
insert(node << 1 | 1, mid + 1, r, idx);
tree[node] = max(tree[node << 1], tree[node << 1 | 1]);
}
int main() {
ios::sync_with_stdio(0);
;
cin >> n;
memset(tree, 0, sizeof(tree));
for (int i = 1; i <= n; i++) {
int num;
cin >> num;
insert(1, 1, n, num);
}
cout << tree[1];
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> d(n + 1, 1e9);
d[0] = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
int l = 0, r = n;
while (l < r - 1) {
int c = (l + r) / 2;
if (d[c] < a[i])
l = c;
else
r = c;
}
d[l + 1] = a[i];
ans = max(ans, l + 1);
}
cout << ans;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int ceilElement(int a[], int start, int end, int key) {
while (end - start > 1) {
int mid = start + (end - start) / 2;
if (a[mid] >= key) {
end = mid;
} else {
start = mid;
}
}
return end;
}
int longestIncreasingSubsequence(int input[], int size) {
if (!size) return 0;
int a[size];
int length = 1;
a[0] = input[0];
for (int i = 1; i < size; i++) {
if (input[i] < a[0]) {
a[0] = input[i];
} else if (input[i] > a[length - 1]) {
a[length++] = input[i];
} else
a[ceilElement(a, -1, length - 1, input[i])] = input[i];
}
return length;
}
int main() {
int n;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int size = sizeof(a) / sizeof(a[0]);
printf("%d", longestIncreasingSubsequence(a, size));
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long i, j, n, m, k, x, y, l, r;
long long res, ans, cur;
string s, q, s1, s2;
char ch1, ch2, ch3;
long long a[500000], b[500000];
bool f11[500000], f12[500000];
bool fix[500000];
vector<long long> g[500000], c[500000];
long long X(long long A, long long B, long long P) {
if (!B) return 1;
if (B == 1) return (A % P);
long long C = X(A, B / 2, P);
C *= C;
C %= P;
if (B % 2) C *= A;
return C % P;
}
long long UG(long long A, long long B) {
if (A > B) return UG(B, A);
if (A == 0) return B;
if (A == 1) return 1;
return UG(B % A, A);
}
long long UJ(long long A, long long B) {
long long C = UG(A, B);
A /= C;
A *= B;
return A;
}
long long d[5000000];
int main() {
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
d[0] = -10;
d[1] = a[1];
for (i = 2; i <= n; i++) d[i] = 1000000000;
for (i = 2; i <= n; i++) {
l = 0;
r = (i - 1);
while (l + 1 < r) {
m = (l + r) / 2;
if (d[m] < a[i])
l = m;
else
r = m - 1;
}
if (d[r] < a[i])
d[r + 1] = min(d[r + 1], a[i]);
else if (d[l] < a[i])
d[l + 1] = min(d[l + 1], a[i]);
}
for (i = n; i >= 1; i--)
if (d[i] != 1000000000) break;
cout << i << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 1000;
long long a[maxn];
long long b[maxn];
int bs(int from, int to, int m);
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int last = 1;
b[1] = a[1];
for (int i = 2; i <= n; i++) {
int x = bs(1, last, a[i]);
if (x > last) last = x;
b[x] = a[i];
}
cout << last << endl;
return 0;
}
int bs(int from, int to, int m) {
while (to - from + 1 > 4) {
if (m > b[(to - from) / 2 + from]) {
from = ((to - from) / 2) + 1 + from;
} else {
to = (to - from) / 2 + from;
}
}
for (int i = from; i <= to; i++) {
if (m < b[i]) return i;
}
return to + 1;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e16;
long long lis(vector<long long> const& a) {
long long n = a.size();
vector<long long> d(n + 1, INF);
d[0] = -INF;
for (long long i = 0; i < n; i++) {
long long j = upper_bound(d.begin(), d.end(), a[i]) - d.begin();
if (d[j - 1] < a[i] && a[i] < d[j]) d[j] = a[i];
}
long long ans = 0;
for (long long i = 0; i <= n; i++)
if (d[i] < INF) ans = i;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> vec(n);
for (long long i = 0; i < n; i++) cin >> vec[i];
cout << lis(vec) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ss[100010] = {0}, top = 0;
for (int i = 0; i < n; i++) {
int in;
cin >> in;
if (in > ss[top]) {
ss[++top] = in;
} else {
int pos = lower_bound(ss, ss + top + 1, in) - ss;
ss[pos] = in;
}
}
cout << top << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 20;
int a[M], lis[M], sz;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int ind = lower_bound(lis, lis + sz, a[i]) - lis;
lis[ind] = a[i];
if (ind == sz) sz++;
}
cout << sz << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long infLL = 0x3f3f3f3f3f3f3f3fLL;
const int hash_mod = 1000037;
const int maxn = 100000 + 5;
int n;
int a[maxn], g[maxn];
int main() {
int res = 0;
scanf("%d", &n);
memset(g, 0x3f, sizeof(g));
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
int k = lower_bound(g + 1, g + n + 1, x) - g;
res = max(res, k);
g[k] = x;
}
printf("%d\n", res);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
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];
}
set<int> s;
for (int i = 0; i < n; i++) {
set<int>::iterator it;
if (s.insert(a[i]).second) {
it = s.find(a[i]);
it++;
if (it != s.end()) {
s.erase(*it);
}
}
}
cout << s.size() << "\n";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
int GETi() {
int i;
scanf("%d", &i);
return i;
}
template <class T>
T sqr(T val) {
return val * val;
}
int N;
vector<int> A;
void solve() {
int f, r, i, j, k, l, x, y, y2;
cin >> N;
for (i = 0; i < N; i++) A.push_back(GETi() - 1);
vector<int> AA(N, N + 1);
vector<int> ID(N);
for (i = 0; i < N; i++) {
vector<int>::iterator it = lower_bound(AA.begin(), AA.end(), A[i]);
ID[i] = distance(AA.begin(), it);
AA[ID[i]] = A[i];
}
printf("%d\n", 1 + *max_element(ID.begin(), ID.end()));
return;
}
int main(int argc, char** argv) {
if (argc > 1) freopen(argv[1], "r", stdin);
solve();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int a[MAXN];
vector<int> v;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int l = lower_bound(v.begin(), v.end(), a[i]) - v.begin();
if (l == v.size())
v.push_back(a[i]);
else
v[l] = a[i];
}
cout << v.size() << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T min(const T& a, const T& b, const T& c) {
return min(min(a, b), min(a, c));
}
template <class T>
T max(const T& a, const T& b, const T& c) {
return max(max(a, b), max(a, c));
}
void debug() {}
int getch() {
int ch;
while ((ch = getchar()) != EOF) {
if (ch != ' ' && ch != ' ') return ch;
}
return EOF;
}
int dp[100100];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
int maxx = 0;
for (int i = 1; i <= n; i++) {
int v;
scanf("%d", &v);
int pos = lower_bound(dp, dp + maxx, v) - dp;
if (pos == maxx) {
dp[maxx++] = v;
} else
dp[pos] = v;
}
printf("%d\n", maxx);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
class fenwick_tree {
private:
int N;
int* bit;
public:
fenwick_tree(int n) {
N = n;
bit = new int[N + 1];
for (int i = 0, _n = (int)N + 1; i < _n; i++) bit[i] = 0;
}
void update(int x, int v) {
for (int i = x; i <= N; i += i & -i) bit[i] = max(bit[i], v);
}
int query(int x) {
int res = 0;
for (int i = x; i; i -= i & -i) res = max(res, bit[i]);
return res;
}
};
int N;
int pos[100005];
int main() {
cin >> N;
fenwick_tree ft(N);
for (int i = 0, _n = (int)N; i < _n; i++) {
int x;
cin >> x;
pos[x - 1] = i + 1;
}
int res = 0;
for (int i = 0, _n = (int)N; i < _n; i++) {
int cur = 1 + ft.query(pos[i]);
res = max(res, cur);
ft.update(pos[i], cur);
}
cout << res << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int LIS(const vector<int>& a) {
vector<int> v;
v.push_back(-1);
for (int i = 0; i < a.size(); i++)
if (a[i] > v.back())
v.push_back(a[i]);
else
*lower_bound(v.begin(), v.end(), a[i]) = a[i];
return (int)v.size() - 1;
}
int main() {
int a, n;
vector<int> v;
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
cout << LIS(v) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005], d[100005];
int f(int s, int q) {
int l, r, m, ans;
l = 1;
r = s;
while (l <= r) {
m = (l + r) >> 1;
if (d[m] > q) {
ans = m;
r = m - 1;
} else {
l = m + 1;
}
}
return ans;
}
int lis(void) {
int ans, i, x;
ans = 1;
d[1] = a[1];
for (i = 2; i <= n; i++) {
if (a[i] < d[1])
d[1] = a[i];
else if (a[i] > d[ans])
d[++ans] = a[i];
else {
x = f(ans, a[i]);
d[x] = a[i];
}
}
return ans;
}
int main() {
int i;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
cout << lis() << endl;
return 0;
}
| 8 | CPP |
def lis(a):
b = []
for c in a:
# if len(b) == 0 or c > b[-1]
if len(b) == 0 or c > b[-1]:
b.append(c)
else:
l = 0
r = len(b)
while l < r-1:
m = l+r>>1
# if b[m] <= c: l = m
if b[m] < c: l = m
else: r = m
# if b[l] <= c: l += 1
if b[l] < c: l += 1
b[l] = c
return len(b)
n = int(input())
a = list(map(int, input().split()))
print(lis(a))
# Made By Mostafa_Khaled | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int MAXN = 100005;
int ar[MAXN];
int bs[MAXN];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", ar + i);
}
int best = 1;
bs[1] = ar[0];
for (int i = 1; i < n; i++) {
if (ar[i] > bs[best]) {
bs[++best] = ar[i];
} else if (ar[i] < bs[1]) {
bs[1] = ar[i];
} else {
int l = 1;
int r = best;
while (l < r) {
int m = (l + r + 1) / 2;
if (ar[i] > bs[m])
l = m;
else
r = m - 1;
}
bs[l + 1] = ar[i];
}
}
printf("%d\n", best);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int ar[1000000 + 100];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &ar[i]);
vector<int> v;
v.push_back(ar[0]);
for (int i = 1; i < n; i++) {
auto x = lower_bound(v.begin(), v.end(), ar[i]);
if (x == v.end())
v.push_back(ar[i]);
else
*x = ar[i];
}
cout << v.size();
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int idx;
const int N = 1e5;
stack<int> sk[N];
int a[N];
int n;
int FindIndx(int x) {
int l = 0, r = idx, m, ans = -1;
while (l <= r) {
m = (l + r) >> 1;
if (sk[m].top() > x) {
ans = m;
r = m - 1;
} else
l = m + 1;
}
return ans;
}
void FindLIS() {
idx = 0;
sk[idx].push(a[0]);
for (int i = 1; i < n; i++) {
int curidx = FindIndx(a[i]);
if (curidx == -1) {
idx++;
sk[idx].push(a[i]);
} else {
sk[curidx].push(a[i]);
}
}
cout << idx + 1 << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
FindLIS();
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 922337203685477;
const long long mininf = -922337203685477;
const long long nax = 1e5 + 5;
long long n, a[nax], bit[nax];
long long sum(long long x) {
long long ret = 0;
for (long long i = x; i > 0; i -= i & -i) {
ret = max(ret, bit[i]);
}
return ret;
}
long long upd(long long x, long long y) {
for (long long i = x; i <= n; i += i & -i) {
bit[i] = max(bit[i], y);
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = 0, cnt = 0;
for (long long i = 0; i < n; i++) {
cnt = sum(a[i] - 1);
ans = max(ans, cnt + 1);
upd(a[i], cnt + 1);
}
cout << ans << '\n';
}
| 8 | CPP |
#include <bits/stdc++.h>
const int maxn = 100010;
int a[maxn + 1];
int f[maxn + 1];
int result;
int n;
void ins(int x, int v) {
while (x <= n) {
if (v > f[x]) f[x] = v;
x += (x & (x ^ (x - 1)));
}
}
int ask(int x) {
int v = 0;
while (x) {
if (f[x] > v) v = f[x];
x -= (x & (x ^ (x - 1)));
}
return v;
}
void init() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
}
void work() {
int i, j;
result = 0;
for (i = 1; i <= n; ++i) {
j = 1 + ask(a[i] - 1);
if (j > result) result = j;
ins(a[i], j);
}
}
void output() { printf("%d\n", result); }
int main() {
init();
work();
output();
return 0;
}
| 8 | CPP |
def lis(a):
b = []
for c in a:
# if len(b) == 0 or c > b[-1]
if len(b) == 0 or c > b[-1]:
b.append(c)
else:
l = 0
r = len(b)
while l < r-1:
m = l+r>>1
# if b[m] <= c: l = m
if b[m] < c: l = m
else: r = m
# if b[l] <= c: l += 1
if b[l] < c: l += 1
b[l] = c
return len(b)
n = int(input())
a = list(map(int, input().split()))
print(lis(a))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int in[100005];
set<pair<int, int> > S;
set<pair<int, int> >::iterator it;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", in + i);
S.insert(make_pair(0, 0));
for (int i = 0; i < n; ++i) {
S.insert(make_pair(in[i], 0));
it = S.find(make_pair(in[i], 0));
--it;
int a = (*it).second;
++a;
++it;
S.erase(it);
S.insert(make_pair(in[i], a));
it = S.find(make_pair(in[i], a));
++it;
while (it != S.end()) {
if ((*it).second <= a) {
S.erase(it);
it = S.find(make_pair(in[i], a));
++it;
continue;
}
break;
}
}
int rez = 0;
for (it = S.begin(); it != S.end(); ++it) {
rez = max(rez, (*it).second);
}
printf("%d\n", rez);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
FILE *in;
FILE *out;
const int MAX = 131072;
const int TREE = 262144;
int n;
int a[MAX];
int tree[TREE];
void update(int idx, int val) {
idx += (TREE >> 1);
while (idx) {
tree[idx] = max(tree[idx], val);
idx >>= 1;
}
}
int query(int idx) {
idx += (TREE >> 1);
int ret = tree[idx];
bool flag = !(idx & 1);
idx >>= 1;
while (idx) {
if (flag) ret = max(ret, tree[(idx << 1) + 1]);
flag = !(idx & 1);
idx >>= 1;
}
return ret;
}
int lis() {
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
int cur = query(a[i] + 1) + 1;
ans = max(ans, cur);
update(a[i], cur);
}
return ans;
}
int main(void) {
in = stdin;
out = stdout;
fscanf(in, "%d", &n);
for (int i = 0; i < n; i++) fscanf(in, "%d", &a[i]);
fprintf(out, "%d\n", lis());
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100009];
int dp[100009];
int n;
int binary_sch(int l, int h, int val) {
int md;
while (l < h) {
md = (l + h) / 2;
if (dp[md] < val) {
l = md + 1;
} else
h = md;
}
return h;
}
int LIS() {
dp[0] = a[0];
int len = 1;
for (int i = 1; i < n; i++) {
if (a[i] < dp[0]) {
dp[0] = a[i];
} else if (a[i] > dp[len - 1]) {
dp[len++] = a[i];
} else {
int p = binary_sch(0, len - 1, a[i]);
dp[p] = a[i];
}
}
return len;
}
int main() {
cin >> n;
for (int i = 0; i <= n - 1; i++) {
cin >> a[i];
}
printf("%d\n", LIS());
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const string nl = "\n";
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
long long n;
cin >> n;
vector<long long> a(n);
for (auto& i : a) {
cin >> i;
}
vector<long long> dp;
for (long long i = 0; i < n; ++i) {
auto it = lower_bound(dp.begin(), dp.end(), a[i]);
if (it == dp.end()) {
dp.push_back(a[i]);
} else {
*it = a[i];
}
}
cout << ((long long)(dp).size()) << nl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <typename T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <typename T>
T max(T a, T b, T c, T d) {
return max(a, max(b, max(c, d)));
}
template <typename T>
void read(vector<T> &arr, long long N) {
arr.clear();
arr.resize(N);
for (long long i = 0; i < N; i++) cin >> arr[i];
}
template <typename T>
void read(vector<pair<T, T>> &arr, long long N) {
arr.clear();
arr.resize(N);
for (long long i = 0; i < (long long)arr.size(); i++)
cin >> arr[i].first >> arr[i].second;
}
template <typename T>
void read(vector<vector<T>> &arr, long long N, long long M) {
arr.clear();
arr.resize(N, vector<T>(M));
for (long long i = 0; i < N; i++) {
for (long long j = 0; j < M; j++) cin >> arr[i][j];
}
}
template <typename T, size_t N>
long long SIZE(const T (&t)[N]) {
return N;
}
template <typename T>
long long SIZE(const T &t) {
return t.size();
}
string to_string(const string s, long long x1 = 0, long long x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(const bool b) { return (b ? "true" : "false"); }
string to_string(const char c) { return string({c}); }
template <size_t N>
string to_string(const bitset<N> &b, long long x1 = 0, long long x2 = 1e9) {
string t = "";
for (long long __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(const A(&v), long long x1 = 0, long long x2 = 1e9,
C... coords);
long long l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B>
string to_string(const pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(const A(&v), long long x1, long long x2, C... coords) {
long long rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0) res += '\n';
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += '\n';
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0) res += '\n';
return res;
}
void printm() { ; }
template <typename Heads, typename... Tails>
void printm(Heads H, Tails... T) {
cout << to_string(H) << " | ";
printm(T...);
}
bool lexi(string &s1, string &s2) {
long long I = s1.size(), J = s2.size(), i = 0, j = 0;
while (i < I and j < J) {
if (s1[i] > s2[j]) return true;
if (s1[i] < s2[j]) return false;
i++;
j++;
}
if (I >= J) return true;
return false;
}
struct uf {
vector<long long> par, size;
void init(long long N) {
par.resize(N, -1);
size.resize(N, 1);
}
long long root(long long a) {
if (par[a] == -1) return a;
return par[a] = root(par[a]);
}
void unite(long long a, long long b) {
a = root(a);
b = root(b);
if (a == b) return;
if (size[a] < size[b]) {
par[a] = b;
size[b] += size[a];
} else {
par[b] = a;
size[a] += size[b];
}
}
bool same(long long a, long long b) {
if (root(a) == root(b)) return true;
return false;
}
};
struct seg_tree {
vector<long long> make;
long long siz;
vector<long long> arr;
void init(vector<long long> &a, bool max, bool range) {
arr.clear();
make.clear();
arr = a;
siz = arr.size();
make.resize(4 * siz);
if (max)
build_max(0, 0, siz - 1);
else if (range)
build_range(0, 0, siz - 1);
}
long long get_max(long long L, long long R) {
return Get_max(0, 0, siz - 1, L, R);
}
void update_max(long long index, long long val) {
Update_max(0, 0, siz - 1, index, val);
return;
}
long long get_sum(long long L, long long R) {
return Get_sum(0, 0, siz - 1, L, R);
}
void update_range(long long index, long long add) {
Update_range(0, 0, siz - 1, index, add);
return;
}
long long build_range(long long ind, long long L, long long R) {
if (L == R) {
make[ind] = arr[L];
return make[ind];
} else {
long long mid = (L + R) / 2;
long long a = build_range(2 * ind + 1, L, mid);
long long b = build_range(2 * ind + 2, mid + 1, R);
make[ind] = a + b;
return make[ind];
}
}
long long Get_sum(long long ind, long long L, long long R, long long Left,
long long Right) {
if (L > Right or R < Left) return 0;
if (Left <= L and R <= Right) return make[ind];
long long mid = (L + R) / 2;
long long a = Get_sum(2 * ind + 1, L, mid, Left, Right);
long long b = Get_sum(2 * ind + 2, mid + 1, R, Left, Right);
return a + b;
}
void Update_range(long long ind, long long L, long long R, long long index,
long long add) {
if (L == R) {
make[ind] = add;
arr[index] = add;
} else {
long long mid = (L + R) / 2;
if (L <= index and index <= R) {
Update_range(2 * ind + 1, L, mid, index, add);
} else {
Update_range(2 * ind + 2, mid + 1, R, index, add);
}
make[ind] = make[2 * ind + 1] + make[2 * ind + 2];
}
}
long long build_max(long long ind, long long L, long long R) {
if (L == R) {
make[ind] = arr[L];
return make[ind];
} else {
long long mid = (L + R) / 2;
return make[ind] = max(build_max(2 * ind + 1, L, mid),
build_max(2 * ind + 2, mid + 1, R));
}
}
long long Get_max(long long ind, long long L, long long R, long long Left,
long long Right) {
if (R < Left or L > Right) return -1e15;
if (Left <= L and R <= Right) return make[ind];
long long mid = (L + R) / 2;
return max(Get_max(2 * ind + 1, L, mid, Left, Right),
Get_max(2 * ind + 2, mid + 1, R, Left, Right));
}
long long Update_max(long long ind, long long L, long long R, long long index,
long long val) {
if (L == R) {
arr[index] = val;
make[ind] = val;
return val;
} else {
long long mid = (L + R) / 2;
if (L <= index and index <= mid) {
make[ind] = Update_max(2 * ind + 1, L, mid, index, val);
} else {
make[ind] = Update_max(2 * ind + 2, mid + 1, R, index, val);
}
make[ind] = max(make[2 * ind + 1], make[2 * ind + 2]);
return make[ind];
}
}
};
static bool comp(pair<long long, long long> &a, pair<long long, long long> &b) {
if (a.first < b.first) return true;
if (a.first == b.first) {
if (a.second < b.second) return true;
}
return false;
}
static bool comp1(vector<long long> &a, vector<long long> &b) {
if (a[0] < b[0]) return true;
if (a[0] == b[0] and a[1] > b[1]) return true;
return false;
}
long long Max = 1e17, Min = -1e15;
long long N, M, K, D;
long long mod = 1e9;
long long P = 93;
void solve() {
cin >> N;
vector<long long> arr(N);
for (long long i = 0; i < N; i++) {
cin >> arr[i];
--arr[i];
}
vector<long long> cnt(N);
seg_tree var;
var.init(cnt, true, false);
for (long long i = 0; i < N; i++) {
long long val = var.get_max(0, arr[i]) + 1;
var.update_max(arr[i], val);
}
long long ans = 0;
for (auto it : var.arr) {
ans = max(ans, it);
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
auto start_time = chrono::high_resolution_clock::now();
bool test = 0;
if (!test)
solve();
else {
long long tt;
cin >> tt;
while (tt--) solve();
}
auto end_time = chrono::high_resolution_clock::now();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int ri() {
register char c;
while (1) {
c = getchar();
if (c >= '0' && c <= '9') break;
}
register int x = 0;
while (1) {
x = x * 10 + c - 48;
c = getchar();
if (c < '0' || c > '9') return x;
}
}
int n, x[100010];
vector<vector<int>> s;
vector<int> cur;
int main() {
n = ri();
for (int i = 0; i < n; i++) x[i] = ri();
for (int i = 0; i < n; i++) {
auto j = lower_bound(cur.begin(), cur.end(), x[i]) - cur.begin();
if (j == cur.size()) {
s.push_back({});
cur.push_back({});
} else if (cur[j] == x[i])
continue;
s[j].push_back(x[i]);
cur[j] = x[i];
}
cout << s.size() << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int N, l, r, now;
int a[100010];
int main() {
scanf("%d", &N);
a[0] = 10000000;
now = 0;
for (int i = 0, c; i < N; i++) {
scanf("%d", &c);
l = 0;
r = now;
while (l < r) {
int mid = (l + r) >> 1;
if (c >= a[mid])
l = mid + 1;
else
r = mid;
}
if (a[l] <= c) l++;
a[l] = c;
if (l > now) now = l;
}
printf("%d\n", now + 1);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int seq[100010];
int main() {
int n;
while (scanf("%d", &n) > 0) {
int L = 0;
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
if (L == 0 or seq[L - 1] < a) {
seq[L++] = a;
continue;
}
int lo = 0, up = L - 1, j;
while (lo <= up) {
int mid = (lo + up) >> 1;
if (seq[mid] < a) {
lo = mid + 1;
} else {
up = mid - 1;
j = mid;
}
}
seq[j] = a;
}
printf("%d\n", L);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int a[maxn];
int g[maxn];
int d[maxn];
int main(int argc, char *argv[]) {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i <= n; ++i) g[i] = 1000000000;
for (int i = 0; i < n; ++i) {
int k = lower_bound(g + 1, g + n + 1, a[i]) - g;
d[i] = k;
g[k] = a[i];
}
int ans = 1;
for (int i = 0; i < n; i++) ans = max(ans, d[i]);
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
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;
}
int main() {
std::vector<int> v;
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
v.push_back(x);
}
std::cout << LongestIncreasingSubsequenceLength(v) << '\n';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = int(1e9 + 7);
const double PI = acos(-1.0);
int n, i, j, d[100010], a[100010];
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
d[0] = -1000000000;
for (i = 1; i <= n; i++) d[i] = 1000000000;
for (i = 0; i < n; i++) {
j = (int)(upper_bound(d, d + n, a[i]) - d);
if (d[j - 1] < a[i] && d[j] > a[i]) d[j] = a[i];
}
for (i = 1; i <= n; i++)
if (d[i] == 1000000000) break;
cout << i - 1;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int a[1000000];
int n;
int dp[1000000];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i <= n; i++) {
dp[i] = inf;
}
for (int i = 0; i < n; i++) {
int k = upper_bound(dp, dp + n + 1, a[i]) - dp;
dp[k] = a[i];
}
int ans = 0;
for (int i = 0; i <= n; i++) {
if (dp[i] != inf) {
ans = i + 1;
}
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100 * 1000 + 10;
int a[max_n];
vector<int> lis;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int pos = lower_bound(lis.begin(), lis.end(), a[i]) - lis.begin();
if (pos == lis.size())
lis.push_back(a[i]);
else
lis[pos] = a[i];
}
cout << lis.size() << '\n';
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 1, now = 1, INF = (int)1e9;
cin >> n;
vector<int> A(n), D((int)1e7, INF);
for (int i = 0; i < n; i++) cin >> A[i];
D[0] = -INF;
for (int i = 0; i < n; i++) {
int j = int(upper_bound(D.begin(), D.end(), A[i]) - D.begin());
if (D[j - 1] < A[i] && A[i] < D[j]) D[j] = A[i];
}
for (int i = 1; i < (int)1e7; ans = (D[i] != INF ? i : ans), i++)
;
cout << ans;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
int a[N], n, q[N], s, t;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int v;
cin >> v;
int l = s, r = t;
while (l <= r) {
int mid = (l + r) >> 1;
if (q[mid] < v)
l = mid + 1;
else
r = mid - 1;
}
if (r == t)
q[++t] = v;
else
q[r + 1] = min(q[r + 1], v);
}
cout << t << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> s;
vector<int>::iterator it;
int v[100001];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", v + i);
s.reserve(100000);
for (int i = 0; i < n; ++i) {
it = lower_bound(s.begin(), s.end(), v[i]);
if (it == s.end())
s.push_back(v[i]);
else
*it = v[i];
}
if (s.size() == 1) s.clear();
printf("%d", s.size());
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int n, ft[N + 5];
pair<int, int> arr[N + 5];
void update(int l, int k) {
for (; l <= N; l += (l) & (-l)) ft[l] = max(ft[l], k);
return;
}
int get(int l) {
int ret = 0;
for (; l >= 1; l -= (l) & (-l)) ret = max(ret, ft[l]);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
arr[i] = make_pair(a, i);
}
sort(arr + 1, arr + n + 1);
int ans = 0;
for (int i = 1; i <= n; i++) {
int temp = get(arr[i].second - 1) + 1;
update(arr[i].second, temp);
ans = max(ans, get(arr[i].second - 1) + 1);
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
const double EPS = 1e-6;
int dp[100005];
static int topp;
void LIS(int x) {
if (topp == 0)
dp[topp++] = x;
else if (x > dp[topp - 1])
dp[topp++] = x;
else {
int left = 0, right = topp;
while (left < right) {
int mid = (left + right) >> 1;
if (dp[mid] > x)
right = mid;
else
left = mid + 1;
}
while (left < topp - 1 && dp[left] == dp[left + 1]) left++;
dp[left] = x;
}
}
int main() {
int n;
scanf("%d", &n);
::topp = 0;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
LIS(a);
}
printf("%d\n", topp);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100005;
int tree[maxN * 4];
int query(int t, int l, int r, int x, int y) {
if (x > r || y < l) return -1;
if (l >= x && r <= y) return tree[t];
int m = (l + r) / 2;
return max(query(t * 2 + 1, l, m, x, y), query(t * 2 + 2, m + 1, r, x, y));
}
void update(int t, int l, int r, int index, int value) {
if (l == r) {
tree[t] = value;
return;
}
int m = (l + r) / 2;
if (index <= m)
update(t * 2 + 1, l, m, index, value);
else
update(t * 2 + 2, m + 1, r, index, value);
tree[t] = max(tree[t * 2 + 1], tree[t * 2 + 2]);
}
int main() {
int n;
scanf("%d", &n);
vector<int> a(n), d(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
d[i] = query(0, 0, n - 1, 0, a[i] - 1) + 1;
update(0, 0, n - 1, a[i] - 1, d[i]);
if (d[i] > ans) ans = d[i];
}
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
int a[100005], d[100005];
void cal() {
d[1] = a[1];
int len = 1;
for (int i = 2; i <= n; i++) {
if (a[i] >= d[len])
d[++len] = a[i];
else {
int j = upper_bound(d + 1, d + len + 1, a[i]) - d;
d[j] = a[i];
}
}
cout << len << endl;
}
int main() {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%d", a + i);
}
cal();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100010], c[100010], len;
int find(int L, int R, int x) {
if (L == R) return L;
int mid = (L + R) >> 1;
if (c[mid] < x)
return find(mid + 1, len, x);
else
return find(L, mid, x);
}
int main() {
int i, n, t, m, T, b, k, ans, j, max;
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n; i++) scanf("%d", &a[i]);
len = 0;
c[0] = -100000000;
for (i = 0; i < n; i++) {
if (a[i] > c[len])
j = ++len;
else
j = find(1, len, a[i]);
c[j] = a[i];
}
printf("%d\n", len);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
int main() {
int n, i, elem;
cin >> n;
vector<int> A(n);
vector<int> B(n + 1, INF);
for (i = 0; i < n; ++i) {
cin >> elem;
*upper_bound(B.begin(), B.end(), elem) = elem;
}
int ans = 0;
for (i = 0; i < n; ++i)
if (B[i] < INF) ans++;
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[333333];
int f[333333];
int main() {
int n;
scanf("%d", &n);
long long sum = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int t = 0;
for (int i = 1; i <= n; i++) {
if (a[i] >= f[t])
f[++t] = a[i];
else {
int idx = lower_bound(f + 1, f + t + 1, a[i]) - f;
f[idx] = a[i];
}
}
cout << t;
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.