solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
const int N = 2e5 + 20;
int n, s[N], a[N], fen[N];
inline void add(int p, int val) {
for (p++; p < N; p += p & -p) fen[p] += val;
}
inline int get(int p) {
int sum = 0;
for (; p; p -= p & -p) sum += fen[p];
return sum;
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) add(i + 1, i + 1);
int p = n - 1;
while (p >= 0) {
int low = 0, high = n + 1;
while (high - low > 1) {
int mid = (low + high) >> 1;
if (get(mid) <= s[p])
low = mid;
else
high = mid;
}
a[p] = low;
add(low, -low);
p--;
}
for (int i = 0; i < n; i++) cout << a[i] << ' ';
cout << '\n';
}
| 10 | CPP |
def sumsegtree(l,seg,st,en,x):
if st==en:
seg[x]=l[st]
else:
mid=(st+en)>>1
sumsegtree(l,seg,st,mid,2*x)
sumsegtree(l,seg,mid+1,en,2*x+1)
seg[x]=seg[2*x]+seg[2*x+1]
def query(seg,st,en,val,x):
if st==en:
return seg[x]
mid=(st+en)>>1
if seg[2*x]>=val:
return query(seg,st,mid,val,2*x)
return query(seg,mid+1,en,val-seg[2*x],2*x+1)
def upd(seg,st,en,ind,val,x):
if st==en:
seg[x]=val
return
mid=(st+en)>>1
if mid>=ind:
upd(seg,st,mid,ind,val,2*x)
else:
upd(seg,mid+1,en,ind,val,2*x+1)
seg[x]=seg[2*x]+seg[2*x+1]
n=int(input())
l=list(map(int,range(1,n+1)))
s=[0]*n
p=list(map(int,input().split()))
seg=["#"]*(n<<2)
sumsegtree(l,seg,0,len(l)-1,1)
for i in range(n-1,-1,-1):
s[i]=query(seg,1,n,p[i]+1,1)
upd(seg,1,n,s[i],0,1)
print (*s) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5;
long long n, t[N], a[N], res[N];
set<long long> st;
void upd(long long i) {
long long d = i;
for (i; i < N; i |= i + 1) t[i] += d;
}
long long sum(long long l, long long r) {
long long s = 0;
for (; r >= 0; r &= r + 1, r--) s += t[r];
l--;
for (; l >= 0; l &= l + 1, l--) s -= t[l];
return s;
}
long long f(long long x) {
if (!sum(x, x))
return (x * x + x) / 2 - sum(0, x) - x;
else
return (x * x + x) / 2 - sum(0, x);
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
st.insert(i);
}
for (long long i = n - 1; i >= 0; i--) {
long long l = 1, r = n, med;
while (r - l > 1) {
med = (r + l) / 2;
if (f(med) > a[i])
r = med;
else
l = med;
}
if (f(r) == a[i]) {
res[i] = r;
upd(r);
} else {
res[i] = l;
upd(l);
}
}
for (long long i = 0; i < n; ++i) cout << res[i] << ' ';
}
| 10 | CPP |
# https://codeforces.com/contest/1208/problem/D
from sys import stdin, stdout
input = stdin.readline
print = stdout.write
# For every i from N to 1, let's say the value of the si is x.
# So it means there are k smallest unused numbers whose sum is x.
# We simply put the (k+1)st number in the output permutation at this i, and continue to move left.
# segment tree and binary search
_ = input()
x = [int(i) for i in input().split()]
res = []
from math import log
class SegmentTree(object):
def __init__(self, nums):
self.arr = nums
self.l = len(nums)
self.tree = [0] * self.l + nums
for i in range(self.l - 1, 0, -1):
self.tree[i] = self.tree[i << 1] + self.tree[i << 1 | 1]
def update(self, i, val):
n = self.l + i
self.tree[n] = val
while n > 1:
self.tree[n >> 1] = self.tree[n] + self.tree[n ^ 1]
n >>= 1
def query(self, i, j):
m = self.l + i
n = self.l + j
res = 0
while m <= n:
if m & 1:
res += self.tree[m]
m += 1
m >>= 1
if n & 1 == 0:
res += self.tree[n]
n -= 1
n >>= 1
return res
tree = SegmentTree(list(range(1, len(x) + 1)))
org = len(x)
while x:
# from back to forth
q = x.pop()
lo = 0
hi = org - 1
while lo < hi:
mid = (lo + hi) // 2
# print(lo, hi, mid)
sm = tree.query(0, mid)
# print(sm, mid)
if sm > q:
hi = mid
else:
lo = mid + 1
# print(tree.arr, lo, hi)
idx = tree.arr[lo]
# print(idx)
tree.update(lo, 0)
# also from back to forth
res.append(idx)
print(' '.join(str(i) for i in res[::-1])) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using std::size_t;
template <typename T, typename Op = std::plus<T>>
class SegmentTree {
std::vector<T> arr;
int n;
Op op;
public:
template <class InputIterator>
SegmentTree(size_t n_, InputIterator begin);
SegmentTree(size_t n_, const T& value = T());
const T& operator[](size_t i) const;
inline T query(size_t l, size_t r) const;
void modify(size_t i, const T& value);
};
template <class T, typename Op>
template <class InputIterator>
SegmentTree<T, Op>::SegmentTree(size_t n_, InputIterator begin)
: n(n_), arr(n_ << 1) {
for (int i = n; i != n << 1; ++i) {
arr[i] = *begin;
++begin;
}
for (int i = n - 1; i >= 0; --i) {
arr[i] = op(arr[i << 1], arr[(i << 1) ^ 1]);
}
}
template <class T, typename Op>
SegmentTree<T, Op>::SegmentTree(size_t n_, const T& value)
: n(n_), arr(n_ << 1, value) {
for (int i = n - 1; i >= 0; --i) {
arr[i] = op(arr[i << 1], arr[(i << 1) ^ 1]);
}
}
template <class T, typename Op>
inline const T& SegmentTree<T, Op>::operator[](size_t i) const {
return arr[i + n];
}
template <class T, typename Op>
T SegmentTree<T, Op>::query(size_t l, size_t r) const {
bool linit = false, rinit = false;
T ltail, rtail;
l += n, r += n;
while (l < r) {
if (l & 1) {
if (linit) {
ltail = op(ltail, arr[l++]);
} else {
ltail = arr[l++];
linit = true;
}
}
if (r & 1) {
if (rinit) {
rtail = op(arr[--r], rtail);
} else {
rtail = arr[--r];
rinit = true;
}
}
l >>= 1, r >>= 1;
}
if (!linit) {
return rtail;
} else if (!rinit) {
return ltail;
} else {
return op(ltail, rtail);
}
}
template <class T, typename Op>
void SegmentTree<T, Op>::modify(size_t i, const T& value) {
i += n;
arr[i] = value;
while (i > 1) {
arr[i >> 1] = op(arr[i], arr[i ^ 1]);
i >>= 1;
}
}
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> p(n);
vector<long long> s(n);
for (long long& s_i : s) scanf("%lld", &s_i);
vector<long long> range(n);
iota(range.begin(), range.end(), 1);
SegmentTree<long long> T(n, range.begin());
for (int i = n - 1; i >= 0; --i) {
int x = 0, z = n, y = n >> 1;
while (x != y) {
(s[i] < T.query(0, y)) ? z = y : x = y;
y = (x + z) >> 1;
}
T.modify(x, 0);
p[i] = x + 1;
}
for (int x : p) printf("%d ", x);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, eps = 1e-10;
int n;
long long a[N];
long long tree[N];
int ans[N];
long long sum(int x) {
long long res = 0;
while (x) {
res += tree[x];
x -= (x & (-x));
}
return res;
}
void add(int x, long long sum) {
while (x <= n) {
tree[x] += sum;
x += (x & (-x));
}
return;
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = (1); i < (n + 1); ++i) cin >> a[i], add(i + 1, i);
for (int i = (n); i >= (1); --i) {
long long l = 1, r = n;
while (l < r) {
int m = (l + r + 1) / 2;
if (sum(m) <= a[i])
l = m;
else
r = m - 1;
}
ans[i] = r;
add(r + 1, -r);
}
for (int i = (1); i < (n + 1); ++i) cout << ans[i] << " ";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
long long IM = -999999999999;
typedef struct nde {
int ll;
int rl;
long long val;
int pos;
long long prv;
struct nde* l;
struct nde* r;
struct nde* pr;
} prt;
prt* getnew() {
prt* p = new prt();
p->prv = 0;
return p;
}
prt* createTree(long long ar[], prt* pps[], int s, int e, prt* pr) {
prt* rt = getnew();
rt->ll = s;
rt->rl = e;
rt->pr = pr;
rt->l = 0;
rt->r = 0;
if (s == e) {
rt->pos = s;
rt->val = ar[s];
pps[s] = rt;
return rt;
} else {
prt* t = createTree(ar, pps, s, (s + e) / 2, rt);
prt* tt = createTree(ar, pps, 1 + ((s + e) / 2), e, rt);
rt->l = t;
rt->r = tt;
if (t->val == tt->val) {
rt->val = t->val;
rt->pos = tt->pos;
} else if (t->val < tt->val) {
rt->val = t->val;
rt->pos = t->pos;
} else {
rt->val = tt->val;
rt->pos = tt->pos;
}
}
return rt;
}
void uptd(int k, int rr, long long u, prt* p) {
if (p->ll >= k && p->rl <= rr) {
p->prv += u;
return;
}
p->l->prv += p->prv;
p->r->prv += p->prv;
p->prv = 0;
if (p->l->rl >= k && p->l->ll <= k) {
uptd(k, rr, u, p->l);
} else if (p->l->ll <= rr && p->l->rl >= rr) {
uptd(k, rr, u, p->l);
} else if (p->l->ll >= k && p->l->rl <= rr) {
uptd(k, rr, u, p->l);
} else {
}
if (p->r->rl >= k && p->r->ll <= k) {
uptd(k, rr, u, p->r);
} else if (p->r->ll <= rr && p->r->rl >= rr) {
uptd(k, rr, u, p->r);
} else if (p->r->ll >= k && p->r->rl <= rr) {
uptd(k, rr, u, p->r);
} else {
}
if ((p->l->val - p->l->prv) < (p->r->val - p->r->prv)) {
p->val = p->l->val - p->l->prv;
p->pos = p->l->pos;
} else {
p->val = p->r->val - p->r->prv;
p->pos = p->r->pos;
}
return;
}
void inactive(int k, prt* root) { uptd(k, k, IM, root); }
int main() {
int u;
cin >> n;
long long ar[n + 1];
prt* pps[n + 1];
int i = 1;
while (i <= n) {
cin >> ar[i];
i++;
}
prt* root = createTree(ar, pps, 1, n, 0);
i = 1;
int t;
while (i <= n) {
t = root->pos;
ar[t] = i;
inactive(t, root);
if (t < n) uptd(t + 1, n, i, root);
i++;
}
i = 1;
while (i <= n) {
cout << ar[i] << " ";
i++;
}
cout << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void ECHO(string _s) {
cout << endl;
(void)_s;
}
template <typename T, typename... Args>
void ECHO(string _s, T x, Args... args) {
int _i;
string _s2 = "";
for (_i = 0; _i < (int)(_s).size(); ++_i) {
if (_s[_i] == ',') break;
if (_s[_i] != ' ') _s2 += _s[_i];
}
if (_i == (int)(_s).size()) {
--_i;
}
cout << " (" << _s2 << "):" << x;
ECHO(_s.substr(_i + 1, (int)(_s).size() - _i - 1), args...);
}
template <typename T0, typename T1>
inline ostream& operator<<(ostream& os, pair<T0, T1>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
inline ostream& operator<<(ostream& os, vector<T>& v) {
for (int i = 0; i < (int)(v).size(); ++i) {
if (i > 0) cout << "_";
cout << v[i];
}
cout << endl;
return os;
}
inline long long _gcd(long long a, long long b) {
while (b) b %= a ^= b ^= a ^= b;
return a;
}
mt19937 ran(time(0));
const long double PI = acos(-1);
const long double eps = 1e-9;
const long long inf = LLONG_MAX / 10;
vector<long long> v, ans;
long long n;
const long long MAX = 2 * 1e5 + 10;
vector<long long> bit(MAX, 0);
void update(int dx, long long val) {
for (int i = dx + 1; i <= n; i += ((i) & (-(i)))) bit[i] += val;
}
long long query(int dx) {
long long ans = 0, i;
for (i = dx + 1; i > 0; i -= ((i) & (-(i)))) ans += bit[i];
return ans;
}
int get_number(long long sum) {
long long l = 0, r = n, mid, ans;
while (l + 1 < r) {
mid = (l + r) >> 1;
ans = query(mid);
if (ans <= sum)
l = mid;
else
r = mid;
}
return l + 1;
}
int main() {
ios::sync_with_stdio(false);
int i, x;
cin >> n;
v.resize(n + 1);
n = v.size() - 1;
ans.resize(n + 1);
for (i = 1; i <= n; ++i) {
update(i, i);
cin >> v[i];
}
for (i = n; i > 0; --i) {
x = get_number(v[i]);
ans[i] = x;
update(x, -x);
}
for (i = 1; i <= n; ++i) {
if (i > 1) cout << " ";
cout << ans[i];
}
cout << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long res = 1;
a = a % 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
b--;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long fermat_inv(long long y) { return power(y, 1000000007 - 2); }
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
long long sum[800050];
void build(long long a[], int v, int l, int r) {
if (l == r)
sum[v] = a[l];
else {
int m = (l + r) / 2;
build(a, 2 * v, l, m);
build(a, 2 * v + 1, m + 1, r);
sum[v] = sum[2 * v] + sum[2 * v + 1];
}
}
long long query(int v, int tl, int tr, int l, int r) {
if (l > r)
return 0;
else if (l == tl && r == tr)
return sum[v];
else {
int m = (tl + tr) / 2;
return query(2 * v, tl, m, l, min(r, m)) +
query(2 * v + 1, m + 1, tr, max(l, m + 1), r);
}
}
void update(int v, int l, int r, int pos, int val) {
if (l == r)
sum[v] = val;
else {
int m = (l + r) / 2;
if (pos <= m)
update(2 * v, l, m, pos, val);
else
update(2 * v + 1, m + 1, r, pos, val);
sum[v] = sum[2 * v] + sum[2 * v + 1];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
int n;
cin >> n;
long long b[n];
long long a[n + 1];
a[0] = 0;
for (int i = 0; i < n; i++) {
cin >> b[i];
a[i + 1] = i + 1;
}
build(a, 1, 0, n);
for (int i = n - 1; i >= 0; i--) {
long long l = 0;
long long r = n;
long long pos = -1;
while (l <= r) {
long long m = (l + r) / 2;
long long val = query(1, 0, n, 0, m);
if (val <= b[i]) {
pos = m;
l = m + 1;
} else
r = m - 1;
}
b[i] = pos + 1;
update(1, 0, n, pos + 1, 0);
}
for (int i = 0; i < n; i++) {
cout << b[i] << " ";
}
cout << "\n";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const long long inf = 1e11;
struct Node {
int l, r, num;
long long tag;
long long val;
} node[4 * maxn];
long long a[maxn];
int ans[maxn];
void up(int no) {
if (node[no << 1].val < node[no << 1 | 1].val) {
node[no].val = node[no << 1].val;
node[no].num = node[no << 1].num;
} else {
node[no].val = node[no << 1 | 1].val;
node[no].num = node[no << 1 | 1].num;
}
}
void build(int l, int r, int no) {
node[no].l = l;
node[no].r = r;
node[no].tag = 0;
if (l == r) {
node[no].val = a[l];
node[no].num = l;
return;
}
int mid = l + r >> 1;
build(l, mid, no << 1);
build(mid + 1, r, no << 1 | 1);
up(no);
}
void pushdown(int no) {
node[no << 1].tag += node[no].tag;
node[no << 1].val += node[no].tag;
node[no << 1 | 1].tag += node[no].tag;
node[no << 1 | 1].val += node[no].tag;
node[no].tag = 0;
}
void change(int l, int r, int no, long long num) {
if (node[no].r < l || node[no].l > r) return;
if (node[no].l >= l && node[no].r <= r) {
node[no].tag += num;
node[no].val += num;
return;
}
if (node[no].tag != 0) {
pushdown(no);
}
change(l, r, no << 1, num);
change(l, r, no << 1 | 1, num);
up(no);
}
int main() {
int n, i;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
build(1, n, 1);
for (i = 1; i <= n; i++) {
int x = node[1].num;
ans[x] = i;
change(x, x, 1, inf);
change(x + 1, n, 1, -i);
}
for (i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
| 10 | CPP |
NN = 18
BIT=[0]*(2**NN+1)
def addbit(i, x):
while i <= 2**NN:
BIT[i] += x
i += i & (-i)
def getsum(i):
ret = 0
while i != 0:
ret += BIT[i]
i -= i&(-i)
return ret
def searchbit(x):
l, sl = 0, 0
d = 2**(NN-1)
while d:
m = l + d
sm = sl + BIT[m]
if sm <= x:
l, sl = m, sm
d //= 2
return l
N = int(input())
A = [int(a) for a in input().split()]
for i in range(1, N+1):
addbit(i, i)
ANS = []
for s in A[::-1]:
a = searchbit(s) + 1
addbit(a, -a)
ANS.append(a)
print(*ANS[::-1]) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 2 * 100224;
struct BIT {
long long data[maxN] = {0};
void update(long long idx, long long val) {
while (idx < maxN) {
data[idx] += val;
idx += idx & -idx;
}
}
void update(long long l, long long r, long long val) {
update(l, val);
update(r + 1, -val);
}
long long query(long long idx) {
long long res = 0;
while (idx > 0) {
res += data[idx];
idx -= idx & -idx;
}
return res;
}
long long query(long long l, long long r) { return query(r) - query(l); }
};
struct LazyBIT {
BIT bitAdd, bitSub;
void update(long long l, long long r, long long val) {
bitAdd.update(l, r, val);
bitSub.update(l, r, (l - 1) * val);
bitSub.update(r + 1, (-r + l - 1) * val);
}
long long query(long long idx) {
return idx * bitAdd.query(idx) - bitSub.query(idx);
}
long long query(long long l, long long r) { return query(r) - query(l - 1); }
};
long long parent[maxN];
long long rnk[maxN];
long long lfmost[maxN];
long long rtmost[maxN];
long long vis[maxN];
void make_set(long long v) {
parent[v] = v;
rnk[v] = 0;
lfmost[v] = v;
rtmost[v] = v;
}
long long find_set(long long v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rnk[a] < rnk[b]) swap(a, b);
parent[b] = a;
lfmost[a] = min(lfmost[a], lfmost[b]);
rtmost[a] = max(rtmost[a], rtmost[b]);
if (rnk[a] == rnk[b]) rnk[a]++;
}
}
int main() {
long long n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
long long sum = 0;
LazyBIT B;
for (long long i = 1; i <= n; i++) {
B.update(i, i, sum);
sum += i;
}
vector<long long> haha;
for (int i = n - 1; i >= 0; i--) {
long long lo = 1;
long long hi = n;
long long mid;
long long ans;
long long val;
long long temp;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (vis[mid] == 1) {
if (lfmost[find_set(mid)] - 1 >= lo)
mid = lfmost[find_set(mid)] - 1;
else if (rtmost[find_set(mid)] + 1 <= hi)
mid = rtmost[find_set(mid)] + 1;
else
break;
}
val = B.query(mid, mid);
if (val == v[i]) {
ans = mid;
hi = mid - 1;
} else if (v[i] > val) {
lo = mid + 1;
} else if (v[i] < val) {
hi = mid - 1;
}
}
B.update(ans, n, -ans);
vis[ans] = 1;
make_set(ans);
if (vis[ans] == 1 && vis[ans + 1] == 1) union_sets(ans, ans + 1);
if (vis[ans] == 1 && vis[ans - 1] == 1) union_sets(ans, ans - 1);
haha.push_back(ans);
}
reverse(haha.begin(), haha.end());
for (auto u : haha) {
cout << u << " ";
}
}
| 10 | CPP |
#include <bits/stdc++.h>
struct BIT {
int n;
long long a[200005];
int lowbit(int x) { return x & -x; }
void build(int size) { n = size; }
void update(int x, int val) {
for (; x <= n; x += lowbit(x)) a[x] += val;
}
long long query(int x) {
long long ret = 0;
for (; x; x -= lowbit(x)) ret += a[x];
return ret;
}
};
BIT b;
long long s[200005];
int a[200005];
int main() {
int n;
scanf("%d", &n);
b.build(n);
for (int i = 1; i <= n; ++i) scanf("%lld", &s[i]);
for (int i = 1; i <= n; ++i) b.update(i, i);
for (int i = n; i; --i) {
int left = 1, right = n;
while (left < right) {
int mid = (left + right + 1) >> 1;
if (b.query(mid - 1) <= s[i])
left = mid;
else
right = mid - 1;
}
a[i] = left;
b.update(a[i], -a[i]);
}
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
return 0;
}
| 10 | CPP |
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
#sys.setrecursionlimit(300000)
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")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=0, func=lambda a, b: max(a, b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n=int(input())
l=list(map(int,input().split()))
f=[i for i in range(1,n+1)]
s=SegmentTree(f)
ans=[0]*n
for i in range(n-1,-1,-1):
st=1
end=n
while(st<=end):
mid=(st+end)//2
su=s.query(0,mid-2)
if su==l[i]:
an=mid
st=mid+1
elif su<l[i]:
st=mid+1
else:
end=mid-1
ans[i]=an
s.__setitem__(an-1,0)
print(*ans,sep=" ") | 10 | PYTHON3 |
import sys
input = sys.stdin.readline
class SegTree(object):
"""docstring for SegTree"""
def __init__(self, n, arr):
self.n = n
self.arr = arr
self.tree = [0 for i in range(2*n)]
def construct(self): # Construction
for i in range(self.n):
self.tree[n+i] = self.arr[i]
for i in range(n-1,0,-1):
self.tree[i] = self.function(self.tree[2*i],self.tree[2*i+1])
def update(self,index,value):
start = index+self.n
self.tree[start] = value
while start>0:
start = start//2
self.tree[start] = self.function(self.tree[2*start],self.tree[2*start+1])
def calc(self,low,high): # 0-indexed
low+=self.n
high+=self.n
ans = 0 # Needs to initialised
while low<high:
if low%2:
ans = self.function(ans, self.tree[low])
low += 1
if high%2:
high -= 1
ans = self.function(ans, self.tree[high])
low = low//2
high = high//2
return ans
def function(self,a,b): # Function used to construct Segment Tree
return a + b
def find(num):
low = 0
high = n-1
while low<high:
mid = (low+high)//2
if st.calc(0,mid+1)>num:
high = mid - 1
else:
low = mid + 1
if st.calc(0,low+1)>num:
return low
else:
return low + 1
n = int(input())
a = list(map(int,input().split()))
arr = [i for i in range(1,n+1)]
st = SegTree(n,arr)
st.construct()
ans = [-1]*n
for i in range(n-1,-1,-1):
ind = find(a[i])
# print (a[i],ind,arr)
ans[i] = arr[ind]
st.update(ind,0)
print (*ans)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, s[200005], tree[800005], lazy[800005], ans[200005];
void pushdown(long long ind, long long l, long long r) {
if (l != r && lazy[ind] != 0) {
lazy[2 * ind] += lazy[ind];
tree[2 * ind] += lazy[ind];
lazy[2 * ind + 1] += lazy[ind];
tree[2 * ind + 1] += lazy[ind];
lazy[ind] = 0;
}
}
void build(long long ind, long long l, long long r) {
if (l == r) {
tree[ind] = s[l];
return;
}
long long mid = (l + r) / 2;
build(2 * ind, l, mid);
build(2 * ind + 1, mid + 1, r);
tree[ind] = min(tree[2 * ind], tree[2 * ind + 1]);
}
long long query(long long ind, long long l, long long r) {
pushdown(ind, l, r);
if (l == r) return l;
tree[ind] = min(tree[2 * ind], tree[2 * ind + 1]);
long long mid = (l + r) / 2;
if (tree[2 * ind + 1] == 0)
query(2 * ind + 1, mid + 1, r);
else
query(2 * ind, l, mid);
}
void update(long long ind, long long l, long long r, long long ll, long long rr,
long long val) {
pushdown(ind, l, r);
if (r < ll || l > rr) return;
if (ll <= l && r <= rr) {
tree[ind] += val;
lazy[ind] += val;
return;
}
long long mid = (l + r) / 2;
update(2 * ind, l, mid, ll, rr, val);
update(2 * ind + 1, mid + 1, r, ll, rr, val);
tree[ind] = min(tree[2 * ind], tree[2 * ind + 1]);
}
int32_t main() {
cin >> n;
for (long long i = 1; i <= n; ++i) cin >> s[i];
build(1, 1, n);
for (long long i = 1; i <= n; ++i) {
long long t = query(1, 1, n);
ans[t] = i;
if (t < n) update(1, 1, n, t + 1, n, -i);
update(1, 1, n, t, t, 1e18);
}
for (long long i = 1; i <= n; ++i) cout << ans[i] << " ";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool cur1;
int n;
int ans[200005];
long long S[200005];
struct Bittree {
long long sum[200005];
inline void update(int x, int v) {
while (x <= n) {
sum[x] += v;
x += x & (-x);
}
}
inline long long query(int x) {
long long res = 0;
while (x) {
res += sum[x];
x ^= x & (-x);
}
return res;
}
} bit;
inline void Rd(int &res) {
char c;
res = 0;
while (c = getchar(), c < 48)
;
do res = (res << 3) + (res << 1) + (c ^ 48);
while (c = getchar(), c > 47);
return;
}
long long ch[200005];
inline bool check(int x, long long y) {
long long h = ch[x - 1] - bit.query(x - 1);
return h <= y;
}
bool cur2;
int main() {
Rd(n);
for (int i = 1; i <= n; i++) ch[i] = ch[i - 1] + i;
for (int i = 1; i <= n; i++) scanf("%lld", &S[i]);
for (int i = n; i >= 1; i--) {
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid, S[i]))
ans[i] = mid, l = mid + 1;
else
r = mid - 1;
}
bit.update(ans[i], ans[i]);
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
using namespace std;
void redirectIO() {
ios::sync_with_stdio(false);
cin.tie(0);
}
long long mVal[1100000];
long long upd[1100000];
long long s[210000];
void refr(int a) { mVal[a] = mVal[a * 2] + mVal[a * 2 + 1] + upd[a]; }
void push(int a) {
mVal[a * 2] += upd[a];
upd[a * 2] += upd[a];
mVal[a * 2 + 1] += upd[a];
upd[a * 2 + 1] += upd[a];
upd[a] = 0;
}
void build(int a, int beg, int end) {
if (beg == end) {
mVal[a] = beg - 1;
return;
}
build(a * 2, beg, (beg + end) / 2);
build(a * 2 + 1, (beg + end) / 2 + 1, end);
refr(a);
}
int targ_end;
int targ_beg;
long long targ_val;
void update(int a, int beg, int end) {
if (beg > targ_end || end < targ_beg) return;
if (beg >= targ_beg && end <= targ_end) {
upd[a] += targ_val;
mVal[a] += targ_val;
return;
}
push(a);
update(a * 2, beg, (beg + end) / 2);
update(a * 2 + 1, (beg + end) / 2 + 1, end);
refr(a);
}
int findIndex(int a, int beg, int end) {
if (beg == end) {
return beg;
}
push(a);
if (mVal[a * 2] < targ_val) {
targ_val -= mVal[a * 2];
return findIndex(a * 2 + 1, (beg + end) / 2 + 1, end);
}
return findIndex(a * 2, beg, (beg + end) / 2);
}
int main() {
redirectIO();
int n;
cin >> n;
for (int i = 1; i <= (n); i++) cin >> s[i];
build(1, 1, n);
set<int> ss;
for (int i = 1; i <= (n); i++) ss.insert(i);
vector<int> answer;
for (int i = n; i > 0; --i) {
targ_val = s[i];
int b = findIndex(1, 1, n);
int a = *ss.lower_bound(b);
ss.erase(a);
answer.push_back(a);
targ_beg = a + 1;
targ_end = a + 1;
targ_val = -a;
update(1, 1, n);
}
reverse(answer.begin(), answer.end());
for (int x : answer) cout << x << " ";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int N = 1e13 + 7;
long long int n;
vector<long long int> s(200004), p(200004), lazy(800004);
vector<long long int> tree(800004);
void build(long long int node, long long int l, long long int r) {
if (l == r) {
tree[node] = s[l];
return;
}
long long int mid = (l + r) / 2;
build(2 * node, l, mid);
build(2 * node + 1, mid + 1, r);
tree[node] = min(tree[2 * node], tree[2 * node + 1]);
}
void update(long long int node, long long int l, long long int r,
long long int st, long long int en, long long int val) {
if (l > en || r < st) {
return;
}
if (l >= st && r <= en) {
lazy[node] += val;
return;
}
long long int mid = (l + r) / 2;
update(2 * node, l, mid, st, en, val);
update(2 * node + 1, mid + 1, r, st, en, val);
tree[node] = min(tree[2 * node] + lazy[2 * node],
tree[2 * node + 1] + lazy[2 * node + 1]);
}
long long int query(long long int node, long long int l, long long int r,
long long int tot) {
if (l == r) {
return l;
}
long long int mid = (l + r) / 2;
tot += lazy[node];
if (tree[2 * node + 1] + tot + lazy[2 * node + 1] == 0) {
return query(2 * node + 1, mid + 1, r, tot);
}
return query(2 * node, l, mid, tot);
}
void solve() {
cin >> n;
for (long long int i = 1; i <= n; i++) {
cin >> s[i];
}
build(1, 1, n);
long long int i = 1;
while (i <= n) {
long long int u = query(1, 1, n, 0);
p[u] = i;
i++;
update(1, 1, n, u, u, N);
update(1, 1, n, u + 1, n, -i + 1);
}
for (long long int i = 1; i <= n; i++) {
cout << p[i] << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9, PI = acos(-1.);
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int N = 2e5 + 5;
int n;
long long mi[4 * N], pos[4 * N], v[N], lz[4 * N];
void build(int p, int l, int r) {
if (l == r) {
mi[p] = v[l], pos[p] = l;
return;
}
build(2 * p, l, (l + r) / 2);
build(2 * p + 1, (l + r) / 2 + 1, r);
mi[p] = min(mi[2 * p], mi[2 * p + 1]);
if (mi[p] == mi[2 * p + 1])
pos[p] = pos[2 * p + 1];
else
pos[p] = pos[2 * p];
}
void push(int p, int l, int r) {
if (lz[p]) {
mi[p] += lz[p];
if (l != r) {
lz[2 * p] += lz[p];
lz[2 * p + 1] += lz[p];
}
lz[p] = 0;
}
}
pair<long long, long long> query(int p, int l, int r, int i, int j) {
push(p, l, r);
if (r < i or l > j) return {LINF, 0};
if (l >= i and r <= j) return {mi[p], pos[p]};
pair<long long, long long> a = query(2 * p, l, (l + r) / 2, i, j);
pair<long long, long long> b = query(2 * p + 1, (l + r) / 2 + 1, r, i, j);
if (a.first < b.first)
return a;
else
return b;
}
void update(int p, int l, int r, int i, int j, long long v) {
push(p, l, r);
if (r < i or l > j) return;
if (l >= i and r <= j) {
lz[p] = v;
push(p, l, r);
return;
}
update(2 * p, l, (l + r) / 2, i, j, v);
update(2 * p + 1, (l + r) / 2 + 1, r, i, j, v);
mi[p] = min(mi[2 * p], mi[2 * p + 1]);
if (mi[p] == mi[2 * p + 1])
pos[p] = pos[2 * p + 1];
else
pos[p] = pos[2 * p];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &v[i]);
build(1, 1, n);
for (int i = 1; i <= n; i++) {
auto p = query(1, 1, n, 1, n);
assert(p.second);
v[p.second] = i;
update(1, 1, n, p.second + 1, n, -i);
update(1, 1, n, p.second, p.second, LINF);
}
for (int i = 1; i <= n; i++) printf("%lld ", v[i]);
printf("\n");
return 0;
}
| 10 | CPP |
from sys import stdin,stdout
def update(L,C,l,r,rt):
if l==r:
tree[rt]+=C
return
mid=(l+r)//2
if L<=mid:
update(L,C,l,mid,rt<<1)
else:
update(L,C,mid+1,r,rt<<1|1)
tree[rt]=tree[rt<<1]+tree[rt<<1|1]
def query(s,l,r,rt):
if l==r:
return l
mid=(l+r)//2
if tree[rt<<1]>s:
return query(s,l,mid,rt<<1)
else:
return query(s-tree[rt<<1],mid+1,r,rt<<1|1)
if __name__ == '__main__':
tree=[0]*800005
n=int(stdin.readline())
a=list(map(int,stdin.readline().split()))
for i in range(n):
update(i+1,i+1,1,n,1)
b=[0]*200005
for i in range(n,0,-1):
b[i]=query(a[i-1],1,n,1)
update(b[i],-b[i],1,n,1)
for i in range(n):
stdout.write('%d '%(b[i+1])) | 10 | PYTHON3 |
#include <bits/stdc++.h>
long long int min2(long long int a, long long int b) { return a > b ? a : b; }
long long int max2(long long int a, long long int b) { return a < b ? a : b; }
class node {
public:
int left, right;
long long int num, min;
bool isMinLeft;
bool willPropagate;
node *leftchild, *rightchild, *parent;
node(int left, int right, node *parent) {
this->left = left;
this->right = right;
this->min = this->num = 0;
this->isMinLeft = false;
this->parent = parent;
this->willPropagate = false;
if (left == right) {
this->leftchild = NULL;
this->rightchild = NULL;
} else {
int mid = (this->left + this->right) / 2;
this->leftchild = new node(this->left, mid, this);
this->rightchild = new node(mid + 1, this->right, this);
}
}
bool isLeaf() { return this->leftchild == NULL && this->rightchild == NULL; }
bool isIn(int index) { return (this->left <= index && index <= this->right); }
int updateDirection(int lbound, int rbound) {
if (this->left == lbound && this->right == rbound)
return 0;
else if (this->isLeaf() || lbound > rbound)
return -1;
else if (this->leftchild->isIn(lbound) && this->leftchild->isIn(rbound))
return 1;
else if (this->rightchild->isIn(lbound) && this->rightchild->isIn(rbound))
return 2;
else if (this->leftchild->isIn(lbound) && this->rightchild->isIn(rbound))
return 3;
else
return -1;
}
long long int parent_num_sum() {
node *ancestor = this;
long long int ans = 0;
while (ancestor != NULL) {
ans += ancestor->num;
ancestor = ancestor->parent;
}
return ans;
}
void singleUpdate() {
if (this->isLeaf()) {
this->min = this->num;
this->isMinLeft = true;
} else {
isMinLeft = true;
isMinLeft = (this->leftchild->min < this->rightchild->min);
this->min = num;
if (isMinLeft)
this->min += this->leftchild->min;
else
this->min += this->rightchild->min;
}
}
void upperPropagation() {
if (!this->willPropagate)
return;
else if (!this->isLeaf() && (this->leftchild->willPropagate ||
this->rightchild->willPropagate))
return;
else {
this->willPropagate = false;
this->singleUpdate();
if (this->parent != NULL) this->parent->upperPropagation();
}
}
void update(long long int val, int lbound, int rbound) {
int dir = this->updateDirection(lbound, rbound);
if (dir == -1) return;
this->willPropagate = true;
if (dir == 0) {
this->num += val;
this->upperPropagation();
} else if (dir == 1) {
this->leftchild->willPropagate = true;
this->leftchild->update(val, lbound, rbound);
} else if (dir == 2) {
this->rightchild->willPropagate = true;
this->rightchild->update(val, lbound, rbound);
} else if (dir == 3) {
this->leftchild->willPropagate = true;
this->rightchild->willPropagate = true;
this->leftchild->update(val, lbound, this->leftchild->right);
this->rightchild->update(val, this->rightchild->left, rbound);
}
}
long long int search(int lbound, int rbound) {
int dir = this->updateDirection(lbound, rbound);
if (dir == -1)
throw "Invalid range";
else if (dir == 0) {
return min;
} else if (dir == 1)
return this->leftchild->search(lbound, rbound) + num;
else if (dir == 2)
return this->rightchild->search(lbound, rbound) + num;
else if (dir == 3) {
if (this->isMinLeft)
return leftchild->search(lbound, leftchild->right) + num;
else
return rightchild->search(rightchild->left, rbound) + num;
}
}
int findMinimumIndex() {
if (this->isLeaf())
return this->left;
else if (this->isMinLeft)
return leftchild->findMinimumIndex();
else
return rightchild->findMinimumIndex();
}
void print(int tabLevel) {
for (int i = 0; i < tabLevel - 1; i++) printf("| ");
if (tabLevel > 0) printf("+-- ");
printf("Node covering [%d, %d]: num %lld, min %lld, isLeft %c\n",
this->left, this->right, this->num, this->min,
isMinLeft ? 'L' : 'R');
if (!this->isLeaf()) {
this->leftchild->print(tabLevel + 1);
this->rightchild->print(tabLevel + 1);
}
}
};
int main(void) {
int n;
scanf("%d", &n);
std::vector<long long int> sum(n, 0);
node *root = new node(0, n - 1, NULL);
for (int i = 0; i < n; i++) {
scanf("%lld", &sum[i]);
root->update(sum[i], i, i);
}
std::vector<int> perm(n, -1);
for (int num = 1; num <= n; num++) {
int rightmost = root->findMinimumIndex();
root->update(-num, rightmost, n - 1);
root->update(1LL << 40, rightmost, rightmost);
perm[rightmost] = num;
}
for (int i = 0; i < n; i++) printf("%d ", perm[i]);
printf("\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const double EPS = 1e-9;
const long long MOD = (long long)(1e9 + 7);
const long long MAXV = (long long)(2e5 + 10);
const long long MAXE = (long long)(1e6 + 10);
long long seg[MAXV * 4];
long long lazy[MAXV * 4];
long long A[MAXV * 4];
void build(int n, int s, int e) {
if (s + 1 == e) {
seg[n] = A[s];
} else {
int m = (s + e) >> 1;
build(n * 2, s, m);
build(n * 2 + 1, m, e);
seg[n] = min(seg[n * 2], seg[n * 2 + 1]);
}
}
void add_lazy(int n, long long x) {
lazy[n] += x;
seg[n] += x;
}
void push(int n, int s, int e) {
if (s + 1 == e) return;
add_lazy(n * 2, lazy[n]);
add_lazy(n * 2 + 1, lazy[n]);
lazy[n] = 0;
}
void update(int n, int s, int e, int a, int b, long long x) {
if (s >= b || e <= a) return;
if (s >= a && e <= b)
add_lazy(n, x);
else {
if (lazy[n]) push(n, s, e);
int m = (s + e) >> 1;
update(n * 2, s, m, a, b, x);
update(n * 2 + 1, m, e, a, b, x);
seg[n] = min(seg[n * 2], seg[n * 2 + 1]);
}
}
int query(int n, int s, int e) {
if (s + 1 == e)
return s;
else {
if (lazy[n]) push(n, s, e);
int m = (s + e) >> 1;
long long ans;
if (seg[n * 2] < seg[n * 2 + 1])
ans = query(n * 2, s, m);
else
ans = query(n * 2 + 1, m, e);
seg[n] = min(seg[n * 2], seg[n * 2 + 1]);
return ans;
}
}
int n;
long long ans[MAXV];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> A[i];
build(1, 0, n);
long long curr = 1;
for (int i = 0; i < n; i++) {
int p = query(1, 0, n);
ans[p] = curr;
update(1, 0, n, p + 1, n, -curr);
update(1, 0, n, p, p + 1, INF);
curr++;
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = ~0ull >> 1;
long long _min[2000005 * 5], add[2000005 * 5];
int n;
long long s[2000005];
int ans[2000005];
void pushup(int o) { _min[o] = min(_min[o << 1], _min[o << 1 | 1]); }
void pushdown(int o) {
if (add[o]) {
add[o << 1] += add[o];
add[o << 1 | 1] += add[o];
_min[o << 1] += add[o];
_min[o << 1 | 1] += add[o];
add[o] = 0;
}
}
void build(int o, int l, int r) {
if (l == r) {
_min[o] = s[l];
return;
}
int m = (l + r) >> 1;
build(o << 1, l, m);
build(o << 1 | 1, m + 1, r);
pushup(o);
}
void update(int o, int l, int r, int ql, int qr, long long v) {
if (ql <= l && qr >= r) {
add[o] += v;
_min[o] += v;
return;
}
pushdown(o);
int m = (l + r) >> 1;
if (ql <= m && qr >= l) update(o << 1, l, m, ql, qr, v);
if (ql <= r && qr >= m + 1) update(o << 1 | 1, m + 1, r, ql, qr, v);
pushup(o);
}
int query(int o, int l, int r, long long v) {
if (l == r) {
return l;
}
pushdown(o);
int m = (l + r) >> 1;
if (_min[o << 1 | 1] == v)
return query(o << 1 | 1, m + 1, r, v);
else
return query(o << 1, l, m, v);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
build(1, 1, n);
for (int i = 0; i < n; i++) {
long long v = _min[1];
int pos = query(1, 1, n, v);
ans[pos] = i + 1;
update(1, 1, n, pos, pos, INF);
if (pos < n) update(1, 1, n, pos + 1, n, -1 * (i + 1));
}
for (int i = 1; i <= n; i++) {
if (i != 1) cout << " ";
cout << ans[i];
}
cout << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long n, tag[N << 2], ans[N], pos;
long long a[N], val[N << 2];
inline void pushup(long long o) { val[o] = min(val[o << 1], val[o << 1 | 1]); }
inline void apply(long long o, long long x) { val[o] += x, tag[o] += x; }
inline void pushdown(long long o) {
if (tag[o]) {
apply(o << 1, tag[o]);
apply(o << 1 | 1, tag[o]);
tag[o] = 0;
}
}
inline void build(long long o, long long l, long long r) {
if (l == r) {
val[o] = a[l];
return;
}
long long mid = (l + r) >> 1;
build(o << 1, l, mid), build(o << 1 | 1, mid + 1, r);
pushup(o);
}
inline void change(long long o, long long l, long long r, long long x,
long long y, long long z) {
if (x <= l && r <= y) {
apply(o, z);
return;
}
long long mid = (l + r) >> 1;
pushdown(o);
if (x <= mid) change(o << 1, l, mid, x, y, z);
if (y > mid) change(o << 1 | 1, mid + 1, r, x, y, z);
pushup(o);
}
inline long long last_zero(long long o, long long l, long long r) {
if (l == r) return l;
pushdown(o);
long long mid = (l + r) >> 1;
if (val[o << 1 | 1] == 0)
return last_zero(o << 1 | 1, mid + 1, r);
else
return last_zero(o << 1, l, mid);
}
inline long long query_min(long long o, long long l, long long r, long long x,
long long y) {
if (l == r) return val[o];
pushdown(o);
long long mid = (l + r) >> 1;
long long res = INF;
if (x <= mid)
res = min(res, query_min(o << 1, l, mid, x, y));
else if (y > mid)
res = min(res, query_min(o << 1 | 1, mid + 1, r, x, y));
return res;
}
signed main() {
cin >> n;
for (register long long i = (1); i <= (n); ++i) cin >> a[i];
memset(val, INF, sizeof(val));
build(1, 1, n);
for (register long long i = (1); i <= (n); ++i) {
pos = last_zero(1, 1, n);
if (pos == 1) cerr << i << ' ' << pos << endl;
ans[pos] = i;
change(1, 1, n, pos, pos, INF);
change(1, 1, n, pos, n, -1ll * i);
}
for (register long long i = (1); i <= (n); ++i) cout << ans[i] << ' ';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a[3000000], tree[4 * 3000000], ans[4 * 3000000];
int n;
void update(int indx, int left, int right, int pos, long long val) {
if (left > pos || right < pos) return;
if (left == right) {
tree[indx] += val;
return;
}
int mid = (left + right) >> 1;
update(indx * 2, left, mid, pos, val);
update(indx * 2 + 1, mid + 1, right, pos, val);
tree[indx] = tree[indx * 2] + tree[indx * 2 + 1];
}
long long query(int indx, int l, int r, int left, int right) {
if (left > right || l > right || r < left) return 0;
if (l >= left && r <= right) return tree[indx];
int mid = (l + r) >> 1;
long long x = query(indx * 2, l, mid, left, right);
long long y = query(indx * 2 + 1, mid + 1, r, left, right);
return x + y;
}
int doit(long long val) {
int low = 1, high = n, ans = 1;
while (low <= high) {
int mid = (low + high) >> 1;
long long xx = query(1, 1, n, 1, mid - 1);
if (xx <= val) {
low = mid + 1;
ans = mid;
} else
high = mid - 1;
}
return ans;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.setf(ios::fixed);
cout.precision(20);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) update(1, 1, n, i, i);
for (int i = n; i > 0; i--) {
ans[i] = doit(a[i]);
update(1, 1, n, ans[i], -1ll * ans[i]);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long m) {
a %= m;
long long ret = 1;
while (b) {
if (b & 1) ret = ((ret % m) * (a % m)) % m;
a = ((a % m) * (a % m)) % m;
b >>= 1;
}
return ret;
}
const int N = 2e5 + 5;
long long n, bit[N + 3], a[N + 2], ans[N + 2];
void update(long long val, int x) {
for (; x <= N; x += x & (-x)) {
bit[x] += val;
}
}
long long query(int x) {
int tm = x;
long long ret = 0;
while (x > 0) {
ret += bit[x];
x -= x & (-x);
}
ret += ans[tm - 1];
return ret;
}
void pre() {
long long now = 0;
ans[0] = 0;
for (long long i = 1; i < N; i++) {
now += i;
ans[i] = now;
}
}
int main() {
pre();
cin >> n;
vector<long long> vec;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = n - 1; i >= 0; i--) {
int l = 1, r = n + 1, mid;
while ((r - l) > 1) {
mid = (l + r) / 2;
long long result = query(mid);
if (result <= a[i]) {
l = mid;
} else {
r = mid;
}
}
if (query(l + 1) == a[i]) {
vec.push_back(l + 1);
update(-(l + 1), l + 2);
} else {
vec.push_back(l);
update(-(l), l + 1);
}
}
reverse(vec.begin(), vec.end());
for (auto it : vec) {
cout << it << " ";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const long long inf = 0x3f3f3f3f;
const long long inn = 0x80808080;
using namespace std;
const long long maxm = 2e5 + 5;
long long mi[maxm << 2];
long long laz[maxm << 2];
long long p[maxm];
long long n;
void pushup(long long node) { mi[node] = min(mi[node * 2], mi[node * 2 + 1]); }
void pushdown(long long node) {
if (laz[node]) {
mi[node * 2] += laz[node];
mi[node * 2 + 1] += laz[node];
laz[node * 2] += laz[node];
laz[node * 2 + 1] += laz[node];
laz[node] = 0;
}
}
void build(long long l, long long r, long long node) {
if (l == r) {
cin >> mi[node];
return;
}
long long mid = (l + r) / 2;
build(l, mid, node * 2);
build(mid + 1, r, node * 2 + 1);
pushup(node);
}
long long ask(long long x, long long l, long long r, long long node) {
if (l == r) {
mi[node] = (1LL << 60);
return l;
}
long long mid = (l + r) / 2;
pushdown(node);
long long ans = 1;
if (mi[node * 2 + 1] <= x)
ans = ask(x, mid + 1, r, node * 2 + 1);
else
ans = ask(x, l, mid, node * 2);
pushup(node);
return ans;
}
void update(long long st, long long ed, long long val, long long l, long long r,
long long node) {
if (st <= l && ed >= r) {
mi[node] += val;
laz[node] += val;
return;
}
pushdown(node);
long long mid = (l + r) / 2;
if (st <= mid) update(st, ed, val, l, mid, node * 2);
if (ed >= mid) update(st, ed, val, mid + 1, r, node * 2 + 1);
pushup(node);
}
signed main() {
ios::sync_with_stdio(0);
cin >> n;
build(1, n, 1);
for (long long i = 1; i <= n; i++) {
long long x = ask(0, 1, n, 1);
p[x] = i;
if (x != n) {
update(x + 1, n, -i, 1, n, 1);
}
}
for (long long i = 1; i <= n; i++) {
cout << p[i] << ' ';
}
cout << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, i, e, f, g, n, m, k, l, A[200005], B[200005], mid, le, ri,
BITree[4000005], ans, fix[200005];
long long getSum(long long index) {
long long sum = 0;
while (index > 0) {
sum += BITree[index];
index -= index & (-index);
}
return sum;
}
void updateBIT(long long index, long long val) {
while (index <= 1000005) {
BITree[index] += val;
index += index & (-index);
}
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> A[i];
updateBIT(i, i);
}
for (long long i = n; i >= 1; i--) {
le = 0;
ri = n;
while (le <= ri) {
mid = (le + ri) / 2;
a = getSum(mid);
if (a > A[i]) {
ri = mid - 1;
} else if (a <= A[i]) {
ans = mid;
le = mid + 1;
}
}
updateBIT(ans + 1, -(ans + 1));
B[i] = ans + 1;
fix[ans + 1] = 1;
}
for (long long i = 1; i <= n; i++) cout << B[i] << " ";
}
| 10 | CPP |
from sys import stdin,stdout
class Tree(object):
def __init__(self,n):
self.tree=[0]*(4*n+10)
def update(self,L,C,l,r,rt):
if l==r:
self.tree[rt]+=C
return
mid=(l+r)//2
if L<=mid:
self.update(L,C,l,mid,rt<<1)
else:
self.update(L,C,mid+1,r,rt<<1|1)
self.tree[rt]=self.tree[rt<<1]+self.tree[rt<<1|1]
def query(self,s,l,r,rt):
if l==r:
return l
mid=(l+r)//2
if self.tree[rt<<1]>s:
return self.query(s,l,mid,rt<<1)
else:
return self.query(s-self.tree[rt<<1],mid+1,r,rt<<1|1)
if __name__ == '__main__':
n=int(stdin.readline())
a=list(map(int,stdin.readline().split()))
b=[0]*(n+10)
seg=Tree(n)
for i in range(n):
seg.update(i+1,i+1,1,n,1)
for i in range(n,0,-1):
b[i]=seg.query(a[i-1],1,n,1)
seg.update(b[i],-b[i],1,n,1)
for i in range(n):
stdout.write('%d '%(b[i+1]))
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> tree[4 * 200005 + 1];
long long lo[4 * 200005 + 1], hi[4 * 200005 + 1], a[200005],
delta[4 * 200005 + 1], ans[200005];
void init(long long i, long long a, long long b) {
lo[i] = a;
hi[i] = b;
if (a == b) return;
long long m = (a + b) / 2;
init(2 * i, a, m);
init(2 * i + 1, m + 1, b);
}
void merge(long long i0, long long i1, long long i2) {
if (tree[i1].first + delta[i1] == tree[i2].first + delta[i2])
tree[i0] = {tree[i1].first + delta[i1],
max(tree[i1].second, tree[i2].second)};
else if (tree[i1].first + delta[i1] < tree[i2].first + delta[i2])
tree[i0] = {tree[i1].first + delta[i1], tree[i1].second};
else
tree[i0] = {tree[i2].first + delta[i2], tree[i2].second};
}
void build(long long i) {
long long l = lo[i];
long long r = hi[i];
if (l == r) {
tree[i] = {a[l], l};
return;
}
build(2 * i);
build(2 * i + 1);
merge(i, 2 * i, 2 * i + 1);
}
void prop(long long i) {
delta[2 * i] += delta[i];
delta[2 * i + 1] += delta[i];
delta[i] = 0;
}
void range_update(long long i, long long a, long long b, long long val) {
if (b < lo[i] || hi[i] < a) return;
if (a <= lo[i] && hi[i] <= b) {
delta[i] += val;
return;
}
prop(i);
range_update(2 * i, a, b, val);
range_update(2 * i + 1, a, b, val);
merge(i, 2 * i, 2 * i + 1);
}
pair<long long, long long> query(long long i, long long l, long long r) {
if (r < lo[i] || hi[i] < l) {
return {(long long)1e12, (long long)1e12};
}
if (l <= lo[i] && hi[i] <= r) {
return {tree[i].first + delta[i], tree[i].second};
}
prop(i);
pair<long long, long long> minr = query(2 * i, l, r);
pair<long long, long long> minl = query(2 * i + 1, l, r);
merge(i, 2 * i, 2 * i + 1);
return tree[i];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
init(1, 1, n);
build(1);
for (long long i = 1; i <= n; i++) {
long long t = query(1, 1, n).second;
ans[t] = i;
range_update(1, t + 1, n, -i);
range_update(1, t, t, (long long)1e12);
}
for (long long i = 1; i <= n; i++) cout << ans[i] << " ";
cout << "\n";
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize "03"
using namespace std;
const long long int N = 2e5 + 5;
const long long int mod = 1e9 + 7;
const long long int inf = 1e18 + 9;
long long int a[N];
long long int t[4 * N], lzy[4 * N];
void build(long long int nd, long long int s, long long int e) {
if (s == e)
t[nd] = a[s], a[s] = 0;
else {
long long int md = (s + e) >> 1;
build(2 * nd, s, md);
build(2 * nd + 1, md + 1, e);
t[nd] = min(t[2 * nd], t[2 * nd + 1]);
}
}
void pushdown(long long int nd, long long int s, long long int e) {
if (s == e) {
t[nd] -= lzy[nd];
lzy[nd] = 0;
return;
}
lzy[2 * nd] += lzy[nd];
lzy[2 * nd + 1] += lzy[nd];
t[nd] -= lzy[nd];
lzy[nd] = 0;
}
void upd(long long int nd, long long int s, long long int e, long long int l,
long long int r, long long int v) {
if (s > r || e < l || l > r) return;
if (s >= l && e <= r) {
lzy[nd] += v;
return;
}
pushdown(nd, s, e);
long long int md = (s + e) >> 1;
upd(2 * nd, s, md, l, r, v);
upd(2 * nd + 1, md + 1, e, l, r, v);
t[nd] = min(t[2 * nd] - lzy[2 * nd], t[2 * nd + 1] - lzy[2 * nd + 1]);
}
long long int query(long long int nd, long long int s, long long int e) {
pushdown(nd, s, e);
if (s == e) return s;
long long int md = (s + e) >> 1;
long long int p;
if (t[2 * nd + 1] - lzy[2 * nd + 1] == 0)
p = query(2 * nd + 1, md + 1, e);
else
p = query(2 * nd, s, md);
t[nd] = min(t[2 * nd] - lzy[2 * nd], t[2 * nd + 1] - lzy[2 * nd + 1]);
return p;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
for (long long int i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
for (long long int i = 1; i <= n; i++) {
long long int id = query(1, 1, n);
a[id] = i;
upd(1, 1, n, id, id, -inf);
upd(1, 1, n, id + 1, n, i);
}
for (long long int i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9, PI = acos(-1.);
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int N = 2e5 + 5;
int n, ans[N];
long long mi[4 * N], pos[4 * N], v[N], lz[4 * N];
void build(int p, int l, int r) {
if (l == r) {
mi[p] = v[l], pos[p] = l;
return;
}
int m = (l + r) / 2;
build(2 * p, l, m);
build(2 * p + 1, m + 1, r);
mi[p] = min(mi[2 * p], mi[2 * p + 1]);
if (mi[p] == mi[2 * p + 1])
pos[p] = pos[2 * p + 1];
else
pos[p] = pos[2 * p];
}
void push(int p, int l, int r) {
if (lz[p]) {
mi[p] += lz[p];
if (l != r) {
lz[2 * p] += lz[p];
lz[2 * p + 1] += lz[p];
}
lz[p] = 0;
}
}
pair<long long, long long> query(int p, int l, int r, int i, int j) {
push(p, l, r);
if (r < i or l > j) assert(0);
if (i <= l and r <= j) return {mi[p], pos[p]};
int m = (l + r) / 2;
if (m > j) return query(2 * p, l, m, i, j);
if (m < i) return query(2 * p + 1, m + 1, r, i, j);
pair<long long, long long> a = query(2 * p, l, m, i, j);
pair<long long, long long> b = query(2 * p + 1, m + 1, r, i, j);
if (a.first < b.first)
return a;
else
return b;
}
void update(int p, int l, int r, int i, int j, long long v) {
push(p, l, r);
if (r < i or l > j) return;
if (i <= l and r <= j) {
lz[p] = v;
push(p, l, r);
return;
}
update(2 * p, l, (l + r) / 2, i, j, v);
update(2 * p + 1, (l + r) / 2 + 1, r, i, j, v);
mi[p] = min(mi[2 * p], mi[2 * p + 1]);
if (mi[p] == mi[2 * p + 1])
pos[p] = pos[2 * p + 1];
else
pos[p] = pos[2 * p];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &v[i]);
build(1, 1, n);
memset(ans, -1, sizeof(ans));
for (int i = 1; i <= n; i++) {
auto p = query(1, 1, n, 1, n);
ans[p.second] = i;
update(1, 1, n, p.second + 1, n, -i);
update(1, 1, n, p.second, p.second, LINF);
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 10 | CPP |
class DualBIT():
def __init__(self, n):
self.n = n
self.bit = [0] * (n + 1)
def get(self, i):
'''i番目の要素を取得'''
i = i + 1
s = 0
while i <= self.n:
s += self.bit[i]
i += i & -i
return s
def _add(self, i, x):
while i > 0:
self.bit[i] += x
i -= i & -i
def add(self, i, j, x):
'''[i, j)の要素にxを加算する'''
self._add(j, x)
self._add(i, -x)
n = int(input())
a = list(map(int, input().split()))
bit = DualBIT(n+3)
for i in range(1, n+1):
bit.add(i+1, n+1, i)
li = []
flag = False
while True:
if not a:
break
ok = n + 1
ng = 0
num = a[-1]
if num == 0 and not flag:
flag = True
bit.add(1, n + 2, -1)
li.append(1)
del a[-1]
continue
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if bit.get(mid) > num:
ok = mid
else:
ng = mid
tmp = ok - 1
bit.add(ok, n + 2, -tmp)
li.append(tmp)
del a[-1]
print(*li[::-1])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
long long n, a[N], c[N], p[N];
inline long long read() {
long long ret = 0, f = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
ret = ret * 10 + c - 48;
c = getchar();
}
if (f) return -ret;
return ret;
}
long long lowbit(long long x) { return x & -x; }
void add(long long x, long long y) {
while (x <= n) {
c[x] += y;
x += lowbit(x);
}
}
long long sum(long long x) {
long long res = 0;
while (x > 0) {
res += c[x];
x -= lowbit(x);
}
return res;
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) add(i, i);
for (long long i = n; i; i--) {
long long l = 1, r = n;
while (l < r) {
long long mid = (l + r + 1) / 2;
if (sum(mid - 1) <= a[i])
l = mid;
else
r = mid - 1;
}
p[i] = r;
add(r, -r);
}
for (long long i = 1; i <= n; i++) printf("%d ", p[i]);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long n = 1, n2, s[200010], ans[200010], dat[800010];
void INIT(long long k, long long lb, long long ub) {
if (lb == ub) return;
INIT(k * 2 + 1, lb, (lb + ub) / 2);
INIT(k * 2 + 2, (lb + ub) / 2 + 1, ub);
dat[k] = dat[k * 2 + 1] + dat[k * 2 + 2];
}
long long query(long long k, long long lb, long long ub, long long tlb,
long long tub) {
if (ub < tlb || tub < lb) return 0;
if (tlb <= lb && ub <= tub) return dat[k];
return query(k * 2 + 1, lb, (lb + ub) / 2, tlb, tub) +
query(k * 2 + 2, (lb + ub) / 2 + 1, ub, tlb, tub);
}
void upd(long long val) {
long long k = val - 1 + n - 1;
dat[k] -= val;
while (k > 0) {
dat[(k - 1) / 2] -= val;
k = (k - 1) / 2;
}
}
bool check(long long mid, long long i) {
return query(0, 0, n - 1, 0, mid - 2) <= s[i];
}
int main() {
cin >> n2;
while (n < n2) n *= 2;
for (int i = 0; i < n2; i++) scanf("%I64d", &s[i]);
for (int i = 0; i < n; i++) dat[i + n - 1] = i + 1;
INIT(0, 0, n - 1);
for (int i = n2 - 1; i >= 0; i--) {
int lb = 1, ub = n2, mid;
while (lb < ub) {
mid = (lb + ub + 1) / 2;
if (check(mid, i))
lb = mid;
else
ub = mid - 1;
}
ans[i] = lb;
upd(lb);
}
check(2, 2);
for (int i = 0; i < n2; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200200;
long long mn[4 * maxn], ps[4 * maxn], ls[4 * maxn];
void push(int i, int l, int r) {
if (ls[i]) {
mn[i] += ls[i];
if (l != r) {
ls[2 * i] += ls[i];
ls[2 * i + 1] += ls[i];
}
ls[i] = 0;
}
}
void pull(int i) {
long long m = min(mn[2 * i], mn[2 * i + 1]);
mn[i] = m;
ps[i] = m == mn[2 * i + 1] ? ps[2 * i + 1] : ps[2 * i];
}
long long arr[maxn];
void build(int i, int l, int r) {
if (l == r) {
mn[i] = arr[l];
ps[i] = l;
} else {
int m = (l + r) / 2;
build(2 * i, l, m);
build(2 * i + 1, m + 1, r);
pull(i);
}
}
void add(int i, int l, int r, int x, int y, long long v) {
push(i, l, r);
if (l > y || r < x) return;
if (x <= l && r <= y) {
ls[i] += v;
push(i, l, r);
return;
}
int m = (l + r) / 2;
add(2 * i, l, m, x, y, v);
add(2 * i + 1, m + 1, r, x, y, v);
pull(i);
}
int ans[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld", arr + i);
build(1, 0, n - 1);
for (int i = 1; i <= n; i++) {
int p = ps[1];
ans[p] = i;
if (p != n - 1) {
add(1, 0, n - 1, p + 1, n - 1, -i);
}
add(1, 0, n - 1, p, p, 1ll << 50);
}
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
bool b = 0;
char c;
while (!isdigit(c = getchar()) && c != '-')
;
if (c == '-') c = getchar(), b = 1;
x = c - 48;
while (isdigit(c = getchar())) x = (x << 3) + (x << 1) + c - 48;
if (b) x = -x;
}
template <typename T>
inline void wrip(T x) {
if (x > 9) wrip(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void write(T x) {
if (x < 0) putchar('-'), x = -x;
wrip(x);
}
void reads(string &s) {
char c;
while (!isalpha(c = getchar()))
;
s = c;
while (isalpha(c = getchar())) s += c;
}
const long long mod = 1e9 + 7;
const int N = 2e5 + 11;
int n, a[N];
long long s[N], it[4 * N], lazy[4 * N];
void push(int id) {
it[id << 1] += lazy[id];
it[(id << 1) + 1] += lazy[id];
lazy[id << 1] += lazy[id];
lazy[(id << 1) + 1] += lazy[id];
lazy[id] = 0;
}
void update(int id, int l, int r, int u, int v, long long val) {
if (l > v || r < u) return;
if (u <= l && r <= v) {
lazy[id] += val;
it[id] += val;
return;
}
if (lazy[id]) push(id);
int mid = l + r >> 1;
update(id << 1, l, mid, u, v, val);
update((id << 1) + 1, mid + 1, r, u, v, val);
it[id] = min(it[id << 1], it[(id << 1) + 1]);
}
int Find(int id, int l, int r, long long val) {
if (it[id] > val) return l - 1;
if (l == r) return l;
if (lazy[id]) push(id);
int mid = l + r >> 1;
if (it[(id << 1) + 1] <= val) return Find((id << 1) + 1, mid + 1, r, val);
return Find(id << 1, l, mid, val);
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(s[i]);
for (int i = 1; i <= n; i++) {
s[0] += i;
update(1, 1, n, i, i, s[0]);
}
for (int i = n; i > 0; i--) {
int pos = Find(1, 1, n, s[i]);
a[i] = pos + 1;
update(1, 1, n, pos + 1, n, -a[i]);
}
for (int i = 1; i <= n; i++) {
write(a[i]);
putchar(' ');
}
}
| 10 | CPP |
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
from sys import stdin, stdout
from collections import defaultdict
from collections import deque
import math
import copy
#T = int(input())
N = int(input())
#s1 = input()
#s2 = input()
#N,Q = [int(x) for x in stdin.readline().split()]
arr = [int(x) for x in stdin.readline().split()]
bit = [0]*N
series = [x for x in range(N)]
def lowbit(x):
return x&(-x)
def update(idx,delta):
while idx<N:
bit[idx] += delta
idx += lowbit(idx)
def query(x):
s = 0
while x>0:
s += bit[x]
x -= lowbit(x)
return s
# init
for i in range(N):
bit[i] += series[i]
y = i + lowbit(i)
if y<N:
series[y] += series[i]
visited = [0]*N
ans = [0]*N
for i in range(N-1,-1,-1):
# find
left = 0
right = N-1
target = arr[i]
while left<=right:
mid = (left+right)//2
q = query(mid)
if q<target:
left = mid + 1
elif q>target:
right = mid - 1
else:
if visited[mid]==1:
left = mid + 1
else:
visited[mid] = 1
ans[i] = mid + 1
break
# update
if mid+1<N:
update(mid+1,-mid-1)
print(*ans)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 2e5 + 5, M = 2 * N + 5;
int n;
long long tree[1 << 19], a[N];
void build(int i, int l, int r) {
if (l == r) {
tree[i] = l;
return;
}
int mid = (l + r) / 2;
build(i * 2, l, mid);
build(i * 2 + 1, mid + 1, r);
tree[i] = tree[i * 2] + tree[i * 2 + 1];
}
void update(int i, int l, int r, int trgt, int val) {
if (!(trgt >= l && trgt <= r)) return;
if (l == r) {
tree[i] = val;
return;
}
int mid = (l + r) / 2;
update(i * 2, l, mid, trgt, val);
update(i * 2 + 1, mid + 1, r, trgt, val);
tree[i] = tree[i * 2] + tree[i * 2 + 1];
}
long long getsum(int i, int l, int r, int a, int b) {
if (a > r || b < l) return 0;
if (a <= l && r <= b) return tree[i];
int mid = (l + r) / 2;
return getsum(i * 2, l, mid, a, b) + getsum(i * 2 + 1, mid + 1, r, a, b);
}
int bs(long long sum) {
int l = 0, r = n - 1, mid, ans = -1;
while (l <= r) {
mid = (l + r) / 2;
long long total = getsum(1, 0, n - 1, 0, mid);
if (total > sum)
r = mid - 1;
else {
ans = mid;
l = mid + 1;
}
}
assert(ans != -1);
return ans;
}
int ans[N];
int main() {
scanf("%d", &n);
int nn = n;
++n;
build(1, 0, n - 1);
for (int i = 0; i < nn; ++i) scanf("%lld", a + i);
for (int i = nn - 1; ~i; --i) {
int idx = bs(a[i]) + 1;
ans[i] = idx;
update(1, 0, n - 1, idx, 0);
}
for (int i = 0; i < nn; ++i) printf("%d%c", ans[i], " \n"[i == nn - 1]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[200007];
long long bit[200007];
long long ans[200007];
long long query(long long id) {
long long res = 0;
while (id) {
res += bit[id];
id -= (id & (-id));
}
return res;
}
void add(long long id, long long val) {
while (id <= n) {
bit[id] += val;
id += (id & (-id));
}
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 1; i <= n; i++) add(i, i);
for (long long i = n; i >= 1; i--) {
long long lo = 1, hi = n;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (query(mid - 1) > a[i]) {
hi = mid - 1;
} else {
lo = mid + 1;
ans[i] = mid;
}
}
add(ans[i], -1 * ans[i]);
}
for (long long i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 10 | CPP |
# class SegmentTree(): # adapted from https://www.geeksforgeeks.org/segment-tree-efficient-implementation/
# def __init__(self,arr,func,initialRes=0):
# self.f=func
# self.N=len(arr)
# self.tree=[0 for _ in range(2*self.N)]
# self.initialRes=initialRes
# for i in range(self.N):
# self.tree[self.N+i]=arr[i]
# for i in range(self.N-1,0,-1):
# self.tree[i]=self.f(self.tree[i<<1],self.tree[i<<1|1])
# def updateTreeNode(self,idx,value): #update value at arr[idx]
# self.tree[idx+self.N]=value
# idx+=self.N
# i=idx
# while i>1:
# self.tree[i>>1]=self.f(self.tree[i],self.tree[i^1])
# i>>=1
# def query(self,l,r): #get sum (or whatever function) on interval [l,r] inclusive
# r+=1
# res=self.initialRes
# l+=self.N
# r+=self.N
# while l<r:
# if l&1:
# res=self.f(res,self.tree[l])
# l+=1
# if r&1:
# r-=1
# res=self.f(res,self.tree[r])
# l>>=1
# r>>=1
# return res
# def getMaxSegTree(arr):
# return SegmentTree(arr,lambda a,b:max(a,b),initialRes=-float('inf'))
# def getMinSegTree(arr):
# return SegmentTree(arr,lambda a,b:min(a,b),initialRes=float('inf'))
# def getSumSegTree(arr):
# return SegmentTree(arr,lambda a,b:a+b,initialRes=0)
from collections import Counter
def main():
# mlogn solution
n=int(input())
a=readIntArr()
b=sorted(a,reverse=True)
m=int(input())
allans=[]
for _ in range(m):
k,pos=readIntArr()
cnt=Counter(b[:k])
totalCnts=0
for x in a:
if cnt[x]>0:
cnt[x]-=1
totalCnts+=1
if totalCnts==pos:
allans.append(x)
break
multiLineArrayPrint(allans)
return
import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
# input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
def makeArr(defaultValFactory,dimensionArr): # eg. makeArr(lambda:0,[n,m])
dv=defaultValFactory;da=dimensionArr
if len(da)==1:return [dv() for _ in range(da[0])]
else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
def queryInteractive(i,j):
print('? {} {}'.format(i,j))
sys.stdout.flush()
return int(input())
def answerInteractive(ans):
print('! {}'.format(' '.join([str(x) for x in ans])))
sys.stdout.flush()
inf=float('inf')
MOD=10**9+7
# MOD=998244353
for _abc in range(1):
main() | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
vector<int> v2 = v;
sort(v.rbegin(), v.rend());
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int k, ind;
cin >> k >> ind;
multiset<int> kmax;
for (int i = 0; i < k; ++i) {
kmax.insert(v[i]);
}
vector<int> seq;
for (int i = 0; i < n; ++i) {
auto it = kmax.find(v2[i]);
if (it != kmax.end()) {
kmax.erase(it);
seq.push_back(v2[i]);
}
if (seq.size() == k) {
break;
}
}
cout << seq[ind - 1] << "\n";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> s[110][110], answer[110];
long long dp[110][110];
long long val[110];
int arr[110];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
dp[i][j] = arr[j];
s[i][j].push_back(arr[j]);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; ++j) {
for (int k = 1; k <= j - 1; ++k) {
if (dp[i - 1][k] + arr[j] > dp[i][j]) {
dp[i][j] = dp[i - 1][k] + arr[j];
s[i][j] = s[i - 1][k];
s[i][j].push_back(arr[j]);
} else if (dp[i - 1][k] + arr[j] == dp[i][j]) {
for (int l = 0; l < s[i - 1][k].size(); ++l) {
if (s[i - 1][k][l] < s[i][j][l]) {
s[i][j] = s[i - 1][k];
s[i][j].push_back(arr[j]);
break;
} else if (s[i - 1][k][l] > s[i][j][l]) {
break;
}
}
}
}
if (dp[i][j] > val[i]) {
val[i] = dp[i][j];
answer[i] = s[i][j];
} else if (dp[i][j] == val[i]) {
for (int l = 0; l < s[i][j].size(); ++l) {
if (s[i][j][l] < answer[i][l]) {
answer[i] = s[i][j];
break;
} else if (s[i][j][l] > answer[i][l]) {
break;
}
}
}
}
}
int q;
cin >> q;
while (--q > -1) {
int k, pos;
cin >> k >> pos;
cout << answer[k][pos - 1] << '\n';
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
class SegmentTree {
public:
vector<vector<long long> > a;
long long n;
SegmentTree(vector<long long>& arr) {
n = arr.size();
a.resize(4 * n);
build(1, 0, arr.size(), arr);
}
void build(long long v, long long vl, long long vr, vector<long long>& arr) {
if (vr - vl == 1) {
a[v].push_back(arr[vl]);
} else {
long long vm = (vl + vr) / 2;
build(v * 2, vl, vm, arr);
build(v * 2 + 1, vm, vr, arr);
a[v].resize(vr - vl);
merge(a[v * 2].begin(), a[v * 2].end(), a[v * 2 + 1].begin(),
a[v * 2 + 1].end(), a[v].begin());
}
}
long long get(long long v, long long vl, long long vr, long long l,
long long r, long long x) {
if (vl == l && vr == r) {
return a[v].end() - lower_bound(a[v].begin(), a[v].end(), x);
} else {
long long vm = (vl + vr) / 2;
if (r <= vm) {
return get(v * 2, vl, vm, l, r, x);
} else if (l >= vm) {
return get(v * 2 + 1, vm, vr, l, r, x);
} else {
return get(v * 2, vl, vm, l, vm, x) + get(v * 2 + 1, vm, vr, vm, r, x);
}
}
}
long long get(long long l, long long r, long long x) {
return get(1, 0, n, l, r, x);
}
};
signed main() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
vector<long long> nums = a;
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
vector<vector<long long> > posof(nums.size());
for (long long i = 0; i < n; i++) {
posof[lower_bound(nums.begin(), nums.end(), a[i]) - nums.begin()].push_back(
i);
}
vector<long long> sufcntof(posof.size());
sufcntof.back() = posof.back().size();
for (long long i = (long long)posof.size() - 2; i >= 0; i--) {
sufcntof[i] = sufcntof[i + 1] + posof[i].size();
}
SegmentTree st(a);
long long m;
cin >> m;
for (long long i = 0; i < m; i++) {
long long k, pos;
cin >> k >> pos;
long long numpos = sufcntof.rend() -
lower_bound(sufcntof.rbegin(), sufcntof.rend(), k) - 1;
long long num = nums[numpos];
long long limit =
k - (numpos == sufcntof.size() - 1 ? 0 : sufcntof[numpos + 1]);
long long l = 0;
long long r = n;
while (r - l > 1) {
long long m = (l + r) / 2;
long long c = st.get(0, m + 1, num + 1);
c += min((long long)(lower_bound(posof[numpos].begin(),
posof[numpos].end(), m + 1) -
posof[numpos].begin()),
limit);
if (c >= pos) {
r = m;
} else {
l = m;
}
}
long long m = l;
long long c = st.get(0, m + 1, num + 1);
c += min((long long)(lower_bound(posof[numpos].begin(), posof[numpos].end(),
m + 1) -
posof[numpos].begin()),
limit);
if (c >= pos) {
r = m;
}
cout << a[r] << "\n";
}
return 0;
}
| 10 | CPP |
def min_s(a, k):
res = a.copy()
for i in range(len(a) - k):
m = min(res)
res.reverse()
res.remove(m)
res.reverse()
return res
n = int(input())
a = [int(x) for x in input().split()]
m = int(input())
for _ in range(m):
k, pos = [int(x) for x in input().split()]
l = min_s(a, k)
print(l[pos-1]) | 10 | PYTHON3 |
n = int(input())
arr = list(map(int, input().split()))
q = int(input())
qs = []
for i in range(q):
a, b = map(int, input().split())
qs.append([a, b - 1, i])
qs.sort()
ret = []
used = [0 for i in range(n)]
ans = [-1 for i in range(q)]
for z in range(q):
l, pos, o = qs[z]
while len(ret) < l:
mx = 0
ind = -1
for i in range(n):
if not used[i]:
if mx < arr[i]:
mx = arr[i]
ind = i
used[ind] = 1
ret.append(mx)
c = []
for i in range(n):
if used[i]:
c.append(arr[i])
ans[qs[z][2]] = c[pos]
for i in range(q):
print(ans[i]) | 10 | PYTHON3 |
n = int(input())
a = list(map(int, input().split()))
a1 = sorted(a, key=lambda x: -x)
q = int(input())
for i in range(q):
k, pos = map(int, input().split())
pos -= 1
notused = {}
for j in a1[:k]:
if j in notused:
notused[j] += 1
else:
notused[j] = 1
for j in a:
if j in notused:
if pos > 0:
if notused[j] > 1:
notused[j] -= 1
else:
notused.pop(j)
pos -= 1
else:
print(j)
break
| 10 | PYTHON3 |
n = int(input())
line = list(map(int, input().split()))
m = int(input())
for _ in range(m):
k, pos = map(int, input().split())
lf = line[:]
while len(lf) > k:
j = -1
x = min(lf)
while j > -len(lf)-1:
if lf[j] == x:
del lf[j]
if len(lf) == k:
break
else:
j -= 1
print(lf[pos-1])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const long double error = 2e-6;
const long double PI = acosl(-1);
inline long long int MOD(long long int x, long long int m = mod) {
long long int y = x % m;
return (y >= 0) ? y : y + m;
}
const int inf = 1e9;
const long long int infl = 1061109567;
const int nmax = 1000 + 10;
bool cmp(pair<int, int> p1, pair<int, int> p2) {
if (p1.first != p2.first) return p1.first < p2.first;
return p1.second > p2.second;
}
int main() {
int n;
cin >> n;
int i;
vector<pair<int, int> > vc(n);
vector<int> ara;
for (i = 0; i < n; i++) {
int xx;
cin >> xx;
ara.push_back(xx);
vc[i] = {xx, i};
}
sort(vc.begin(), vc.end(), cmp);
vector<int> ott[n + 2];
set<int> tes;
int pussy = 1;
for (i = n - 1; i >= 0; i--) {
tes.insert(vc[i].second);
ott[pussy].insert(ott[pussy].end(), tes.begin(), tes.end());
pussy++;
}
int m;
cin >> m;
for (i = 1; i <= m; i++) {
int k, pos;
cin >> k >> pos;
vector<int> sv;
int j;
int ans = ott[k][pos - 1];
cout << ara[ans] << "" << endl;
}
return 0;
}
| 10 | CPP |
n = int(input())
arr = list(map(int, input().split()))
arr = [(i, num) for num, i in enumerate(arr)]
arr.sort(key=lambda x: (-x[0], x[1]))
m = int(input())
for q in range(m):
k, pos = tuple(map(int, input().split()))
now = []
for i in arr:
if len(now) == k:
break
now.append(i)
now.sort(key=lambda x: x[1])
# print(k, pos, now)
print(now[pos - 1][0])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long a[105], ans[105], b[105];
signed main() {
long long n, i;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
long long m;
cin >> m;
while (m--) {
long long k, t = 0, c = 0, pos;
cin >> k >> pos;
sort(b, b + n);
memset(ans, 0, sizeof(ans));
for (i = n - k; i < n; i++) {
if (b[i] == b[n - k]) t++;
}
for (i = 0; i < n; i++) {
if (a[i] == b[n - k] && t) {
ans[c++] = a[i];
t--;
} else if (a[i] > b[n - k]) {
ans[c++] = a[i];
}
}
cout << ans[pos - 1] << endl;
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<pair<int, int>> ps(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
ps[i] = make_pair(a[i], i);
}
sort(ps.begin(), ps.end(), [](pair<int, int>& a, pair<int, int>& b) {
if (a.first == b.first) {
return a.second < b.second;
}
return a.first > b.first;
});
int m;
cin >> m;
for (int query = 0; query < m; query++) {
int k, pos;
cin >> k >> pos;
priority_queue<int> q;
for (int i = 0; i < k; i++) {
q.push(ps[i].second);
if (i >= pos) {
q.pop();
}
}
cout << a[q.top()] << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void amin(T &a, U b) {
a = (a > b ? b : a);
}
template <typename T, typename U>
inline void amax(T &a, U b) {
a = (a > b ? a : b);
}
const int N = (1 << 21) + 5;
int fenw[N];
void update(int i, int val) {
for (; i < N; i += i & (-i)) fenw[i] += val;
}
int sum(int r) {
int tot = 0;
for (; r > 0; r -= r & (-r)) tot += fenw[r];
return tot;
}
int getSum(int l, int r) { return sum(r) - sum(l - 1); }
int kth(int k) {
int idx = 0, sum = 0;
for (int i = 21; i >= 0; --i) {
if (fenw[idx + (1 << i)] + sum < k) {
idx += (1 << i);
sum += fenw[idx];
}
}
return idx + 1;
}
void solve() {
int n;
cin >> n;
vector<int> a(n);
vector<pair<int, int>> b(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
b[i] = {a[i], -i};
}
sort(b.begin(), b.end());
int q;
cin >> q;
vector<array<int, 3>> queries(q);
for (int i = 0; i < q; ++i) {
cin >> queries[i][0] >> queries[i][1];
queries[i][2] = i;
}
sort(queries.begin(), queries.end());
int j = 0;
vector<int> ans(q);
for (auto &[len, k, i] : queries) {
while (j < len) {
update(-b.rbegin()[j].second + 1, 1);
++j;
}
ans[i] = a[kth(k) - 1];
}
for (int i : ans) {
cout << i << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tests = 1;
while (tests--) {
solve();
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
bool cmp(pair<int, int> a, pair<int, int> b) {
return a.first > b.first || (a.first == b.first && a.second < b.second);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int>> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a.begin(), a.end(), cmp);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int k, pos;
cin >> k >> pos;
vector<pair<int, int>> t(k);
for (int j = 0; j < k; j++) {
t[j] = {a[j].second, a[j].first};
}
sort(t.begin(), t.end());
cout << t[pos - 1].second << '\n';
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> v;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
v.push_back({-a[i], i});
}
sort(v.begin(), v.end());
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int k, p;
cin >> k >> p;
vector<pair<int, int>> tmp;
for (int j = 0; j < k; j++) {
tmp.push_back({v[j].second, -v[j].first});
}
sort(tmp.begin(), tmp.end());
cout << tmp[p - 1].second << '\n';
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[200001];
pair<int, int> aTmp[200001];
int b[200001];
int kthLargest(int n, int k) {
vector<int> c(n);
for (int i = 0; i < n; ++i) {
c[i] = b[i];
}
sort(c.begin(), c.end());
return c[k - 1];
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
aTmp[i].second = -i;
aTmp[i].first = a[i];
}
sort(aTmp, aTmp + n, greater<pair<int, int>>());
for (int i = 0; i < n; ++i) {
b[i] = -aTmp[i].second;
}
int q;
cin >> q;
while (q--) {
int k, p;
cin >> k >> p;
cout << a[kthLargest(k, p)] << endl;
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool comp(const pair<int, int>& a, const pair<int, int>& b) {
if (a.first == b.first)
return a.second > b.second;
else
return a.first < b.first;
}
int main() {
int n;
cin >> n;
vector<pair<int, int>> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a.begin(), a.end(), comp);
reverse(a.begin(), a.end());
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int k, pos;
cin >> k >> pos;
vector<pair<int, int>> t(k);
for (int j = 0; j < k; j++) {
t[j].first = a[j].second;
t[j].second = a[j].first;
}
sort(t.begin(), t.end());
cout << t[pos - 1].second << '\n';
}
}
| 10 | CPP |
n = int(input())
a = list(map(int, input().split()))
m = int(input())
x = [[a[i], i] for i in range(n)]
x.sort(key = lambda x: x[0], reverse = True)
for _i in range(m):
k, p = map(int, input().split())
print(sorted(x[:k], key = lambda x: x[1])[p - 1][0])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
vector<int> aS = a;
sort(aS.rbegin(), aS.rend());
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
multiset<int> st;
for (int j = 0; j < k; j++) st.insert(aS[j]);
int cnt = 1, ptr = 1;
while (cnt <= pos) {
multiset<int>::iterator it = st.find(a[ptr]);
if (it != st.end()) {
st.erase(it);
cnt++;
}
ptr++;
}
cout << a[ptr - 1] << '\n';
}
}
| 10 | CPP |
n = int(input())
data = list(map(int, input().split()))
m = int(input())
for _ in range(m):
k, pos = map(int, input().split())
s = data[:]
ans = []
for i in range(k):
x = s.index(max(s))
ans.append(x)
s[x] = -1
ans.sort()
print(data[ans[pos - 1]])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(int a, int b) { return a > b; }
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n;
vector<int> a(n), a_f(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a_f[i] = a[i];
}
sort(a_f.begin(), a_f.end(), cmp);
cin >> m;
for (int i = 0; i < m; i++) {
int k, pos;
cin >> k >> pos;
multiset<int> A;
for (int j = 0; j < k; j++) {
A.insert(a_f[j]);
}
vector<bool> used(n);
int now = 0;
for (int now = 0; now < n; now++) {
if (A.find(a[now]) != A.end()) {
A.erase(A.find(a[now]));
used[now] = true;
}
}
vector<int> ans1;
for (int j = 0; j < n; j++) {
if (used[j]) {
ans1.push_back(a[j]);
}
}
cout << ans1[pos - 1] << endl;
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
pos--;
vector<vector<int>> ans(k);
vector<long long> sums(k);
int last = 0;
for (int i = 0; i < n; i++) {
for (int j = last; j >= 0; j--) {
if (j >= k) continue;
if (ans[j].size() == 0) {
if (j == 0) {
ans[j].push_back(arr[i]);
sums[j] = arr[i];
} else {
ans[j] = ans[j - 1];
ans[j].push_back(arr[i]);
sums[j] = sums[j - 1] + arr[i];
}
} else {
if (j == 0) {
if (arr[i] > sums[j]) {
ans[j][0] = arr[i];
sums[j] = arr[i];
}
} else if (sums[j - 1] + arr[i] > sums[j]) {
sums[j] = sums[j - 1] + arr[i];
ans[j] = ans[j - 1];
ans[j].push_back(arr[i]);
} else if (sums[j - 1] + arr[i] == sums[j]) {
bool change = 0;
for (int k = 0; k < ans[j - 1].size(); k++) {
if (ans[j - 1][k] < ans[j][k]) {
change = 1;
break;
} else if (ans[j - 1][k] > ans[j][k]) {
break;
}
}
if (change) {
ans[j] = ans[j - 1];
ans[j].push_back(arr[i]);
}
}
}
}
last += 1;
}
cout << ans[k - 1][pos] << "\n";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
pair<long long, long long> arr[200000];
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = (0); i < (n); i++) {
long long x;
cin >> x;
arr[i] = {x, i};
}
sort(arr, arr + n, cmp);
long long TEST_CASE;
cin >> TEST_CASE;
for (long long TEST_NUM = 1; TEST_NUM <= TEST_CASE; TEST_NUM++) {
long long k, p;
cin >> k >> p;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
for (long long i = (0); i < (k); i++)
pq.push({arr[i].second, arr[i].first});
for (long long i = (0); i < (p - 1); i++) pq.pop();
cout << pq.top().second << '\n';
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int ivalue(string s) {
long long int x = 0;
stringstream obj(s);
obj >> x;
return x;
}
const long long int M = 1e9 + 7;
const long long int N = 1e5 + 5;
const long long int inf = 2e18;
long long int mod(long long int x) { return (x % M); }
long long int mod_minus(long long int a, long long int b) {
long long int ans = (mod(a) - mod(b));
if (ans < 0) ans = mod(ans + M);
return ans;
}
long long int mod_mul(long long int a, long long int b) {
return mod(mod(a) * mod(b));
}
long long int mod_add(long long int a, long long int b) {
return mod(mod(a) + mod(b));
}
long long int power(long long int a, long long int n) {
if (n == 0)
return 1;
else if (n == 1)
return a;
long long int R = power(a, n / 2) % M;
if (n % 2 == 0) {
return mod(mod_mul(R, R));
} else {
return mod(mod_mul(mod_mul(R, a), mod(R)));
}
}
long long int mod_div(long long int a, long long int b) {
long long int ans = mod(a);
long long int b1 = power(b, M - 2);
ans = mod(mod_mul(ans, b1));
return ans;
}
long long int mod_inv(long long int n) { return power(n, M - 2); }
long long int fact_mod(long long int n) {
vector<long long int> fact(n + 1);
fact[0] = 1;
for (long long int i = 1; i < n + 1; i++) {
fact[i] = mod_mul(fact[i - 1], i);
}
return fact[n];
}
long long int nCr_mod(long long int n, long long int r) {
if (r == 0 || n == 0) return 1;
long long int fac[n + 1];
fac[0] = 1;
for (long long int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % M;
return (fac[n] * mod_inv(fac[r]) % M * mod_inv(fac[n - r]) % M) % M;
}
long long int upper_fraction(long long int a, long long int b) {
if (a % b == 0)
return a / b;
else
return (a / b) + 1;
}
bool isInt(double d) {
double dummy;
return modf(d, &dummy) == 0.0;
}
struct CompareHeight {
bool operator()(pair<long long int, long long int> const& x,
pair<long long int, long long int> const& y) {
if (x.first == y.first) return x.second > y.second;
return x.first < y.first;
}
};
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n);
long long int i;
for (i = 0; i < n; i++) cin >> a[i];
long long int m;
cin >> m;
while (m--) {
long long int k, pos;
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int>>, CompareHeight>
pq;
for (i = 0; i < n; i++) pq.push({a[i], i + 1});
cin >> k >> pos;
vector<pair<long long int, long long int>> v(k);
long long int j = 0;
while (pq.empty() == false) {
if (j == k) break;
v[j] = {pq.top().second, pq.top().first};
j++;
pq.pop();
}
sort((v).begin(), (v).end());
cout << v[pos - 1].second << endl;
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
t = 1;
while (t--) solve();
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, a1, b1;
cin >> n;
vector<int> a(n);
priority_queue<pair<int, int>> y;
for (int i = 0; i < n; i++) {
cin >> a[i];
y.push({a[i], -i});
}
vector<vector<int>> e(n);
for (int i = 0; i < n; i++) {
auto we = y.top();
y.pop();
if (i > 0) e[i] = e[i - 1];
e[i].push_back(-we.second);
sort(e[i].begin(), e[i].end());
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a1 >> b1;
cout << a[e[a1 - 1][b1 - 1]] << endl;
}
return 0;
}
| 10 | CPP |
n=int(input())
a=[int(i) for i in input().split()]
b=sorted(a)
c=[]
c.append(a)
for i in range(1,n+1):
k=len(c[i-1])-1-c[i-1][::-1].index(b[i-1])
c.append(c[i-1][0:k]+c[i-1][k+1::])
m=int(input())
for i in range (m):
k,pos=map(int,input().split())
print (c[len(c)-k-1][pos-1])
| 10 | PYTHON3 |
import math
def getFirstSetBitPos(n):
return math.log2(n & -n) + 1
def find_div(x):
ls=[]
for i in range(2,int(x**0.5)+1):
if x%i==0:
ls.append(i)
if i!=x//i:
ls.append(x//i)
return sorted(ls)
from collections import Counter
#for _ in range(1):
n = int(input())
#arr = list(map(int, input().split()))
ar= [(int(x),i) for i, x in enumerate(input().split())]
arr = sorted(ar, key=lambda x: (x[0], -1*x[1]))
m=int(input())
#print(arr)
for i in range(m):
k, pos = map(int, input().split())
ls = sorted(arr[-k:], key=lambda x:x[1])
#print(ls)
print(ls[pos-1][0])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("03")
#pragma GCC optimization("unroll-loops")
using namespace std;
const int maxn = 200001;
const int maxe = 20;
int a[maxn], b[maxn], c, k, pa[maxn], x, y, q, sol, d, d2, mod = 1000000007, j;
int m, n;
char h;
set<int> se;
string s;
pair<int, int> p[maxn + 1];
int rmq[maxn][maxe];
int st[4 * maxn], la[4 * maxn], ft[maxn], dt[maxn], dt2[maxn];
void build(int n) {
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
rmq[i][j] = min(rmq[i][j - 1], rmq[i + (1 << (j - 1))][j - 1]);
}
}
}
int query(int a, int b) {
int k = 31 - __builtin_clz(b - a + 1);
return min(rmq[a][k], rmq[b - (1 << k) + 1][k]);
}
int fin(int i) {
if (pa[i] == i) return i;
return pa[i] = fin(pa[i]);
}
int bs(int l, int r) {
while (l != r) {
int mi = (l + r) / 2;
if (a[mi] == x) return mi;
if (a[mi] > x)
r = mi;
else
l = mi + 1;
}
return l;
}
void crear(int l, int r, int nod) {
if (l == r)
st[nod] = a[l];
else {
int mi = (l + r) / 2;
crear(l, mi, 2 * nod);
crear(mi + 1, r, 2 * nod + 1);
st[nod] = min(st[2 * nod], st[2 * nod + 1]);
}
}
void upd(int l, int r, int nod) {
if (l > x || r < x) return;
if (la[nod] != 0) {
st[nod] += la[nod];
la[2 * nod] += la[nod];
la[2 * nod + 1] += la[nod];
la[nod] = 0;
}
if (l == r)
st[nod] += y;
else {
int mi = (l + r) / 2;
upd(l, mi, 2 * nod);
upd(mi + 1, r, 2 * nod + 1);
st[nod] = min(st[2 * nod], st[2 * nod + 1]);
}
}
int qu(int l, int r, int nod) {
if (l > y || r < x) return 100001;
if (la[nod] != 0) {
st[nod] += la[nod];
la[2 * nod] += la[nod];
la[2 * nod + 1] += la[nod];
la[nod] = 0;
}
if (l >= x && r <= y)
return st[nod];
else {
int mi = (l + r) / 2;
return min(qu(l, mi, 2 * nod), qu(mi + 1, r, 2 * nod + 1));
}
}
void lazy(int l, int r, int nod) {
if (l > y || r < x) return;
if (la[nod] != 0) {
st[nod] += la[nod];
la[2 * nod] += la[nod];
la[2 * nod + 1] += la[nod];
la[nod] = 0;
}
if (l >= x && r <= y) {
st[nod] += q;
if (l != r) {
la[nod * 2] += q;
la[2 * nod + 1] += q;
}
} else {
int mi = (l + r) / 2;
lazy(l, mi, 2 * nod);
lazy(mi + 1, r, 2 * nod + 1);
st[nod] = min(st[2 * nod], st[2 * nod + 1]);
}
}
int ftq(int n) {
int c = 0;
while (n) {
c += ft[n];
n -= (n & -n);
}
return c;
}
void ftupd(int x) {
for (int i = x; i <= n; i += (i & -i)) ft[i] += y;
}
void abi(int x) {
for (int i = x; i <= n; i += (i & -i)) dt[i] += y;
}
void abi2(int x) {
for (int i = x; i <= n; i += (i & -i)) dt2[i] += y;
}
int q1(int n) {
int c = 0;
while (n) {
c += dt[n];
n -= (n & -n);
}
return c;
}
int q2(int n) {
int c = 0;
while (n) {
c += dt[n];
n -= (n & -n);
}
return c;
}
void ini() {
for (int i = 1; i <= n; i++) {
cin >> a[i];
y = a[i] - a[i - 1];
abi(i);
y = a[i] - a[i - 1] * i;
abi2(i);
}
}
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
cin >> m;
while (m--) {
priority_queue<pair<int, int>> pq, sol;
for (int i = 1; i <= n; i++) {
pq.push({a[i], -i});
}
cin >> x >> y;
while (x--) {
sol.push({pq.top().second, pq.top().first});
pq.pop();
}
while (y--) {
d = sol.top().second;
sol.pop();
}
cout << d << '\n';
}
}
| 10 | CPP |
def mergesort(l, r, arr, pos):
if r - l == 1:
return arr, pos
m = (l + r) // 2
arr, pos = mergesort(l, m, arr, pos)
arr, pos = mergesort(m, r, arr, pos)
c = [0 for i in range(r)]
d = [0 for i in range(r)]
poi_a = l
poi_b = m
for i in range(l, r):
if poi_a == m:
c[i] = arr[poi_b]
d[i] = pos[poi_b]
poi_b += 1
elif poi_b == r:
c[i] = arr[poi_a]
d[i] = pos[poi_a]
poi_a += 1
elif a[poi_a] > arr[poi_b]:
c[i] = arr[poi_a]
d[i] = pos[poi_a]
poi_a += 1
else:
c[i] = arr[poi_b]
d[i] = pos[poi_b]
poi_b += 1
for i in range(l, r):
arr[i] = c[i]
pos[i] = d[i]
return arr, pos
n = int(input())
a = list(map(int, input().split()))
p = [i for i in range(n)]
temp = a[:]
a, p = mergesort(0, n, a, p)
i = 0
while i < n:
j = i + 1
while (j < n and a[i] == a[j]):
j += 1
p[i:j] = sorted(p[i:j])
i = j
pref = [[] for i in range(n + 1)]
for i in range(1, n + 1):
pref[i] = [0] + sorted(p[:i])
for m in range(int(input())):
k, pos = map(int, input().split())
print(temp[pref[k][pos]])
| 10 | PYTHON3 |
n = int(input())
a = [int(i) for i in input().split()]
b = [(a[i], n - i) for i in range(n)]
b.sort(reverse=True)
b = [(b[i][0], n - b[i][1]) for i in range(n)]
m = int(input())
for qu in range(m):
k, p = map(int, input().split())
c = b[:k]
c.sort(key = lambda x: x[1])
print(c[p-1][0])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool compare(pair<int, int> p1, pair<int, int> p2) {
if (p1.first == p2.first) {
if (p1.second < p2.second)
return true;
else
return false;
} else if (p1.first < p2.first)
return false;
else
return true;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n;
cin >> n;
int a[n + 1];
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back({x, i + 1});
a[i + 1] = x;
}
int m;
cin >> m;
sort(v.begin(), v.end(), compare);
while (m--) {
set<int> s;
int k, pos;
cin >> k >> pos;
int i = 0;
while (k--) {
s.insert(v[i].second);
i++;
}
auto it = s.begin();
pos--;
while (pos--) {
it++;
}
cout << a[*it] << endl;
}
}
| 10 | CPP |
import sys as _sys
def main():
t = 1
for i_t in range(t):
n, = _read_ints()
a = tuple(_read_ints())
m, = _read_ints()
queries = (tuple(_read_ints()) for i_query in range(m))
result = process_queries(a, queries)
print(*result, sep='\n')
def _read_line():
result = _sys.stdin.readline()
assert result[-1] == "\n"
return result[:-1]
def _read_ints():
return map(int, _read_line().split())
def process_queries(sequence, queries):
sequence = tuple(sequence)
sorted_sequence = sorted(sequence, reverse=True)
for k, pos in queries:
pos -= 1
k_max_elems = sorted_sequence[:k][::-1]
seq = sequence
subseq = []
while len(subseq) < k:
for i_next_elem in range(len(k_max_elems)):
next_elem = k_max_elems[i_next_elem]
seq_after = seq[seq.index(next_elem)+1:]
elems_remain = k_max_elems[:i_next_elem] + k_max_elems[i_next_elem+1:]
if _contains_elems(seq_after, elems_remain):
seq = seq_after
k_max_elems = elems_remain
subseq.append(next_elem)
break
yield subseq[pos]
def _contains_elems(seq, elems):
seq = sorted(seq)
subseq = sorted(elems)
i_seq = 0
i_subseq = 0
while i_seq < len(seq) and i_subseq < len(subseq):
if seq[i_seq] == subseq[i_subseq]:
i_subseq += 1
i_seq += 1
return i_subseq == len(subseq)
if __name__ == '__main__':
main()
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void itval(istream_iterator<string> it) {}
template <typename T, typename... Args>
void itval(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
itval(++it, args...);
}
template <typename T>
inline void print(T x) {
cout << x << "\n";
}
template <typename T>
inline void printvec(T x) {
for (auto a : x) cout << a << ' ';
cout << '\n';
}
const long long int MOD = 1e9 + 7;
struct custom {
bool operator()(const pair<int, int> &p1, const pair<int, int> &p2) const {
if (p1.first == p2.first) {
return p1.second < p2.second;
}
return p1.first > p2.first;
}
};
long long int get_pow(long long int x, long long int k) {
if (k == 0) return 1ll;
long long int y = get_pow(x, k / 2);
y = (y * y) % MOD;
if (k % 2) y = (y * x) % MOD;
return y;
}
const int N = 2e5 + 10;
void solve() {
int n, m, k, x;
cin >> n;
vector<int> v(n);
for (int i = (int)0; i < int(n); i++) cin >> v[i];
vector<pair<int, int> > res;
for (int i = (int)0; i < int(n); i++) {
res.push_back({v[i], i});
}
sort(res.begin(), res.end(), custom());
cin >> m;
for (int i = (int)0; i < int(m); i++) {
cin >> k >> x;
x--;
vector<int> dum;
for (int i = (int)0; i < int(k); i++) dum.push_back(res[i].second);
sort(dum.begin(), dum.end());
for (int i = (int)0; i < int(k); i++) dum[i] = v[dum[i]];
cout << dum[x] << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
clock_t z = clock();
for (int tes = (int)0; tes < int(test); tes++) {
solve();
}
fprintf(stderr, "Total Time:%.4f\n", (double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<double, double>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<double>;
using vs = vector<string>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
const int di[4] = {-1, 0, 1, 0}, dj[4] = {0, 1, 0, -1};
const int di8[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
dj8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const ld PI = acos((ld)-1);
const ll INF = 1e18;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) { return uniform_int_distribution<ll>(a, b)(rng); }
bool pow2(int i) { return i && (i & -i) == i; }
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
ll half(ll x) { return fdiv(x, 2); }
template <class T>
bool chmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool chmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
void remDup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), end(v));
}
template <class T, class U>
void remAll(vector<T>& v, U a) {
v.erase(remove((v).begin(), (v).end(), a), v.end());
}
template <class T, class U>
T fstTrue(T lo, T hi, U f) {
while (lo < hi) {
T mid = half(lo + hi);
f(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U f) {
while (lo < hi) {
T mid = half(lo + hi + 1);
f(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T, class U, class C>
string to_string(tuple<T, U, C> p);
template <class T, class U, class C, class D>
string to_string(tuple<T, U, C, D> p);
string to_string(char c) { return string(1, c); }
string to_string(bool b) { return to_string((int)b); }
string to_string(const char* s) { return (string)s; }
string to_string(string s) { return s; }
template <class T>
string to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
string to_string(vb v) {
string res = "{";
for (int i = (0); i < (((int)(v).size())); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
string to_string(bitset<SZ> b) {
string res = "";
for (int i = (0); i < (((int)(b).size())); ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
string to_string(pair<T, U> p);
template <class T>
string to_string(T v) {
bool fst = 1;
string res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
string to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T, class U, class C>
string to_string(tuple<T, U, C> p) {
return to_string(get<0>(p)) + " " + to_string(get<1>(p)) + " " +
to_string(get<2>(p));
}
template <class T, class U, class C, class D>
string to_string(tuple<T, U, C, D> p) {
return to_string(get<0>(p)) + " " + to_string(get<1>(p)) + " " +
to_string(get<2>(p)) + " " + to_string(get<3>(p));
}
template <class T, class U, class C>
void re(tuple<T, U, C>& p);
template <class T, class U, class C, class D>
void re(tuple<T, U, C, D>& p);
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& d) {
string t;
re(t);
d = stod(t);
}
void re(ld& d) {
string t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(array<T, SZ>& x) {
for (auto& a : x) re(a);
}
template <class T, class U, class C>
void re(tuple<T, U, C>& p) {
re(get<0>(p), get<1>(p), get<2>(p));
}
template <class T, class U, class C, class D>
void re(tuple<T, U, C, D>& p) {
re(get<0>(p), get<1>(p), get<2>(p), get<3>(p));
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
struct chash {
const uint64_t C = ll(2e18 * PI) + 71;
const int RANDOM = rng();
ll operator()(ll x) const { return __builtin_bswap64((x ^ RANDOM) * C); }
};
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using mpq = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using pq = priority_queue<T>;
template <class T, class U>
using um = unordered_map<T, U, chash>;
template <class T>
using us = unordered_set<T, chash>;
template <class T>
using PR = pair<T, T>;
const int MOD = 1e9 + 7;
template <int MOD, int RT>
struct mint {
static const int mod = MOD;
static constexpr mint rt() { return RT; }
int v;
explicit operator int() const { return v; }
mint() { v = 0; }
mint(ll _v) {
v = (-MOD < _v && _v < MOD) ? _v : _v % MOD;
if (v < 0) v += MOD;
}
friend bool operator==(const mint& a, const mint& b) { return a.v == b.v; }
friend bool operator!=(const mint& a, const mint& b) { return !(a == b); }
friend bool operator<(const mint& a, const mint& b) { return a.v < b.v; }
friend void re(mint& a) {
ll x;
re(x);
a = mint(x);
}
friend string to_string(mint a) { return to_string(a.v); }
mint& operator+=(const mint& m) {
if ((v += m.v) >= MOD) v -= MOD;
return *this;
}
mint& operator-=(const mint& m) {
if ((v -= m.v) < 0) v += MOD;
return *this;
}
mint& operator*=(const mint& m) {
v = (ll)v * m.v % MOD;
return *this;
}
mint& operator/=(const mint& m) { return (*this) *= inv(m); }
friend mint pow(mint a, ll p) {
mint ans = 1;
assert(p >= 0);
for (; p; p /= 2, a *= a)
if (p & 1) ans *= a;
return ans;
}
friend mint inv(const mint& a) {
assert(a.v != 0);
return pow(a, MOD - 2);
}
mint operator-() const { return mint(-v); }
mint& operator++() { return *this += 1; }
mint& operator--() { return *this -= 1; }
friend mint operator+(mint a, const mint& b) { return a += b; }
friend mint operator-(mint a, const mint& b) { return a -= b; }
friend mint operator*(mint a, const mint& b) { return a *= b; }
friend mint operator/(mint a, const mint& b) { return a /= b; }
};
typedef mint<MOD, 5> mi;
vector<vector<mi>> scmb;
void genComb(int SZ) {
scmb.assign(SZ, vector<mi>(SZ));
scmb[0][0] = 1;
for (int i = (1); i < (SZ); ++i)
for (int j = (0); j < (i + 1); ++j)
scmb[i][j] = scmb[i - 1][j] + (j ? scmb[i - 1][j - 1] : 0);
}
vi invs, fac, ifac;
void genFac(int SZ) {
invs.resize(SZ), fac.resize(SZ), ifac.resize(SZ);
invs[1] = fac[0] = ifac[0] = 1;
for (int i = (2); i < (SZ); ++i)
invs[i] = MOD - (ll)MOD / i * invs[MOD % i] % MOD;
for (int i = (1); i < (SZ); ++i) {
fac[i] = (ll)fac[i - 1] * i % MOD;
ifac[i] = (ll)ifac[i - 1] * invs[i] % MOD;
}
}
mi comb(int a, int b) {
if (a < b || b < 0) return 0;
return (ll)fac[a] * ifac[b] % MOD * ifac[a - b] % MOD;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
using ul = unsigned long long;
ul modMul(ul a, ul b, const ul mod) {
ll ret = a * b - mod * (ul)((ld)a * b / mod);
return ret + ((ret < 0) - (ret >= (ll)mod)) * mod;
}
ul modPow(ul a, ul b, const ul mod) {
if (b == 0) return 1;
ul res = modPow(a, b / 2, mod);
res = modMul(res, res, mod);
return b & 1 ? modMul(res, a, mod) : res;
}
bool prime(ul n) {
if (n < 2 || n % 6 % 4 != 1) return n - 2 < 2;
ul A[] = {2, 325, 9375, 28178, 450775, 9780504, 1795265022},
s = __builtin_ctzll(n - 1), d = n >> s;
for (auto& a : A) {
ul p = modPow(a, d, n), i = s;
while (p != 1 && p != n - 1 && a % n && i--) p = modMul(p, p, n);
if (p != n - 1 && i != s) return 0;
}
return 1;
}
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void IOS(int n = 10, string s = "") {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(n);
cerr.precision(n);
cerr << fixed;
cout << fixed;
if (((int)(s).size())) {
setIn(s + ".in"), setOut(s + ".out");
}
}
const int mxN = 2e5 + 5;
void solve() {
ll n, m;
re(n);
vl a(n);
re(a, m);
vl b = a;
sort((b).rbegin(), (b).rend());
vpl q(m);
re(q);
V<vl> ans(n + 1);
set<ll> s;
for (auto& i : q) s.insert(i.first);
for (auto& k : s) {
vl v;
ll c = 0;
for (int j = (0); j < (n); ++j)
if (a[j] > b[k - 1]) ++c;
ll t = k - c;
for (int j = (0); j < (n); ++j) {
if (a[j] == b[k - 1] && t > 0) {
v.push_back(a[j]);
--t;
}
if (a[j] > b[k - 1]) v.push_back(a[j]);
}
ans[k] = v;
}
for (auto& i : q) ps(ans[i.first][i.second - 1]);
}
int main() {
IOS();
int t = 1;
for (int i = (0); i < (t); ++i) {
solve();
}
}
| 10 | CPP |
"""
Author - Satwik Tiwari .
18th Feb , 2021 - Thursday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt,log2
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def testcase(t):
for pp in range(t):
solve(pp)
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 10**9+7
#===============================================================================================
# code here ;))
class FenwickTree:
def __init__(self, x):
"""transform list into BIT"""
self.bit = x
for i in range(len(x)):
j = i | (i + 1)
if j < len(x):
x[j] += x[i]
def update(self, idx, x):
"""updates bit[idx] += x"""
while idx < len(self.bit):
self.bit[idx] += x
idx |= idx + 1
def query(self, end):
"""calc sum(bit[:end))"""
x = 0
while end:
x += self.bit[end - 1]
end &= end - 1
return x
def findkth(self, k):
"""Find largest idx such that sum(bit[:idx]) <= k"""
idx = -1
for d in reversed(range(len(self.bit).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(self.bit) and k >= self.bit[right_idx]:
idx = right_idx
k -= self.bit[idx]
return idx + 1
def printpref(self):
out = []
for i in range(1,len(self.bit) + 1):
out.append(self.query(i))
print(out)
"""
ask query(i+1) ---->>> 1 indexed based
update(i,x) --->>> 0indexed based
"""
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
def solve(case):
n = int(inp())
a = lis()
queries = []
m = int(inp())
for i in range(m):
k,pos = sep()
queries.append((k,pos,i))
queries.sort()
b = sorted(a)[::-1]
ind = {}
for i in range(n):
if(a[i] not in ind):
ind[a[i]] = deque([i])
else:
ind[a[i]].append(i)
# currind = 0
# bit = FenwickTree([0]*(len(a) + 10))
# ans = [-1]*m
# for k,pos,where in queries:
# while(currind < k):
# print(b[currind],'========')
# bit.update(ind[b[currind]].popleft(),1)
# currind+=1
# print(where,'==',bit.findkth(pos-1),pos)
# ans[where] = (bit.findkth(pos-1) + 1)
# print(bit.printpref())
#
# for i in ans:
# print(a[i])
sl = SortedList()
currind = 0
ans = [-1]*m
for k,pos,where in queries:
while(currind < k):
sl.add(ind[b[currind]].popleft())
currind += 1
ans[where] = a[sl[pos-1]]
for i in ans:
print(i)
testcase(1)
# testcase(int(inp()))
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using ii = pair<int, int>;
using vii = vector<ii>;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vii a(n);
for (int i = 0; i < (n); i++) cin >> a[i].first, a[i].second = i;
int m;
cin >> m;
sort(a.begin(), a.end(), [](ii& x, ii& y) {
if (x.first > y.first)
return true;
else if (x.first == y.first && x.second < y.second)
return true;
return false;
});
while (m--) {
int k, p;
cin >> k >> p;
map<int, int> b;
for (int i = 0; i < (k); i++) b[a[i].second] = a[i].first;
auto it = b.begin();
while (--p) it++;
cout << it->second << '\n';
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(time(0));
bool comp(pair<int, int> &a, pair<int, int> &b) {
return a.first < b.first || (a.first == b.first && a.second > b.second);
}
int main() {
int n;
cin >> n;
vector<int> g(n);
vector<pair<int, int> > v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first;
v[i].second = i;
g[i] = v[i].first;
}
sort(v.rbegin(), v.rend(), comp);
vector<vector<int> > ans;
vector<int> cur;
for (int i = 0; i < n; i++) {
cur.push_back(v[i].second);
ans.push_back(cur);
}
for (int i = 0; i < n; i++) {
sort(ans[i].begin(), ans[i].end());
}
int k;
cin >> k;
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
cout << g[ans[a - 1][b - 1]] << '\n';
}
return 0;
}
| 10 | CPP |
import sys
from collections import defaultdict
n=int(sys.stdin.readline())
arr=list(map(int,sys.stdin.readline().split()))
l=[i for i in arr]
for i in range(n):
arr[i]=[arr[i],-i]
arr.sort()
dic=defaultdict(list)
'''for i in range(1,n+1):
dic[i]=dic[i-1]+[-arr[n-i][1]]
dic[i].sort()'''
#print(dic,'dic')
z=len(arr)
m=int(sys.stdin.readline())
for _ in range(m):
n,pos=map(int,sys.stdin.readline().split())
if dic[n]!=[]:
#n,pos=map(int,sys.stdin.readline().split())
print(l[dic[n][pos-1]])
else:
dic[n]=[0 for _ in range(n)]
ind=n-1
#print(n,'n',z-1,'start',z-n-1,'end')
for i in range(z-1,z-n-1,-1):
dic[n][ind]=-arr[i][1]
ind-=1
dic[n].sort()
print(l[dic[n][pos-1]])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 * 10;
long long arr[200];
vector<pair<long long, long long>> sortedVec, vec2;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first > b.first) return true;
if (b.first > a.first) return false;
if (a.second > b.second) return false;
return true;
}
int main() {
int n, m;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
sortedVec.push_back(make_pair(arr[i], i));
}
cin >> m;
sort(sortedVec.begin(), sortedVec.end(), comp);
for (int i = 0; i < m; i++) {
int k, pos;
cin >> k >> pos;
for (int j = 0; j < k; j++) {
vec2.push_back(make_pair(sortedVec[j].second, sortedVec[j].first));
}
sort(vec2.begin(), vec2.end());
cout << vec2[pos - 1].second << "\n";
vec2.resize(0);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
long long int gcd(long long int a, long long int b) {
if (a == 0) {
return b;
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long int power(long long int x, long long int n) {
long long ans = 1;
while (n > 0) {
if (n & 1) ans = (ans * x) % 1000000007;
x = (x * x) % 1000000007;
n /= 2;
}
if (x == 0) ans = 0;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
long long int n, i;
cin >> n;
vector<pair<long long int, long long int> > a;
long long int pre[n];
for (i = 0; i < n; i++) {
cin >> pre[i];
a.push_back(make_pair(pre[i], -1 * i));
}
sort(a.begin(), a.end());
for (i = 1; i < n; i++) {
a[i].first += (a[i - 1].first);
}
long long int m;
cin >> m;
for (i = 0; i < m; i++) {
long long int k, r;
cin >> k >> r;
long long int maxs = INT_MIN, l;
for (int j = n - 1; j >= k - 1; j--) {
if (j != k - 1) {
if (a[j].first - a[j - k].first >= maxs) {
maxs = a[j].first - a[j - k].first;
l = j - k + 1;
}
} else {
if (a[j].first >= maxs) {
maxs = a[j].first;
l = 0;
}
}
}
vector<pair<long long int, long long int> > tmp;
if (l == 0) {
tmp.push_back(make_pair(-1 * a[0].second, a[0].first));
}
for (int z = l; z < l + k; z++) {
long long int x = a[z].first, y = -1 * a[z].second;
if (z) {
tmp.push_back(make_pair(y, x - a[z - 1].first));
}
}
sort(tmp.begin(), tmp.end());
cout << tmp[r - 1].second << endl;
}
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int>& a, pair<int, int>& b) {
if (a.first > b.first)
return true;
else if (a.first == b.first)
return a.second < b.second;
return false;
}
bool cmp2(pair<int, int>& a, pair<int, int>& b) { return a.second < b.second; }
void solve() {
int n;
cin >> n;
pair<int, int> a[n];
for (int i = 0; i < n; i++) cin >> a[i].first, a[i].second = i;
sort(a, a + n, cmp);
int q;
cin >> q;
int k, p;
while (q--) {
cin >> k >> p;
pair<int, int> v[k];
for (int i = 0; i < k; i++) v[i] = a[i];
sort(v, v + k, cmp2);
cout << v[p - 1].first << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
;
long long t = 1;
for (int i = 0; i < t; i++) {
solve();
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int> p1, pair<int, int> p2) {
if (p1.first != p2.first)
return p2.first > p1.first;
else
return p2.second < p1.second;
}
void solve() {
int n, x;
cin >> n;
vector<pair<int, int>> v(n);
for (int i = 0; i < n; i++) {
cin >> x;
v[i] = make_pair(x, i);
}
sort(v.begin(), v.end(), comp);
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
pos--;
vector<pair<int, int>> ans;
for (int j = 0; j < k; j++) {
ans.push_back(make_pair(v[n - 1 - j].second, v[n - 1 - j].first));
}
sort(ans.begin(), ans.end());
cout << ans[pos].second << endl;
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
| 10 | CPP |
#include <bits/stdc++.h>
const int LG = 21;
const int N = 400005;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
using namespace std;
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Yes[2] = {"No", "Yes"};
string YES[2] = {"NO", "YES"};
long long inq(long long x, long long y) {
if (!y) return 1 % MOD;
long long l = inq(x, y / 2);
if (y % 2) return l * l % MOD * x % MOD;
return l * l % MOD;
}
long long rev(long long x) { return inq(x, MOD - 2); }
bool __precomputed_combinatorics = 0;
vector<long long> __fact, __ufact, __rev;
void __precompute_combinatorics() {
__precomputed_combinatorics = 1;
__fact.resize(N);
__ufact.resize(N);
__rev.resize(N);
__rev[1] = 1;
for (int i = 2; i < N; i++) __rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = 1; i < N; i++)
__fact[i] = __fact[i - 1] * i % MOD,
__ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
}
long long fact(int x) {
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[x];
}
long long cnk(int n, int k) {
if (k < 0 || k > n) return 0;
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
int Root(int x, vector<int> &root) {
if (x == root[x]) return x;
return root[x] = Root(root[x], root);
}
void Merge(int v, int u, vector<int> &root, vector<int> &sz) {
v = Root(v, root), u = Root(u, root);
if (v == u) return;
if (sz[v] < sz[u]) {
sz[u] += sz[v];
root[v] = u;
} else {
sz[v] += sz[u];
root[u] = v;
}
}
int ok(int x, int n) { return 0 <= x && x < n; }
void bfs(int v, vector<int> &dist, vector<vector<int> > &graph) {
fill((dist).begin(), (dist).end(), -1);
dist[v] = 0;
vector<int> q = {v};
for (int i = 0; i < q.size(); i++) {
for (auto u : graph[q[i]]) {
if (dist[u] == -1) {
dist[u] = dist[q[i]] + 1;
q.push_back(u);
}
}
}
}
vector<int> z_func(string &s) {
vector<int> z(s.size());
z[0] = s.size();
int L = 0, R = 0;
for (int i = 1; i < s.size(); i++) {
z[i] = max(0, min(z[i - L], R - i));
while (i + z[i] < s.size() && s[i + z[i]] == s[z[i]]) z[i]++;
if (i + z[i] > R) {
R = i + z[i];
L = i;
}
}
return z;
}
vector<int> p_func(string &s) {
vector<int> p(s.size());
for (int i = 1; i < s.size(); i++) {
int j = p[i - 1];
while (j > 0 && s[i] != s[j]) j = p[j - 1];
if (s[i] == s[j]) j++;
p[i] = j;
}
return p;
}
vector<int> d1_func(string &s) {
vector<int> d1(s.size());
int L = 0, R = -1;
for (int i = 0; i < s.size(); i++) {
int k = 0;
if (i <= R) k = min(R - i + 1, d1[R - i + L]);
while (i + k < s.size() && i - k >= 0 && s[i - k] == s[i + k]) k++;
d1[i] = k--;
if (i + k > R) {
L = i - k;
R = i + k;
}
}
return d1;
}
vector<int> d2_func(string &s) {
vector<int> d2(s.size());
int L = 0, R = -1;
for (int i = 1; i < s.size(); i++) {
int k = 0;
if (i <= R) k = min(R - i + 1, d2[R - i + L + 1]);
while (i + k < s.size() && i - k - 1 >= 0 && s[i - k - 1] == s[i + k]) k++;
d2[i] = k--;
if (i + k > R) {
L = i - k - 1;
R = i + k;
}
}
return d2;
}
long long log10(long long x) {
if (x < 10) return 1;
return 1 + log10(x / 10);
}
long long ds(long long x) {
if (x < 10) return x;
return x % 10 + ds(x / 10);
}
double sqr(double x) { return x * x; }
bool in(int bit, int mask) { return (mask & (1 << bit)) > 0; }
void Del(vector<int> &v, int pos) {
swap(v[pos], v[v.size() - 1]);
v.pop_back();
}
long long g(vector<long long> &p, int pos) {
if (ok(pos, p.size())) return p[pos];
if (pos < 0 || p.size() == 0) return 0;
return p.back();
}
int g(vector<int> &p, int pos) {
if (ok(pos, p.size())) return p[pos];
if (pos < 0 || p.size() == 0) return 0;
return p.back();
}
int n, q;
int a[N];
pair<int, int> s[N];
struct qu {
int len, pos, id;
};
int ans[N];
qu ask[N];
bool comp(qu a, qu b) { return a.len < b.len; }
int ar[N];
void On(int x) { ar[x] = 1; }
int Find(int pos) {
for (int i = 0; i < n; i++) {
pos -= ar[i];
if (pos == 0) {
return a[i];
}
}
}
signed main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int(i) = 0; (i) != (n); (i)++) {
cin >> a[i];
s[i] = {a[i], -i};
}
sort(s, s + n);
reverse(s, s + n);
for (int(i) = 0; (i) != (n); (i)++) {
s[i].second *= -1;
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> ask[i].len >> ask[i].pos;
ask[i].id = i;
}
sort(ask, ask + q, comp);
int curlen = 0;
for (int i = 0; i < q; i++) {
while (curlen < ask[i].len) {
On(s[curlen].second);
curlen++;
}
ans[ask[i].id] = Find(ask[i].pos);
}
for (int(i) = 0; (i) != (q); (i)++) {
cout << ans[i] << "\n";
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
string gh = "here";
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first > b.first) {
return true;
} else if (a.first == b.first and a.second < b.second) {
return true;
}
return false;
}
bool cmp2(pair<int, int> a, pair<int, int> b) {
if (a.second < b.second) {
return true;
}
return false;
}
int main() {
int n;
cin >> n;
vector<pair<int, int> > v1(n, {0, 0});
for (int i = 0; i < n; i++) {
cin >> v1[i].first;
v1[i].second = i;
}
sort(v1.begin(), v1.end(), cmp);
int m;
cin >> m;
for (int ii = 0; ii < m; ii++) {
int a, b;
cin >> a >> b;
b--;
sort(v1.begin(), v1.begin() + a, cmp2);
cout << ((v1.begin() + b)->first) << '\n';
sort(v1.begin(), v1.begin() + a, cmp);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 200000;
int fen[N + 1];
void add(int x) {
++x;
while (x <= N) {
++fen[x];
x += x & -x;
}
}
int kth(int k) {
int x = 0;
for (int i = 18; i >= 0; --i)
if (x + (1 << i) <= N && fen[x + (1 << i)] <= k) {
x += (1 << i);
k -= fen[x];
}
return x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
cin >> m;
vector<vector<pair<int, int>>> qry(n);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
qry[--x].emplace_back(--y, i);
}
vector<int> b(n);
iota(b.begin(), b.end(), 0);
sort(b.begin(), b.end(),
[&](int i, int j) { return a[i] > a[j] || a[i] == a[j] && i < j; });
vector<int> ans(m);
for (int i = 0; i < n; ++i) {
add(b[i]);
for (auto p : qry[i]) ans[p.second] = a[kth(p.first)];
}
for (int i = 0; i < m; ++i) cout << ans[i] << "\n";
return 0;
}
| 10 | CPP |
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
class SortedList:
def __init__(self, iterable=None, _load=200):
"""Initialize sorted list instance."""
if iterable is None:
iterable = []
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
def main():
n=int(input())
aa=list(map(int,input().split()))
a=[(v,n-i-1) for i,v in enumerate(aa)]
a.sort()
a.reverse()
q=[]
for i in range(int(input())):
x,y=map(int,input().split())
q.append((x,y,i))
q.sort(key=lambda x:x[0])
b=SortedList()
ans=[0]*(len(q))
j=0
for i in q:
while j<i[0]:
b.add(-(a[j][1]-n+1))
j+=1
ans[i[2]]=aa[b[i[1]-1]]
for i in ans:
print(i)
# 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")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main() | 10 | PYTHON3 |
n=int(input())
a=[int(x) for x in input().split()]
b = [[] for i in range(n + 3)]
for g in range(1, n + 1):
k = g
cnt = 0
mm = 10 ** 10
m = 0
for i in range(n):
if len(b[g]) != 0:
mm = min(b[g])
if cnt == k:
if a[i] > mm:
for j in range(k - 1, -1, -1):
if b[g][j] == mm:
b[g].pop(j)
break
b[g].append(a[i])
else:
b[g].append(a[i])
cnt += 1
m = max(b[g])
m = int(input())
for i in range(m):
k, pos = [int(x) for x in input().split()]
pos -= 1
print(b[k][pos])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 9;
const long long mod = 1e9 + 7;
vector<bool> prime(MAX, 1);
vector<int> spf(MAX, 1);
vector<int> primes;
void sieve() {
prime[0] = prime[1] = 0;
spf[2] = 2;
for (long long i = 4; i < MAX; i += 2) {
spf[i] = 2;
prime[i] = 0;
}
primes.push_back(2);
for (long long i = 3; i < MAX; i += 2) {
if (prime[i]) {
primes.push_back(i);
spf[i] = i;
for (long long j = i * i; j < MAX; j += i) {
prime[j] = 0;
if (spf[j] == 1) {
spf[j] = i;
}
}
}
}
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res = res * a;
}
a = a * a;
b = b >> 1;
}
return res;
}
long long power(long long a, long long b, long long m) {
long long res = 1;
while (b) {
if (b & 1) {
res = (res * a) % m;
}
a = (a * a) % m;
b = b >> 1;
}
return res % m;
}
void virtual_main() {}
void real_main() {
int n;
cin >> n;
vector<int> v(n), a(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
a[i] = v[i];
}
sort(v.begin(), v.end());
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
vector<int> values;
for (int i = n - 1; i >= n - k; i--) {
values.push_back(v[i]);
}
reverse(values.begin(), values.end());
vector<int> ans;
vector<bool> mark(n, 0);
int last = 0;
for (int i = 0; i < (int)values.size(); i++) {
int x = values[i];
bool say = 0;
for (int j = last; j < n; j++) {
if (a[j] == x && !mark[j]) {
say = 1;
ans.push_back(j);
mark[j] = 1;
last = j;
break;
}
}
if (!say) {
for (int j = 0; j <= last; j++) {
if (a[j] == x && !mark[j]) {
say = 1;
mark[j] = 1;
last = j;
ans.push_back(j);
break;
}
}
}
}
sort(ans.begin(), ans.end());
cout << a[ans[pos - 1]] << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
virtual_main();
int test_cases = 1;
for (int i = 1; i <= test_cases; i++) {
real_main();
}
return 0;
}
| 10 | CPP |
def main():
n = int(input())
a = list(enumerate(map(int, (input().split()))))
a.sort(key = lambda item: (item[1], -item[0]))
#print(a)
m = int(input())
for i in range(m):
k, pos = map(int, input().split())
s = a[-k:]
s = sorted(s)
print(s[pos - 1][1])
main() | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void ios1() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
}
bool cmd(pair<long long, int> a, pair<long long, int> b) {
if (a.first > b.first)
return 0;
else if (a.first < b.first)
return 1;
else
return (a.second > b.second);
}
int main() {
ios1();
int n;
cin >> n;
pair<long long, int> arr[n];
long long cop[n];
int its[n];
for (int i = 0; i < n; ++i) {
cin >> cop[i];
arr[i] = make_pair(cop[i], i);
}
long long sum1 = 0, sumi[n];
sort(arr, arr + n, cmd);
for (int i = n - 1; i >= 0; --i) {
its[(n - 1) - i] = arr[i].second;
}
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
vector<int> v;
for (int j = a - 1; j >= 0; j--) v.push_back(its[j]);
sort(v.begin(), v.end());
cout << cop[v[b - 1]] << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool mycomp1(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) {
return (a.first < b.first);
} else {
return (a.second > b.second);
}
}
bool mycomp2(pair<int, int> a, pair<int, int> b) {
return (a.second < b.second);
}
void solve() {
int n, m;
cin >> n;
pair<int, int> a[n];
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n, mycomp1);
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
pair<int, int> b[k];
for (int i = 0; i < k; i++) {
b[i] = a[n - k + i];
}
sort(b, b + k, mycomp2);
cout << b[pos - 1].first << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
}
| 10 | CPP |
n = int(input())
aa = [int(i) for i in input().split()]
dic = {}
for i in range(0,n):
if aa[i] not in dic:
dic[aa[i]] = [i]
else:
dic[aa[i]].append(i)
ll = sorted(dic)[::-1]
m = int(input())
for _ in range(0,m):
k,pos = map(int,input().split())
ans = []
for i in range(0,len(ll)):
if len(dic[ll[i]]) < k:
ans += dic[ll[i]]
k -= len(dic[ll[i]])
else:
ans += dic[ll[i]][:k]
break
print(aa[sorted(ans)[pos-1]]) | 10 | PYTHON3 |
n = int(input())
a = list(map(int, input().split()))
u = sorted(a)
m = int(input())
ans = []
for _ in range(m):
k, pos = map(int, input().split())
d = []
p = []
s = u[n - k:]
for i in range(n):
if len(d) == k:
break
for j in range(len(s)):
if s[j] == a[i]:
s[j] = -1
d.append(i)
#p.append(i)
break
d.sort()
ans.append(a[d[pos - 1]])
print('\n'.join(map(str, ans)))
| 10 | PYTHON3 |
n = int(input())
a = list(map(int, input().split()))
a1 = sorted(a, key=lambda x: -x)
m = int(input())
for i in range(m):
k, p = list(map(int, input().split()))
c = {}
c1 = {}
s = []
for j in range(n+1):
s.append({})
pos = {}
for j in range(n):
c[a1[j]] = 0
c1[a1[j]] = 0
s[0][a[j]] = 0
pos[a1[j]] = []
for j in range(n):
s[0][a[j]] += 1
for j in range(n):
for t in range(n):
s[j+1][a[t]] = s[j][a[t]]
s[j+1][a[j]] -= 1
b = []
for j in range(k):
c[a1[j]]+=1
for j in range(k, n):
c1[a1[j]]+=1
ns = []
us = [0]*n
ans = []
for j in range(n-1, -1, -1):
if c1[a[j]] ^ 0:
c1[a[j]] -= 1
else:
ans.append(a[j])
for j in range(len(ans)//2):
ans[j], ans[len(ans)-1-j] = ans[len(ans)-1-j], ans[j]
print(ans[p-1])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > t;
int a[200105];
vector<pair<int, int> > vec[200105];
int ans[200105];
int seg[200105 << 2];
void build(int t, int i, int j) {
if (i == j) {
seg[t] = 1;
return;
}
int left = t << 1, right = left | 1, mid = (i + j) >> 1;
build(left, i, mid);
build(right, mid + 1, j);
seg[t] = seg[left] + seg[right];
}
int upd_ind;
int val;
void update(int t, int i, int j) {
if (i == j) {
seg[t] += val;
return;
}
int left = t << 1, right = left | 1, mid = (i + j) >> 1;
if (upd_ind <= mid)
update(left, i, mid);
else
update(right, mid + 1, j);
seg[t] = seg[left] + seg[right];
}
int query(int t, int i, int j, int p) {
if (i == j) {
return a[i];
}
int left = t << 1, right = left | 1, mid = (i + j) >> 1;
if (seg[left] >= p)
return query(left, i, mid, p);
else
return query(right, mid + 1, j, p - seg[left]);
}
int compute(int p, int n) { return query(1, 1, n, p); }
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
t.insert(make_pair(a[i], -i));
}
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int k, p;
scanf("%d", &k);
scanf("%d", &p);
vec[k].push_back(make_pair(p, i));
}
build(1, 1, n);
for (int k = n; k > 0; k--) {
pair<int, int> elem = *t.begin();
int ind = -elem.second;
for (int j = 0; j < vec[k].size(); j++) {
int p = vec[k][j].first;
int ans_index = vec[k][j].second;
ans[ans_index] = compute(p, n);
}
upd_ind = ind;
val = -1;
update(1, 1, n);
t.erase(elem);
}
for (int i = 1; i <= m; i++) {
printf("%d\n", ans[i]);
}
}
| 10 | CPP |
def main():
import os
from io import BytesIO
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
n = int(input())
a = [(int(el), -ind) for ind, el in enumerate(input().split())]
a.sort(reverse=True)
for i in range(int(input())):
x, y = map(int, input().split())
t = sorted(a[:x], key=lambda x: -x[1])
print(t[y - 1][0])
main()
| 10 | PYTHON3 |
from collections import defaultdict
n=int(input())
a=[int(x) for x in input().split()]
b=sorted(a,reverse=True)
for _ in range(int(input())):
k,pos=map(int,input().split())
d=defaultdict(int)
for i in range(k):
d[b[i]]+=1
count=0
num=-1
for x in a:
if d[x]:
d[x]-=1
count+=1
if count==pos:
num=x
break
print(num) | 10 | PYTHON3 |
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
from collections import defaultdict
from itertools import permutations
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")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
n=int(input())
a1=list(map(int,input().split()))
a=list()
for i in range (n):
a.append((a1[i],n-i))
a.sort(reverse=True)
m=int(input())
for i in range (m):
k,pos=map(int,input().split())
c=list()
for j in range (k):
c.append(n-a[j][1])
c.sort()
res=a1[c[pos-1]]
print(res) | 10 | PYTHON3 |
#include <bits/stdc++.h>
const long long MAX = 2e5 + 5;
using namespace std;
long long fen[MAX], a[MAX];
bool cnt[MAX];
bool compare(const pair<long long, long long> &x,
const pair<long long, long long> &y) {
if (x.second == y.second) return x.first < y.first;
return x.second > y.second;
}
void f_insert(long long loc) {
if (loc > 2e5) return;
fen[loc]++;
f_insert(loc + (loc & -loc));
}
long long get_arc(long long num, bool bol = true) {
if (bol) num--;
if (num < 1) return 0;
return fen[num] + get_arc(num - (num & -num), false);
}
long long ind(long long num, long long l = 1, long long r = 2e5) {
long long mid = (l + r) / 2;
long long s = get_arc(mid);
if (s >= num) return ind(num, l, mid - 1);
if (s + cnt[mid] < num) return ind(num, mid + 1, r);
return mid;
}
int main() {
long long n, q;
cin >> n;
pair<long long, long long> p[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
p[i] = {i + 1, a[i]};
}
sort(p, p + n, compare);
cin >> q;
map<pair<long long, long long>, long long> m;
vector<pair<long long, long long>> v, s;
for (long long i = 0; i < q; i++) {
long long l, r;
cin >> l >> r;
s.push_back({l, r});
v.push_back({l, r});
}
sort(s.begin(), s.end());
long long loc = 0;
for (long long i = 0; i < q; i++) {
long long x = s[i].first, y = s[i].second;
while (loc < x) {
cnt[p[loc].first] = true;
f_insert(p[loc].first);
loc++;
}
long long j = ind(y);
m[{x, y}] = a[j - 1];
}
for (auto i : v) cout << m[i] << endl;
return 0;
}
| 10 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.