solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
void read(Tp &x) {
x = 0;
long long f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') {
f = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
x *= f;
}
long long n, m;
long long s[200005], a[200005];
long long st[200005 << 2], ps[200005 << 2], laz[200005 << 2];
void pushup(long long x) {
st[x] = min(st[(x << 1)], st[((x << 1) | 1)]);
if (st[x] == st[((x << 1) | 1)])
ps[x] = ps[((x << 1) | 1)];
else
ps[x] = ps[(x << 1)];
}
void build(long long x, long long l, long long r) {
if (l == r) {
st[x] = s[l];
ps[x] = l;
return;
}
build((x << 1), l, ((l + r) >> 1));
build(((x << 1) | 1), ((l + r) >> 1) + 1, r);
pushup(x);
}
void pushdown(long long x) {
if (laz[x]) {
laz[(x << 1)] += laz[x];
laz[((x << 1) | 1)] += laz[x];
st[(x << 1)] += laz[x];
st[((x << 1) | 1)] += laz[x];
laz[x] = 0;
}
}
void upd(long long x, long long l, long long r, long long L, long long R,
long long v) {
if (l > R || r < L) return;
if (l >= L && r <= R) {
st[x] += v;
laz[x] += v;
return;
}
pushdown(x);
upd((x << 1), l, ((l + r) >> 1), L, R, v);
upd(((x << 1) | 1), ((l + r) >> 1) + 1, r, L, R, v);
pushup(x);
}
signed main() {
read(n);
for (long long i = 1; i <= n; i++) read(s[i]);
build(1, 1, n);
long long pos;
for (long long i = 1; i <= n; i++) {
pos = ps[1];
a[pos] = i;
upd(1, 1, n, pos, pos, 0x3f3f3f3f3f3f3fll);
upd(1, 1, n, pos + 1, n, -i);
}
for (long long i = 1; i <= n; i++) printf("%I64d ", a[i]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long INF = 1e16 + 239;
const int MAXN = 1e6 + 239;
long long a[MAXN];
namespace SegmentTree {
int n;
long long t[4 * MAXN];
long long mod[4 * MAXN];
void pull(int v) { t[v] = min(t[2 * v + 1], t[2 * v + 2]); }
void apply(int v, long long val) {
t[v] += val;
mod[v] += val;
}
void push(int v) {
if (mod[v] != 0) {
apply(2 * v + 1, mod[v]);
apply(2 * v + 2, mod[v]);
mod[v] = 0;
}
}
void build(int v, int l, int r) {
if (l + 1 == r) {
t[v] = a[l];
} else {
int m = (r + l) >> 1;
build(2 * v + 1, l, m);
build(2 * v + 2, m, r);
pull(v);
}
}
void add(int v, int l, int r, int ql, int qr, long long val) {
if (r <= ql || qr <= l) {
return;
} else if (ql <= l && r <= qr) {
apply(v, val);
} else {
push(v);
int m = (r + l) >> 1;
add(2 * v + 1, l, m, ql, qr, val);
add(2 * v + 2, m, r, ql, qr, val);
pull(v);
}
}
int go_down(int v, int l, int r) {
if (l + 1 == r) {
return l;
} else {
push(v);
int m = (r + l) >> 1;
int res = -1;
if (t[2 * v + 2] == 0) {
res = go_down(2 * v + 2, m, r);
} else {
res = go_down(2 * v + 1, l, m);
}
pull(v);
return res;
}
}
void init(int n_) {
n = n_;
build(0, 0, n);
}
void add(int l, int r, long long val) { add(0, 0, n, l, r, val); }
void add(int pos, long long val) { add(0, 0, n, pos, pos + 1, val); }
int last_zero() { return go_down(0, 0, n); }
} // namespace SegmentTree
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
SegmentTree::init(n);
vector<int> ans(n, -1);
for (int i = 1; i <= n; i++) {
int pos = SegmentTree::last_zero();
ans[pos] = i;
SegmentTree::add(pos, INF);
SegmentTree::add(pos + 1, n, -i);
}
for (auto t : ans) {
cout << t << ' ';
}
cout << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, ar[200005], br[200005], up[800555], dr[100];
pair<long long, long long> tr[800555];
void build(long long, long long, long long),
update(long long, long long, long long, long long),
upd(long long, long long, long long, long long, long long, long long);
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> ar[i];
build(0, 0, n - 1);
long long pos;
for (int i = 1; i < n + 1; i++) {
pos = tr[0].second;
br[pos] = i;
if (pos + 1 < n) upd(0, 0, n - 1, pos + 1, n - 1, i);
update(0, 0, n - 1, pos);
}
for (int i = 0; i < n; i++) cout << br[i] << " ";
}
void build(long long idx, long long l, long long r) {
if (l == r) {
tr[idx].first = ar[l];
tr[idx].second = l;
return;
}
long long mid = (l + r) / 2;
build(2 * idx + 1, l, mid);
build(2 * idx + 2, mid + 1, r);
if (tr[2 * idx + 1].first < tr[2 * idx + 2].first)
tr[idx] = tr[2 * idx + 1];
else
tr[idx] = tr[2 * idx + 2];
}
void update(long long idx, long long l, long long r, long long pos) {
if (up[idx]) {
tr[idx].first -= up[idx];
if (l != r) {
up[2 * idx + 1] += up[idx];
up[2 * idx + 2] += up[idx];
}
up[idx] = 0;
}
if (pos < l || pos > r) return;
if (l == r) {
tr[idx].first = 12345678123456ll;
return;
}
long long mid = (l + r) / 2;
update(2 * idx + 1, l, mid, pos);
update(2 * idx + 2, mid + 1, r, pos);
if (tr[2 * idx + 1].first < tr[2 * idx + 2].first)
tr[idx] = tr[2 * idx + 1];
else
tr[idx] = tr[2 * idx + 2];
}
void upd(long long idx, long long l, long long r, long long low, long long high,
long long val) {
if (up[idx]) {
tr[idx].first -= up[idx];
if (l != r) {
up[2 * idx + 1] += up[idx];
up[2 * idx + 2] += up[idx];
}
up[idx] = 0;
}
if (high < l || low > r) {
return;
}
if (low <= l && r <= high) {
tr[idx].first -= val;
if (l != r) {
up[2 * idx + 1] += val;
up[2 * idx + 2] += val;
}
return;
}
long long mid = (l + r) / 2;
upd(2 * idx + 1, l, mid, low, high, val);
upd(2 * idx + 2, mid + 1, r, low, high, val);
if (tr[2 * idx + 1].first < tr[2 * idx + 2].first)
tr[idx] = tr[2 * idx + 1];
else
tr[idx] = tr[2 * idx + 2];
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long bit[200005];
void add(long long idx, long long val) {
for (int i = idx; i < 200005; i += (i & (-i))) {
bit[i] += val;
}
}
long long query(long long i) {
long long ans = 0;
for (; i > 0; i -= (i & (-i))) ans += bit[i];
return ans;
}
long long b[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, i, j, k, m;
cin >> n;
long long a[n];
for (i = 0; i < n; i++) cin >> a[i];
set<long long> s, s1;
unordered_map<long long, long long> mp;
long long sm = 0;
long long sum[n + 5];
for (i = 1; i <= n; i++) {
sm += i;
mp[sm] = i;
s.insert(i);
s1.insert(sm);
sum[i] = sm;
}
for (i = 1; i <= n; i++) {
add(i, i);
}
for (i = n - 1; i >= 0; i--) {
long long f = 1, l = n;
long long mid;
long long anss = 0;
while (f <= l) {
mid = (f + l) / 2;
if (query(mid) > a[i]) {
l = mid - 1;
} else {
f = mid + 1;
anss = mid;
}
}
anss++;
b[i] = anss;
add(anss, -anss);
}
for (i = 0; i < n; i++) cout << b[i] << " ";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MM = 10000000000000001;
int n;
long long a[200005];
int rs[200005];
long long lazy[4 * 200005];
pair<long long, int> it[4 * 200005];
pair<long long, int> minp(pair<long long, int> A, pair<long long, int> B) {
if (A.first < B.first) return A;
if (A.first > B.first) return B;
if (A.second > B.second) return A;
return B;
}
void build(int x, int l, int r) {
if (l == r) {
it[x] = make_pair(a[l], l);
return;
}
int mid = (l + r) / 2;
build(2 * x, l, mid);
build(2 * x + 1, mid + 1, r);
it[x] = minp(it[2 * x], it[2 * x + 1]);
}
void lazy_upd(int x, int l, int r) {
it[x].first += lazy[x];
if (l != r) {
lazy[2 * x] += lazy[x];
lazy[2 * x + 1] += lazy[x];
}
lazy[x] = 0;
}
void update(int x, int l, int r, int u, int v, long long val) {
lazy_upd(x, l, r);
if ((r < u) || (v < l)) return;
if ((u <= l) && (r <= v)) {
lazy[x] += val;
lazy_upd(x, l, r);
return;
}
int mid = (l + r) / 2;
update(2 * x, l, mid, u, v, val);
update(2 * x + 1, mid + 1, r, u, v, val);
it[x] = minp(it[2 * x], it[2 * x + 1]);
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
for (int i = 1; i <= n; i++) {
pair<long long, int> p = it[1];
int id = p.second;
rs[id] = i;
update(1, 1, n, id, id, MM);
update(1, 1, n, id + 1, n, -i);
}
for (int i = 1; i <= n; i++) cout << rs[i] << ' ';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
long long s[200066];
long long c[200066];
long long ans[200066];
long long lowbit(long long x) { return x & (-x); }
long long q(long long x) {
long long ans = 0;
while (x > 0) {
ans += c[x];
x -= lowbit(x);
}
return ans;
}
void update(long long x, long long v) {
while (x <= n) {
c[x] += v;
x += lowbit(x);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
update(i, i);
}
for (int i = n; i >= 1; i--) {
long long l = 1;
long long r = n;
long long mid;
while (l < r) {
mid = (l + r + 1) / 2;
if (q(mid - 1) <= s[i]) {
l = mid;
} else
r = mid - 1;
}
ans[i] = l;
update(l, -l);
}
for (int i = 1; i <= n; i++) {
if (i != n)
cout << ans[i] << " ";
else
cout << ans[i] << endl;
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)2E5;
long long arr[MAXN + 1];
long long sum[MAXN + 1];
long long bit[MAXN + 1];
int ans[MAXN + 1];
long long query(int x) {
long long ans = 0;
while (x > 0) {
ans += bit[x];
x -= x & -x;
}
return ans;
}
void increment(int x, int amt, int n) {
while (x <= n) {
bit[x] += amt;
x += x & -x;
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + i;
}
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = n; i >= 1; i--) {
int temp = 1;
for (int jump = n / 2 + 1; jump > 0; jump /= 2) {
while (temp + jump <= n &&
sum[temp + jump - 1] - query(temp + jump - 1) <= arr[i])
temp += jump;
}
ans[i] = temp;
increment(temp, temp, n);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005;
vector<int> v;
long long n, a[MX], w[MX], tree[MX * 4 + 5];
long long con(int num, int nodeL, int nodeR) {
if (nodeL == nodeR) return tree[num] = w[nodeL];
long long mid = (nodeL + nodeR) / 2;
return tree[num] =
con(num * 2, nodeL, mid) + con(num * 2 + 1, mid + 1, nodeR);
}
long long sum(int L, int R, int num, int nodeL, int nodeR) {
if (nodeR < L || nodeL > R) return 0;
if (nodeL >= L && nodeR <= R) return tree[num];
int mid = (nodeL + nodeR) / 2;
return sum(L, R, num * 2, nodeL, mid) +
sum(L, R, num * 2 + 1, mid + 1, nodeR);
}
long long upd(int idx, int num, int nodeL, int nodeR) {
if (nodeL > idx || nodeR < idx) return 0;
if (nodeL == nodeR) return tree[num] = 0;
int mid = (nodeL + nodeR) / 2;
upd(idx, num * 2, nodeL, mid);
upd(idx, num * 2 + 1, mid + 1, nodeR);
if (nodeL <= idx && nodeR >= idx) {
tree[num] = tree[num * 2] + tree[num * 2 + 1];
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
w[i] = i + 1;
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
con(1, 0, n - 1);
for (int i = n - 1; i >= 0; i--) {
int s = 0, e = n - 1;
while (s <= e) {
int m = (s + e) / 2;
long long u = sum(0, m, 1, 0, n - 1);
if (u <= a[i]) {
s = m + 1;
} else {
e = m - 1;
}
}
v.push_back(s + 1);
upd(s, 1, 0, n - 1);
}
for (int i = v.size() - 1; i >= 0; i--) {
cout << v[i] << " ";
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 200010;
struct BIT {
long long tree[M];
BIT() { memset(tree, 0, sizeof tree); }
void update(int idx, int val) {
while (idx < M) {
tree[idx] += val;
idx += idx & (-idx);
}
}
long long query(int idx) {
long long sum = 0;
while (idx > 0) {
sum += tree[idx];
idx -= idx & (-idx);
}
return sum;
}
};
long long a[200010];
BIT B;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long long sum = 0;
for (int i = 1; i <= n; i++) {
B.update(i, i);
}
vector<int> ans;
for (int i = n - 1; i >= 0; i--) {
int l = 1, h = n;
while (l < h) {
int m = (l + h) / 2;
if (B.query(m) > a[i])
h = m;
else
l = m + 1;
}
ans.push_back(h);
B.update(h, -h);
}
for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 200222;
const long long inf = 1000111222000111222LL;
struct tree {
long long mx[4 * max_n], add[4 * max_n];
tree() {
memset(mx, 0, sizeof(mx));
memset(add, 0, sizeof(add));
}
void push(int v) {
if (add[v]) {
mx[2 * v] += add[v];
mx[2 * v + 1] += add[v];
add[2 * v] += add[v];
add[2 * v + 1] += add[v];
add[v] = 0;
}
}
void update(int v, int tl, int tr, int l, int r, long long x) {
if (tl == l && tr == r) {
add[v] += x;
mx[v] += x;
return;
}
push(v);
int mid = (tl + tr) / 2;
if (r <= mid) {
update(2 * v, tl, mid, l, r, x);
} else if (l > mid) {
update(2 * v + 1, mid + 1, tr, l, r, x);
} else {
update(2 * v, tl, mid, l, mid, x);
update(2 * v + 1, mid + 1, tr, mid + 1, r, x);
}
mx[v] = max(mx[2 * v], mx[2 * v + 1]);
}
int get_more(int v, int l, int r, long long x) {
if (l == r) {
return l;
}
push(v);
int mid = (l + r) / 2;
if (mx[2 * v] >= x) {
return get_more(2 * v, l, mid, x);
}
return get_more(2 * v + 1, mid + 1, r, x);
}
};
int n, ans[max_n];
long long s[max_n];
tree t;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%I64d", &s[i]);
}
for (int i = 1; i < n; ++i) {
t.update(1, 1, n, i + 1, n, i);
}
for (int i = n - 1; i >= 0; --i) {
ans[i] = t.get_more(1, 1, n, s[i]);
t.update(1, 1, n, ans[i], ans[i], -inf);
if (ans[i] + 1 < n) {
t.update(1, 1, n, ans[i] + 1, n, -ans[i]);
}
}
for (int i = 0; i < n; ++i) {
printf("%d ", ans[i]);
}
puts("");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const int inf = INT_MAX;
const int MAX = 3e6 + 9;
const long long MOD = 1e9 + 7;
const int TOT_PRIMES = 1e6 + 9;
const int MAX_A = 71;
const int LN = 20;
using namespace std;
long long bt[MAX];
long long arr[MAX];
void update(int x, long long val) {
for (int i = x; i < MAX; i += i & -i) bt[i] += val;
}
long long query(int x) {
long long res = 0;
for (int i = x; i > 0; i -= i & -i) res = res + bt[i];
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= n; i++) update(i, i);
int ans[n + 1];
for (int i = n; i >= 1; i--) {
int l = 0, r = n;
while (l <= r) {
int mid = (l + r) / 2;
if (query(mid) > arr[i])
r = mid - 1;
else
l = mid + 1;
}
ans[i] = l;
update(l, -l);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
inline ll read();
const int M = 500016, MOD = 1000000007;
struct BinaryIndexTree {
ll bit[M], n;
inline void modify(ll p, ll x) {
for (; p <= n; p += p & -p) bit[p] += x;
}
inline ll sum(ll p) {
ll res = 0;
for (; p; p -= p & -p) res += bit[p];
return res;
}
inline ll sum(ll l, ll r) { return sum(r) - sum(l - 1); }
} bit;
ll s[M], save[M], vis[M];
int cal(ll s, int n) {
ll lef = 1, rig = n;
while (lef <= rig) {
ll mid = (lef + rig) >> 1;
ll val = mid * (mid - 1) / 2 - bit.sum(mid - 1);
if (val == s && !vis[mid])
return mid;
else if (val <= s)
lef = mid + 1;
else
rig = mid - 1;
}
assert(0);
return -1;
}
int main(void) {
int n = read();
bit.n = n;
for (int i = 1; i <= n; ++i) s[i] = read();
for (int i = n; i >= 1; --i) {
save[i] = cal(s[i], n);
bit.modify(save[i], save[i]);
vis[save[i]] = 1;
}
for (int i = 1; i <= n; ++i) cout << save[i] << " ";
cout << endl;
return 0;
}
inline ll read() {
ll x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
| 10 | CPP |
# 1208D
class segTree():
def __init__(self, n):
self.t = [0] * (n << 2)
def update(self, node, l, r, index, value):
if l == r:
self.t[node] = value
return
mid = (l + r) >> 1
if index <= mid:
self.update(node*2, l, mid, index, value)
else:
self.update(node*2 + 1, mid + 1, r, index, value)
self.t[node] = self.t[node*2] + self.t[node*2 + 1]
def query(self, node, l, r, value):
if l == r:
return self.t[node]
mid = (l + r) >> 1
if self.t[node*2] >= value:
return self.query(node*2, l, mid, value)
return self.query(node*2 + 1, mid + 1, r, value - self.t[node*2])
def do():
n = int(input())
nums = [int(i) for i in input().split(" ")]
res = [0]*n
weightTree = segTree(n)
for i in range(1, n+1):
weightTree.update(1, 1, n, i, i)
# print(weightTree.t)
for i in range(n-1, -1, -1):
res[i] = weightTree.query(1, 1, n, nums[i] + 1)
weightTree.update(1, 1, n, res[i], 0)
return " ".join([str(c) for c in res])
print(do())
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793;
const long long I_MAX = 1LL << 60;
long long mod = 1000000007;
const long long maxN = 2E5;
vector<long long> inv(maxN + 5, 1);
vector<long long> fac(maxN + 5, 1);
void ADD(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
}
void MUL(long long &x, long long y) {
x *= y;
x = (x % mod + mod) % mod;
}
long long mypow(long long b, long long e) {
long long ans = 1;
while (e) {
if (e & 1) MUL(ans, b);
MUL(b, b);
e >>= 1;
}
return ans;
}
long long modinv(long long n) { return mypow(n, mod - 2); }
void calcInv(long long n) {
for (int i = 2; i <= n; ++i) {
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
}
}
void calcFac(long long n) {
for (int i = 2; i <= n; ++i) {
fac[i] = fac[i - 1] * i % mod;
}
}
long long cm(long long a, long long b) {
long long ans = 1;
if (a < b) return 0;
MUL(ans, inv[fac[a - b]]);
MUL(ans, inv[fac[b]]);
MUL(ans, fac[a]);
return ans;
}
long long Lucas(long long n, long long m) {
if (m == 0) return 1;
return cm(n % mod, m % mod) * Lucas(n / mod, m / mod) % mod;
}
long long doLucas(long long n, long long m) {
calcInv(mod);
calcFac(mod);
return Lucas(n, m);
}
const long long maxn = 2E5 + 5;
long long arr[maxn + 1];
int lowbit(int x) { return x & (-x); }
void change(int x, long long add, int size) {
for (int i = x; i <= size; i += lowbit(i)) {
arr[i] += add;
}
}
long long query(int x, int size) {
long long ret = 0;
for (int i = x; i > 0; i -= lowbit(i)) {
ret += arr[i];
}
return ret;
}
void solve() {
long long n;
cin >> n;
bool used[n + 1];
for (int i = 0; i <= n; ++i) used[i] = false;
vector<long long> num(n), res(n, 0);
for (int i = 0; i < n; ++i) {
cin >> num[i];
}
for (int i = 1; i <= n; ++i) {
change(i, i - 1, n);
}
for (int i = n - 1; i >= 1; --i) {
int lo = 1, hi = n, mi;
while (lo < hi) {
mi = (lo + hi) >> 1;
long long tmp = query(mi, n);
if (tmp < num[i]) {
lo = mi + 1;
} else if (tmp == num[i] and used[mi]) {
lo = mi + 1;
} else {
hi = mi;
}
}
change(lo + 1, -lo, n);
used[lo] = true;
res[i] = lo;
}
for (int i = 1; i <= n; ++i) {
if (!used[i]) {
res[0] = i;
break;
}
}
for (int i = 0; i < n; ++i) {
cout << res[i] << ' ';
}
cout << '\n';
}
int main() {
int t = 1;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
| 10 | CPP |
import sys
input=sys.stdin.readline
n=int(input())
s=list(map(int,input().split()))
BIT=[0]*(n+1)
def update(i,w):
while i<=n:
BIT[i]+=w
i+=(i&-i)
def get_sum(i):
res=0
while i>0:
res+=BIT[i]
i-=(i&-i)
return res
for i in range(1,n+1):
update(i,i)
ans=[-1]*n
for i in range(n)[::-1]:
l=0;r=n
ss=s[i]
while True:
mid=(l+r+1)//2
if get_sum(mid)>ss:
if get_sum(mid-1)==ss:
ans[i]=mid
break
else:
r=mid
else:
l=mid
update(mid,-mid)
print(*ans) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long ar[200005];
long long tree[800005];
long long valr[800005];
long long lazy[800005];
long long ans[200005];
int gl = 0;
long long h;
void build(int node, int start, int end) {
if (start == end) {
tree[node] = ar[start];
valr[node] = start;
} else {
int mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
tree[node] = min(tree[node * 2], tree[node * 2 + 1]);
if (tree[node * 2 + 1] == tree[node])
valr[node] = valr[node * 2 + 1];
else
valr[node] = valr[node * 2];
}
}
void updateRange(int node, long long start, long long end, int l, long long r,
long long val) {
if (lazy[node] != 0) {
tree[node] -= lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start > end or start > r or end < l) return;
if (start >= l and end <= r) {
tree[node] -= val;
if (start != end) {
lazy[node * 2] += val;
lazy[node * 2 + 1] += val;
}
if (start == end && gl) {
valr[node] = h;
}
lazy[node] = 0;
return;
}
int mid = (start + end) / 2;
updateRange(node * 2, start, mid, l, r, val);
updateRange(node * 2 + 1, mid + 1, end, l, r, val);
tree[node] = min(tree[node * 2], tree[node * 2 + 1]);
if (tree[node * 2 + 1] == tree[node])
valr[node] = valr[node * 2 + 1];
else
valr[node] = valr[node * 2];
}
pair<long long, long long> queryRange(int node, int start, int end, int l,
int r) {
if (start > end or start > r or end < l) return {10004000000, -1};
if (lazy[node] != 0) {
tree[node] -= lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start >= l and end <= r) return {tree[node], valr[node]};
int mid = (start + end) / 2;
pair<int, int> p1 = queryRange(node * 2, start, mid, l, r);
pair<int, int> p2 = queryRange(node * 2 + 1, mid + 1, end, l, r);
if (p2.first <= p1.first) return p2;
return p1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> ar[i];
gl = 1;
build(1, 0, n - 1);
gl = 0;
for (int i = 0; i < n; i++) {
pair<long long, long long> h = queryRange(1, 0, n - 1, 0, n - 1);
ans[h.second] = i + 1;
updateRange(1, 0, n - 1, h.second + 1, n - 1, i + 1);
updateRange(1, 0, n - 1, h.second, h.second, -200000000000);
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
return 0;
}
| 10 | CPP |
#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 = 1, r = n + 1, mid;
ll tmp;
while (r - l > 1) {
mid = (l + r) / 2;
if (mid == 0)
tmp = 0;
else
tmp = query(1, 1, n, 1, mid - 1);
if (tmp <= s[i]) {
l = mid;
} else
r = mid;
}
p[i] = l;
update(1, 1, n, l, 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();
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> t[4 * 200009];
long long a[200009], lazy[4 * 200009], ans[200009];
void build(long long v, long long tl, long long tr) {
if (tl == tr) {
t[v] = {a[tl], tl};
} else {
long long tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm + 1, tr);
if (t[v * 2].first < t[v * 2 + 1].first ||
(t[v * 2].first == t[v * 2 + 1].first &&
t[v * 2].second > t[v * 2 + 1].second))
t[v] = t[v * 2];
else
t[v] = t[v * 2 + 1];
}
}
void push(long long v) {
t[v * 2].first += lazy[v];
lazy[v * 2] += lazy[v];
t[v * 2 + 1].first += lazy[v];
lazy[v * 2 + 1] += lazy[v];
lazy[v] = 0;
}
void update(long long v, long long tl, long long tr, long long l, long long r,
long long addend) {
if (l > r) return;
if (l == tl && tr == r) {
t[v].first += addend;
lazy[v] += addend;
} else {
push(v);
long long tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm), addend);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, addend);
if (t[v * 2].first < t[v * 2 + 1].first ||
(t[v * 2].first == t[v * 2 + 1].first &&
t[v * 2].second > t[v * 2 + 1].second))
t[v] = t[v * 2];
else
t[v] = t[v * 2 + 1];
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long i = 1;
while (i <= n) cin >> a[i++];
build(1, 1, n);
i = 1;
long long x;
while (i <= n) {
x = t[1].second;
ans[x] = i;
update(1, 1, n, x + 1, n, -i);
update(1, 1, n, x, x, 1e13);
i++;
}
i = 1;
while (i <= n) {
cout << ans[i] << " ";
i++;
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long good_rand() { return rand() * RAND_MAX + rand(); }
template <class A>
class myvector : public std::vector<A> {
public:
A &operator[](int pos) {
if (pos < 0) pos = 0;
while (this->size() <= pos) {
this->push_back({});
}
return std::vector<A>::operator[](pos);
}
void print(bool b = false) {
unsigned int si = this->size();
if (b) std::cout << si << std::endl;
for (unsigned int i = 0; i < si; ++i) {
std::cout << this->operator[](i) << " ";
}
}
void printendl(bool b = false) {
print(b);
std::cout << std::endl;
}
void good_random_shuffle() {
unsigned int si = this->size();
for (unsigned int i = 0; i < si - 1; ++i) {
unsigned int j = good_rand() % (si - i);
j += i;
swap(this->operator[](i), this->operator[](j));
}
}
template <class B>
void read(B &n, bool b = false) {
if (b) std::cin >> n;
for (int i = 0; i < n; ++i) {
std::cin >> this->operator[](i);
}
}
};
template <class A, class B = std::less<typename std::vector<A>::value_type> >
class mypriority_queue : public std::priority_queue<A, std::vector<A>, B> {
public:
A top() const {
if (this->empty()) return {};
return std::priority_queue<A, std::vector<A>, B>::top();
}
void pop() {
if (this->empty()) return;
std::priority_queue<A, std::vector<A>, B>::pop();
}
A take() {
A a = this->top();
this->pop();
return a;
}
void print(bool b = false) const {
while (!this->empty()) {
std::cout << take() << " ";
}
}
void printendl(bool b = false) const {
print(b);
std::cout << std::endl;
}
};
class modll {
static const long long mod = 1000000007;
long long modvalue = 0;
public:
modll() { this->modvalue = 0; }
modll(int x) { this->modvalue = x % mod; }
modll(long long x) { this->modvalue = x % mod; }
modll(const modll &x) { this->modvalue = x.modvalue; }
long long getmodvalue() const { return modvalue; }
static long long modpow(long long z, long long u) {
if (u == 0) return 1;
if (u == 1) return z;
if (u % 2 == 0) {
long long sa = modpow(z, u / 2);
return (sa * sa) % mod;
}
return (z * modpow(z, u - 1)) % mod;
}
static modll fastpow(long long z, long long u) {
modll a = modpow(z, u);
return a;
}
static modll fact(long long z) {
modll a = 1;
for (long long i = 2; i <= z; ++i) {
a *= i;
}
return a;
}
static modll choose(long long n, long long k) {
modll a = 1;
if (k > n / 2) return choose(n, n - k);
for (long long i = n; n - i + 1 <= k; --i) {
a *= i;
}
for (long long i = 2; i <= k; ++i) {
a /= i;
}
return a;
}
long long rec() const { return modll::modpow(modvalue, mod - 2); }
modll operator+(const modll &x) const {
modll a;
a.modvalue = (this->modvalue + x.modvalue) % mod;
return a;
}
modll operator-(const modll &x) const {
modll a;
a.modvalue = (mod + this->modvalue - x.modvalue) % mod;
return a;
}
modll operator*(const modll &x) const {
modll a;
a.modvalue = (this->modvalue * x.modvalue) % mod;
return a;
}
modll operator/(const modll &x) const {
modll a;
if (x.modvalue == 0) return a;
a.modvalue = (this->modvalue * x.rec()) % mod;
return a;
}
template <class A>
modll operator+(A x) const {
if (x < 0) return this->operator-(-x);
modll a;
a.modvalue = (this->modvalue + x % mod) % mod;
return a;
}
template <class A>
modll operator-(A x) const {
if (x < 0) return this->operator+(-x);
modll a;
a.modvalue = (this->modvalue - (x % mod) + mod) % mod;
return a;
}
template <class A>
modll operator*(A x) const {
if (x < 0) {
long long y = x / mod;
y *= mod;
y = x - y;
x = y;
}
x %= mod;
modll a;
a.modvalue = (this->modvalue * x) % mod;
return a;
}
template <class A>
modll operator/(A x) const {
if (x < 0) {
long long y = x / mod;
y *= mod;
y = x - y;
x = y;
}
x %= mod;
modll a;
if (x == 0) return a;
modll b = x;
a = *this / b;
return a;
}
void operator=(modll x) { this->modvalue = x.modvalue; }
template <class A>
void operator=(A x) {
this->modvalue = x % mod;
}
bool operator==(modll x) const { return (this->modvalue == x.modvalue); }
template <class A>
bool operator==(A x) const {
return (this->modvalue == x);
}
bool operator<(modll x) const { return (this->modvalue < x.modvalue); }
template <class A>
bool operator<(A x) const {
return (this->modvalue < x);
}
bool operator>(modll x) const { return (this->modvalue > x.modvalue); }
template <class A>
bool operator>(A x) {
return (this->modvalue > x);
}
bool operator<=(modll x) const { return (this->modvalue <= x.modvalue); }
template <class A>
bool operator<=(A x) const {
return (this->modvalue <= x);
}
bool operator>=(modll x) const { return (this->modvalue >= x.modvalue); }
template <class A>
bool operator>=(A x) const {
return (this->modvalue >= x);
}
void operator+=(const modll &x) {
this->modvalue += x.modvalue;
this->modvalue %= mod;
}
template <class A>
void operator+=(A x) {
if (x < 0) this->operator+=(-1 * x);
this->modvalue += x % mod;
if (modvalue < 0) {
this->modvalue *= -1;
if (modvalue % mod == 0)
modvalue = 0;
else
modvalue = mod - (modvalue % mod);
}
this->modvalue %= mod;
}
void operator-=(const modll &x) {
this->modvalue -= x.modvalue;
while (this->modvalue < 0) this->modvalue += mod;
this->modvalue %= mod;
}
template <class A>
void operator-=(A x) {
if (x < 0) this->operator+=(-1 * x);
this->modvalue -= x % mod;
if (modvalue < 0) {
this->modvalue *= -1;
if (modvalue % mod == 0)
modvalue = 0;
else
modvalue = mod - (modvalue % mod);
}
this->modvalue %= mod;
}
void operator*=(const modll &x) {
this->modvalue *= x.modvalue;
this->modvalue %= mod;
}
template <class A>
void operator*=(A x) {
bool neg = false;
if (x < 0) {
neg = true;
x *= -1;
}
this->modvalue *= x % mod;
if (modvalue < 0) {
this->modvalue *= -1;
if (modvalue % mod == 0)
modvalue = 0;
else
modvalue = mod - (modvalue % mod);
}
this->modvalue %= mod;
if (neg) {
this->modvalue = mod - modvalue;
this->modvalue %= mod;
}
}
void operator/=(const modll &x) {
if (x.modvalue == 0) {
this->modvalue = 0;
return;
}
this->modvalue = this->modvalue / x.modvalue;
this->modvalue %= mod;
}
template <class A>
void operator/=(A x) {
bool neg = false;
if (x < 0) {
neg = true;
x *= -1;
}
modll se = x % mod;
this->operator/=(se);
if (modvalue < 0) {
this->modvalue *= -1;
if (modvalue % mod == 0)
modvalue = 0;
else
modvalue = mod - (modvalue % mod);
}
this->modvalue %= mod;
if (neg) {
this->modvalue = mod - modvalue;
this->modvalue %= mod;
}
}
modll operator++() {
modvalue++;
if (modvalue == mod) modvalue = 0;
}
modll operator--() {
modvalue--;
if (modvalue < 0) modvalue += mod;
}
void print() const { std::cout << this->modvalue; }
void printspace() const { std::cout << this->modvalue << " "; }
void printendl() const { std::cout << this->modvalue << std::endl; }
};
set<long long> pos;
set<long long> t;
myvector<long long> v;
myvector<long long> w;
long long n, m, k, l, r, x, y;
mypriority_queue<long long> pq;
const long long N = 200005;
long long a[2 * N];
long long b[2 * N];
long long c[2 * N];
long long from[2 * N];
long long to[2 * N];
long long childa(long long z) { return (z * 2) + 1; }
long long childb(long long z) { return (z * 2) + 2; }
long long parent(long long z) {
if (z == 0) return -1;
return (z - 1) / 2;
}
void update(long long u) {
if (u < 0) return;
if (childa(u) < 2 * m - 1)
b[u] = (b[childa(u)] + c[childa(u)] + b[childb(u)] + c[childb(u)]);
else
b[u] = a[m - 1];
if (u != 0) update(parent(u));
}
void add(long long l, long long r, long long z, long long u) {
if (from[u] == l && to[u] == r) {
c[u] += z;
update(u);
} else {
if (to[childa(u)] >= l) {
add(l, min(r, to[childa(u)]), z, childa(u));
}
if (from[childb(u)] <= r) {
add(max(l, from[childb(u)]), r, z, childb(u));
}
}
}
long long getvalue(long long l, long long r, long long u) {
long long sa = 0;
long long sb = 0;
if (from[u] == l && to[u] == r) {
return c[u] + b[u];
}
if (to[childa(u)] >= l) {
sa = getvalue(l, min(r, to[childa(u)]), childa(u));
}
if (from[childb(u)] <= r) {
sb = getvalue(max(l, from[childb(u)]), r, childb(u));
}
return c[u] + sa + sb;
}
const int SIZE = 400005;
long long A[SIZE];
long long sum(long long i) {
long long sum = 0;
while (i > 0) sum += A[i], i -= ((i) & -(i));
return sum;
}
void add(long long i, long long k) {
while (i < SIZE) A[i] += k, i += ((i) & -(i));
}
int main() {
std::ios_base::sync_with_stdio(false);
v.read(n, true);
w[n - 1] = 0;
for (int i = 1; i <= n; ++i) add(i, i);
for (int i = 1; i <= n; ++i) t.insert(i);
for (int i = n - 1; i >= 0; --i) {
long long small = 0;
long long big = n;
while (small != big) {
int mid = small + big;
mid /= 2;
if (sum(mid) < v[i])
small = mid + 1;
else
big = mid;
}
x = *t.upper_bound(small);
add(x, -x);
t.erase(x);
w[i] = x;
}
w.print(false);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long s[200005], p[200005];
long long t[200005];
long long lowbit(long long x) {
return x & (-x);
if (14209 > 9243) {
if (31558 > 31075) {
bool ZENBDJUSHQ;
ZENBDJUSHQ = 28821;
if (21853 > 13000) {
if (11380 > 20609) {
int TNKUVWEIHB;
int UJWVDIONEM;
}
if (5029 > 1837) {
long long OZJTULNDAW;
short YUTAUSEEWT;
short YXRPTHHAJU;
}
if (2054 > 19771) {
bool WLDOHJWIET;
int VWGFIBINCA;
}
}
}
}
}
void Add(long long x, long long v) {
for (long long i = x; i <= n; i += lowbit(i)) t[i] += v;
double ARKMGILIPN;
return;
bool GDFJDYLEIO;
GDFJDYLEIO = 10065;
}
long long Sum(long long x) {
long long sum = 0;
double UQDXFBTCAN;
for (long long i = x; i >= 1; i -= lowbit(i)) sum += t[i];
if (18949 > 18458) {
if (14374 > 21712) {
int WCHPQHSLWV;
WCHPQHSLWV = 2964;
if (WCHPQHSLWV) {
short ZXHACSVHHM;
if (18954 > 31325) {
bool FMPKHFGCRD;
long long YJBZSHKCBM;
long long ZEDQQFWOJD;
}
double JLHPFGBHZG;
}
long long ONYRGSYOVI;
ONYRGSYOVI = 31043;
double PYNDFOTLPO;
}
if (9140 > 25442) {
if (27549 > 330) {
if (11689 > 10410) {
bool EIDMTSXEVP;
long long VDGUHIGORW;
short LVGBKIEMWO;
}
long long GOCRHCMVKN;
GOCRHCMVKN = 18506;
}
if (3433 > 18363) {
if (9590 > 3934) {
double ADAWDPHVWQ;
int ZZFLJENXXA;
int YVKXBGKFAW;
int YENRQKDEMC;
}
if (24567 > 699) {
bool JKTZQVQNVI;
short KDYQAMAEXV;
}
}
bool FZXPWJHKLT;
}
}
return sum;
bool LXXTNIQSIQ;
LXXTNIQSIQ = 16503;
if (LXXTNIQSIQ) {
bool SGABGODWLS;
SGABGODWLS = 3660;
if (SGABGODWLS) {
double EKGJBRZCHE;
EKGJBRZCHE = 21905;
short GHUHPBLOLN;
GHUHPBLOLN = 19589;
}
if (905 > 23769) {
double BZEOTAPENM;
short ADIXHUIDFN;
}
if (6283 > 12100) {
long long TLCVCFZOPS;
}
}
}
long long find(long long x) {
long long l = 1, r = n, best = 0;
short NSUMYJFLQG;
NSUMYJFLQG = 8388;
if (NSUMYJFLQG) {
double LAMCGVSZJZ;
LAMCGVSZJZ = 8066;
if (LAMCGVSZJZ) {
long long PHXVHXWSMU;
PHXVHXWSMU = 19588;
if (PHXVHXWSMU) {
int FTXDMLNTIJ;
FTXDMLNTIJ = 20885;
if (FTXDMLNTIJ) {
short ZYKWENLPEM;
double MJAKMQZDHK;
}
short PKIDBRUHHW;
PKIDBRUHHW = 2614;
if (PKIDBRUHHW) {
short PVKKZCKHBO;
}
if (13597 > 29011) {
short ZYYRZRACEQ;
}
if (30081 > 3983) {
short NLQVBZSSLC;
short PPWPECFVVD;
}
}
}
bool PPFAIENCTH;
PPFAIENCTH = 12546;
}
while (l <= r) {
long long mid = (l + r) / 2;
if (19539 > 25798) {
double WKPBFCJGGF;
int JAISCSLFHH;
JAISCSLFHH = 7526;
if (JAISCSLFHH) {
short GXNFUDMIED;
GXNFUDMIED = 30340;
if (GXNFUDMIED) {
bool PHHVBBDNXT;
double ZYRWVCKZNG;
}
if (9243 > 16638) {
long long UVAYWQMWJE;
}
bool UYQTSPIOBQ;
UYQTSPIOBQ = 9384;
}
if (18654 > 8057) {
short GJMTBVKSNW;
GJMTBVKSNW = 26968;
if (GJMTBVKSNW) {
int MKFLTHYAHJ;
int YTTWCIDRLC;
}
}
if (26324 > 9562) {
long long HLHVJACVDE;
HLHVJACVDE = 532;
}
double KEACFCSIPN;
KEACFCSIPN = 8567;
}
if (Sum(mid) <= x)
best = mid, l = mid + 1;
else
r = mid - 1;
bool VXIMTSMKZH;
VXIMTSMKZH = 4146;
}
return best;
if (27270 > 30192) {
double FYQYPYIZBE;
FYQYPYIZBE = 13300;
if (FYQYPYIZBE) {
int BUAQUSLGGX;
BUAQUSLGGX = 25559;
}
long long VUTCCPUHGI;
VUTCCPUHGI = 19065;
if (VUTCCPUHGI) {
if (14907 > 12825) {
bool ZVGIJBPWBI;
ZVGIJBPWBI = 28220;
if (ZVGIJBPWBI) {
long long GOUDEVPCUS;
}
if (2301 > 28031) {
bool GBGHNTABIY;
bool NYOFNYFHZY;
}
if (5470 > 25957) {
double DDHWUDBHBQ;
double XWKBQIMRVB;
bool LGDBSVJAUQ;
}
bool TKHDXSCCZT;
TKHDXSCCZT = 629;
if (TKHDXSCCZT) {
long long DUOXDVKMWC;
double DQRMRUGRBX;
int KBVEIFAHYN;
}
if (11770 > 25280) {
short CQROWDYDBB;
}
}
if (14459 > 16830) {
short YKMCFIIAUC;
YKMCFIIAUC = 18746;
if (3989 > 25073) {
long long EVOJKKFNFD;
bool UTFZMYOPJE;
long long SXPTTBRECO;
double HCACGIYWSI;
}
bool XBMKBFEECL;
if (8235 > 26698) {
long long RDFOXJMTVY;
double CRFJGTKOGJ;
double LHYMZCOWSV;
}
}
}
}
}
int main() {
scanf("%lld", &n);
if (12780 > 22489) {
bool ZCGTBFPGCT;
if (31745 > 30661) {
if (16855 > 19706) {
if (6813 > 27906) {
bool BDLPUHCGPZ;
}
if (17716 > 30112) {
long long CPDWYHUXET;
double ECYJHIHUYI;
}
long long YHKYVAVFSC;
YHKYVAVFSC = 31968;
}
if (29265 > 4049) {
int CQGKXISAEK;
CQGKXISAEK = 24895;
if (CQGKXISAEK) {
bool HCQEYAGTSQ;
long long JANTIWMHWD;
long long MGVVEAKYMX;
}
if (24687 > 18276) {
bool HKJEKCZGXJ;
short WHMCKELLCQ;
bool ZLYREOGAEL;
}
}
if (4956 > 9981) {
if (30989 > 19101) {
long long HDNQSSLRVV;
}
short FWZWSVYEHD;
FWZWSVYEHD = 18822;
short VKBATGOHEU;
VKBATGOHEU = 3131;
if (VKBATGOHEU) {
double YELJWTCJCL;
long long RLHTACRWVG;
double MEAVPENMTC;
long long KMUCQDSYUH;
}
long long YXPNUTBPJG;
}
}
}
for (long long i = 1; i <= n; i++) scanf("%lld", &s[i]);
short CQZNJNYJTN;
CQZNJNYJTN = 24204;
for (long long i = 1; i <= n; i++) Add(i, i);
short NBDMGXUMGA;
NBDMGXUMGA = 6446;
if (NBDMGXUMGA) {
int VBAKBENTED;
VBAKBENTED = 30605;
double JHILCUMRPQ;
long long YKRRTOSFOC;
YKRRTOSFOC = 4532;
}
for (long long i = n; i >= 1; i--) {
long long now = find(s[i]) + 1;
long long ALOXIXBCDP;
ALOXIXBCDP = 30259;
p[i] = now;
if (6231 > 15348) {
bool SNQBILZKZV;
SNQBILZKZV = 9882;
}
Add(now, -now);
if (20211 > 26895) {
double AMXOCTKDVN;
short POYHERVAAD;
POYHERVAAD = 22794;
}
}
for (long long i = 1; i <= n; i++) printf("%lld ", p[i]);
if (11139 > 24245) {
if (31075 > 14249) {
bool VXYOAAFRPE;
}
if (30404 > 16859) {
if (6719 > 24136) {
int JZYOWUJYVO;
JZYOWUJYVO = 13997;
if (JZYOWUJYVO) {
short JGKAZNEOSJ;
}
double ZIZXCRMYJJ;
ZIZXCRMYJJ = 14485;
if (ZIZXCRMYJJ) {
int IKFRLBQAOD;
int IPLSQGFXRO;
int URGXSDTNYF;
}
}
if (22449 > 4321) {
long long KQOXESIYRM;
KQOXESIYRM = 23208;
if (23812 > 5143) {
bool BREVDBAVPF;
int LMDKUOZGRM;
}
if (12363 > 27150) {
double RAVHNLTWBI;
short QXWRRIDQZE;
}
if (10441 > 3829) {
short FOPYPNXIEC;
long long VDTXLTZIQA;
}
}
int HWVDHWVNRU;
}
int JOIUZSHBQD;
JOIUZSHBQD = 10785;
}
printf("\n");
double QPMGPDWNPP;
QPMGPDWNPP = 8018;
return 0;
if (2682 > 13987) {
long long HKOIUGGXUN;
HKOIUGGXUN = 1996;
if (HKOIUGGXUN) {
short CRQZREGLKN;
CRQZREGLKN = 25479;
if (CRQZREGLKN) {
double NLEIVMKSEN;
if (25751 > 5300) {
double XFJUHXKDLM;
bool XWCVCCHXKF;
}
int GTJSUVKGBL;
GTJSUVKGBL = 16027;
if (GTJSUVKGBL) {
int XDOIHZMHBS;
bool MFNQOMGNZM;
int GLGNMAJTNO;
double DFGGGITLQL;
}
}
if (31529 > 10708) {
if (19626 > 4272) {
long long ERRWRVJEKW;
bool LTKQTNBHJT;
short GOJMATLKUP;
}
int JDLZPPCWHD;
JDLZPPCWHD = 15489;
if (JDLZPPCWHD) {
long long SYNEQEVSQQ;
}
}
if (20640 > 3925) {
long long FCMSKKBEER;
FCMSKKBEER = 16970;
if (FCMSKKBEER) {
int SFFWMRFYCQ;
int NZYEEPYPDM;
double UAFAKDISGU;
}
short BQNSJWWJGR;
if (19093 > 13597) {
double EKFLWHBJMS;
long long UITRVPCKMF;
bool XRUTCVXATC;
short GGJRRDHHBG;
}
short CIWYDTZODJ;
CIWYDTZODJ = 1312;
if (CIWYDTZODJ) {
long long TPKHLUEEUM;
double GECEIJUTLQ;
short ASHAQRBZUC;
bool GEBCKXQVJT;
short AAMYLEWKFX;
}
}
int GTCYNMPZRO;
GTCYNMPZRO = 7257;
}
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f ^= 1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return f ? x : -x;
}
struct BIT {
long long sum[200005];
void upd(int x, int v) {
for (; x < 200005; x += x & -x) sum[x] += v;
}
long long qry(int x) {
long long ans = 0;
for (; x; x -= x & -x) ans += sum[x];
return ans;
}
} bit;
int n;
long long s[200005];
int ans[200005];
int main() {
n = read();
for (int i = 1; i <= n; ++i) scanf("%lld", s + i);
for (int i = 1; i <= n; ++i) bit.upd(i, i);
for (int i = n; i; --i) {
int lb = 1, rb = n;
while (lb < rb) {
int md = (lb + rb + 1) >> 1;
if (bit.qry(md - 1) <= s[i])
lb = md;
else
rb = md - 1;
}
ans[i] = lb;
bit.upd(ans[i], -ans[i]);
}
for (int i = 1; i <= n; ++i) printf("%d%c", ans[i], i == n ? 10 : 32);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int LIM = 1e5 + 5, MOD = 1e9 + 7;
const int maxn = 1000006;
long long solve(long long a, long long b) {
if ((a == b) || (a == 0)) {
return 0;
} else {
long long res;
res = 1 + solve(a % (b / 2), b / 2);
return res;
}
}
long long ft[200005];
long long n;
void update(long long i, long long diff) {
for (; i <= n; i = i + (i & (-i))) {
ft[i] += diff;
}
}
long long query(long long i) {
long long sum = 0;
for (; i > 0; i = i - (i & (-i))) {
sum += ft[i];
}
return sum;
}
long long solve(long long z) {
long long sum = 0, ret = 0, i;
for (i = 20; i >= 0; i--) {
if (((ret + (1 << i)) <= n) && ((ft[ret + (1 << i)] + sum) <= z)) {
ret = ret + (1 << i);
sum = sum + ft[ret];
}
}
return (ret + 1);
}
int main() {
long long i, j, k, m;
cin >> n;
long long res[n + 5];
long long s[n + 5];
for (i = 1; i <= n; i++) ft[i] = 0;
for (i = 1; i <= n; i++) {
update(i, i);
cin >> s[i];
}
for (i = n; i >= 1; i--) {
res[i] = solve(s[i]);
update(res[i], -res[i]);
}
for (i = 1; i <= n; i++) {
cout << res[i] << " ";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, N = 2e5 + 5;
inline int read() {
int sum = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') sum = sum * 10 + c - 48, c = getchar();
return sum * f;
}
int n, a[N];
long long pre[N], c[N], s[N], ans[N];
bool vis[N];
void add(int x, int v) {
for (int i = x; i <= n; i += (i & -i)) c[i] += v;
}
long long query(int x) {
long long ans = 0;
for (int i = x; i > 0; i -= (i & -i)) ans += c[i];
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + i - 1;
for (int i = n; i >= 1; i--) {
int l = 1, r = n, pos = 0;
while (l <= r) {
int mid = (l + r) >> 1;
long long tmp = query(mid);
if (pre[mid] - tmp > s[i])
r = mid - 1;
else if (pre[mid] - tmp == s[i] && vis[mid])
l = mid + 1;
else if (pre[mid] - tmp == s[i]) {
pos = mid;
break;
} else
l = mid + 1;
}
ans[i] = pos;
vis[pos] = 1;
add(pos + 1, pos);
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize "O3"
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 2e5 + 5;
const int M = 1 << 18;
pair<long long, int> tree[M * 2 + 5];
long long lazy[M * 2 + 5];
int n, ans[N];
void push(int v) {
tree[v * 2].first += lazy[v];
tree[v * 2 + 1].first += lazy[v];
lazy[v * 2] += lazy[v];
lazy[v * 2 + 1] += lazy[v];
lazy[v] = 0;
}
void add(int l, int r, long long val, int v = 1, int le = 1, int re = M - 1) {
if (l > r || l > re || r < le) return;
if (le >= l && re <= r) {
tree[v].first += val;
lazy[v] += val;
return;
}
int mid = (le + re) / 2;
push(v);
add(l, r, val, v * 2, le, mid);
add(l, r, val, v * 2 + 1, mid + 1, re);
tree[v] = min(tree[v * 2], tree[v * 2 + 1]);
}
void solve() {
int pom;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> tree[i + M - 1].first;
tree[i + M - 1].second = {-i};
}
for (int i = M - 1; i >= 1; i--) tree[i] = min(tree[i * 2], tree[i * 2 + 1]);
for (int i = 1; i <= n; i++) {
pom = -tree[1].second;
ans[pom] = i;
add(pom, pom, INF);
add(pom + 1, n, -i);
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<long long, int>;
const int maxn = 2e5 + 5;
int n;
long long a[maxn], s[maxn], t[maxn << 2];
void build(int l, int r, int rt) {
if (l == r) {
t[rt] = l;
return;
}
int m = l + r >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
t[rt] = t[rt << 1] + t[rt << 1 | 1];
}
void update(int pos, int l, int r, int rt) {
if (l > pos || r < pos) return;
if (l == r) {
t[rt] = 0;
return;
}
int m = l + r >> 1;
update(pos, l, m, rt << 1);
update(pos, m + 1, r, rt << 1 | 1);
t[rt] = t[rt << 1] + t[rt << 1 | 1];
}
int query(long long q, int l, int r, int rt) {
if (l == r) return l;
int m = l + r >> 1;
if (t[rt << 1] > q)
return query(q, l, m, rt << 1);
else
return query(q - t[rt << 1], m + 1, r, rt << 1 | 1);
}
void pri(int l, int r, int rt) {
if (l == r) {
printf("%lld ", t[rt]);
return;
}
int m = l + r >> 1;
pri(l, m, rt << 1);
pri(m + 1, r, rt << 1 | 1);
}
int main() {
scanf("%d", &n);
build(1, n, 1);
for (int i = 1; i <= n; i++) scanf("%lld", s + i);
for (int i = n; i > 0; i--) {
a[i] = query(s[i], 1, n, 1);
update(a[i], 1, n, 1);
}
for (int i = 1; i <= n; i++) printf("%lld ", a[i]);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int ans[200005], n;
long long a[200005], aib[200005];
inline void Update(int p, int val) {
while (p <= n) {
aib[p] += val;
p += p & (-p);
}
}
inline long long Sum(int p) {
long long s = 0;
while (p >= 1) {
s += aib[p];
p -= p & (-p);
}
return s;
}
int main() {
int left, right, mid, poz;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
Update(i, i);
}
for (int i = n; i >= 1; i--) {
left = 1;
right = n;
while (left <= right) {
mid = (left + right) / 2;
if (Sum(mid) > a[i]) {
poz = mid;
right = mid - 1;
} else
left = mid + 1;
}
ans[i] = poz;
Update(poz, -poz);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:640000000")
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int maxn = (int)2e5 + 10;
long long a[maxn];
int res[maxn];
long long t[4 * maxn];
void build(int idx, int l, int r) {
if (l == r) {
t[idx] = l;
} else {
int m = (l + r) >> 1;
build(2 * idx, l, m);
build(2 * idx + 1, m + 1, r);
t[idx] = t[2 * idx] + t[2 * idx + 1];
}
}
int get(int idx, int l, int r, long long sum) {
if (l == r) return l;
int m = (l + r) >> 1;
if (t[2 * idx] > sum) {
return get(2 * idx, l, m, sum);
}
return get(2 * idx + 1, m + 1, r, sum - t[2 * idx]);
}
void upd(int idx, int l, int r, int pos) {
if (l == r) {
t[idx] = 0;
} else {
int m = (l + r) >> 1;
if (pos <= m) {
upd(2 * idx, l, m, pos);
} else {
upd(2 * idx + 1, m + 1, r, pos);
}
t[idx] = t[2 * idx] + t[2 * idx + 1];
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
build(1, 1, n);
for (int i = n - 1; i >= 0; i--) {
int val = get(1, 1, n, a[i]);
res[i] = val;
upd(1, 1, n, val);
}
for (int i = 0; i < n; i++) {
printf("%d ", res[i]);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long> tree;
vector<long long> s;
vector<long long> p;
long long build(long long L, long long R, long long v) {
if (R - L == 1) {
return tree[v] = L + 1;
} else {
return tree[v] = build(L, (L + R) / 2, v * 2 + 1) +
build((L + R) / 2, R, v * 2 + 2);
}
}
long long get(long long L, long long R, long long v, long long sum) {
if (R - L == 1) {
return L;
}
if (tree[v * 2 + 1] <= sum) {
return get((L + R) / 2, R, v * 2 + 2, sum - tree[v * 2 + 1]);
} else {
return get(L, (L + R) / 2, v * 2 + 1, sum);
}
}
long long sset(long long L, long long R, long long v, long long x) {
if (R - L == 1) {
return tree[v] = 0;
}
if (x < (L + R) / 2) {
return tree[v] = sset(L, (L + R) / 2, v * 2 + 1, x) + tree[v * 2 + 2];
} else {
return tree[v] = sset((L + R) / 2, R, v * 2 + 2, x) + tree[v * 2 + 1];
}
}
int32_t main() {
long long N;
cin >> N;
tree.resize(N * 4);
s.resize(N);
p.resize(N);
for (long long i = 0; i < N; i++) {
cin >> s[i];
}
build(0, N, 0);
for (long long i = N - 1; i >= 0; i--) {
p[i] = get(0, N, 0, s[i]);
sset(0, N, 0, p[i]);
p[i]++;
}
for (auto i : p) {
cout << i << " ";
}
cout << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const int maxn = (int)2e5 + 10;
int n;
long long v[maxn];
long long t[4 * maxn];
void change(int it, int l, int r, int pos, int x) {
if (l == r) {
t[it] = x;
} else {
int m = (l + r) >> 1;
if (pos <= m) {
change(2 * it, l, m, pos, x);
} else {
change(2 * it + 1, m + 1, r, pos, x);
}
t[it] = t[2 * it] + t[2 * it + 1];
}
}
int go(int it, int l, int r, long long s) {
if (l == r) {
return l;
}
int m = (l + r) >> 1;
if (t[2 * it] > s) {
return go(2 * it, l, m, s);
}
return go(2 * it + 1, m + 1, r, s - t[2 * it]);
}
int ans[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%lld", &v[i]);
}
for (int i = 1; i <= n; i++) {
change(1, 1, n, i, i);
}
for (int i = n - 1; i >= 0; i--) {
int x = go(1, 1, n, v[i]);
change(1, 1, n, x, 0);
ans[i] = x;
}
for (int i = 0; i < n; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int T;
long long n;
long long a[333333];
long long twosum[333333];
long long tree[(1LL << 18) * 3];
long long ans[333333];
set<long long> s;
void update(long long x, long long y) {
x += (1LL << 18);
while (x > 0LL) {
tree[x] += y;
x /= 2LL;
}
}
long long sum(int s, int e, int ns = 0, int ne = (1LL << 18) - 1, int idx = 1) {
if (s > ne || ns > e) return 0LL;
if (s <= ns && ne <= e) return tree[idx];
int mid = (ns + ne) / 2;
return sum(s, e, ns, mid, idx * 2) + sum(s, e, mid + 1, ne, idx * 2 + 1);
}
int main() {
scanf("%lld", &n);
for (long long i = 1LL; i <= n; i++) {
scanf("%lld", &a[i]);
twosum[i] = twosum[i - 1] + i;
s.insert(i);
update(i, i);
}
for (long long i = n; i > 0; i--) {
long long st = 1LL;
long long ed = n;
long long val;
while (st <= ed) {
long long mid = (st + ed) / 2LL;
if (sum(1, (int)mid - 1) <= a[i]) {
st = mid + 1LL;
val = mid;
} else
ed = mid - 1LL;
}
val = *s.lower_bound(val);
update(val, -val);
s.erase(val);
ans[i] = val;
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, ans[200100];
long long s[200100];
pair<long long, int> seg[800100];
long long lazy[800100];
void build(int l, int r, int ind) {
if (l == r) {
seg[ind] = {s[l], l};
return;
}
int mid = (l + r) / 2;
build(l, mid, ind * 2);
build(mid + 1, r, ind * 2 + 1);
if (seg[ind * 2].first < seg[ind * 2 + 1].first)
seg[ind] = seg[ind * 2];
else if (seg[ind * 2].first > seg[ind * 2 + 1].first)
seg[ind] = seg[ind * 2 + 1];
else {
if (seg[ind * 2].second > seg[ind * 2 + 1].second)
seg[ind] = seg[ind * 2];
else
seg[ind] = seg[ind * 2 + 1];
}
}
void push(int ind) {
lazy[ind * 2] += lazy[ind];
lazy[ind * 2 + 1] += lazy[ind];
lazy[ind] = 0;
}
void update(int l, int r, int x, int y, int ind, long long add) {
if (x > y or l > y or r < x) return;
if (l >= x and r <= y) {
lazy[ind] += add;
seg[ind].first += lazy[ind];
if (l != r) {
lazy[ind * 2] += lazy[ind];
lazy[ind * 2 + 1] += lazy[ind];
}
lazy[ind] = 0;
return;
}
seg[ind].first += lazy[ind];
push(ind);
int mid = (l + r) / 2;
update(l, mid, x, y, ind * 2, add);
update(mid + 1, r, x, y, ind * 2 + 1, add);
if (seg[ind * 2].first + lazy[ind * 2] <
seg[ind * 2 + 1].first + lazy[ind * 2 + 1])
seg[ind] = {seg[ind * 2].first + lazy[ind * 2], seg[ind * 2].second};
else if (seg[ind * 2].first + lazy[ind * 2] >
seg[ind * 2 + 1].first + lazy[ind * 2 + 1])
seg[ind] = {seg[ind * 2 + 1].first + lazy[ind * 2 + 1],
seg[ind * 2 + 1].second};
else {
if (seg[ind * 2].second > seg[ind * 2 + 1].second)
seg[ind] = {seg[ind * 2].first + lazy[ind * 2], seg[ind * 2].second};
else
seg[ind] = {seg[ind * 2 + 1].first + lazy[ind * 2 + 1],
seg[ind * 2 + 1].second};
}
}
pair<long long, int> calc(int l, int r, int ind) {
seg[ind].first += lazy[ind];
if (l == r) {
lazy[ind] = 0;
return seg[ind];
} else
push(ind);
if (seg[ind].first > 0) return seg[ind];
int mid = (l + r) / 2;
pair<long long, int> b = calc(mid + 1, r, ind * 2 + 1);
if (b.first <= 0)
return b;
else
return calc(l, mid, ind * 2);
}
int main() {
memset(lazy, 0, sizeof(lazy));
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i];
build(1, n, 1);
for (int i = 1; i <= n; i++) {
pair<long long, int> a = calc(1, n, 1);
ans[a.second] = i;
update(1, n, a.second + 1, n, 1, -i);
update(1, n, a.second, a.second, 1, 1e12);
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long mod = 1e9 + 7;
long long tree[200050 << 2], lazy[200050 << 2], a[200050];
void pushup(long long rt) { tree[rt] = min(tree[rt << 1], tree[rt << 1 | 1]); }
void pushdown(long long rt) {
if (lazy[rt]) {
lazy[rt << 1] += lazy[rt];
lazy[rt << 1 | 1] += lazy[rt];
tree[rt << 1] -= lazy[rt];
tree[rt << 1 | 1] -= lazy[rt];
lazy[rt] = 0;
}
}
void build(long long l, long long r, long long rt) {
if (l == r) {
tree[rt] = a[l];
return;
}
long long mid = (l + r) / 2;
build(l, mid, rt * 2);
build(mid + 1, r, rt * 2 + 1);
pushup(rt);
}
void update_id(long long pos, long long l, long long r, long long rt) {
if (l == r) {
tree[rt] = INF;
return;
}
pushdown(rt);
long long mid = (l + r) / 2;
if (pos <= mid)
update_id(pos, l, mid, rt * 2);
else
update_id(pos, mid + 1, r, rt * 2 + 1);
pushup(rt);
}
void update_range(long long L, long long R, long long w, long long l,
long long r, long long rt) {
if (L <= l && r <= R) {
tree[rt] -= w;
lazy[rt] += w;
return;
}
pushdown(rt);
long long mid = (l + r) / 2;
if (L <= mid) update_range(L, R, w, l, mid, rt * 2);
if (R > mid) update_range(L, R, w, mid + 1, r, rt * 2 + 1);
pushup(rt);
}
long long query(long long l, long long r, long long rt) {
if (l == r) {
return l;
}
pushdown(rt);
long long mid = (l + r) / 2;
if (tree[rt << 1 | 1] == 0)
return query(mid + 1, r, rt * 2 + 1);
else
return query(l, mid, rt * 2);
}
long long ans[200050];
int main() {
long long n;
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
build(1, n, 1);
for (long long i = 1; i <= n; i++) {
int pos = query(1, n, 1);
ans[pos] = i;
update_id(pos, 1, n, 1);
update_range(pos, n, i, 1, n, 1);
}
for (long long i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct BIT {
int size;
vector<long long> bit;
BIT() { size = 0; }
BIT(int s) {
size = s;
bit.resize(size + 1);
init();
}
void init() {
for (int i = 1; i <= size; i++) bit[i] = 0;
}
long long query(long long i) {
long long ret = 0;
while (i > 0) {
ret += bit[i];
i -= i & (-i);
}
return ret;
}
void add(long long i, long long x) {
while (i <= size) {
bit[i] += x;
i += i & (-i);
}
}
};
long long n;
long long s[200005];
long long ans[200005];
BIT bit(200005);
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n; i++) bit.add(i, i);
for (int i = n; i >= 1; i--) {
long long ub = n, lb = 0, mid;
while (ub - lb > 1) {
mid = (ub + lb) / 2;
if (bit.query(mid) <= s[i])
lb = mid;
else
ub = mid;
}
ans[i] = ub;
bit.add(ub, -ub);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long maxn = 2e5 + 10;
long long n, a[maxn], ans[maxn];
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void print(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
void write(long long x) {
print(x);
puts("");
}
struct Segment_Tree {
struct Seg {
long long mn, f;
} tree[maxn << 2];
void update(long long k) {
tree[k].mn = min(tree[k << 1].mn, tree[k << 1 | 1].mn);
}
void down(long long k) {
if (tree[k].f) {
tree[k << 1].f += tree[k].f;
tree[k << 1 | 1].f += tree[k].f;
tree[k << 1].mn += tree[k].f;
tree[k << 1 | 1].mn += tree[k].f;
tree[k].f = 0;
}
}
void build(long long k, long long l, long long r) {
tree[k].f = 0;
if (l == r) {
tree[k].mn = a[l];
return;
}
long long mid = (l + r) >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
update(k);
}
void change(long long k, long long l, long long r, long long x, long long y,
long long v) {
if (x > y) return;
if (x <= l && r <= y) {
tree[k].mn += v;
tree[k].f += v;
return;
}
down(k);
long long mid = (l + r) >> 1;
if (x <= mid) change(k << 1, l, mid, x, y, v);
if (mid < y) change(k << 1 | 1, mid + 1, r, x, y, v);
update(k);
}
void erase(long long k, long long l, long long r, long long x) {
if (l == r) {
tree[k].mn = inf;
tree[k].f = 0;
return;
}
down(k);
long long mid = (l + r) >> 1;
if (x <= mid)
erase(k << 1, l, mid, x);
else
erase(k << 1 | 1, mid + 1, r, x);
update(k);
}
long long query(long long k, long long l, long long r) {
if (l == r) return l;
down(k);
long long mid = (l + r) >> 1;
if (!tree[k << 1 | 1].mn)
return query(k << 1 | 1, mid + 1, r);
else
return query(k << 1, l, mid);
}
} T;
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
T.build(1, 1, n);
for (long long i = 1; i <= n; i++) {
long long pos = T.query(1, 1, n);
ans[pos] = i;
T.change(1, 1, n, pos + 1, n, -i);
T.erase(1, 1, n, pos);
}
for (long long i = 1; i <= n; i++) printf("%lld ", ans[i]);
puts("");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long> bit(200001);
void update(long long x, long long y, long long n) {
for (long long i = x; i <= n; i = i + (i & (-i))) bit[i] += y;
}
int search(long long x, int n) {
long long ans = 0, sum = 0;
for (int i = 21; i >= 0; i--) {
if (ans + (1LL << i) <= n && sum + bit[ans + (1LL << i)] <= x) {
ans = ans + (1LL << i);
sum = sum + bit[ans];
}
}
return ans + 1;
}
int main() {
int n;
cin >> n;
vector<long long> arr(n + 1);
for (int i = 1; i <= n; i++) {
cin >> arr[i];
update(i, i, n);
}
vector<int> ans(n + 1);
for (int i = n; i > 0; i--) {
ans[i] = search(arr[i], n);
update(ans[i], -ans[i], n);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int n, ans[MAXN], mark[MAXN];
long long s[MAXN], tree[MAXN];
void add(int x, int val) {
for (; x <= n; x += x & -x) tree[x] += val;
}
long long ask(int x) {
long long res = 0;
for (; x; x &= x - 1) res += tree[x];
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = n - 1; ~i; --i) {
int l = 1, r = n, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (1LL * mid * (mid - 1) / 2 - ask(mid - 1) <= s[i]) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
if (ans < 0) exit(-1);
::ans[i] = ans;
add(ans, ans);
}
for (int i = 0; i < n; ++i) cout << ans[i] << ' ';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
std::vector<long long> a;
const long long INF = 1000000000000000000LL;
int lm = -1;
std::vector<long long> ts;
long long fill(int l, int r, int i) {
if (l == r) {
ts[i] = a[l];
return a[l];
}
int m = (l + r) / 2;
ts[i] = fill(l, m, i * 2) + fill(m + 1, r, i * 2 + 1);
return ts[i];
}
void init(int n) {
ts.assign(4 * n, 0);
fill(0, n - 1, 1);
}
long long getSum(int l, int r, int cl, int cr, int i) {
if (l == cl && r == cr) return ts[i];
int cm = (cl + cr) / 2;
if (r <= cm) return getSum(l, r, cl, cm, i * 2);
if (cm < l) return getSum(l, r, cm + 1, cr, i * 2 + 1);
return getSum(l, cm, cl, cm, i * 2) +
getSum(cm + 1, r, cm + 1, cr, i * 2 + 1);
}
void set(int cl, int cr, int i, int ai, int val) {
if (cl == ai && cr == ai) {
ts[i] = a[ai] = val;
return;
}
int cm = (cl + cr) / 2;
if (ai <= cm)
set(cl, cm, i * 2, ai, val);
else
set(cm + 1, cr, i * 2 + 1, ai, val);
ts[i] = ts[i * 2] + ts[i * 2 + 1];
}
int main() {
int n;
scanf("%d", &n);
std::vector<long long> s(n);
for (long long& x : s) scanf("%I64d", &x);
a.assign(1 + n, 0);
for (int i = 0; i < (int)a.size(); ++i) a[i] = i;
init(a.size());
std::vector<int> ans(n);
for (int i = n - 1; i >= 0; --i) {
int l = 0, r = n + 1;
while (r > l + 1) {
int m = (l + r) / 2;
long long sum = getSum(0, m, 0, n, 1);
if (sum > s[i])
r = m;
else
l = m;
}
ans[i] = l + 1;
set(0, n, 1, l + 1, 0);
}
for (int x : ans) printf("%d ", x);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long A[300001];
long long tree[300001 * 4 + 2], prop[4 * 300001 + 2], ans[300001];
void create(long long node, long long b, long long e) {
if (b == e) {
tree[node] = A[b];
return;
}
long long l = 2 * node;
long long r = l + 1;
long long m = (b + e) / 2;
create(l, b, m);
create(r, m + 1, e);
tree[node] = min(tree[l], tree[r]);
}
void update(long long node, long long b, long long e, long long i, long long j,
long long val) {
if (b > j || e < i) return;
if (i <= b && e <= j) {
if (val == ((long long)1 << 62)) {
tree[node] = ((long long)1 << 62);
return;
}
prop[node] += val;
tree[node] -= val;
return;
}
long long l = 2 * node;
long long r = l + 1;
long long m = (b + e) / 2;
if (prop[node]) {
prop[l] += prop[node];
prop[r] += prop[node];
tree[l] = -prop[node];
tree[r] -= prop[node];
prop[node] = 0;
}
update(l, b, m, i, j, val);
update(r, m + 1, e, i, j, val);
tree[node] = min(tree[l], tree[r]);
}
long long query(long long node, long long b, long long e) {
if (b == e) return b;
long long l = 2 * node;
long long r = l + 1;
long long m = (b + e) / 2;
if (prop[node]) {
prop[l] += prop[node];
prop[r] += prop[node];
tree[l] -= prop[node];
tree[r] -= prop[node];
prop[node] = 0;
}
if (tree[r] == 0)
return query(r, m + 1, e);
else
return query(l, b, m);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
memset(prop, 0, sizeof prop);
;
long long n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> A[i];
create(1, 1, n);
for (int i = 1; i <= n; i++) {
long long p = query(1, 1, n);
ans[p] = i;
update(1, 1, n, p, p, ((long long)1 << 62));
update(1, 1, n, p + 1, n, i);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << "\n";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PII = pair<int, int>;
template <class T>
struct Fenwick {
vector<T> v;
Fenwick(size_t n) : v(n + 1) {}
void add(size_t i, T x) {
for (++i; i < v.size(); i += i & -i) v[i] += x;
}
T sum(size_t i) {
for (v[0] = T(); i; i -= i & -i) v[0] += v.at(i);
return v[0];
}
T sum(size_t l, size_t r) { return sum(r) - sum(l); }
};
const int N = 2e5 + 5;
int n, a[N];
LL s[N];
int main() {
cin >> n;
Fenwick<LL> fw(N);
for (int i = (1); i <= (n); ++i) scanf("%lld", &s[i]), fw.add(i, i);
for (int i = n; i >= 1; i--) {
int l = 0, r = n;
while (l + 1 < r) {
int m = (l + r) >> 1;
LL sum = fw.sum(m + 1);
if (sum <= s[i])
l = m;
else
r = m;
}
a[i] = l + 1;
fw.add(l + 1, -(l + 1));
}
for (int i = 1; i <= n; i++) printf("%d%c", a[i], " \n"[i == n]);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct BIT {
int n, N_MAX;
vector<long long> v;
BIT(int n) {
this->n = n + 100;
N_MAX = n - 1;
v.assign(n + 110, 0);
}
void upd(int p, int x) {
while (p <= n) v[p] += x, p += p & -p;
}
long long que(int p) {
long long ans = 0;
while (p) ans += v[p], p -= p & -p;
return ans;
}
long long quep(int p) { return que(p) - que(p - 1); }
long long bit_search(long long s) {
long long sum = 0, pos = 0;
for (int i = 21; i >= 0; i--)
if (pos + (1 << i) <= N_MAX && sum + v[pos + (1 << i)] < s) {
pos += (1 << i);
sum += v[pos];
}
return pos + 1;
}
};
int main() {
int n;
scanf("%d", &n);
BIT bit(n);
vector<long long> v(n + 1), ans(n + 1);
for (int i = 1; i <= n; i++) scanf("%lld", &v[i]), bit.upd(i, i);
for (int i = n; i; i--) {
int p = bit.bit_search(v[i] + 1);
ans[i] = p;
bit.upd(p, -p);
}
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
printf("\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void rset();
void init_test();
void solve();
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed;
cout.precision(20);
init_test();
return 0;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
template <typename T>
void MACRO_rdv2_Init(long long n, T& t) {
t.resize(n);
}
template <typename First, typename... Rest>
void MACRO_rdv2_Init(long long n, First& first, Rest&... rest) {
first.resize(n);
MACRO_rdv2_Init(n, rest...);
}
template <typename T>
void MACRO_rdv2_Scan(long long p, T& t) {
std::cin >> t[p];
}
template <typename First, typename... Rest>
void MACRO_rdv2_Scan(long long p, First& first, Rest&... rest) {
std::cin >> first[p];
MACRO_rdv2_Scan(p, rest...);
}
template <typename T>
void wrv(const vector<T>& v) {
for (long long(__ii) = (0); (__ii) < (((long long)v.size())); ++(__ii)) {
if (__ii) cout << ' ';
cout << v[__ii];
}
cout << '\n';
}
template <typename T>
void wrm(const vector<vector<T>>& v) {
for (long long(__ii) = (0); (__ii) < (((long long)v.size())); ++(__ii)) {
for (long long(__jj) = (0); (__jj) < (v[__ii].size()); ++(__jj)) {
if (__jj) cout << ' ';
cout << v[__ii][__jj];
}
cout << '\n';
}
}
template <typename T>
void sc(T& x) {
cin >> x;
}
template <typename Head, typename... Tail>
void sc(Head& head, Tail&... tail) {
cin >> head;
sc(tail...);
}
template <typename T>
void wr(const T& x) {
cout << x << '\n';
}
template <typename Head, typename... Tail>
void wr(const Head& head, const Tail&... tail) {
cout << head << ' ';
wr(tail...);
}
template <typename T>
void wrf(const T& x) {
cout << x << endl;
}
template <typename Head, typename... Tail>
void wrf(const Head& head, const Tail&... tail) {
cout << head << ' ';
wrf(tail...);
}
template <typename T>
void debug_out(const T& x) {
cerr << x << '\n';
}
template <typename Head, typename... Tail>
void debug_out(const Head& head, const Tail&... tail) {
cerr << head << ' ';
debug_out(tail...);
}
template <typename... T>
void err(const T&... cod) {
wr(cod...);
exit(0);
}
const long long N = 2e5 + 10;
const long long inf = 1e12;
long long st_mn, st_mx;
class segtree {
private:
struct node {
long long mn, mx;
node(long long mn = inf, long long mx = -inf) : mn(mn), mx(mx){};
node operator+(const node& rhs) const {
node ans;
ans.mn = min(mn, rhs.mn);
ans.mx = max(mx, rhs.mx);
return ans;
}
};
long long n, ql, qr;
vector<node> st;
vector<long long> lazy;
void push(long long sl, long long sr, long long at) {
if (lazy[at] == 0) return;
st[at].mn += lazy[at];
st[at].mx += lazy[at];
if (sl != sr) {
lazy[at << 1] += lazy[at];
lazy[at << 1 | 1] += lazy[at];
}
lazy[at] = 0;
}
void add_recur(long long sl, long long sr, long long at, long long delta) {
push(sl, sr, at);
if (qr < sl || ql > sr) return;
if (ql <= sl && qr >= sr) {
lazy[at] += delta;
push(sl, sr, at);
return;
}
long long mid = (sl + sr) >> 1;
long long le = at << 1, ri = at << 1 | 1;
add_recur(sl, mid, le, delta);
add_recur(mid + 1, sr, ri, delta);
st[at] = st[le] + st[ri];
}
node get_recur(long long sl, long long sr, long long at) {
push(sl, sr, at);
if (qr < sl || ql > sr) return node();
if (ql <= sl && qr >= sr) return st[at];
long long mid = (sl + sr) >> 1;
return get_recur(sl, mid, at << 1) + get_recur(mid + 1, sr, at << 1 | 1);
}
public:
segtree() {}
segtree(long long _n) { init(_n); }
void init(long long _n) {
this->n = _n;
st.assign(n << 2, node(0, 0));
lazy.assign(n << 2, 0);
}
void add(long long l, long long r, long long delta) {
ql = l, qr = r;
if (l > r) return;
add_recur(0, n - 1, 1, delta);
}
void get(long long l, long long r) {
ql = l, qr = r;
node tmp = get_recur(0, n - 1, 1);
st_mn = tmp.mn, st_mx = tmp.mx;
}
};
long long find_zero(long long n, segtree* st) {
long long low = 0, high = n - 1;
while (low < high) {
long long mid = (low + high + 1) / 2;
st->get(mid, high);
if (st_mn == 0)
low = mid;
else
high = mid - 1;
}
return low;
}
void solve() {
long long n;
sc(n);
vector<long long> a(n);
for (long long(__ii) = (0); (__ii) < (n); ++(__ii)) cin >> a[__ii];
segtree* st = new segtree(n);
for (long long(i) = (0); (i) < (n); ++(i)) st->add(i, i, a[i]);
vector<long long> ans(n);
for (long long(i) = (1); (i) < (n + 1); ++(i)) {
long long at = find_zero(n, st);
ans[at] = i;
st->add(at, at, inf);
st->add(at + 1, n - 1, -i);
}
wrv(ans);
}
void init_test() {
long long qq = 1;
while (qq--) solve();
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, b[N];
long long BIT[N], a[N];
int lowbit(int x) { return x & (-x); }
void Add(int x, int y) {
while (x <= n) {
BIT[x] += y;
x += lowbit(x);
}
}
long long Sum(int x) {
long long ans = 0;
while (x) {
ans += BIT[x];
x -= lowbit(x);
}
return ans;
}
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
for (register int i = 1; i <= n; i++) Add(i, i);
for (register int i = n; i >= 1; i--) {
int l = 1, r = n;
while (l <= r) {
int mid = l + r >> 1;
long long w = Sum(mid - 1);
if (w <= a[i])
l = mid + 1;
else
r = mid - 1;
}
b[i] = r;
Add(r, -r);
}
for (register int i = 1; i <= n; i++) printf("%d ", b[i]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int bit[200005];
int n;
void update(int j, int x) {
for (; j < 200005; j += j & (-j)) bit[j] += x;
}
long long int query(int j) {
if (j == 0) return 0;
long long int x = 0;
for (; j > 0; j -= (j) & (-j)) x += bit[j];
return x;
}
int next_ele(long long int s) {
int l, r, m;
long long int q;
l = 0, r = n;
while (l < r - 1) {
m = (l + r) / 2;
q = query(m);
if (q < s) l = m + 1;
if (q > s) r = m - 1;
if (q == s) l = m;
}
m = l;
if (query(r) == s) m = r;
return m + 1;
}
int compute(long long int s) {
int x;
s *= 2;
x = sqrt(s);
return x + 1;
}
int main() {
int i;
scanf("%d", &n);
vector<long long int> sum(n);
for (i = 0; i < n; i++) cin >> sum[i];
vector<int> ans(n);
ans[n - 1] = compute(sum[n - 1]);
for (i = 1; i < n + 1; i++) update(i, i);
update(ans[n - 1], -ans[n - 1]);
for (i = n - 2; i >= 0; i--) {
ans[i] = next_ele(sum[i]);
update(ans[i], -ans[i]);
}
for (i = 0; i < n; i++) printf("%d ", ans[i]);
printf("\n");
}
| 10 | CPP |
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
from sys import stdin, stdout
from collections import defaultdict
from collections import deque
import math
import copy
#T = int(input())
N = int(input())
#s1 = input()
#s2 = input()
#N,Q = [int(x) for x in stdin.readline().split()]
arr = [int(x) for x in stdin.readline().split()]
bit = [0]*(N+1)
series = [0] + [x for x in range(N)]
def lowbit(x):
return x&(-x)
def update(idx,delta):
while idx<=N:
bit[idx] += delta
idx += lowbit(idx)
def query(x):
s = 0
while x>0:
s += bit[x]
x -= lowbit(x)
return s
# init
for i in range(1,N+1):
bit[i] += series[i]
y = i + lowbit(i)
if y<=N:
series[y] += series[i]
visited = [0]*(N+1)
ans = [0]*N
for i in range(N-1,-1,-1):
# find
left = 1
right = N
target = arr[i]
while True:
L = right - left + 1
num = left - 1 + 2**int(math.log(L,2))
q = bit[num]
#print(num,q,target,left,right)
if q<target:
target -= q
left = num + 1
elif q>target:
right = num - 1
else:
if visited[num]==1:
target -= q
left = num + 1
else:
visited[num] = 1
ans[i] = num
break
# update
update(num+1,-num)
print(*ans)
| 10 | PYTHON3 |
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
#sys.setrecursionlimit(300000)
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=0, func=lambda a, b: max(a, b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n=int(input())
l=list(map(int,input().split()))
f=[i for i in range(1,n+1)]
s=SegmentTree(f)
ans=[0]*n
for i in range(n-1,-1,-1):
st=1
end=n
while(st<=end):
mid=(st+end)//2
su=s.query(0,mid-2)
if su==l[i]:
an=mid
st=mid+1
elif su<l[i]:
st=mid+1
else:
end=mid-1
ans[i]=an
s.__setitem__(an-1,0)
print(*ans,sep=" ") | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n;
long long sum[N], ans[N], cur;
long long seg[1 << 20];
set<int> nw;
void update(int i, int v, int ni = 0, int ns = 0, int ne = n) {
if (ns > i || ne < i || ns > ne) return;
if (ns == ne && ns == i) {
seg[ni] += v;
return;
}
if (ns >= ne) return;
int l = ni * 2 + 1, r = l + 1, mid = (ns + ne) / 2;
update(i, v, l, ns, mid);
update(i, v, r, mid + 1, ne);
seg[ni] = seg[l] + seg[r];
}
long long query(int qs, int qe, int ni = 0, int ns = 0, int ne = n) {
if (ns > qe || ne < qs || ns > ne) return 0;
if (ns >= qs && ne <= qe) return seg[ni];
int l = ni * 2 + 1, r = l + 1, mid = (ns + ne) / 2;
return query(qs, qe, l, ns, mid) + query(qs, qe, r, mid + 1, ne);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%lld", sum + i);
for (int i = 1; i <= n; ++i) nw.insert(i);
for (int i = n - 1; i >= 0; --i) {
int st = 0, en = n - 1;
while (st < en) {
int mid = (st + en + 1) / 2;
long long s = 1ll * mid * (mid + 1) / 2 - query(0, mid);
if (s > sum[i])
en = mid - 1;
else
st = mid;
}
int x = *nw.lower_bound(st + 1);
nw.erase(x);
ans[i] = x;
update(x, x);
}
for (int i = 0; i < n; ++i) printf("%lld ", ans[i]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005];
long long s[200005];
pair<long long, int> sg[800005];
long long lz[800005];
void Build(int nod, int l, int r) {
sg[nod] = {0, r};
if (l == r) return;
int mid = (l + r) / 2;
Build(2 * nod, l, mid);
Build(2 * nod + 1, mid + 1, r);
}
void Sift(int nod, int l, int r) {
sg[nod].first += lz[nod];
if (l != r) {
lz[2 * nod] += lz[nod];
lz[2 * nod + 1] += lz[nod];
}
lz[nod] = 0;
}
void Upd(int nod, int l, int r, int lt, int rt, long long v) {
Sift(nod, l, r);
if (l > rt || r < lt) return;
if (l >= lt && r <= rt) {
lz[nod] += v;
Sift(nod, l, r);
return;
}
int mid = (l + r) / 2;
Upd(2 * nod, l, mid, lt, rt, v);
Upd(2 * nod + 1, mid + 1, r, lt, rt, v);
if (sg[2 * nod + 1].first > sg[2 * nod].first)
sg[nod] = sg[2 * nod];
else
sg[nod] = sg[2 * nod + 1];
}
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n;
Build(1, 1, n);
for (int i = 1; i <= n; i++) {
cin >> s[i];
Upd(1, 1, n, i, i, s[i]);
}
for (int i = 1; i <= n; i++) {
int p = sg[1].second;
a[p] = i;
Upd(1, 1, n, p, n, -i);
Upd(1, 1, n, p, p, 1000000000000000005);
}
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
namespace fast {
inline char nc() {
static char buf[100000], *L = buf, *R = buf;
return L == R && (R = (L = buf) + fread(buf, 1, 100000, stdin), L == R)
? EOF
: *L++;
}
template <class orz>
inline void qread(orz &x) {
x = 0;
char ch = nc();
bool f = 0;
while (ch < '0' || ch > '9') (ch == '-') && (f = 1), ch = nc();
while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + (ch ^ 48), ch = nc();
f && (x = -x);
}
} // namespace fast
using namespace fast;
template <class orz>
inline void read(orz &x) {
x = 0;
bool f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') (ch == '-') && (f = 1), ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
f && (x = -x);
}
template <class orz>
inline void out(orz x) {
(x < 0) && (putchar('-'), x = -x);
if (x > 9) out(x / 10);
putchar(x % 10 + '0');
}
const double PI = acos(-1);
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const long long mod = 998244353;
const int maxn = 2e5 + 5;
long long c[maxn], n;
long long ask(int x) {
long long ans = 0;
for (; x; x -= x & -x) ans += c[x];
return ans;
}
void add(int x, long long y) {
for (; x <= n; x += x & -x) c[x] += y;
}
long long s[maxn];
long long ans[maxn];
int erfen(long long key) {
int left = 1;
int right = n;
while (left <= right) {
int mid = (left + right) / 2;
if (ask(mid) <= key) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return right;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &s[i]);
add(i, i * 1LL);
}
for (int i = n; i >= 1; i--) {
ans[i] = erfen(s[i]) + 1;
add(ans[i], -1LL * ans[i]);
}
printf("%lld", ans[1]);
for (int i = 2; i <= n; i++) {
printf(" %lld", ans[i]);
}
putchar('\n');
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, ans[N];
long long a[N], bit[N];
void update(int pos) {
for (int i = pos; i < N; i += (i & -i)) {
bit[i] += pos;
}
}
long long query(int pos) {
long long res = 0;
for (int i = pos; i; i -= (i & -i)) {
res += bit[i];
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = n; i; i--) {
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) / 2;
if (1ll * (mid - 1) * mid / 2 - query(mid - 1) <= a[i]) {
ans[i] = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
update(ans[i]);
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << (i == n ? "\n" : " ");
}
}
| 10 | CPP |
def update(x,val):
while x<=n:
BIT[x]+=val
x+=(x&-x)
def query(x):
s=0
while x>0:
s=(s+BIT[x])
x-=(x&-x)
return s
n=int(input())
BIT=[0]*(n+1)
for i in range(1,n+1):
update(i,i)
arr=list(map(int,input().split()))
answers=[0]*(n)
#print(BIT)
for i in range(n-1,-1,-1):
lol=arr[i]
low=0
fjf=0
high=n
# print(lol)
while True:
mid=(high+low+1)//2
j=query(mid)
# print(mid,j)
# print(answers)
# break
if j>lol:
if query(mid-1)==lol:
answers[i]=mid
update(mid,-mid)
break
else:
high=mid
else:
low=mid
print(*answers)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1000005;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const long long MOD = 100000007;
const double eps = 1e-10;
long long qpow(long long a, long long b) {
long long tmp = a % MOD, ans = 1;
while (b) {
if (b & 1) {
ans *= tmp, ans %= MOD;
}
tmp *= tmp, tmp %= MOD, b >>= 1;
}
return ans;
}
long long lowbit(long long x) { return x & -x; }
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
long long mmax(long long a, long long b, long long c) {
return max(a, max(b, c));
}
long long mmin(long long a, long long b, long long c) {
return min(a, min(b, c));
}
void mod(long long &a) {
a += MOD;
a %= MOD;
}
bool chk(long long now) {}
long long half(long long l, long long r) {
while (l <= r) {
long long m = (l + r) / 2;
if (chk(m))
r = m - 1;
else
l = m + 1;
}
return l;
}
long long ll(long long p) { return p << 1; }
long long rr(long long p) { return p << 1 | 1; }
long long mm(long long l, long long r) { return (l + r) / 2; }
long long lg(long long x) {
if (x == 0) return 1;
return (long long)log2(x) + 1;
}
bool smleql(double a, double b) {
if (a < b || fabs(a - b) <= eps) return true;
return false;
}
double len(double a, double b, double c, double d) {
return sqrt((a - c) * (a - c) + (b - d) * (b - d));
}
bool isp(long long x) {
if (x == 1) return false;
if (x == 2) return true;
for (long long i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
long long n;
long long s[maxn], h[maxn], a[maxn];
long long mx[maxn], mn[maxn];
long long tag[maxn];
void up(long long p) {
mx[p] = max(mx[ll(p)], mx[rr(p)]);
mn[p] = min(mn[ll(p)], mn[rr(p)]);
}
void down(long long p, long long l, long long r) {
if (tag[p]) {
long long m = mm(l, r);
tag[ll(p)] += tag[p];
tag[rr(p)] += tag[p];
mx[ll(p)] += tag[p];
mx[rr(p)] += tag[p];
mn[ll(p)] += tag[p];
mn[rr(p)] += tag[p];
tag[p] = 0;
}
}
pair<long long, long long> ask(long long p, long long l, long long r,
long long L, long long R) {
if (L <= l && r <= R) {
return make_pair(mn[p], mx[p]);
}
down(p, l, r);
pair<long long, long long> le = make_pair(inf, -1), ri = make_pair(inf, -1);
long long m = mm(l, r);
if (L <= m) le = ask(ll(p), l, m, L, R);
if (R > m) ri = ask(rr(p), m + 1, r, L, R);
up(p);
return make_pair(min(le.first, ri.first), max(le.second, ri.second));
}
void change(long long p, long long l, long long r, long long L, long long R,
long long v) {
if (L <= l && r <= R) {
mx[p] += v;
mn[p] += v;
tag[p] += v;
return;
}
down(p, l, r);
long long m = mm(l, r);
if (L <= m) change(ll(p), l, m, L, R, v);
if (R > m) change(rr(p), m + 1, r, L, R, v);
up(p);
}
void build(long long p = 1, long long l = 1, long long r = n) {
if (l == r) {
mx[p] = h[l];
mn[p] = h[l];
return;
}
long long m = mm(l, r);
build(ll(p), l, m);
build(rr(p), m + 1, r);
up(p);
}
long long get(long long l, long long r, long long v) {
if (l == r) return l;
long long m = mm(l, r);
pair<long long, long long> le = make_pair(inf, -1), ri = make_pair(inf, -1);
if (l <= m) le = ask(1, 1, n, l, m);
if (le.first <= v && le.second >= v)
return get(l, m, v);
else
return get(m + 1, r, v);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
for (long long i = 1; i <= 200000; ++i) h[i] = i * (i - 1) / 2;
for (long long i = 1; i <= n; ++i) cin >> s[i];
build();
for (long long i = n; i >= 1; --i) {
a[i] = get(1, n, s[i]);
if (a[i] < n) change(1, 1, n, a[i] + 1, n, -a[i]);
change(1, 1, n, a[i], a[i], -10000000);
}
for (long long i = 1; i <= n; ++i) cout << a[i] << ' ';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("O3")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("Ofast")
using namespace std;
const int INF = 1e9 + 10;
const long long INFll = 2e18;
const int BASE1 = 179;
const int BASE2 = 653;
const long long MOD = 998244353;
const int MAXA = 2000001;
const int MAXN = 2e5 + 1;
const int MAXLOG = 22;
const long long COST = 1000 * 1000 * 1000;
const long double PI = 3.1415926535;
const long double EPS = 1e-15;
struct SegmentTree {
vector<pair<long long, long long> > tree;
vector<long long> arr, add;
SegmentTree(vector<long long>& a) {
tree.resize(4 * ((int)(a).size()), make_pair(INF, -1));
add.resize(4 * ((int)(a).size()), 0);
arr = a;
build(0, 0, ((int)(arr).size()));
}
void build(long long v, long long left, long long right) {
if (left + 1 == right) {
tree[v] = make_pair(arr[left], -left);
return;
}
long long mid = (left + right) / 2;
build(2 * v + 1, left, mid);
build(2 * v + 2, mid, right);
tree[v] = min(tree[2 * v + 1], tree[2 * v + 2]);
}
void push(long long v, long long left, long long right) {
if (add[v] == 0) return;
tree[v].first += add[v];
if (left != right - 1) {
add[2 * v + 1] += add[v];
add[2 * v + 2] += add[v];
}
add[v] = 0;
}
void addval(long long v, long long left, long long right, long long lq,
long long rq, long long val) {
push(v, left, right);
if (left >= rq || lq >= right) return;
if (lq <= left && rq >= right) {
add[v] += val;
push(v, left, right);
return;
}
long long mid = (left + right) / 2;
addval(2 * v + 1, left, mid, lq, rq, val);
addval(2 * v + 2, mid, right, lq, rq, val);
tree[v] = min(tree[2 * v + 1], tree[2 * v + 2]);
}
pair<long long, long long> getMin(long long v, long long left,
long long right, long long lq,
long long rq) {
push(v, left, right);
if (left >= lq && right <= rq)
return tree[v];
else if (left >= rq || right <= lq)
return make_pair(INF, -1);
long long mid = (left + right) / 2;
return min(getMin(2 * v + 1, left, mid, lq, rq),
getMin(2 * v + 2, mid, right, lq, rq));
}
};
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < (n); i++) cin >> a[i];
SegmentTree tree(a);
vector<long long> p(n, -1);
for (int i = 0; i < (n); i++) {
auto pos = tree.getMin(0, 0, n, 0, n);
p[-pos.second] = i + 1;
tree.addval(0, 0, n, -pos.second, -pos.second + 1, INFll);
tree.addval(0, 0, n, -pos.second + 1, n, -i - 1);
}
for (int i = 0; i < (n); i++) cout << p[i] << " ";
cout << "\n";
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int grand(int x) { return uniform_int_distribution<int>(0, x - 1)(rng); }
long long getInt() {
bool minus = false;
long long result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = result * 10 + (ch - '0');
}
if (minus)
return -result;
else
return result;
}
long long gcd(long long x, long long y) {
if (x < y) return gcd(y, x);
if (y == 0) return x;
return gcd(y, x % y);
}
const long long mod = 1e9 + 7;
long long modexp(long long x, long long ex) {
long long ans = 1ll;
while (ex > 0) {
if (ex & 1ll) ans = (ans * x) % mod;
ex >>= 1ll;
x = (x * x) % mod;
}
return ans;
}
const long long maxn = 1e6 + 7;
const long long N = 1e6 + 7;
const long long inf = 1e151515151515151515151515151515 + 7;
long long srr[N];
long long per[N];
pair<long long, long long> tree[N];
long long lzy[N];
void build(long long nd, long long st, long long en) {
if (st == en) {
tree[nd] = {srr[st], -st};
return;
}
long long mid = (st + en) >> 1;
build(nd + nd, st, mid);
build(nd + nd + 1, mid + 1, en);
tree[nd] = min(tree[nd + nd], tree[nd + nd + 1]);
}
inline void push(long long x) {
if (lzy[x] == 0) return;
tree[x + x].first += lzy[x];
tree[x + x + 1].first += lzy[x];
lzy[x + x] += lzy[x];
lzy[x + x + 1] += lzy[x];
lzy[x] = 0;
}
void upd(long long nd, long long st, long long en, long long l, long long r,
long long val) {
if (en < l || r < st) return;
if (l <= st && en <= r) {
tree[nd].first += val;
lzy[nd] += val;
return;
}
push(nd);
long long mid = (st + en) >> 1;
upd(nd + nd, st, mid, l, r, val);
upd(nd + nd + 1, mid + 1, en, l, r, val);
tree[nd] = min(tree[nd + nd], tree[nd + nd + 1]);
}
pair<long long, long long> qry(long long nd, long long st, long long en,
long long l, long long r) {
if (en < l || r < st) return {inf, 0};
if (l <= st && en <= r) return tree[nd];
push(nd);
long long mid = (st + en) >> 1;
return min(qry(nd + nd, st, mid, l, r), qry(nd + nd + 1, mid + 1, en, l, r));
}
int32_t main() {
{
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> srr[i];
}
build(1, 1, n);
for (long long i = 1; i <= n; i++) {
auto p = qry(1, 1, n, 1, n);
per[-p.second] = i;
upd(1, 1, n, -p.second + 1, n, -i);
upd(1, 1, n, -p.second, -p.second, inf);
}
for (long long i = 1; i <= n; i++) {
cout << per[i] << " ";
}
cout << "\n";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int t, n;
long long s[200005];
long long T[200005 << 2];
void build(int u, int l, int r) {
T[u] = 0;
if (l == r) {
T[u] = l;
return;
}
build((u << 1), l, ((l + r) >> 1));
build((u << 1 | 1), ((l + r) >> 1) + 1, r);
T[u] = T[(u << 1)] + T[(u << 1 | 1)];
}
int query(int u, int l, int r, long long S) {
if (l == r) return l;
if (T[(u << 1)] > S)
return query((u << 1), l, ((l + r) >> 1), S);
else
return query((u << 1 | 1), ((l + r) >> 1) + 1, r, S - T[(u << 1)]);
}
void change(int u, int l, int r, int p) {
if (l == r) {
T[u] = 0;
return;
}
if (p <= ((l + r) >> 1))
change((u << 1), l, ((l + r) >> 1), p);
else
change((u << 1 | 1), ((l + r) >> 1) + 1, r, p);
T[u] = T[(u << 1)] + T[(u << 1 | 1)];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &s[i]);
}
build(1, 1, n);
vector<int> ans(n + 1);
for (int i = n; i >= 1; i--) {
ans[i] = query(1, 1, n, s[i]);
change(1, 1, n, ans[i]);
}
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
puts("");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
long long s[200001];
int used[200001];
long long stree[800001];
int result[200001];
long long update(int node, int l, int r, int index, long long diff) {
if (r < index || index < l) return stree[node];
if (r == l) {
stree[node] += diff;
return stree[node];
};
return stree[node] = update(node * 2, l, (l + r) / 2, index, diff) +
update(node * 2 + 1, (l + r) / 2 + 1, r, index, diff);
}
long long query(int node, int l, int r, int left, int right) {
if (r < left || l > right) return 0;
if (l >= left && r <= right) return stree[node];
return query(node * 2, l, (l + r) / 2, left, right) +
query(node * 2 + 1, (l + r) / 2 + 1, r, left, right);
}
int bsearch(long long c) {
int mi = 1;
int ma = n;
if (c == 0 && used[1] == 0) return 0;
while (mi + 1 < ma) {
int mid = (mi + ma) / 2;
long long res = query(1, 1, n, 1, mid);
if (res <= c)
mi = mid;
else
ma = mid;
}
return mi;
}
int main(void) {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
for (int i = 1; i <= n; i++) {
update(1, 1, n, i, i);
}
for (int i = n; i >= 1; i--) {
result[i] = bsearch(s[i]) + 1;
update(1, 1, n, result[i], -result[i]);
used[result[i]] = 1;
}
for (int i = 1; i <= n; i++) {
cout << result[i] << " ";
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool mini(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool maxi(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int N = 2e5 + 5;
int n, ans[N];
long long bit[N], p[N];
void up(int i, int val) {
assert(i > 0);
for (; i <= n; i += i & -i) bit[i] += val;
}
long long get(int i) {
long long res = 0;
for (; i; i -= i & -i) res += bit[i];
return res;
}
inline void sol() {
cin >> n;
for (int i = 0, _ = (n); i < _; i++) cin >> p[i], up(i + 1, i + 1);
for (int i = (int)(n)-1; i >= 0; --i) {
int l = 1, r = n, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (get(mid - 1) <= p[i])
l = mid;
else
r = mid - 1;
}
up(l, -l);
ans[i] = l;
}
for (int i = 0, _ = (n); i < _; i++) cout << ans[i] << ' ';
}
signed main() {
{ ios_base::sync_with_stdio(false), cin.tie(NULL); };
cout.precision(10);
cout << fixed;
sol();
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const long long INF = 1e18;
int n;
long long a[maxn], ans[maxn];
long long tree[maxn << 2], laz[maxn << 2];
void pushup(int rt) { tree[rt] = min(tree[rt << 1], tree[(rt << 1) | 1]); }
void build(int l, int r, int rt) {
if (l == r) {
tree[rt] = a[l];
return;
}
build(l, ((l + r) >> 1), 2 * rt);
build(((l + r) >> 1) + 1, r, 2 * rt + 1);
pushup(rt);
}
void change(int x, int l, int r, int rt) {
if (l == r) {
tree[rt] = INF;
return;
}
if (x <= ((l + r) >> 1))
change(x, l, ((l + r) >> 1), 2 * rt);
else
change(x, ((l + r) >> 1) + 1, r, 2 * rt + 1);
pushup(rt);
}
void pushdown(int rt) {
long long& x = laz[rt];
if (x) {
tree[rt << 1] += x;
tree[(rt << 1) | 1] += x;
laz[rt << 1] += x;
laz[(rt << 1) | 1] += x;
x = 0;
}
}
void update(int x, int ql, int qr, int l, int r, int rt) {
if (ql == l && qr == r) {
laz[rt] += x;
tree[rt] += x;
return;
}
pushdown(rt);
if (qr <= ((l + r) >> 1))
update(x, ql, qr, l, ((l + r) >> 1), 2 * rt);
else if (ql > ((l + r) >> 1))
update(x, ql, qr, ((l + r) >> 1) + 1, r, 2 * rt + 1);
else {
update(x, ql, ((l + r) >> 1), l, ((l + r) >> 1), 2 * rt);
update(x, ((l + r) >> 1) + 1, qr, ((l + r) >> 1) + 1, r, 2 * rt + 1);
}
pushup(rt);
}
int query(int l, int r, int rt) {
if (l == r) return l;
pushdown(rt);
if (tree[((l + r) >> 1) + 1, r, 2 * rt + 1] == 0)
return query(((l + r) >> 1) + 1, r, 2 * rt + 1);
else
return query(l, ((l + r) >> 1), 2 * rt);
}
int main() {
cin.sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
build(1, n, 1);
int t;
for (int i = 1; i <= n; i++) {
t = query(1, n, 1);
ans[t] = i;
change(t, 1, n, 1);
if (t != n) update(-i, t + 1, n, 1, n, 1);
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
inline long long minn(long long a, long long b) {
if (a < b) return a;
return b;
}
const int MAXN = 2e5 + 5;
const long long INF = 1ll << 60;
int n;
long long mi[MAXN << 2], tag[MAXN << 2];
inline void pushdwn(int k) {
mi[k << 1] -= tag[k];
tag[k << 1] += tag[k];
mi[k << 1 | 1] -= tag[k];
tag[k << 1 | 1] += tag[k];
tag[k] = 0;
}
inline void pushup(int k) { mi[k] = minn(mi[k << 1], mi[k << 1 | 1]); }
void bld(int k, int l, int r) {
if (l == r) {
scanf("%I64d", mi + k);
return;
}
int mid = l + r >> 1;
bld(k << 1, l, mid);
bld(k << 1 | 1, mid + 1, r);
pushup(k);
return;
}
int qx, qy, qv;
int Query(int k, int l, int r) {
if (l == r) return l;
pushdwn(k);
int mid = l + r >> 1;
if (!mi[k << 1 | 1]) return Query(k << 1 | 1, mid + 1, r);
return Query(k << 1, l, mid);
}
void Modify2(int k, int l, int r) {
if (l == r) {
if (mi[k] < 0) mi[k] = INF;
return;
}
pushdwn(k);
if (mi[k] < 0) {
int mid = l + r >> 1;
Modify2(k << 1, l, mid);
Modify2(k << 1 | 1, mid + 1, r);
pushup(k);
}
return;
}
void Modify(int k, int l, int r) {
if (qx <= l && r <= qy) {
mi[k] -= qv;
tag[k] += qv;
if (mi[k] < 0) {
if (l == r) {
mi[k] = INF;
return;
}
Modify2(k, l, r);
}
return;
}
pushdwn(k);
int mid = l + r >> 1;
if (qx <= mid) Modify(k << 1, l, mid);
if (mid < qy) Modify(k << 1 | 1, mid + 1, r);
pushup(k);
return;
}
int ans[MAXN];
int main() {
scanf("%d", &n);
bld(1, 1, n);
for (int i = 1; i <= n; i++) {
int t = Query(1, 1, n);
ans[t] = i;
qx = t, qy = n, qv = i;
Modify(1, 1, n);
}
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], i == n ? '\n' : ' ');
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct S {
int a, b;
S() {}
S(int _a, int _b) {
a = _a;
b = _b;
}
const bool operator<(const S &o) const { return a < o.a; }
};
string exm;
inline void exf(void) {
cout << exm << "\n";
exit(0);
}
template <typename T>
inline void showAll(vector<T> &v, string sep = "") {
for (T &here : v) cout << here << sep;
}
template <typename T>
inline void showAll(T arr[], int st, int end, string sep = "") {
for (int i = st; i <= end; i++) cout << arr[i] << sep;
}
template <typename T>
inline vector<int> int_seperation(T N, int d = 10) {
vector<int> v;
while (N) {
v.push_back(N % d);
N /= d;
}
reverse(v.begin(), v.end());
return v;
}
const int SIZE = 200009;
long long arr[SIZE], tree[SIZE * 8];
int ans[SIZE];
int n;
long long getSum(int i) {
long long res = 0;
while (i) {
res += tree[i];
i -= (i & -i);
}
return res;
}
void update(int i, long long a) {
while (i < n + 1) {
tree[i] += a;
i += (i & -i);
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &arr[i]);
}
for (int i = 1; i <= n; i++) {
update(i, i);
}
for (int i = n; i; i--) {
int l = 0, r = n + 1;
while (l + 1 < r) {
int mid = (l + r) / 2;
long long sum = getSum(mid) - getSum(0);
if (sum > arr[i])
r = mid;
else
l = mid;
}
ans[i] = l + 1;
update(l + 1, -l - 1);
}
showAll(ans, 1, n, " ");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
long long a[N];
pair<long long, long long> seg[4 * N];
void build(long long ind, long long l, long long r) {
if (l > r) return;
if (l == r) {
seg[ind] = {a[l], l};
return;
}
long long mid = (l + r) / 2;
build(2 * ind + 1, l, mid);
build(2 * ind + 2, mid + 1, r);
if (seg[2 * ind + 1].first < seg[2 * ind + 2].first)
seg[ind] = seg[2 * ind + 1];
else
seg[ind] = seg[2 * ind + 2];
}
long long lazy[4 * N];
void update(long long ind, long long l, long long r, long long lq, long long rq,
long long val) {
if (lazy[ind] != 0) {
seg[ind].first += lazy[ind];
if (l != r) {
lazy[ind * 2 + 1] += lazy[ind];
lazy[ind * 2 + 2] += lazy[ind];
}
lazy[ind] = 0;
}
if (l > r || r < lq || rq < l) return;
if (l >= lq && r <= rq) {
seg[ind].first += val;
if (l != r) {
lazy[ind * 2 + 1] += val;
lazy[ind * 2 + 2] += val;
}
return;
}
long long mid = (l + r) / 2;
update(2 * ind + 1, l, mid, lq, rq, val);
update(2 * ind + 2, mid + 1, r, lq, rq, val);
if (seg[2 * ind + 1].first < seg[2 * ind + 2].first)
seg[ind] = seg[2 * ind + 1];
else
seg[ind] = seg[2 * ind + 2];
}
pair<long long, long long> query(long long ind, long long l, long long r,
long long lq, long long rq) {
if (l > r || r < lq || rq < l) return {1000000007, 0};
if (lazy[ind] != 0) {
seg[ind].first += lazy[ind];
if (l != r) {
lazy[ind * 2 + 1] += lazy[ind];
lazy[ind * 2 + 2] += lazy[ind];
}
lazy[ind] = 0;
}
if (l >= lq && r <= rq) return seg[ind];
long long mid = (l + r) / 2;
pair<long long, long long> k1, k2;
k1 = query(2 * ind + 1, l, mid, lq, rq);
k2 = query(2 * ind + 2, mid + 1, r, lq, rq);
if (k1.first < k2.first)
return k1;
else
return k2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long n, i, k;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
build(0, 0, n - 1);
long long ans[n];
pair<long long, long long> x;
long long l;
k = 1;
for (i = 0; i < n; i++) {
x = query(0, 0, n - 1, 0, n - 1);
l = x.second;
ans[l] = k;
update(0, 0, n - 1, l, l, 1000000007000000);
update(0, 0, n - 1, l + 1, n - 1, -k);
k++;
}
for (i = 0; i < n; i++) cout << ans[i] << " ";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long s[200001], up[200001];
long long d[200001], c[200001];
long long ans[200001];
inline long long lowbit(long long x) { return x & -x; }
inline long long getup(long long x) {
long long ans = 0;
for (; x; x -= lowbit(x)) ans += c[x];
return ans;
}
inline void add(long long x, long long d) {
for (; x <= n; x += lowbit(x)) c[x] += d;
}
long long mybound(long long x) {
long long l = 1, r = n;
while (l < r) {
long long mid = (l + r + 1) >> 1;
if (getup(mid) <= x)
l = mid;
else
r = mid - 1;
}
return l;
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &s[i]);
for (long long i = 1; i <= n; i++) up[i] = up[i - 1] + i - 1;
for (long long i = 1; i <= n; i++) c[i] = up[i] - up[i - lowbit(i)];
for (long long i = n; i >= 1; i--) {
long long p = mybound(s[i]);
ans[i] = p;
add(p + 1, -p);
}
for (long long i = 1; i <= n; i++) printf("%lld ", ans[i]);
putchar('\n');
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
template <class T, class U>
inline void add_self(T &a, U b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
}
template <class T, class U>
inline void min_self(T &x, U y) {
if (y < x) x = y;
}
template <class T, class U>
inline void max_self(T &x, U y) {
if (y > x) x = y;
}
template <class T, class U>
inline void mul_self(T &x, U y) {
x *= y;
x %= mod;
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
cout << t;
;
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <class T, class U>
void print_m(const map<T, U> &m, int w = 3) {
if (m.empty()) {
cout << "Empty" << endl;
return;
}
for (auto x : m) cout << "(" << x.first << ": " << x.second << ")," << endl;
cout << endl;
}
template <class T, class U>
void debp(const pair<T, U> &pr, bool end_line = 1) {
cout << "{" << pr.first << " " << pr.second << "}";
cout << (end_line ? "\n" : ", ");
}
template <class T>
void print_vp(const T &vp, int sep_line = 0) {
if (vp.empty()) {
cout << "Empty" << endl;
return;
}
if (!sep_line) cout << "{ ";
for (auto x : vp) debp(x, sep_line);
if (!sep_line) cout << "}\n";
cout << endl;
}
template <typename T>
void print(const T &v, bool show_index = false) {
int w = 2;
if (show_index) {
for (int i = 0; i < int((v).size()); i++) cout << setw(w) << i << " ";
cout << endl;
}
for (auto &el : v) cout << setw(w) << el << " ";
cout << endl;
}
template <typename T>
void print_vv(const T &vv) {
if (int((vv).size()) == 0) {
cout << "Empty" << endl;
return;
}
int w = 3;
cout << setw(w) << " ";
for (int j = 0; j < int((*vv.begin()).size()); j++)
cout << setw(w) << j << " ";
cout << endl;
int i = 0;
for (auto &v : vv) {
cout << i++ << " {";
for (auto &el : v) cout << setw(w) << el << " ";
cout << "},\n";
}
cout << endl;
}
const long long inf = 1e15L;
struct node {
bool clazy = 0;
long long lazy = 0, mn = inf;
node(){};
node(long long v) : mn(v){};
};
class SegmentTree {
public:
int n;
vector<node> st;
SegmentTree(vector<long long> &a) {
n = int((a).size());
st.resize(8 * n);
build(1, 0, n - 1, a);
}
node merge(node &l, node &r) {
node cur;
cur.mn = min(l.mn, r.mn);
return cur;
}
void build(int pos, int l, int r, vector<long long> &a) {
if (l == r) {
st[pos] = node(a[l]);
return;
}
int mid = (l + r) / 2;
build(2 * pos, l, mid, a);
build(2 * pos + 1, mid + 1, r, a);
st[pos] = merge(st[2 * pos], st[2 * pos + 1]);
}
void update(int pos, int sl, int sr, int l, int r, long long val) {
propagate(pos, sl, sr);
if (r < sl || sr < l)
return;
else if (l <= sl && sr <= r) {
st[pos].clazy = 1;
st[pos].lazy = val;
propagate(pos, sl, sr);
return;
}
int mid = (sl + sr) / 2;
update(2 * pos, sl, mid, l, r, val);
update(2 * pos + 1, mid + 1, sr, l, r, val);
st[pos] = merge(st[2 * pos], st[2 * pos + 1]);
}
int query(int pos, int sl, int sr) {
propagate(pos, sl, sr);
if (sl == sr) return sl;
int mid = (sl + sr) / 2;
propagate(2 * pos, sl, mid);
propagate(2 * pos + 1, mid + 1, sr);
if (st[2 * pos + 1].mn == 0) return query(2 * pos + 1, mid + 1, sr);
return query(2 * pos, sl, mid);
}
void propagate(int pos, int sl, int sr) {
if (!st[pos].clazy) return;
if (sl != sr) {
st[2 * pos].lazy += st[pos].lazy;
st[2 * pos + 1].lazy += st[pos].lazy;
st[2 * pos].clazy = st[2 * pos + 1].clazy = 1;
}
st[pos].mn += st[pos].lazy;
st[pos].lazy = st[pos].clazy = 0;
}
void update(int l, int r, long long v) {
if (l > r) return;
update(1, 0, n - 1, l, r, v);
}
int query() { return query(1, 0, n - 1); }
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
while (cin >> n) {
vector<long long> a(n);
for (int i = 0; i < int(n); i++) cin >> a[i];
SegmentTree st(a);
vector<int> out(n);
for (int i = int(1); i < int(n + 1); i++) {
int idx = st.query();
out[idx] = i;
st.update(idx, idx, inf);
st.update(idx + 1, n - 1, -i);
}
print(out);
}
return 0;
}
| 10 | CPP |
from sys import setrecursionlimit as SRL, stdin
SRL(10 ** 7)
rd = stdin.readline
rrd = lambda: map(int, rd().strip().split())
n = int(rd())
bit = [0] * 200005
def add(x, val):
while x <= n:
bit[x] += val
x += (x & -x)
def query(x):
num = 0
for i in range(30, -1, -1):
if num+(1 << i) <= n and bit[num + (1 << i)] <= x:
x -= bit[num + (1 << i)]
num += (1 << i)
return num + 1
for i in range(1, n + 1):
add(i, i)
s = list(rrd())
ans = []
for i in range(len(s) - 1, -1, -1):
q = query(s[i])
ans.append(q)
add(q, -q)
ans = ans[::-1]
print(*ans) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 10;
const long long inf = 1e15 + 10;
const long long mod = 1e9 + 7;
set<int> s;
long long a[M], ans[M];
long long sum[4 * M], lazy[4 * M];
int v[M * 4];
void pushup(int x) { sum[x] = min(sum[x << 1], sum[x << 1 | 1]); }
void built(int l, int r, int i) {
if (l == r) {
sum[i] = a[l];
return;
}
int mid = l + r >> 1;
built(l, mid, i << 1);
built(mid + 1, r, i << 1 | 1);
pushup(i);
}
void pp(int i) {
if (lazy[i]) {
sum[i << 1] -= lazy[i];
sum[i << 1 | 1] -= lazy[i];
lazy[i << 1] += lazy[i];
lazy[i << 1 | 1] += lazy[i];
lazy[i] = 0;
}
}
void add(int l, int r, int x, int y, long long va, int i) {
if (l >= x && r <= y) {
sum[i] -= va;
lazy[i] += va;
return;
}
pp(i);
int mid = l + r >> 1;
if (x <= mid) add(l, mid, x, y, va, i << 1);
if (y > mid) add(mid + 1, r, x, y, va, i << 1 | 1);
pushup(i);
}
long long query(int l, int r, int i) {
if (l == r) {
return l;
}
pp(i);
int mid = l + r >> 1, k;
if (sum[i << 1] < sum[i << 1 | 1])
k = query(l, mid, i << 1);
else
k = query(mid + 1, r, i << 1 | 1);
return k;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
built(1, n, 1);
for (int i = 1; i <= n; i++) {
int pos = query(1, n, 1);
ans[pos] = i;
add(1, n, pos, pos, -inf, 1);
add(1, n, pos + 1, n, i, 1);
}
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MN = 200010;
int n;
long long ft[MN];
void update(int pos, long long by) {
while (pos < n) ft[pos] += by, pos |= pos + 1;
}
long long query(int pos) {
long long ans = 0;
while (pos >= 0) ans += ft[pos], pos = (pos & (pos + 1)) - 1;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) update(i, i);
vector<int> ans(n);
for (int i = n - 1; i >= 0; i--) {
int lo = 0, hi = n;
while (hi - lo > 1) {
int mi = (hi + lo) / 2;
if (query(mi) <= a[i])
lo = mi;
else
hi = mi;
}
update(lo + 1, -lo - 1);
ans[i] = lo;
}
for (int i = 0; i < n; i++) cout << ans[i] + 1 << " ";
cout << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, p[200005], mnpos[1 << 19];
long long s[200005], mn[1 << 19], add[1 << 19];
void pushup(int u) {
mn[u] = mn[u << 1 | 1], mnpos[u] = mnpos[u << 1 | 1];
if (mn[u << 1] < mn[u]) mn[u] = mn[u << 1], mnpos[u] = mnpos[u << 1];
}
void build(int u, int l, int r) {
if (l == r) {
mn[u] = s[l];
mnpos[u] = l;
return;
}
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushup(u);
}
void upd(int u, long long v) { add[u] += v, mn[u] += v; }
void pushdown(int u) {
if (add[u]) {
upd(u << 1, add[u]);
upd(u << 1 | 1, add[u]);
add[u] = 0;
}
}
void update(int u, int l, int r, int ql, int qr, long long v) {
if (l >= ql && r <= qr) {
upd(u, v);
return;
}
int mid = l + r >> 1;
pushdown(u);
if (ql <= mid) update(u << 1, l, mid, ql, qr, v);
if (qr > mid) update(u << 1 | 1, mid + 1, r, ql, qr, v);
pushup(u);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", s + i);
build(1, 1, n);
for (int i = 1; i <= n; ++i) {
int x = mnpos[1];
p[x] = i;
update(1, 1, n, x, x, 1LL << 40);
if (x + 1 <= n) update(1, 1, n, x + 1, n, -i);
}
for (int i = 1; i <= n; ++i) printf("%d ", p[i]);
puts("");
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
long long pre[N] = {};
void add(long long p, long long x) {
for (long long i = p; i <= N; i += (i & -i)) pre[i] += x;
}
long long query(long long p) {
long long ans = 0;
for (long long i = p; i > 0; i -= i & (-i)) ans += pre[i];
return ans;
}
int main() {
long long n;
cin >> n;
long long x[n], ans[n];
for (long long i = 1; i <= n; i++) add(i, i);
for (long long i = 0; i < n; i++) cin >> x[i];
for (long long i = n - 1; i >= 0; i--) {
long long l = 0, r = n, mid;
while (l < r) {
mid = l + r >> 1;
if (query(mid) <= x[i])
l = mid + 1;
else
r = mid;
}
ans[i] = l;
add(l, -l);
}
for (long long i : ans) cout << i << ' ';
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve();
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t = 1;
for (int i = 1; i <= t; ++i) solve();
cerr << "Time taken: " << ((clock() * 1000) / CLOCKS_PER_SEC) << "ms\n";
}
const long long int N = 2e5 + 2;
long long int t[4 * N];
long long int lazy[4 * N];
long long int a[N];
long long int n;
void init() { memset(lazy, 0, sizeof(lazy)); }
void upd(long long int node, long long int l, long long int r,
long long int x) {
lazy[node] += x;
t[node] += x;
return;
}
void passDown(long long int node, long long int l, long long int r) {
long long int mid = (l + r) / 2;
upd(2 * node, l, mid, lazy[node]);
upd(2 * node + 1, mid + 1, r, lazy[node]);
lazy[node] = 0;
}
void build(long long int node = 1, long long int tl = 0,
long long int tr = n - 1) {
if (tl > tr) {
return;
}
if (tl == tr) {
t[node] = a[tl];
return;
}
long long int mid = (tl + tr) / 2;
build(2 * node, tl, mid);
build(2 * node + 1, mid + 1, tr);
t[node] = min(t[2 * node], t[2 * node + 1]);
}
void updateRange(long long int l, long long int r, long long int val,
long long int node = 1, long long int tl = 0,
long long int tr = n - 1) {
if (r < l or l > tr or tl > r or tl > tr) {
return;
}
if (l <= tl and tr <= r) {
upd(node, tl, tr, val);
return;
}
passDown(node, tl, tr);
long long int mid = (tl + tr) / 2;
updateRange(l, r, val, 2 * node, tl, mid);
updateRange(l, r, val, 2 * node + 1, mid + 1, tr);
t[node] = min(t[2 * node], t[2 * node + 1]);
}
long long int queryRange(long long int l, long long int r,
long long int node = 1, long long int tl = 0,
long long int tr = n - 1) {
if (r < l or tr < tl or l > tr or tl > r) {
return 0;
}
if (tl == tr) {
return tl;
}
passDown(node, tl, tr);
long long int mid = (tl + tr) / 2;
if (t[2 * node + 1])
return queryRange(l, r, 2 * node, tl, mid);
else
return queryRange(l, r, 2 * node + 1, mid + 1, tr);
}
void solve() {
cin >> n;
std::vector<long long int> ans(n);
for (long long int i = 0; i < n; ++i) {
cin >> a[i];
}
init();
build();
for (long long int i = 0; i < n; ++i) {
long long int pos = queryRange(0, n - 1);
ans[pos] = i + 1;
updateRange(pos + 1, n - 1, -(i + 1));
updateRange(pos, pos, 1e14);
}
for (long long int i = 0; i < n; ++i) {
cout << ans[i] << " ";
}
cout << '\n';
}
| 10 | CPP |
def sumsegtree(l,seg,st,en,x):
if st==en:
seg[x]=l[st]
else:
mid=(st+en)>>1
sumsegtree(l,seg,st,mid,2*x)
sumsegtree(l,seg,mid+1,en,2*x+1)
seg[x]=seg[2*x]+seg[2*x+1]
def query(seg,st,en,val,x):
if st==en:
return seg[x]
mid=(st+en)>>1
if seg[2*x]>=val:
return query(seg,st,mid,val,2*x)
return query(seg,mid+1,en,val-seg[2*x],2*x+1)
def upd(seg,st,en,ind,val,x):
if st==en:
seg[x]=val
return
mid=(st+en)>>1
if mid>=ind:
upd(seg,st,mid,ind,val,2*x)
else:
upd(seg,mid+1,en,ind,val,2*x+1)
seg[x]=seg[2*x]+seg[2*x+1]
n=int(input())
l=list(map(int,range(1,n+1)))
s=[0]*n
p=list(map(int,input().split()))
seg=["#"]*(n<<2)
sumsegtree(l,seg,0,len(l)-1,1)
for i in range(len(p)-1,-1,-1):
s[i]=query(seg,1,n,p[i]+1,1)
upd(seg,1,n,s[i],0,1)
print (*s) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct BIT {
int n, N_MAX;
vector<long long> v;
BIT(int n) {
this->n = n + 100;
N_MAX = n;
v.assign(n + 110, 0);
}
void upd(int p, int x) {
while (p <= n) v[p] += x, p += p & -p;
}
long long que(int p) {
long long ans = 0;
while (p) ans += v[p], p -= p & -p;
return ans;
}
long long quep(int p) { return que(p) - que(p - 1); }
long long bit_search(long long s) {
long long sum = 0, pos = 0;
for (int i = 21; i >= 0; i--)
if (pos + (1 << i) <= N_MAX && sum + v[pos + (1 << i)] <= s) {
pos += (1 << i);
sum += v[pos];
}
return pos + 1;
}
};
int main() {
int n;
scanf("%d", &n);
BIT bit(n);
vector<long long> v(n + 1), ans(n + 1);
for (int i = 1; i <= n; i++) scanf("%lld", &v[i]), bit.upd(i, i);
for (int i = n; i; i--) {
int p = bit.bit_search(v[i]);
ans[i] = p;
bit.upd(p, -p);
}
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
printf("\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const long long inf = 1e14;
int n;
long long a[maxn], ans[maxn];
struct SegmentTree {
long long tr[maxn << 2], tag[maxn << 2];
void pushup(int rt) { tr[rt] = min(tr[rt << 1], tr[rt << 1 | 1]); }
void build(int rt, int l, int r) {
tag[rt] = 0;
if (l == r) {
tr[rt] = a[l];
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
void load(int rt, long long k) {
tr[rt] += k;
tag[rt] += k;
}
void pushdown(int rt) {
load(rt << 1, tag[rt]);
load(rt << 1 | 1, tag[rt]);
tag[rt] = 0;
}
void update(int nl, int nr, int l, int r, int rt, long long k) {
if (nl > nr) return;
if (nl <= l && nr >= r) {
load(rt, k);
return;
}
int mid = (l + r) >> 1;
pushdown(rt);
if (nl <= mid) update(nl, nr, l, mid, rt << 1, k);
if (nr >= mid + 1) update(nl, nr, mid + 1, r, rt << 1 | 1, k);
pushup(rt);
}
} seg2;
int pos;
void get_pos2(int rt, int l, int r) {
if (l == r) {
pos = l;
return;
}
seg2.pushdown(rt);
int mid = (l + r) >> 1;
if (seg2.tr[rt << 1 | 1] <= 0)
get_pos2(rt << 1 | 1, mid + 1, r);
else
get_pos2(rt << 1, l, mid);
seg2.pushup(rt);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", a + i);
seg2.build(1, 1, n);
for (int x = 1; x <= n; x++) {
get_pos2(1, 1, n);
ans[pos] = x;
seg2.update(pos, pos, 1, n, 1, inf);
seg2.update(pos + 1, n, 1, n, 1, -x);
}
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ '0');
ch = getchar();
}
return x * f;
}
namespace BIT {
long long C[1000005];
inline void Add(long long x, long long val) {
for (register long long i = x; i < 1000005; i += (i & (-i))) {
C[i] += val;
}
}
inline long long Query(long long x) {
long long ans = 0;
for (register long long i = x; i > 0; i -= (i & (-i))) {
ans += C[i];
}
return ans;
}
}; // namespace BIT
using namespace BIT;
long long a[1000005], n;
inline long long BinSearch(long long pos) {
long long l = 0, r = 1000005 - 1, ans;
while (l < r - 1) {
long long mid = (l + r) >> 1;
if (Query(mid) <= a[pos])
l = mid;
else
r = mid;
}
return r;
}
long long ans[1000005];
int main() {
n = read();
for (register long long i = 1; i <= n; ++i) a[i] = read();
for (register long long i = 1; i <= n; ++i) {
Add(i, i);
}
for (register long long i = n; i >= 1; --i) {
long long pos = BinSearch(i);
Add(pos, -pos);
ans[i] = pos;
}
for (register long long i = 1; i <= n; ++i) {
printf("%I64d ", ans[i]);
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long BIT[N], s[N];
int n;
int ans[N];
void update(int x, int delta) {
for (; x <= n; x += x & -x) BIT[x] += delta;
}
long long query(int x) {
long long sum = 0;
for (; x > 0; x -= x & -x) sum += BIT[x];
return sum;
}
int searchNumber(long long prefSum) {
int num = 0;
long long sum = 0;
for (int i = 21; i >= 0; --i) {
if ((num + (1 << i) <= n) && (sum + BIT[num + (1 << i)] <= prefSum)) {
num += (1 << i);
sum += BIT[num];
}
}
return num + 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
update(i, i);
scanf("%I64d", &s[i]);
}
for (int i = n; i >= 1; --i) {
ans[i] = searchNumber(s[i]);
update(ans[i], -ans[i]);
}
for (int i = 1; i <= n; ++i) {
printf("%d", ans[i]);
if (i < n) {
printf(" ");
} else
printf("\n");
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
bool minimize(X &x, const Y &y) {
X eps = 1e-9;
if (x > y + eps) {
x = y;
return true;
} else
return false;
}
template <class X, class Y>
bool maximize(X &x, const Y &y) {
X eps = 1e-9;
if (x + eps < y) {
x = y;
return true;
} else
return false;
}
template <class T>
T Abs(const T &x) {
return (x < 0 ? -x : x);
}
class SegmentTree {
private:
int n;
vector<pair<long long, int>> tree;
vector<long long> lazy;
void build(long long a[], int i, int l, int r) {
if (l == r) {
tree[i] = make_pair(a[l], -l);
return;
}
int m = (l + r) >> 1;
build(a, 2 * i, l, m);
build(a, 2 * i + 1, m + 1, r);
tree[i] = min(tree[2 * i], tree[2 * i + 1]);
}
void pushDown(int i) {
for (int j = (2 * i), _b = (2 * i + 1); j <= _b; j++) {
tree[j].first += lazy[i];
lazy[j] += lazy[i];
}
lazy[i] = 0;
}
void update(int i, int l, int r, int u, int v, long long c) {
if (l > v || r < u || l > r || v < u) return;
if (u <= l && r <= v) {
tree[i].first += c;
lazy[i] += c;
return;
}
pushDown(i);
int m = (l + r) >> 1;
update(2 * i, l, m, u, v, c);
update(2 * i + 1, m + 1, r, u, v, c);
tree[i] = min(tree[2 * i], tree[2 * i + 1]);
}
public:
SegmentTree(int n = 0, long long a[] = NULL) {
this->n = n;
if (n > 0) {
tree.assign(4 * n + 7, pair<long long, int>());
lazy.assign(4 * n + 7, 0);
build(a, 1, 1, n);
}
}
void update(int l, int r, long long c) { update(1, 1, n, l, r, c); }
int getZeroPos(void) const {
return tree[1].first == 0 ? -tree[1].second : -1;
}
};
const long long INF = (long long)1e18 + 7LL;
long long a[200200];
int perm[200200], n;
void process(void) {
cin >> n;
for (int i = (1), _b = (n); i <= _b; i++) cin >> a[i];
SegmentTree myit(n, a);
for (int i = (1), _b = (n); i <= _b; i++) {
int pos = myit.getZeroPos();
assert(pos > 0);
perm[pos] = i;
myit.update(pos + 1, n, -i);
myit.update(pos, pos, INF);
}
for (int i = (1), _b = (n); i <= _b; i++) printf("%d ", perm[i]);
printf("\n");
}
int main(void) {
process();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long s[200010];
long long a[200010];
long long cnt[200010];
long long p[200010];
long long lb(long long x) { return x & (-x); }
void ins(int x, int y) {
for (long long i = x; i <= n; i += lb(i)) {
p[i] += y;
}
return;
}
long long gs(int x) {
long long sum = 0;
for (long long i = x; i > 0; i -= lb(i)) {
sum += p[i];
}
return sum;
}
int re(long long x) {
int l = 1, r = n;
while (l < r) {
int mid = (l + r + 1) / 2;
long long tmp = gs(mid - 1);
if (tmp > x)
r = mid - 1;
else
l = mid;
}
return r;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
int i, j;
for (i = 1; i <= n; i++) {
cin >> s[i];
ins(i, i);
}
for (i = n; i > 0; i--) {
a[i] = re(s[i]);
ins(a[i], -a[i]);
}
for (i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long dx[] = {1, 0, -1, 0};
long long dy[] = {0, 1, 0, -1};
long long gcd(long long x, long long y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
long long expo(long long n, long long m, long long p) {
long long r = 1;
n = n % p;
while (m > 0) {
if (m % 2) r = (r * n) % p;
n = (n * n) % p;
m = m / 2;
}
return r % p;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long lazy[2000005];
vector<long long> a;
struct node {
long long val;
long long ind;
};
node seg[2000005];
void build(long long m, long long s, long long e) {
node t;
if (s > e) return;
if (s == e) {
t.val = a[s];
t.ind = s;
seg[m] = t;
return;
}
long long mid = (s + e) / 2;
build(2 * m, s, mid);
build(2 * m + 1, mid + 1, e);
seg[m].val = min(seg[2 * m].val, seg[2 * m + 1].val);
if (seg[2 * m].val >= seg[2 * m + 1].val)
seg[m].ind = seg[2 * m + 1].ind;
else
seg[m].ind = seg[2 * m].ind;
}
void update(long long m, long long s, long long e, long long l, long long r,
long long v) {
if (lazy[m] != 0) {
seg[m].val = seg[m].val + lazy[m];
if (s != e) {
lazy[2 * m] += lazy[m];
lazy[2 * m + 1] += lazy[m];
}
lazy[m] = 0;
}
if (s > e || s > r || e < l || r < l) return;
if (s >= l && e <= r) {
seg[m].val += v;
if (s != e) {
lazy[2 * m] += v;
lazy[2 * m + 1] += v;
}
return;
}
long long mid = (s + e) / 2;
update(2 * m, s, mid, l, r, v);
update(2 * m + 1, mid + 1, e, l, r, v);
seg[m].val = min(seg[2 * m].val, seg[2 * m + 1].val);
if (seg[2 * m].val >= seg[2 * m + 1].val)
seg[m].ind = seg[2 * m + 1].ind;
else
seg[m].ind = seg[2 * m].ind;
}
node query(long long m, long long s, long long e, long long l, long long r) {
if (lazy[m] != 0) {
seg[m].val = seg[m].val + lazy[m];
if (s != e) {
lazy[2 * m] += lazy[m];
lazy[2 * m + 1] += lazy[m];
}
lazy[m] = 0;
}
node x, y, t;
x.ind = -1;
if (s > e || s > r || e < l) return x;
if (s >= l && e <= r) {
return seg[m];
}
long long mid = (s + e) / 2;
x = query(2 * m, s, mid, l, r);
y = query(2 * m + 1, mid + 1, e, l, r);
t.val = min(x.val, y.val);
if (x.val >= y.val) {
t.ind = y.ind;
} else {
t.ind = x.ind;
}
return t;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
a.push_back(x);
}
build(1, 0, n - 1);
vector<long long> ans(n);
for (long long i = 1; i <= n; i++) {
node t = query(1, 0, n - 1, 0, n - 1);
ans[t.ind] = i;
update(1, 0, n - 1, t.ind, t.ind, (1LL << 61));
update(1, 0, n - 1, t.ind + 1, n - 1, -i);
}
for (long long i = 0; i < n; i++) cout << ans[i] << ' ';
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long arr[N];
int n;
int lowbit(int x) { return x & -x; }
void addv(int p, long long val) {
while (p <= n) {
arr[p] += val;
p += lowbit(p);
}
}
void add(int l, int r, long long val) {
addv(l, val);
addv(r + 1, -val);
}
long long get(int p) {
long long res = 0;
while (p) {
res += arr[p];
p -= lowbit(p);
}
return res;
}
long long search(long long val) {
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) / 2;
if (get(mid) <= val)
l = mid + 1;
else
r = mid - 1;
}
return r;
}
long long sum[N];
long long ans[N];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> sum[i];
add(i + 1, n, i);
}
for (int i = n; i >= 1; i--) {
ans[i] = search(sum[i]);
add(ans[i] + 1, n, -ans[i]);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Node {
long long l, r, rt, lz, minn, maxx;
} node[1008611];
long long a[200861], sum[400861];
long long ans[200861];
void build(long long l, long long r, long long rt) {
long long mid = (l + r) / 2;
node[rt].l = l, node[rt].r = r;
node[rt].lz = 0;
if (l == r) {
node[rt].minn = sum[l];
node[rt].maxx = sum[l];
return;
}
build(l, mid, rt * 2);
build(mid + 1, r, rt * 2 + 1);
node[rt].minn = min(node[rt * 2].minn, node[rt * 2 + 1].minn);
node[rt].maxx = max(node[rt * 2].maxx, node[rt * 2 + 1].maxx);
}
void push_down(long long rt) {
if (node[rt].lz) {
node[rt * 2].minn -= node[rt].lz;
node[rt * 2 + 1].minn -= node[rt].lz;
node[rt * 2].maxx -= node[rt].lz;
node[rt * 2 + 1].maxx -= node[rt].lz;
node[rt * 2].lz += node[rt].lz;
node[rt * 2 + 1].lz += node[rt].lz;
node[rt].lz = 0;
}
}
long long query(long long v, long long rt) {
if (node[rt].l == node[rt].r) {
return node[rt].r + 1;
}
push_down(rt);
if (node[rt * 2 + 1].minn <= v) {
return query(v, rt * 2 + 1);
} else if (node[rt * 2].maxx >= v) {
return query(v, rt * 2);
}
node[rt].minn = min(node[rt * 2].minn, node[rt * 2 + 1].minn);
node[rt].maxx = max(node[rt * 2].maxx, node[rt * 2 + 1].maxx);
}
void update(long long l, long long r, long long v, long long rt) {
long long mid = (node[rt].l + node[rt].r) / 2;
if (node[rt].l == l && node[rt].r == r) {
node[rt].lz += v;
node[rt].minn -= v;
node[rt].maxx -= v;
return;
}
push_down(rt);
if (r <= mid) {
update(l, r, v, rt * 2);
} else if (l > mid) {
update(l, r, v, rt * 2 + 1);
} else {
update(l, mid, v, rt * 2);
update(mid + 1, r, v, rt * 2 + 1);
}
node[rt].minn = min(node[rt * 2].minn, node[rt * 2 + 1].minn);
node[rt].maxx = max(node[rt * 2].maxx, node[rt * 2 + 1].maxx);
}
int main() {
long long n, i, j;
scanf("%lld", &n);
sum[0] = 0;
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
sum[i] = sum[i - 1] + i;
}
build(0, n, 1);
for (i = n; i >= 1; i--) {
ans[i] = query(a[i], 1);
update(ans[i], n, ans[i], 1);
}
for (i = 1; i <= n; i++) {
if (i == n)
printf("%lld\n", ans[i]);
else if (i < n) {
printf("%lld ", ans[i]);
}
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const int MAXN = 2e5 + 20;
const int SIZE = (1 << 19) + 20;
long long s[MAXN];
int ans[MAXN];
struct Segment_tree {
struct Node {
int sl, sr;
long long val;
} tree[SIZE];
inline void update(int root) {
tree[root].val = tree[(root << 1)].val + tree[(root << 1 | 1)].val;
}
inline void build(int root, int l, int r) {
tree[root].sl = l;
tree[root].sr = r;
if (l == r) {
tree[root].val = l;
return;
}
build((root << 1), l, ((tree[root].sl + tree[root].sr) >> 1));
build((root << 1 | 1), ((tree[root].sl + tree[root].sr) >> 1) + 1, r);
update(root);
}
inline int find(int root, long long v) {
if (tree[root].sl == tree[root].sr) {
tree[root].val = 0;
return tree[root].sl;
}
int res = 0;
if (tree[(root << 1)].val > v) {
res = find((root << 1), v);
} else {
res = find((root << 1 | 1), v - tree[(root << 1)].val);
}
update(root);
return res;
}
} Tree;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int n;
cin >> n;
for (register int i = (1); i <= (n); ++i) {
cin >> s[i];
}
Tree.build(1, 1, n);
for (register int i = (n); i >= (1); --i) {
ans[i] = Tree.find(1, s[i]);
}
for (register int i = (1); i <= (n); ++i) {
cout << ans[i] << ' ';
}
cout << '\n';
return 0;
}
| 10 | CPP |
from operator import add
class Stree:
def __init__(self, f, n, default, init_data):
self.ln = 2**(n-1).bit_length()
self.data = [default] * (self.ln * 2)
self.f = f
for i, d in init_data.items():
self.data[self.ln + i] = d
for j in range(self.ln - 1, 0, -1):
self.data[j] = f(self.data[j*2], self.data[j*2+1])
def update(self, i, a):
p = self.ln + i
self.data[p] = a
while p > 1:
p = p // 2
self.data[p] = self.f(self.data[p*2], self.data[p*2+1])
def get(self, i, j):
def _get(l, r, p):
if i <= l and j >= r:
return self.data[p]
else:
m = (l+r)//2
if j <= m:
return _get(l, m, p*2)
elif i >= m:
return _get(m, r, p*2+1)
else:
return self.f(_get(l, m, p*2), _get(m, r, p*2+1))
return _get(0, self.ln, 1)
def find_value(self, v):
def _find_value(l, r, p, v):
if r == l+1:
return l
elif self.data[p*2] <= v:
return _find_value((l+r)//2, r, p*2+1, v - self.data[p*2])
else:
return _find_value(l, (l+r)//2, p*2, v)
return _find_value(0, self.ln, 1, v)
def main():
n = int(input())
sums = {i:i for i in range(n+1)}
stree = Stree(add, n+1, 0, sums)
ss = list(map(int, input().split()))
ss.reverse()
pp = []
for s in ss:
sval = stree.find_value(s)
pp.append(sval)
stree.update(sval,0)
print(*(reversed(pp)))
if __name__ == "__main__":
main() | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool tomin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <class T>
bool tomax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
template <class T>
void read(T &x) {
char c;
x = 0;
int f = 1;
while (c = getchar(), c < '0' || c > '9')
if (c == '-') f = -1;
do x = (x << 3) + (x << 1) + (c ^ 48);
while (c = getchar(), c >= '0' && c <= '9');
x *= f;
}
bool mem1;
const double Pi = acos(-1);
const int maxn = 2e5 + 5;
int n;
long long A[maxn];
int ans[maxn];
long long c[maxn];
void Add(int x, int v) {
while (x <= n) {
c[x] += v;
x += x & -x;
}
}
long long query(int x) {
long long res = 0;
while (x) {
res += c[x];
x &= x - 1;
}
return res;
}
bool mem2;
int main() {
srand(time(NULL));
read(n);
for (int i = 1, i_ = n; i <= i_; ++i) read(A[i]);
for (int i = 1, i_ = n; i <= i_; ++i) Add(i, i);
for (int i = n, i_ = 1; i >= i_; --i) {
int L = 0, R = n - 1, mid, res;
while (L <= R) {
if (query(mid = L + R >> 1) <= A[i])
L = (res = mid) + 1;
else
R = mid - 1;
}
ans[i] = res + 1;
Add(ans[i], -ans[i]);
}
for (int i = 1, i_ = n; i <= i_; ++i) printf("%d ", ans[i]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int bit[200005];
int n;
void update(int j, int x) {
for (; j < 200005; j += j & (-j)) bit[j] += x;
}
long long int query(int j) {
if (j == 0) return 0;
long long int x = 0;
for (; j > 0; j -= (j) & (-j)) x += bit[j];
return x;
}
int next_ele(long long int s) {
int l, r, m;
long long int q;
l = 0, r = n;
while (l < r) {
m = (l + r) / 2;
if (query(m) > s)
r = m;
else
l = m + 1;
}
return l;
}
int compute(long long int s) {
int x;
s *= 2;
x = sqrt(s);
return x + 1;
}
int main() {
int i;
scanf("%d", &n);
vector<long long int> sum(n);
for (i = 0; i < n; i++) cin >> sum[i];
vector<int> ans(n);
ans[n - 1] = compute(sum[n - 1]);
for (i = 1; i < n + 1; i++) update(i, i);
update(ans[n - 1], -ans[n - 1]);
for (i = n - 2; i >= 0; i--) {
ans[i] = next_ele(sum[i]);
update(ans[i], -ans[i]);
}
for (i = 0; i < n; i++) printf("%d ", ans[i]);
printf("\n");
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mxN = 2e5 + 10;
long long a[mxN], v[mxN];
long long N;
long long ans[mxN];
void upd(long long x, long long v) {
for (long long i = x; i <= N; i += i & -i) a[i] += v;
}
long long sum(long long x) {
long long S = 0;
for (long long i = x; i; i -= i & -i) S += a[i];
return S;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N;
for (long long i = 1; i <= N; ++i) {
cin >> v[i];
upd(i, i);
}
for (long long i = N; i; --i) {
long long hi = N, lo = 1;
while (lo < hi) {
long long mid = (lo + hi) >> 1;
long long x = sum(mid);
if (x <= v[i])
lo = mid + 1;
else
hi = mid;
}
ans[i] = lo;
upd(lo, -lo);
}
for (int i = 1; i <= N; ++i) cout << ans[i] << " \n"[i == N];
}
| 10 | CPP |
_ = input()
x = [int(i) for i in input().split()]
res = []
from math import log
class SegmentTree(object):
def __init__(self, nums):
self.arr = nums
self.l = len(nums)
self.tree = [0] * self.l + nums
for i in range(self.l - 1, 0, -1):
self.tree[i] = self.tree[i << 1] + self.tree[i << 1 | 1]
def update(self, i, val):
n = self.l + i
self.tree[n] = val
while n > 1:
self.tree[n >> 1] = self.tree[n] + self.tree[n ^ 1]
n >>= 1
def query(self, i, j):
m = self.l + i
n = self.l + j
res = 0
while m <= n:
if m & 1:
res += self.tree[m]
m += 1
m >>= 1
if n & 1 == 0:
res += self.tree[n]
n -= 1
n >>= 1
return res
tree = SegmentTree(list(range(1, len(x) + 1)))
org = len(x)
while x:
q = x.pop()
lo = 0
hi = org - 1
while lo < hi:
mid = (lo + hi) // 2
# print(lo, hi, mid)
sm = tree.query(0, mid)
# print(sm, mid)
if sm > q:
hi = mid
else:
lo = mid + 1
# print(tree.arr, lo, hi)
idx = tree.arr[lo]
# print(idx)
tree.update(lo, 0)
res.append(idx)
print(' '.join(str(i) for i in res[::-1])) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
class fenwicktree {
public:
long long n;
long long b[200005];
fenwicktree(long long N) {
n = N;
for (long long i = 0; i <= n; i++) b[i] = 0;
}
long long sum(long long idx) {
long long ret = 0;
for (idx; idx > 0; idx -= (idx & -idx)) ret += b[idx];
return ret;
}
void add(long long idx, long long delta) {
for (idx; idx <= n; idx += (idx & -idx)) b[idx] += delta;
}
};
long long bin(long long l, long long r, long long x, fenwicktree &f) {
while (l < r) {
long long mid = (l + r + 1) / 2;
if (f.sum(mid) <= x)
l = mid;
else
r = mid - 1;
}
return l + 1;
}
void solve() {
cin >> n;
fenwicktree f(n + 5);
for (long long i = 1; i <= n; i++) f.add(i, i);
long long a[200005];
long long res[200005];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = n - 1; i >= 0; i--) {
long long x = bin(0, n - 1, a[i], f);
res[i] = x;
f.add(x, -x);
}
for (long long i = 0; i < n; i++) cout << res[i] << " ";
cout << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) solve();
}
| 10 | CPP |
#include <bits/stdc++.h>
const int N = 1e6 + 10;
const long long int INF = 1e18;
const int MOD = 998244353;
const int lgN = 20;
using namespace std;
long long int tree[4 * N], lz[4 * N], v[N], w[N];
void build(int node, int st, int en) {
lz[node] = 0;
if (st == en) {
tree[node] = v[st];
return;
}
int m = (st + en) / 2;
build(2 * node + 1, st, m);
build(2 * node + 2, m + 1, en);
tree[node] = min(tree[2 * node + 1], tree[2 * node + 2]);
}
void pushdown(int node, int st, int en) {
if (lz[node] > 0) {
tree[node] -= lz[node];
if (st < en) {
lz[2 * node + 1] += lz[node];
lz[2 * node + 2] += lz[node];
}
lz[node] = 0;
}
}
void pupd(int pos, long long int val, int node, int st, int en) {
pushdown(node, st, en);
if (st == en) {
tree[node] = val;
return;
}
int m = (st + en) / 2;
pushdown(2 * node + 1, st, m);
pushdown(2 * node + 2, m + 1, en);
if (pos <= m)
pupd(pos, val, 2 * node + 1, st, m);
else
pupd(pos, val, 2 * node + 2, m + 1, en);
tree[node] = min(tree[2 * node + 1], tree[2 * node + 2]);
}
void upd(int l, int r, int val, int node, int st, int en) {
pushdown(node, st, en);
if (st > r || en < l) return;
int m = (st + en) / 2;
if (st >= l && en <= r) {
tree[node] -= val;
if (st < en) {
lz[2 * node + 1] += val;
lz[2 * node + 2] += val;
}
return;
}
upd(l, r, val, 2 * node + 1, st, m);
upd(l, r, val, 2 * node + 2, m + 1, en);
tree[node] = min(tree[2 * node + 1], tree[2 * node + 2]);
}
int query(int node, int st, int en) {
pushdown(node, st, en);
if (st == en) return st;
int m = (st + en) / 2;
pushdown(2 * node + 1, st, m);
pushdown(2 * node + 2, m + 1, en);
if (tree[2 * node + 2] <= tree[2 * node + 1])
return query(2 * node + 2, m + 1, en);
return query(2 * node + 1, st, m);
}
void solve() {
int n, i, go = 1;
cin >> n;
for (i = 0; i < n; i++) cin >> v[i];
build(0, 0, n - 1);
while (go <= n) {
int ans = query(0, 0, n - 1);
assert(ans >= 0 && ans <= n - 1);
w[ans] = go;
if (ans + 1 < n) upd(ans + 1, n - 1, go, 0, 0, n - 1);
go++;
pupd(ans, INF, 0, 0, n - 1);
}
for (i = 0; i < n; i++) cout << w[i] << " \n"[i == n - 1];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int T = 1;
for (int t = 1; t <= T; t++) {
solve();
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200004;
long long s[N], p[N];
int n, a[N];
void add(int x, int v) {
for (int i = x; i <= n; i += (i & -i)) s[i] += v;
}
long long que(int x) {
long long ans = 0;
for (int i = x; i; i -= (i & -i)) ans += s[i];
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &p[i]);
add(i, i);
}
for (int i = n; i >= 1; i--) {
int l = 0, r = n;
while (l < r) {
int mid = (l + r) / 2;
if (que(mid) > p[i])
r = mid;
else
l = mid + 1;
}
add(l, -l);
a[i] = l;
}
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2 * 1e5 + 3;
const long long INF = INT_MAX;
const long long NEINF = INT_MIN;
const long long MOD = 1e9 + 7;
long long Add(long long x, long long y) { return (x + y) % MOD; }
long long Mul(long long x, long long y) { return (x * y) % MOD; }
long long BinPow(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = Mul(res, x);
x = Mul(x, x);
y >>= 1;
}
return res;
}
long long ModInverse(long long x) { return BinPow(x, MOD - 2); }
long long Div(long long x, long long y) { return Mul(x, ModInverse(y)); }
long long GetBit(long long num, long long i) { return (num >> i) & 1; }
long long n;
long long bit[N], s[N], val[N], res[N];
void add(long long idx, long long delta) {
while (idx <= n) {
bit[idx] += delta;
idx += idx & -idx;
}
}
long long get(long long idx) {
long long res = 0;
while (idx > 0) {
res += bit[idx];
idx -= idx & -idx;
}
return res;
}
long long search(long long v) {
long long l = 0, r = n - 1, res, mid;
while (l <= r) {
mid = (l + r) >> 1;
long long temp = get(mid) + ((mid + 1) * mid) / 2;
if (temp == v) {
res = mid;
l = mid + 1;
} else if (temp > v)
r = mid - 1;
else
l = mid + 1;
}
return res;
}
void Solve() {
cin >> n;
for (long long i = 1; i <= n; ++i) cin >> s[i];
for (long long i = 1; i <= n; ++i) val[i] = i;
for (long long i = n; i >= 1; --i) {
long long pos = search(s[i]) + 1;
res[i] = pos;
add(pos, -pos);
}
for (long long i = 1; i <= n; ++i) cout << res[i] << " ";
}
signed main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
Solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct BigNum {
vector<long long> value;
void set(long long x) {
value = *(new vector<long long>);
value.push_back(x);
}
void duplicate(BigNum other) { value = other.value; }
void add(BigNum other) {
vector<long long> o = other.value;
if (o.size() > value.size()) {
vector<long long> t = value;
value = o;
o = t;
}
for (int i = 0; i < o.size(); i += 1) {
value[i] += o[i];
if (i < value.size() - 1 && value[i] >= (long long)1e9) {
value[i + 1] += value[i] / (long long)1e9;
value[i] = value[i] % (long long)1e9;
}
}
if (value.back() >= (long long)1e9) {
value.push_back(value.back() / (long long)1e9);
value[value.size() - 2] = value[value.size() - 2] % (long long)1e9;
}
}
void mul(long long mul) {
for (int i = 0; i < value.size(); i += 1) {
value[i] *= mul;
}
for (int i = 0; i < value.size() - 1; i += 1) {
if (value[i] >= (long long)1e9) {
value[i + 1] += value[i] / (long long)1e9;
value[i] = value[i] % (long long)1e9;
}
}
if (value.back() >= (long long)1e9) {
value.push_back(value.back() / (long long)1e9);
value[value.size() - 2] = value[value.size() - 2] % (long long)1e9;
}
}
long double div(BigNum other1, BigNum other2) {
int s = value.size();
long double current = value.back();
if (s >= 2) {
current += ((long double)value[s - 2]) / (long long)1e9;
}
if (s >= 3) {
current +=
((long double)value[s - 3]) / ((long long)1e9 * (long long)1e9);
}
int s1 = other1.value.size();
int s2 = other2.value.size();
long double other = 0;
if (s1 + s2 - 1 == s) {
other += other1.value.back() * other2.value.back();
if (s1 >= 2) {
other += ((long double)other1.value[s1 - 2] * other2.value.back()) /
(long long)1e9;
}
if (s2 >= 2) {
other += ((long double)other2.value[s2 - 2] * other1.value.back()) /
(long long)1e9;
}
if (s1 >= 3) {
other += ((long double)other1.value[s1 - 3] * other2.value.back()) /
((long long)1e9 * (long long)1e9);
}
if (s2 >= 3) {
other += ((long double)other2.value[s2 - 3] * other1.value.back()) /
((long long)1e9 * (long long)1e9);
}
}
if (s1 + s2 - 1 == s - 1) {
other += other1.value.back() * other2.value.back();
if (s1 >= 2) {
other += ((long double)other1.value[s1 - 2] * other2.value.back()) /
(long long)1e9;
}
if (s2 >= 2) {
other += ((long double)other2.value[s2 - 2] * other1.value.back()) /
(long long)1e9;
}
other /= (long long)1e9;
}
if (s1 + s2 - 1 == s - 2) {
other += other1.value.back() * other2.value.back();
other /= (long long)1e9 * (long long)1e9;
}
return other / current;
}
string stringify() {
string out = to_string(value.back());
for (int i = value.size() - 1 - 1; i > -1; i -= 1) {
string cur = to_string(value[i] + (long long)1e9);
out += cur.substr(1);
}
return out;
}
};
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long triangle(long long x) { return (((long long)(x + 1)) * (x)) / 2; }
long long modInverse(long long a) {
long long m = 1000000007;
long long y = 0, x = 1;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) {
x += 1000000007;
}
return x;
}
long long modInverse(long long a, long long b) {
long long m = b;
long long y = 0, x = 1;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) {
x += b;
}
return x;
}
long long pow(long long a, long long b) {
if (a <= 1) {
return a;
}
if (b == 0) {
return 1;
}
if (b % 2 == 0) {
return pow((a * a) % 1000000007, b / 2) % 1000000007;
}
return (a * pow((a * a) % 1000000007, b / 2)) % 1000000007;
}
vector<long long> dev(vector<pair<long long, long long> > divisors) {
if (divisors.size() == 0) {
vector<long long> cur;
cur.push_back(1);
return cur;
}
long long x = divisors.back().first;
long long n = divisors.back().second;
divisors.pop_back();
vector<long long> ans = dev(divisors);
vector<long long> cur;
long long xi = 1;
for (int i = 0; i < n + 1; i += 1) {
for (int j = 0; j < ans.size(); j += 1) {
cur.push_back(ans[j] * xi);
}
xi *= x;
}
return cur;
}
void add(vector<int>& x, vector<int>& y) {
for (int i = 0; i < x.size(); i += 1) {
x[i] += y[i];
}
}
struct pt {
long long x, y;
long long d() const { return x * x + y * y; }
};
inline pt operator-(const pt& a) { return {-a.x, -a.y}; }
inline pt operator+(const pt& a, const pt& b) { return {a.x + b.x, a.y + b.y}; }
inline pt operator-(const pt& a, const pt& b) { return {a.x - b.x, a.y - b.y}; }
inline long long operator*(const pt& a, const pt& b) {
return a.x * b.y - a.y * b.x;
}
inline bool operator<(const pt& a, const pt& b) { return a * b < 0; }
inline long long operator/(const pt& a, const pt& b) {
return a.x * b.x + a.y * b.y;
}
inline bool operator==(const pt& a, const pt& b) {
return a.x == b.x && a.y == b.y;
}
inline bool operator!=(const pt& a, const pt& b) {
return a.x != b.x || a.y != b.y;
}
pt o;
bool comp(pt a, pt b) { return (a - o) * (b - o) < 0; }
vector<vector<long long> > segtre(20);
void fix(int i, int j) {
long long t = min(segtre[i - 1][2 * j], segtre[i - 1][2 * j + 1]);
segtre[i][j] += t;
segtre[i - 1][2 * j] -= t;
segtre[i - 1][2 * j + 1] -= t;
}
int findzero() {
int i = 20 - 1;
int j = 0;
while (i > 0) {
if (segtre[i - 1][2 * j]) {
j = 2 * j + 1;
} else {
j = 2 * j;
}
i--;
}
return j;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
for (int i = 0; i < 20; i += 1) {
segtre[i].resize(2 * n);
}
for (int i = 0; i < n; i += 1) {
cin >> segtre[0][n - i - 1];
}
for (int i = 1; i < 20; i += 1) {
for (int j = 0; j < n; j += 1) {
fix(i, j);
}
}
vector<long long> a(n);
for (int i = 0; i < n; i += 1) {
long long cur = findzero();
a[cur] = i + 1;
segtre[0][cur] = n * n;
for (int j = 0; j < 20; j += 1) {
if ((1 << j) & cur) {
segtre[j][(cur >> j) - 1] -= i + 1;
}
}
for (int j = 1; j < 20; j += 1) {
fix(j, cur >> j);
fix(j, max((long long)0, (cur >> j) - 1));
}
}
for (int i = n - 1; i > -1; i -= 1) {
cout << a[i] << ' ';
}
cout << "" << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e17;
struct node {
long long ans, sub;
node() : ans(0), sub(0){};
};
struct SegmentTree {
long long N;
vector<node> st;
vector<long long> a;
long long left(long long p) { return p << 1; }
long long right(long long p) { return (p << 1) + 1; }
void push(long long p) {
st[left(p)].sub += st[p].sub;
st[right(p)].sub += st[p].sub;
st[left(p)].ans -= st[p].sub;
st[right(p)].ans -= st[p].sub;
st[p].sub = 0;
}
void merge(long long p) {
st[p].ans = min(st[left(p)].ans, st[right(p)].ans);
}
void build(long long p, long long l, long long r) {
if (l == r) {
st[p].ans = a[l];
} else {
long long mid = l + r >> 1;
build(left(p), l, mid);
build(right(p), mid + 1, r);
merge(p);
}
}
SegmentTree(long long N, vector<long long>& a) : N(N), st(4 * N), a(a) {
build(1, 0, N - 1);
}
void setElem(long long p, long long l, long long r, long long i) {
if (l == r) {
st[p].ans = inf;
} else {
long long mid = l + r >> 1;
push(p);
if (i > mid)
setElem(right(p), mid + 1, r, i);
else
setElem(left(p), l, mid, i);
merge(p);
}
}
void update(long long p, long long l, long long r, long long i, long long j,
long long val) {
if (l == i && r == j) {
st[p].sub += val;
st[p].ans -= val;
} else {
long long mid = l + r >> 1;
push(p);
if (i > mid)
update(right(p), mid + 1, r, i, j, val);
else if (j <= mid)
update(left(p), l, mid, i, j, val);
else {
update(left(p), l, mid, i, mid, val);
update(right(p), mid + 1, r, mid + 1, j, val);
}
merge(p);
}
}
void update(long long i, long long val) {
if (i + 1 < N) update(1, 0, N - 1, i + 1, N - 1, val);
setElem(1, 0, N - 1, i);
}
long long query(long long p, long long l, long long r) {
if (l == r) {
return l;
} else {
long long mid = l + r >> 1;
push(p);
if (st[right(p)].ans == 0)
return query(right(p), mid + 1, r);
else
return query(left(p), l, mid);
}
}
long long query() { return query(1, 0, N - 1); }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> s(n);
for (long long i = 0; i < n; i++) cin >> s[i];
vector<int> ans(n);
SegmentTree st(n, s);
for (long long i = 0; i < n; i++) {
long long idx = st.query();
ans[idx] = i + 1;
st.update(idx, i + 1);
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 10 | CPP |
#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;
}
| 10 | CPP |
#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;
}
| 10 | CPP |
#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;
}
| 10 | CPP |
#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;
}
| 10 | CPP |
#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] << " ";
}
}
| 10 | CPP |
#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;
}
| 10 | CPP |
#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();
}
| 10 | CPP |
#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] << " ";
}
| 10 | CPP |
#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;
}
| 10 | CPP |
#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]);
}
| 10 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.