solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
set<int> myset;
int main(int argc, char** argv) {
int n, x;
cin >> n;
auto it = myset.begin();
for (int i = 0; i < n; i++) {
cin >> x;
myset.insert(x);
it = myset.find(x);
it++;
if (it != myset.end()) myset.erase(it);
}
cout << ((int)(myset).size()) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6, inf = 1e9;
int a[N + 10], dp[N + 10];
int main() {
int n, l;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int j = upper_bound(dp, dp + l, a[i]) - dp;
if (l == j) l++;
dp[j] = a[i];
}
cout << l;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846264338327950288419716939937511;
const double eps = 1e-9;
char ch_ch_ch[1 << 20];
inline string gs() {
scanf("%s", ch_ch_ch);
return string(ch_ch_ch);
}
inline string gl() {
gets(ch_ch_ch);
return string(ch_ch_ch);
}
inline int gi() {
int x;
scanf("%d", &x);
return x;
}
const int inf = 1000000000;
template <typename T>
class FenwickSummator {
private:
T* fenv;
int n;
public:
FenwickSummator(int N) {
n = N;
fenv = new T[N + 1];
memset(fenv, 0, (N + 1) * sizeof(T));
}
void add(int p, T val) {
if (p < 0 || p >= n) return;
for (++p; p <= n; p += p & -p) fenv[p] = max(fenv[p], val);
}
T maxi(int p) {
if (p < 0) return 0;
if (p >= n) p = n - 1;
T res = 0;
for (++p; p > 0; p -= p & -p) res = max(res, fenv[p]);
return res;
}
~FenwickSummator() { delete[] fenv; }
};
int a[100100];
FenwickSummator<int> fenv(100100);
int n;
void solution() {
n = gi();
for (int i = 0; i < (n); ++i) a[i] = gi();
int res = 0;
for (int i = 0; i < (n); ++i) {
int cur = fenv.maxi(a[i] - 1);
fenv.add(a[i], cur + 1);
res = max(res, cur + 1);
}
cout << res << endl;
}
int main(int argc, char** argv) {
solution();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int maxn = 100000 + 9;
int n;
int num[maxn], d[maxn], Left, Right, mid, l;
int main() {
while (scanf("%d", &n) == 1) {
for (int i = 1; i <= n; ++i) scanf("%d", &num[i]);
memset(d, 0, sizeof(d));
d[0] = -inf;
d[1] = inf;
l = 0;
for (int i = 1; i <= n; ++i) {
Left = 0;
Right = l + 1;
while (Left < Right) {
if (Left + 1 == Right) {
if (d[Right] < num[i]) Left = Right;
break;
}
mid = (Left + Right + 1) >> 1;
if (d[mid] < num[i])
Left = mid;
else
Right = mid - 1;
}
if (Left == l) {
d[++l + 1] = inf;
}
d[Left + 1] = num[i];
}
printf("%d\n", l);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const double infd = 2e+9;
const int infi = INT_MAX;
template <class T>
inline T sqr(T x) {
return x * x;
}
int main() {
ios_base::sync_with_stdio(false);
vector<int> a, d;
int n;
cin >> n;
a.resize(n);
d.resize(n, infi);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int x = upper_bound(d.begin(), d.end(), a[i]) - d.begin();
d[x] = a[i];
}
cout << (lower_bound(d.begin(), d.end(), infi) - d.begin());
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 10;
int d[mx];
int ft[mx];
void upd(int i, int v) {
i = mx - i - 2;
for (; i < mx; i += (i & -i)) ft[i] = max(ft[i], v);
}
int qry(int i) {
int a = 0;
i = mx - i - 2;
for (; i > 0; i -= (i & -i)) a = max(a, ft[i]);
return a;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", d + i);
}
int ans = 1;
for (int i = n - 1; i >= 0; i--) {
int fi = 1 + qry(d[i]);
ans = max(ans, fi);
upd(d[i], fi);
}
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int main() {
int i, j, n, top, tmp;
int stack[maxn];
cin >> n;
top = 0;
stack[0] = 0;
for (i = 0; i < n; i++) {
cin >> tmp;
if (tmp > stack[top]) {
stack[++top] = tmp;
} else {
int low = 1, high = top;
int mid;
while (low <= high) {
mid = (low + high) / 2;
if (tmp > stack[mid]) {
low = mid + 1;
} else {
high = mid - 1;
}
}
stack[low] = tmp;
}
}
cout << top << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005];
int n;
int main() {
scanf("%d\n", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
b[0] = -1000000;
for (int i = 1; i <= n; i++) {
b[i] = 1000000;
}
for (int i = 0; i < n; i++) {
int j = upper_bound(b, b + n, a[i]) - b;
if (b[j - 1] < a[i] && b[j] > a[i]) {
b[j] = a[i];
}
}
for (int i = n; i >= 1; i--) {
if (b[i] < 1000000) {
printf("%d\n", i);
return 0;
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int scanst(char *a) {
int i = 0;
char c = 0;
while (c < 33) c = getchar();
while (c > 33) {
a[i++] = c;
c = getchar();
}
a[i] = 0;
return i;
}
template <typename T>
bool scan(T &n) {
n = 0;
bool got = false;
bool negative = false;
char c = getchar();
if (c == EOF) return false;
while (c<'0' | c> '9') {
if (c == '-') negative = true;
c = getchar();
}
while (c >= '0' && c <= '9') {
got = true;
n = n * 10 + c - 48;
c = getchar();
}
if (negative) n = ~(n - 1);
return got;
}
template <typename T>
inline T GCD(T a, T b) {
a = abs(a);
b = abs(b);
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
template <typename T>
inline T LCM(T x, T y) {
T tp = GCD(x, y);
if ((x / tp) * 1. * y > 9e18) return 9e18;
return (x / tp) * y;
}
template <typename T>
inline T BigMod(T A, T B, T M) {
T ret = 1;
while (B) {
if (B & 1) ret = (ret * A) % M;
A = (A * A) % M;
B = B >> 1;
}
return ret;
}
template <typename T>
inline T InvMod(T A, T M) {
return BigMod(A, M - 2, M);
}
int gcdr(int a, int b) {
if (a == 0) return b;
return gcdr(b % a, a);
}
void FastIO() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
}
int main() {
FastIO();
int n, m, p, q, i, j;
while (cin >> n) {
int arr[100005] = {0};
for (i = 0; i <= n - 1; i++) cin >> arr[i];
vector<int> ans;
for (i = 0; i <= n - 1; i++) {
if (ans.size() == 0) {
ans.push_back(arr[i]);
} else {
auto index = lower_bound(ans.begin(), ans.end(), arr[i]) - ans.begin();
auto index2 = lower_bound(ans.begin(), ans.end(), arr[i]);
if (index2 == ans.end())
ans.push_back(arr[i]);
else {
ans[index] = arr[i];
}
}
}
cout << ans.size() << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int c[100010], n, a[100010];
int lowbit(int x) { return x & (-x); }
void update(int x, int val) {
for (int i = x; i; i -= lowbit(i)) c[i] = max(c[i], val);
}
int qmax(int x) {
int ret = 0;
for (int i = x; i <= n; i += lowbit(i)) ret = max(ret, c[i]);
return ret;
}
int main() {
int k, ans;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
memset(c, 0, sizeof(c));
ans = 0;
for (int i = n; i >= 1; i--) {
k = qmax(a[i]);
ans = max(ans, k + 1);
update(a[i], k + 1);
}
cout << ans << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> v(100010, INT_MAX);
int main() {
ios_base::sync_with_stdio(0);
int n, a;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
*lower_bound(v.begin(), v.end(), a) = a;
}
for (int i = 0; i <= n; i++)
if (v[i] == INT_MAX) {
cout << i << "\n";
return 0;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 101110;
int n;
int a[N], s[N], f[N];
void update(int x, int v) {
for (; x <= n; x += x & -x) s[x] = max(s[x], v);
}
int cal(int x) {
int r = 0;
for (; x > 0; x -= x & -x) r = max(r, s[x]);
return r;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int r = 0;
for (int i = 1; i <= n; i++) {
f[i] = cal(a[i] - 1) + 1;
update(a[i], f[i]);
r = max(r, f[i]);
}
cout << r << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int len;
int s[100005];
int dpi[100005];
int dp[100005];
int last[100005];
int ans[100005];
int main() {
scanf("%d", &len);
for (int i = 0; i < len; i++) scanf("%d", &s[i]);
int max = 0;
memset(dp, 0, sizeof(dp));
for (int i = 0; i < len; i++) {
int k = lower_bound(dp, dp + max, s[i]) - dp;
if (k == max) {
dp[max] = s[i];
dpi[max] = i;
last[i] = dpi[max - 1];
max++;
} else {
dp[k] = s[i];
dpi[k] = i;
last[i] = dpi[k - 1];
}
}
printf("%d\n", max);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 2e5 + 10;
int n, temp;
vector<int> ans;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> temp;
int pos = lower_bound(ans.begin(), ans.end(), temp) - ans.begin();
if (pos == ans.size())
ans.push_back(temp);
else
ans[pos] = temp;
}
cout << ans.size() << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
const int INF = 1000000000;
int n, a;
int d[MAXN];
int main() {
d[0] = -INF;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) d[i] = INF;
for (int i = 0; i < n; ++i) {
scanf("%d", &a);
int pos = (upper_bound(d, d + n, a) - d);
if (d[pos - 1] < a && a < d[pos]) {
d[pos] = a;
}
}
int res = 1;
for (int i = 1; i <= n; ++i)
if (d[i] <= n) res = i;
cout << res << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 20;
int a[N];
vector<int> dp;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
int indx = lower_bound(dp.begin(), dp.end(), a[i]) - dp.begin();
if (indx < dp.size())
dp[indx] = a[i];
else
dp.push_back(a[i]);
}
cout << dp.size();
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N = 1e6 + 2;
int a[100010];
vector<int> bit(1e6 + 2);
void update(int i, int val) {
while (i < N) {
bit[i] = max(bit[i], val);
i = i + (i & (-i));
}
}
int query(int i) {
int ret = 0;
while (i) {
ret = max(ret, bit[i]);
i = i - (i & (-i));
}
return ret;
}
int main() {
int i, n, lis = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; ++i) {
int val = query(a[i] - 1);
lis = max(lis, val + 1);
update(a[i], val + 1);
}
cout << lis << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int LIS(vector<int> X) {
int n = X.size(), L = 0, M[n + 1], P[n];
int lo, hi, mi;
L = 0;
M[0] = 0;
for (int i = 0, j; i < n; i++) {
lo = 0;
hi = L;
while (lo != hi) {
mi = (lo + hi + 1) / 2;
if (X[M[mi]] < X[i])
lo = mi;
else
hi = mi - 1;
}
j = lo;
P[i] = M[j];
if (j == L || X[i] < X[M[j + 1]]) {
M[j + 1] = i;
L = max(L, j + 1);
}
}
return L;
}
vector<int> X;
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0, a; i < n; ++i) {
cin >> a;
X.push_back(a);
}
cout << LIS(X) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int LIS(vector<int>& s) {
if (s.size() == 0) return 0;
vector<int> v;
v.push_back(s[0]);
for (int i = 1; i < s.size(); ++i) {
int n = s[i];
if (n > v.back())
v.push_back(n);
else
*lower_bound(v.begin(), v.end(), n) = n;
}
return v.size();
}
int main(void) {
vector<int> input;
int n;
scanf("%d", &n);
while (n--) {
int buff;
scanf("%d", &buff);
input.push_back(buff);
}
printf("%d\n", LIS(input));
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
struct node {
long long val;
int pos;
} temp[MAXN][20];
int dp[MAXN], n, ans;
long long a[MAXN];
void merge_sort(int l, int r, int deep) {
if (l == r) {
temp[l][deep].val = a[l];
temp[l][deep].pos = l;
return;
}
int mid = (l + r) >> 1;
merge_sort(l, mid, deep + 1);
merge_sort(mid + 1, r, deep + 1);
int p1 = l, p2 = mid + 1, p = l;
while (p1 <= mid && p2 <= r) {
if (temp[p1][deep + 1].val < temp[p2][deep + 1].val) {
temp[p++][deep] = temp[p1++][deep + 1];
} else {
temp[p++][deep] = temp[p2++][deep + 1];
}
}
while (p1 <= mid) {
temp[p++][deep] = temp[p1++][deep + 1];
}
while (p2 <= r) {
temp[p++][deep] = temp[p2++][deep + 1];
}
return;
}
void CDQ_divalgorithm(int l, int r, int deep) {
if (l == r) {
dp[l] = max(dp[l], 1);
ans = max(ans, dp[l]);
return;
}
int mid = (l + r) >> 1;
CDQ_divalgorithm(l, mid, deep + 1);
int p1 = l, p2 = mid + 1, nowmaxdp = 0;
while (p1 <= mid && p2 <= r) {
if (temp[p1][deep + 1].val < temp[p2][deep + 1].val) {
nowmaxdp = max(nowmaxdp, dp[temp[p1++][deep + 1].pos]);
} else {
dp[temp[p2][deep + 1].pos] =
max(nowmaxdp + 1, dp[temp[p2][deep + 1].pos]);
p2++;
}
}
while (p2 <= r) {
dp[temp[p2][deep + 1].pos] = max(nowmaxdp + 1, dp[temp[p2][deep + 1].pos]);
p2++;
}
CDQ_divalgorithm(mid + 1, r, deep + 1);
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
}
merge_sort(1, n, 0);
CDQ_divalgorithm(1, n, 0);
printf("%d\n", ans);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[100001];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> arr[i];
set<int> s;
set<int>::iterator it;
for (int i = 0; i < n; i++) {
s.insert(arr[i]);
it = s.find(arr[i]);
it++;
if (it != s.end()) s.erase(it);
}
cout << s.size() << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, ar[100005];
vector<int> A;
template <typename T>
inline void SI(T &n) {
char c = getchar();
n = 0;
for (; (c > 47 && c < 58); c = getchar()) n = 10 * n + c - 48;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
SI(n);
for (int i = 0; i < n; i++) {
SI(ar[i]);
if (!i || ar[i] > A.back())
A.push_back(ar[i]);
else if (ar[i] < A[0])
A[0] = ar[i];
else
A[lower_bound(A.begin(), A.end(), ar[i]) - A.begin()] = ar[i];
}
cout << A.size();
return 0;
}
| 8 | CPP |
from bisect import bisect_right
def answer(n,A):
ans=[A[0]]
for i in range(1,n):
if ans[-1]<A[i]:
ans.append(A[i])
else:
index=bisect_right(ans,A[i])
ans[index]=A[i]
return len(ans)
n=int(input())
arr=list(map(int,input().split()))
print(answer(n,arr)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void deba(int* a, int n) {
cerr << "| ";
for (int i = 0; i < (n); i++) cerr << a[i] << " ";
cerr << "|" << endl;
}
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 30;
int a[123456];
int dp[123456];
int* p;
int main() {
int n;
scanf("%d", &n);
;
for (int i = 0; i < (n); i++) scanf("%d", &a[i]);
;
for (int i = 0; i < (n + 2); i++) dp[i] = INF;
dp[0] = -INF;
dp[1] = a[0];
for (int i = (1); i <= (n - 1); i++) {
p = lower_bound(dp, dp + n, a[i]);
*p = a[i];
}
p = lower_bound(dp, dp + n + 1, INF - 1);
cout << p - dp - 1 << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using std::max;
int N;
int A[100000 + 7];
int F[100000 + 7];
int G[100000 + 7];
int Fa[100000 + 7];
int Max1[100000 + 7];
int Max2[100000 + 7];
int Used[100000 + 7];
int Find(int X) { return X == Fa[X] ? X : Fa[X] = Find(Fa[X]); }
void Init() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", A + i);
}
void Cover(int L, int R) {
if (L > R) return;
for (int i = L; i <= R; i++) {
if (Find(i) == i) {
Used[i] = 1, Fa[i] = i + 1;
} else
i = Find(i) - 1;
}
}
void Work1() {
int Ans = 0;
F[1] = 1;
Max1[1] = 1;
for (int i = 2; i <= N; i++) {
F[i] = 1;
for (int j = 1; j < i; j++)
if (A[j] < A[i] && F[j] + 1 > F[i]) F[i] = F[j] + 1;
if (F[i] > Ans) Ans = F[i];
Max1[i] = (Max1[i - 1] > F[i] ? Max1[i - 1] : F[i]);
}
G[N] = 1;
Max2[N] = 1;
for (int i = N - 1; i >= 1; i--) {
G[i] = 1;
for (int j = N; j > i; j--)
if (A[j] > A[i] && G[j] + 1 > G[i]) G[i] = G[j] + 1;
Max2[i] = (Max2[i + 1] > G[i] ? Max2[i + 1] : G[i]);
}
printf("%d\n", Ans);
for (int i = 2; i <= N; i++)
if (Max1[i - 1] == Ans) Cover(i, i);
for (int i = 1; i < N; i++)
if (Max2[i + 1] == Ans) Cover(i, i);
for (int i = 1; i <= N; i++) {
for (int j = i + 1; j <= N; j++) {
if (F[i] + G[j] == Ans && A[i] < A[j]) Cover(i + 1, j - 1);
}
}
for (int i = 1; i <= N; i++)
if (!Used[i]) printf("%d ", i);
}
struct Part {
int key, val, id;
} Partion[100000 + 7];
int St[100000 + 7];
int Ed[100000 + 7];
int Maxr[100000 + 7];
bool ComparePart(const Part& A, const Part& B) {
return A.key < B.key || A.key == B.key && A.val < B.val;
}
int Len;
int D[100000 + 7];
void Work2() {
int Ans, Answer = 0;
Max1[1] = F[Len = 1] = 1;
D[Len] = A[1];
for (int i = 2; i <= N; i++) {
if (D[Len] < A[i])
D[++Len] = A[i], F[i] = Len;
else {
int L = 1, R = Len, Mid;
for (; L < R;) {
Mid = L + R >> 1;
if (D[Mid] > A[i])
R = Mid;
else
L = Mid + 1;
}
F[i] = L;
D[L] = A[i];
}
Max1[i] = max(Max1[i - 1], F[i]);
}
printf("%d\n", Ans = Answer = Len);
}
int main() {
Init();
for (int i = 1; i <= N + 1; i++) Fa[i] = i;
Work2();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, a, k;
vector<long long> v;
int main() {
cin >> n;
cin >> a;
v.push_back(a);
for (int i = 1; i < n; i++) {
cin >> a;
if (a > v[v.size() - 1])
v.push_back(a);
else {
k = lower_bound(v.begin(), v.end(), a) - v.begin();
v[k] = a;
}
}
cout << v.size() << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
namespace Debug {
void dout() { cerr << "\n"; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << " " << H;
dout(T...);
}
template <typename T>
void dout(const T *a, int n) {
cerr << "\n[";
for (int i = 0; i < n; i++) {
cerr << " " << a[i];
}
cerr << " ]\n";
}
template <typename T>
void dout(T **b, int r, int c) {
for (int i = 0; i < r; i++) {
cerr << "[";
for (int j = 0; j < c; j++) {
cerr << " " << b[i][j];
}
cerr << " ]\n";
}
}
template <typename T>
void dout(const vector<T> v) {
cerr << "\n[";
for (T i : v) {
cerr << " " << i;
}
cerr << " ]\n";
}
template <typename T>
void dout(const vector<vector<T>> v) {
cerr << "\n";
for (vector<T> u : v) {
cerr << "[";
for (T i : u) {
cerr << " " << i;
}
cerr << " ]\n";
}
}
template <typename F, typename S>
void dout(const vector<pair<F, S>> u) {
cerr << "\n";
for (pair<F, S> v : u) {
cerr << "[ " << v.first << " " << v.second << " ]\n";
}
}
} // namespace Debug
using namespace Debug;
const int N = 1e5 + 69;
int n, a[N], BIT[N];
void update(int x, int val) {
for (; x <= n; x += x & -x) {
(BIT[x]) = max((BIT[x]), (val));
;
}
}
int query(int x) {
int res = 0;
for (; x > 0; x -= x & -x) {
(res) = max((res), (BIT[x]));
;
}
return res;
}
int main() {
cin >> n;
memset((BIT), 0, sizeof(BIT));
vector<pair<int, int>> vpi(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
vpi[i] = make_pair(a[i], i);
}
sort(vpi.begin() + 1, vpi.end());
for (int i = 1; i <= n; i++) {
update(vpi[i].second, query(vpi[i].second) + 1);
}
cout << query(n) << '\n';
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 20123;
const int maxn = 211001;
const int INF = 0x7f7f7f7f;
int n;
int a[maxn], b[maxn], sz;
unsigned long long sum[maxn];
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
int binary(int l, int r, int k) {
int m, ans = -1;
while (l <= r) {
m = (l + r) >> 1;
if (b[m] >= k) {
ans = m;
r = m - 1;
} else {
l = m + 1;
}
}
return ans;
}
int cnt = 0;
int main() {
ios::sync_with_stdio(false);
int i;
cin >> n;
for (i = 1; i <= n; ++i) cin >> a[i];
cnt = 1;
b[0] = a[1];
for (i = 2; i <= n; ++i) {
int t = binary(0, cnt - 1, a[i]);
if (t < 0)
b[cnt++] = a[i];
else
b[t] = a[i];
}
printf("%d\n", cnt);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 210000;
const int inf = 1000000000;
int n, a[maxN], d[maxN];
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 j = 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 >= 1; --i) {
if (d[i] < inf) {
printf("%d\n", i);
return 0;
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD9 = 1e9 + 7;
const long long MAX = 1e5 + 10;
const double eps = 0.99;
int tree[4 * MAX];
int a[MAX];
int value = 0, idx = 0;
void update(int node, int start, int end) {
if (start == end) {
a[idx] = value;
tree[node] = value;
return;
}
int mid = (start + end) / 2;
if (start <= idx && idx <= mid)
update(node * 2, start, mid);
else
update(node * 2 + 1, mid + 1, end);
tree[node] = max(tree[node * 2], tree[node * 2 + 1]);
}
int query(int node, int start, int end, int l, int r) {
if (start >= l && end <= r) {
return tree[node];
}
if (end < l || start > r) return 0;
int mid = (start + end) / 2;
int q = query(node * 2, start, mid, l, r);
q = max(q, query(node * 2 + 1, mid + 1, end, l, r));
return q;
}
bool ff[100];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
memset(tree, 0, sizeof(tree));
vector<int> vec;
int ma = INT_MIN;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
vec.push_back(x);
ma = max(x, ma);
}
for (int i = 0; i < n; i++) {
value = query(1, 1, ma, 1, vec[i] - 1) + 1;
idx = vec[i];
update(1, 1, ma);
}
cout << tree[1] << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
template <class T>
void checkmin(T &t, T x) {
if (x < t) t = x;
}
template <class T>
void checkmax(T &t, T x) {
if (x > t) t = x;
}
using namespace std;
const int INF = 0x3fffffff;
const double PI = acos(-1.0);
const double EPS = 1e-9;
const int maxN = 100010;
int a[maxN], c[maxN], 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] = -INF;
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 |
from bisect import bisect_right
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>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int n, T[100011];
int get(int i) {
int res = 0;
while (i) {
res = max(res, T[i]);
i -= i & (-i);
}
return res;
}
void update(int i, int d) {
while (i <= n) {
T[i] = max(T[i], d);
i += i & (-i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = (1), _b = (n); i <= _b; i++) {
int x;
cin >> x;
int k = get(x - 1);
update(x, k + 1);
}
cout << get(n) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[100001], i, n, d[100001], p[100001], ans[100001], q, t, aa[100001];
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> arr[i];
d[0] = -INT_MAX;
for (i = 1; i <= n; i++) d[i] = INT_MAX;
for (i = 0; i < n; i++) {
int j = int(upper_bound(d, d + n, arr[i]) - d);
if ((d[j - 1] < arr[i]) && (d[j] > arr[i])) {
d[j] = arr[i];
p[j] = i;
ans[i] = p[j - 1];
}
}
for (i = 1; i <= n; i++) {
if (d[i] != INT_MAX) t = i;
}
cout << t << endl;
aa[0] = p[t] + 1;
int o = t;
t = p[t];
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100010], ans[100010];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
ans[i] = 1000000;
scanf("%d", &a[i]);
}
ans[n] = 1000000;
ans[0] = -1;
for (int i = 0; i < n; ++i) {
int l = 0;
int r = i + 1;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (ans[mid] < a[i])
l = mid;
else
r = mid;
}
ans[l + 1] = min(ans[l + 1], a[i]);
}
for (int i = n; i > 0; --i)
if (ans[i] < 1000000) {
printf("%d\n", i);
return 0;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const int MAXN = 1e5 + 10;
int v[MAXN];
int lis[MAXN];
int main() {
int n;
scanf("%d", &n);
for (int a = 0; a < n; ++a) scanf("%d", &v[a]);
memset(lis, INF, sizeof(lis));
for (int a = 0; a < n; ++a) {
int i = lower_bound(lis, lis + n, v[a]) - lis;
lis[i] = v[a];
}
int hi = 0;
for (int a = 0; a < n; ++a)
if (lis[a] != INF) hi = a;
printf("%d\n", hi + 1);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int a[100010] = {0}, dp[100010] = {0};
for (int i = 0; i < N; i++) scanf("%d", &a[i]);
int lis = 1;
dp[1] = a[0];
for (int i = 1; i < N; i++) {
int pos = upper_bound(dp + 1, dp + lis + 1, a[i]) - dp;
dp[pos] = a[i];
lis = max(lis, pos);
}
cout << lis;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
int N;
scanf("%d", &N);
static int data[100500];
for (int i = 0; i < N; i++) scanf("%d", data + i);
vector<int> min_of_len;
for (int i = 0; i < N; i++) {
int idx = upper_bound(min_of_len.begin(), min_of_len.end(), data[i]) -
min_of_len.begin();
if (idx == min_of_len.size())
min_of_len.push_back(data[i]);
else
min_of_len[idx] = data[i];
}
cout << min_of_len.size() << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005], x, ans;
const int inf = 99999999;
int main(int argc, char **argv) {
while (~scanf("%d", &n)) {
for (int i = 0; i <= n; ++i) a[i] = inf;
ans = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
int p = lower_bound(a, a + n, x) - a;
a[p] = x;
ans = max(ans, p);
}
printf("%d\n", ans + 1);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[100000];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
set<int> st;
typeof(st.begin()) it;
for (int i = 0; i < n; i++) {
st.insert(arr[i]);
it = st.find(arr[i]);
it++;
if (it != st.end()) st.erase(it);
}
cout << st.size() << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T MAX(T a, T b) {
if (a > b) return a;
return b;
}
template <class T>
inline T MIN(T a, T b) {
if (a < b) return a;
return b;
}
template <class T>
inline T ABS(T x) {
if (x < 0) return -x;
return x;
}
inline void OPEN(const string &s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
const static int inf = 1000000000;
int n, arr[100005];
int LIS[100005];
int main() {
scanf("%d", &n);
for (int(i) = (0); (i) < (n); ++(i)) {
scanf("%d", &arr[i]);
LIS[i + 1] = inf;
}
int res = 0;
for (int(i) = (0); (i) < (n); ++(i)) {
int l = 1, h = res;
while (l <= h) {
int m = (l + h) / 2;
if (LIS[m] < arr[i])
l = m + 1;
else
h = m - 1;
}
if (LIS[l] > arr[i]) LIS[l] = arr[i];
res = max(res, l);
}
printf("%d\n", res);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 10;
int n, a[maxN], len, t[maxN];
int main() {
cin >> n;
t[0] = maxN;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int x = lower_bound(t, t + len, a[i]) - t;
t[x] = a[i];
if (x == len) t[++len] = maxN;
}
cout << len;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int uppbound(int *len, int k, int N) {
int a = 0;
int b = N;
int c = (a + b) / 2;
while (a != b) {
if (len[c] >= k) {
b = c;
} else {
a = c + 1;
}
c = (a + b) / 2;
}
return b;
}
void NVP(int *len, int k, int N) {
int a = uppbound(len, k, N);
len[a] = k;
}
int main() {
int N;
scanf("%d", &N);
int *mas = new int[N];
for (int i = 0; i < N; i++) scanf("%d", &mas[i]);
int *len = new int[N + 1];
for (int i = 0; i <= N; i++) {
len[i] = 1000001;
}
len[0] = -1000001;
for (int i = 0; i < N; i++) {
NVP(len, mas[i], N);
}
int i = 0;
while ((len[i] != 1000001) && (i <= N)) {
i++;
}
cout << i - 1;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int LIS(vector<int> A) {
int N = A.size(), i;
set<int> s;
set<int>::iterator k;
for (i = 0; i < N; i++) {
if (s.insert(A[i]).second) {
k = s.find(A[i]);
k++;
if (k != s.end()) s.erase(k);
}
}
return s.size();
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
cout << LIS(v) << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100010];
int f[100010];
int main() {
while (cin >> n) {
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
int ans = 1;
f[1] = a[1];
for (int i = 2; i <= n; ++i) {
int pos = lower_bound(f, f + ans, a[i]) - f;
if (a[i] >= f[pos])
f[++ans] = a[i];
else
f[pos] = a[i];
}
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void openfile() {}
const int N = 1e5 + 22;
int dp[N], c[N], a[N];
int main() {
openfile();
int i, j, n;
while (cin >> n) {
for (i = 1; i <= n; ++i) cin >> a[i];
c[1] = a[1];
dp[1] = 1;
int mx = 1;
for (i = 2; i <= n; ++i) {
if (c[mx] < a[i]) {
c[++mx] = a[i];
dp[i] = mx;
} else {
int tmp = lower_bound(c + 1, c + mx + 1, a[i]) - c;
c[tmp] = a[i];
dp[i] = tmp;
}
}
cout << mx << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, x, a[100005], cnt;
int main() {
int i, j, k;
while (scanf("%d", &n) == 1) {
cnt = 0;
for (i = 0; i < n; i++) {
scanf("%d", &x);
if (cnt == 0 || x > a[cnt - 1])
a[cnt++] = x;
else {
k = lower_bound(a, a + cnt, x) - a;
a[k] = x;
}
}
printf("%d\n", cnt);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
double PI = 4.00 * (atan(1));
long long int ceilfind(long long int endlen[], long long int start,
long long int end, long long int key) {
long long int mid;
while ((end - start) > 1) {
mid = (end + start) / 2;
if (endlen[mid] >= key) {
end = mid;
} else {
start = mid;
}
}
return end;
}
long long int LIS(long long int arr1[], long long int n) {
long long int endpos[n];
for (long long int i = 1; i < n; i++) {
endpos[i] = -1;
}
endpos[0] = arr1[0];
long long int currend = 0;
for (long long int i = 1; i < n; i++) {
if (arr1[i] < endpos[0]) {
endpos[0] = arr1[i];
continue;
}
if (arr1[i] > endpos[currend]) {
currend++;
endpos[currend] = arr1[i];
continue;
}
long long int val1 = ceilfind(endpos, -1, currend, arr1[i]);
endpos[val1] = arr1[i];
}
return currend + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int arr1[n];
for (long long int i = 0; i < n; i++) {
cin >> arr1[i];
}
long long int ans = LIS(arr1, n);
cout << ans;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> v(n), dp(n + 1);
fill(dp.begin(), dp.end(), 1000000000);
dp[0] = 0;
for (auto &x : v) cin >> x;
for (int i = 0; i < n; i++) {
int x = v[i];
int lo = 0, hi = n;
while (lo < hi) {
int mi = (lo + hi + 1) / 2;
if (dp[mi] < x)
lo = mi;
else
hi = mi - 1;
}
dp[lo + 1] = min(dp[lo + 1], x);
}
for (int i = n; i >= 0; i--) {
if (dp[i] <= n) {
cout << i << endl;
return 0;
}
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
const int N = 100007;
int n, a[N], dp[N];
int main() {
int res = 0;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
dp[i + 1] = INF;
}
dp[0] = -INF;
for (int i = 0; i < n; ++i) {
int j = upper_bound(dp, dp + n, a[i]) - dp;
if (dp[j] > a[i] && dp[j - 1] < a[i]) dp[j] = a[i];
}
for (int i = 1; i <= n; ++i)
if (dp[i] != INF) res = i;
printf("%d\n", res);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long binarySearch(long x, long s, long L, vector<long> &X, vector<long> &M) {
if (s == L - 1) {
if (X[M[s]] < x)
return s;
else
return -1;
}
if (X[M[(L + s) / 2]] <= x)
return binarySearch(x, (L + s) / 2, L, X, M);
else
return binarySearch(x, s, (L + s) / 2, X, M);
return -1;
}
int main() {
long n;
cin >> n;
vector<long> X(n), P(n, -1), M(n, -1);
long L = 0;
for (int i = 0; i < n; i++) {
cin >> X[i];
long j = L - 1;
if (L) j = binarySearch(X[i], 0, L, X, M);
if (j == L - 1) {
L++;
M[L - 1] = i;
} else if (X[i] < X[M[j + 1]])
M[j + 1] = i;
}
cout << L << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int tab[100005], z, n, a, i, j;
int* it;
int main() {
scanf("%d", &n);
for (j = 0; j <= n; ++j) tab[j] = 2000000001;
for (j = 0; j < n; ++j) {
scanf("%d", &a);
it = lower_bound(tab, tab + n, a);
*it = a;
}
for (j = 0; j <= n; ++j)
if (tab[j] == 2000000001) break;
printf("%d\n", j);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, a[maxn], par[maxn];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> lis;
lis.push_back(a[0]);
for (int i = 1; i < n; i++) {
if (a[i] > lis[lis.size() - 1]) {
lis.push_back(a[i]);
par[a[i]] = lis[lis.size() - 2];
continue;
}
int low = lower_bound(lis.begin(), lis.end(), a[i]) - lis.begin();
lis[low] = a[i];
if (low == 0)
par[a[i]] = -1;
else
par[a[i]] = lis[low - 1];
}
cout << lis.size() << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000009;
const int MOD = 1000000007;
int T[5000009];
struct fenwick {
int sum(int i) {
int s = 0;
for (; i > 0; i -= (i & -i)) {
s = max(T[i], s);
}
return s;
}
void update(int i, int v) {
for (; i < 1000009; i += (i & -i)) {
T[i] = max(T[i], v);
}
}
};
int N;
vector<int> V;
map<int, int> MP;
map<int, int> RE;
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
int num;
cin >> num;
V.push_back(num);
}
vector<int> aux = V;
fenwick F;
sort(aux.begin(), aux.end());
int k = 1;
for (int i = 0; i < N; i++) {
if (!MP.count(aux[i])) {
MP[aux[i]] = k;
RE[k] = aux[i];
k++;
}
}
int mm = 0;
set<pair<int, int> > S;
for (int i = 0; i < N; i++) {
int num = MP[V[i]];
int v = F.sum(num - 1);
F.update(num, v + 1);
mm = max(v + 1, mm);
}
cout << mm << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, vet[100001], aux[100001];
int solve() {
int r = 0;
for (int i = 1; i <= n; ++i) {
int v = vet[i];
int p = lower_bound(aux, aux + n + 1, v) - aux;
aux[p] = v;
r = max(r, p);
}
return r;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", vet + i), aux[i] = n + 1;
printf("%d\n", solve());
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int ceilIndex(vector<int> v, int l, int r, int x) {
while (r - l > 1) {
int mid = l + (r - l) / 2;
if (v[mid] >= x)
r = mid;
else
l = mid;
}
return r;
}
int main() {
int n, i;
scanf("%d", &n);
int ar[n + 5];
vector<int> tail;
for (i = 0; i < n; i++) {
scanf("%d", &ar[i]);
tail.push_back(0);
}
tail[0] = ar[0];
int len = 1;
for (i = 1; i < n; i++) {
auto b = tail.begin(), e = tail.begin() + len;
auto it = lower_bound(b, e, ar[i]);
if (it == tail.begin() + len)
tail[len++] = ar[i];
else
*it = ar[i];
}
printf("%d\n", len);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> dp;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
auto p = lower_bound(dp.begin(), dp.end(), a);
if (p == dp.end()) {
dp.emplace_back(a);
} else if (*p > a) {
*p = a;
}
}
cout << (int)dp.size();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int lis(long long int *a, long long int n) {
set<long long int> s;
long long int i;
for (i = 0; i < n; i++) {
auto it = s.upper_bound(a[i]);
if (it == s.end()) {
s.insert(a[i]);
} else {
s.erase(it);
s.insert(a[i]);
}
}
return s.size();
}
int main() {
long long int i, n, a[100010];
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
cout << lis(a, n) << endl;
return 0;
}
| 8 | CPP |
n = int(input())
a= list(map(int,input().split()))
bit = [0]*(n+1)
def update(idx,val):
while idx<=n:
bit[idx] = max(bit[idx],val)
idx+=idx&(-idx)
def query(idx):
res =0
while idx>0:
res = max(res,bit[idx])
idx-=idx&(-idx)
return res
b = []
for i in range(n):
b.append([a[i],-(i+1)])
b.sort()
for i in range(n):
qe = query(-b[i][1])
update(-b[i][1],qe+1)
print(query(n)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int bit[100009] = {0}, m = -1, n;
void update(long long int i, long long int val) {
while (i <= n) {
bit[i] = max(val, bit[i]);
i += (i & (-i));
}
}
long long int query(long long int i) {
long long int sum = 0;
while (i > 0) {
sum = max(sum, bit[i]);
i -= (i & (-i));
}
return sum;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
long long int i, x;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
m = max(m, x);
update(x, query(x - 1) + 1);
}
cout << query(n) << endl;
return 0;
}
| 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];
set<int> st;
set<int>::iterator it;
for (int i = 0; i < n; i++) {
st.insert(a[i]);
it = st.find(a[i]);
it++;
if (it != st.end()) st.erase(it);
}
cout << st.size() << '\n';
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;
}
int a[100100];
int arr[100100];
int main() {
int n;
cin >> n;
memset(arr, 0x3f, sizeof(arr));
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
int ans = 0;
for (int i = 0; i < n; i++) {
int j = lower_bound(arr, arr + n, a[i]) - arr;
arr[j] = a[i];
smax(ans, j + 1);
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
int num[100009];
int n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> num[i];
int mx = 0;
set<int>::iterator iter;
for (int i = 0; i < n; i++) {
s.insert(num[i]);
iter = s.find(num[i]);
iter++;
if (iter != s.end()) s.erase(iter);
}
cout << s.size() << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream &operator>>(istream &in, vector<T> &vec) {
for (int i = 0; i < vec.size(); ++i) in >> vec[i];
return in;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &vec) {
for (int i = 0; i < vec.size(); ++i) out << vec[i] << " ";
return out;
}
void ans(int v = -1e9) {
if (v == -1e9)
cout << "YES" << endl;
else
cout << v << endl;
exit(0);
}
void err(bool check = 1) {
if (check)
cout << "NO" << endl;
else
cout << -1 << endl;
exit(0);
}
const int INF = 1e5 + 1;
int tree[INF];
long long a, b;
void seter(int i, int dx) {
for (; i <= a; i |= i + 1) {
tree[i] = max(tree[i], dx);
}
}
int geter(int i) {
int res = 0;
for (; i > 0; i = (i & (i + 1)) - 1) {
res = max(res, tree[i]);
}
return res;
}
void solve() {
cin >> a;
vector<int> x(a);
cin >> x;
vector<int> pref(a);
pref[0] = 1;
seter(x[0], 1);
for (int i = 1; i < a; ++i) {
int f = geter(x[i]);
seter(x[i], f + 1);
}
int res = 0;
for (int i = 1; i <= a; ++i) {
res = max(res, geter(i));
}
cout << res << endl;
}
int main(int argv, char *argc[]) {
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(12);
solve();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, ans;
int ar[100003];
int tree[4 * 100003];
int Query(int cx, int cy, int qx, int qy, int pos) {
if (cy < qx || qy < cx) return 0;
if (qx <= cx && cy <= qy) return tree[pos];
int mid = (cx + cy) >> 1;
return max(Query(cx, mid, qx, qy, pos * 2),
Query(mid + 1, cy, qx, qy, pos * 2 + 1));
}
void Update(int cx, int cy, int q, int val, int pos) {
if (cy < q || q < cx) return;
tree[pos] = max(tree[pos], val);
if (cx == cy) return;
int mid = (cx + cy) >> 1;
Update(cx, mid, q, val, pos * 2);
Update(mid + 1, cy, q, val, pos * 2 + 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &ar[i]);
for (int i = 1; i <= n; i++) {
int tmp = Query(1, n, 1, ar[i], 1) + 1;
Update(1, n, ar[i], tmp, 1);
ans = max(ans, tmp);
}
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100009];
cin >> n;
int M[100009];
for (int i = 0; i < n; i++) cin >> a[i];
int L = 0;
for (int i = 0; i < n; i++) {
int lo = 1, hi = L;
while (lo <= hi) {
int mid = lo + hi;
mid = mid / 2 + mid % 2;
if (a[M[mid]] < a[i])
lo = mid + 1;
else
hi = mid - 1;
}
int newL = lo;
M[newL] = i;
L = max(newL, L);
}
cout << L << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
const int ninf = -1000000;
const int inf = 1000000;
int dp[100005];
int binSearch(int value) {
int L = 0, R = n, M;
while (R - L > 1) {
M = (L + R) / 2;
if (dp[M] > value)
R = M;
else
L = M;
}
if (dp[L] > value)
return L;
else
return R;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
dp[0] = ninf;
for (int i = 1; i <= n; i++) dp[i] = inf;
for (int i = 0; i < n; i++) {
dp[binSearch(a[i])] = a[i];
}
int result;
for (int i = n; i >= 0; i--) {
if (dp[i] != inf) {
result = i;
break;
}
}
cout << result;
return 0;
}
| 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, 1000000);
for (int i = 0; i < n; i++) *lower_bound(d.begin(), d.end(), a[i]) = a[i];
for (int i = 0; i <= n; i++) {
if (d[i] == 1000000) {
cout << i;
return 0;
}
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
inline int RI() {
int ret = 0, flag = 1, ip = getchar();
for (; ip < 48 || ip > 57; ip = getchar()) {
if (ip == 45) {
flag = -1;
ip = getchar();
break;
}
}
for (; ip > 47 && ip < 58; ip = getchar()) ret = ret * 10 + ip - 48;
return flag * ret;
}
const int mx = 1e5 + 10;
int n;
int tree[mx * 3], ar[mx];
void update(int node, int b, int e, int i, int val) {
if (i > e || i < b) {
return;
}
if (i >= e && i <= b) {
tree[node] = max(tree[node], val);
return;
}
int left = node << 1;
int right = left | 1;
int mid = (b + e) >> 1;
update(left, b, mid, i, val);
update(right, mid + 1, e, i, val);
tree[node] = max(tree[left], tree[right]);
}
int query(int node, int b, int e, int i, int j) {
if (i > e || j < b) {
return 0;
}
if (b >= i && e <= j) {
return tree[node];
}
int left = node << 1;
int right = left | 1;
int mid = (b + e) >> 1;
int part1 = query(left, b, mid, i, j);
int part2 = query(right, mid + 1, e, i, j);
return max(part1, part2);
}
int main() {
int h, ans, x;
while (cin >> n) {
ans = 0;
memset(tree, 0, sizeof tree);
for (int i = 0; i < n; i++) {
cin >> x;
h = query(1, 0, n, 0, x - 1) + 1;
update(1, 0, n, x, h);
ans = max(ans, h);
}
cout << ans << "\n";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int lis[100010];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
int top = 0;
int tmp;
scanf("%d", &tmp);
lis[++top] = tmp;
for (int i = 1; i < n; i++) {
scanf("%d", &tmp);
if (tmp > lis[top])
lis[++top] = tmp;
else {
int l = 1, r = top, mid;
while (l != r) {
mid = (l + r) >> 1;
if (lis[mid] >= tmp)
r = mid;
else
l = mid + 1;
}
lis[r] = tmp;
}
}
printf("%d\n", top);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline void fi(int *a) {
register char c = 0;
while (c < 33) c = getchar();
*a = 0;
while (c > 33) {
*a = *a * 10 + c - '0';
c = getchar();
}
}
int main() {
int n;
cin >> n;
int arr1[n + 2];
int i, j;
for (i = 0; i < n; i++) cin >> arr1[i];
int LIS[n];
LIS[0] = arr1[0];
int count = 1;
for (i = 1; i < n; i++) {
if (arr1[i] < LIS[0])
LIS[0] = arr1[i];
else if (arr1[i] > LIS[count - 1])
LIS[count++] = arr1[i];
else {
int l = 0, r = count - 1, m;
int idx = r;
while (r - l > 0) {
m = (l + r) / 2;
if (LIS[m] > arr1[i]) {
r = m;
idx = r;
} else if (LIS[m] == arr1[i]) {
idx = m;
break;
} else
l = m + 1;
if (m == l) break;
}
LIS[idx] = arr1[i];
}
}
printf("%d\n", count);
return 0;
}
| 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;
vector<int> LIS(vector<int>& v) {
int i;
vector<int> dp(N, 1 << 30), id(N);
for (i = 0; i < v.size(); i++) {
id[i] = lower_bound(dp.begin(), dp.end(), v[i]) - dp.begin();
dp[id[i]] = v[i];
}
int nl = *max_element(id.begin(), id.end());
vector<int> ret(nl + 1);
for (i = 0; i < N; i++)
if (id[N - 1 - i] == nl) ret[nl--] = v[N - 1 - i];
return ret;
}
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);
printf("%d\n", LIS(A).size());
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 = 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;
int main(int argc, char *argv[]) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
memset(tree.maxv, 0, sizeof(tree.maxv));
for (int i = 1; i <= n; i++) {
tree.ql = 1;
tree.qr = a[i] - 1;
d[i] = 1 + tree.query(1, 1, n);
tree.p = a[i];
tree.v = d[i];
tree.update(1, 1, n);
}
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;
const int mod = 1000000007;
const int INF = 1000000000;
int n, a, d[100005];
void update(int x, int a);
int get(int x);
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
update(a, get(a - 1) + 1);
}
cout << get(n) << "\n";
return 0;
}
void update(int x, int a) {
for (; x <= n; x |= x + 1) d[x] = max(d[x], a);
}
int get(int x) {
int result = 0;
for (; x > 0; x = (x & (x + 1)) - 1) result = max(result, d[x]);
return result;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long longest(std::vector<long long> v) {
vector<long long> tail;
long long i, n = v.size();
tail.push_back(v[0]);
for (i = 1; i < n; i++) {
if (v[i] < tail[0])
tail[0] = v[i];
else if (v[i] > tail[tail.size() - 1])
tail.push_back(v[i]);
long long x = lower_bound(tail.begin(), tail.end(), v[i]) - tail.begin();
if (x == tail.size()) continue;
tail[x] = v[i];
}
return tail.size();
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long n, i;
cin >> n;
vector<long long> v(n);
for (i = 0; i < n; i++) cin >> v[i];
cout << longest(v);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int st[4 * MAXN];
int getMax(int v, int tl, int tr, int l, int r) {
if (l == tl && r == tr) return st[v];
int tm = (tl + tr) / 2;
int m1 = 0, m2 = 0;
if (l < tm) m1 = getMax(2 * v, tl, tm, l, min(r, tm));
if (r > tm) m2 = getMax(2 * v + 1, tm, tr, max(l, tm), r);
return max(m1, m2);
}
void change(int v, int tl, int tr, int i, int x) {
if (tl == tr - 1) {
st[v] = x;
return;
}
int tm = (tl + tr) / 2;
if (i < tm)
change(2 * v, tl, tm, i, x);
else
change(2 * v + 1, tm, tr, i, x);
st[v] = max(st[2 * v], st[2 * v + 1]);
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int k = a[i] > 1 ? getMax(1, 1, n + 1, 1, a[i]) : 0;
change(1, 1, n + 1, a[i], k + 1);
}
cout << st[1] << '\n';
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int modulo = 222222;
const int maxN = 888888;
int a[maxN], rsq[maxN];
void replace(int i, int x) {
i += modulo - 1;
rsq[i] = max(rsq[i], x);
i /= 2;
while (i > 0) {
rsq[i] = max(rsq[i + i], rsq[i + i + 1]);
i /= 2;
}
}
int getMax(int l, int r) {
int i = l + modulo - 1, j = r + modulo - 1, ans = 0;
while (i <= j) {
if (i % 2) ans = max(ans, rsq[i]);
if ((j + 1) % 2) ans = max(ans, rsq[j]);
i = (i + 1) / 2;
j = (j - 1) / 2;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) {
replace(i, 0);
}
for (int i = 1; i <= n; ++i) {
int x = a[i], y = getMax(1, x - 1);
replace(x, y + 1);
}
cout << getMax(1, n) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000009);
const int INF((1 << 30) - 1);
const int MAXN(100005);
int a[MAXN], na = 0;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
int low = 0, high = na - 1, mid, pos = na;
while (low <= high) {
mid = (low + high) / 2;
if (a[mid] > x)
pos = mid, high = mid - 1;
else
low = mid + 1;
}
a[pos] = x;
if (pos == na) na++;
}
printf("%d", na);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int b[100005];
int n;
int findd(int len, int p) {
int l, r, mid;
l = 1, r = len, mid = (l + r) >> 1;
while (l <= r) {
if (p > b[mid])
l = mid + 1;
else if (p < b[mid])
r = mid - 1;
else
return mid;
mid = (l + r) >> 1;
}
return l;
}
int LIS() {
int i, j, len = 1;
b[1] = a[0];
for (i = 1; i < n; i++) {
j = findd(len, a[i]);
b[j] = a[i];
if (j > len) len = j;
}
return len;
}
int main() {
int i;
while (~scanf("%d", &n)) {
for (i = 0; i < n; i++) scanf("%d", &a[i]);
printf("%d\n", LIS());
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[100005];
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
set<int> st;
set<int>::iterator it;
st.clear();
for (int i = 0; i < n; i++) {
st.insert(arr[i]);
it = st.find(arr[i]);
it++;
if (it != st.end()) st.erase(it);
}
cout << st.size() << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000 + 10, maxm = (1 << 17), mod = (int)1e9 + 7,
hash = 7000001, inf = (1 << 29);
const double pi = 3.14159265359, ee = 2.71828;
int a[maxn];
vector<int> q;
int main() {
ios::sync_with_stdio(0);
int n, c;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
c = upper_bound(q.begin(), q.end(), a[i]) - q.begin();
if (c == q.size())
q.push_back(a[i]);
else
q[c] = a[i];
}
cout << q.size() << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
int n, a[MAX], f[MAX], d[MAX];
long long result;
void update(int x, int val) {
int u = x;
while (u <= n) {
f[u] = max(f[u], val);
u += (u & -u);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
result = 0;
int u;
memset(d, 0, sizeof(d));
memset(f, 0, sizeof(f));
d[1] = 1;
update(a[1], 1);
int result;
for (int i = 2; i <= n; i++) {
u = a[i] - 1;
result = 0;
while (u > 0) {
result = max(result, f[u]);
u -= (u & -u);
}
d[i] = result + 1;
update(a[i], d[i]);
}
result = 0;
for (int i = 1; i <= n; i++) result = max(result, d[i]);
cout << result << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int v[100005], h[100005], n;
vector<int> q;
void insert(int i) {
int val = v[i];
int lo, mid, hi;
lo = -1;
hi = q.size();
while (hi - lo > 1) {
mid = lo + (hi - lo) / 2;
if (val > q[mid])
lo = mid;
else
hi = mid;
}
if (hi == q.size()) {
q.push_back(val);
h[i] = q.size();
} else {
q[hi] = val;
h[i] = hi + 1;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i];
insert(i);
}
int dim = q.size();
cout << dim << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
int n;
int a[100009];
int b[100009], p;
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
p = 1;
b[0] = a[1];
for (int i = 2; i <= n; i++) {
int k = lower_bound(b, b + p, a[i]) - b;
if (k == p) p++;
b[k] = a[i];
}
printf("%d\n", p);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> lis;
int32_t main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
long long pos = (lower_bound(lis.begin(), lis.end(), x) - lis.begin());
if (pos == lis.size()) lis.push_back(x);
lis[pos] = x;
}
cout << lis.size();
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
vector<int> lis = {a[1]};
for (int i = 2; i <= n; ++i) {
if (a[i] > lis.back())
lis.push_back(a[i]);
else
*lower_bound(lis.begin(), lis.end(), a[i]) = a[i];
}
cout << lis.size() << endl;
}
| 8 | CPP |
n=int(input())
a=list(map(lambda x: int(x), 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 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
print(LongestIncreasingSubsequenceLength(a,len(a))) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int N, tree[1000090], ar[1000090];
int read(int pos) {
int ret = 0;
while (pos > 0) {
ret = max(ret, tree[pos]);
pos -= (pos & -pos);
}
return ret;
}
void add(int pos, int val) {
while (pos <= N) {
tree[pos] = max(tree[pos], val);
pos += (pos & -pos);
}
}
int main() {
while (cin >> N) {
memset(tree, 0, sizeof(tree));
int ret = 0;
for (int i = 0, _n = N; i < _n; i++) {
scanf("%d", &ar[i]);
int L = read(ar[i]) + 1;
ret = max(L, ret);
add(ar[i], L);
}
cout << ret << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
int a[N], p[N];
int cnt;
int n;
void work() {
p[cnt = 1] = a[0];
for (int i = 1; i < n; i++) {
if (a[i] >= p[cnt])
p[++cnt] = a[i];
else {
int w = upper_bound(p, p + cnt + 1, a[i]) - p;
if (w > cnt)
p[++cnt] = a[i];
else
p[w] = a[i];
}
}
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
work();
printf("%d\n", cnt);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
int pre[100005];
map<int, int>::iterator l, k;
vector<int> LIS_nlogn(vector<int> V) {
int i, j;
for (i = 0; i < V.size(); i++) {
m.insert(make_pair(V[i], i));
l = k = m.find(V[i]);
k++;
if (l == m.begin()) {
pre[i] = -1;
} else {
l--;
pre[i] = l->second;
}
if (k != m.end()) {
m.erase(k);
}
}
vector<int> res;
k = m.end();
res.clear();
k--;
j = k->second;
while (j != -1) {
res.push_back(j);
j = pre[j];
}
return res;
}
int main() {
int N, i, x;
vector<int> V;
cin >> N;
for (i = 1; i <= N; i++) {
cin >> x;
V.push_back(x);
}
vector<int> res = LIS_nlogn(V);
cout << res.size() << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool mins(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool maxs(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int inf = 1e9 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
for (auto &x : a) cin >> x;
vector<int> dp(n + 1, inf);
dp[0] = -inf;
for (int i = 0; i < n; i++) {
int v = lower_bound(dp.begin(), dp.end(), a[i]) - dp.begin();
dp[v] = a[i];
}
int i = 0;
for (i = n; i >= 0; i--) {
if (dp[i] != inf) break;
}
cout << i << '\n';
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;
}
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[100010];
int first[100010];
int dp[100010];
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++) first[i] = 0x3f3f3f3f;
dp[1] = 1;
first[0] = a[1];
for (int i = 2; i <= n; i++) {
int nn = lower_bound(first, first + n, a[i]) - first;
first[nn] = a[i];
dp[i] = nn + 1;
}
int mn = 0;
for (int i = 1; i <= n; i++) smax(mn, dp[i]);
cout << mn << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int _;
const int MAXN = 111 * 1000;
int n;
int a[MAXN];
vector<int> v;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
int x = lower_bound(v.begin(), v.end(), a[i]) - v.begin();
if (x == ((int)(v).size()))
v.push_back(a[i]);
else
v[x] = a[i];
}
cout << ((int)(v).size()) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void reup() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int n;
int a[200005];
int b[200005];
void enter() {
reup();
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
}
void solve() {
for (int i = 1; i <= n; ++i) b[i] = 1000000000;
int ans = 0;
for (int i = 1; i <= n; ++i) {
int ta = lower_bound(b + 1, b + 1 + n, a[i]) - b;
b[ta] = a[i];
ans = max(ans, ta);
}
cout << ans;
}
int main() {
enter();
solve();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int tree[4 * N];
int a[N];
void update(int node, int s, int e, int p, int val) {
if (s > p or e < p) return;
if (s >= p and e <= p) {
tree[node] = val;
return;
}
int mid = (s + e) / 2;
update(2 * node, s, mid, p, val);
update(2 * node + 1, mid + 1, e, p, val);
tree[node] = max(tree[2 * node], tree[2 * node + 1]);
}
int get(int node, int s, int e, int l, int r) {
if (l > e or r < s) return 0;
if (s >= l and e <= r) {
return tree[node];
}
int mid = (s + e) / 2;
int left = get(2 * node, s, mid, l, r);
int right = get(2 * node + 1, mid + 1, e, l, r);
return max(left, right);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int cur = get(1, 1, n, 1, a[i] - 1) + 1;
ans = max(ans, cur);
update(1, 1, n, a[i], cur);
}
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const long double PI = acos(-1.0);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
;
int N, i, x;
cin >> N;
set<int> ans;
for (i = 0; i < N; ++i) {
cin >> x;
ans.insert(x);
auto it = ans.find(x);
++it;
if (it != ans.end()) ans.erase(it);
}
cout << ans.size();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
int g[N], a[N], n;
int Find(int x) {
int l = 0, r = n, ret = 0;
while (l <= r) {
int mid = l + r >> 1;
if (g[mid] < x) {
ret = mid;
l = mid + 1;
} else
r = mid - 1;
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(g, 0x7f, sizeof(g));
g[0] = 0;
for (int i = 1; i <= n; i++) {
int j = Find(a[i]);
g[j + 1] = min(g[j + 1], a[i]);
}
for (int i = n; i >= 1; i--)
if (g[i] < 1e9) {
printf("%d\n", i);
break;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int n = 200006;
int bit[n];
int query(int i) {
int maxx = 0;
while (i > 0) {
maxx = max(maxx, bit[i]);
i -= (i & -i);
}
return maxx;
}
void update(int i, int v) {
while (i < n) {
bit[i] = max(bit[i], v);
i += (i & (-i));
}
}
int LIS(vector<int> a) {
int nn = a.size();
for (int i = 0; i < nn; i++) {
int value = query(a[i] - 1);
update(a[i], value + 1);
}
return query(n - 1);
}
int main() {
ios_base::sync_with_stdio(0);
memset(bit, 0, sizeof(bit));
int xxxx;
cin >> xxxx;
vector<int> v(xxxx);
for (int i = 0; i < xxxx; i++) {
cin >> v[i];
}
cout << LIS(v);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int seg[4 * 100005];
void upd(long long int node, long long int s, long long int e,
long long int idx, long long int val) {
if (s > e or idx < s or idx > e) return;
if (s == e) {
seg[node] = val;
return;
}
long long int mid = (s + e) / 2;
upd(2 * node, s, mid, idx, val);
upd(2 * node + 1, mid + 1, e, idx, val);
seg[node] = max(seg[2 * node], seg[2 * node + 1]);
}
long long int query(long long int node, long long int s, long long int e,
long long int l, long long int r) {
if (s > e or r < s or l > e) return 0;
if (s >= l and e <= r) return seg[node];
long long int mid = (s + e) / 2;
return max(query(2 * node, s, mid, l, r),
query(2 * node + 1, mid + 1, e, l, r));
}
int main() {
long long int n, i, j, k;
cin >> n;
vector<long long int> a(n);
for (i = 0; i < n; i++) cin >> a[i];
upd(1, 1, n, a[0], 1);
for (i = 1; i < n; i++) {
long long int p = query(1, 1, n, 1, a[i]);
upd(1, 1, n, a[i], p + 1);
}
cout << seg[1] << '\n';
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int BIT[500000];
int ar[500000];
void update(int idx, int val) {
int mx = val;
int i;
for (i = idx; i <= 499999; i = i + (i & -i)) {
mx = max(mx, BIT[i]);
BIT[i] = mx;
}
}
int query(int idx) {
int ans = 0;
;
while (idx > 0) {
ans = max(ans, BIT[idx]);
idx = idx - (idx & -idx);
}
return ans;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
update(ar[i], query(ar[i] - 1) + 1);
}
int t = 0;
for (int i = 1; i <= n; i++) t = max(t, BIT[i]);
cout << t << endl;
return 0;
}
| 8 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.