text
stringlengths 49
983k
|
|---|
#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] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
long long fen[N];
void modify(int x, long long v) {
while (x < N) {
fen[x] += v;
x |= x + 1;
}
}
long long get(int x) {
long long r = 0;
while (x >= 0) {
r += fen[x];
x = (x & (x + 1)) - 1;
}
return r;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<long long> s(n);
for (int(i) = 0; (i) < (int)(n); ++(i)) cin >> s[i];
for (int(i) = 0; (i) < (int)(n); ++(i)) 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 (get(mid) > s[i]) {
high = mid;
} else {
low = mid + 1;
}
}
a[i] = low + 1;
modify(low, -low - 1);
}
for (int(i) = 0; (i) < (int)(n); ++(i)) cout << a[i] << ' ';
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 9;
long long s[maxn];
int p[maxn];
int vis[maxn];
int temp;
struct node {
int l, r;
long long minn, lazy;
} tree[maxn << 2];
void BT(int p, int l, int r) {
tree[p].l = l, tree[p].r = r;
if (l == r) {
tree[p].minn = s[l];
tree[p].lazy = 0;
return;
}
int mid = (l + r) >> 1;
BT(p << 1, l, mid);
BT(p << 1 | 1, mid + 1, r);
tree[p].minn = min(tree[p << 1].minn, tree[p << 1 | 1].minn);
tree[p].lazy = 0;
}
void spread(int p) {
tree[p << 1].lazy += tree[p].lazy;
tree[p << 1].minn -= tree[p].lazy;
tree[p << 1 | 1].lazy += tree[p].lazy;
tree[p << 1 | 1].minn -= tree[p].lazy;
tree[p].lazy = 0;
}
void Query(int p) {
if (tree[p].l == tree[p].r) {
tree[p].minn = 0x3f3f3f3f3f3f3f3f;
temp = tree[p].l;
return;
}
spread(p);
if (tree[p << 1 | 1].minn == 0) {
Query(p << 1 | 1);
} else
Query(p << 1);
tree[p].minn = min(tree[p << 1].minn, tree[p << 1 | 1].minn);
}
void Update(int p, int l, int r, int v) {
if (tree[p].l >= l && tree[p].r <= r) {
tree[p].lazy += v;
tree[p].minn -= v;
return;
}
spread(p);
int mid = (tree[p].l + tree[p].r) >> 1;
if (l > mid) {
Update(p << 1 | 1, l, r, v);
} else if (r <= mid)
Update(p << 1, l, r, v);
else {
Update(p << 1 | 1, l, r, v);
Update(p << 1, l, r, v);
}
tree[p].minn = min(tree[p << 1].minn, tree[p << 1 | 1].minn);
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
scanf("%lld", &s[i]);
}
BT(1, 1, n);
for (int i = 1; i <= n; i++) {
Query(1);
p[temp] = i;
if (temp < n) Update(1, temp + 1, n, i);
}
for (int i = 1; i <= n; i++) {
if (i == 1)
printf("%d", p[i]);
else
printf(" %d", p[i]);
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, eps = 1e-10;
int n;
long long a[N];
long long tree[N];
int ans[N];
long long sum(int x) {
long long res = 0;
while (x) {
res += tree[x];
x -= (x & (-x));
}
return res;
}
void add(int x, long long sum) {
while (x <= n) {
tree[x] += sum;
x += (x & (-x));
}
return;
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = (1); i < (n + 1); ++i) cin >> a[i], add(i + 1, i);
for (int i = (n); i >= (1); --i) {
long long l = 1, r = n;
while (l <= r) {
if (sum(((l + r) >> 1)) > a[i])
r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
}
ans[i] = r;
add(r + 1, -r);
}
for (int i = (1); i < (n + 1); ++i) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long cl[202020];
long long T[202020];
int chk[202020];
int ans[202020];
void m_Tree(int x, int t) {
for (int i = x; i <= n; i += i & (-i)) {
T[i] += t;
}
}
long long g_Tree(int x) {
long long ret = 0;
for (int i = x; i > 0; i -= i & (-i)) ret += T[i];
return ret;
}
int BS(int s, int e, long long t) {
if (s == e) return s;
int m = (s + e) / 2 + 1;
if (t >= g_Tree(m - 1)) return BS(m, e, t);
return BS(s, m - 1, t);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", cl + i), m_Tree(i, i);
for (int i = n; i > 0; i--) {
ans[i] = BS(1, n, cl[i]);
m_Tree(ans[i], -ans[i]);
chk[ans[i]] = 1;
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
const long double PI =
3.141592653589793238462643383279502884197169399375105820974944;
const long long mod = 998244353;
const long long inf = 1e18;
const long long maxn = 1e5 + 5;
struct BIT {
vector<long long> bit;
long long maxn;
void init(long long n) {
maxn = n;
bit.assign(n + 1, 0);
}
void update(long long i, long long val) {
for (; i <= maxn; i += (i & -i)) bit[i] += val;
}
long long sum(long long i) {
long long res = 0;
for (; i > 0; i -= (i & -i)) res += bit[i];
return res;
}
long long rsum(long long l, long long r) { return sum(r) - sum(l - 1); }
};
long long n, a[maxn];
void solve() {
long long n;
cin >> n;
BIT bit;
bit.init(n + 5);
long long a[n + 5];
set<long long> s;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
bit.update(i, i);
s.insert(i);
}
for (long long i = n; i >= 1; --i) {
long long lb = 1, rb = n;
while (lb < rb) {
long long mid = (lb + rb + 1) / 2;
if (bit.sum(mid - 1) > a[i])
rb = mid - 1;
else if (bit.sum(mid - 1) < a[i])
lb = mid + 1;
else
lb = rb = mid;
}
auto it = s.lower_bound(lb);
a[i] = *it;
bit.update(*it, -*it);
s.erase(it);
}
for (long long i = 1; i <= n; i++) cout << a[i] << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long tc = 1;
while (tc--) {
solve();
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<unsigned long long> t, lazy;
void build(unsigned long long a[], int v, int tl, int tr) {
if (tl == tr) {
t[v] = a[tl];
} else {
int tm = (tl + tr) / 2;
build(a, v * 2 + 1, tl, tm);
build(a, v * 2 + 2, tm + 1, tr);
t[v] = min(t[v * 2 + 1], t[v * 2 + 2]);
}
}
void add(int v, int tl, int tr, int l, int r, unsigned long long addend) {
if (l > r) return;
if (l == tl && tr == r) {
t[v] += addend;
lazy[v] += addend;
} else {
t[v * 2 + 1] += lazy[v];
lazy[v * 2 + 1] += lazy[v];
t[v * 2 + 2] += lazy[v];
lazy[v * 2 + 2] += lazy[v];
lazy[v] = 0;
int tm = (tl + tr) / 2;
add(v * 2 + 1, tl, tm, l, min(r, tm), addend);
add(v * 2 + 2, tm + 1, tr, max(l, tm + 1), r, addend);
t[v] = min(t[v * 2 + 1], t[v * 2 + 2]);
}
}
int last_zero(int v, int l, int r) {
if (l == r) {
return l;
} else {
int m = (r + l) / 2;
t[v * 2 + 1] += lazy[v];
lazy[v * 2 + 1] += lazy[v];
t[v * 2 + 2] += lazy[v];
lazy[v * 2 + 2] += lazy[v];
lazy[v] = 0;
t[v] = min(t[v * 2 + 1], t[v * 2 + 2]);
if (t[2 * v + 2]) {
return last_zero(2 * v + 1, l, m);
}
return last_zero(2 * v + 2, m + 1, r);
}
}
int main() {
const unsigned long long INF = 1e16 + 239;
int n;
cin >> n;
unsigned long long s[n];
int p[n];
t.assign(n * 4, INF);
lazy.assign(n * 4, 0);
for (int i = 0; i < n; i++) {
cin >> s[i];
}
build(s, 0, 0, n - 1);
for (int i = 1; i <= n; i++) {
int pos = last_zero(0, 0, n - 1);
p[pos] = i;
add(0, 0, n - 1, pos, pos, INF);
add(0, 0, n - 1, pos + 1, n - 1, -i);
}
for (int i = 0; i < n; i++) {
cout << p[i] << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 2e5 + 5;
const int inf = 0x3f3f3f3f;
long long s[MAXN];
struct node {
int l, r;
long long sum;
} node[MAXN << 2];
void build(int l, int r, int num) {
node[num].l = l;
node[num].r = r;
if (l == r) {
node[num].sum = l;
return;
}
int mid = (l + r) >> 1;
build(l, mid, num << 1);
build(mid + 1, r, num << 1 | 1);
node[num].sum = node[num << 1].sum + node[num << 1 | 1].sum;
}
void updata(int pos, int num) {
if (node[num].l == node[num].r) {
node[num].sum = 0;
return;
}
int mid = (node[num].l + node[num].r) >> 1;
if (pos <= mid)
updata(pos, num << 1);
else
updata(pos, num << 1 | 1);
node[num].sum = node[num << 1 | 1].sum + node[num << 1].sum;
}
int query(long long val, int num) {
if (node[num].l == node[num].r) {
return node[num].l;
}
long long sum1 = node[num << 1].sum;
if (sum1 <= val)
return query(val - sum1, num << 1 | 1);
else
return query(val, num << 1);
}
int dp[MAXN];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
build(1, n, 1);
for (int i = n; i >= 1; i--) {
int ans = query(s[i], 1);
dp[i] = ans;
updata(ans, 1);
}
for (int i = 1; i <= n; i++) {
cout << dp[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[300000], b[300000], C[300000];
int lowbit(int x) { return x & (-x); }
long long getSum(int x) {
long long sum = 0;
for (int i = x; i > 0; i -= lowbit(i)) sum += C[i];
return sum;
}
void add(int x, int val) {
for (int i = x; i < n; i += lowbit(i)) C[i] += val;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
add(i, i);
}
for (int i = n; i >= 1; i--) {
int l = 1, r = n;
int mid;
while (l < r) {
mid = (l + r) / 2;
if (getSum(mid) > a[i])
r = mid;
else
l = mid + 1;
}
b[i] = r;
add(r, -r);
}
for (int i = 1; i <= n; i++) {
cout << b[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
struct node {
long long w, change;
int in;
};
vector<long long> a;
vector<node> t;
const long long INF = 1e18;
node combine(node a, node b, long long change) {
a.w += a.change;
b.w += b.change;
node res;
if (a.w != b.w)
res = (a.w < b.w) ? a : b;
else
res = (a.in > b.in) ? a : b;
res.change = change;
return res;
}
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v] = {a[tl], 0, tl};
return;
}
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
t[v] = combine(t[2 * v], t[2 * v + 1], t[v].change);
}
void delete_el(int v, int tl, int tr, int pos) {
if (tl == tr) {
t[v] = {INF, 0, 0};
return;
}
int tm = (tl + tr) / 2;
if (pos <= tm)
delete_el(2 * v, tl, tm, pos);
else
delete_el(2 * v + 1, tm + 1, tr, pos);
t[v] = combine(t[2 * v], t[2 * v + 1], t[v].change);
}
void update(int v, int tl, int tr, int l, int r, long long val) {
if (l > r) return;
if (l == tl && r == tr) {
t[v].change -= val;
return;
}
int tm = (tl + tr) / 2;
update(2 * v, tl, tm, l, min(r, tm), val);
update(2 * v + 1, tm + 1, tr, max(l, tm + 1), r, val);
t[v] = combine(t[2 * v], t[2 * v + 1], t[v].change);
}
int main() {
int n;
cin >> n;
a.resize(n);
t.resize(4 * n);
for (int i = 0; i < n; i++) cin >> a[i];
build(1, 0, n - 1);
vector<long long> ans(n);
for (int i = 0; i < n; i++) {
int in = t[1].in;
ans[in] = i + 1;
delete_el(1, 0, n - 1, in);
update(1, 0, n - 1, in + 1, n - 1, i + 1);
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[8] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy[8] = {1, -1, -1, 0, 1, -1, 0, 1};
long long tree[4 * 200005], lazy[4 * 200005], ans[4 * 200005], a[200005];
void build(long long int start, long long int last, long long int node) {
if (start == last) {
tree[node] = a[start];
ans[node] = start;
return;
}
long long int mid = (start + last) >> 1, l = node << 1;
build(start, mid, l), build(mid + 1, last, l + 1);
long long t1 = tree[l], t2 = tree[l + 1];
if (t1 < t2)
ans[node] = ans[l];
else
ans[node] = ans[l + 1];
tree[node] = (tree[l] > tree[l + 1] ? tree[l + 1] : tree[l]);
return;
}
void update(long long int start, long long int last, long long int l,
long long int r, long long int node, long long val) {
if (lazy[node]) {
tree[node] += lazy[node];
if (start != last) {
lazy[node << 1] += lazy[node];
lazy[(node << 1) + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start > r || last < l) return;
if (l <= start && r >= last) {
tree[node] += val;
if (start != last) {
lazy[node << 1] += val;
lazy[(node << 1) + 1] += val;
}
return;
}
long long int mid = (start + last) >> 1;
update(start, mid, l, r, node << 1, val);
update(mid + 1, last, l, r, (node << 1) + 1, val);
if (tree[node << 1] < tree[(node << 1) + 1])
ans[node] = ans[node << 1];
else
ans[node] = ans[(node << 1) + 1];
tree[node] = (tree[node << 1] > tree[(node << 1) + 1] ? tree[(node << 1) + 1]
: tree[node << 1]);
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int n1 = n, ans1[n + 1], cnt = 1;
for (long long int i = 1; i <= n; i++) cin >> a[i];
build(1, n, 1);
while (n1--) {
long long int idx = ans[1];
ans1[idx] = cnt;
update(1, n, idx, idx, 1, 1000000000000);
if (idx < n) update(1, n, idx + 1, n, 1, -cnt);
cnt++;
}
for (long long int i = 1; i <= n; i++) cout << ans1[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long n, m, s[N], a[N], C[N], vis[N];
long long lowbit(long long x) { return (x & (-x)); }
long long sum(long long x) {
long long res = 0;
while (x > 0) {
res += C[x];
x -= lowbit(x);
}
return res;
}
void add(long long x, long long d) {
d = d * x;
while (x < N) {
C[x] += d;
x += lowbit(x);
}
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> s[i], add(i, 1);
}
for (long long i = n; i >= 1; i--) {
long long l = 1, r = n, ans = 0;
while (l <= r) {
long long mid = (r + l) >> 1, su = (sum(mid - 1));
if (su == s[i]) {
if (vis[mid]) {
l = mid + 1;
continue;
}
ans = mid;
add(mid, -1);
break;
}
if (su < s[i]) {
l = mid + 1;
} else
r = mid - 1;
}
a[i] = ans;
vis[ans] = 1;
}
for (long long i = 1; i <= n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
|
#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) {
assert(i > 0);
for (long long val = i; i <= n; i += i & -i) bit[i] += val;
}
long long get(int i) {
long long res = 0;
for (; i > 0; i -= i & -i) res += bit[i];
return res;
}
inline void sol() {
cin >> n;
for (int i = 0, _ = (n); i < _; i++) cin >> p[i];
for (int i = (int)(n)-1; i >= 0; --i) {
long long l = 0, r = n - 1, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (mid * (mid + 1) / 2 > get(mid) + p[i])
r = mid - 1;
else
l = mid;
}
up(ans[i] = l + 1);
}
for (int i = 0, _ = (n); i < _; i++) cout << ans[i] << ' ';
cout << "\n";
}
signed main() {
{ ios_base::sync_with_stdio(false), cin.tie(NULL); };
cout.precision(10);
cout << fixed;
sol();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, lo[(long long)(2e5 + 5) * 4], hi[(long long)(2e5 + 5) * 4],
ans[(long long)(2e5 + 5)];
long long base[(long long)(2e5 + 5)], delta[(long long)(2e5 + 5) * 4];
pair<long long, int> mn[(long long)(2e5 + 5) * 4];
void update(int i);
void ini(int i, int a, int b) {
lo[i] = a;
hi[i] = b;
if (a == b) {
mn[i].first = base[a];
mn[i].second = a;
return;
}
int mid = (a + b) / 2;
ini(2 * i, a, mid);
ini(2 * i + 1, mid + 1, b);
update(i);
}
void update(int i) {
if (mn[i * 2].first + delta[i * 2] == mn[i * 2 + 1].first + delta[i * 2 + 1])
mn[i] = mn[i * 2 + 1], mn[i].first += delta[i * 2 + 1];
else if (mn[i * 2].first + delta[i * 2] <
mn[i * 2 + 1].first + delta[i * 2 + 1])
mn[i] = mn[i * 2], mn[i].first += delta[i * 2];
else
mn[i] = mn[i * 2 + 1], mn[i].first += delta[i * 2 + 1];
}
void prop(int i) {
delta[i * 2] += delta[i];
delta[i * 2 + 1] += delta[i];
delta[i] = 0;
}
void inc(int i, int a, int b, long long val) {
if (lo[i] >= a && hi[i] <= b) {
delta[i] += val;
return;
}
if (lo[i] > b || hi[i] < a) return;
prop(i);
inc(i * 2, a, b, val);
inc(i * 2 + 1, a, b, val);
update(i);
}
void change(int i, int loc) {
if (lo[i] == loc && hi[i] == loc) {
mn[i].first = 1e18, mn[i].second = -1;
delta[i] = 1e18;
return;
}
if (lo[i] > loc || hi[i] < loc) return;
prop(i);
change(i * 2, loc);
change(i * 2 + 1, loc);
update(i);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) cin >> base[i];
ini(1, 1, n);
for (int i = 1; i <= n; i++) {
pair<long long, int> loc = mn[1];
change(1, loc.second);
inc(1, loc.second + 1, n, -1 * i);
ans[loc.second] = i;
}
for (int i = 1; i <= n; i++) {
cout << ans[i];
if (i != n) cout << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long int n;
long long int tree[200001 * 10];
long int a[200002];
void build(long int node, long int start, long int end) {
if (start == end) {
tree[node] = a[start];
} else {
long int mid = (start + end) / 2;
build(2 * node + 1, start, mid);
build(2 * node + 2, mid + 1, end);
tree[node] = tree[2 * node + 1] + tree[2 * node + 2];
}
}
void update(long int node, long int start, long int end, long int ind) {
if (start == end)
tree[node] = a[ind];
else {
long int mid = (start + end) / 2;
if (start <= ind && ind <= mid) {
update(2 * node + 1, start, mid, ind);
} else {
update(2 * node + 2, mid + 1, end, ind);
}
tree[node] = tree[2 * node + 1] + tree[2 * node + 2];
}
}
long long int query(long int node, long int start, long int end, long int l,
long int r) {
if (r < start || end < l) {
return 0;
}
if (l <= start && end <= r) {
return tree[node];
}
long int mid = (start + end) / 2;
long long int p1 = query(2 * node + 1, start, mid, l, r);
long long int p2 = query(2 * node + 2, mid + 1, end, l, r);
return (p1 + p2);
}
long int idx[200002];
long int root(long int x) {
while (idx[x] != x) {
idx[x] = idx[idx[x]];
x = idx[x];
}
return x;
}
int main() {
cin >> n;
long int ans = 0;
for (long int i = 0; i <= n + 1; i++) a[i] = i, idx[i] = i;
build(0, 0, n);
long long int b[n];
for (long int i = 0; i < n; i++) cin >> b[i];
vector<long int> x;
for (long int i = n - 1; i >= 0; i--) {
long int l = 0, r = n;
long int ans = -1;
while (l <= r) {
long int mid = (l + r) / 2;
long long int temp1 = query(0, 0, n, 0, mid);
if (temp1 == b[i]) {
ans = mid + 1;
break;
} else if (temp1 < b[i]) {
l = mid + 1;
} else
r = mid - 1;
}
ans = root(ans);
x.push_back(ans);
a[ans] = 0;
update(0, 0, n, ans);
idx[root(ans)] = root(ans + 1);
}
for (long int i = 0; i < x.size(); i++) cout << x[x.size() - 1 - i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Nmax = 2e6 + 5;
long long v[Nmax];
long long ans[Nmax];
long long lazy[4 * Nmax];
pair<long long, long long> all[4 * Nmax];
long long p, q, val;
void add(long long &first, long long val) {
if (first != LLONG_MAX) first += val;
}
void propagate(long long node) {
if (lazy[node]) {
add(lazy[(node << 1)], lazy[node]);
add(lazy[((node << 1) + 1)], lazy[node]);
add(all[(node << 1)].first, lazy[node]);
add(all[((node << 1) + 1)].first, lazy[node]);
lazy[node] = 0;
}
}
void build(long long lo, long long hi, long long node) {
if (lo == hi) {
all[node] = make_pair(v[lo], -lo);
} else {
long long mid = (lo + hi) >> 1;
build(lo, mid, (node << 1));
build(mid + 1, hi, ((node << 1) + 1));
all[node] = min(all[(node << 1)], all[((node << 1) + 1)]);
}
}
void update(long long lo, long long hi, long long node) {
propagate(node);
if (p <= lo and hi <= q) {
lazy[node] += val;
all[node].first += val;
} else {
long long mid = (lo + hi) >> 1;
if (p <= mid) update(lo, mid, (node << 1));
if (mid < q) update(mid + 1, hi, ((node << 1) + 1));
all[node] = min(all[(node << 1)], all[((node << 1) + 1)]);
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(nullptr);
long long n;
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> v[i];
}
build(1, n, 1);
for (long long pos, i = 1; i <= n; ++i) {
pos = -all[1].second;
ans[pos] = i;
p = q = pos;
val = LLONG_MAX;
update(1, n, 1);
p = pos + 1;
q = n;
val = -i;
if (p <= q) update(1, n, 1);
}
for (long long i = 1; i <= n; ++i) cout << ans[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int z[200020];
long long a[200020];
long long c[200020];
void R(int x, int y) {
for (; x <= n; x += x & -x) {
c[x] += y;
}
}
int A(long long x) {
int re = 0;
for (int i = 1 << 20; i > 0; i >>= 1) {
if (re + i <= n && c[re + i] <= x) {
x -= c[re += i];
}
}
return re + 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
R(i, i);
}
for (int i = n; i > 0; i--) {
z[i] = A(a[i]);
R(z[i], -z[i]);
}
for (int i = 1; i <= n; i++) {
printf("%d%c", z[i], i == n ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t[200025 * 4], lz[200025 * 4], n, a[200025];
void build(int l, int r, int i) {
t[i] = 1ll * l * (l - 1) / 2;
if (l == r) return;
build(l, (l + r) / 2, i * 2 + 1);
build((l + r) / 2 + 1, r, i * 2 + 2);
t[i] = max(t[i * 2 + 1], t[i * 2 + 2]);
}
void down(int i) {
lz[i * 2 + 1] += lz[i];
lz[i * 2 + 2] += lz[i];
t[i * 2 + 1] += lz[i];
t[i * 2 + 2] += lz[i];
lz[i] = 0;
}
void updata(int L, int R, long long v, int l, int r, int i) {
if (L <= l && R >= r) {
t[i] += v;
lz[i] += v;
return;
}
if (lz[i]) down(i);
if (L <= (l + r) / 2) updata(L, R, v, l, (l + r) / 2, i * 2 + 1);
if (R > (l + r) / 2) updata(L, R, v, (l + r) / 2 + 1, r, i * 2 + 2);
t[i] = max(t[i * 2 + 1], t[i * 2 + 2]);
}
int query(long long v, int l, int r, int i) {
if (l == r) return l;
if (lz[i]) down(i);
if (t[i * 2 + 1] >= v) return query(v, l, (l + r) / 2, i * 2 + 1);
return query(v, (l + r) / 2 + 1, r, i * 2 + 2);
}
int main() {
cin >> n;
for (int i = (1); i <= (n); i++) scanf("%lld", &a[i]);
build(1, n, 0);
for (int i = (n); i >= (1); i--) {
a[i] = query(a[i], 1, n, 0);
if (a[i] < n) updata(a[i] + 1, n, -a[i], 1, n, 0);
updata(a[i], a[i], -1e12, 1, n, 0);
}
for (int i = (1); i <= (n); i++) printf("%lld%c", a[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 2e5 + 10;
const long long inf = 1e17 + 10;
using namespace std;
struct Seg {
long long v[MAXN * 4], lazy[MAXN * 4];
int m(int l, int r) { return (l + r) / 2; }
void updPoint(int pos, int l, int r, int x, long long val) {
if (l == r) {
v[pos] = val;
return;
}
if (x <= m(l, r))
updPoint(pos * 2, l, m(l, r), x, val);
else
updPoint(pos * 2 + 1, m(l, r) + 1, r, x, val);
v[pos] = min(v[pos * 2], v[pos * 2 + 1]);
}
void refresh(int pos, int l, int r) {
long long k = lazy[pos];
lazy[pos] = 0;
v[pos] -= k;
if (l == r) return;
for (int i = 0; i < 2; i++) lazy[pos * 2 + i] += k;
}
void updInterval(int pos, int l, int r, int beg, int en, long long val) {
refresh(pos, l, r);
if (l > en || r < beg) return;
if (l >= beg && r <= en) {
lazy[pos] += val;
refresh(pos, l, r);
return;
}
updInterval(pos * 2, l, m(l, r), beg, en, val);
updInterval(pos * 2 + 1, m(l, r) + 1, r, beg, en, val);
v[pos] = min(v[pos * 2], v[pos * 2 + 1]);
}
int buscab(int pos, int l, int r) {
refresh(pos, l, r);
if (l == r) return l;
refresh(pos * 2, l, m(l, r));
refresh(pos * 2 + 1, m(l, r) + 1, r);
if (v[pos * 2] > 0) return buscab(pos * 2 + 1, m(l, r) + 1, r);
return buscab(pos * 2, l, m(l, r));
}
};
int n;
long long vet[MAXN];
int seq[MAXN];
Seg seg;
int main() {
scanf("%d", &n);
for (int i = 1; i < n + 1; i++) scanf("%lld", &vet[i]);
reverse(vet + 1, vet + 1 + n);
for (int i = 1; i < n + 1; i++) seg.updPoint(1, 1, n, i, vet[i]);
for (int i = 1; i < n + 1; i++) {
int t = seg.buscab(1, 1, n);
seg.updInterval(1, 1, n, 1, t - 1, i);
seg.updInterval(1, 1, n, t, t, -inf);
seq[n - t + 1] = i;
}
for (int i = 1; i < n + 1; i++) printf("%d ", seq[i]);
printf("\n");
}
|
#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;
}
|
#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;
}
|
#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];
}
|
#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] << " ";
}
|
#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;
}
|
#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;
}
}
|
#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;
}
|
#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] << " ";
}
}
|
#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;
}
|
#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;
}
|
#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] << " ";
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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();
}
|
#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++;
}
}
|
#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);
}
|
#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;
}
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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]);
}
|
#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] << " ";
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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] << " ";
}
|
#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;
}
|
#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;
}
|
#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";
}
|
#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]);
}
|
#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;
}
|
#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();
}
|
#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;
}
|
#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");
}
|
#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;
}
|
#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] << ' ';
}
|
#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');
}
|
#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" : " ");
}
}
|
#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;
}
|
#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;
}
|
#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";
}
|
#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;
}
|
#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] << " ";
}
}
|
#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();
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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("");
}
|
#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 << ' ';
}
|
#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';
}
|
#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;
}
|
#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;
}
|
#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]);
}
}
|
#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");
}
}
|
#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;
}
|
#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;
}
|
#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] << ' ';
}
|
#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] << " ";
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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");
}
|
#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];
}
|
#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();
}
|
#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;
}
|
#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]);
}
|
#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;
}
|
#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;
}
|
#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;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.