text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll n;
ll a[200001];
ll sum[200001];
ll bit[200001];
ll p[200001];
template <typename T>
inline T read() {
T x = 0;
T multiplier = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') {
multiplier = -1;
}
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch & 15);
ch = getchar();
}
return x * multiplier;
}
inline ll query(ll idx) {
ll ans = 0;
for (; idx; idx -= idx & -idx) {
ans += bit[idx];
}
return ans;
}
inline void add(ll n, ll idx, ll val) {
for (; idx <= n; idx += idx & -idx) {
bit[idx] += val;
}
}
inline ll get_idx(ll x) {
ll l = 1, r = n, mid;
ll idx;
while (l <= r) {
mid = (l + r + 1) >> 1;
if (query(mid) <= x) {
l = mid + 1;
idx = mid;
} else {
r = mid - 1;
}
}
return idx;
}
int main() {
n = read<ll>();
for (ll i = 1; i <= n; i++) {
a[i] = read<ll>();
}
for (ll i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + i - 1;
}
for (ll i = 1; i <= n; i++) {
bit[i] = sum[i] - sum[i - (i & -i)];
}
for (ll i = n; i >= 1; i--) {
ll x = get_idx(a[i]);
p[i] = x;
add(n, x + 1, -x);
}
for (ll i = 1; i <= n; i++) {
printf("%lld ", p[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 222222;
int p[N], a[N], streee[N << 2];
long long s[N], stree[N << 2];
int n;
void supdate(int x, int v, int l, int r, int pos) {
if (l == r) {
streee[pos] += v;
return;
}
int m = l + (r - l) / 2;
if (x <= m) {
supdate(x, v, l, m, pos * 2 + 1);
} else {
supdate(x, v, m + 1, r, pos * 2 + 2);
}
streee[pos] = streee[pos * 2 + 1] + streee[pos * 2 + 2];
}
int squery(int i, int l, int r, int pos) {
if (l == r) {
return l;
}
int m = l + (r - l) / 2;
if (i > streee[2 * pos + 1]) {
return squery(i - streee[2 * pos + 1], m + 1, r, pos * 2 + 2);
}
return squery(i, l, m, pos * 2 + 1);
}
long long build(int l, int r, int pos) {
if (l == r) {
stree[pos] = a[l];
return stree[pos];
}
int m = l + r >> 1;
long long x = build(l, m, pos * 2 + 1);
long long y = build(m + 1, r, pos * 2 + 2);
stree[pos] = x + y;
return stree[pos];
}
void update(int i, int cl, int cr, int pos) {
if (cl == i && cr == i) {
stree[pos] = 0;
return;
}
int m = cl + cr >> 1;
if (i <= m) {
update(i, cl, m, pos * 2 + 1);
} else {
update(i, m + 1, cr, pos * 2 + 2);
}
stree[pos] = stree[pos * 2 + 1] + stree[pos * 2 + 2];
}
long long query(int l, int r, int cl, int cr, int pos) {
if (cl > r || cr < l) {
return 0;
} else if (cl >= l && cr <= r) {
return stree[pos];
}
int m = cl + cr >> 1;
long long x = query(l, r, cl, m, pos * 2 + 1);
long long y = query(l, r, m + 1, cr, pos * 2 + 2);
return x + y;
}
int solve(long long sum, int si) {
int l = 1, r = si;
while (l < r) {
int i = l + r >> 1;
int ii = squery(i, 1, n, 0);
long long curr = query(0, ii - 1, 1, n, 0);
if (curr < sum) {
l = i + 1;
} else {
r = i;
}
}
return squery(l, 1, n, 0);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = (1); i <= (n); i++) {
cin >> s[i];
a[i] = i;
supdate(i, 1, 1, n, 0);
}
build(1, n, 0);
for (int i = (n); i >= (1); i--) {
p[i] = solve(s[i], i);
update(p[i], 1, n, 0);
supdate(p[i], -1, 1, n, 0);
}
for (int i = (1); i <= (n); i++) {
cout << p[i] << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const long long inf = 1e18;
long long a[N], ans[N];
struct node {
int l, r;
long long lazy;
long long v;
};
node e[N * 5];
void build(int root, int l, int r) {
e[root].l = l;
e[root].r = r;
e[root].lazy = e[root].v = 0;
if (l == r) {
e[root].v = a[l];
return;
}
build(root * 2, l, (l + r) / 2);
build(root * 2 + 1, (l + r) / 2 + 1, r);
e[root].v = min(e[root * 2].v, e[root * 2 + 1].v);
}
void updown(int root) {
if (e[root].lazy) {
e[root * 2].lazy += e[root].lazy;
e[root * 2 + 1].lazy += e[root].lazy;
e[root * 2].v -= e[root].lazy;
e[root * 2 + 1].v -= e[root].lazy;
e[root].lazy = 0;
}
}
int que(int root, int x) {
if (e[root].l == e[root].r) return e[root].l;
updown(root);
if (e[root * 2 + 1].v == x)
return que(root * 2 + 1, x);
else
return que(root * 2, x);
}
void update1(int root, int x) {
if (e[root].l == e[root].r) {
e[root].v = inf;
return;
}
int mid = (e[root].l + e[root].r) / 2;
if (x <= mid)
update1(root * 2, x);
else
update1(root * 2 + 1, x);
e[root].v = min(e[root * 2].v, e[root * 2 + 1].v);
}
void update2(int root, int l, int r, int x) {
if (e[root].l == l && e[root].r == r) {
e[root].v -= x;
e[root].lazy += x;
return;
}
updown(root);
int mid = (e[root].l + e[root].r) / 2;
if (l > mid)
update2(root * 2 + 1, l, r, x);
else {
if (r <= mid)
update2(root * 2, l, r, x);
else {
update2(root * 2, l, mid, x);
update2(root * 2 + 1, mid + 1, r, x);
}
}
e[root].v = min(e[root * 2].v, e[root * 2 + 1].v);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
build(1, 1, n);
for (int i = 1; i <= n; i++) {
int k = que(1, 0);
ans[k] = i;
update1(1, k);
if (k != n) update2(1, k + 1, n, i);
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> s;
vector<pair<long long, long long>> tree;
void build(long long l, long long r, long long v) {
if (r - 1 == l) {
tree[v] = {s[l], l};
return;
}
long long m = (r + l) / 2;
build(l, m, v * 2 + 1);
build(m, r, v * 2 + 2);
auto a = tree[v * 2 + 1];
auto b = tree[v * 2 + 2];
if (a.first < b.first) {
tree[v] = a;
} else {
tree[v] = b;
}
}
vector<long long> mod;
pair<long long, long long> get(long long l, long long r, long long u,
long long w, long long v) {
if (r <= u || l >= w) {
return {1e9, 0};
}
if (r <= w && l >= u) {
return tree[v];
}
long long m = (r + l) / 2;
auto a = get(l, m, u, w, v * 2 + 1);
auto b = get(m, r, u, w, v * 2 + 2);
if (a.first < b.first) {
return {a.first + mod[v], a.second};
} else {
return {b.first + mod[v], b.second};
}
}
void update(long long l, long long r, long long u, long long w, long long v,
long long delt) {
if (r <= u || l >= w) {
return;
}
if (r <= w && l >= u) {
mod[v] += delt;
auto a = tree[v];
tree[v] = {a.first + delt, a.second};
return;
}
long long m = (r + l) / 2;
update(l, m, u, w, v * 2 + 1, delt);
update(m, r, u, w, v * 2 + 2, delt);
auto a = tree[v * 2 + 1];
auto b = tree[v * 2 + 2];
if (a.first < b.first) {
tree[v] = {a.first + mod[v], a.second};
} else {
tree[v] = {b.first + mod[v], b.second};
}
}
signed main() {
long long n;
cin >> n;
s.resize(n);
for (long long i = 0; i < n; i++) {
cin >> s[i];
}
tree.resize(4 * n);
mod.resize(4 * n);
build(0, n, 0);
vector<long long> v(n);
long long sum = 0;
for (long long i = 1; i <= n; i++) {
auto a = get(0, n, 0, n, 0);
v[a.second] = i;
update(0, n, a.second, a.second + 1, 0, 1e18 + 1);
update(0, n, a.second + 1, n, 0, -i);
}
for (long long i = 0; i < n; i++) {
cout << v[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[200005];
pair<long long int, long long int> tree[4 * 200005];
long long int lazy[4 * 200005];
void build(long long int node, long long int st, long long int en) {
if (st == en) {
tree[node] = {a[st], st};
return;
}
long long int mid = (st + en) / 2;
build(2 * node, st, mid);
build(2 * node + 1, mid + 1, en);
if (tree[2 * node].first != tree[2 * node + 1].first)
tree[node] = min(tree[2 * node], tree[2 * node + 1]);
else {
tree[node].first = min(tree[2 * node].first, tree[2 * node + 1].first);
tree[node].second = max(tree[2 * node].second, tree[2 * node + 1].second);
}
}
void update(long long int node, long long int st, long long int en,
long long int l, long long int r, long long int v) {
if (lazy[node] != 0) {
tree[node].first += lazy[node];
if (st != en) {
lazy[2 * node] += lazy[node];
lazy[2 * node + 1] += lazy[node];
}
lazy[node] = 0;
}
if (st > en || st > r || en < l) return;
if (st >= l && en <= r) {
tree[node].first += v;
if (st != en) {
lazy[2 * node] += v;
lazy[2 * node + 1] += v;
}
return;
}
long long int mid = (st + en) / 2;
update(2 * node, st, mid, l, r, v);
update(2 * node + 1, mid + 1, en, l, r, v);
if (tree[2 * node].first != tree[2 * node + 1].first)
tree[node] = min(tree[2 * node], tree[2 * node + 1]);
else {
tree[node].first = min(tree[2 * node].first, tree[2 * node + 1].first);
tree[node].second = max(tree[2 * node].second, tree[2 * node + 1].second);
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int i;
long long int ans[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
build(1, 0, n - 1);
for (i = 1; i <= n; i++) {
long long int j = tree[1].second;
update(1, 0, n - 1, j, j, 1e17);
update(1, 0, n - 1, j + 1, n - 1, -i);
ans[j] = i;
}
for (i = 0; i < n; i++) {
cout << ans[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') w = -1;
ch = getchar();
}
while (isdigit(ch)) s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int maxn = 2e5 + 10;
long long a[maxn], coun[maxn << 2], sum[maxn << 2];
long long ans[maxn];
int n;
void build(int l, int r, int i) {
if (l == r) {
sum[i] = 1;
coun[i] = l;
return;
}
int mid = (l + r) >> 1;
build(l, mid, i << 1);
build(mid + 1, r, (i << 1) + 1);
sum[i] = sum[i << 1] + sum[(i << 1) + 1];
coun[i] = coun[i << 1] + coun[(i << 1) + 1];
}
void update(int l, int r, int pos, int i) {
if (l == r) {
sum[i] = 0;
coun[i] = 0;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid) update(l, mid, pos, i << 1);
if (pos > mid) update(mid + 1, r, pos, (i << 1) + 1);
sum[i] = sum[i << 1] + sum[(i << 1) + 1];
coun[i] = coun[i << 1] + coun[(i << 1) + 1];
}
long long query(int l, int r, int i, int k) {
if (sum[i] <= k) return coun[i];
int mid = (l + r) >> 1;
if (sum[i << 1] >= k) return query(l, mid, i << 1, k);
return coun[i << 1] + query(mid + 1, r, (i << 1) + 1, k - sum[i << 1]);
}
int queryMin(int l, int r, int i, int k) {
if (l == r) return l;
int mid = (l + r) >> 1;
if (sum[i << 1] >= k) return queryMin(l, mid, i << 1, k);
return queryMin(mid + 1, r, (i << 1) + 1, k - sum[i << 1]);
}
bool check(int mid, long long x) { return query(1, n, 1, mid) >= x; }
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read();
build(1, n, 1);
for (int i = n; i >= 1; --i) {
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid - 1, a[i])) {
ans[i] = queryMin(1, n, 1, mid);
r = mid - 1;
} else
l = mid + 1;
}
update(1, n, ans[i], 1);
}
for (int i = 1; i <= n; ++i) write(ans[i]), putchar(' ');
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int maxN = 1e6 + 10;
ll tree[4 * maxN];
int n, p[maxN];
ll s[maxN];
void update(int x, int l, int r, int k, int w) {
if (l == r)
tree[x] = w;
else {
int mid = (l + r) / 2;
if (k <= mid)
update(2 * x, l, mid, k, w);
else
update(2 * x + 1, mid + 1, r, k, w);
tree[x] = tree[2 * x] + tree[2 * x + 1];
}
}
void build(int x, int l, int r) {
if (l == r)
tree[x] = p[l];
else {
int mid = (l + r) / 2;
build(2 * x, l, mid);
build(2 * x + 1, mid + 1, r);
tree[x] = tree[2 * x] + tree[2 * x + 1];
}
}
ll query(int x, int l, int r, int i, int j) {
if (l > j || r < i)
return 0;
else if (l >= i && r <= j)
return tree[x];
int mid = (l + r) / 2;
return query(2 * x, l, mid, i, j) + query(2 * x + 1, mid + 1, r, i, j);
}
void input() {
cin >> n;
for (int i = int(1); i <= int(n); ++i) p[i] = i;
for (int i = int(1); i <= int(n); ++i) cin >> s[i];
}
void solve() {
build(1, 1, n);
for (int i = int(n); i >= int(1); --i) {
int l = 0, r = n, mid;
ll tmp;
while (r - l > 1) {
mid = (l + r) / 2;
if (mid == 0)
tmp = 0;
else
tmp = query(1, 1, n, 1, mid);
if (tmp <= s[i]) {
l = mid;
} else
r = mid;
}
p[i] = l + 1;
update(1, 1, n, l + 1, 0);
}
}
void output() {
for (int i = int(1); i <= int(n); ++i) cout << p[i] << " ";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
input();
solve();
output();
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, q, x, k, t, y, w = 2, z, a[200500], ans[200500], bit[400500];
long long get(int i) {
long long ret = 0;
while (i) ret += bit[i], i -= (i & -i);
return ret;
}
void update(int i, int val) {
while (i <= 2 * n) bit[i] += val, i += (i & -i);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i - 1], update(i + 1, i);
for (int i = n - 1; i >= 0; --i) {
z = 0;
for (int j = pow(2, ceil(log2(n))); j > 0; j /= 2)
if (get(j + z) <= a[i]) z += j;
update(z + 1, -z);
ans[i] = z;
}
for (int i = 0; i < n; ++i) cout << ans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class fenwick {
public:
vector<T> fenw;
int n;
fenwick(int _n) : n(_n) { fenw.resize(n); }
void modify(int x, T v) {
while (x < n) {
fenw[x] += v;
x |= (x + 1);
}
}
T get(int x) {
T v{};
while (x >= 0) {
v += fenw[x];
x = (x & (x + 1)) - 1;
}
return v;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<long long> s(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
}
fenwick<long long> fenw(n);
for (int i = 0; i < n; i++) {
fenw.modify(i, i + 1);
}
vector<int> a(n);
for (int i = n - 1; i >= 0; i--) {
int low = 0, high = n - 1;
while (low < high) {
int mid = (low + high) >> 1;
if (fenw.get(mid) > s[i]) {
high = mid;
} else {
low = mid + 1;
}
}
a[i] = low + 1;
fenw.modify(low, -low - 1);
}
for (int i = 0; i < n; i++) {
if (i > 0) {
cout << " ";
}
cout << a[i];
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e16 + 5;
const int N = 1e6 + 5;
long long first[N];
long long lazy[N] = {0};
long long s[N];
int ans[N];
void pull(int v) { first[v] = min(first[2 * v + 1], first[2 * v + 2]); }
void apply(int v, long long val) {
first[v] += val;
lazy[v] += val;
}
void laziness(int v, int a, int b) {
if (lazy[v] != 0) {
apply(2 * v + 1, lazy[v]);
apply(2 * v + 2, lazy[v]);
lazy[v] = 0;
}
}
void zbuduj(int v, int a, int b) {
if (a > b) return;
if (a == b) {
first[v] = s[a];
return;
}
zbuduj(2 * v + 1, a, (a + b) / 2);
zbuduj(2 * v + 2, (a + b) / 2 + 1, b);
first[v] = min(first[2 * v + 1], first[2 * v + 2]);
}
void dodaj(int v, int a, int b, int i, int j, long long val) {
if (b < i || a > j) {
return;
} else if (a >= i && b <= j) {
apply(v, val);
} else {
laziness(v, a, b);
dodaj(2 * v + 1, a, (a + b) / 2, i, j, val);
dodaj(2 * v + 2, (a + b) / 2 + 1, b, i, j, val);
pull(v);
}
}
int get_min(int v, int a, int b) {
if (a == b)
return a;
else {
laziness(v, a, b);
int x = -1;
if (first[2 * v + 2] == 0) {
x = get_min(2 * v + 2, (a + b) / 2 + 1, b);
} else {
x = get_min(2 * v + 1, a, (a + b) / 2);
}
pull(v);
return x;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (n); ++i) scanf("%I64d", &s[i]);
zbuduj(0, 0, n - 1);
for (int i = (1); i <= (n); ++i) {
int indeks = get_min(0, 0, n - 1);
ans[indeks] = i;
dodaj(0, 0, n - 1, indeks, indeks, INF);
dodaj(0, 0, n - 1, indeks + 1, n - 1, -i);
}
for (int i = 0; i < (n); ++i) printf("%d ", ans[i]);
}
|
#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';
}
|
#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] << ' ';
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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");
}
|
#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 << " ";
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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();
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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] << " ";
}
|
#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";
}
|
#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;
}
|
#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;
}
|
#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]);
}
|
#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;
}
|
#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;
}
|
#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(' ');
}
}
|
#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;
}
|
#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] << " ";
}
|
#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;
}
|
#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';
}
}
|
#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;
}
|
#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;
}
|
#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;
}
}
|
#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;
}
|
#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();
}
}
|
#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;
}
|
#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;
}
|
#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;
}
}
|
#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';
}
}
|
#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';
}
}
|
#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;
}
}
|
#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;
}
|
#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';
}
}
|
#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();
}
|
#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;
}
|
#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';
}
}
|
#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;
}
}
|
#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;
}
|
#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();
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
}
}
|
#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();
}
}
|
#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();
}
}
|
#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";
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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();
}
}
|
#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]);
}
}
|
#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;
}
|
#include <bits/stdc++.h>
using namespace std;
hash<string> hfn;
const int inf = 2e9;
const long long mod = 1e9 + 7;
const long double eps = 1e-8;
const long long biginf = 2e18;
bool comp(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
void solve() {
int n;
cin >> n;
vector<pair<int, int> > v(n);
vector<int> stv(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first;
v[i].second = i;
stv[i] = v[i].first;
}
sort((v).begin(), (v).end(), comp);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int k, ind;
cin >> k >> ind;
ind--;
int pos = n - k + ind;
vector<pair<int, int> > r;
for (int i = n - k; i < n; i++)
r.push_back(make_pair(v[i].second, v[i].first));
sort((r).begin(), (r).end());
cout << r[ind].second << endl;
}
}
void multisolve() {
int t;
cin >> t;
while (t--) solve();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> p1, pair<int, int> p2) {
if (p1.first == p2.first) {
return p1.second < p2.second;
} else {
return p1.first > p2.first;
}
}
int fc(int k, int pos, vector<pair<int, int> > a, vector<int> b) {
vector<int> y;
for (int i = 0; i < k; i++) {
y.push_back(a[i].second);
}
sort(y.begin(), y.end());
return y[pos - 1];
}
int main() {
int n;
cin >> n;
vector<pair<int, int> > a(n);
vector<int> b(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
b[i] = a[i].first;
}
sort(a.begin(), a.end(), cmp);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int k, pos;
cin >> k >> pos;
int x = fc(k, pos, a, b);
cout << b[x] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> v(n), so(n);
for (long long i = 0; i < n; ++i) {
cin >> v[i];
so[i] = v[i];
}
sort(so.begin(), so.end());
long long m;
cin >> m;
for (long long i = 0; i < m; ++i) {
long long k, pos;
cin >> k >> pos;
map<long long, long long> mp;
for (long long j = n - k; j < n; ++j) {
mp[so[j]]++;
}
for (long long j = 0; j < n; ++j) {
if (mp.count(v[j]) and mp[v[j]] > 0) {
--pos;
mp[v[j]]--;
}
if (pos == 0) {
cout << v[j] << endl;
break;
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
{ solve(); }
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 123, MAXN = 2e5 + 47;
long long p = 41;
template <class T>
istream& operator>>(istream& in, vector<T>& a) {
for (auto& i : a) in >> i;
return in;
}
template <class T>
ostream& operator<<(ostream& out, vector<T>& a) {
for (auto& i : a) out << i << " ";
return out;
}
template <class T, class U>
istream& operator>>(istream& in, vector<pair<T, U>>& a) {
for (auto& i : a) in >> i.first >> i.second;
return in;
}
template <class T, class U>
ostream& operator<<(ostream& out, vector<pair<T, U>>& a) {
for (auto& i : a) out << i.first << " " << i.second << endl;
return out;
}
bool cmp(pair<long long, long long>& a, pair<long long, long long>& b) {
if (a.first > b.first) return 1;
if (a.first < b.first) return 0;
if (a.first == b.first) {
if (a.second < b.second)
return 1;
else
return 0;
}
}
signed main() {
setlocale(LC_ALL, "rus");
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<long long> a(n);
cin >> a;
vector<pair<long long, long long>> p(n);
for (long long i = 0; i < n; ++i) p[i] = make_pair(a[i], i);
sort(p.begin(), p.end(), cmp);
long long m;
cin >> m;
while (m--) {
long long k, pos;
cin >> k >> pos;
vector<long long> b(n, 0);
for (long long i = 0; i < k; ++i) b[p[i].second] = p[i].first;
vector<long long> ans;
for (long long i = 0; i < n; ++i)
if (b[i]) ans.push_back(b[i]);
cout << ans[pos - 1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 1;
const int N = 1e6 * 3;
const double EPS = 1 / 1e10;
vector<int> v, v1;
set<pair<long long, long long> > second;
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
return (a.first > b.first) || (a.first == b.first && a.second < b.second);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q, n;
cin >> n;
pair<long long, long long> a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n, cmp);
cin >> q;
for (int w = 1; w <= q; w++) {
int k, pos;
second.clear();
cin >> k >> pos;
for (int i = 0; i < k; i++)
second.insert(make_pair(a[i].second, a[i].first));
set<pair<long long, long long> >::iterator it = second.begin();
for (int i = 0; i < pos - 1; it++, i++)
;
cout << it->second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
const long long md = 1e9 + 7;
long long n, q, a, i, k, pos;
vector<pair<long long, long long> > v, ans;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first)
return a.second < b.second;
else
return a > b;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a;
v.push_back({a, i});
}
sort(v.begin(), v.end(), comp);
cin >> q;
while (q--) {
cin >> k >> pos;
ans.clear();
for (i = 0; i < k; i++) {
ans.push_back({v[i].second, v[i].first});
}
sort(ans.begin(), ans.end());
pos--;
cout << ans[pos].second << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n;
vector<int> a_f(n);
vector<pair<int, int>> a(n);
for (int i = 0; i < n; i++)
cin >> a[i].first, a[i].second = i, a_f[i] = a[i].first;
sort(a.begin(), a.end(), comp);
cin >> m;
vector<vector<int>> tmp(n);
vector<bool> used(n);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < n - i; j++) used[a[j].second] = true;
for (int j = 0; j < n; j++) {
if (used[j]) continue;
tmp[i - 1].push_back(a_f[j]);
}
used.assign(n, false);
}
while (m--) {
int j, pos;
cin >> j >> pos;
cout << tmp[j - 1][pos - 1] << '\n';
}
return 0;
}
|
#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);
int m;
cin >> m;
for (i = 1; i <= m; i++) {
int k, pos;
cin >> k >> pos;
vector<int> sv;
int j;
for (j = n - 1; j >= n - k; j--) {
sv.push_back(vc[j].second);
}
sort(sv.begin(), sv.end());
cout << ara[sv[pos - 1]] << "" << endl;
}
return 0;
}
|
#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--) {
map<int, pair<int, vector<int>>> mp;
int k, pos;
cin >> k >> pos;
vector<int> temp;
mp[0] = make_pair(0, temp);
for (int i = 0; i < n; i++) {
vector<pair<int, vector<int>>> toadd;
for (auto& a : mp) {
if (a.first >= k) continue;
int nsm = a.second.first + arr[i];
vector<int> temp = a.second.second;
;
temp.push_back(arr[i]);
toadd.push_back(make_pair(nsm, temp));
}
for (auto& a : toadd) {
if (!mp.count(a.second.size()) || mp[a.second.size()].first < a.first ||
(mp[a.second.size()].first == a.first &&
mp[a.second.size()].second > a.second)) {
mp[a.second.size()] = a;
}
}
}
auto e = mp.end();
e--;
cout << e->second.second[pos - 1] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
int a[N];
vector<pair<int, int> > vec;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first)
return a.first > b.first;
else
return a.second < b.second;
}
void solve() {
int k, pos;
cin >> k >> pos;
vector<int> ans;
for (int i = 0; i < k; i++) {
ans.push_back(vec[i].second);
}
sort(ans.begin(), ans.end());
cout << a[ans[pos - 1]] << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
vec.push_back({a[i], i});
}
int m;
cin >> m;
sort(vec.begin(), vec.end(), cmp);
while (m--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long N = 200000;
vector<bool> visited(N + 1, false);
bool isprime(long long x) {
for (long long i = 2; i <= sqrt(x); i++) {
if (x % i == 0) return false;
}
return true;
}
void findfact(long long x, map<long long, vector<long long>>& m) {
for (long long i = 3; i * i <= x; i += 2) {
if (x % i == 0) {
if (i == x / i)
m[x].push_back(i);
else {
m[x].push_back(i);
m[x].push_back(x / i);
}
break;
}
}
return;
}
struct cmp {
bool operator()(const pair<int, int>& a, const pair<int, int>& b) {
if (a.first > b.first)
return false;
else if (a.first < b.first)
return true;
if (a.second < b.second) return false;
return true;
}
};
bool isPalindrome(string t) {
long long st = 0;
long long end = t.size() - 1;
while (st <= end) {
if (t[st] != t[end]) return false;
st++;
end--;
}
return true;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool pow2(long long x) { return x && (!(x & (x - 1))); }
unsigned long long factorial(unsigned long long n) {
return (n == 1 || n == 0) ? 1 : n * factorial(n - 1);
}
unsigned long long binomialCoeff(unsigned long long n, unsigned long long k) {
unsigned long long res = 1;
if (k > n - k) k = n - k;
for (unsigned long long i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
vector<long long> hp;
void primeFactors(long long n) {
while (n % 2 == 0) {
hp.push_back(2);
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
hp.push_back(i);
n = n / i;
}
}
if (n > 2) hp.push_back(n);
}
long long minFlipsMonoIncr(string S) {
int flip = 0;
int ones = 0;
bool flag = false;
for (int i = 0; i < S.size(); i++) {
if (S[i] - '0' == 1) flag = true;
if (flag && S[i] - '0' == 0)
flip++;
else if (S[i] == '1')
ones++;
if (flip > ones) flip = ones;
}
return flip;
}
void dfs() {}
int main() {
ios_base::sync_with_stdio(0);
long long n;
cin >> n;
vector<long long> arr(n + 1);
for (long long i = 1; i <= n; i++) cin >> arr[i];
long long m;
cin >> m;
while (m--) {
long long k, pos;
cin >> k >> pos;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long>>, cmp>
pq;
for (long long i = 1; i <= n; i++) pq.push(make_pair(arr[i], i));
vector<long long> temp(n + 1, -1);
while (k--) {
temp[pq.top().second] = pq.top().first;
pq.pop();
}
long long ele = 0;
long long i;
for (i = 1; i <= n; i++) {
if (temp[i] == -1)
continue;
else
ele++;
if (ele == pos) break;
}
cout << temp[i] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const LL INF = INT_MAX;
const int N = 1e5 + 7;
const LL MOD = 1e9 + 7;
void ArrayIn(int size, int a[]) {
for (int i = 0; i < size; i++) scanf("%d", &a[i]);
}
void ArrayOut(int size, int a[]) {
for (int i = 0; i < size; i++) printf("%d ", a[i]);
printf("\n");
}
int main() {
int n, m, i;
scanf("%d", &n);
vector<pair<int, int>> ar(n + 1);
for (i = 1; i <= n; i++) {
int item;
scanf("%d", &item);
ar[i] = make_pair(item, i);
}
sort(ar.rbegin(), ar.rend() - 1);
for (i = 1; i <= n; i++) {
int j = i;
while (ar[j].first == ar[j + 1].first && j < n) j++;
reverse(ar.begin() + i, ar.begin() + j + 1);
i = j;
}
scanf("%d", &m);
while (m--) {
vector<pair<int, int>> cur = ar;
int k, pos;
scanf("%d%d", &k, &pos);
for (i = 1; i <= k; i++) {
swap(cur[i].first, cur[i].second);
}
sort(cur.begin() + 1, cur.begin() + 1 + k);
printf("%d\n", cur[pos].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int no = 3e6 + 5, modulo = 1e9 + 7, inf = 1e18, N = 3e3 + 1;
long long int ar[no], br[no], cr[no];
void solve() {
long long int n = 0, m = 0, a = 0, b = 0, c = 0, d = 0, x = 0, y = 0, z = 0,
w = 0, k = 0;
cin >> n;
vector<long long int> vv;
for (long long int i = 1; i < n + 1; i++) cin >> ar[i], vv.push_back(ar[i]);
cin >> m;
sort(vv.rbegin(), vv.rend());
while (m--) {
cin >> x >> y;
a = vv[x - 1];
vector<long long int> ans, v;
map<long long int, long long int> mapp;
for (long long int i = 0; i < x; i++) {
if (vv[i] > a) v.push_back(vv[i]), mapp[vv[i]]++;
}
z = 0;
for (long long int i = 1; i < n + 1; i++) {
if (ans.size() == x) break;
if (ar[i] == a && z < (x - v.size())) {
ans.push_back(a);
z++;
} else if (mapp[ar[i]] > 0) {
mapp[ar[i]]--;
ans.push_back(ar[i]);
if (mapp[ar[i]] == 0) mapp.erase(ar[i]);
}
}
cout << ans[y - 1] << "\n";
}
}
inline void runn() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
for (long long int i = 1; i < t + 1; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 2 * acos(0.0);
struct arr {
long long index, val;
};
struct query {
long long n, ind, index, ans;
};
bool compare(arr a1, arr a2) {
if (a1.val == a2.val) return (a1.index < a2.index);
return (a1.val > a2.val);
}
bool compare2(arr a1, arr a2) { return (a1.index < a2.index); }
bool compare1(query q1, query q2) { return (q1.n < q2.n); }
bool compare3(query q1, query q2) { return (q1.index < q2.index); }
int main() {
long long n, i;
cin >> n;
arr A[n];
for (i = 0; i < n; ++i) {
cin >> A[i].val;
A[i].index = i + 1;
}
sort(A, A + n, compare);
long long m;
cin >> m;
query q[m];
for (i = 0; i < m; ++i) {
cin >> q[i].n >> q[i].ind;
q[i].index = i;
}
sort(q, q + m, compare1);
for (i = 0; i < m; ++i) {
if (i != 0) {
if (q[i].n != q[i - 1].n) {
sort(A, A + q[i - 1].n, compare);
sort(A, A + q[i].n, compare2);
q[i].ans = A[q[i].ind - 1].val;
} else
q[i].ans = A[q[i].ind - 1].val;
} else {
sort(A, A + q[i].n, compare2);
q[i].ans = A[q[i].ind - 1].val;
}
}
sort(q, q + m, compare3);
for (i = 0; i < m; ++i) cout << q[i].ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e12;
int main() {
int n;
cin >> n;
vector<int> a(n), s;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
s = a;
sort(s.begin(), s.end());
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int k, pos;
cin >> k >> pos;
int c = 0;
vector<int> ans, st(k);
while (c < k) {
st[c] = s[n - 1 - c];
++c;
}
sort(st.begin(), st.end());
for (int q = 0; q < n; ++q) {
bool flag = false;
for (int j = 0; j < st.size(); ++j) {
if (a[q] == st[j]) {
flag = true;
st.erase(st.begin() + j);
break;
}
}
if (flag && ans.size() < k) {
ans.push_back(a[q]);
}
}
cout << ans[pos - 1] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 123, MAXN = 5e5 + 47, MEGAINF = 1e18 + 228;
template <class T>
inline istream& operator>>(istream& in, vector<T>& a) {
for (auto& i : a) in >> i;
return in;
}
template <class T>
inline ostream& operator<<(ostream& out, vector<T>& a) {
for (auto i : a) out << i << " ";
return out;
}
template <class T, class U>
inline istream& operator>>(istream& in, vector<pair<T, U>>& a) {
for (auto& i : a) in >> i.first >> i.second;
return in;
}
template <class T, class U>
inline ostream& operator<<(ostream& out, vector<pair<T, U>>& a) {
for (auto& i : a) out << i.first << " " << i.second << "\n";
return out;
}
signed main() {
setlocale(LC_ALL, "rus");
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<long long> a(n);
cin >> a;
vector<pair<long long, long long>> p;
for (long long i = 0; i < n; ++i) p.push_back({a[i], i});
sort(p.begin(), p.end(),
[&](pair<long long, long long> one, pair<long long, long long> two) {
if (one.first == two.first) return one.second < two.second;
return one.first > two.first;
});
long long m;
cin >> m;
while (m--) {
long long k, pos;
cin >> k >> pos;
--pos;
vector<long long> have;
for (long long i = 0; i < k; ++i) have.push_back(p[i].second);
sort(have.begin(), have.end());
long long ind = have[pos];
cout << a[ind] << "\n";
}
}
|
#include <bits/stdc++.h>
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const int maxn = 100100;
using namespace std;
int ans[110][110];
struct node {
int nub, pos;
} a[110];
bool cmp(node c, node b) {
if (c.nub == b.nub) return c.pos < b.pos;
return c.nub > b.nub;
}
bool cmp2(node c, node b) { return c.pos < b.pos; }
int main() {
int n, m;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i].nub;
a[i].pos = i;
}
sort(a + 1, a + 1 + n, cmp);
ans[1][1] = a[1].nub;
for (int i = 2; i <= n; ++i) {
sort(a + 1, a + 1 + i, cmp2);
for (int j = 1; j <= i; ++j) {
ans[i][j] = a[j].nub;
}
}
cin >> m;
for (int i = 1; i <= m; ++i) {
int x, pos;
cin >> x >> pos;
cout << ans[x][pos] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace kotespace {
template <class T>
class duplet {
private:
public:
T x, y;
duplet(){};
duplet(T a, T b) : x(a), y(b){};
bool operator<(const duplet P) const {
return (x < P.x || (x == P.x && y < P.y));
}
bool operator>(const duplet P) const {
return (x > P.x || (x == P.x && y > P.y));
}
bool operator==(const duplet P) const { return (x == P.x && y == P.y); }
bool operator!=(const duplet P) const { return (x != P.x || y != P.y); }
void reverse() { std::swap(x, y); }
};
template <class P>
istream &operator>>(istream &in, duplet<P> &T) {
return (in >> T.x >> T.y);
}
template <class P>
ostream &operator<<(ostream &out, duplet<P> T) {
return (out << T.x << " " << T.y);
}
template <class T>
class triplet {
private:
public:
T x, y, z;
triplet(){};
triplet(T a, T b, T c) : x(a), y(b), z(c){};
bool operator<(const triplet P) const {
return (x < P.x || (x == P.x && y < P.y) ||
(x == P.x && y == P.y && z < P.z));
}
bool operator>(const triplet P) const {
return (x > P.x || (x == P.x && y > P.y) ||
(x == P.x && y == P.y && z > P.z));
}
bool operator==(const triplet P) const {
return (x == P.x && y == P.y && z == P.z);
}
bool operator!=(const triplet P) const {
return (x != P.x || y != P.y || z != P.z);
}
void reverse() { std::swap(x, z); }
void cycle_right(int a) {
if (a == 1) {
std::swap(x, y);
std::swap(x, z);
}
if (a == 2) {
std::swap(x, z);
std::swap(y, x);
}
}
void cycle_left(int a) {
if (a == 1) {
std::swap(x, z);
std::swap(y, x);
}
if (a == 2) {
std::swap(x, y);
std::swap(x, z);
}
}
};
template <class P>
istream &operator>>(istream &in, triplet<P> &T) {
return (in >> T.x >> T.y >> T.z);
}
template <class P>
ostream &operator<<(ostream &out, triplet<P> &T) {
return (out << T.x << " " << T.y << " " << T.z);
}
} // namespace kotespace
using namespace kotespace;
long long inf = 1000 * 1000 * 1000 + 5;
long long inf64 = inf * inf;
long long mod = 228228227;
vector<duplet<int> > a;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cerr << fixed << setprecision(10);
cout << fixed << setprecision(10);
srand(time(0));
float START_TIME = clock();
int n;
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].x;
a[i].x *= -1;
a[i].y = i;
}
sort(a.begin(), a.end());
int k;
cin >> k;
for (int i = 0; i < k; ++i) {
int x, y;
cin >> x >> y;
vector<duplet<int> > b;
for (int j = 0; j < x; ++j) {
b.emplace_back(a[j].y, -a[j].x);
}
sort(b.begin(), b.end());
cout << b[y - 1].y << endl;
}
cerr << endl << (clock() - START_TIME) / CLOCKS_PER_SEC << " sec." << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 2, mod = 1e9 + 7;
void solve() {
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(), [](pair<int, int> i, pair<int, int> j) {
if (i.first == j.first) return i.second < j.second;
return i.first > j.first;
});
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
vector<pair<int, int> > v(a.begin(), a.begin() + k);
sort(v.begin(), v.end(), [](pair<int, int> i, pair<int, int> j) {
return i.second < j.second;
});
cout << v[pos - 1].first << '\n';
}
}
int main() {
int tt = 1;
for (int tc = 1; tc <= tt; tc++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using ld = long double;
void solve();
bool comp(const pair<int64_t, int64_t> &a, const pair<int64_t, int64_t> &b) {
if (a.first != b.first) return (a.first < b.first);
return (a.second > b.second);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
solve();
return 0;
}
void solve() {
int64_t n;
cin >> n;
pair<int64_t, int64_t> a[n];
for (int64_t i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n, comp);
int64_t q;
cin >> q;
while (q--) {
int64_t x, y;
cin >> x >> y;
vector<pair<int64_t, int64_t>> v;
for (int64_t i = n - 1; i >= n - x; i--) {
v.push_back({a[i].second, a[i].first});
}
sort((v).begin(), (v).end());
cout << v[y - 1].second << endl;
}
}
|
#include <bits/stdc++.h>
bool choice_first(std::vector<size_t> a, std::vector<size_t> b) {
uint64_t sum_a, sum_b;
sum_a = sum_b = 0;
for (auto elem : a) {
sum_a += elem;
}
for (auto elem : b) {
sum_b += elem;
}
return sum_a > sum_b || (sum_a == sum_b && a < b);
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
size_t n, m;
std::cin >> n;
std::vector<std::vector<std::vector<size_t>>> dp(
n + 1, std::vector<std::vector<size_t>>(n + 1));
std::vector<size_t> a(n);
for (size_t i = 0; i < n; i++) {
std::cin >> a[i];
}
std::cin >> m;
for (size_t i = 0; i < n; i++) {
if (i == 0) {
dp[1][i] = {a[0]};
continue;
}
dp[1][i] = std::max(std::vector<size_t>{a[i]}, dp[1][i - 1]);
}
for (size_t i = 2; i <= n; i++) {
for (size_t j = i - 1; j < n; j++) {
if (j == i - 1) {
std::vector<size_t> cur = dp[i - 1][j - 1];
cur.push_back(a[j]);
dp[i][j] = cur;
continue;
}
std::vector<size_t> first, second;
first = dp[i - 1][j - 1];
first.push_back(a[j]);
second = dp[i][j - 1];
if (choice_first(first, second)) {
dp[i][j] = first;
} else {
dp[i][j] = second;
}
}
}
for (size_t i = 0; i < m; i++) {
size_t k, pos;
std::cin >> k >> pos;
std::cout << dp[k][n - 1][pos - 1] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Z = (int)3e3 + 228;
const int N = (int)3e5 + 228;
const int INF = (int)1e9 + 228;
const int MOD = (int)1e9 + 7;
int a[N];
map<int, int> cnt;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> b;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b.push_back(a[i]);
}
sort(b.rbegin(), b.rend());
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
multiset<int> mn;
map<int, int> q;
for (int i = 0; i < k; i++) mn.insert(b[i]), q[b[i]]++;
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (k == 0) break;
if (mn.find(a[i]) != mn.end()) {
if (a[i] == *mn.begin()) {
ans.push_back(a[i]);
q[a[i]]--;
mn.erase(mn.begin());
k--;
}
map<int, int> now;
for (int j = i + 1; j <= n; j++) now[a[j]]++;
bool f = true;
for (auto it : mn)
if (q[it] > now[it]) f = false;
if (f)
continue;
else {
ans.push_back(a[i]);
q[a[i]]--;
mn.erase(mn.find(a[i]));
k--;
}
}
}
cout << ans[pos - 1] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, arr[101], sr[101];
vector<int> dp[101];
multiset<int> s;
int main() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
sr[i] = arr[i];
}
sort(sr, sr + n, [](int a, int b) { return a > b; });
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < i; j++) {
s.insert(sr[j]);
}
for (long long j = 0; j < n; j++) {
if (s.count(arr[j])) {
dp[i].push_back(arr[j]);
s.erase(s.find(arr[j]));
}
}
}
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
cout << dp[a][b - 1] << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.