solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, x, y, mx, idx;
int deg[100010];
vector<int> edge[100010];
bool vis[100010];
bool can = true;
void dfs(int u) {
vis[u] = true;
int sz_u = (int)edge[u].size();
if (u != idx && sz_u == 2) {
can = false;
return;
}
for (int i = 0; i < sz_u && can; ++i) {
if (!vis[edge[u][i]]) dfs(edge[u][i]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &x, &y);
edge[x].push_back(y);
edge[y].push_back(x);
deg[x]++;
deg[y]++;
if (deg[x] > deg[idx]) {
idx = x;
}
if (deg[y] > deg[idx]) {
idx = y;
}
}
if (n == 2) {
puts("YES");
} else if (n == 3) {
puts("NO");
} else {
dfs(idx);
can ? puts("YES") : puts("NO");
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse4")
const long double EPS = 1e-9;
const long long INF = 1e9;
const long long mod = 1e9 + 7;
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
long long n, m, k;
long long q;
vector<vector<long long>> vec;
vector<bool> used;
vector<long long> cnt;
vector<long long> ans;
vector<long long> pref;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
vec.resize(n);
cnt.resize(n, 0);
for (int i = 0; i < n - 1; ++i) {
int v, to;
cin >> v >> to;
--v;
--to;
vec[v].push_back(to);
vec[to].push_back(v);
cnt[v]++;
cnt[to]++;
}
int cntl = 0, cntnl = 0;
for (int i = 0; i < n; ++i) {
if (cnt[i] == 1)
cntl++;
else if (cnt[i] == 2) {
cout << "NO";
return 0;
} else {
int cntal = 0;
for (int j = 0; j < vec[i].size(); ++j) {
if (cnt[vec[i][j]] == 1) {
cntal++;
}
}
if (cntal <= 1) {
cntnl++;
}
}
}
if ((cntl == 2 && n > 2)) {
cout << "NO";
} else {
cout << "YES";
}
return 0;
}
| 10 | CPP |
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(input())
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())
N = inp()
cnt = [0]*N
for _ in range(N-1):
x,y = inpl()
cnt[x-1] += 1
cnt[y-1] += 1
for c in cnt:
if c == 2:
print('NO')
break
else:
print('YES')
| 10 | PYTHON3 |
# https://codeforces.com/contest/1189/problem/D1
n = int(input())
g = {}
p = {}
path = {}
flg = True
for _ in range(n-1):
u,v = map(int, input().split())
if u not in g:
g[u] = []
g[u].append(v)
if v not in g:
g[v] = []
g[v].append(u)
flg = 'YES'
for x in g:
if len(g[x]) == 1:continue
if len(g[x]) == 2:
flg = 'NO'
break
print(flg) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
vector<vector<long long>> graph(n + 1);
if (n == 2) {
cout << "YES"
<< "\n";
return 0;
}
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (long long i = 0; i < graph.size(); i++) {
if (graph[i].size() == 1) continue;
if (graph[i].size() == 2) {
cout << "NO"
<< "\n";
return 0;
}
}
cout << "YES"
<< "\n";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 1;
vector<long long> v[N];
int main() {
long long n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (v[i].size() == 2) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
long mmid(long a, long b, long c) {
return a < b ? (b < c ? b : max(a, c)) : (b > c ? b : min(a, c));
}
ll modinv(ll a) {
ll b = 1000000007, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return (u + 1000000007) % 1000000007;
}
ll moddevide(ll a, ll b) { return (a * modinv(b)) % 1000000007; }
ll modncr(ll n, ll r) {
ll i, plus = 1;
for (i = 0; i < r; i++) {
plus = (plus * (n - i)) % 1000000007;
plus = moddevide(plus, i + 1);
}
return plus;
}
ll euclidean_gcd(ll a, ll b) {
if (a < b) return euclidean_gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
int i, N, K, a, b, ch, now;
long t;
cin >> N;
vector<vector<int>> v(N);
for (i = 0; i < N - 1; i++) {
cin >> a >> b;
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
}
for (i = 0; i < N; i++) {
K = v[i].size();
if (K == 2) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
long long int n;
cin >> n;
vector<long long int> v[n + 1];
for (long long int i = 0; i < n - 1; i++) {
long long int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (long long int i = 0; i <= n; i++) {
if (v[i].size() == 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
long long mod = 998244353;
using namespace std;
const long long N = 1e5 + 5;
vector<long long> g[N];
long long n;
void fail() {
cout << "NO\n";
exit(0);
}
long long cnt = 1;
void dfs(long long node, long long p = 0) {
if (g[node].size() == 2) cnt = 0;
for (long long nx : g[node]) {
if (nx == p) continue;
dfs(nx, node);
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
if (n == 2) {
cout << "YES\n";
return 0;
}
if (n == 3) fail();
for (long long i = 1, u, v; i < n; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
if (cnt)
cout << "YES";
else
cout << "NO";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 998244353;
bool cmp(pair<int, pair<int, int>> a, pair<int, pair<int, int>> b) {
if (a.first >= b.first) return false;
return true;
}
int main() {
long long n, i = 0, j, k, m, q, l, r = 0, w, x, y, z = 0;
string t, s;
cin >> n;
vector<vector<long long>> a(n);
for (int i = 0; i < int(n - 1); i++) {
cin >> x >> y;
a[x - 1].push_back(y);
a[y - 1].push_back(x);
}
for (int i = 0; i < int(n); i++) {
if (int(a[i].size()) == 2) z = 1;
}
if (z == 1)
cout << "NO";
else
cout << "YES";
}
| 10 | CPP |
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7
import threading
threading.stack_size(10**8)
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
def solve():
n = int(ri())
g = [ [] for i in range(n)]
for i in range(n-1):
a,b = Ri();a-=1;b-=1
g[a].append(b);g[b].append(a)
# child = [0]*n
# print(g)
flag = [True]
def dfs1(cur, par):
if len(g[cur]) == 2:
flag[0] = False
return
for child in g[cur]:
if child == par: continue
dfs1(child, cur)
return
dfs1(0, -1)
if flag[0]:
YES()
else:
NO()
threading.Thread(target= solve).start() | 10 | PYTHON3 |
n = int(input())
deg = [0]*n
for i in range(n-1):
u, v = map(int, input().split())
deg[u-1] += 1
deg[v-1] += 1
if all(i != 2 for i in deg):
print("YES")
else:
print("NO")
# cnt = sum(1 for i in deg if i == 1)
# if cnt*(cnt-1)//2 >= n - 1:
# print("YES")
# else:
# print("NO") | 10 | PYTHON3 |
from math import log2
from collections import defaultdict
import sys
input = sys.stdin.readline
'''
for CASES in range(int(input())):
n, m = map(int, input().split())
n = int(input())
A = list(map(int, input().split()))
S = input().strip()
sys.stdout.write(" ".join(map(str,ans))+"\n")
'''
inf = 100000000000000000 # 1e17
mod = 998244353
n = int(input())
A=defaultdict(list)
ru=[0]*n
for i in range(n-1):
x,y = map(int, input().split())
x-=1
y-=1
A[x].append(y)
A[y].append(x)
ru[x]+=1
ru[y]+=1
num=0
flag=1
for i in range(n):
if ru[i]==2:
flag=0
if flag==1:
print("yes")
else:
print("no")
# the end
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> d(n + 1);
for (int i = 1; i <= n - 1; ++i) {
int u, v;
cin >> u >> v;
d[u]++, d[v]++;
}
bool ok = 1;
for (int i = 1; i <= n; ++i) {
if (d[i] == 2) {
ok = 0;
break;
}
}
if (!ok) {
cout << "no"
<< "\n";
} else {
cout << "yes"
<< "\n";
}
return 0;
}
| 10 | CPP |
n = int(input())
g = [[] for i in range(n)]
for i in range(n - 1):
u, v = map(int, input().split())
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
for v in range(n):
if len(g[v]) == 2:
print('NO')
exit(0)
print('YES')
| 10 | PYTHON3 |
a = int(input())
A = [0]*a
k=0
for i in range(a-1):
q,w = map(int,input().split())
A[q-1]+=1
if A[q-1]==2:
k+=1
elif A[q-1]==3:
k-=1
A[w-1]+=1
if A[w-1]==2:
k+=1
elif A[w-1]==3:
k-=1
if k == 0:
print('YES')
else:
print('NO') | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
long long n;
cin >> n;
vector<long long> a[100001];
for (long long i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
for (long long i = 1; i <= n; i++) {
if (a[i].size() == 2) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void fast(string name = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
if ((int)name.size() > 0) {
freopen((name + ".in").c_str(), "r", stdin);
freopen((name + ".out").c_str(), "w", stdout);
}
}
const int N = 1e5;
int deg[N];
int n;
void solve() {
cin >> n;
int a, b;
fill(deg, deg + n + 1, 0);
for (int i = 1; i < n; ++i) {
cin >> a >> b;
deg[a]++;
deg[b]++;
}
for (int i = 1; i <= n; ++i) {
if (deg[i] == 2) {
cout << "NO\n";
return;
}
}
cout << "YES\n";
}
int main() {
fast("");
solve();
return 0;
}
| 10 | CPP |
n = int(input())
dep = []
for i in range(n) :
dep.append(0)
for i in range(n-1) :
a, b = input().split(' ')
a = int(a)
b = int(b)
dep[a-1] = dep[a-1]+1
dep[b-1] = dep[b-1]+1
good = 1
for i in range(n) :
if dep[i] == 2 :
good = 0
if good == 1 :
print('YES')
else :
print('NO')
| 10 | PYTHON3 |
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
n = int(input())
d = [[] for _ in range(n)]
for i in range(n-1):
u, v = map(int, input().split())
u -= 1
v -= 1
d[u].append(v)
d[v].append(u)
for i in range(n):
if len(d[i]) == 2:
print('NO')
exit()
else:
print("YES")
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long b, long long p, long long md) {
if (p == 0) return 1;
if (p % 2 == 1) {
return ((b % md) * bigmod(b, p - 1, md)) % md;
} else {
long long y = bigmod(b, p / 2, md);
return (y * y) % md;
}
}
int deg[100005];
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
deg[a]++;
deg[b]++;
}
for (int i = 1; i <= n; i++) {
if (deg[i] == 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 500010;
int n, m, d[N];
inline int read() {
int sym = 0, res = 0;
char ch = 0;
while (!isdigit(ch)) sym |= (ch == '-'), ch = getchar();
while (isdigit(ch)) res = (res << 3) + (res << 1) + (ch ^ 48), ch = getchar();
return sym ? -res : res;
}
void file() {
freopen("read.in", "r", stdin);
freopen("write.out", "w", stdout);
}
int main() {
n = read();
for (int i = 1; i <= n - 1; i++) {
int x = read(), y = read();
d[x]++, d[y]++;
}
for (int i = 1; i <= n; i++) {
if (d[i] == 2) {
printf("NO");
return 0;
}
}
printf("YES");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long ar[100005], n, flag;
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
long long l, r;
cin >> l >> r;
ar[l]++;
ar[r]++;
}
for (int i = 0; i < n + 1; i++)
if (ar[i] == 2) flag = 1;
if (!flag)
cout << "YES";
else
cout << "NO";
}
| 10 | CPP |
n=int(input())
tree={}
for i in range(n-1):
a,b=[int(x) for x in input().split()]
if a not in tree:
tree[a]=1
else:
tree[a]+=1
if b not in tree:
tree[b]=1
else:
tree[b]+=1
for item in tree:
if tree[item]==2:
print('NO')
break
else:
print('YES')
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool b2(const pair<pair<int, int>, int> &p1,
const pair<pair<int, int>, int> &p2) {
return p1.first.first > p2.first.first;
}
bool b1(const pair<pair<int, int>, int> &p1,
const pair<pair<int, int>, int> &p2) {
return p1.first.second < p2.first.second;
}
bool bbk(vector<pair<int, int>> &v1, vector<pair<int, int>> &v2) {
return v1.size() < v2.size();
}
int n;
vector<int> v[100005];
bool check = true;
void solve() {
for (long long int i = 1; i <= n; i++) {
if (v[i].size() == 2) {
check = false;
break;
}
}
}
int main() {
cin >> n;
int a, b;
for (long long int i = 1; i <= n - 1; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
solve();
if (check)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e18, M = 1e9 + 7;
const long long int N = 1e5 + 5;
vector<long long int> v[N];
void solve() {
long long int n;
cin >> n;
long long int a, b;
for (long long int i = 1; i < n; ++i) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (long long int i = 1; i <= n; ++i) {
if (v[i].size() == 2ll) {
cout << "NO";
return;
}
}
cout << "YES";
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 10 | CPP |
from collections import defaultdict, deque, Counter
from sys import stdin, stdout
from heapq import heappush, heappop
import math
import io
import os
import math
import bisect
#?############################################################
def isPrime(x):
for i in range(2, x):
if i*i > x:
break
if (x % i == 0):
return False
return True
#?############################################################
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den, p - 2, p)) % p
#?############################################################
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3, int(math.sqrt(n))+1, 2):
while n % i == 0:
l.append(int(i))
n = n / i
if n > 2:
l.append(n)
return list(set(l))
#?############################################################
def power(x, y, p):
res = 1
x = x % p
if (x == 0):
return 0
while (y > 0):
if ((y & 1) == 1):
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
#?############################################################
def sieve(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
#?############################################################
def digits(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
#?############################################################
def ceil(n, x):
if (n % x == 0):
return n//x
return n//x+1
#?############################################################
def mapin():
return map(int, input().split())
#?############################################################
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
# python3 15.py<in>op
n = int(input())
d = [0]*n
for _ in range(n-1):
u, v = mapin()
d[u-1]+=1
d[v-1]+=1
if(d.count(2) == 0):
print("YES")
else:
print("NO")
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 1);
int u, v;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
a[u]++;
a[v]++;
}
bool check = false;
for (int i = 1; i <= n; i++)
if (a[i] == 2) check = true;
if (check)
cout << "NO";
else
cout << "YES";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100005];
int main() {
int t, q, n, m, x, y, i, j, k;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
int f = 0;
for (i = 1; i <= n; i++) {
if (v[i].size() == 2) {
f = 1;
break;
}
}
if (f == 0)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a, b;
vector<vector<int>> A(n);
for (int i = 0; i < (n - 1); i++) {
cin >> a >> b;
A[a - 1].push_back(b - 1);
A[b - 1].push_back(a - 1);
}
if (n <= 2) {
cout << "YES" << endl;
return 0;
}
bool flag = false;
for (int i = 0; i < A.size(); i++) {
if (A[i].size() != 1 && A[i].size() < 3) {
flag = true;
}
}
if (flag == false) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> N[100005];
void addE(int a, int b) {
N[a].push_back(b);
N[b].push_back(a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, a, b;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> a >> b;
addE(a - 1, b - 1);
}
int sz;
for (int i = 0; i < n; i++) {
sz = N[i].size();
if (sz == 2) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int fx[] = {+1, -1, +0, +0};
const int fy[] = {+0, +0, +1, -1};
int ans = 0;
void nishantwrp(int cas) {
int n;
cin >> n;
vector<int> nodes[n + 1];
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
nodes[a].push_back(b);
nodes[b].push_back(a);
}
for (int i = 0; i < n; i++) {
if ((int)nodes[i + 1].size() == 2) {
cout << "NO";
return;
}
}
cout << "YES";
}
signed main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
int cas = 1;
while (cas <= t) {
nishantwrp(cas);
cas++;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
solve();
return 0;
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
long long n;
vector<vector<long long> > a(200001);
void solve() {
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
u--, v--;
a[u].push_back(v);
a[v].push_back(u);
}
if (n == 2) {
cout << "YES";
return;
}
for (long long i = 0; i < n; i++) {
if (a[i].size() == 2) {
cout << "NO";
return;
}
}
cout << "YES";
}
| 10 | CPP |
n=int(input())
arr=[0]*n
for i in range(0,n-1):
x,y=map(int,input().split())
arr[x-1]+=1
arr[y-1]+=1
for i in range(0,n):
if arr[i]==2:
print("NO")
exit()
print("YES") | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int>> graph;
int solve() {
long long int n;
cin >> n;
graph.resize(n + 1);
n--;
while (n--) {
long long int a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
long long int flag = 0;
for (auto adj : graph) {
if (adj.size() == 2) flag = 1;
}
if (flag)
cout << "NO\n";
else
cout << "YES\n";
return 0;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> G[100005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (G[i].size() == 2) {
printf("NO\n");
return 0;
}
printf("YES\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename S37, typename... Args>
void err(istream_iterator<string> it, S37 a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
const long long N = 200010, mod = 1e9 + 7, mod2 = 1e9 + 9, mod3 = 998244353,
sq = 450, base = 37, lg = 25, inf = 1e18 + 10, del = 67733;
long long n, m, x, y, w, z, X, Y, Z, t, k, ans, a[N];
vector<long long> v[N];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
a[x]++;
a[y]++;
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (a[i] == 2) return cout << "NO", 0;
}
cout << "YES";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
const int N = 1e5 + 7;
const int xinc[] = {0, 0, 1, -1};
const int yinc[] = {1, -1, 0, 0};
void solve() {
long long n, i, a, b;
cin >> n;
;
std::vector<long long> adj[n + 1];
std::vector<bool> visited(n + 1, false);
queue<long long> q;
for (i = 0; i < n - 1; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
q.push(1);
visited[1] = true;
while (!q.empty()) {
long long curr = q.front();
q.pop();
long long deg = adj[curr].size();
if (!(deg == 1 || deg > 2)) {
cout << "NO";
return;
}
for (auto nei : adj[curr]) {
if (!visited[nei]) {
q.push(nei);
visited[nei] = true;
}
}
}
cout << "YES";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
vector<int> conn[200100];
bool oka = true;
void dfs(int u, int par) {
if (par == -1 && conn[u].size() == 1)
;
else {
if (conn[u].size() == 1) return;
if (conn[u].size() < 3 || oka == false) {
oka = false;
return;
}
}
for (int v : conn[u]) {
if (v == par) continue;
dfs(v, u);
}
}
int main() {
int n;
cin >> n;
int u, v;
for (int i = 1; i <= n - 1; i++) {
cin >> u >> v;
conn[u].push_back(v);
conn[v].push_back(u);
}
dfs(1, -1);
if (oka)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 10;
int n;
vector<int> vs[N];
bool dfs(int node, int par) {
if (par != -1 && vs[node].size() == 1) {
return false;
}
int children = 0;
bool bad = false;
for (int v : vs[node])
if (v != par) {
++children;
bad |= dfs(v, node);
}
if (par != -1) bad |= children == 1;
return bad;
}
void solve() {
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v, --u, --v;
vs[u].push_back(v);
vs[v].push_back(u);
}
int cnt = 0;
bool bad = false;
for (int i = 0; i < n && cnt < 2; ++i) {
if (vs[i].size() == 1) {
++cnt;
bad |= dfs(i, -1);
}
}
cout << (bad ? "NO" : "YES") << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.precision(20);
cout << fixed;
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
long long mod = 1000000007;
const int MX = 0x3f3f3f;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, i, u, v;
cin >> n;
vector<int> adj[n];
for (i = 0; i <= n - 2; i++) {
cin >> u >> v;
adj[u - 1].emplace_back(v - 1);
adj[v - 1].emplace_back(u - 1);
}
if (n == 2) {
cout << "YES";
return 0;
}
for (i = 0; i <= n - 1; i++) {
if (adj[i].size() == 1) continue;
if (adj[i].size() < 3) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int de[maxn];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
memset(de, 0, sizeof de);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
de[u]++;
de[v]++;
}
bool flag = true;
for (int i = 1; i <= n; i++) {
if (de[i] == 2) {
flag = false;
break;
}
}
if (flag)
puts("YES");
else
puts("NO");
}
| 10 | CPP |
import sys
n = int(sys.stdin.readline().strip())
d = [0] * n
for i in range (0, n - 1):
u, v = sys.stdin.readline().strip().split()
u, v = int(u) - 1, int(v) - 1
d[u] = d[u] + 1
d[v] = d[v] + 1
if 2 in d:
print("NO")
else:
print("YES") | 10 | PYTHON3 |
n = int(input())
tr = [0] * (n + 1)
for i in range(n - 1):
u, v = map(int, input().split())
tr[u] += 1
tr[v] += 1
for i in range(1, n + 1):
if tr[i] == 2:
print('No')
break
else:
print('Yes')
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int const maxn = 1e5 + 5;
vector<int> p[maxn];
int main() {
int n;
scanf("%d", &n);
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
p[u].push_back(v);
p[v].push_back(u);
}
bool flag = 1;
for (int i = 1; i <= n; i++)
if (p[i].size() == 2) flag = 0;
if (flag)
printf("YES\n");
else
printf("NO\n");
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, i, flag = 0, x, y;
cin >> n;
long long int a[200005];
for (i = 1; i <= n; i++) {
a[i] = 0;
}
for (i = 1; i < n; i++) {
cin >> x >> y;
a[x]++;
a[y]++;
}
for (i = 1; i <= n; i++) {
if (a[i] == 2) {
flag = 1;
}
}
if (flag == 0) {
cout << "YES";
} else {
cout << "NO";
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 7;
int d[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
d[u]++, d[v]++;
}
bool flag = true;
for (int i = 1; i <= n; i++) {
if (d[i] == 2) flag = false;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int limit = 1000000;
int n;
vector<int> g[limit];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int u = 1; u <= n; u++) {
vector<int> &ar = g[u];
if (int(ar.size()) == 2) {
cout << "NO" << endl;
exit(0);
}
}
cout << "YES" << endl;
}
| 10 | CPP |
#572_D1
n = int(input())
arr = [0] * n
for i in range(0, n - 1):
l = [int(j) for j in input().split(" ")]
arr[l[0] - 1] += 1
arr[l[1] - 1] += 1
print(["YES", "NO"][2 in arr])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
const double eps = 1e-7;
using namespace std;
int n;
int deg[100010];
int main() {
while (~scanf("%d", &n)) {
int a = 0, b = 0;
memset(deg, 0, sizeof(deg));
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d", &a, &b);
deg[a] += 1;
deg[b] += 1;
}
bool isOk = 1;
for (int i = 1; i <= n; ++i) {
if (deg[i] == 2) {
isOk = 0;
break;
}
}
printf("%s\n", isOk ? "YES" : "NO");
}
return 0;
}
| 10 | CPP |
def add(x):
global d, d2
if x not in d: d[x] = 0
d[x] += 1
if d[x] == 2:
d2[x] = a
if d[x] == 3:
del d2[x]
import sys
n = int(sys.stdin.readline())
d = {}
d2 = {}
for _ in range(n-1):
a, b = map(int, sys.stdin.readline().split())
add(a)
add(b)
res = 'YES'
for k in d2:
res = 'NO'
break
print(res)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[100006];
int main(void) {
int n, x, y;
cin >> n;
for (int i = 1; i < n; i++) cin >> x >> y, a[x]++, a[y]++;
for (int i = 1; i <= n; i++)
if (a[i] == 2) {
cout << "NO";
return 0;
}
cout << "YES";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
unordered_map<int, int> m;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
m[a]++;
m[b]++;
}
for (int i = 1; i <= n; i++) {
if (m[i] == 2) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 2 * 100224;
struct BIT {
long long data[maxN] = {0};
void update(long long idx, long long val) {
while (idx < maxN) {
data[idx] += val;
idx += idx & -idx;
}
}
void update(long long l, long long r, long long val) {
update(l, val);
update(r + 1, -val);
}
long long query(long long idx) {
long long res = 0;
while (idx > 0) {
res += data[idx];
idx -= idx & -idx;
}
return res;
}
long long query(long long l, long long r) { return query(r) - query(l); }
};
struct LazyBIT {
BIT bitAdd, bitSub;
void update(long long l, long long r, long long val) {
bitAdd.update(l, r, val);
bitSub.update(l, r, (l - 1) * val);
bitSub.update(r + 1, (-r + l - 1) * val);
}
long long query(long long idx) {
return idx * bitAdd.query(idx) - bitSub.query(idx);
}
long long query(long long l, long long r) { return query(r) - query(l - 1); }
};
long long parent[maxN];
long long rnk[maxN];
long long lfmost[maxN];
long long rtmost[maxN];
long long vis[maxN];
void make_set(long long v) {
parent[v] = v;
rnk[v] = 0;
lfmost[v] = v;
rtmost[v] = v;
}
long long find_set(long long v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rnk[a] < rnk[b]) swap(a, b);
parent[b] = a;
lfmost[a] = min(lfmost[a], lfmost[b]);
rtmost[a] = max(rtmost[a], rtmost[b]);
if (rnk[a] == rnk[b]) rnk[a]++;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
long long sum = 0;
LazyBIT B;
for (long long i = 1; i <= n; i++) {
B.update(i, i, sum);
sum += i;
}
vector<long long> haha;
for (int i = n - 1; i >= 0; i--) {
long long lo = 1;
long long hi = n;
long long mid;
long long ans;
long long val;
long long temp;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (vis[mid] == 1) {
if (lfmost[find_set(mid)] - 1 >= lo)
mid = lfmost[find_set(mid)] - 1;
else if (rtmost[find_set(mid)] + 1 <= hi)
mid = rtmost[find_set(mid)] + 1;
else
break;
}
val = B.query(mid, mid);
if (val == v[i]) {
ans = mid;
hi = mid - 1;
} else if (v[i] > val) {
lo = mid + 1;
} else if (v[i] < val) {
hi = mid - 1;
}
}
B.update(ans, n, -ans);
vis[ans] = 1;
make_set(ans);
if (vis[ans] == 1 && vis[ans + 1] == 1) union_sets(ans, ans + 1);
if (vis[ans] == 1 && vis[ans - 1] == 1) union_sets(ans, ans - 1);
haha.push_back(ans);
}
reverse(haha.begin(), haha.end());
for (auto u : haha) {
cout << u << " ";
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int const maxn = 1e6 + 5;
long long tree[4 * maxn], lazy[4 * maxn], a[maxn];
int kq[maxn];
int n;
void down(int g) {
if (lazy[g] != 0) {
tree[g << 1] += lazy[g];
lazy[g << 1] += lazy[g];
tree[(g << 1) | 1] += lazy[g];
lazy[(g << 1) | 1] += lazy[g];
lazy[g] = 0;
}
}
void buld(int g, int l, int r) {
if (l == r) {
tree[g] = a[l];
} else {
int m = (l + r) >> 1;
buld(g << 1, l, m);
buld((g << 1) | 1, m + 1, r);
tree[g] = min(tree[g << 1], tree[(g << 1) | 1]);
}
}
void update(int g, int l, int r, int u, int v, long long val) {
if (r < u || v < l) return;
if (u <= l && r <= v) {
tree[g] += val;
lazy[g] += val;
} else {
down(g);
int m = (l + r) >> 1;
update(g << 1, l, m, u, v, val);
update((g << 1) | 1, m + 1, r, u, v, val);
tree[g] = min(tree[g << 1], tree[(g << 1) | 1]);
}
}
int find_zero(int g, int l, int r) {
if (l == r)
return l;
else {
down(g);
int m = (l + r) >> 1;
int res = -1;
if (tree[(g << 1) | 1] == 0)
res = find_zero((g << 1) | 1, m + 1, r);
else
res = find_zero(g << 1, l, m);
tree[g] = min(tree[g << 1], tree[(g << 1) | 1]);
return res;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
buld(1, 1, n);
for (int i = 1; i <= n; i++) {
int pos = find_zero(1, 1, n);
kq[pos] = i;
update(1, 1, n, pos, pos, 1e18);
update(1, 1, n, pos + 1, n, -i);
}
for (int i = 1; i <= n; i++) cout << kq[i] << " ";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, a[500001], f[500001], ans[500001], mn;
int lowbit(int x) { return x & (-x); }
void ins(long long x, long long w) {
long long i;
for (i = x; i <= n; i += lowbit(i)) f[i] += w;
}
long long query(long long x) {
long long xlh = 0, i;
for (i = x; i; i -= lowbit(i)) xlh += f[i];
return xlh;
}
int main() {
long long i, l, r, mid;
scanf("%lld", &n);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (i = 1; i <= n; i++) ins(i, i);
for (i = n; i; i--) {
l = 1;
r = n;
mn = 1;
while (l <= r) {
mid = (l + r) / 2;
if (query(mid - 1) <= a[i])
mn = mid, l = mid + 1;
else
r = mid - 1;
}
ins(mn, -mn);
ans[i] = mn;
}
for (i = 1; i <= n; i++) printf("%lld ", ans[i]);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int ar[4 * 200005];
void update(int a, int b, int l, int h, int p) {
if (a < l || a > h) return;
if (l == h) {
ar[p] += b;
return;
}
int m = (l + h) / 2;
update(a, b, l, m, 2 * p);
update(a, b, m + 1, h, 2 * p + 1);
ar[p] += b;
return;
}
int query(int l, int h, int p, long long int s) {
if (l == h) return l;
int m = (l + h) / 2;
if (ar[2 * p] > s)
return query(l, m, 2 * p, s);
else
return query(m + 1, h, 2 * p + 1, s - ar[2 * p]);
}
int compute(long long int s) {
int x;
s *= 2;
x = sqrt(s);
return x + 1;
}
int main() {
int i, n;
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, 0, n, 1);
update(ans[n - 1], -ans[n - 1], 0, n, 1);
for (i = n - 2; i >= 0; i--) {
ans[i] = query(0, n, 1, sum[i]);
update(ans[i], -ans[i], 0, n, 1);
}
for (i = 0; i < n; i++) printf("%d ", ans[i]);
printf("\n");
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 200100;
pair<long long, long long> tree[256 * 1024 * 2];
long long lazy[256 * 1024 * 2];
void updateRangeUtil(long long si, long long ss, long long se, long long us,
long long ue, long long diff) {
if (lazy[si] != 0) {
tree[si].first += lazy[si];
if (ss != se) {
lazy[si * 2 + 1] += lazy[si];
lazy[si * 2 + 2] += lazy[si];
}
lazy[si] = 0;
}
if (ss > se || ss > ue || se < us) return;
if (ss >= us && se <= ue) {
tree[si].first += diff;
if (ss != se) {
lazy[si * 2 + 1] += diff;
lazy[si * 2 + 2] += diff;
}
return;
}
long long mid = (ss + se) / 2;
updateRangeUtil(si * 2 + 1, ss, mid, us, ue, diff);
updateRangeUtil(si * 2 + 2, mid + 1, se, us, ue, diff);
tree[si] = min(tree[si * 2 + 1], tree[si * 2 + 2]);
}
void updateRange(long long n, long long us, long long ue, long long diff) {
updateRangeUtil(0, 0, n - 1, us, ue, diff);
}
void updateRangeUtil2(long long si, long long ss, long long se, long long us,
long long ue, long long diff) {
if (ss > se || ss > ue || se < us) return;
if (ss >= us && se <= ue) {
tree[si].second += diff;
return;
}
long long mid = (ss + se) / 2;
updateRangeUtil2(si * 2 + 1, ss, mid, us, ue, diff);
updateRangeUtil2(si * 2 + 2, mid + 1, se, us, ue, diff);
tree[si] = min(tree[si * 2 + 1], tree[si * 2 + 2]);
}
void updateRange2(long long n, long long us, long long ue, long long diff) {
updateRangeUtil2(0, 0, n - 1, us, ue, diff);
}
int main() {
long long arr[MAX];
long long n;
cin >> n;
for (long long i = 0; i < n; ++i) {
cin >> arr[i];
}
reverse(arr, arr + n);
for (long long i = 0; i < n; ++i) {
updateRange2(n, i, i, i);
}
for (long long i = 0; i < n; ++i) {
updateRange(n, i, i, arr[i]);
}
long long res[MAX];
for (long long iter = 1; iter <= n; ++iter) {
long long smallest = tree[0].second;
updateRange(n, 0, smallest, -iter);
updateRange(n, smallest, smallest, 1LL << 62);
res[smallest] = iter;
}
reverse(res, res + n);
for (long long i = 0; i < n; ++i) {
if (i) cout << ' ';
cout << res[i];
}
cout << endl;
}
| 10 | CPP |
from sys import stdin,stdout
class Tree(object):
def __init__(self,n):
self.tree=[0]*(4*n+10)
self.b=[0]*(n+10)
self.a=list(map(int,stdin.readline().split()))
self.n=n
def update(self,L,C,l,r,rt):
if l==r:
self.tree[rt]+=C
return
mid=(l+r)//2
if L<=mid:
self.update(L,C,l,mid,rt<<1)
else:
self.update(L,C,mid+1,r,rt<<1|1)
self.tree[rt]=self.tree[rt<<1]+self.tree[rt<<1|1]
def query(self,s,l,r,rt):
if l==r:
return l
mid=(l+r)//2
if self.tree[rt<<1]>s:
return self.query(s,l,mid,rt<<1)
else:
return self.query(s-self.tree[rt<<1],mid+1,r,rt<<1|1)
def slove(self):
for i in range(n):
self.update(i+1,i+1,1,n,1)
for i in range(n,0,-1):
self.b[i]=self.query(self.a[i-1],1,n,1)
self.update(self.b[i],-self.b[i],1,n,1)
for i in range(n):
stdout.write('%d '%(self.b[i+1]))
if __name__ == '__main__':
n=int(stdin.readline())
seg=Tree(n)
seg.slove() | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int maxm = 4e6 + 10;
const long long mod = 1e9 + 7;
const int inf = 0x3ffffff;
const double eps = 1e-5;
long long n, s[maxn];
long long a[maxn], ans[maxn << 2], tag[maxn << 2], m;
long long res[maxn];
inline void push_up(long long p) { ans[p] = ans[p << 1] + ans[p << 1 | 1]; }
inline void f(long long p, long long l, long long r, long long k) {
tag[p] += k;
ans[p] += (r - l + 1) * k;
}
void build(long long l, long long r, long long p) {
if (l == r) {
ans[p] = a[l];
return;
}
long long mid = (l + r) >> 1;
build(l, mid, p << 1);
build(mid + 1, r, p << 1 | 1);
push_up(p);
}
inline void push_down(long long p, long long l, long long r) {
long long mid = (l + r) >> 1;
f(p << 1, l, mid, tag[p]);
f(p << 1 | 1, mid + 1, r, tag[p]);
tag[p] = 0;
}
inline void update(long long nl, long long nr, long long l, long long r,
long long p, long long k) {
if (nl <= l && r <= nr) {
ans[p] += k * (r - l + 1);
tag[p] += k;
return;
}
push_down(p, l, r);
long long mid = (l + r) >> 1;
if (nl <= mid) update(nl, nr, l, mid, p << 1, k);
if (nr > mid) update(nl, nr, mid + 1, r, p << 1 | 1, k);
push_up(p);
}
long long query(long long q_x, long long q_y, long long l, long long r,
long long p) {
long long res = 0;
if (q_x <= l && q_y >= r) return ans[p];
long long mid = (l + r) >> 1;
push_down(p, l, r);
if (q_x <= mid) res += query(q_x, q_y, l, mid, p << 1);
if (q_y > mid) res += query(q_x, q_y, mid + 1, r, p << 1 | 1);
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
a[i] = i;
}
build(1, n, 1);
for (int i = n; i >= 1; i--) {
int l = 1, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (query(1, mid, 1, n, 1) > s[i])
r = mid;
else
l = mid + 1;
}
update(l, l, 1, n, 1, -l);
res[i] = l;
}
for (int i = 1; i <= n; i++) cout << res[i] << " ";
return ~~(0 - 0);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll P[200001];
ll sum[200001];
ll fen[200001];
int ans[200001];
void build() {
for (int i = 1; i <= 200000; i++) {
sum[i] = sum[i - 1] + ll(i - 1);
fen[i] = sum[i] - sum[i - (i & -i)];
}
}
ll query(int l, int r) {
if (l != 1LL) return query(1, r) - query(1, l - 1);
ll ans = 0LL;
while (r > 0) {
ans += fen[r];
r -= r & -r;
}
return ans;
}
void update(int i) {
ll taking = ll(i);
i++;
while (i <= 200000) {
fen[i] -= taking;
i += (i & -i);
}
}
int find(ll s) {
ll cur = 0LL;
int ind = 0;
for (int b = 17; b >= 0; b--) {
if (ind + (1 << b) <= 200000 && cur + fen[ind + (1 << b)] <= s) {
cur += fen[ind + (1 << b)];
ind += (1 << b);
}
}
return ind;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> P[i];
build();
for (int i = n; i >= 1; i--) {
ans[i] = find(P[i]);
update(ans[i]);
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long read() {
char ch = getchar();
long long x = 0, ff = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') ff = -ff;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * ff;
}
void write(long long aa) {
if (aa < 0) putchar('-'), aa = -aa;
if (aa > 9) write(aa / 10);
putchar(aa % 10 + '0');
return;
}
long long n;
long long a[200005];
long long tt[800005], tts[800005], lz[800005];
void up(long long rt) {
tt[rt] = min(tt[rt << 1], tt[rt << 1 | 1]);
if (tt[rt << 1] >= tt[rt << 1 | 1])
tts[rt] = tts[rt << 1 | 1];
else
tts[rt] = tts[rt << 1];
return;
}
void bt(long long rt, long long ll, long long rr) {
if (ll == rr) {
tt[rt] = read(), tts[rt] = ll;
return;
}
long long mid = (ll + rr) >> 1;
bt(rt << 1, ll, mid);
bt(rt << 1 | 1, mid + 1, rr);
up(rt);
return;
}
void push(long long rt) {
if (!lz[rt]) return;
tt[rt << 1] += lz[rt];
tt[rt << 1 | 1] += lz[rt];
lz[rt << 1] += lz[rt];
lz[rt << 1 | 1] += lz[rt];
lz[rt] = 0;
return;
}
void update(long long rt, long long ll, long long rr, long long L, long long R,
long long kk) {
if (ll == L && rr == R) {
tt[rt] += kk;
lz[rt] += kk;
return;
}
long long mid = (ll + rr) >> 1;
push(rt);
if (R <= mid)
update(rt << 1, ll, mid, L, R, kk);
else if (L > mid)
update(rt << 1 | 1, mid + 1, rr, L, R, kk);
else
update(rt << 1, ll, mid, L, mid, kk),
update(rt << 1 | 1, mid + 1, rr, mid + 1, R, kk);
up(rt);
return;
}
int main() {
n = read();
bt(1, 1, n);
for (long long i = 1; i <= n; ++i) {
long long now = tts[1];
a[now] = i;
update(1, 1, n, now, now, n * n);
if (now < n) update(1, 1, n, now + 1, n, -i);
}
for (long long i = 1; i <= n; ++i, putchar(' ')) write(a[i]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 5;
int p[M << 2], res[M];
long long V[M << 2], tag[M << 2];
void push_up(int o) {
if (V[o << 1] < V[o << 1 | 1]) {
V[o] = V[o << 1];
p[o] = p[o << 1];
} else {
V[o] = V[o << 1 | 1];
p[o] = p[o << 1 | 1];
}
}
void push_down(int o) {
tag[o << 1] += tag[o];
tag[o << 1 | 1] += tag[o];
V[o << 1] += tag[o];
V[o << 1 | 1] += tag[o];
tag[o] = 0;
}
void build(int o, int l, int r) {
if (l == r) {
scanf("%lld", &V[o]);
p[o] = l;
return;
}
int mid = (l + r) / 2;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
push_up(o);
}
void upd(int o, int l, int r, int L, int R, long long x) {
if (L > R) return;
if (L <= l && r <= R) {
tag[o] += x;
V[o] += x;
return;
}
int mid = (l + r) / 2;
push_down(o);
if (L <= mid) upd(o << 1, l, mid, L, R, x);
if (R > mid) upd(o << 1 | 1, mid + 1, r, L, R, x);
push_up(o);
}
int main() {
int n;
scanf("%d", &n);
build(1, 1, n);
for (int i = 1; i <= n; i++) {
int pos = p[1];
res[pos] = i;
upd(1, 1, n, pos, pos, 1e11);
upd(1, 1, n, pos + 1, n, -i);
}
for (int i = 1; i <= n; i++) {
printf("%d ", res[i]);
}
return 0;
}
| 10 | CPP |
import sys
input = sys.stdin.readline
n=int(input())
A=list(map(int,input().split()))
BIT=[0]*(n+1)
def update(v,w):
while v<=n:
BIT[v]+=w
v+=(v&(-v))
def getvalue(v):
ANS=0
while v!=0:
ANS+=BIT[v]
v-=(v&(-v))
return ANS
for i in range(1,n+1):
update(i,i)
ANS=[-1]*n
for i in range(n-1,-1,-1):
MIN=0
MAX=n
k=A[i]
while True:
x=(MIN+MAX+1)//2
if getvalue(x)>k:
if getvalue(x-1)==k:
ANS[i]=x
break
else:
MAX=x
else:
MIN=x
update(x,-x)
print(*ANS)
| 10 | PYTHON3 |
class FTree:
def __init__(self, f):
self.n = len(f)
self.ft = [0] * (self.n + 1)
for i in range(1, self.n + 1):
self.ft[i] += f[i - 1]
if i + self.lsone(i) <= self.n:
self.ft[i + self.lsone(i)] += self.ft[i]
def lsone(self, s):
return s & (-s)
def query(self, i, j):
if i > 1:
return self.query(1, j) - self.query(1, i - 1)
s = 0
while j > 0:
s += self.ft[j]
j -= self.lsone(j)
return s
def update(self, i, v):
while i <= self.n:
self.ft[i] += v
i += self.lsone(i)
def select(self, k):
lo = 1
hi = self.n
for i in range(19): ######## 30
mid = (lo + hi) // 2
if self.query(1, mid) < k:
lo = mid
else:
hi = mid
return hi
n = int(input())
data = [int(i) for i in input().split()]
ft = FTree(list(range(1, n+1)))
ans = [""]*n
for i in range(n-1, -1, -1):
val = data[i]
ind = ft.select(val+1)
ans[i] = str(ind)
ft.update(ind, -ind)
print(" ".join(ans)) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int ans[maxn];
int n;
long long a[maxn];
const int maxnode = maxn << 2;
long long sum[maxnode], add[maxnode];
struct Node {
int l, r;
int mid() { return (l + r) >> 1; }
} node[maxnode];
void Pushup(int rt) { sum[rt] = sum[rt << 1] + sum[rt << 1 | 1]; }
void Pushdown(int rt, int m) {
if (add[rt]) {
add[rt << 1] += add[rt];
add[rt << 1 | 1] += add[rt];
sum[rt << 1] += add[rt] * (m - (m >> 1));
sum[rt << 1 | 1] += add[rt] * (m >> 1);
add[rt] = 0;
}
}
void build(int l, int r, int rt) {
node[rt].l = l;
node[rt].r = r;
add[rt] = 0;
if (l == r) {
sum[rt] = (long long)l;
return;
}
int m = node[rt].mid();
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
Pushup(rt);
}
void update(int c, int l, int r, int rt) {
if (node[rt].l == l && node[rt].r == r) {
add[rt] += c;
sum[rt] += (long long)c * (r - l + 1);
return;
}
if (node[rt].l == node[rt].r) return;
Pushdown(rt, node[rt].r - node[rt].l + 1);
int m = node[rt].mid();
if (r <= m)
update(c, l, r, rt << 1);
else if (l > m)
update(c, l, r, rt << 1 | 1);
else {
update(c, l, m, rt << 1);
update(c, m + 1, r, rt << 1 | 1);
}
Pushup(rt);
}
int res;
void query(int l, int r, int rt, long long x) {
if (l == r) {
res = l;
return;
}
int m = node[rt].mid();
Pushdown(rt, m);
if (sum[rt << 1] > x && sum[rt << 1] > 0)
query(l, m, rt << 1, x);
else
query(m + 1, r, rt << 1 | 1, x - sum[rt << 1]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
build(1, n, 1);
for (int i = n; i; i--) {
query(1, n, 1, a[i]);
ans[i] = res;
update(-res, res, res, 1);
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 10;
const long long INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const long long MOD = 1e9 + 7;
long long segtree[MAXN << 2];
long long lazy[MAXN << 2];
long long arr[MAXN];
long long ans[MAXN];
void pushup(long long rt) {
segtree[rt] = min(segtree[rt << 1], segtree[rt << 1 | 1]);
}
void pushdown(long long rt) {
if (lazy[rt]) {
segtree[rt << 1] = max(0ll, segtree[rt << 1] - lazy[rt]);
segtree[rt << 1 | 1] = max(0ll, segtree[rt << 1 | 1] - lazy[rt]);
lazy[rt << 1] += lazy[rt];
lazy[rt << 1 | 1] += lazy[rt];
lazy[rt] = 0;
}
}
void build(long long l, long long r, long long rt) {
lazy[rt] = 0;
if (l == r) {
segtree[rt] = arr[l];
return;
}
long long m = l + r >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
pushup(rt);
}
long long query(long long l, long long r, long long rt) {
if (l == r) {
return l;
}
long long m = l + r >> 1;
pushdown(rt);
if (!segtree[rt << 1 | 1])
return query(m + 1, r, rt << 1 | 1);
else
return query(l, m, rt << 1);
}
void update(long long l, long long r, long long L, long long R, long long C,
long long rt) {
if (L <= l && r <= R) {
segtree[rt] = max(0ll, segtree[rt] - C);
lazy[rt] += C;
return;
}
long long m = l + r >> 1;
pushdown(rt);
if (L <= m) update(l, m, L, R, C, rt << 1);
if (R > m) update(m + 1, r, L, R, C, rt << 1 | 1);
pushup(rt);
}
void update(long long l, long long r, long long pos, long long rt) {
if (l == r && l == pos) {
segtree[rt] = LLINF;
return;
}
long long m = l + r >> 1;
pushdown(rt);
if (pos <= m)
update(l, m, pos, rt << 1);
else
update(m + 1, r, pos, rt << 1 | 1);
pushup(rt);
}
signed main() {
long long n;
scanf("%lld", &n);
for (long long i = 1; i <= n; ++i) {
scanf("%lld", &arr[i]);
}
build(1, n, 1);
long long now = 0;
for (long long i = n; i > 0; --i) {
long long index = query(1, n, 1);
ans[index] = ++now;
if (index + 1 <= n) update(1, n, index + 1, n, now, 1);
update(1, n, index, 1);
}
for (long long i = 1; i <= n; ++i) printf("%lld ", ans[i]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long b[200005];
int n;
long long sum(long long x) {
if (x == 0) {
return 0;
}
long long pas = 0;
while (x > 0) {
pas += b[x];
x = x & (x - 1);
}
return pas;
}
void update(long long x, long long i) {
while (i <= n) {
b[i] += x;
i += (i & (-i));
}
}
int main() {
cin >> n;
long long s[n + 1];
s[0] = 0;
int p[n + 1];
p[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> s[i];
update(i, i);
}
int mid = 0;
for (int i = n; i > 0; i--) {
int l = 1;
int r = n;
while (l != r) {
mid = (l + r + 1) / 2;
if (sum(mid - 1) <= s[i]) {
l = mid;
} else {
r = mid - 1;
}
}
update(-l, l);
p[i] = l;
}
for (int i = 1; i <= n; i++) {
cout << p[i] << " ";
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, p[N];
long long a[N], tr[N << 2];
void build(int k, int l, int r) {
if (l == r) {
tr[k] = l;
return;
}
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
tr[k] = tr[k << 1] + tr[k << 1 | 1];
}
void add(int k, int l, int r, int v) {
if (l == r) {
tr[k] = 0;
return;
}
int mid = l + r >> 1;
if (v <= mid)
add(k << 1, l, mid, v);
else
add(k << 1 | 1, mid + 1, r, v);
tr[k] = tr[k << 1] + tr[k << 1 | 1];
}
int query(int k, int l, int r, long long v) {
if (l == r) {
return l - 1;
}
int mid = l + r >> 1;
if (tr[k << 1] > v)
return query(k << 1, l, mid, v);
else
return query(k << 1 | 1, mid + 1, r, v - tr[k << 1]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
build(1, 1, n);
for (int i = n; i >= 1; i--) {
p[i] = query(1, 1, n, a[i]) + 1;
add(1, 1, n, p[i]);
}
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<int, int>;
using ld = long double;
using pii = pair<int, int>;
using dbl = long double;
using vll = vector<int>;
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
const ll mod = 1000000007;
const ll N = 2e5 + 10;
const ll inf = 1e16 + 10;
ll seg[4 * N], lz[4 * N], a[N], n;
ll merge(ll x, ll y) { return min(x, y); }
ll cnt(ll l, ll r) { return 1; }
void build(ll cur, ll s, ll e) {
if (s == e) {
seg[cur] = a[s];
return;
}
build(cur + cur, s, (s + e) / 2);
build(cur + cur + 1, (s + e) / 2 + 1, e);
seg[cur] = merge(seg[cur + cur], seg[cur + cur + 1]);
}
void propogate(ll cur, ll s, ll e) {
if (s != e) {
lz[cur + cur] += lz[cur];
lz[cur + cur + 1] += lz[cur];
}
seg[cur] += cnt(s, e) * lz[cur];
lz[cur] = 0;
}
void update(ll cur, ll s, ll e, ll l, ll r, ll val) {
propogate(cur, s, e);
if (e < l || s > r) return;
if (l <= s && e <= r) {
lz[cur] += val;
propogate(cur, s, e);
return;
}
update(cur + cur, s, (s + e) / 2, l, r, val);
update(cur + cur + 1, (s + e) / 2 + 1, e, l, r, val);
seg[cur] = merge(seg[cur + cur], seg[cur + cur + 1]);
}
ll query(ll cur, ll s, ll e, ll l, ll r) {
propogate(cur, s, e);
if (e < l || s > r) return inf;
if (l <= s && e <= r) return seg[cur];
ll q1 = query(cur + cur, s, (s + e) / 2, l, r);
ll q2 = query(cur + cur + 1, (s + e) / 2 + 1, e, l, r);
return merge(q1, q2);
}
ll dfs(ll cur, ll s, ll e) {
propogate(cur, s, e);
if (s == e) {
return s;
}
propogate(cur + cur, s, (s + e) / 2);
propogate(cur + cur + 1, (s + e) / 2 + 1, e);
if (seg[cur + cur + 1] == 0) {
return dfs(cur + cur + 1, (s + e) / 2 + 1, e);
} else {
return dfs(cur + cur, s, (s + e) / 2);
}
}
void build() { build(1, 1, n); }
void update(ll pos, ll val) { update(1, 1, n, pos, pos, val); }
void update(ll l, ll r, ll val) { update(1, 1, n, l, r, val); }
ll query(ll l, ll r) { return query(1, 1, n, l, r); }
signed main() {
cin >> n;
for (ll i = 1; i <= n; i++) {
cin >> a[i];
}
build();
ll ans[n];
for (ll i = 0; i < n; i++) {
ll x = dfs(1, 1, n);
update(x, inf);
update(x + 1, n, -(i + 1));
ans[x - 1] = i + 1;
}
for (ll i = 0; i < n; i++) {
cout << ans[i] << " ";
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int fen[200005];
void upd(long long int x, long long int a) {
for (long long int i = x; i < 200005; i += (i & (-i))) {
fen[i] += a;
}
}
long long int ret(long long int x) {
long long int o = 0;
for (long long int i = x; i > 0; i -= (i & (-i))) {
o += fen[i];
}
return o;
}
int main() {
long long int n;
cin >> n;
long long int s[n];
for (long long int i = 0; i < n; i++) {
cin >> s[i];
upd(i + 1, i + 1);
}
long long int out[n];
for (long long int i = n - 1; i >= 0; i--) {
long long int l = 0, h = n - 1;
while (h - l > 1) {
long long int mi = (h + l) / 2;
if (ret(mi) > s[i]) {
h = mi;
} else {
l = mi;
}
}
if (ret(h) == s[i]) {
out[i] = h + 1;
upd(h + 1, -h - 1);
} else {
out[i] = l + 1;
upd(l + 1, -l - 1);
}
cout << "\n";
}
for (long long int i = 0; i < n; i++) {
cout << out[i] << " ";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 200100;
const long long INF = 2000000100;
const long long MOD = 998244353;
long long N, S[MAXN], P[MAXN];
long long B[MAXN];
void update(int ind, long long v) {
for (int i = ind; i <= N; i += (i & -i)) {
B[i] += v;
}
}
long long query(int ind) {
if (ind == 0) return 0;
long long s = 0;
for (int i = ind; i > 0; i -= (i & -i)) {
s += B[i];
}
return s;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> N;
for (int i = 0; i < N; i++) cin >> S[i];
for (int i = 1; i <= N; i++) update(i, i);
for (int i = N - 1; i >= 0; i--) {
long long a = 1, b = N, c;
long long ans = -39;
while (a <= b) {
c = (a + b) / 2;
if (query(c - 1) > S[i]) {
b = c - 1;
} else {
ans = c;
a = c + 1;
}
}
P[i] = ans;
update(ans, -ans);
}
for (int i = 0; i < N; i++) cout << P[i] << (i == N - 1 ? "\n" : " ");
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct node {
int64_t data, lazy;
int pos;
};
node st[200001 * 4];
int64_t input[200001];
int anw[200001];
void output(int root, int L, int R) {
if (L == R) {
return;
}
int mid = (L + R) >> 1;
output(root << 1, L, mid);
output(root << 1 | 1, mid + 1, R);
}
void Init(int root, int L, int R) {
st[root].lazy = 0;
if (L == R) {
st[root].data = input[L];
st[root].pos = L;
return;
}
int mid = (L + R) >> 1;
Init(root << 1, L, mid);
Init(root << 1 | 1, mid + 1, R);
int lpos = root << 1, rpos = root << 1 | 1;
st[root].data = min(st[lpos].data, st[rpos].data);
if (st[root].data == st[rpos].data) {
st[root].pos = st[rpos].pos;
} else {
st[root].pos = st[lpos].pos;
}
}
void Update(int root, int l, int r, int L, int R, int64_t val) {
if (l == L && r == R) {
st[root].lazy += val;
st[root].data += val;
return;
}
int mid = (L + R) >> 1;
if (st[root].lazy != 0) {
Update(root << 1, L, mid, L, mid, st[root].lazy);
Update(root << 1 | 1, mid + 1, R, mid + 1, R, st[root].lazy);
st[root].lazy = 0;
}
if (r <= mid) {
Update(root << 1, l, r, L, mid, val);
} else if (mid < l) {
Update(root << 1 | 1, l, r, mid + 1, R, val);
} else {
Update(root << 1, l, mid, L, mid, val);
Update(root << 1 | 1, mid + 1, r, mid + 1, R, val);
}
int lpos = root << 1, rpos = root << 1 | 1;
st[root].data = min(st[lpos].data, st[rpos].data);
if (st[root].data == st[rpos].data) {
st[root].pos = st[rpos].pos;
} else {
st[root].pos = st[lpos].pos;
}
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> input[i];
}
Init(1, 1, n);
int64_t MAX = int64_t(n) * int64_t(n) * int64_t(100);
if (n == 2) {
output(1, 1, n);
}
for (int i = 1; i <= n; i++) {
int pos = st[1].pos;
anw[pos] = i;
Update(1, pos, pos, 1, n, MAX);
Update(1, pos, n, 1, n, int64_t(i * -1));
if (n == 2) {
output(1, 1, n);
}
}
for (int i = 1; i <= n; i++) {
cout << anw[i] << " ";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10, Max = 101;
const int MOD = 1000000007;
const long long OO = 2e12 + 5000;
const long long Sqrt = 710;
const double PI = acos(-1);
const double EPS = 1e-9;
int n;
long long a[N];
pair<long long, long long> seg[4 * N];
long long lazy[8 * N];
void push(int p) {
if (!lazy[p]) return;
seg[p].first += lazy[p];
lazy[p * 2] += lazy[p];
lazy[p * 2 + 1] += lazy[p];
lazy[p] = 0;
}
void build(int p = 1, int s = 1, int e = n) {
if (s == e) {
seg[p] = {a[s], -s};
return;
}
int mid = (s + e) / 2;
build(p * 2, s, mid);
build(p * 2 + 1, mid + 1, e);
seg[p] = min(seg[p * 2], seg[p * 2 + 1]);
}
void update(int from, int to, long long val, int p = 1, int s = 1, int e = n) {
push(p);
if (s > to || from > e) return;
if (s >= from && e <= to) {
lazy[p] += val;
push(p);
return;
}
int mid = (s + e) / 2;
update(from, to, val, p * 2, s, mid);
update(from, to, val, p * 2 + 1, mid + 1, e);
seg[p] = min(seg[p * 2], seg[p * 2 + 1]);
}
pair<long long, long long> get(int from = 1, int to = n, int p = 1, int s = 1,
int e = n) {
push(p);
if (s > to || from > e) return {OO, OO};
if (s >= from && e <= to) {
return seg[p];
}
int mid = (s + e) / 2;
pair<long long, long long> first = get(from, to, p * 2, s, mid);
pair<long long, long long> second = get(from, to, p * 2 + 1, mid + 1, e);
return min(first, second);
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
vector<int> sol(N);
build();
int cnt = 0;
for (int i = 1; i <= n; ++i) {
pair<long long, long long> mn = get();
int idx = mn.second * -1;
assert(mn.second != OO);
sol[idx] = i;
long long val = OO;
update(idx, idx, val);
val = i;
update(1 + idx, n, -val);
}
for (int i = 1; i <= n; ++i) cout << sol[i] << " ";
cout << endl;
}
| 10 | CPP |
# https://codeforces.com/contest/1208/problem/D
from sys import stdin, stdout
input = stdin.readline
# print = stdout.write
# si is the sum of elements before the i-th element that are smaller than the i-th element.
# For every i from N to 1, let's say the value of the si is x.
# So it means there are k smallest unused numbers whose sum is x.
# We simply put the k+1st number in the output permutation at this i, and continue to move left.
# BIT and binary lifting
# https://codeforces.com/contest/1208/submission/59526098
class BIT:
def __init__(self, nums):
# we store the sum information in bit 1.
# so the indices should be 1 based.
# here we assume nums[0] = 0
self.nums = [0] * (len(nums))
for i, x in enumerate(nums):
if i == 0:
continue
self.update(i, x)
def low_bit(self, x):
return x & (-x)
def update(self, i, diff):
while i < len(self.nums):
self.nums[i] += diff
i += self.low_bit(i)
def prefix_sum(self, i):
ret = 0
while i != 0:
ret += self.nums[i]
i -= self.low_bit(i)
return ret
def search(self, x):
# find the index i such that prefix_sum(i) == x
cur_index, cur_sum = 0, 0
delta = len(self.nums) - 1
while delta - self.low_bit(delta):
delta -= self.low_bit(delta)
while delta:
m = cur_index + delta
if m < len(self.nums):
sm = cur_sum + self.nums[m]
if sm <= x:
cur_index, cur_sum = m, sm
delta //= 2
return cur_index + 1
n = int(input())
bit = BIT(range(n+1))
ans = [0 for _ in range(n)]
nums = list(map(int, input().split()))
for i in range(n - 1, -1, -1):
index = bit.search(nums[i])
bit.update(index, -index)
ans[i] = index
print(*ans)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
class {
public:
pair<long long, long long> T[200009 << 2];
long long lz[200009 << 2];
long long n, f[200009], ans[200009];
void solve() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> f[i];
build(1, 1, n);
for (int i = 1; i <= n; ++i) {
auto res = query(1, 1, n, 1, n);
ans[res.second] = i;
update(1, 1, n, res.second + 1, n, -i);
update(1, 1, n, res.second, res.second, 1e18);
}
for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
}
void build(int rt, int l, int r) {
lz[rt] = 0;
if (l == r) {
T[rt] = {f[l], l};
return;
}
int mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
up(rt);
}
void up(int rt) {
if (T[rt << 1].first == T[rt << 1 | 1].first) {
T[rt] = T[rt << 1 | 1];
} else {
T[rt] = min(T[rt << 1], T[rt << 1 | 1]);
}
}
void update(int rt, int l, int r, int ll, int rr, long long v) {
if (ll > rr) return;
if (ll <= l && rr >= r) {
lz[rt] += v;
T[rt].first += v;
return;
}
int mid = l + r >> 1;
down(rt);
if (ll <= mid) update(rt << 1, l, mid, ll, rr, v);
if (rr > mid) update(rt << 1 | 1, mid + 1, r, ll, rr, v);
up(rt);
}
pair<long long, long long> query(int rt, int l, int r, int ll, int rr) {
if (ll <= l && rr >= r) {
return T[rt];
}
int mid = l + r >> 1;
down(rt);
pair<long long, long long> res = {1e18, 1e18};
if (ll <= mid) {
pair<long long, long long> ret = query(rt << 1, l, mid, ll, rr);
if (ret.first == res.first)
res.second = ret.second;
else
res = min(res, ret);
}
if (rr > mid) {
pair<long long, long long> ret = query(rt << 1 | 1, mid + 1, r, ll, rr);
if (ret.first == res.first)
res.second = ret.second;
else
res = min(res, ret);
}
return res;
}
void down(int rt) {
if (lz[rt]) {
T[rt << 1].first += lz[rt];
lz[rt << 1] += lz[rt];
T[rt << 1 | 1].first += lz[rt];
lz[rt << 1 | 1] += lz[rt];
lz[rt] = 0;
}
}
} NSPACE;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
NSPACE.solve();
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const long long inf = 1000000000000;
const int N = 200005;
const long long LLMAX = 2e18;
const long long MOD = 1000000009ll;
const double eps = 1e-8;
const int MAXN = 1e6 + 10;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int read() {
int 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;
}
int n, ans[N];
long long a[N];
struct SegmentTree {
int l, r, id;
long long v, add;
} tree[N * 4];
void push_up(int i) {
if (tree[i << 1 | 1].v == tree[i << 1].v) {
if (tree[i << 1 | 1].id > tree[i << 1].id) {
tree[i].id = tree[i << 1 | 1].id;
tree[i].v = tree[i << 1 | 1].v;
} else {
tree[i].id = tree[i << 1].id;
tree[i].v = tree[i << 1].v;
}
} else {
if (tree[i << 1].v < tree[i << 1 | 1].v) {
tree[i].id = tree[i << 1].id;
tree[i].v = tree[i << 1].v;
} else {
tree[i].id = tree[i << 1 | 1].id;
tree[i].v = tree[i << 1 | 1].v;
}
}
return;
}
void build(int p, int l, int r) {
tree[p].l = l, tree[p].r = r;
if (l == r) {
tree[p].v = a[l];
tree[p].id = r;
return;
}
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
push_up(p);
}
void spread(int p) {
if (tree[p].add) {
tree[p << 1].add += tree[p].add;
tree[p << 1 | 1].add += tree[p].add;
tree[p << 1].v += tree[p].add;
tree[p << 1 | 1].v += tree[p].add;
tree[p].add = 0;
}
}
void change(int p, int l, int r, long long d) {
if (l <= tree[p].l && r >= tree[p].r) {
tree[p].v += d;
tree[p].add += d;
return;
}
spread(p);
int mid = (tree[p].l + tree[p].r) >> 1;
if (l <= mid) change(p << 1, l, r, d);
if (r > mid) change(p << 1 | 1, l, r, d);
push_up(p);
}
int main(int argc, char const *argv[]) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
build(1, 1, n);
for (int i = 1; i <= n; ++i) {
ans[tree[1].id] = i;
int d = tree[1].id;
change(1, d, d, 10000000000000);
change(1, d + 1, n, -i);
}
for (int i = 1; i <= n; ++i) {
printf("%d%c", ans[i], " \n"[i == n]);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 2e9;
const long long INFLL = 1e18;
const int MAX_N = 1;
int N;
vector<long long> v;
struct SEG {
struct NODE {
int l, r;
long long data;
};
vector<NODE> seg;
int SZ;
void add() { seg.push_back((NODE){-1, -1, (long long)0}); }
void Init(int x) {
SZ = x;
add();
init(0, 1, SZ);
}
void init(int idx, int s, int e) {
if (s == e) return;
seg[idx].l = seg.size();
add();
seg[idx].r = seg.size();
add();
init(seg[idx].l, s, (s + e) / 2);
init(seg[idx].r, (s + e) / 2 + 1, e);
}
void Update(int x, long long y) { update(0, 1, SZ, x, y); }
void update(int idx, int s, int e, int x, long long y) {
seg[idx].data += y;
if (s == e) return;
if (x <= (s + e) / 2)
update(seg[idx].l, s, (s + e) / 2, x, y);
else
update(seg[idx].r, (s + e) / 2 + 1, e, x, y);
}
long long Sum(int x, int y) { return sum(0, 1, SZ, x, y); }
long long sum(int idx, int s, int e, int x, int y) {
if (x <= s && e <= y)
return seg[idx].data;
else if (x > e || y < s)
return 0;
return sum(seg[idx].l, s, (s + e) / 2, x, y) +
sum(seg[idx].r, (s + e) / 2 + 1, e, x, y);
}
};
SEG Seg;
vector<long long> ans;
set<int> st;
int main() {
cin >> N;
Seg.Init(N);
for (int i = 0; i < N; i++) {
long long x;
scanf("%lld", &x);
v.push_back(x);
}
for (int i = 1; i <= N; i++) {
Seg.Update(i, i);
st.insert(i);
}
while (!v.empty()) {
long long x = v.back();
v.pop_back();
int s = 1, e = N, m;
while (s < e) {
m = (s + e) / 2 + 1;
if (Seg.Sum(1, m - 1) > x) {
e = m - 1;
} else {
s = m;
}
}
s = (*st.lower_bound(s));
st.erase(s);
ans.push_back(s);
Seg.Update(s, -s);
}
while (!ans.empty()) {
printf("%d ", (int)ans.back());
ans.pop_back();
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const int inf = INT_MAX;
const int MAX = 3e6 + 9;
const long long MOD = 1e9 + 7;
const int TOT_PRIMES = 1e6 + 9;
const int MAX_A = 71;
const int LN = 20;
using namespace std;
long long bt[MAX];
long long arr[MAX];
void update(int x, long long val) {
for (int i = x; i < MAX; i += i & -i) bt[i] += val;
}
long long query(int x) {
long long res = 0;
for (int i = x; i > 0; i -= i & -i) res = res + bt[i];
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= n; i++) update(i, i);
int ans[n + 1];
for (int i = n; i >= 1; i--) {
int l = 0, r = n;
while (l <= r) {
int mid = (l + r) / 2;
if (query(mid) > arr[i])
r = mid - 1;
else
l = mid + 1;
}
ans[i] = l;
update(l, -l);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
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';
}
| 10 | CPP |
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!
from sys import stdin, stdout
from collections import defaultdict
from collections import deque
import math
import copy
#T = int(input())
N = int(input())
#s1 = input()
#s2 = input()
#N,Q = [int(x) for x in stdin.readline().split()]
arr = [int(x) for x in stdin.readline().split()]
bit = [0]*(N+1)
series = [0] + [x for x in range(N)]
def lowbit(x):
return x&(-x)
def update(idx,delta):
while idx<=N:
bit[idx] += delta
idx += lowbit(idx)
def query(x):
s = 0
while x>0:
s += bit[x]
x -= lowbit(x)
return s
# init
for i in range(1,N+1):
bit[i] += series[i]
y = i + lowbit(i)
if y<=N:
series[y] += series[i]
visited = [0]*(N+1)
ans = [0]*N
for i in range(N-1,-1,-1):
# find
left = 1
right = N
target = arr[i]
while left<=right:
mid = (left+right)//2
q = query(mid)
#print(mid,q)
if q<target:
left = mid + 1
elif q>target:
right = mid - 1
else:
if visited[mid]==1:
left = mid + 1
else:
visited[mid] = 1
ans[i] = mid
break
# update
update(mid+1,-mid)
print(*ans)
| 10 | PYTHON3 |
#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");
}
}
| 10 | CPP |
def sum_number(n,j):
j[0]=0
j[1]=0
for i in range(2,n+1):
j[i]=j[i-1]+(i-1)
return(j)
po=int(input())
l=[0]*(po+1)
l1=[int(i) for i in input().split()]
def getsum(BITTree,i):
s = 0
while i > 0:
s += BITTree[i]
i -= i & (-i)
return(s)
def updatebit(BITTree , n , i ,v):
#print('n',n)
while i <= n:
#print('i',i)
BITTree[i] += v
i += i & (-i)
#print(BITTree)
for i in range(1,po+1):
updatebit(l,po,i,i)
output=[0]*po
for i in range(po-1,-1,-1):
min_=0
max_=po
k=l1[i]
while True:
x=(min_+max_+1)//2
if getsum(l,x)>k:
if getsum(l,x-1)==k:
output[i]=x
break
else:
#print(x)
max_=x
else :
#print(x)
min_=x
updatebit(l,po,x,-x)
print(*output)
| 10 | PYTHON3 |
#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;
}
| 10 | CPP |
#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]);
}
| 10 | CPP |
#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;
}
| 10 | CPP |
#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] << ' ';
}
}
| 10 | CPP |
#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] << " ";
}
}
| 10 | CPP |
#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] << " ";
}
}
| 10 | CPP |
#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;
}
| 10 | CPP |
#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;
}
| 10 | CPP |
import sys
input = sys.stdin.readline
nn = 18
bit=[0]*(2**nn+1)
def addbit(i, x):
while i <= 2**nn:
bit[i] += x
i += i & (-i)
def getsum(i):
ret = 0
while i != 0:
ret += bit[i]
i -= i&(-i)
return ret
def searchbit(x):
l, sl = 0, 0
d = 2**(nn-1)
while d:
m = l + d
sm = sl + bit[m]
if sm <= x:
l, sl = m, sm
d //= 2
return l + 1
n = int(input())
l = list(map(int, input().split()))
for i in range(1, n + 1):
addbit(i, i)
ans = [0 for _ in range(n)]
for i in range(n - 1, -1, -1):
a = searchbit(l[i])
addbit(a, -a)
ans[i] = a
print(*ans)
| 10 | PYTHON3 |
#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;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool mini(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool maxi(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int N = 2e5 + 5;
int n, ans[N];
long long bit[N], p[N];
void up(int i) {
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();
}
| 10 | CPP |
#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;
}
| 10 | CPP |
#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] << " ";
}
| 10 | CPP |
#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;
}
| 10 | CPP |
#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;
}
| 10 | CPP |
#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;
}
| 10 | CPP |
#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");
}
| 10 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.