question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>def comp(x):</line-1>
<line-3> if x % i == 0:</line-3>
<line-4> return True</line-4>
<line-5> return False</line-5>
<line-6></line-6>
<line-7>N = int(input())</line-7>
<line-8></line-8>
<line-9>if N == 4:</line-9>
<line-10> print('YES', '1', '3', '2', '4', sep = '\n')</line-10>
<line-11>elif comp(N):</line-11>
<line-12> print('NO')</line-12>
<line-13>else:</line-13>
<line-14> print('YES', '1', sep = '\n')</line-14>
<line-15> if N > 1:</line-15>
<line-16> for i in range(2, N):</line-16>
<line-18> print(N)</line-18>
<line-19> </line-19>
|
{"code": "<line-2> for i in range(2, x):</line-2>\n<line-17> print((i - 1) * pow(i, N - 2, N) % N)</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>from collections import defaultdict</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5> n, T = [int(_) for _ in input().split()]</line-5>
<line-6> data = defaultdict(list)</line-6>
<line-7> for i in range(n):</line-7>
<line-8> t, q = [int(_) for _ in input().split()]</line-8>
<line-9> data[T - t].append(q)</line-9>
<line-10></line-10>
<line-11> prev_level = []</line-11>
<line-12> for level_id in range(1, T + 1):</line-12>
<line-13> level = sorted(data[T - level_id] + prev_level, reverse=True) </line-13>
<line-14> if T - level_id <= 10:</line-14>
<line-15> max_size = 2 ** (T - level_id)</line-15>
<line-16> level = level[:max_size]</line-16>
<line-17> if len(level) % 2 == 1:</line-17>
<line-18> level.append(0)</line-18>
<line-19> prev_level = [</line-19>
<line-20> level[i] + level[i + 1]</line-20>
<line-21> for i in range(0, len(level), 2)</line-21>
<line-22> ]</line-22>
<line-24></line-24>
<line-25>__starting_point()</line-25>
|
{"code": "<line-4>def __starting_point():</line-4>\n<line-23> print(prev_level[0])</line-23>", "lines": [4, 23]}
#### 0
|
<line-1>import sys</line-1>
<line-3>arr = list(map(int, sys.stdin.readline().split()))</line-3>
<line-4>tot = sum(arr)</line-4>
<line-5>if tot % k != 0:</line-5>
<line-6> print('No')</line-6>
<line-7> return</line-7>
<line-8>tot //= k</line-8>
<line-9>idx,cur = 0,0</line-9>
<line-10>ans = []</line-10>
<line-11>for i in range(n):</line-11>
<line-12> cur += arr[i]</line-12>
<line-13> idx += 1</line-13>
<line-14> if cur == tot:</line-14>
<line-15> ans.append(idx)</line-15>
<line-16> idx = 0</line-16>
<line-17> cur = 0</line-17>
<line-18> elif cur > tot:</line-18>
<line-19> print('No')</line-19>
<line-20> return</line-20>
<line-21>if sum(ans) != n:</line-21>
<line-22> print('No')</line-22>
<line-23> return</line-23>
<line-24>print('Yes')</line-24>
<line-26> print(an,end=' ')</line-26>
|
{"code": "<line-2>n,k = map(int, sys.stdin.readline().split())</line-2>\n<line-25>for an in ans:</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>f = lambda: map(int, input().split())</line-1>
<line-3>wb = [(0, 0)] + list(zip(f(), f()))</line-3>
<line-4>t = list(range(n + 1))</line-4>
<line-5></line-5>
<line-6></line-6>
<line-7>def g(x):</line-7>
<line-8> if x == t[x]: return x</line-8>
<line-9> t[x] = g(t[x])</line-9>
<line-10> return t[x]</line-10>
<line-11></line-11>
<line-12></line-12>
<line-13>for i in range(m):</line-13>
<line-14> x, y = f()</line-14>
<line-15> x, y = g(x), g(y)</line-15>
<line-16> if x != y: t[y] = x</line-16>
<line-17></line-17>
<line-18>p = [[] for j in range(n + 1)]</line-18>
<line-19>for i in range(1, n + 1): p[g(i)].append(i)</line-19>
<line-20></line-20>
<line-21>d = [1] + [0] * w</line-21>
<line-22>for q in p:</line-22>
<line-23> if len(q) > 1:</line-23>
<line-24> WB = [wb[i] for i in q]</line-24>
<line-25> SW = sum(q[0] for q in WB)</line-25>
<line-26> SB = sum(q[1] for q in WB)</line-26>
<line-27></line-27>
<line-28> for D in range(w, -1, -1):</line-28>
<line-29> if d[D]:</line-29>
<line-30> if D + SW <= w: d[D + SW] = max(d[D + SW], d[D] + SB)</line-30>
<line-31> for W, B in WB:</line-31>
<line-32> if D + W <= w: d[D + W] = max(d[D + W], d[D] + B)</line-32>
<line-33></line-33>
<line-34> elif len(q) == 1:</line-34>
<line-35> W, B = wb[q[0]]</line-35>
<line-36> for D in range(w - W, -1, -1):</line-36>
<line-38></line-38>
<line-39>print(max(d) - 1)</line-39>
|
{"code": "<line-2>n, m, w = f()</line-2>\n<line-37> if d[D]: d[D + W] = max(d[D + W], d[D] + B)</line-37>", "lines": [2, 37]}
#### 0
|
<line-1>maxn=50+10</line-1>
<line-3>dp=[None]*maxn</line-3>
<line-4>c=[None]*maxn</line-4>
<line-5>size=[0]*maxn</line-5>
<line-6></line-6>
<line-7>for i in range(0,maxn):</line-7>
<line-8> c[i]=[0]*maxn</line-8>
<line-9> c[i][0]=1</line-9>
<line-10> for j in range(1,i+1):</line-10>
<line-11> c[i][j]=c[i-1][j-1]+c[i-1][j]</line-11>
<line-12></line-12>
<line-13>n=int(input())</line-13>
<line-14>for i in range(1,n+1):</line-14>
<line-15> g[i]=[]</line-15>
<line-16>for i in range(1,n):</line-16>
<line-17> u,v=input().split()</line-17>
<line-18> u=int(u)</line-18>
<line-19> v=int(v)</line-19>
<line-20> g[u].append(v)</line-20>
<line-21> g[v].append(u)</line-21>
<line-22></line-22>
<line-23>def mul(a,b,x,y):</line-23>
<line-24> tmp=[0]*(x+y+1)</line-24>
<line-25> for i in range(0,x+1):</line-25>
<line-26> for j in range(0,y+1):</line-26>
<line-27> tmp[i+j]+=a[i]*b[j]*c[i+j][i]*c[x+y-i-j][x-i]</line-27>
<line-28> return tmp</line-28>
<line-29>def dfs(pos,fa):</line-29>
<line-30> nonlocal dp</line-30>
<line-31> nonlocal size</line-31>
<line-32> dp[pos]=[1]</line-32>
<line-33> size[pos]=0</line-33>
<line-34> for ch in g[pos]:</line-34>
<line-35> if ch != fa:</line-35>
<line-36> dfs(pos=ch,fa=pos)</line-36>
<line-37> dp[pos]=mul(dp[pos],dp[ch],size[pos],size[ch])</line-37>
<line-38> size[pos]+=size[ch]</line-38>
<line-39> if fa:</line-39>
<line-40> size[pos]+=1</line-40>
<line-41> tmp=[0]*(size[pos]+1)</line-41>
<line-42> for i in range(0,size[pos]+1):</line-42>
<line-43> for j in range(0,size[pos]):</line-43>
<line-44> if j<i:</line-44>
<line-45> tmp[i]+=dp[pos][i-1]</line-45>
<line-46> else:</line-46>
<line-47> tmp[i]+=dp[pos][j]*0.5</line-47>
<line-48> dp[pos]=tmp</line-48>
<line-49></line-49>
<line-50>for i in range(1,n+1):</line-50>
<line-51> dfs(pos=i,fa=0)</line-51>
<line-52> tmp=dp[i][0]</line-52>
<line-53> for j in range(1,n):</line-53>
<line-55> print(tmp)</line-55>
|
{"code": "<line-2>g=[None]*maxn</line-2>\n<line-54> tmp/=j</line-54>", "lines": [2, 54]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>MOD = 10**9+7</line-4>
<line-5>S = readline().strip().split('1')</line-5>
<line-6>if len(S) == 1:</line-6>
<line-7> print(len(S[0]))</line-7>
<line-8>else:</line-8>
<line-9> S = [len(s)+1 for s in S]</line-9>
<line-10> ans = S[0]*S[-1]</line-10>
<line-11> S = S[1:-1]</line-11>
<line-12> </line-12>
<line-13> dp = [0]*(max(S)+2)</line-13>
<line-14> dp[0] = 1</line-14>
<line-15> for ai in S:</line-15>
<line-16> res = 0</line-16>
<line-17> rz = 0</line-17>
<line-18> for i in range(ai+1):</line-18>
<line-19> res = (res + dp[i])%MOD</line-19>
<line-20> rz = (rz + (ai-i)*dp[i])%MOD</line-20>
<line-21> dp[i] = 0</line-21>
<line-22> dp[0] = rz</line-22>
<line-23> dp[ai] = res</line-23>
<line-24> aaa = 0</line-24>
<line-25> for d in dp:</line-25>
<line-27> print(aaa*ans%MOD)</line-27>
|
{"code": "<line-2>readline = sys.stdin.readline</line-2>\n<line-26> aaa = (aaa+d)%MOD</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def main():</line-4>
<line-5> n, m = map(int, input().split())</line-5>
<line-6> a = list(map(int, input().split())) + [0]*500000</line-6>
<line-7> ans_S = 0</line-7>
<line-8> a[n] = a[0] + m</line-8>
<line-9> s = [0]*600600</line-9>
<line-10> for i in range(n):</line-10>
<line-11> s[i] = a[i + 1] - a[i]</line-11>
<line-12> s[n] = -1</line-12>
<line-13> for i in range(n):</line-13>
<line-14> s[2*n - i] = s[i]</line-14>
<line-15> for i in range(2*n + 1, 3*n + 1):</line-15>
<line-16> s[i] = s[i - n]</line-16>
<line-17> l, r = 0, 0</line-17>
<line-18> z = [0]*600600</line-18>
<line-19> for i in range(1, 3*n + 1):</line-19>
<line-20> if i < r:</line-20>
<line-21> z[i] = z[i - l]</line-21>
<line-22> while i + z[i] <= 3*n and (s[i + z[i]] == s[z[i]]):</line-22>
<line-23> z[i] += 1</line-23>
<line-24> if i + z[i] > r:</line-24>
<line-25> l = i</line-25>
<line-26> r = i + z[i]</line-26>
<line-27> ans = []</line-27>
<line-28> for i in range(n + 1, 2*n + 1):</line-28>
<line-29> if z[i] < n:</line-29>
<line-30> continue</line-30>
<line-31> ans_S += 1</line-31>
<line-32> ans.append((a[0] + a[2*n - i + 1]) % m)</line-32>
<line-33> ans.sort()</line-33>
<line-34> print(ans_S)</line-34>
<line-35> print(*ans)</line-35>
<line-36> return</line-36>
<line-37></line-37>
<line-38>def __starting_point():</line-38>
<line-40>__starting_point()</line-40>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-39> main()</line-39>", "lines": [2, 39]}
#### 0
|
<line-1>def init_factorials(N, mod):</line-1>
<line-3> fac = [1] * N</line-3>
<line-4> for i in range(1, N):</line-4>
<line-5> f *= i</line-5>
<line-6> f %= mod</line-6>
<line-7> fac[i] = f</line-7>
<line-8> return fac</line-8>
<line-9></line-9>
<line-10>def init_inv(N, mod, fac):</line-10>
<line-11> b = bin(mod-2)[2:][-1::-1]</line-11>
<line-12> ret = 1</line-12>
<line-13> tmp = fac[N]</line-13>
<line-14> if b[0] == '1':</line-14>
<line-15> ret = fac[N]</line-15>
<line-16> for bi in b[1:]:</line-16>
<line-17> tmp *= tmp</line-17>
<line-18> tmp %= mod</line-18>
<line-19> if bi == '1':</line-19>
<line-20> ret *= tmp</line-20>
<line-21> ret %= mod</line-21>
<line-22> inv = [1] * (N + 1)</line-22>
<line-23> inv[N] = ret</line-23>
<line-24> for i in range(N-1, 0, -1):</line-24>
<line-25> ret *= i + 1</line-25>
<line-26> ret %= mod</line-26>
<line-27> inv[i] = ret</line-27>
<line-28> return inv</line-28>
<line-29></line-29>
<line-30></line-30>
<line-31>def f(r, c, mod, fac, inv):</line-31>
<line-32> return (fac[r + c] * inv[r] * inv[c]) % mod</line-32>
<line-33></line-33>
<line-34></line-34>
<line-35>def read_data():</line-35>
<line-36> h, w, n = list(map(int, input().split()))</line-36>
<line-37> blacks = []</line-37>
<line-38> for i in range(n):</line-38>
<line-39> r, c = list(map(int, input().split()))</line-39>
<line-40> blacks.append((r, c))</line-40>
<line-41> return h, w, n, blacks</line-41>
<line-42></line-42>
<line-43>def solve(h, w, n, blacks):</line-43>
<line-44> mod = 10**9 + 7</line-44>
<line-45> fac = init_factorials(h + w + 10, mod)</line-45>
<line-46> inv = init_inv(h + w + 5, mod, fac)</line-46>
<line-47> ans = (fac[h+w-2]*inv[h-1]*inv[w-1]) % mod</line-47>
<line-48> eb = [(r + c, r, c) for r, c in blacks]</line-48>
<line-49> eb.sort()</line-49>
<line-50> blacks = [(r, c) for rc, r, c in eb]</line-50>
<line-51> g = [f(r-1, c-1, mod, fac, inv) for r, c in blacks]</line-51>
<line-52> hw = h+w</line-52>
<line-53> for i, (r, c) in enumerate(blacks):</line-53>
<line-54> gi = g[i]</line-54>
<line-55> rc = r + c</line-55>
<line-56> ans -= gi*fac[hw-rc]*inv[h-r]*inv[w-c]</line-56>
<line-57> ans %= mod</line-57>
<line-58> for j, (rj, cj) in enumerate(blacks[i+1:], i+1):</line-58>
<line-59> if r <= rj and c <= cj:</line-59>
<line-60> g[j] -= gi*fac[rj+cj-rc]*inv[rj-r]*inv[cj-c]</line-60>
<line-61> g[j] %= mod</line-61>
<line-62> return ans</line-62>
<line-63></line-63>
<line-65>print(solve(h, w, n, blacks))</line-65>
|
{"code": "<line-2> f = 1</line-2>\n<line-64>h, w, n, blacks = read_data()</line-64>", "lines": [2, 64]}
#### 0
|
<line-1>f = lambda: list(map(int, input().split()))[1:]</line-1>
<line-3>s, p, q = [], [], []</line-3>
<line-4>for x in [0, 1]:</line-4>
<line-5> r = f()</line-5>
<line-6> s.append(r)</line-6>
<line-7> t = [len(r)] * n</line-7>
<line-8> t[0] = 0</line-8>
<line-9> p.append(t)</line-9>
<line-10> q.append((x, 0))</line-10>
<line-11>while q:</line-11>
<line-12> x, i = q.pop()</line-12>
<line-13> y = 1 - x</line-13>
<line-14> for d in s[y]:</line-14>
<line-15> j = (i - d) % n</line-15>
<line-16> if p[y][j] < 1: continue</line-16>
<line-17> p[y][j] = -1</line-17>
<line-18> for d in s[x]:</line-18>
<line-19> k = (j - d) % n</line-19>
<line-20> if p[x][k] < 1: continue</line-20>
<line-21> p[x][k] -= 1</line-21>
<line-22> if p[x][k] == 0: q.append((x, k))</line-22>
<line-24> print(*[['Lose', 'Loop', 'Win'][min(q, 1)] for q in p[x][1:]])</line-24>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-23>for x in [0, 1]:</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>def read_data():</line-1>
<line-3> As = list(map(int, input().split()))</line-3>
<line-4> LRs = []</line-4>
<line-5> for i in range(q):</line-5>
<line-6> L, R = list(map(int, input().split()))</line-6>
<line-7> LRs.append((L, R))</line-7>
<line-8> return n, q, As, LRs</line-8>
<line-9></line-9>
<line-10>def solve(n, q, As, LRs):</line-10>
<line-11> difs = calc_difs(As)</line-11>
<line-12> Ls = get_Ls(difs)</line-12>
<line-13> Rs = get_Rs_allow_ties(difs)</line-13>
<line-14> for L, R in LRs:</line-14>
<line-15> print(calc(L-1, R-2, Ls, Rs, difs))</line-15>
<line-16></line-16>
<line-17> </line-17>
<line-18>def calc_difs(As):</line-18>
<line-19> difs = [abs(a0 - a1) for a0, a1 in zip(As, As[1:])]</line-19>
<line-20> return difs</line-20>
<line-21></line-21>
<line-22></line-22>
<line-23>def get_Ls(Vs):</line-23>
<line-24> L = []</line-24>
<line-25> st = []</line-25>
<line-26> for i, v in enumerate(Vs):</line-26>
<line-27> while st and Vs[st[-1]] < v:</line-27>
<line-28> st.pop()</line-28>
<line-29> if st:</line-29>
<line-30> L.append(st[-1] + 1)</line-30>
<line-31> else:</line-31>
<line-32> L.append(0)</line-32>
<line-33> st.append(i)</line-33>
<line-34> return L</line-34>
<line-35></line-35>
<line-36>def get_Ls_allow_ties(Vs):</line-36>
<line-37> L = []</line-37>
<line-38> st = []</line-38>
<line-39> for i, v in enumerate(Vs):</line-39>
<line-40> while st and Vs[st[-1]] <= v:</line-40>
<line-41> st.pop()</line-41>
<line-42> if st:</line-42>
<line-43> L.append(st[-1] + 1)</line-43>
<line-44> else:</line-44>
<line-45> L.append(0)</line-45>
<line-46> st.append(i)</line-46>
<line-47> return L</line-47>
<line-48></line-48>
<line-49>def get_Rs(Vs):</line-49>
<line-50> n = len(Vs)</line-50>
<line-51> revVs = Vs[::-1]</line-51>
<line-52> revRs = get_Ls(revVs)</line-52>
<line-53> revRs.reverse()</line-53>
<line-54> return [n - 1 - R for R in revRs]</line-54>
<line-55></line-55>
<line-56></line-56>
<line-57>def get_Rs_allow_ties(Vs):</line-57>
<line-58> n = len(Vs)</line-58>
<line-59> revVs = Vs[::-1]</line-59>
<line-60> revRs = get_Ls_allow_ties(revVs)</line-60>
<line-61> revRs.reverse()</line-61>
<line-62> return [n - 1 - R for R in revRs]</line-62>
<line-63></line-63>
<line-64>def calc(L, R, Ls, Rs, difs):</line-64>
<line-65> ans = 0</line-65>
<line-66> for i in range(L, R + 1):</line-66>
<line-67> ans += difs[i] * (i - max(Ls[i], L) + 1) * (min(Rs[i], R) - i + 1)</line-67>
<line-68> return ans</line-68>
<line-69></line-69>
<line-71>solve(n, q, As, LRs)</line-71>
|
{"code": "<line-2> n, q = map(int, input().split())</line-2>\n<line-70>n, q, As, LRs = read_data()</line-70>", "lines": [2, 70]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>n = int(input())</line-4>
<line-5>matrix = [array('i', list(map(int, input().split()))) for _ in range(n)]</line-5>
<line-6>aa = tuple([int(x) - 1 for x in input().split()])</line-6>
<line-7>ans = [''] * n</line-7>
<line-8></line-8>
<line-9>for i in range(n-1, -1, -1):</line-9>
<line-10> x = aa[i]</line-10>
<line-11></line-11>
<line-12> for a in range(n):</line-12>
<line-13> for b in range(n):</line-13>
<line-14> if matrix[a][b] > matrix[a][x] + matrix[x][b]:</line-14>
<line-15> matrix[a][b] = matrix[a][x] + matrix[x][b]</line-15>
<line-16></line-16>
<line-17> val, overflow = 0, 0</line-17>
<line-18> for a in aa[i:]:</line-18>
<line-19> for b in aa[i:]:</line-19>
<line-20> val += matrix[a][b]</line-20>
<line-21> if val > 10**9:</line-21>
<line-22> overflow += 1</line-22>
<line-23> val -= 10**9</line-23>
<line-24></line-24>
<line-26></line-26>
<line-27>print(' '.join(ans))</line-27>
|
{"code": "<line-2>from array import array # noqa: F401</line-2>\n<line-25> ans[i] = str(10**9 * overflow + val)</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>def check(num1, num2, p, k):</line-1>
<line-3> v *= num1 * num1 + num2 * num2</line-3>
<line-4> v %= p</line-4>
<line-5> v += p</line-5>
<line-6> v %= p</line-6>
<line-7> return v == k % p</line-7>
<line-8></line-8>
<line-9>def __starting_point():</line-9>
<line-10></line-10>
<line-11> n, p, k = (int(x) for x in input().split())</line-11>
<line-12> idx___number = [int(x) for x in input().split()]</line-12>
<line-13></line-13>
<line-14> idx___precount = [((pow(x, 4, p) - k * x) % p + p) % p for x in idx___number]</line-14>
<line-15></line-15>
<line-16> met_precount___vals = {}</line-16>
<line-17> ans = 0</line-17>
<line-18> for number, precount in zip(idx___number[::-1], idx___precount[::-1]):</line-18>
<line-19> if precount not in met_precount___vals:</line-19>
<line-20> met_precount___vals[precount] = []</line-20>
<line-21> else:</line-21>
<line-22> for val in met_precount___vals[precount]:</line-22>
<line-23> if check(number, val, p, k):</line-23>
<line-24> ans += 1</line-24>
<line-25> met_precount___vals[precount].append(number)</line-25>
<line-27></line-27>
<line-28>__starting_point()</line-28>
|
{"code": "<line-2> v = num1 + num2</line-2>\n<line-26> print(ans)</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>import heapq</line-1>
<line-2></line-2>
<line-4> q, r = divmod(a, k)</line-4>
<line-5> return q**2 * (k-r) + (q+1)**2 * r</line-5>
<line-6></line-6>
<line-7>def diff(a, k):</line-7>
<line-8> return sum_sqaure(a, k+1) - sum_sqaure(a, k)</line-8>
<line-9></line-9>
<line-10>n, k = map(int, input().split())</line-10>
<line-11>nums = list(map(int, input().split()))</line-11>
<line-12></line-12>
<line-13>curr = sum(sum_sqaure(a, 1) for a in nums)</line-13>
<line-14>Q = [(diff(a, 1), a, 1) for a in nums]</line-14>
<line-15>heapq.heapify(Q)</line-15>
<line-16>for __ in range(k - n):</line-16>
<line-17> d, a, i = heapq.heappop(Q)</line-17>
<line-18> curr += d</line-18>
<line-20>print(curr)</line-20>
|
{"code": "<line-3>def sum_sqaure(a, k):</line-3>\n<line-19> heapq.heappush(Q, (diff(a, i+1), a, i+1))</line-19>", "lines": [3, 19]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4> if not tree:</line-4>
<line-5> return</line-5>
<line-6> stack = [(root, priv_root, cur_lvl, priv_lvl)]</line-6>
<line-7> while stack:</line-7>
<line-8> (root, priv_root, cur_lvl, priv_lvl) = stack.pop()</line-8>
<line-9> if cur_lvl ^ diff[root]:</line-9>
<line-10> cur_lvl ^= 1</line-10>
<line-11> pick_list.append(str(root))</line-11>
<line-12> stack += [(vertex, root, priv_lvl, cur_lvl)</line-12>
<line-13> for vertex in tree[root] if vertex != priv_root]</line-13>
<line-14></line-14>
<line-15>def main():</line-15>
<line-16> n = int(input())</line-16>
<line-17> tree = dict()</line-17>
<line-18> for _ in range(n - 1):</line-18>
<line-19> (u, v) = list(map(int, input().split()))</line-19>
<line-20> tree[u] = tree.get(u, set()) | set([v])</line-20>
<line-21> tree[v] = tree.get(v, set()) | set([u])</line-21>
<line-22> init = [0] + list(map(int, input().split()))</line-22>
<line-23> goal = [0] + list(map(int, input().split()))</line-23>
<line-24> diff = [i ^ j for (i, j) in zip(init, goal)]</line-24>
<line-25> pick_list = list()</line-25>
<line-26></line-26>
<line-27> dfs(tree, 1, 0, 0, 0, diff, pick_list)</line-27>
<line-28></line-28>
<line-29> num = len(pick_list)</line-29>
<line-30> print(num)</line-30>
<line-31> if num:</line-31>
<line-32> print('\n'.join(pick_list))</line-32>
<line-33></line-33>
<line-34>def __starting_point():</line-34>
<line-36></line-36>
<line-37>__starting_point()</line-37>
|
{"code": "<line-3>def dfs(tree, root, priv_root, cur_lvl, priv_lvl, diff, pick_list):</line-3>\n<line-35> return(main())</line-35>", "lines": [3, 35]}
#### 0
|
<line-1>def prime(n):</line-1>
<line-3> t = [1] * (n + 1)</line-3>
<line-4> for i in range(3, m):</line-4>
<line-5> if t[i]: t[i * i :: 2 * i] = [0] * ((n - i * i) // (2 * i) + 1)</line-5>
<line-6> return [2] + [i for i in range(3, n + 1, 2) if t[i]]</line-6>
<line-7></line-7>
<line-8>def gcd(a, b):</line-8>
<line-9> c = a % b</line-9>
<line-10> return gcd(b, c) if c else b</line-10>
<line-11></line-11>
<line-12>p = prime(31650)</line-12>
<line-13>def g(n):</line-13>
<line-14> m = int(n ** 0.5)</line-14>
<line-15> for j in p:</line-15>
<line-16> if n % j == 0: return True</line-16>
<line-17> if j > m: return False</line-17>
<line-18></line-18>
<line-19>def f(n):</line-19>
<line-20> a, b = n, n + 1</line-20>
<line-21> while g(a): a -= 1</line-21>
<line-22> while g(b): b += 1</line-22>
<line-23> p, q = (b - 2) * a + 2 * (n - b + 1), 2 * a * b</line-23>
<line-24> d = gcd(p, q)</line-24>
<line-26></line-26>
<line-27>for i in range(int(input())): f(int(input()))</line-27>
|
{"code": "<line-2> m = int(n ** 0.5) + 1</line-2>\n<line-25> print(str(p // d) + '/' + str(q // d))</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>from itertools import starmap</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5> n, q = list(map(int, input().split()))</line-5>
<line-6></line-6>
<line-7> a = list(range(n + 1))</line-7>
<line-8> flipped = False</line-8>
<line-9> start = 0</line-9>
<line-10> end = n</line-10>
<line-11></line-11>
<line-12> for _ in range(q):</line-12>
<line-13> cmd, *args = list(map(int, input().split()))</line-13>
<line-14></line-14>
<line-15> if cmd == 1:</line-15>
<line-16> p = args[0]</line-16>
<line-17> if p > end-start-p:</line-17>
<line-18> flipped = not flipped</line-18>
<line-19> p = end-start-p</line-19>
<line-20> if flipped:</line-20>
<line-21> a[end-p:end-2*p:-1] = starmap(</line-21>
<line-22> lambda a, b: a+n-b,</line-22>
<line-23> list(zip(a[end-p:end-2*p:-1], a[end-p:end]))</line-23>
<line-24> )</line-24>
<line-25> end -= p</line-25>
<line-26> else:</line-26>
<line-27> start += p</line-27>
<line-28> a[start:start+p] = starmap(</line-28>
<line-29> lambda a, b: a-b,</line-29>
<line-30> list(zip(a[start:start+p], a[start:start-p:-1]))</line-30>
<line-31> )</line-31>
<line-32> else:</line-32>
<line-33> l, r = args</line-33>
<line-34> if flipped:</line-34>
<line-35> l, r = end-start-r, end-start-l</line-35>
<line-36> print(a[start + r] - a[start + l])</line-36>
<line-37></line-37>
<line-38></line-38>
<line-39>def __starting_point():</line-39>
<line-41></line-41>
<line-42></line-42>
<line-43>__starting_point()</line-43>
|
{"code": "<line-4>def main():</line-4>\n<line-40> main()</line-40>", "lines": [4, 40]}
#### 0
|
<line-1>n, p, q = input(), set(), set()</line-1>
<line-3> q = set(i | j for j in q)</line-3>
<line-4> q.add(i)</line-4>
<line-6>print(len(p))</line-6>
|
{"code": "<line-2>for i in map(int, input().split()):</line-2>\n<line-5> p.update(q)</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>buck = [[0, 0] for i in range(2201)]</line-1>
<line-3>for i in range(m):</line-3>
<line-4> a = int(input())</line-4>
<line-5> ok = True</line-5>
<line-6> br = 0</line-6>
<line-7> for j in range(2200, -1, -1):</line-7>
<line-8> if a & (1 << j):</line-8>
<line-9> if(buck[j][0]):</line-9>
<line-10> a ^= buck[j][0]</line-10>
<line-11> br ^= buck[j][1]</line-11>
<line-12> else:</line-12>
<line-13> ok = False</line-13>
<line-14> buck[j][0] = a</line-14>
<line-15> buck[j][1] = br | (1 << i)</line-15>
<line-16> break</line-16>
<line-17> if not ok:</line-17>
<line-18> print("0")</line-18>
<line-19> else:</line-19>
<line-20> lst = []</line-20>
<line-21> for j in range(2201):</line-21>
<line-22> if br & (1 << j):</line-22>
<line-23> lst.append(j)</line-23>
<line-24> print(len(lst), end = ' ')</line-24>
<line-25> for j in lst:</line-25>
<line-27> print('\n', end='')</line-27>
|
{"code": "<line-2>m = int(input())</line-2>\n<line-26> print(j, end = ' ')</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>import heapq</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>buy = [] # negative</line-5>
<line-6>sell = []</line-6>
<line-7>unknown = []</line-7>
<line-8></line-8>
<line-9>res = 1</line-9>
<line-10>for i in range(n):</line-10>
<line-11> cmd, amount = input().strip().split()</line-11>
<line-12> amount = int(amount)</line-12>
<line-13> if cmd == 'ADD':</line-13>
<line-14> if sell and sell[0] < amount:</line-14>
<line-15> heapq.heappush(sell, amount)</line-15>
<line-16> elif buy and -buy[0] > amount:</line-16>
<line-17> heapq.heappush(buy, -amount)</line-17>
<line-18> else:</line-18>
<line-19> unknown.append(amount)</line-19>
<line-20> else:</line-20>
<line-21> if (sell and amount > sell[0]) or (buy and amount < -buy[0]):</line-21>
<line-22> print(0)</line-22>
<line-23> return</line-23>
<line-24> if sell and amount == sell[0]:</line-24>
<line-25> heapq.heappop(sell)</line-25>
<line-26> elif buy and amount == -buy[0]:</line-26>
<line-27> heapq.heappop(buy)</line-27>
<line-28> else:</line-28>
<line-29> res = res * 2 % 1000000007</line-29>
<line-30> for x in unknown:</line-30>
<line-31> if x < amount:</line-31>
<line-32> heapq.heappush(buy, -x)</line-32>
<line-33> elif x > amount:</line-33>
<line-34> heapq.heappush(sell, x)</line-34>
<line-35> unknown = []</line-35>
<line-37>print(res)</line-37>
|
{"code": "<line-3>n = int(input())</line-3>\n<line-36>res = res * (len(unknown) + 1) % 1000000007</line-36>", "lines": [3, 36]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>a = []</line-3>
<line-4>for i in range(max(s)):</line-4>
<line-5> a.append([]) </line-5>
<line-6>for i in range(len(s)):</line-6>
<line-7> a[s[i]-1].append(i)</line-7>
<line-8>a = list([x for x in a if x != []])</line-8>
<line-9>if len(a) > 1:</line-9>
<line-10> for i in range(1,len(a)):</line-10>
<line-11> if len(a[i]) > 1:</line-11>
<line-12> s = a[i-1][-1]</line-12>
<line-13> if s > a[i][0] and s < a[i][-1]:</line-13>
<line-14> for j in range(1,len(a[i])):</line-14>
<line-15> if s < a[i][j]:</line-15>
<line-16> a[i] = a[i][j:] + a[i][:j]</line-16>
<line-17> break</line-17>
<line-18>t = []</line-18>
<line-19>for i in a:</line-19>
<line-20> t += i</line-20>
<line-21>c = 0</line-21>
<line-22>x = t[0] + 1</line-22>
<line-23>i = n-1</line-23>
<line-24>while i > 0:</line-24>
<line-25> if t[i] < t[i-1]:</line-25>
<line-26> k = t[i] - t[i-1] + n</line-26>
<line-27> else:</line-27>
<line-28> k = t[i] - t[i-1]</line-28>
<line-29> c += k</line-29>
<line-30> x -= c//n </line-30>
<line-32>print(c+x)</line-32>
<line-33></line-33>
<line-34></line-34>
<line-35></line-35>
<line-36></line-36>
|
{"code": "<line-2>s = list(map(int,input().split(' ')))</line-2>\n<line-31> i -= 1</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>inp = input().split(' ')</line-1>
<line-3></line-3>
<line-4>totNums = int(inp[0]); totOpt = int(inp[1]);</line-4>
<line-5>inp = input().split(' '); #assert(len(inp) == totNums);</line-5>
<line-6>for it in inp: val.append(int(it))</line-6>
<line-7></line-7>
<line-8>dp = [[0.0 for _ in range(0,totNums)] for __ in range(0,totNums)]</line-8>
<line-9>for i in range(0,totNums):</line-9>
<line-10> for j in range(0,totNums):</line-10>
<line-11> if val[i]>val[j]: dp[i][j] = 1.0</line-11>
<line-12></line-12>
<line-13>while totOpt>0:</line-13>
<line-14> totOpt -= 1</line-14>
<line-15></line-15>
<line-16> inp = input().split(' ')</line-16>
<line-17> fr = int(inp[0])-1; to = int(inp[1])-1;</line-17>
<line-18></line-18>
<line-19> for i in range(0,totNums):</line-19>
<line-20> if i!=fr and i!=to:</line-20>
<line-21> dp[i][fr] = dp[i][to] = (dp[i][fr] + dp[i][to]) / 2;</line-21>
<line-22> dp[fr][i] = dp[to][i] = (dp[fr][i] + dp[to][i]) / 2;</line-22>
<line-23></line-23>
<line-24> dp[fr][to] = dp[to][fr] = (dp[fr][to] + dp[to][fr]) / 2;</line-24>
<line-25></line-25>
<line-26>ans = 0.0</line-26>
<line-27>for i in range(0,totNums):</line-27>
<line-28> for j in range(i+1,totNums):</line-28>
<line-30></line-30>
<line-31>print('%.10f'%ans)</line-31>
|
{"code": "<line-2>val=[];</line-2>\n<line-29> ans += dp[i][j]</line-29>", "lines": [2, 29]}
#### 0
|
<line-1>q, b, c = list(map(int, input().split()))</line-1>
<line-3>a = list(map(int, input().split()))</line-3>
<line-4>ans = 0</line-4>
<line-5>for i in a:</line-5>
<line-6> if b < i < c:</line-6>
<line-8>print(ans)</line-8>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-7>\t\tans += 1</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>def solve():</line-1>
<line-3> t = list(map(int, input().split()))</line-3>
<line-4> from bisect import insort</line-4>
<line-5> from math import floor</line-5>
<line-6> insort(t, a * n1)</line-6>
<line-7> pred = 0</line-7>
<line-8> k = 0</line-8>
<line-9> kpred = 0</line-9>
<line-10> n = 0</line-10>
<line-11> step = d // a + 1</line-11>
<line-12> sol = 0</line-12>
<line-13> fl = 0</line-13>
<line-14> for i in t:</line-14>
<line-15> if (i > pred):</line-15>
<line-16> if fl == 0:</line-16>
<line-17> n = (i - pred + (pred % a)) // a</line-17>
<line-18> if n != 0:</line-18>
<line-19> k += (n // step) * step - step * (n % step == 0) + 1</line-19>
<line-20> if k > n1:</line-20>
<line-21> k = n1</line-21>
<line-22> fl = 1</line-22>
<line-23> # print(k)</line-23>
<line-24> if (k * a + d >= i) and (n != 0):</line-24>
<line-25> pred = k * a + d</line-25>
<line-26> else:</line-26>
<line-27> pred = i + d</line-27>
<line-28> k = floor(pred // a)</line-28>
<line-29> sol += 1</line-29>
<line-30> # if n==0:</line-30>
<line-31> k = min(floor(pred // a), n1)</line-31>
<line-32> sol += n // step + (n % step != 0)</line-32>
<line-33> else:</line-33>
<line-34> sol += 1</line-34>
<line-35> pred = i + d</line-35>
<line-36> if i == a * n1:</line-36>
<line-37> fl = 1</line-37>
<line-38> # print(i,pred,sol,n,step,k, fl)</line-38>
<line-40>solve()</line-40>
|
{"code": "<line-2> n1, m, a, d = list(map(int, input().split()))</line-2>\n<line-39> print(sol)</line-39>", "lines": [2, 39]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>lp,rp = [0 for i in range(n)],[0 for i in range(n)]</line-5>
<line-6>lnr, rnr = [a[i] for i in range(n)],[a[i] for i in range(n)]</line-6>
<line-7>mx = a[0]</line-7>
<line-8>for i in range(1,n):</line-8>
<line-9> if a[i] > mx:</line-9>
<line-10> mx = a[i]</line-10>
<line-11> lp[i] = lp[i-1]</line-11>
<line-12> else:</line-12>
<line-13> mx += 1</line-13>
<line-14> lp[i] = lp[i-1] + mx - a[i]</line-14>
<line-15> lnr[i] = mx</line-15>
<line-16></line-16>
<line-17>mx = a[-1]</line-17>
<line-18>for i in range(n-2,-1,-1):</line-18>
<line-19> if a[i] > mx:</line-19>
<line-20> mx = a[i]</line-20>
<line-21> rp[i] = rp[i+1]</line-21>
<line-22> else:</line-22>
<line-23> mx += 1</line-23>
<line-24> rp[i] = rp[i+1] + mx - a[i]</line-24>
<line-25> rnr[i] = mx</line-25>
<line-26> </line-26>
<line-27>ans = min(rp[0], lp[-1])</line-27>
<line-28>for i in range(1,n-1):</line-28>
<line-29> ca = lp[i-1] + rp[i+1]</line-29>
<line-30> if max(lnr[i-1], rnr[i+1]) + 1 > a[i]:</line-30>
<line-31> ca += max(lnr[i-1], rnr[i+1]) + 1 - a[i]</line-31>
<line-33>print(ans)</line-33>
|
{"code": "<line-3>a = list(map(int, input().split()))</line-3>\n<line-32> ans = min(ans, ca)</line-32>", "lines": [3, 32]}
#### 0
|
<line-1>oleg = input()</line-1>
<line-3>oleg = sorted(list(oleg))</line-3>
<line-4>igor = sorted(list(igor))</line-4>
<line-5>n = len(oleg)</line-5>
<line-6>oleg_turns = (n + 1) // 2</line-6>
<line-7>igor_turns = n // 2</line-7>
<line-8>min_oleg_id = 0</line-8>
<line-9>min_igor_id = n - igor_turns</line-9>
<line-10>ans = ['?'] * n</line-10>
<line-11>max_oleg_id = oleg_turns - 1 </line-11>
<line-12>max_igor_id = n - 1</line-12>
<line-13>curr_turn = 'o'</line-13>
<line-14>next_turn = {'o' : 'i', 'i' : 'o'}</line-14>
<line-15>l_ans = 0</line-15>
<line-16>r_ans = n - 1</line-16>
<line-17>while r_ans >= l_ans:</line-17>
<line-18> if curr_turn == 'o':</line-18>
<line-19> if oleg[min_oleg_id] < igor[max_igor_id]:</line-19>
<line-20> ans[l_ans] = oleg[min_oleg_id]</line-20>
<line-21> l_ans += 1</line-21>
<line-22> min_oleg_id += 1</line-22>
<line-23> else:</line-23>
<line-24> ans[r_ans] = oleg[max_oleg_id]</line-24>
<line-25> r_ans += -1</line-25>
<line-26> max_oleg_id += -1</line-26>
<line-27> curr_turn = 'i'</line-27>
<line-28> else:</line-28>
<line-29> if igor[max_igor_id] > oleg[min_oleg_id]:</line-29>
<line-30> ans[l_ans] = igor[max_igor_id]</line-30>
<line-31> l_ans += 1</line-31>
<line-32> max_igor_id += -1</line-32>
<line-33> else:</line-33>
<line-34> ans[r_ans] = igor[min_igor_id]</line-34>
<line-35> r_ans += -1</line-35>
<line-36> min_igor_id += 1</line-36>
<line-37> curr_turn = 'o'</line-37>
<line-39>print(strans)</line-39>
|
{"code": "<line-2>igor = input()</line-2>\n<line-38>strans = ''.join(ans)</line-38>", "lines": [2, 38]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>for _ in range(int(input())):</line-4>
<line-5> x = int(input())</line-5>
<line-6> s = list(map(int, input()))</line-6>
<line-7> ans = len(s)</line-7>
<line-8> for i in range(1, x+1):</line-8>
<line-9> ans = (i + (ans-i) * s[i-1]) % mod</line-9>
<line-10> r = len(s)</line-10>
<line-11> for _ in range(s[i-1]-1):</line-11>
<line-12> if len(s) < x:</line-12>
<line-13> s += s[i:r]</line-13>
<line-14> else:</line-14>
<line-16></line-16>
<line-17> print(ans)</line-17>
|
{"code": "<line-2>mod = 10**9 + 7</line-2>\n<line-15> break</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>n, _q = map(int, input().split())</line-1>
<line-3>mxi = [-1] * 200001</line-3>
<line-4>cnt = [0] * 200001</line-4>
<line-5>nd = 0</line-5>
<line-6>a = list(map(int, input().split()))</line-6>
<line-7>for i, v in enumerate(a):</line-7>
<line-8> if mni[v] == -1: mni[v] = i; nd += 1</line-8>
<line-9> mxi[v] = i</line-9>
<line-10> cnt[v] += 1</line-10>
<line-11>r = 0</line-11>
<line-12>z = 0</line-12>
<line-13>currmax = 0</line-13>
<line-14>for i, v in enumerate(a):</line-14>
<line-15> if i == mni[v]: z += 1</line-15>
<line-16> if i == mxi[v]: z -= 1</line-16>
<line-17> currmax = max(currmax, cnt[v])</line-17>
<line-19>print(n - r)</line-19>
|
{"code": "<line-2>mni = [-1] * 200001</line-2>\n<line-18> if z == 0: r += currmax; currmax = 0</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>n, m = list(map(int, input().split()))</line-1>
<line-3>for i in range(m):</line-3>
<line-4> p, q = list(map(int, input().split()))</line-4>
<line-5> g[p - 1].append(q - 1)</line-5>
<line-6> g[q - 1].append(p - 1)</line-6>
<line-7></line-7>
<line-8>comp = [-1] * n</line-8>
<line-9>def shortest(root):</line-9>
<line-10> dist = [-1] * n</line-10>
<line-11> q = [0] * n</line-11>
<line-12> left, right = 0, 1</line-12>
<line-13> q[left] = root</line-13>
<line-14> dist[root] = 0</line-14>
<line-15> good = True</line-15>
<line-16> while left < right:</line-16>
<line-17> x = q[left]</line-17>
<line-18> left = left + 1</line-18>
<line-19> for i in g[x]:</line-19>
<line-20> if dist[i] is -1: </line-20>
<line-21> dist[i] = 1 + dist[x]</line-21>
<line-22> q[right] = i</line-22>
<line-23> right = right + 1</line-23>
<line-24> elif dist[i] == dist[x]:</line-24>
<line-25> good = False </line-25>
<line-26> far = 0</line-26>
<line-27> for i in dist: </line-27>
<line-28> if far < i:</line-28>
<line-29> far = i</line-29>
<line-30> return good, far, dist</line-30>
<line-31></line-31>
<line-32>arr = [0] * n</line-32>
<line-33>good = True</line-33>
<line-34>for i in range(n):</line-34>
<line-35> _, opt, dist = shortest(i)</line-35>
<line-36> if _ is False: good = False</line-36>
<line-37> if comp[i] is -1:</line-37>
<line-38> for j in range(n): </line-38>
<line-39> if dist[j] is not -1: comp[j] = i</line-39>
<line-40> if arr[comp[i]] < opt: </line-40>
<line-41> arr[comp[i]] = opt</line-41>
<line-42></line-42>
<line-44>else: print(sum(arr))</line-44>
<line-45></line-45>
|
{"code": "<line-2>g = [[] for _ in range(n)]</line-2>\n<line-43>if good is False: print('-1')</line-43>", "lines": [2, 43]}
#### 0
|
<line-1>MOD = 1000000007</line-1>
<line-2></line-2>
<line-4>p = [int(x) for x in input().split()]</line-4>
<line-5>x = [int(x) for x in input().split()]</line-5>
<line-6></line-6>
<line-7>children = [[] for x in range(n)]</line-7>
<line-8></line-8>
<line-9>for i in range(1,n):</line-9>
<line-10> children[p[i-1]].append(i)</line-10>
<line-11></line-11>
<line-12>#print(children)</line-12>
<line-13></line-13>
<line-14>count = [(0,0) for i in range(n)]</line-14>
<line-15>for i in reversed(list(range(n))):</line-15>
<line-16> prod = 1</line-16>
<line-17> for ch in children[i]:</line-17>
<line-18> prod *= count[ch][0]+count[ch][1]</line-18>
<line-19> if x[i]:</line-19>
<line-20> count[i] = (0,prod % MOD)</line-20>
<line-21> else:</line-21>
<line-22> tot = 0</line-22>
<line-23> for ch in children[i]:</line-23>
<line-24> cur = count[ch][1]*prod // (count[ch][0]+count[ch][1])</line-24>
<line-25> tot += cur</line-25>
<line-27></line-27>
<line-28>print(count[0][1])</line-28>
|
{"code": "<line-3>n = int(input())</line-3>\n<line-26> count[i] = (prod % MOD, tot % MOD)</line-26>", "lines": [3, 26]}
#### 0
|
<line-1>"""</line-1>
<line-3></line-3>
<line-4>Author : chaotic_iak</line-4>
<line-5>Language: Python 3.3.4</line-5>
<line-6>"""</line-6>
<line-7></line-7>
<line-8>def read(mode=2):</line-8>
<line-9> # 0: String</line-9>
<line-10> # 1: List of strings</line-10>
<line-11> # 2: List of integers</line-11>
<line-12> inputs = input().strip()</line-12>
<line-13> if mode == 0:</line-13>
<line-14> return inputs</line-14>
<line-15> if mode == 1:</line-15>
<line-16> return inputs.split()</line-16>
<line-17> if mode == 2:</line-17>
<line-18> return [int(x) for x in inputs.split()]</line-18>
<line-19></line-19>
<line-20>def write(s="\n"):</line-20>
<line-21> if isinstance(s, list): s = " ".join(map(str,s))</line-21>
<line-22> s = str(s)</line-22>
<line-23> print(s, end="")</line-23>
<line-24></line-24>
<line-25>################################################### SOLUTION</line-25>
<line-26></line-26>
<line-27># croft algorithm to generate primes</line-27>
<line-28># from pyprimes library, not built-in, just google it</line-28>
<line-29>from itertools import compress</line-29>
<line-30>import itertools</line-30>
<line-31>def croft():</line-31>
<line-32> """Yield prime integers using the Croft Spiral sieve.</line-32>
<line-33></line-33>
<line-34> This is a variant of wheel factorisation modulo 30.</line-34>
<line-35> """</line-35>
<line-36> # Implementation is based on erat3 from here:</line-36>
<line-37> # http://stackoverflow.com/q/2211990</line-37>
<line-38> # and this website:</line-38>
<line-39> # http://www.primesdemystified.com/</line-39>
<line-40> # Memory usage increases roughly linearly with the number of primes seen.</line-40>
<line-41> # dict ``roots`` stores an entry x:p for every prime p.</line-41>
<line-42> for p in (2, 3, 5):</line-42>
<line-43> yield p</line-43>
<line-44> roots = {9: 3, 25: 5} # Map d**2 -> d.</line-44>
<line-45> primeroots = frozenset((1, 7, 11, 13, 17, 19, 23, 29))</line-45>
<line-46> selectors = (1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0)</line-46>
<line-47> for q in compress(</line-47>
<line-48> # Iterate over prime candidates 7, 9, 11, 13, ...</line-48>
<line-49> itertools.islice(itertools.count(7), 0, None, 2),</line-49>
<line-50> # Mask out those that can't possibly be prime.</line-50>
<line-51> itertools.cycle(selectors)</line-51>
<line-52> ):</line-52>
<line-53> # Using dict membership testing instead of pop gives a</line-53>
<line-54> # 5-10% speedup over the first three million primes.</line-54>
<line-55> if q in roots:</line-55>
<line-56> p = roots[q]</line-56>
<line-57> del roots[q]</line-57>
<line-58> x = q + 2*p</line-58>
<line-59> while x in roots or (x % 30) not in primeroots:</line-59>
<line-60> x += 2*p</line-60>
<line-61> roots[x] = p</line-61>
<line-62> else:</line-62>
<line-63> roots[q*q] = q</line-63>
<line-64> yield q</line-64>
<line-65></line-65>
<line-66>n, = read()</line-66>
<line-67>cr = croft()</line-67>
<line-68>primes = []</line-68>
<line-69>for i in cr:</line-69>
<line-70> if i < n:</line-70>
<line-71> primes.append(i)</line-71>
<line-72> else:</line-72>
<line-73> break</line-73>
<line-74>primes.reverse()</line-74>
<line-75></line-75>
<line-76>used = [0] * (n+1)</line-76>
<line-77>res = []</line-77>
<line-78>for p in primes:</line-78>
<line-79> k = n//p</line-79>
<line-80> tmp = []</line-80>
<line-81> while k:</line-81>
<line-82> if not used[k*p]:</line-82>
<line-83> tmp.append(k*p)</line-83>
<line-84> used[k*p] = 1</line-84>
<line-85> if len(tmp) == 2:</line-85>
<line-86> res.append(tmp)</line-86>
<line-87> tmp = []</line-87>
<line-88> k -= 1</line-88>
<line-89> if tmp == [p] and p > 2 and p*2 <= n and len(res) and res[-1][1] == p*2:</line-89>
<line-90> res[-1][1] = p</line-90>
<line-91> used[p*2] = 0</line-91>
<line-92> used[p] = 1</line-92>
<line-93></line-93>
<line-94>print(len(res))</line-94>
<line-96> print(" ".join(map(str, i)))</line-96>
|
{"code": "<line-2>Codeforces Round 257 Div 1 Problem C</line-2>\n<line-95>for i in res:</line-95>", "lines": [2, 95]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5> cnt = [0] * 2 ** 18</line-5>
<line-6> t = str.maketrans("0123456789", "0101010101")</line-6>
<line-7> _, *l = stdin.read().splitlines()</line-7>
<line-8> for sign, s in map(str.split, l):</line-8>
<line-9> if sign == '?':</line-9>
<line-10> print(cnt[int(s, 2)])</line-10>
<line-11> else:</line-11>
<line-12> cnt[int(s.translate(t), 2)] += 1 if sign == '+' else -1</line-12>
<line-13></line-13>
<line-14></line-14>
<line-15>def __starting_point():</line-15>
<line-17></line-17>
<line-18>__starting_point()</line-18>
|
{"code": "<line-4>def main():</line-4>\n<line-16> main()</line-16>", "lines": [4, 16]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> n = int(input())</line-4>
<line-5> a = list(map(int,input().split()))</line-5>
<line-6> sumA = sum(a)</line-6>
<line-7> TWins = False</line-7>
<line-8> for elem in a:</line-8>
<line-9> if elem > sumA // 2:</line-9>
<line-10> TWins = True</line-10>
<line-11> break</line-11>
<line-12> if TWins or sumA % 2 != 0:</line-12>
<line-13> print("T")</line-13>
<line-15> print("HL")</line-15>
|
{"code": "<line-3>for _ in range(t):</line-3>\n<line-14> else:</line-14>", "lines": [3, 14]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>stk = []</line-3>
<line-4>for v in map(int, input().split()):</line-4>
<line-5> last = 0</line-5>
<line-6> while len(stk) and stk[-1][0] < v and stk[-1][1]:</line-6>
<line-7> last = max(last, stk[-1][1])</line-7>
<line-8> del stk[-1]</line-8>
<line-9></line-9>
<line-10> if not len(stk) or stk[-1][0] < v:</line-10>
<line-11> stk.append((v, 0))</line-11>
<line-12> else:</line-12>
<line-14>print(ans)</line-14>
|
{"code": "<line-2>ans = 0</line-2>\n<line-13> stk.append((v, last + 1)); ans = max(ans, last + 1)</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>def main():</line-1>
<line-3> aa = sorted(map(int, input().split()))</line-3>
<line-4> maxa = max(aa)</line-4>
<line-5> m = [False] * (maxa + 1)</line-5>
<line-6> x = []</line-6>
<line-7> b = 0</line-7>
<line-8> for a in aa:</line-8>
<line-9> if b != a:</line-9>
<line-10> m[a] = True</line-10>
<line-11> for i in range(b, a):</line-11>
<line-12> x.append(b)</line-12>
<line-13> b = a</line-13>
<line-14> x.append(b)</line-14>
<line-15> ans = 0</line-15>
<line-16> for i in range(maxa - 1, 1, -1):</line-16>
<line-17> if i < ans:</line-17>
<line-18> break</line-18>
<line-19> if m[i]:</line-19>
<line-20> for j in range(1, maxa // i + 1):</line-20>
<line-21> ans = max(ans, x[min(i * (j + 1) - 1, maxa)] % i)</line-21>
<line-22> print(ans)</line-22>
<line-23></line-23>
<line-24></line-24>
<line-25>def __starting_point():</line-25>
<line-27>__starting_point()</line-27>
|
{"code": "<line-2> input()</line-2>\n<line-26> main()</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>MAX_N = max(pos_blast, key=lambda x: x[0])[0] + 2</line-3>
<line-4>power = [0 for _ in range(MAX_N)]</line-4>
<line-5>tower = [False for _ in range(MAX_N)]</line-5>
<line-6>can_destroy = [0 for _ in range(MAX_N)]</line-6>
<line-7>for pos, blast in pos_blast:</line-7>
<line-8> pos += 1</line-8>
<line-9> tower[pos] = True</line-9>
<line-10> power[pos] = blast</line-10>
<line-11>for i in range(1, MAX_N):</line-11>
<line-12> if not tower[i]:</line-12>
<line-13> can_destroy[i] = can_destroy[i-1]</line-13>
<line-14> else:</line-14>
<line-16>print(n - max(can_destroy))</line-16>
|
{"code": "<line-2>pos_blast = [list(map(int, input().split())) for _ in range(n)]</line-2>\n<line-15> can_destroy[i] = can_destroy[max(0, i - power[i] - 1)] + 1</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>def main():</line-1>
<line-3> scores = []</line-3>
<line-4> for i in range(n):</line-4>
<line-5> a = list(map(int, input().split()))</line-5>
<line-6> tot = sum(a)</line-6>
<line-7> scores.append((-tot, i))</line-7>
<line-8></line-8>
<line-9> scores.sort()</line-9>
<line-10> for i in range(n):</line-10>
<line-11> if scores[i][1] == 0:</line-11>
<line-13></line-13>
<line-14>main()</line-14>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-12> print(i + 1)</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>for i in range(n):</line-3>
<line-4> tree.append([])</line-4>
<line-5> ans.append(0.0)</line-5>
<line-6> sz.append(0)</line-6>
<line-7></line-7>
<line-8>for i in range(n-1):</line-8>
<line-9> tree[pos[i]-1].append(i+1)</line-9>
<line-10></line-10>
<line-11>for i in range(n)[::-1]:</line-11>
<line-12> sz[i] = 1</line-12>
<line-13> for to in tree[i]:</line-13>
<line-14> sz[i] += sz[to]</line-14>
<line-15></line-15>
<line-16>for i in range(n):</line-16>
<line-17> for to in tree[i]:</line-17>
<line-18> ans[to] = ans[i] + 1 + (sz[i]-1-sz[to]) * 0.5</line-18>
<line-19></line-19>
<line-21>print(' '.join(list(map(st,ans))))</line-21>
|
{"code": "<line-2>pos,tree,ans,sz = list(map(int,input().split())) if n > 1 else [],[],[],[]</line-2>\n<line-20>st = lambda i: str(i+1)</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>from collections import Counter</line-1>
<line-2></line-2>
<line-4>a = list(map(int, input().split()))</line-4>
<line-5>c = Counter(a)</line-5>
<line-6></line-6>
<line-7>res = 0</line-7>
<line-8>cur = 0</line-8>
<line-9>for i in sorted(c.keys()):</line-9>
<line-10> d = min(c[i], cur)</line-10>
<line-11> cur -= d</line-11>
<line-12> res += d</line-12>
<line-14></line-14>
<line-15>print(res)</line-15>
|
{"code": "<line-3>n = int(input())</line-3>\n<line-13> cur += c[i]</line-13>", "lines": [3, 13]}
#### 0
|
<line-1>n, m = list(map(int, input().split()))</line-1>
<line-3>p = c = 0</line-3>
<line-4>for i in range(1, n):</line-4>
<line-5> if s[i] == s[i - 1]:</line-5>
<line-6> c += n * (m - 1)</line-6>
<line-7> p = i</line-7>
<line-8> elif s[i] != s[i - 2]:</line-8>
<line-9> p = i - 1</line-9>
<line-10> c += i - p</line-10>
<line-12>print(ans)</line-12>
|
{"code": "<line-2>s = input()</line-2>\n<line-11>ans = n * n * (m - 1) - c</line-11>", "lines": [2, 11]}
#### 0
|
<line-2>b = a[::-1]</line-2>
<line-3>print(a + b)</line-3>
|
{"code": "<line-1>a = input()</line-1>", "lines": [1]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>for a in range(n):</line-5>
<line-6> name = input()</line-6>
<line-7></line-7>
<line-8> name = name.replace('u', 'oo')</line-8>
<line-9></line-9>
<line-10> while (name.count('kh') > 0):</line-10>
<line-11> name = name.replace('kh', 'h')</line-11>
<line-13></line-13>
<line-14>print(len(s))</line-14>
|
{"code": "<line-2>s = set()</line-2>\n<line-12> s.add(name)</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>n, k = list(map(int, input().split()))</line-4>
<line-5></line-5>
<line-6>begin = [-1] * n</line-6>
<line-7>end = [-1] * n</line-7>
<line-8>hurt = [-1] * n</line-8>
<line-9></line-9>
<line-10>adj = [[] for i in range(n)]</line-10>
<line-11>for _ in range(n-1):</line-11>
<line-12> u ,v = list(map(int, input().split()))</line-12>
<line-13> adj[u-1].append(v-1)</line-13>
<line-14> adj[v-1].append(u-1)</line-14>
<line-15></line-15>
<line-16>hurt[0] = 1</line-16>
<line-17>begin[0] = 0</line-17>
<line-18>stack = [0]</line-18>
<line-19>curr = 1</line-19>
<line-20>while stack:</line-20>
<line-21> nex = stack[-1]</line-21>
<line-22> if adj[nex]:</line-22>
<line-23> v = adj[nex].pop()</line-23>
<line-24> if begin[v] == -1:</line-24>
<line-25> begin[v] = curr</line-25>
<line-26> curr += 1</line-26>
<line-27> stack.append(v)</line-27>
<line-28> hurt[v] = len(stack)</line-28>
<line-29> else:</line-29>
<line-30> end[nex] = curr</line-30>
<line-31> stack.pop()</line-31>
<line-32></line-32>
<line-33>desc = [end[i] - begin[i]-hurt[i] for i in range(n)]</line-33>
<line-34>desc.sort(reverse = True)</line-34>
<line-35>out = 0</line-35>
<line-36>for i in range(n - k):</line-36>
<line-38>print(out)</line-38>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-37> out += desc[i]</line-37>", "lines": [2, 37]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>n = int(input())</line-5>
<line-6>a = list(map(int, input().split()))</line-6>
<line-7>b = a</line-7>
<line-8></line-8>
<line-9>ans = 0</line-9>
<line-10>for k in range(29):</line-10>
<line-11> a0 = []</line-11>
<line-12> a1 = []</line-12>
<line-13> a0a = a0.append</line-13>
<line-14> a1a = a1.append</line-14>
<line-15> </line-15>
<line-16> b0 = []</line-16>
<line-17> b1 = []</line-17>
<line-18> b0a = b0.append</line-18>
<line-19> b1a = b1.append</line-19>
<line-20> for i in a:</line-20>
<line-21> if i&(1<<k): a1a(i)</line-21>
<line-22> else: a0a(i)</line-22>
<line-23> for i in b:</line-23>
<line-24> if i&(1<<k): b1a(i)</line-24>
<line-25> else: b0a(i)</line-25>
<line-26> </line-26>
<line-27> a = a0+a1</line-27>
<line-28> b = b0+b1</line-28>
<line-29> mask = (1<<(k+1))-1</line-29>
<line-30> </line-30>
<line-31> aa = [i&mask for i in a]</line-31>
<line-32> bb = [i&mask for i in b]</line-32>
<line-33> </line-33>
<line-34> res = 0</line-34>
<line-35> p1 = 1<<k</line-35>
<line-36> p2 = mask+1</line-36>
<line-37> p3 = p1+p2</line-37>
<line-38></line-38>
<line-39> j1 = j2 = j3 = 0 </line-39>
<line-40> for jj, ai in enumerate(reversed(aa)):</line-40>
<line-41> while j1 < n and ai+bb[j1] < p1:</line-41>
<line-42> j1 += 1</line-42>
<line-43> while j2 < n and ai+bb[j2] < p2:</line-43>
<line-44> j2 += 1</line-44>
<line-45> while j3 < n and ai+bb[j3] < p3:</line-45>
<line-46> j3 += 1</line-46>
<line-47> res += max(n, n - jj) - max(j3, n - jj)</line-47>
<line-48> res += max(j2, n - jj) - max(j1, n - jj)</line-48>
<line-50> </line-50>
<line-51>print(ans) </line-51>
|
{"code": "<line-2>input = sys.stdin.readline </line-2>\n<line-49> ans |= (res & 1) << k</line-49>", "lines": [2, 49]}
#### 0
|
<line-1>import sys</line-1>
<line-3>a = [int(x) for x in sys.stdin.readline().split()]</line-3>
<line-4></line-4>
<line-5>eps = 1e-12</line-5>
<line-6></line-6>
<line-7>def f(x):</line-7>
<line-8> mx = a[0] - x</line-8>
<line-9> tsmx = 0.0</line-9>
<line-10> mn = a[0] - x</line-10>
<line-11> tsmn = 0.0</line-11>
<line-12> for ai in a:</line-12>
<line-13> tsmx = max(tsmx + ai - x, ai - x)</line-13>
<line-14> mx = max(tsmx, mx)</line-14>
<line-15> tsmn = min(tsmn + ai - x, ai - x)</line-15>
<line-16> mn = min(tsmn, mn)</line-16>
<line-17></line-17>
<line-18> return abs(mx), abs(mn)</line-18>
<line-19></line-19>
<line-20>l = min(a)</line-20>
<line-21>r = max(a)</line-21>
<line-22>f1, f2 = f(l)</line-22>
<line-23>for i in range(0, 90):</line-23>
<line-24> m = (l + r) / 2</line-24>
<line-25> f1, f2 = f(m)</line-25>
<line-26> if f1 > f2:</line-26>
<line-27> l = m</line-27>
<line-28> else:</line-28>
<line-29> r = m</line-29>
<line-30></line-30>
<line-32>print(min(A,B))</line-32>
|
{"code": "<line-2>n = int(sys.stdin.readline())</line-2>\n<line-31>A, B = f(l)</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>n=int(input())</line-4>
<line-5>A=list(map(int,input().split()))</line-5>
<line-6></line-6>
<line-7>BIT=[0]*(n+1)</line-7>
<line-8></line-8>
<line-9>def update(v,w):</line-9>
<line-10> while v<=n:</line-10>
<line-11> BIT[v]+=w</line-11>
<line-12> v+=(v&(-v))</line-12>
<line-13></line-13>
<line-14>def getvalue(v):</line-14>
<line-15> ANS=0</line-15>
<line-16> while v!=0:</line-16>
<line-17> ANS+=BIT[v]</line-17>
<line-18> v-=(v&(-v))</line-18>
<line-19> return ANS</line-19>
<line-20></line-20>
<line-21>for i in range(1,n+1):</line-21>
<line-22> update(i,i)</line-22>
<line-23></line-23>
<line-24>ANS=[-1]*n</line-24>
<line-25></line-25>
<line-26>for i in range(n-1,-1,-1):</line-26>
<line-27> MIN=0</line-27>
<line-28> MAX=n</line-28>
<line-29> k=A[i]</line-29>
<line-30></line-30>
<line-31> while True:</line-31>
<line-32> x=(MIN+MAX+1)//2</line-32>
<line-33></line-33>
<line-34></line-34>
<line-35> if getvalue(x)>k:</line-35>
<line-36> if getvalue(x-1)==k:</line-36>
<line-37> ANS[i]=x</line-37>
<line-38> break</line-38>
<line-39> else:</line-39>
<line-40> MAX=x</line-40>
<line-41> else:</line-41>
<line-42> MIN=x</line-42>
<line-43></line-43>
<line-45></line-45>
<line-46> </line-46>
<line-47>print(*ANS)</line-47>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-44> update(x,-x)</line-44>", "lines": [2, 44]}
#### 0
|
<line-1>def main():</line-1>
<line-3> a = [[int(i) for i in input().split()] for j in range(n)]</line-3>
<line-4> </line-4>
<line-5> result = [-1] * n</line-5>
<line-6> for i in range(n - 1):</line-6>
<line-7> for j in range(n):</line-7>
<line-8> d = set(a[j][k] for k in range(n) if result[k] == -1 and j != k)</line-8>
<line-9> if len(d) == 1:</line-9>
<line-10> result[j] = d.pop()</line-10>
<line-11> result[result.index(-1)] = n</line-11>
<line-12> </line-12>
<line-14> </line-14>
<line-15>main()</line-15>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-13> print(' '.join(str(i) for i in result))</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>import sys</line-1>
<line-3>import heapq</line-3>
<line-4></line-4>
<line-5>mod=998244353</line-5>
<line-6></line-6>
<line-7>n,m=list(map(int,input().split()))</line-7>
<line-8></line-8>
<line-9>E=[[] for i in range(n+1)]</line-9>
<line-10>E2=[[] for i in range(n+1)]</line-10>
<line-11></line-11>
<line-12>for i in range(m):</line-12>
<line-13> x,y=list(map(int,input().split()))</line-13>
<line-14> E[x].append(y)</line-14>
<line-15> E2[y].append(x)</line-15>
<line-16></line-16>
<line-17>TIME=[1<<29]*(n+1)</line-17>
<line-18>TIME[1]=0</line-18>
<line-19></line-19>
<line-20>def shuku(x,y):</line-20>
<line-21> return (x<<20)+y</line-21>
<line-22></line-22>
<line-23>Q=[]</line-23>
<line-24>ANS=[]</line-24>
<line-25></line-25>
<line-26>for k in range(n+1):</line-26>
<line-27> NQ=[]</line-27>
<line-28></line-28>
<line-29> if k<=1:</line-29>
<line-30> heapq.heappush(Q,shuku(0,1))</line-30>
<line-31></line-31>
<line-32> if k%2==0:</line-32>
<line-33> while Q:</line-33>
<line-34> #print(Q)</line-34>
<line-35> x=heapq.heappop(Q)</line-35>
<line-36> time=x>>20</line-36>
<line-37> town=x-(time<<20)</line-37>
<line-38></line-38>
<line-39> #print(x,time,town)</line-39>
<line-40></line-40>
<line-41> if TIME[town]<time:</line-41>
<line-42> continue</line-42>
<line-43></line-43>
<line-44> for to in E[town]:</line-44>
<line-45> if TIME[to]>time+1:</line-45>
<line-46> TIME[to]=time+1</line-46>
<line-47> heapq.heappush(Q,shuku(TIME[to],to))</line-47>
<line-48> heapq.heappush(NQ,shuku(TIME[to],to))</line-48>
<line-49></line-49>
<line-50> else:</line-50>
<line-51> while Q:</line-51>
<line-52> x=heapq.heappop(Q)</line-52>
<line-53> time=x>>20</line-53>
<line-54> town=x-(time<<20)</line-54>
<line-55></line-55>
<line-56> #print(x,time,town)</line-56>
<line-57></line-57>
<line-58> if TIME[town]<time:</line-58>
<line-59> continue</line-59>
<line-60></line-60>
<line-61> for to in E2[town]:</line-61>
<line-62> if TIME[to]>time+1:</line-62>
<line-63> TIME[to]=time+1</line-63>
<line-64> heapq.heappush(Q,shuku(TIME[to],to))</line-64>
<line-65> heapq.heappush(NQ,shuku(TIME[to],to))</line-65>
<line-66></line-66>
<line-67> #print(k,TIME)</line-67>
<line-68></line-68>
<line-69> Q=NQ</line-69>
<line-70> ANS.append(TIME[n])</line-70>
<line-71></line-71>
<line-72> if k>=100 and TIME[n]!=1<<29:</line-72>
<line-73> break</line-73>
<line-74></line-74>
<line-75>A=ANS[0]</line-75>
<line-76>for k in range(1,len(ANS)):</line-76>
<line-77> if ANS[k]==1<<29:</line-77>
<line-78> continue</line-78>
<line-79></line-79>
<line-80> if ANS[k-1]==1<<29:</line-80>
<line-81> A=(ANS[k]+pow(2,k,mod)-1)%mod</line-81>
<line-82></line-82>
<line-83> if k<60 and ANS[k-1]-ANS[k]>pow(2,k-1):</line-83>
<line-85></line-85>
<line-86>print(A)</line-86>
<line-87> </line-87>
<line-88></line-88>
<line-89></line-89>
<line-90> </line-90>
<line-91> </line-91>
<line-92> </line-92>
<line-93> </line-93>
<line-94> </line-94>
<line-95></line-95>
<line-96> </line-96>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-84> A=(ANS[k]+pow(2,k,mod)-1)%mod</line-84>", "lines": [2, 84]}
#### 0
|
<line-1>def main():</line-1>
<line-3> from array import array</line-3>
<line-4> from collections import deque</line-4>
<line-5> input = sys.stdin.readline</line-5>
<line-6></line-6>
<line-7> H, W, Q = list(map(int, input().split()))</line-7>
<line-8> grid = array('b', [0] * (H*W))</line-8>
<line-9> #flg_0 = 0</line-9>
<line-10> #flg_1 = 0</line-10>
<line-11> for h in range(H):</line-11>
<line-12> line = input().rstrip('\n')</line-12>
<line-13> """</line-13>
<line-14> if "0" in line:</line-14>
<line-15> flg_0 = 1</line-15>
<line-16> if "1" in line:</line-16>
<line-17> flg_1 = 1</line-17>
<line-18> """</line-18>
<line-19> for w in range(W):</line-19>
<line-20> if line[w] == "1":</line-20>
<line-21> grid[h*W + w] ^= 1</line-21>
<line-22></line-22>
<line-23> """</line-23>
<line-24> if flg_0 == 0:</line-24>
<line-25> for _ in range(Q):</line-25>
<line-26> print(1)</line-26>
<line-27> return</line-27>
<line-28> if flg_1 == 0:</line-28>
<line-29> for _ in range(Q):</line-29>
<line-30> print(0)</line-30>
<line-31> return</line-31>
<line-32> """</line-32>
<line-33></line-33>
<line-34> que = deque()</line-34>
<line-35> start_change = [-1] * (H*W)</line-35>
<line-36> d = [(1, 0), (-1, 0), (0, 1), (0, -1)]</line-36>
<line-37> for h in range(H):</line-37>
<line-38> for w in range(W):</line-38>
<line-39> same = 0</line-39>
<line-40> hw = h*W+w</line-40>
<line-41> for dh, dw in d:</line-41>
<line-42> h_new, w_new = h+dh, w+dw</line-42>
<line-43> hw_new = h_new * W + w_new</line-43>
<line-44> if 0 <= h_new < H and 0 <= w_new < W:</line-44>
<line-45> if grid[hw] == grid[hw_new]:</line-45>
<line-46> same = 1</line-46>
<line-47> break</line-47>
<line-48> if same:</line-48>
<line-49> que.append(hw)</line-49>
<line-50> start_change[hw] = 0</line-50>
<line-51></line-51>
<line-52> while que:</line-52>
<line-53> hw = que.popleft()</line-53>
<line-54> h, w = divmod(hw, W)</line-54>
<line-55> for dh, dw in d:</line-55>
<line-56> h_new, w_new = h + dh, w + dw</line-56>
<line-57> hw_new = h_new * W + w_new</line-57>
<line-58> if 0 <= h_new < H and 0 <= w_new < W:</line-58>
<line-59> if start_change[hw_new] == -1:</line-59>
<line-60> start_change[hw_new] = start_change[hw] + 1</line-60>
<line-61> que.append(hw_new)</line-61>
<line-62></line-62>
<line-63> for _ in range(Q):</line-63>
<line-64> h, w, p = list(map(int, input().split()))</line-64>
<line-65> h -= 1</line-65>
<line-66> w -= 1</line-66>
<line-67> hw = h*W + w</line-67>
<line-68> if start_change[hw] == -1:</line-68>
<line-69> print(grid[hw])</line-69>
<line-70> continue</line-70>
<line-71> if p <= start_change[hw]:</line-71>
<line-72> print(grid[hw])</line-72>
<line-73> else:</line-73>
<line-74> if (p - start_change[hw]) % 2 == 0:</line-74>
<line-75> print(grid[hw])</line-75>
<line-76> else:</line-76>
<line-77> print(grid[hw] ^ 1)</line-77>
<line-78></line-78>
<line-79></line-79>
<line-80>def __starting_point():</line-80>
<line-82></line-82>
<line-83>__starting_point()</line-83>
|
{"code": "<line-2> import sys</line-2>\n<line-81> main()</line-81>", "lines": [2, 81]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>p = [0] * (n + 1)</line-3>
<line-4>ans = [1] * (n + 1)</line-4>
<line-5>ind = n</line-5>
<line-6>for i in range(n):</line-6>
<line-7> p[a[i] - 1] = 1</line-7>
<line-8> while ind > 0 and p[ind - 1] == 1:</line-8>
<line-9> ind -= 1</line-9>
<line-11>print(' '.join(map(str, ans)))</line-11>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-10> ans[i + 1] = 1 + (i + 1) - (n - ind)</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>for i in range (n):</line-3>
<line-4> t,x,y=list(map(int,input().split()))</line-4>
<line-5> if t==1:</line-5>
<line-6> ta+=(x+y)</line-6>
<line-7> da+=y</line-7>
<line-8> if (t==2):</line-8>
<line-9> tb+=(x+y)</line-9>
<line-10> db+=y </line-10>
<line-11>if (ta-da>=0.5*ta):</line-11>
<line-12> print ('LIVE')</line-12>
<line-13>else :</line-13>
<line-14> print ('DEAD')</line-14>
<line-15>if (tb-db>=0.5*tb):</line-15>
<line-16> print ('LIVE')</line-16>
<line-18> print ('DEAD') </line-18>
<line-19> </line-19>
|
{"code": "<line-2>ta,tb,da,db=[0]*4</line-2>\n<line-17>else :</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>#!usr/bin/env python3</line-1>
<line-3>from heapq import heappush, heappop</line-3>
<line-4>import sys</line-4>
<line-5>import math</line-5>
<line-6>import bisect</line-6>
<line-7>def LI(): return [int(x) for x in sys.stdin.readline().split()]</line-7>
<line-8>def I(): return int(sys.stdin.readline())</line-8>
<line-9>def LS():return [list(x) for x in sys.stdin.readline().split()]</line-9>
<line-10>def S():</line-10>
<line-11> res = list(sys.stdin.readline())</line-11>
<line-12> if res[-1] == "\n":</line-12>
<line-13> return res[:-1]</line-13>
<line-14> return res</line-14>
<line-15>def IR(n):</line-15>
<line-16> return [I() for i in range(n)]</line-16>
<line-17>def LIR(n):</line-17>
<line-18> return [LI() for i in range(n)]</line-18>
<line-19>def SR(n):</line-19>
<line-20> return [S() for i in range(n)]</line-20>
<line-21>def LSR(n):</line-21>
<line-22> return [LS() for i in range(n)]</line-22>
<line-23></line-23>
<line-24>sys.setrecursionlimit(1000000)</line-24>
<line-25>mod = 1000000007</line-25>
<line-26></line-26>
<line-27>#A</line-27>
<line-28>def A():</line-28>
<line-29> n = I()</line-29>
<line-30> a = LI()</line-30>
<line-31> a.sort()</line-31>
<line-32> f = [1]*n</line-32>
<line-33> p = 0</line-33>
<line-34> ans = 0</line-34>
<line-35> while p < n:</line-35>
<line-36> while p < n and not f[p]:</line-36>
<line-37> p += 1</line-37>
<line-38> if p == n:</line-38>
<line-39> break</line-39>
<line-40> ans += 1</line-40>
<line-41> for i in range(n):</line-41>
<line-42> if a[i]%a[p] == 0:</line-42>
<line-43> f[i] = 0</line-43>
<line-44> print(ans)</line-44>
<line-45> return</line-45>
<line-46></line-46>
<line-47>#B</line-47>
<line-48>def B():</line-48>
<line-49> n = I()</line-49>
<line-50> s = list(map(int, input()))</line-50>
<line-51> g = LIR(n)</line-51>
<line-52> ans = sum(s)</line-52>
<line-53> for t in range(30000):</line-53>
<line-54> for i in range(n):</line-54>
<line-55> ai,bi = g[i]</line-55>
<line-56> if t < bi:</line-56>
<line-57> continue</line-57>
<line-58> if (t-bi)%ai == 0:</line-58>
<line-59> s[i] ^= 1</line-59>
<line-60> su = sum(s)</line-60>
<line-61> if ans < su:</line-61>
<line-62> ans = su</line-62>
<line-63> print(ans)</line-63>
<line-64> return</line-64>
<line-65></line-65>
<line-66>#C</line-66>
<line-67>def C():</line-67>
<line-68> t = I()</line-68>
<line-69> for _ in range(t):</line-69>
<line-70> n = I()</line-70>
<line-71> s = list(map(int, input()))</line-71>
<line-72> mi = [s[-1]]</line-72>
<line-73> for i in s[:-1][::-1]:</line-73>
<line-74> mi.append(min(mi[-1],i))</line-74>
<line-75> mi = mi[::-1]</line-75>
<line-76> ans = [None]*n</line-76>
<line-77> for i in range(n):</line-77>
<line-78> if mi[i] == s[i]:</line-78>
<line-79> ans[i] = 1</line-79>
<line-80> else:</line-80>
<line-81> ans[i] = 2</line-81>
<line-82> q = [s[i] for i in range(n) if ans[i] > 1]</line-82>
<line-83> p = [q[i] for i in range(len(q))]</line-83>
<line-84> p.sort()</line-84>
<line-85> if p == q:</line-85>
<line-86> print(*ans,sep = "")</line-86>
<line-87> else:</line-87>
<line-88> print("-")</line-88>
<line-89> return</line-89>
<line-90></line-90>
<line-91>#D</line-91>
<line-92>def D():</line-92>
<line-93> def root(x):</line-93>
<line-94> if x == par[x]:</line-94>
<line-95> return x</line-95>
<line-96> par[x] = root(par[x])</line-96>
<line-97> return par[x]</line-97>
<line-98></line-98>
<line-99> def unite(x,y):</line-99>
<line-100> x = root(x)</line-100>
<line-101> y = root(y)</line-101>
<line-102> if rank[x] < rank[y]:</line-102>
<line-103> par[x] = y</line-103>
<line-104> else:</line-104>
<line-105> par[y] = x</line-105>
<line-106> if rank[x] == rank[y]:</line-106>
<line-107> rank[x] += 1</line-107>
<line-108></line-108>
<line-109> n,k = LI()</line-109>
<line-110> par = [i for i in range(n)]</line-110>
<line-111> rank = [0]*n</line-111>
<line-112> for i in range(k):</line-112>
<line-113> x,y = LI()</line-113>
<line-114> x -= 1</line-114>
<line-115> y -= 1</line-115>
<line-116> if root(x) != root(y):</line-116>
<line-117> unite(x,y)</line-117>
<line-118> size = [0]*n</line-118>
<line-119> for i in range(n):</line-119>
<line-120> size[root(i)] += 1</line-120>
<line-121> ans = 0</line-121>
<line-122> for i in size:</line-122>
<line-123> if i > 0:</line-123>
<line-124> ans += i-1</line-124>
<line-125> print(k-ans)</line-125>
<line-126> return</line-126>
<line-127></line-127>
<line-128>#E</line-128>
<line-129>def E():</line-129>
<line-130></line-130>
<line-131> return</line-131>
<line-132></line-132>
<line-133>#F</line-133>
<line-134>def F():</line-134>
<line-135></line-135>
<line-136> return</line-136>
<line-137></line-137>
<line-138>#G</line-138>
<line-139>def G():</line-139>
<line-140></line-140>
<line-141> return</line-141>
<line-142></line-142>
<line-143>#H</line-143>
<line-144>def H():</line-144>
<line-145></line-145>
<line-146> return</line-146>
<line-147></line-147>
<line-148>#Solve</line-148>
<line-149>def __starting_point():</line-149>
<line-151></line-151>
<line-152>__starting_point()</line-152>
|
{"code": "<line-2>from collections import defaultdict,deque</line-2>\n<line-150> D()</line-150>", "lines": [2, 150]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>for i in range(n-1):</line-3>
<line-4> u,v = [int(i)-1 for i in input().split()]</line-4>
<line-5> g[u].append(v)</line-5>
<line-6> g[v].append(u)</line-6>
<line-7></line-7>
<line-8>leaf = [len(i)==1 for i in g]</line-8>
<line-9>root = -1</line-9>
<line-10>mx = n-1</line-10>
<line-11>for i in range(n):</line-11>
<line-12> if leaf[i]:</line-12>
<line-13> root = i</line-13>
<line-14> leafs = 0</line-14>
<line-15> for j in g[i]:</line-15>
<line-16> if leaf[j]:</line-16>
<line-17> leafs += 1</line-17>
<line-18> if leafs > 1:</line-18>
<line-19> mx -= leafs-1</line-19>
<line-20></line-20>
<line-21>stack = [(root, -1, 0)]</line-21>
<line-22>even = True</line-22>
<line-23>while len(stack)>0:</line-23>
<line-24> i, j, d = stack.pop()</line-24>
<line-25> if leaf[i] and d%2 == 1:</line-25>
<line-26> even = False</line-26>
<line-27> break</line-27>
<line-28> for k in g[i]:</line-28>
<line-29> if k != j:</line-29>
<line-30> stack.append((k,i,d+1))</line-30>
<line-32></line-32>
<line-33>print(mn,mx)</line-33>
|
{"code": "<line-2>g = [[] for i in range(n)]</line-2>\n<line-31>mn = 1 if even else 3</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>n=int(input())</line-5>
<line-6>b=list(map(int,input().split()))</line-6>
<line-7>ope=[[] for i in range(n)]</line-7>
<line-8>Q=int(input())</line-8>
<line-9>for i in range(Q):</line-9>
<line-10> l,r=list(map(int,input().split()))</line-10>
<line-11> ope[r-1].append(l-1)</line-11>
<line-12></line-12>
<line-13>res=b.count(0)</line-13>
<line-14></line-14>
<line-15>Data=[(-1)**((b[i]==1)+1) for i in range(n)]</line-15>
<line-16>for i in range(1,n):</line-16>
<line-17> Data[i]+=Data[i-1]</line-17>
<line-18>Data=[0]+Data</line-18>
<line-19></line-19>
<line-20>for i in range(n):</line-20>
<line-21> ope[i].sort(reverse=True)</line-21>
<line-22></line-22>
<line-23># N: 処理する区間の長さ</line-23>
<line-24>N=n+1</line-24>
<line-25>N0 = 2**(N-1).bit_length()</line-25>
<line-26>data = [None]*(2*N0)</line-26>
<line-27>INF = (-2**31, -2**31)</line-27>
<line-28># 区間[l, r+1)の値をvに書き換える</line-28>
<line-29># vは(t, value)という値にする (新しい値ほどtは大きくなる)</line-29>
<line-30>def update(l, r, v):</line-30>
<line-31> L = l + N0; R = r + N0</line-31>
<line-32> while L < R:</line-32>
<line-33> if R & 1:</line-33>
<line-34> R -= 1</line-34>
<line-35> if data[R-1]:</line-35>
<line-36> data[R-1] = max(v,data[R-1])</line-36>
<line-37> else:</line-37>
<line-38> data[R-1]=v</line-38>
<line-39></line-39>
<line-40> if L & 1:</line-40>
<line-41> if data[L-1]:</line-41>
<line-42> data[L-1] = max(v,data[L-1])</line-42>
<line-43> else:</line-43>
<line-44> data[L-1]=v</line-44>
<line-45> L += 1</line-45>
<line-46> L >>= 1; R >>= 1</line-46>
<line-47># a_iの現在の値を取得</line-47>
<line-48>def _query(k):</line-48>
<line-49> k += N0-1</line-49>
<line-50> s = INF</line-50>
<line-51> while k >= 0:</line-51>
<line-52> if data[k]:</line-52>
<line-53> s = max(s, data[k])</line-53>
<line-54> k = (k - 1) // 2</line-54>
<line-55> return s</line-55>
<line-56># これを呼び出す</line-56>
<line-57>def query(k):</line-57>
<line-58> return _query(k)[1]</line-58>
<line-59></line-59>
<line-60>for i in range(n+1):</line-60>
<line-61> update(i,i+1,(-Data[i],-Data[i]))</line-61>
<line-62>if ope[0]:</line-62>
<line-63> update(1,2,(0,0))</line-63>
<line-64></line-64>
<line-65>for i in range(1,n):</line-65>
<line-66> val=query(i)</line-66>
<line-67> update(i+1,i+2,(val+Data[i]-Data[i+1],val+Data[i]-Data[i+1]))</line-67>
<line-68> for l in ope[i]:</line-68>
<line-69> val=query(l)</line-69>
<line-71></line-71>
<line-72></line-72>
<line-73></line-73>
<line-74>print((n-(res+query(n)+Data[n])))</line-74>
|
{"code": "<line-3>input=sys.stdin.readline</line-3>\n<line-70> update(l+1,i+2,(val,val))</line-70>", "lines": [3, 70]}
#### 0
|
<line-1></line-1>
<line-2>import sys</line-2>
<line-4>input=sys.stdin.readline</line-4>
<line-5>mii=lambda:list(map(int,input().split()))</line-5>
<line-6></line-6>
<line-7>for _ in range(int(input())):</line-7>
<line-8> n,x=mii()</line-8>
<line-9> has=0</line-9>
<line-10> a=0</line-10>
<line-11> for i in mii():</line-11>
<line-12> if x==i: has=1</line-12>
<line-13> a=max(a,i)</line-13>
<line-14> if has:</line-14>
<line-15> print(1)</line-15>
<line-17> print(max(2,(x-1)//a+1))</line-17>
|
{"code": "<line-3>#sys.stdin=open(\"data.txt\")</line-3>\n<line-16> else:</line-16>", "lines": [3, 16]}
#### 0
|
<line-1>import sys</line-1>
<line-3>qis = [int(sys.stdin.readline().strip()) for _ in range(q)]</line-3>
<line-4></line-4>
<line-5>def query(n, q):</line-5>
<line-6> d = 2 * n - q</line-6>
<line-7> while d % 2 == 0:</line-7>
<line-8> d //= 2</line-8>
<line-9> return (n - d // 2)</line-9>
<line-10></line-10>
<line-12> print (query(n, qi))</line-12>
|
{"code": "<line-2>[n, q] = map(int, sys.stdin.readline().strip().split())</line-2>\n<line-11>for qi in qis:</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>T = int(input())</line-1>
<line-3> a, b, n = [int(i) for i in input().split()]</line-3>
<line-4> if n%3 == 2:</line-4>
<line-5> print(a^b)</line-5>
<line-6> elif n%3 == 1:</line-6>
<line-7> print(b)</line-7>
<line-9> print(a)</line-9>
|
{"code": "<line-2>for t in range(T):</line-2>\n<line-8> else:</line-8>", "lines": [2, 8]}
#### 0
|
<line-1></line-1>
<line-2></line-2>
<line-3>class Graph:</line-3>
<line-5> self.n_vertices = n_vertices</line-5>
<line-6> self.edges = edges</line-6>
<line-7> self.directed = directed</line-7>
<line-8> self.weighted = weighted</line-8>
<line-9></line-9>
<line-10> @property</line-10>
<line-11> def adj(self):</line-11>
<line-12> try:</line-12>
<line-13> return self._adj</line-13>
<line-14> except AttributeError:</line-14>
<line-15> adj = [[] for _ in range(self.n_vertices)]</line-15>
<line-16> def d_w(e):</line-16>
<line-17> adj[e[0]].append((e[1],e[2]))</line-17>
<line-18> def ud_w(e):</line-18>
<line-19> adj[e[0]].append((e[1],e[2]))</line-19>
<line-20> adj[e[1]].append((e[0],e[2]))</line-20>
<line-21> def d_uw(e):</line-21>
<line-22> adj[e[0]].append(e[1])</line-22>
<line-23> def ud_uw(e):</line-23>
<line-24> adj[e[0]].append(e[1])</line-24>
<line-25> adj[e[1]].append(e[0])</line-25>
<line-26> helper = (ud_uw, d_uw, ud_w, d_w)[self.directed+self.weighted*2]</line-26>
<line-27> for e in self.edges:</line-27>
<line-28> helper(e)</line-28>
<line-29> self._adj = adj</line-29>
<line-30> return adj</line-30>
<line-31></line-31>
<line-32>class RootedTree(Graph):</line-32>
<line-33> def __init__(self, n_vertices, edges, root_vertex):</line-33>
<line-34> self.root = root_vertex</line-34>
<line-35> super().__init__(n_vertices, edges, False, False)</line-35>
<line-36></line-36>
<line-37> @property</line-37>
<line-38> def parent(self):</line-38>
<line-39> try:</line-39>
<line-40> return self._parent</line-40>
<line-41> except AttributeError:</line-41>
<line-42> adj = self.adj</line-42>
<line-43> parent = [None]*self.n_vertices</line-43>
<line-44> parent[self.root] = -1</line-44>
<line-45> stack = [self.root]</line-45>
<line-46> for i in range(self.n_vertices):</line-46>
<line-47> v = stack.pop()</line-47>
<line-48> for u in adj[v]:</line-48>
<line-49> if parent[u] is None:</line-49>
<line-50> parent[u] = v</line-50>
<line-51> stack.append(u)</line-51>
<line-52> self._parent = parent</line-52>
<line-53> return parent</line-53>
<line-54></line-54>
<line-55> @property</line-55>
<line-56> def children(self):</line-56>
<line-57> try:</line-57>
<line-58> return self._children</line-58>
<line-59> except AttributeError:</line-59>
<line-60> children = [None]*self.n_vertices</line-60>
<line-61> for v,(l,p) in enumerate(zip(self.adj,self.parent)):</line-61>
<line-62> children[v] = [u for u in l if u != p]</line-62>
<line-63> self._children = children</line-63>
<line-64> return children</line-64>
<line-65></line-65>
<line-66> @property</line-66>
<line-67> def dfs_order(self):</line-67>
<line-68> try:</line-68>
<line-69> return self._dfs_order</line-69>
<line-70> except AttributeError:</line-70>
<line-71> order = [None]*self.n_vertices</line-71>
<line-72> children = self.children</line-72>
<line-73> stack = [self.root]</line-73>
<line-74> for i in range(self.n_vertices):</line-74>
<line-75> v = stack.pop()</line-75>
<line-76> order[i] = v</line-76>
<line-77> for u in children[v]:</line-77>
<line-78> stack.append(u)</line-78>
<line-79> self._dfs_order = order</line-79>
<line-80> return order</line-80>
<line-81></line-81>
<line-82>from functools import reduce</line-82>
<line-83>from itertools import accumulate,chain</line-83>
<line-84>def rerooting(rooted_tree, merge, identity, finalize):</line-84>
<line-85> N = rooted_tree.n_vertices</line-85>
<line-86> parent = rooted_tree.parent</line-86>
<line-87> children = rooted_tree.children</line-87>
<line-88> order = rooted_tree.dfs_order</line-88>
<line-89></line-89>
<line-90> # from leaf to parent</line-90>
<line-91> dp_down = [None]*N</line-91>
<line-92> for v in reversed(order[1:]):</line-92>
<line-93> dp_down[v] = finalize(reduce(merge,</line-93>
<line-94> (dp_down[c] for c in children[v]),</line-94>
<line-95> identity))</line-95>
<line-96></line-96>
<line-97> # from parent to leaf</line-97>
<line-98> dp_up = [None]*N</line-98>
<line-99> dp_up[0] = identity</line-99>
<line-100> for v in order:</line-100>
<line-101> if len(children[v]) == 0:</line-101>
<line-102> continue</line-102>
<line-103> temp = (dp_up[v],)+tuple(dp_down[u] for u in children[v])+(identity,)</line-103>
<line-104> left = tuple(accumulate(temp,merge))</line-104>
<line-105> right = tuple(accumulate(reversed(temp[2:]),merge))</line-105>
<line-106> for u,l,r in zip(children[v],left,reversed(right)):</line-106>
<line-107> dp_up[u] = finalize(merge(l,r))</line-107>
<line-108></line-108>
<line-109> res = [None]*N</line-109>
<line-110> for v,l in enumerate(children):</line-110>
<line-111> res[v] = reduce(merge,</line-111>
<line-112> (dp_down[u] for u in children[v]),</line-112>
<line-113> identity)</line-113>
<line-114> res[v] = finalize(merge(res[v], dp_up[v]))</line-114>
<line-115></line-115>
<line-116> return res</line-116>
<line-117></line-117>
<line-118>def solve(T):</line-118>
<line-119> MOD = 10**9 + 7</line-119>
<line-120> def merge(x,y):</line-120>
<line-121> return (x*y)%MOD</line-121>
<line-122> def finalize(x):</line-122>
<line-123> return x+1</line-123>
<line-124></line-124>
<line-125> return [v-1 for v in rerooting(T,merge,1,finalize)]</line-125>
<line-126></line-126>
<line-127></line-127>
<line-128>def __starting_point():</line-128>
<line-129> N = int(input())</line-129>
<line-130> edges = [(i+1,p-1) for i,p in enumerate(map(int,input().split()))]</line-130>
<line-131> T = RootedTree(N, edges, 0)</line-131>
<line-133></line-133>
<line-134>__starting_point()</line-134>
|
{"code": "<line-4> def __init__(self, n_vertices, edges, directed=True, weighted=False):</line-4>\n<line-132> print(*solve(T))</line-132>", "lines": [4, 132]}
#### 0
|
<line-1></line-1>
<line-2></line-2>
<line-3>#===============================================================================================</line-3>
<line-5></line-5>
<line-6></line-6>
<line-7></line-7>
<line-8>from fractions import Fraction</line-8>
<line-9>import sys</line-9>
<line-10>import os</line-10>
<line-11>from io import BytesIO, IOBase</line-11>
<line-12>from functools import cmp_to_key</line-12>
<line-13></line-13>
<line-14># from itertools import *</line-14>
<line-15>from heapq import *</line-15>
<line-16>from math import gcd, factorial,floor,ceil,sqrt</line-16>
<line-17></line-17>
<line-18>from copy import deepcopy</line-18>
<line-19>from collections import deque</line-19>
<line-20></line-20>
<line-21></line-21>
<line-22>from bisect import bisect_left as bl</line-22>
<line-23>from bisect import bisect_right as br</line-23>
<line-24>from bisect import bisect</line-24>
<line-25></line-25>
<line-26>#==============================================================================================</line-26>
<line-27>#fast I/O region</line-27>
<line-28>BUFSIZE = 8192</line-28>
<line-29></line-29>
<line-30></line-30>
<line-31>class FastIO(IOBase):</line-31>
<line-32> newlines = 0</line-32>
<line-33></line-33>
<line-34> def __init__(self, file):</line-34>
<line-35> self._fd = file.fileno()</line-35>
<line-36> self.buffer = BytesIO()</line-36>
<line-37> self.writable = "x" in file.mode or "r" not in file.mode</line-37>
<line-38> self.write = self.buffer.write if self.writable else None</line-38>
<line-39></line-39>
<line-40> def read(self):</line-40>
<line-41> while True:</line-41>
<line-42> b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))</line-42>
<line-43> if not b:</line-43>
<line-44> break</line-44>
<line-45> ptr = self.buffer.tell()</line-45>
<line-46> self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)</line-46>
<line-47> self.newlines = 0</line-47>
<line-48> return self.buffer.read()</line-48>
<line-49></line-49>
<line-50> def readline(self):</line-50>
<line-51> while self.newlines == 0:</line-51>
<line-52> b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))</line-52>
<line-53> self.newlines = b.count(b"\n") + (not b)</line-53>
<line-54> ptr = self.buffer.tell()</line-54>
<line-55> self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)</line-55>
<line-56> self.newlines -= 1</line-56>
<line-57> return self.buffer.readline()</line-57>
<line-58></line-58>
<line-59> def flush(self):</line-59>
<line-60> if self.writable:</line-60>
<line-61> os.write(self._fd, self.buffer.getvalue())</line-61>
<line-62> self.buffer.truncate(0), self.buffer.seek(0)</line-62>
<line-63></line-63>
<line-64></line-64>
<line-65>class IOWrapper(IOBase):</line-65>
<line-66> def __init__(self, file):</line-66>
<line-67> self.buffer = FastIO(file)</line-67>
<line-68> self.flush = self.buffer.flush</line-68>
<line-69> self.writable = self.buffer.writable</line-69>
<line-70> self.write = lambda s: self.buffer.write(s.encode("ascii"))</line-70>
<line-71> self.read = lambda: self.buffer.read().decode("ascii")</line-71>
<line-72> self.readline = lambda: self.buffer.readline().decode("ascii")</line-72>
<line-73></line-73>
<line-74></line-74>
<line-75>def print(*args, **kwargs):</line-75>
<line-76> """Prints the values to a stream, or to sys.stdout by default."""</line-76>
<line-77> sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)</line-77>
<line-78> at_start = True</line-78>
<line-79> for x in args:</line-79>
<line-80> if not at_start:</line-80>
<line-81> file.write(sep)</line-81>
<line-82> file.write(str(x))</line-82>
<line-83> at_start = False</line-83>
<line-84> file.write(kwargs.pop("end", "\n"))</line-84>
<line-85> if kwargs.pop("flush", False):</line-85>
<line-86> file.flush()</line-86>
<line-87></line-87>
<line-88></line-88>
<line-89>if sys.version_info[0] < 3:</line-89>
<line-90> sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)</line-90>
<line-91>else:</line-91>
<line-92> sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)</line-92>
<line-93></line-93>
<line-94># inp = lambda: sys.stdin.readline().rstrip("\r\n")</line-94>
<line-95></line-95>
<line-96>#===============================================================================================</line-96>
<line-97>### START ITERATE RECURSION ###</line-97>
<line-98>from types import GeneratorType</line-98>
<line-99>def iterative(f, stack=[]):</line-99>
<line-100> def wrapped_func(*args, **kwargs):</line-100>
<line-101> if stack: return f(*args, **kwargs)</line-101>
<line-102> to = f(*args, **kwargs)</line-102>
<line-103> while True:</line-103>
<line-104> if type(to) is GeneratorType:</line-104>
<line-105> stack.append(to)</line-105>
<line-106> to = next(to)</line-106>
<line-107> continue</line-107>
<line-108> stack.pop()</line-108>
<line-109> if not stack: break</line-109>
<line-110> to = stack[-1].send(to)</line-110>
<line-111> return to</line-111>
<line-112> return wrapped_func</line-112>
<line-113>#### END ITERATE RECURSION ####</line-113>
<line-114></line-114>
<line-115>#===============================================================================================</line-115>
<line-116>#some shortcuts</line-116>
<line-117></line-117>
<line-118>def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input</line-118>
<line-119>def out(var): sys.stdout.write(str(var)) #for fast output, always take string</line-119>
<line-120>def lis(): return list(map(int, inp().split()))</line-120>
<line-121>def stringlis(): return list(map(str, inp().split()))</line-121>
<line-122>def sep(): return list(map(int, inp().split()))</line-122>
<line-123>def strsep(): return list(map(str, inp().split()))</line-123>
<line-124># def graph(vertex): return [[] for i in range(0,vertex+1)]</line-124>
<line-125>def zerolist(n): return [0]*n</line-125>
<line-126>def nextline(): out("\n") #as stdout.write always print sring.</line-126>
<line-127>def testcase(t):</line-127>
<line-128> for pp in range(t):</line-128>
<line-129> solve(pp)</line-129>
<line-130>def printlist(a) :</line-130>
<line-131> for p in range(0,len(a)):</line-131>
<line-132> out(str(a[p]) + ' ')</line-132>
<line-133>def google(p):</line-133>
<line-134> print('Case #'+str(p)+': ',end='')</line-134>
<line-135>def lcm(a,b): return (a*b)//gcd(a,b)</line-135>
<line-136>def power(x, y, p) :</line-136>
<line-137> y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.</line-137>
<line-138> res = 1 # Initialize result</line-138>
<line-139> x = x % p # Update x if it is more , than or equal to p</line-139>
<line-140> if (x == 0) :</line-140>
<line-141> return 0</line-141>
<line-142> while (y > 0) :</line-142>
<line-143> if ((y & 1) == 1) : # If y is odd, multiply, x with result</line-143>
<line-144> res = (res * x) % p</line-144>
<line-145></line-145>
<line-146> y = y >> 1 # y = y/2</line-146>
<line-147> x = (x * x) % p</line-147>
<line-148> return res</line-148>
<line-149>def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))</line-149>
<line-150>def isPrime(n) :</line-150>
<line-151> if (n <= 1) : return False</line-151>
<line-152> if (n <= 3) : return True</line-152>
<line-153> if (n % 2 == 0 or n % 3 == 0) : return False</line-153>
<line-154> i = 5</line-154>
<line-155> while(i * i <= n) :</line-155>
<line-156> if (n % i == 0 or n % (i + 2) == 0) :</line-156>
<line-157> return False</line-157>
<line-158> i = i + 6</line-158>
<line-159> return True</line-159>
<line-160>inf = pow(10,20)</line-160>
<line-161>mod = 10**9+7</line-161>
<line-162>#===============================================================================================</line-162>
<line-163># code here ;))</line-163>
<line-164>def djkistra(g,st,dist,lol,vis): #g contains b,dist(a to b) and dist is initiaalised by 10**9 initiallly</line-164>
<line-165> pq = []</line-165>
<line-166> dist[st] = 0</line-166>
<line-167> heappush(pq,(0,st))</line-167>
<line-168> while(len(pq) != 0):</line-168>
<line-169> curr = heappop(pq)[1]</line-169>
<line-170> for i in range(0,len(g[curr])):</line-170>
<line-171> b = g[curr][i][0]</line-171>
<line-172> w = g[curr][i][1]</line-172>
<line-173> if(dist[b] > dist[curr] + w):</line-173>
<line-174> dist[b] = dist[curr]+w</line-174>
<line-175> heappush(pq,(dist[b],b))</line-175>
<line-176></line-176>
<line-177></line-177>
<line-178>def modif_djkistra(g,dist,usedtrains):</line-178>
<line-179> h = []</line-179>
<line-180> for i in range(len(g)):</line-180>
<line-181> if(dist[i] != inf):</line-181>
<line-182> heappush(h,(dist[i],i))</line-182>
<line-183> while(len(h) != 0):</line-183>
<line-184> d,curr = heappop(h)</line-184>
<line-185> if(d != dist[curr]): #dublicate train with larger length</line-185>
<line-186> continue</line-186>
<line-187> for to,newd in g[curr]:</line-187>
<line-188> if(newd+d<=dist[to]):</line-188>
<line-189> usedtrains[to] = False</line-189>
<line-190> if(dist[to] > newd+d):</line-190>
<line-191> heappush(h,(newd+d,to))</line-191>
<line-192> dist[to] = newd+d</line-192>
<line-193></line-193>
<line-194>def solve(case):</line-194>
<line-195> n,m,k = sep()</line-195>
<line-196> dist = [inf]*n;dist[0] = 0</line-196>
<line-197> g = [[] for i in range(n)]</line-197>
<line-198> for i in range(m):</line-198>
<line-199> a,b,c = sep()</line-199>
<line-200> a-=1</line-200>
<line-201> b-=1</line-201>
<line-202> g[a].append((b,c))</line-202>
<line-203> g[b].append((a,c))</line-203>
<line-204> have = []</line-204>
<line-205> usedtrain = [False]*n</line-205>
<line-206> for i in range(k):</line-206>
<line-207> a,b = sep()</line-207>
<line-208> a-=1</line-208>
<line-209> dist[a] = min(dist[a],b)</line-209>
<line-210> # g[0].append((a,b))</line-210>
<line-211> # g[a].append((0,b))</line-211>
<line-212> have.append(a)</line-212>
<line-213> usedtrain[a] = True</line-213>
<line-214> modif_djkistra(g,dist,usedtrain)</line-214>
<line-215> cnt = 0</line-215>
<line-216> have = list(set(have))</line-216>
<line-217> for i in range(n):</line-217>
<line-218> if(usedtrain[i]):</line-218>
<line-219> cnt+=1</line-219>
<line-220> # print(cnt)</line-220>
<line-221> print(k - cnt)</line-221>
<line-222></line-222>
<line-223></line-223>
<line-224></line-224>
<line-225></line-225>
<line-226></line-226>
<line-227></line-227>
<line-229># testcase(int(inp()))</line-229>
<line-230></line-230>
<line-231></line-231>
<line-232></line-232>
<line-233></line-233>
<line-234></line-234>
<line-235></line-235>
<line-236></line-236>
<line-237></line-237>
<line-238></line-238>
|
{"code": "<line-4>#importing some useful libraries.</line-4>\n<line-228>testcase(1)</line-228>", "lines": [4, 228]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>m=int(sys.stdin.readline())</line-4>
<line-5></line-5>
<line-6>Numx=[]</line-6>
<line-7>Numy=[]</line-7>
<line-8>Numz=[]</line-8>
<line-9>x=0</line-9>
<line-10>y=0</line-10>
<line-11>z=0</line-11>
<line-12>for i in range(len(s)):</line-12>
<line-13> if(s[i]=='x'):</line-13>
<line-14> x+=1</line-14>
<line-15> if(s[i]=='y'):</line-15>
<line-16> y+=1</line-16>
<line-17> if(s[i]=='z'):</line-17>
<line-18> z+=1</line-18>
<line-19> Numx.append(x)</line-19>
<line-20> Numy.append(y)</line-20>
<line-21> Numz.append(z)</line-21>
<line-22> </line-22>
<line-23></line-23>
<line-24>Ans=""</line-24>
<line-25>for M in range(m):</line-25>
<line-26> s,e=list(map(int,sys.stdin.readline().split()))</line-26>
<line-27> if(e-s+1<=2):</line-27>
<line-28> Ans+="YES\n"</line-28>
<line-29> continue</line-29>
<line-30> s-=1</line-30>
<line-31> e-=1</line-31>
<line-32> x=Numx[e]</line-32>
<line-33> y=Numy[e]</line-33>
<line-34> z=Numz[e]</line-34>
<line-35> if(s!=0):</line-35>
<line-36> x-=Numx[s-1]</line-36>
<line-37> y-=Numy[s-1]</line-37>
<line-38> z-=Numz[s-1]</line-38>
<line-39> if(x==y==z):</line-39>
<line-40> Ans+="YES\n"</line-40>
<line-41> continue</line-41>
<line-42> L=[x,y,z]</line-42>
<line-43> L.sort()</line-43>
<line-44> if(L[0]==L[1] and L[2]==L[1]+1):</line-44>
<line-45> Ans+="YES\n"</line-45>
<line-46> continue</line-46>
<line-47> if(L[1]==L[2] and L[0]==L[1]-1):</line-47>
<line-48> Ans+="YES\n"</line-48>
<line-49> else:</line-49>
<line-51>sys.stdout.write(Ans)</line-51>
<line-52> </line-52>
<line-53> </line-53>
<line-54></line-54>
<line-55> </line-55>
|
{"code": "<line-2>s=sys.stdin.readline().split()[0]</line-2>\n<line-50> Ans+=\"NO\\n\"</line-50>", "lines": [2, 50]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>d = list(map(int, sys.stdin.readline().split()))</line-4>
<line-5>gph = [[] for _ in range(n)]</line-5>
<line-6></line-6>
<line-7>for _ in range(m):</line-7>
<line-8> u, v = list(map(int, sys.stdin.readline().split()))</line-8>
<line-9> u -= 1</line-9>
<line-10> v -= 1</line-10>
<line-11> gph[u].append((v, _))</line-11>
<line-12> gph[v].append((u, _))</line-12>
<line-13> </line-13>
<line-14>t = -1</line-14>
<line-15>if d.count(1) % 2 == 1:</line-15>
<line-16> if -1 not in d:</line-16>
<line-17> print(-1)</line-17>
<line-18> return</line-18>
<line-19> t = d.index(-1)</line-19>
<line-20></line-20>
<line-21>ans = [False] * m</line-21>
<line-22>vis = [False] * n</line-22>
<line-23>ed = [(-1, -1)] * n</line-23>
<line-24>rets = [(d[u] == 1) or (u == t) for u in range(n)]</line-24>
<line-25></line-25>
<line-26>stk = [[0, iter(gph[0])]]</line-26>
<line-27>while len(stk) > 0:</line-27>
<line-28> u = stk[-1][0]</line-28>
<line-29> vis[u] = True</line-29>
<line-30> try:</line-30>
<line-31> while True:</line-31>
<line-32> v, i = next(stk[-1][1])</line-32>
<line-33> if not vis[v]:</line-33>
<line-34> ed[v] = (u, i)</line-34>
<line-35> stk.append([v, iter(gph[v])])</line-35>
<line-36> break</line-36>
<line-37> except StopIteration:</line-37>
<line-38> p, e = ed[u]</line-38>
<line-39> if p >= 0 and rets[u]:</line-39>
<line-40> rets[p] = not rets[p]</line-40>
<line-41> ans[e] = True</line-41>
<line-42> stk.pop()</line-42>
<line-43> pass</line-43>
<line-44> </line-44>
<line-45>print(ans.count(True))</line-45>
<line-47>#1231</line-47>
|
{"code": "<line-3>n, m = list(map(int, sys.stdin.readline().split()))</line-3>\n<line-46>print(\"\\n\".join([str(i+1) for i in range(m) if ans[i]]))</line-46>", "lines": [3, 46]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>q=int(input())</line-3>
<line-4>changes=[0]*q</line-4>
<line-5>for i in range(q):</line-5>
<line-6> changes[-i-1]=tuple(map(int,input().split()))</line-6>
<line-7>final=[-1]*n</line-7>
<line-8>curr=0</line-8>
<line-9>for guy in changes:</line-9>
<line-10> if guy[0]==1:</line-10>
<line-11> if final[guy[1]-1]==-1:</line-11>
<line-12> final[guy[1]-1]=max(guy[2],curr)</line-12>
<line-13> else:</line-13>
<line-14> curr=max(curr,guy[1])</line-14>
<line-15>for i in range(n):</line-15>
<line-16> if final[i]==-1:</line-16>
<line-17> final[i]=max(curr,a[i])</line-17>
<line-19>print(" ".join(final))</line-19>
|
{"code": "<line-2>a=list(map(int,input().split()))</line-2>\n<line-18>final=[str(guy) for guy in final]</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>n, q = map(int, input().split())</line-1>
<line-3></line-3>
<line-4>nxt = [[n + 1] * (n + 2) for _ in range(26)]</line-4>
<line-5>for i in range(n - 1, -1, -1):</line-5>
<line-6> c = ord(s[i + 1]) - 97</line-6>
<line-7> for j in range(26):</line-7>
<line-8> nxt[j][i] = nxt[j][i + 1]</line-8>
<line-9> nxt[c][i] = i + 1</line-9>
<line-10></line-10>
<line-11>w = [[-1], [-1], [-1]]</line-11>
<line-12>idx = lambda i, j, k: i * 65536 + j * 256 + k</line-12>
<line-13>dp = [0] * (256 * 256 * 256)</line-13>
<line-14>def calc(fix=None):</line-14>
<line-15> r = list(map(range, (len(w[0]), len(w[1]), len(w[2]))))</line-15>
<line-16> if fix is not None: r[fix] = range(len(w[fix]) - 1, len(w[fix]))</line-16>
<line-17> for i in r[0]:</line-17>
<line-18> for j in r[1]:</line-18>
<line-19> for k in r[2]:</line-19>
<line-20> dp[idx(i, j, k)] = min(nxt[w[0][i]][dp[idx(i - 1, j, k)]] if i else n + 1,</line-20>
<line-21> nxt[w[1][j]][dp[idx(i, j - 1, k)]] if j else n + 1,</line-21>
<line-22> nxt[w[2][k]][dp[idx(i, j, k - 1)]] if k else n + 1)</line-22>
<line-23> if i == j == k == 0: dp[idx(i, j, k)] = 0</line-23>
<line-24></line-24>
<line-25>out = []</line-25>
<line-26>for _ in range(q):</line-26>
<line-27> t, *r = input().split()</line-27>
<line-28> if t == '+':</line-28>
<line-29> i, c = int(r[0]) - 1, ord(r[1]) - 97</line-29>
<line-30> w[i].append(c)</line-30>
<line-31> calc(i)</line-31>
<line-32> else:</line-32>
<line-33> i = int(r[0]) - 1</line-33>
<line-34> w[i].pop()</line-34>
<line-35> req = dp[idx(len(w[0]) - 1, len(w[1]) - 1, len(w[2]) - 1)]</line-35>
<line-37></line-37>
<line-38>print(*out, sep='\n')</line-38>
|
{"code": "<line-2>s = '!' + input()</line-2>\n<line-36> out.append('YES' if req <= n else 'NO')</line-36>", "lines": [2, 36]}
#### 0
|
<line-1>import sys</line-1>
<line-3>class Lazysegtree:</line-3>
<line-4> #RAQ</line-4>
<line-5> def __init__(self, A, intv, initialize = True, segf = min):</line-5>
<line-6> #区間は 1-indexed で管理</line-6>
<line-7> self.N = len(A)</line-7>
<line-8> self.N0 = 2**(self.N-1).bit_length()</line-8>
<line-9> self.intv = intv</line-9>
<line-10> self.segf = segf</line-10>
<line-11> self.lazy = [0]*(2*self.N0)</line-11>
<line-12> if initialize:</line-12>
<line-13> self.data = [intv]*self.N0 + A + [intv]*(self.N0 - self.N)</line-13>
<line-14> for i in range(self.N0-1, 0, -1):</line-14>
<line-15> self.data[i] = self.segf(self.data[2*i], self.data[2*i+1]) </line-15>
<line-16> else:</line-16>
<line-17> self.data = [intv]*(2*self.N0)</line-17>
<line-18></line-18>
<line-19> def _ascend(self, k):</line-19>
<line-20> k = k >> 1</line-20>
<line-21> c = k.bit_length()</line-21>
<line-22> for j in range(c):</line-22>
<line-23> idx = k >> j</line-23>
<line-24> self.data[idx] = self.segf(self.data[2*idx], self.data[2*idx+1]) \</line-24>
<line-25> + self.lazy[idx]</line-25>
<line-26> </line-26>
<line-27> def _descend(self, k):</line-27>
<line-28> k = k >> 1</line-28>
<line-29> idx = 1</line-29>
<line-30> c = k.bit_length()</line-30>
<line-31> for j in range(1, c+1):</line-31>
<line-32> idx = k >> (c - j)</line-32>
<line-33> ax = self.lazy[idx]</line-33>
<line-34> if not ax:</line-34>
<line-35> continue</line-35>
<line-36> self.lazy[idx] = 0</line-36>
<line-37> self.data[2*idx] += ax</line-37>
<line-38> self.data[2*idx+1] += ax</line-38>
<line-39> self.lazy[2*idx] += ax</line-39>
<line-40> self.lazy[2*idx+1] += ax</line-40>
<line-41> </line-41>
<line-42> def query(self, l, r):</line-42>
<line-43> L = l+self.N0</line-43>
<line-44> R = r+self.N0</line-44>
<line-45> Li = L//(L & -L)</line-45>
<line-46> Ri = R//(R & -R)</line-46>
<line-47> self._descend(Li)</line-47>
<line-48> self._descend(Ri - 1)</line-48>
<line-49> </line-49>
<line-50> s = self.intv </line-50>
<line-51> while L < R:</line-51>
<line-52> if R & 1:</line-52>
<line-53> R -= 1</line-53>
<line-54> s = self.segf(s, self.data[R])</line-54>
<line-55> if L & 1:</line-55>
<line-56> s = self.segf(s, self.data[L])</line-56>
<line-57> L += 1</line-57>
<line-58> L >>= 1</line-58>
<line-59> R >>= 1</line-59>
<line-60> return s</line-60>
<line-61> </line-61>
<line-62> def add(self, l, r, x):</line-62>
<line-63> L = l+self.N0</line-63>
<line-64> R = r+self.N0</line-64>
<line-65></line-65>
<line-66> Li = L//(L & -L)</line-66>
<line-67> Ri = R//(R & -R)</line-67>
<line-68> </line-68>
<line-69> while L < R :</line-69>
<line-70> if R & 1:</line-70>
<line-71> R -= 1</line-71>
<line-72> self.data[R] += x</line-72>
<line-73> self.lazy[R] += x</line-73>
<line-74> if L & 1:</line-74>
<line-75> self.data[L] += x</line-75>
<line-76> self.lazy[L] += x</line-76>
<line-77> L += 1</line-77>
<line-78> L >>= 1</line-78>
<line-79> R >>= 1</line-79>
<line-80> </line-80>
<line-81> self._ascend(Li)</line-81>
<line-82> self._ascend(Ri-1)</line-82>
<line-83> </line-83>
<line-84> def binsearch(self, l, r, check, reverse = False):</line-84>
<line-85> L = l+self.N0</line-85>
<line-86> R = r+self.N0</line-86>
<line-87> Li = L//(L & -L)</line-87>
<line-88> Ri = R//(R & -R)</line-88>
<line-89> self._descend(Li)</line-89>
<line-90> self._descend(Ri-1)</line-90>
<line-91> SL, SR = [], []</line-91>
<line-92> while L < R:</line-92>
<line-93> if R & 1:</line-93>
<line-94> R -= 1</line-94>
<line-95> SR.append(R)</line-95>
<line-96> if L & 1:</line-96>
<line-97> SL.append(L)</line-97>
<line-98> L += 1</line-98>
<line-99> L >>= 1</line-99>
<line-100> R >>= 1</line-100>
<line-101> </line-101>
<line-102> if reverse:</line-102>
<line-103> for idx in (SR + SL[::-1]):</line-103>
<line-104> if check(self.data[idx]):</line-104>
<line-105> break</line-105>
<line-106> else:</line-106>
<line-107> return -1</line-107>
<line-108> while idx < self.N0:</line-108>
<line-109> ax = self.lazy[idx]</line-109>
<line-110> self.lazy[idx] = 0</line-110>
<line-111> self.data[2*idx] += ax</line-111>
<line-112> self.data[2*idx+1] += ax</line-112>
<line-113> self.lazy[2*idx] += ax</line-113>
<line-114> self.lazy[2*idx+1] += ax</line-114>
<line-115> idx = idx << 1</line-115>
<line-116> if check(self.data[idx+1]):</line-116>
<line-117> idx += 1</line-117>
<line-118> return idx - self.N0</line-118>
<line-119> else:</line-119>
<line-120> for idx in (SL + SR[::-1]):</line-120>
<line-121> if check(self.data[idx]):</line-121>
<line-122> break</line-122>
<line-123> else:</line-123>
<line-124> return -1</line-124>
<line-125> while idx < self.N0:</line-125>
<line-126> ax = self.lazy[idx]</line-126>
<line-127> self.lazy[idx] = 0</line-127>
<line-128> self.data[2*idx] += ax</line-128>
<line-129> self.data[2*idx+1] += ax</line-129>
<line-130> self.lazy[2*idx] += ax</line-130>
<line-131> self.lazy[2*idx+1] += ax</line-131>
<line-132> idx = idx << 1</line-132>
<line-133> if not check(self.data[idx]):</line-133>
<line-134> idx += 1</line-134>
<line-135> return idx - self.N0</line-135>
<line-136> def provfunc(self):</line-136>
<line-137> idx = 1</line-137>
<line-138> if self.data[1] >= 0:</line-138>
<line-139> return -1</line-139>
<line-140> while idx < self.N0:</line-140>
<line-141> ax = self.lazy[idx]</line-141>
<line-142> self.lazy[idx] = 0</line-142>
<line-143> self.data[2*idx] += ax</line-143>
<line-144> self.data[2*idx+1] += ax</line-144>
<line-145> self.lazy[2*idx] += ax</line-145>
<line-146> self.lazy[2*idx+1] += ax</line-146>
<line-147> idx = idx << 1</line-147>
<line-148> if self.data[idx+1] < 0:</line-148>
<line-149> idx += 1</line-149>
<line-150> return idx - self.N0</line-150>
<line-151></line-151>
<line-152>N, M = list(map(int, input().split()))</line-152>
<line-153>A = list(map(int, input().split()))</line-153>
<line-154>B = list(map(int, input().split()))</line-154>
<line-155>table = [0]*(10**6+1)</line-155>
<line-156>for a in A:</line-156>
<line-157> table[a] -= 1</line-157>
<line-158>for b in B:</line-158>
<line-159> table[b] += 1</line-159>
<line-160>table = list(accumulate(table[::-1]))[::-1]</line-160>
<line-161>T = Lazysegtree(table, 0, True, min)</line-161>
<line-162>Q = int(input())</line-162>
<line-163>Ans = [None]*Q</line-163>
<line-164>for q in range(Q):</line-164>
<line-165> t, i, x = list(map(int, sys.stdin.readline().split()))</line-165>
<line-166> i -= 1</line-166>
<line-167> if t == 1:</line-167>
<line-168> T.add(0, x+1, -1)</line-168>
<line-169> T.add(0, A[i]+1, 1)</line-169>
<line-170> A[i] = x</line-170>
<line-171> else:</line-171>
<line-172> T.add(0, x+1, 1)</line-172>
<line-173> T.add(0, B[i]+1, -1)</line-173>
<line-174> B[i] = x</line-174>
<line-176></line-176>
<line-177>print('\n'.join(map(str, Ans))) </line-177>
|
{"code": "<line-2>from itertools import accumulate </line-2>\n<line-175> Ans[q] = T.provfunc()</line-175>", "lines": [2, 175]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>for i in range(n):</line-3>
<line-4> a.append(list(map(int,input().split())))</line-4>
<line-5>m=int(input())</line-5>
<line-6>b=list(map(lambda x:int(x)-1,input().split()))</line-6>
<line-7>c=[]</line-7>
<line-8>now=0</line-8>
<line-9>k=0</line-9>
<line-10>ans=[]</line-10>
<line-11>for i in range(n):</line-11>
<line-12> t=a[i]</line-12>
<line-13> last=now</line-13>
<line-14> if t[0]==1:</line-14>
<line-15> now+=1</line-15>
<line-16> if len(c)<100000: c.append(t[1])</line-16>
<line-17> if k<m and b[k]==now-1: </line-17>
<line-18> ans.append(t[1])</line-18>
<line-19> k+=1</line-19>
<line-20> else:</line-20>
<line-21> now+=t[1]*t[2]</line-21>
<line-22> while t[2]:</line-22>
<line-23> if len(c)<100000: c.extend(c[:t[1]])</line-23>
<line-24> else: break</line-24>
<line-25> t[2]-=1</line-25>
<line-26> while k<m and last<=b[k]<now:</line-26>
<line-27> ans.append(c[(b[k]-last)%t[1]])</line-27>
<line-28> k+=1 </line-28>
<line-30> print(ans[i],end=' ')</line-30>
|
{"code": "<line-2>a=[]</line-2>\n<line-29>for i in range(m):</line-29>", "lines": [2, 29]}
#### 0
|
<line-1>def dfs(x, y):</line-1>
<line-3> y += 1</line-3>
<line-4> nonlocal flag</line-4>
<line-5> if flag or str.isalpha(grid[x][y]):</line-5>
<line-6> return</line-6>
<line-7> if y >= n - 1:</line-7>
<line-8> flag = True</line-8>
<line-9> return</line-9>
<line-10> </line-10>
<line-11> # stay idle</line-11>
<line-12> if not str.isalpha(grid[x][y + 1]) and not str.isalpha(grid[x][y + 2]) and (x, y + 2) not in vis:</line-12>
<line-13> dfs(x, y + 2)</line-13>
<line-14></line-14>
<line-15> # move down</line-15>
<line-16> if x > 0 and not str.isalpha(grid[x - 1][y]) and not str.isalpha(grid[x - 1][y + 1]) and not str.isalpha(grid[x - 1][y + 2]) and (x - 1, y + 2) not in vis:</line-16>
<line-17> dfs(x - 1, y + 2)</line-17>
<line-18></line-18>
<line-19> #move up</line-19>
<line-20> if x < 2 and not str.isalpha(grid[x + 1][y]) and not str.isalpha(grid[x + 1][y + 1]) and not str.isalpha(grid[x + 1][y + 2]) and (x + 1, y + 2) not in vis:</line-20>
<line-21> dfs(x + 1, y + 2)</line-21>
<line-22> </line-22>
<line-23></line-23>
<line-24>T = int(input())</line-24>
<line-25>for loop in range(T):</line-25>
<line-26> n, k = [ int(i) for i in input().split() ]</line-26>
<line-27> grid = list()</line-27>
<line-28> grid.append(input() + " ")</line-28>
<line-29> grid.append(input() + " ")</line-29>
<line-30> grid.append(input() + " ")</line-30>
<line-31> vis = list()</line-31>
<line-32> flag = False</line-32>
<line-33> for i in range(3):</line-33>
<line-34> if grid[i][0] == 's':</line-34>
<line-35> grid[i] = " " + grid[i][1:]</line-35>
<line-36> dfs(i, 0)</line-36>
<line-37> break</line-37>
<line-38> if flag:</line-38>
<line-39> print("YES")</line-39>
<line-41> print("NO")</line-41>
|
{"code": "<line-2> vis.append((x, y))</line-2>\n<line-40> else:</line-40>", "lines": [2, 40]}
#### 0
|
<line-1># import atexit</line-1>
<line-3># import sys</line-3>
<line-4>#</line-4>
<line-5># _INPUT_LINES = sys.stdin.read().splitlines()</line-5>
<line-6># input = iter(_INPUT_LINES).__next__</line-6>
<line-7># _OUTPUT_BUFFER = io.StringIO()</line-7>
<line-8># sys.stdout = _OUTPUT_BUFFER</line-8>
<line-9>#</line-9>
<line-10>#</line-10>
<line-11># @atexit.register</line-11>
<line-12># def write():</line-12>
<line-13># sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())</line-13>
<line-14></line-14>
<line-15>import bisect</line-15>
<line-16>from datetime import datetime</line-16>
<line-17></line-17>
<line-18></line-18>
<line-19>def main():</line-19>
<line-20> n, m = list(map(int, input().split()))</line-20>
<line-21> n -= 1</line-21>
<line-22></line-22>
<line-23> timestamps = []</line-23>
<line-24> raw = []</line-24>
<line-25> while True:</line-25>
<line-26> s = ""</line-26>
<line-27> try:</line-27>
<line-28> s = input()</line-28>
<line-29> except:</line-29>
<line-30> print(-1)</line-30>
<line-31> return</line-31>
<line-32></line-32>
<line-33> d = datetime.strptime(s[0:19], "%Y-%m-%d %H:%M:%S")</line-33>
<line-34> timestamps.append(int(d.timestamp()))</line-34>
<line-35> raw.append(s[0:19])</line-35>
<line-36> idx = bisect.bisect_left(timestamps, timestamps[-1] - n)</line-36>
<line-37> if len(timestamps) - idx == m:</line-37>
<line-38> print(raw[-1])</line-38>
<line-39> return</line-39>
<line-40></line-40>
<line-41></line-41>
<line-42>def __starting_point():</line-42>
<line-44></line-44>
<line-45>__starting_point()</line-45>
|
{"code": "<line-2># import io</line-2>\n<line-43> main()</line-43>", "lines": [2, 43]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>b = [int(x) for x in input().strip()]</line-3>
<line-4>p, q, r, s = 0, 0, 0, 0</line-4>
<line-5>for i in range(n):</line-5>
<line-6> if a[i] * 2 + b[i] == 0:</line-6>
<line-7> p += 1</line-7>
<line-8> if a[i] * 2 + b[i] == 1:</line-8>
<line-9> q += 1</line-9>
<line-10> if a[i] * 2 + b[i] == 2:</line-10>
<line-11> r += 1</line-11>
<line-12> if a[i] * 2 + b[i] == 3:</line-12>
<line-14>print(p*r + p*s + q*r)</line-14>
|
{"code": "<line-2>a = [int(x) for x in input().strip()]</line-2>\n<line-13> s += 1</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>import sys</line-1>
<line-3>sys.setrecursionlimit(10**9)</line-3>
<line-4>from collections import deque</line-4>
<line-5></line-5>
<line-6>class Node:</line-6>
<line-7> def __init__(self,depth):</line-7>
<line-8> self.depth=depth</line-8>
<line-9> self.left=None</line-9>
<line-10> self.right=None</line-10>
<line-11></line-11>
<line-12>def insert(node,s):</line-12>
<line-13> n=node</line-13>
<line-14> for i in range(len(s)):</line-14>
<line-15> t=s[i]</line-15>
<line-16> if t=='0':</line-16>
<line-17> if n.left is None:</line-17>
<line-18> n.left=Node(i+1)</line-18>
<line-19> n=n.left</line-19>
<line-20> else:</line-20>
<line-21> if n.right is None:</line-21>
<line-22> n.right=Node(i+1)</line-22>
<line-23> n=n.right</line-23>
<line-24></line-24>
<line-25>class Trie:</line-25>
<line-26> def __init__(self):</line-26>
<line-27> self.root=Node(0)</line-27>
<line-28> def insert(self,s:str):</line-28>
<line-29> insert(self.root,s)</line-29>
<line-30></line-30>
<line-31>n,l=map(int,input().split())</line-31>
<line-32>S=[input().strip() for _ in range(n)]</line-32>
<line-33>trie=Trie()</line-33>
<line-34>for s in S:</line-34>
<line-35> trie.insert(s)</line-35>
<line-36>Data=[]</line-36>
<line-37>q=deque([trie.root])</line-37>
<line-38></line-38>
<line-39>def dfs(node):</line-39>
<line-40> if node.right is None and node.left is None:</line-40>
<line-41> return</line-41>
<line-42> if node.right is None or node.left is None:</line-42>
<line-43> Data.append(l-node.depth)</line-43>
<line-44> if node.right:</line-44>
<line-45> q.append(node.right)</line-45>
<line-46> if node.left:</line-46>
<line-47> q.append(node.left)</line-47>
<line-48></line-48>
<line-49>while q:</line-49>
<line-50> dfs(q.popleft())</line-50>
<line-51>xor=0</line-51>
<line-52></line-52>
<line-53>def Grundy(n):</line-53>
<line-54> ret=1</line-54>
<line-55> while n%2==0:</line-55>
<line-56> n//=2</line-56>
<line-57> ret*=2</line-57>
<line-58> return ret</line-58>
<line-59></line-59>
<line-60>for i in Data:</line-60>
<line-62>print('Alice' if xor else 'Bob')</line-62>
|
{"code": "<line-2>input=sys.stdin.readline</line-2>\n<line-61> xor^=Grundy(i)</line-61>", "lines": [2, 61]}
#### 0
|
<line-1>class SegmentTree:</line-1>
<line-3> """initialize the segment tree with data"""</line-3>
<line-4> self._default = default</line-4>
<line-5> self._func = func</line-5>
<line-6> self._len = len(data)</line-6>
<line-7> self._size = _size = 1 << (self._len - 1).bit_length()</line-7>
<line-8></line-8>
<line-9> self.data = [default] * (2 * _size)</line-9>
<line-10> self.data[_size:_size + self._len] = data</line-10>
<line-11> for i in reversed(list(range(_size))):</line-11>
<line-12> self.data[i] = func(self.data[i + i], self.data[i + i + 1])</line-12>
<line-13></line-13>
<line-14> def __delitem__(self, idx):</line-14>
<line-15> self[idx] = self._default</line-15>
<line-16></line-16>
<line-17> def __getitem__(self, idx):</line-17>
<line-18> return self.data[idx + self._size]</line-18>
<line-19></line-19>
<line-20> def __setitem__(self, idx, value):</line-20>
<line-21> idx += self._size</line-21>
<line-22> self.data[idx] = value</line-22>
<line-23> idx >>= 1</line-23>
<line-24> while idx:</line-24>
<line-25> self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])</line-25>
<line-26> idx >>= 1</line-26>
<line-27></line-27>
<line-28> def __len__(self):</line-28>
<line-29> return self._len</line-29>
<line-30></line-30>
<line-31> def query(self, start, stop):</line-31>
<line-32> """func of data[start, stop)"""</line-32>
<line-33> start += self._size</line-33>
<line-34> stop += self._size</line-34>
<line-35></line-35>
<line-36> res_left = res_right = self._default</line-36>
<line-37> while start < stop:</line-37>
<line-38> if start & 1:</line-38>
<line-39> res_left = self._func(res_left, self.data[start])</line-39>
<line-40> start += 1</line-40>
<line-41> if stop & 1:</line-41>
<line-42> stop -= 1</line-42>
<line-43> res_right = self._func(self.data[stop], res_right)</line-43>
<line-44> start >>= 1</line-44>
<line-45> stop >>= 1</line-45>
<line-46></line-46>
<line-47> return self._func(res_left, res_right)</line-47>
<line-48></line-48>
<line-49> def __repr__(self):</line-49>
<line-50> return "SegmentTree({0})".format(self.data)</line-50>
<line-51></line-51>
<line-52></line-52>
<line-53>n = int(input())</line-53>
<line-54>s = input()</line-54>
<line-55></line-55>
<line-56>pref = []</line-56>
<line-57>curr = 0</line-57>
<line-58>for c in s:</line-58>
<line-59> if c == '1':</line-59>
<line-60> curr += 1</line-60>
<line-61> else:</line-61>
<line-62> curr = 0</line-62>
<line-63> pref.append(curr)</line-63>
<line-64></line-64>
<line-65>suff = []</line-65>
<line-66>curr = 0</line-66>
<line-67>for c in s[::-1]:</line-67>
<line-68> if c == '1':</line-68>
<line-69> curr += 1</line-69>
<line-70> else:</line-70>
<line-71> curr = 0</line-71>
<line-72> suff.append(curr)</line-72>
<line-73>suff.reverse()</line-73>
<line-74> </line-74>
<line-75></line-75>
<line-76>st = SegmentTree(suff)</line-76>
<line-77></line-77>
<line-78>out = 0</line-78>
<line-79>add = 0</line-79>
<line-80>for i in range(n):</line-80>
<line-81> if s[i] == '1':</line-81>
<line-82> lo = -1</line-82>
<line-83> hi = i - pref[i] + 1</line-83>
<line-84> while hi - lo > 1:</line-84>
<line-85> t = (lo + hi) // 2</line-85>
<line-86> if st.query(t, i - pref[i] + 1) >= pref[i]:</line-86>
<line-87> lo = t</line-87>
<line-88> else:</line-88>
<line-89> hi = t</line-89>
<line-90> add += (i - lo)</line-90>
<line-91> #print(add)</line-91>
<line-93>print(out)</line-93>
<line-94> </line-94>
|
{"code": "<line-2> def __init__(self, data, default=0, func=max):</line-2>\n<line-92> out += add</line-92>", "lines": [2, 92]}
#### 0
|
<line-1>n, k = map(int, input().split())</line-1>
<line-3>b = ['0'] * n</line-3>
<line-4>c = []</line-4>
<line-5>s = input()</line-5>
<line-6>for i in range(n):</line-6>
<line-7> if k != 0:</line-7>
<line-8> if s[i] == '(':</line-8>
<line-9> c.append(i)</line-9>
<line-10> else:</line-10>
<line-11> d = c.pop()</line-11>
<line-12> a[i] = 1</line-12>
<line-13> a[d] = 1</line-13>
<line-14> k -= 2</line-14>
<line-15>for i in range(n):</line-15>
<line-17> print(s[i], end = '')</line-17>
|
{"code": "<line-2>a = [0] * n</line-2>\n<line-16> if a[i] == 1:</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>from collections import deque</line-1>
<line-2></line-2>
<line-4> n = len(adj)</line-4>
<line-5> nn = [len(a) for a in adj]</line-5>
<line-6> q = deque()</line-6>
<line-7> for i in range(n):</line-7>
<line-8> if nn[i] < k:</line-8>
<line-9> q.append(i)</line-9>
<line-10> while q:</line-10>
<line-11> v = q.popleft()</line-11>
<line-12> for u in adj[v]:</line-12>
<line-13> nn[u] -= 1</line-13>
<line-14> if nn[u] == k-1:</line-14>
<line-15> q.append(u)</line-15>
<line-16> res = [0]*m</line-16>
<line-17> nk = len([1 for i in nn if i >= k])</line-17>
<line-18> res[-1] = nk</line-18>
<line-19> for i in range(m-1, 0, -1):</line-19>
<line-20> u1, v1 = uv[i]</line-20>
<line-21></line-21>
<line-22> if nn[u1] < k or nn[v1] < k:</line-22>
<line-23> res[i - 1] = nk</line-23>
<line-24> continue</line-24>
<line-25> if nn[u1] == k:</line-25>
<line-26> q.append(u1)</line-26>
<line-27> nn[u1] -= 1</line-27>
<line-28> if not q and nn[v1] == k:</line-28>
<line-29> q.append(v1)</line-29>
<line-30> nn[v1] -= 1</line-30>
<line-31></line-31>
<line-32> if not q:</line-32>
<line-33> nn[u1] -= 1</line-33>
<line-34> nn[v1] -= 1</line-34>
<line-35> adj[u1].remove(v1)</line-35>
<line-36> adj[v1].remove(u1)</line-36>
<line-37></line-37>
<line-38> while q:</line-38>
<line-39> v = q.popleft()</line-39>
<line-40> nk -= 1</line-40>
<line-41> for u in adj[v]:</line-41>
<line-42> nn[u] -= 1</line-42>
<line-43> if nn[u] == k - 1:</line-43>
<line-44> q.append(u)</line-44>
<line-45> res[i - 1] = nk</line-45>
<line-46> return res</line-46>
<line-47></line-47>
<line-48>n, m, k = map(int, input().split())</line-48>
<line-49>a = [set() for i in range(n)]</line-49>
<line-50>uv = []</line-50>
<line-51>for i in range(m):</line-51>
<line-52> u, v = map(int, input().split())</line-52>
<line-53> a[u - 1].add(v - 1)</line-53>
<line-54> a[v - 1].add(u - 1)</line-54>
<line-55> uv.append((u-1, v-1))</line-55>
<line-56></line-56>
<line-58>print(str(res)[1:-1].replace(' ', '').replace(',', '\n'))</line-58>
|
{"code": "<line-3>def solve(adj, m, k, uv):</line-3>\n<line-57>res = solve(a, m, k, uv)</line-57>", "lines": [3, 57]}
#### 0
|
<line-1>def sub(a, s):</line-1>
<line-3> ps = 0</line-3>
<line-4> while pa < len(a) and ps < len(s):</line-4>
<line-5> if a[pa] == s[ps]:</line-5>
<line-6> ps += 1</line-6>
<line-7> pa += 1</line-7>
<line-8> else:</line-8>
<line-9> pa += 1</line-9>
<line-10></line-10>
<line-11> return ps == len(s)</line-11>
<line-12></line-12>
<line-13>def subword(t, ord_ar, n):</line-13>
<line-14> t_copy = []</line-14>
<line-15> for i in range(len(ord_ar)):</line-15>
<line-16> if ord_ar[i] >= n:</line-16>
<line-17> t_copy.append(t[i])</line-17>
<line-18> return t_copy</line-18>
<line-19></line-19>
<line-20>def check(t, p, ord_ar, n):</line-20>
<line-21> s = subword(t, ord_ar, n)</line-21>
<line-22> return sub(s, p)</line-22>
<line-23></line-23>
<line-24>def bin_s(l, r, f):</line-24>
<line-25> while r > l + 1:</line-25>
<line-26> m = (r + l) // 2</line-26>
<line-27> if f(m):</line-27>
<line-28> l = m</line-28>
<line-29> else:</line-29>
<line-30> r = m</line-30>
<line-31> return l</line-31>
<line-32></line-32>
<line-33></line-33>
<line-34></line-34>
<line-35>def main():</line-35>
<line-36> t = input().strip()</line-36>
<line-37> p = input().strip()</line-37>
<line-38> ord_ar = [0]*len(t)</line-38>
<line-39> </line-39>
<line-40> seq = list(map(int, input().strip().split()))</line-40>
<line-41> for i,x in enumerate(seq):</line-41>
<line-42> ord_ar[x-1] = i</line-42>
<line-43></line-43>
<line-44> ans = bin_s(0, len(t), lambda n: check(t, p, ord_ar, n))</line-44>
<line-46></line-46>
<line-47>main()</line-47>
|
{"code": "<line-2> pa = 0</line-2>\n<line-45> print(ans)</line-45>", "lines": [2, 45]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-2></line-2>
<line-4>a = [int(i) for i in input().split()]</line-4>
<line-5>b = [int(i) for i in input().split()]</line-5>
<line-6></line-6>
<line-7>s = []</line-7>
<line-8>for i in range(n):</line-8>
<line-9> s.append([p[i], a[i], b[i]])</line-9>
<line-10></line-10>
<line-11>s = sorted(s)</line-11>
<line-12></line-12>
<line-13>m = int(input())</line-13>
<line-14>c = [int(i) for i in input().split()]</line-14>
<line-15></line-15>
<line-16>idx = [0]*4</line-16>
<line-17></line-17>
<line-18>ans = []</line-18>
<line-19></line-19>
<line-20>for i in range(m):</line-20>
<line-21> ci = c[i]</line-21>
<line-22> while idx[ci] < n:</line-22>
<line-23> if s[idx[ci]][1] == ci or s[idx[ci]][2] == ci:</line-23>
<line-24> s[idx[ci]][1] = 0</line-24>
<line-25> s[idx[ci]][2] = 0</line-25>
<line-26> ans.append(s[idx[ci]][0])</line-26>
<line-27> break</line-27>
<line-28> idx[ci]+=1</line-28>
<line-29> if idx[ci] == n:</line-29>
<line-31></line-31>
<line-32>print(*ans)</line-32>
|
{"code": "<line-3>p = [int(i) for i in input().split()]</line-3>\n<line-30> ans.append(-1)</line-30>", "lines": [3, 30]}
#### 0
|
<line-1>import sys </line-1>
<line-3></line-3>
<line-4>MOD = 10**9 + 7</line-4>
<line-5>t = int(input())</line-5>
<line-6></line-6>
<line-7>for _ in range(t):</line-7>
<line-8> r, c = list(map(int, input().split()))</line-8>
<line-9> s = [list(input()) for i in range(r)]</line-9>
<line-10> cnt_a = 0</line-10>
<line-11> flag_kado = False</line-11>
<line-12> flag_hen = False</line-12>
<line-13> flag_hen2 = False</line-13>
<line-14> if s[0][0] == "A" or s[0][c-1] == "A" or s[r-1][0] == "A" or s[r-1][c-1] == "A":</line-14>
<line-15> flag_kado = True</line-15>
<line-16> </line-16>
<line-17> for i in range(r):</line-17>
<line-18> tmp = 0</line-18>
<line-19> for j in range(c):</line-19>
<line-20> if s[i][j] == "A":</line-20>
<line-21> if i == 0 or j == 0 or i == r-1 or j == c-1:</line-21>
<line-22> flag_hen2 = True</line-22>
<line-23> tmp += 1</line-23>
<line-24> cnt_a += tmp</line-24>
<line-25> if tmp == c and (i == 0 or i == r-1):</line-25>
<line-26> flag_hen = True</line-26>
<line-27> elif tmp == c:</line-27>
<line-28> flag_kado = True</line-28>
<line-29></line-29>
<line-30> for i in range(c):</line-30>
<line-31> tmp = 0</line-31>
<line-32> for j in range(r):</line-32>
<line-33> if s[j][i] == "A":</line-33>
<line-34> tmp += 1</line-34>
<line-35> if tmp == r and (i == 0 or i == c-1):</line-35>
<line-36> flag_hen = True</line-36>
<line-37> elif tmp == r:</line-37>
<line-38> flag_kado = True</line-38>
<line-39> </line-39>
<line-40></line-40>
<line-41> if cnt_a == c*r:</line-41>
<line-42> print(0)</line-42>
<line-43> elif flag_hen:</line-43>
<line-44> print(1)</line-44>
<line-45> elif flag_kado:</line-45>
<line-46> print(2)</line-46>
<line-47> elif flag_hen2:</line-47>
<line-48> print(3)</line-48>
<line-49> elif cnt_a != 0:</line-49>
<line-50> print(4)</line-50>
<line-52> print("MORTAL")</line-52>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-51> else:</line-51>", "lines": [2, 51]}
#### 0
|
<line-1>"""</line-1>
<line-3></line-3>
<line-4>Author : chaotic_iak</line-4>
<line-5>Language: Python 3.5.2</line-5>
<line-6>"""</line-6>
<line-7></line-7>
<line-8>################################################### SOLUTION</line-8>
<line-9></line-9>
<line-10>def main():</line-10>
<line-11> n, = read()</line-11>
<line-12> curr = 2</line-12>
<line-13> for lv in range(1, n+1):</line-13>
<line-14> tgt = (lv*(lv+1))**2</line-14>
<line-15> print((tgt - curr) // lv)</line-15>
<line-16> curr = lv*(lv+1)</line-16>
<line-17> return</line-17>
<line-18></line-18>
<line-19>#################################################### HELPERS</line-19>
<line-20></line-20>
<line-21>def read(typ=int):</line-21>
<line-22> # None: String, non-split</line-22>
<line-23> # Not None: Split</line-23>
<line-24> input_line = input().strip()</line-24>
<line-25> if typ is None:</line-25>
<line-26> return input_line</line-26>
<line-27> return list(map(typ, input_line.split()))</line-27>
<line-28></line-28>
<line-29>def write(s="\n"):</line-29>
<line-30> if s is None: s = ""</line-30>
<line-31> if isinstance(s, list): s = " ".join(map(str, s))</line-31>
<line-32> s = str(s)</line-32>
<line-34></line-34>
<line-35>write(main())</line-35>
|
{"code": "<line-2>Codeforces Round 372 Div 1 Problem A</line-2>\n<line-33> print(s, end=\"\")</line-33>", "lines": [2, 33]}
#### 0
|
<line-1></line-1>
<line-2>import os</line-2>
<line-4>from io import BytesIO, IOBase</line-4>
<line-5></line-5>
<line-6></line-6>
<line-7>def main():</line-7>
<line-8> pass</line-8>
<line-9></line-9>
<line-10></line-10>
<line-11># region fastio</line-11>
<line-12></line-12>
<line-13>BUFSIZE = 8192</line-13>
<line-14></line-14>
<line-15></line-15>
<line-16>class FastIO(IOBase):</line-16>
<line-17> newlines = 0</line-17>
<line-18></line-18>
<line-19> def __init__(self, file):</line-19>
<line-20> self._fd = file.fileno()</line-20>
<line-21> self.buffer = BytesIO()</line-21>
<line-22> self.writable = "x" in file.mode or "r" not in file.mode</line-22>
<line-23> self.write = self.buffer.write if self.writable else None</line-23>
<line-24></line-24>
<line-25> def read(self):</line-25>
<line-26> while True:</line-26>
<line-27> b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))</line-27>
<line-28> if not b:</line-28>
<line-29> break</line-29>
<line-30> ptr = self.buffer.tell()</line-30>
<line-31> self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)</line-31>
<line-32> self.newlines = 0</line-32>
<line-33> return self.buffer.read()</line-33>
<line-34></line-34>
<line-35> def readline(self):</line-35>
<line-36> while self.newlines == 0:</line-36>
<line-37> b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))</line-37>
<line-38> self.newlines = b.count(b"\n") + (not b)</line-38>
<line-39> ptr = self.buffer.tell()</line-39>
<line-40> self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)</line-40>
<line-41> self.newlines -= 1</line-41>
<line-42> return self.buffer.readline()</line-42>
<line-43></line-43>
<line-44> def flush(self):</line-44>
<line-45> if self.writable:</line-45>
<line-46> os.write(self._fd, self.buffer.getvalue())</line-46>
<line-47> self.buffer.truncate(0), self.buffer.seek(0)</line-47>
<line-48></line-48>
<line-49></line-49>
<line-50>class IOWrapper(IOBase):</line-50>
<line-51> def __init__(self, file):</line-51>
<line-52> self.buffer = FastIO(file)</line-52>
<line-53> self.flush = self.buffer.flush</line-53>
<line-54> self.writable = self.buffer.writable</line-54>
<line-55> self.write = lambda s: self.buffer.write(s.encode("ascii"))</line-55>
<line-56> self.read = lambda: self.buffer.read().decode("ascii")</line-56>
<line-57> self.readline = lambda: self.buffer.readline().decode("ascii")</line-57>
<line-58></line-58>
<line-59></line-59>
<line-60>sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)</line-60>
<line-61>input = lambda: sys.stdin.readline().rstrip("\r\n")</line-61>
<line-62></line-62>
<line-63>MOD = 10 ** 9 + 7</line-63>
<line-64></line-64>
<line-65>memo = dict()</line-65>
<line-66>def solve(m):</line-66>
<line-67> if m not in memo:</line-67>
<line-68> if m < 0:</line-68>
<line-69> memo[m] = 0</line-69>
<line-70> if m == 0:</line-70>
<line-71> memo[m] = 1</line-71>
<line-72> half = m//2</line-72>
<line-73> memo[m] = (solve(half) + solve(half - 1) + solve(half - 2) + solve(half - 3)) % MOD</line-73>
<line-74> return memo[m]</line-74>
<line-75> </line-75>
<line-76></line-76>
<line-77>t = int(input())</line-77>
<line-78>out = []</line-78>
<line-79>for m in map(int, input().split()):</line-79>
<line-80> #out.append(solve(m))</line-80>
<line-81> v = m//2</line-81>
<line-82> u = v//2</line-82>
<line-83> w = (v-u)</line-83>
<line-85>print('\n'.join(map(str,out)))</line-85>
|
{"code": "<line-3>import sys</line-3>\n<line-84> out.append((u*w+u+w+1)%MOD)</line-84>", "lines": [3, 84]}
#### 0
|
<line-1>import sys</line-1>
<line-3>def solve():</line-3>
<line-4> sys.setrecursionlimit(10**6)</line-4>
<line-5> readline = sys.stdin.readline</line-5>
<line-6> writelines = sys.stdout.writelines</line-6>
<line-7> N = int(readline())</line-7>
<line-8> G = [[] for i in range(N)]</line-8>
<line-9> for i in range(N-1):</line-9>
<line-10> u, v = map(int, readline().split())</line-10>
<line-11> G[u-1].append(v-1)</line-11>
<line-12> G[v-1].append(u-1)</line-12>
<line-13></line-13>
<line-14> # Euler tour technique</line-14>
<line-15> S = []</line-15>
<line-16> FS = [0]*N; LS = [0]*N</line-16>
<line-17> depth = [0]*N</line-17>
<line-18> stk = [-1, 0]</line-18>
<line-19> it = [0]*N</line-19>
<line-20> while len(stk) > 1:</line-20>
<line-21> v = stk[-1]</line-21>
<line-22> i = it[v]</line-22>
<line-23> if i == 0:</line-23>
<line-24> FS[v] = len(S)</line-24>
<line-25> depth[v] = len(stk)</line-25>
<line-26> if i < len(G[v]) and G[v][i] == stk[-2]:</line-26>
<line-27> it[v] += 1</line-27>
<line-28> i += 1</line-28>
<line-29> if i == len(G[v]):</line-29>
<line-30> LS[v] = len(S)</line-30>
<line-31> stk.pop()</line-31>
<line-32> else:</line-32>
<line-33> stk.append(G[v][i])</line-33>
<line-34> it[v] += 1</line-34>
<line-35> S.append(v)</line-35>
<line-36></line-36>
<line-37> L = len(S)</line-37>
<line-38> lg = [0]*(L+1)</line-38>
<line-39> # Sparse Table</line-39>
<line-40> for i in range(2, L+1):</line-40>
<line-41> lg[i] = lg[i >> 1] + 1</line-41>
<line-42> st = [[L]*(L - (1 << i) + 1) for i in range(lg[L]+1)]</line-42>
<line-43> st[0][:] = S</line-43>
<line-44> b = 1</line-44>
<line-45> for i in range(lg[L]):</line-45>
<line-46> st0 = st[i]</line-46>
<line-47> st1 = st[i+1]</line-47>
<line-48> for j in range(L - (b<<1) + 1):</line-48>
<line-49> st1[j] = (st0[j] if depth[st0[j]] <= depth[st0[j+b]] else st0[j+b])</line-49>
<line-50> b <<= 1</line-50>
<line-51></line-51>
<line-52> INF = 10**18</line-52>
<line-53> ans = []</line-53>
<line-54> Q = int(readline())</line-54>
<line-55> G0 = [[]]*N</line-55>
<line-56> P = [0]*N</line-56>
<line-57> deg = [0]*N</line-57>
<line-58> KS = [0]*N</line-58>
<line-59> A = [0]*N</line-59>
<line-60> B = [0]*N</line-60>
<line-61> for t in range(Q):</line-61>
<line-62> k, *vs = map(int, readline().split())</line-62>
<line-63> for i in range(k):</line-63>
<line-64> vs[i] -= 1</line-64>
<line-65> KS[vs[i]] = 1</line-65>
<line-66> vs.sort(key=FS.__getitem__)</line-66>
<line-67> for i in range(k-1):</line-67>
<line-68> x = FS[vs[i]]; y = FS[vs[i+1]]</line-68>
<line-69> l = lg[y - x + 1]</line-69>
<line-70> w = st[l][x] if depth[st[l][x]] <= depth[st[l][y - (1 << l) + 1]] else st[l][y - (1 << l) + 1]</line-70>
<line-71> vs.append(w)</line-71>
<line-72> vs.sort(key=FS.__getitem__)</line-72>
<line-73> stk = []</line-73>
<line-74> prv = -1</line-74>
<line-75> for v in vs:</line-75>
<line-76> if v == prv:</line-76>
<line-77> continue</line-77>
<line-78> while stk and LS[stk[-1]] < FS[v]:</line-78>
<line-79> stk.pop()</line-79>
<line-80> if stk:</line-80>
<line-81> G0[stk[-1]].append(v)</line-81>
<line-82> G0[v] = []</line-82>
<line-83> it[v] = 0</line-83>
<line-84> stk.append(v)</line-84>
<line-85> prv = v</line-85>
<line-86> que = deque()</line-86>
<line-87> prv = -1</line-87>
<line-88> P[vs[0]] = -1</line-88>
<line-89> for v in vs:</line-89>
<line-90> if v == prv:</line-90>
<line-91> continue</line-91>
<line-92> for w in G0[v]:</line-92>
<line-93> P[w] = v</line-93>
<line-94> deg[v] = len(G0[v])</line-94>
<line-95> if deg[v] == 0:</line-95>
<line-96> que.append(v)</line-96>
<line-97> prv = v</line-97>
<line-98></line-98>
<line-99> while que:</line-99>
<line-100> v = que.popleft()</line-100>
<line-101> if KS[v]:</line-101>
<line-102> a = 0</line-102>
<line-103> for w in G0[v]:</line-103>
<line-104> ra = A[w]; rb = B[w]</line-104>
<line-105> if depth[v]+1 < depth[w]:</line-105>
<line-106> a += min(ra, rb+1)</line-106>
<line-107> else:</line-107>
<line-108> a += ra</line-108>
<line-109> A[v] = INF</line-109>
<line-110> B[v] = a</line-110>
<line-111> else:</line-111>
<line-112> a = 0; b = c = INF</line-112>
<line-113> for w in G0[v]:</line-113>
<line-114> ra = A[w]; rb = B[w]</line-114>
<line-115> a, b, c = a + ra, min(a + rb, b + ra), min(b + rb, c + min(ra, rb))</line-115>
<line-116> A[v] = min(a, b+1, c+1)</line-116>
<line-117> B[v] = b</line-117>
<line-118></line-118>
<line-119> p = P[v]</line-119>
<line-120> if p != -1:</line-120>
<line-121> deg[p] -= 1</line-121>
<line-122> if deg[p] == 0:</line-122>
<line-123> que.append(p)</line-123>
<line-124> v = min(A[vs[0]], B[vs[0]])</line-124>
<line-125> if v >= INF:</line-125>
<line-126> ans.append("-1\n")</line-126>
<line-127> else:</line-127>
<line-128> ans.append("%d\n" % v)</line-128>
<line-129> for v in vs:</line-129>
<line-130> KS[v] = 0</line-130>
<line-131></line-131>
<line-133>solve()</line-133>
|
{"code": "<line-2>from collections import deque</line-2>\n<line-132> writelines(ans)</line-132>", "lines": [2, 132]}
#### 0
|
<line-1>def main():</line-1>
<line-3> dumi=0</line-3>
<line-4> for child in graph[vert]:</line-4>
<line-5> if child!=pard:</line-5>
<line-6> if len(graph[child])==1:</line-6>
<line-7> memo[child]=0</line-7>
<line-8> else:</line-8>
<line-9> memo[child]=countchildren(graph,child,memo,vert)[0]</line-9>
<line-10> dumi+=memo[child]+1</line-10>
<line-11> return((dumi,memo))</line-11>
<line-12> n=int(input())</line-12>
<line-13> neigh=[]</line-13>
<line-14> for i in range(n):</line-14>
<line-15> neigh.append([])</line-15>
<line-16> for i in range(n-1):</line-16>
<line-17> a,b=map(int,input().split())</line-17>
<line-18> neigh[a-1].append(b-1)</line-18>
<line-19> neigh[b-1].append(a-1)</line-19>
<line-20> same=1</line-20>
<line-21> layer=[0]</line-21>
<line-22> pars=[None]</line-22>
<line-23> j=0</line-23>
<line-24> while layer!=[]:</line-24>
<line-25> j+=1</line-25>
<line-26> newlayer=[]</line-26>
<line-27> newpars=[]</line-27>
<line-28> for i in range(len(layer)):</line-28>
<line-29> for vert in neigh[layer[i]]:</line-29>
<line-30> if vert!=pars[i]:</line-30>
<line-31> newlayer.append(vert)</line-31>
<line-32> newpars.append(layer[i])</line-32>
<line-33> layer=newlayer</line-33>
<line-34> pars=newpars</line-34>
<line-35> if j%2==0:</line-35>
<line-36> same+=len(layer)</line-36>
<line-37> bipartite=same*(n-same)</line-37>
<line-38> info=countchildren(neigh,0,[None]*n)[1]</line-38>
<line-39> dist=0</line-39>
<line-40> for guy in info:</line-40>
<line-41> if guy!=None:</line-41>
<line-42> dist+=(guy+1)*(n-guy-1)</line-42>
<line-43> print((dist+bipartite)//2)</line-43>
<line-44></line-44>
<line-45>import sys</line-45>
<line-46>import threading</line-46>
<line-47>sys.setrecursionlimit(2097152)</line-47>
<line-48>threading.stack_size(134217728)</line-48>
<line-49>main_thread=threading.Thread(target=main)</line-49>
<line-51>main_thread.join()</line-51>
|
{"code": "<line-2> def countchildren(graph,vert,memo,pard=None):</line-2>\n<line-50>main_thread.start()</line-50>", "lines": [2, 50]}
#### 0
|
<line-1>import sys</line-1>
<line-3>class UF():</line-3>
<line-4> def __init__(self, num):</line-4>
<line-5> self.par = [-1]*num</line-5>
<line-6> self.weight = [0]*num</line-6>
<line-7> def find(self, x):</line-7>
<line-8> if self.par[x] < 0:</line-8>
<line-9> return x</line-9>
<line-10> else:</line-10>
<line-11> stack = []</line-11>
<line-12> while self.par[x] >= 0:</line-12>
<line-13> stack.append(x)</line-13>
<line-14> x = self.par[x]</line-14>
<line-15> for xi in stack:</line-15>
<line-16> self.par[xi] = x</line-16>
<line-17> return x</line-17>
<line-18> </line-18>
<line-19> def union(self, x, y):</line-19>
<line-20> rx = self.find(x)</line-20>
<line-21> ry = self.find(y)</line-21>
<line-22> if rx != ry:</line-22>
<line-23> if self.par[rx] > self.par[ry]:</line-23>
<line-24> rx, ry = ry, rx</line-24>
<line-25> self.par[rx] += self.par[ry]</line-25>
<line-26> self.par[ry] = rx</line-26>
<line-27> self.weight[rx] += self.weight[ry]</line-27>
<line-28> return rx</line-28>
<line-29></line-29>
<line-30>N, K = list(map(int, readline().split()))</line-30>
<line-31>S = list(map(int, readline().strip()))</line-31>
<line-32></line-32>
<line-33>A = [[] for _ in range(N)]</line-33>
<line-34></line-34>
<line-35>for k in range(K):</line-35>
<line-36> BL = int(readline())</line-36>
<line-37> B = list(map(int, readline().split()))</line-37>
<line-38> for b in B:</line-38>
<line-39> A[b-1].append(k)</line-39>
<line-40></line-40>
<line-41>cnt = 0</line-41>
<line-42>T = UF(2*K)</line-42>
<line-43>used = set()</line-43>
<line-44>Ans = [None]*N</line-44>
<line-45>inf = 10**9+7</line-45>
<line-46>for i in range(N):</line-46>
<line-47> if not len(A[i]):</line-47>
<line-48> Ans[i] = cnt</line-48>
<line-49> continue</line-49>
<line-50> kk = 0</line-50>
<line-51> if len(A[i]) == 2: </line-51>
<line-52> x, y = A[i]</line-52>
<line-53> if S[i]:</line-53>
<line-54> rx = T.find(x)</line-54>
<line-55> ry = T.find(y)</line-55>
<line-56> if rx != ry:</line-56>
<line-57> rx2 = T.find(x+K)</line-57>
<line-58> ry2 = T.find(y+K)</line-58>
<line-59> sp = min(T.weight[rx], T.weight[rx2]) + min(T.weight[ry], T.weight[ry2])</line-59>
<line-60> if x not in used:</line-60>
<line-61> used.add(x)</line-61>
<line-62> T.weight[rx] += 1</line-62>
<line-63> if y not in used:</line-63>
<line-64> used.add(y)</line-64>
<line-65> T.weight[ry] += 1</line-65>
<line-66> rz = T.union(rx, ry)</line-66>
<line-67> rz2 = T.union(rx2, ry2)</line-67>
<line-68> sf = min(T.weight[rz], T.weight[rz2])</line-68>
<line-69> kk = sf - sp</line-69>
<line-70> else:</line-70>
<line-71> rx = T.find(x)</line-71>
<line-72> ry2 = T.find(y+K)</line-72>
<line-73> sp = 0</line-73>
<line-74> if rx != ry2:</line-74>
<line-75> ry = T.find(y)</line-75>
<line-76> rx2 = T.find(x+K)</line-76>
<line-77> sp = min(T.weight[rx], T.weight[rx2]) + min(T.weight[ry], T.weight[ry2])</line-77>
<line-78> if x not in used:</line-78>
<line-79> used.add(x)</line-79>
<line-80> T.weight[rx] += 1</line-80>
<line-81> if y not in used:</line-81>
<line-82> used.add(y)</line-82>
<line-83> T.weight[ry] += 1</line-83>
<line-84> rz = T.union(rx, ry2)</line-84>
<line-85> rz2 = T.union(rx2, ry)</line-85>
<line-86> sf = min(T.weight[rz], T.weight[rz2])</line-86>
<line-87> kk = sf - sp</line-87>
<line-88> else:</line-88>
<line-89> if S[i]:</line-89>
<line-90> x = A[i][0]</line-90>
<line-91> rx = T.find(x)</line-91>
<line-92> rx2 = T.find(x+K)</line-92>
<line-93> sp = min(T.weight[rx], T.weight[rx2])</line-93>
<line-94> T.weight[rx] += inf</line-94>
<line-95> sf = min(T.weight[rx], T.weight[rx2])</line-95>
<line-96> kk = sf - sp</line-96>
<line-97> else:</line-97>
<line-98> x = A[i][0]</line-98>
<line-99> rx = T.find(x)</line-99>
<line-100> rx2 = T.find(x+K)</line-100>
<line-101> sp = min(T.weight[rx], T.weight[rx2])</line-101>
<line-102> T.weight[rx2] += inf</line-102>
<line-103> if x not in used:</line-103>
<line-104> used.add(x)</line-104>
<line-105> T.weight[rx] += 1</line-105>
<line-106> sf = min(T.weight[rx], T.weight[rx2])</line-106>
<line-107> kk = sf-sp</line-107>
<line-108> Ans[i] = cnt + kk</line-108>
<line-110>print('\n'.join(map(str, Ans)))</line-110>
<line-111> </line-111>
|
{"code": "<line-2>readline = sys.stdin.readline</line-2>\n<line-109> cnt = Ans[i] </line-109>", "lines": [2, 109]}
#### 0
|
<line-1>import sys</line-1>
<line-3>input = reader.__next__</line-3>
<line-4></line-4>
<line-5>class Binary_Indexed_Tree():</line-5>
<line-6> def __init__(self, n):</line-6>
<line-7> self.n = n</line-7>
<line-8> self.data = [0]*(n+1)</line-8>
<line-9></line-9>
<line-10> def add(self, i, x):</line-10>
<line-11> while i <= self.n:</line-11>
<line-12> self.data[i] += x</line-12>
<line-13> i += i & -i</line-13>
<line-14></line-14>
<line-15> def get(self, i):</line-15>
<line-16> return self.sum_range(i, i)</line-16>
<line-17></line-17>
<line-18> def sum(self, i):</line-18>
<line-19> ret = 0</line-19>
<line-20> while i:</line-20>
<line-21> ret += self.data[i]</line-21>
<line-22> i &= i-1</line-22>
<line-23> return ret</line-23>
<line-24></line-24>
<line-25> def sum_range(self, l, r):</line-25>
<line-26> return self.sum(r)-self.sum(l-1)</line-26>
<line-27></line-27>
<line-28> def lower_bound(self, w):</line-28>
<line-29> if w<=0:</line-29>
<line-30> return 0</line-30>
<line-31> i = 0</line-31>
<line-32> k = 1<<(self.n.bit_length())</line-32>
<line-33> while k:</line-33>
<line-34> if i+k <= self.n and self.data[i+k] < w:</line-34>
<line-35> w -= self.data[i+k]</line-35>
<line-36> i += k</line-36>
<line-37> k >>= 1</line-37>
<line-38> return i+1</line-38>
<line-39></line-39>
<line-40>n = int(input())</line-40>
<line-41>a = list(map(int, input().split()))</line-41>
<line-42>d = {j:i for i,j in enumerate(a)}</line-42>
<line-43>BIT1 = Binary_Indexed_Tree(n)</line-43>
<line-44>BIT2 = Binary_Indexed_Tree(n)</line-44>
<line-45>BIT3 = Binary_Indexed_Tree(n)</line-45>
<line-46></line-46>
<line-47>tentou = 0</line-47>
<line-48>ans = []</line-48>
<line-49>for i in range(n):</line-49>
<line-50> tmp = 0</line-50>
<line-51> p = d[i+1]</line-51>
<line-52> inv_p = n-p</line-52>
<line-53> tentou += BIT1.sum(inv_p)</line-53>
<line-54> BIT1.add(inv_p, 1)</line-54>
<line-55></line-55>
<line-56> BIT2.add(p+1, 1)</line-56>
<line-57> BIT3.add(p+1, p+1)</line-57>
<line-58> m = i//2+1</line-58>
<line-59> mean = BIT2.lower_bound(i//2+1)</line-59>
<line-60> tmp = 0</line-60>
<line-61> if i%2 == 0:</line-61>
<line-62> tmp -= m*(m-1)</line-62>
<line-63> else:</line-63>
<line-64> tmp -= m*m</line-64>
<line-65> tmp += tentou</line-65>
<line-66> left = BIT3.sum_range(1, mean)</line-66>
<line-67> right = BIT3.sum_range(mean, n)</line-67>
<line-68> if i%2 == 0:</line-68>
<line-69> left = mean*m - left</line-69>
<line-70> right = right - mean*m</line-70>
<line-71> else:</line-71>
<line-72> left = mean*m - left</line-72>
<line-73> right = right - mean*(m+1)</line-73>
<line-74> tmp += left + right</line-74>
<line-76>print(*ans)</line-76>
<line-77></line-77>
|
{"code": "<line-2>reader = (s.rstrip() for s in sys.stdin)</line-2>\n<line-75> ans.append(tmp)</line-75>", "lines": [2, 75]}
#### 0
|
<line-1>def popcount(n):</line-1>
<line-3> while n > 0:</line-3>
<line-4> res += n & 1</line-4>
<line-5> n >>= 2</line-5>
<line-6></line-6>
<line-7>def A(l, r):</line-7>
<line-8> r += 1</line-8>
<line-9> t = 1 << 64</line-9>
<line-10> while t & (l ^ r) == 0:</line-10>
<line-11> t >>= 1</line-11>
<line-12> res = l | (t - 1)</line-12>
<line-13> #print(t, res)</line-13>
<line-14> return res</line-14>
<line-15></line-15>
<line-16>def __starting_point():</line-16>
<line-17> """assert(A(1, 2) == 1)</line-17>
<line-18> assert(A(2, 4) == 3)</line-18>
<line-19> assert(A(1, 10) == 7)</line-19>
<line-20> assert(A(13, 13) == 13)</line-20>
<line-21> assert(A(1, 7) == 7)"""</line-21>
<line-22></line-22>
<line-23> n = int(input())</line-23>
<line-24> for _ in range(n):</line-24>
<line-25> l, r = list(map(int, input().split()))</line-25>
<line-26> res = A(l, r)</line-26>
<line-28></line-28>
<line-29>__starting_point()</line-29>
|
{"code": "<line-2>\tres = 0</line-2>\n<line-27>\t\tprint(res)</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>def mat(shape, inital_val=None):</line-1>
<line-3> return [mat(shape[1:], inital_val) for _ in range(shape[0])] </line-3>
<line-4> else:</line-4>
<line-5> return [inital_val] * shape[0]</line-5>
<line-6> </line-6>
<line-7>def main():</line-7>
<line-8> n, m = [int(x) for x in input().split()]</line-8>
<line-9> graph = [{} for _ in range(n)]</line-9>
<line-10> for _ in range(m):</line-10>
<line-11> v, u, c = input().split()</line-11>
<line-12> graph[int(v) - 1][int(u) - 1] = c</line-12>
<line-13> </line-13>
<line-14> winner_table = mat([n, n, 26])</line-14>
<line-15> </line-15>
<line-16> def get_winner(u, v, char_to_beat):</line-16>
<line-17> """</line-17>
<line-18> Args:</line-18>
<line-19> u: The position of current turn's player. </line-19>
<line-20> v: The position of next turn's player.</line-20>
<line-21> char_to_beat: The character played in the previous round.</line-21>
<line-22> Returns:</line-22>
<line-23> 'A' if current turn's player wins, 'B' otherwise.</line-23>
<line-24> """</line-24>
<line-25> char_idx = ord(char_to_beat) - ord('a')</line-25>
<line-26> if not winner_table[u][v][char_idx]:</line-26>
<line-27> winner = 'B'</line-27>
<line-28> for w, c in list(graph[u].items()):</line-28>
<line-29> if c >= char_to_beat and get_winner(v, w, c) == 'B':</line-29>
<line-30> winner = 'A'</line-30>
<line-31> break</line-31>
<line-32> winner_table[u][v][char_idx] = winner</line-32>
<line-33> return winner_table[u][v][char_idx]</line-33>
<line-34> </line-34>
<line-35> for i in range(n):</line-35>
<line-36> print(''.join(get_winner(i, j, 'a') for j in range(n)))</line-36>
<line-37> </line-37>
<line-38></line-38>
<line-39>def __starting_point():</line-39>
<line-41></line-41>
<line-42>__starting_point()</line-42>
|
{"code": "<line-2> if len(shape) > 1:</line-2>\n<line-40> main()</line-40>", "lines": [2, 40]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>r[1] = [0]</line-3>
<line-4>for i in range(n - 1):</line-4>
<line-5> a, b = map(int, input().split())</line-5>
<line-6> r[a].append(b)</line-6>
<line-7> r[b].append(a)</line-7>
<line-8>t = list(map(int, input().split()))</line-8>
<line-9>u, v = [0] * (n + 1), [0] * (n + 1)</line-9>
<line-10>for i, j in enumerate(t, 1):</line-10>
<line-11> if j < 0: u[i] = - j</line-11>
<line-12> else: v[i] = j</line-12>
<line-13>t, p = [1], [0] * (n + 1)</line-13>
<line-14>while t:</line-14>
<line-15> a = t.pop()</line-15>
<line-16> for b in r[a]:</line-16>
<line-17> if p[b]: continue</line-17>
<line-18> p[b] = a</line-18>
<line-19> t.append(b)</line-19>
<line-20>k = [len(t) for t in r]</line-20>
<line-21>t = [a for a in range(2, n + 1) if k[a] == 1]</line-21>
<line-22>x, y = [0] * (n + 1), [0] * (n + 1)</line-22>
<line-23>while t:</line-23>
<line-24> a = t.pop()</line-24>
<line-25> b = p[a]</line-25>
<line-26> x[b] = max(x[b], u[a])</line-26>
<line-27> y[b] = max(y[b], v[a])</line-27>
<line-28> k[b] -= 1</line-28>
<line-29> if k[b] == 1:</line-29>
<line-30> t.append(b)</line-30>
<line-31> if u[b] > 0:</line-31>
<line-32> if x[b] - y[b] > u[b]:</line-32>
<line-33> u[b], v[b] = x[b], x[b] - u[b]</line-33>
<line-34> else: u[b], v[b] = y[b] + u[b], y[b]</line-34>
<line-35> else:</line-35>
<line-36> if y[b] - x[b] > v[b]:</line-36>
<line-37> u[b], v[b] = y[b] - v[b], y[b]</line-37>
<line-39>print(u[1] + v[1])</line-39>
|
{"code": "<line-2>r = [[] for i in range(n + 1)]</line-2>\n<line-38> else: u[b], v[b] = x[b], x[b] + v[b]</line-38>", "lines": [2, 38]}
#### 0
|
<line-1>MOD=10**9+7</line-1>
<line-3>A=list(map(int, input().split()))</line-3>
<line-4>B=list(map(int, input().split()))</line-4>
<line-5>P=[[1] for _ in range(401)]</line-5>
<line-6>for _ in range(1,401):</line-6>
<line-7> for i in range(1,401):</line-7>
<line-8> P[i].append(P[i][-1]*i%MOD)</line-8>
<line-9>R=[[] for _ in range(N)]</line-9>
<line-10>for i,AB in enumerate(zip(A, B)):</line-10>
<line-11> AA,BB=AB</line-11>
<line-12> for a in range(401):</line-12>
<line-13> tmp=0</line-13>
<line-14> for x in range(AA,BB+1):</line-14>
<line-15> tmp+=P[x][a]</line-15>
<line-16> tmp%=MOD</line-16>
<line-17> R[i].append(tmp)</line-17>
<line-18>dp=[[0]*(C+1) for _ in range(N+1)]</line-18>
<line-19>dp[0][0]=1</line-19>
<line-20>for n in range(1,N+1):</line-20>
<line-21> for k in range(C+1):</line-21>
<line-22> for l in range(k+1):</line-22>
<line-23> dp[n][k]+=dp[n-1][k-l]*R[n-1][l]</line-23>
<line-25>print(dp[N][C])</line-25>
|
{"code": "<line-2>N,C=map(int, input().split())</line-2>\n<line-24> dp[n][k]%=MOD</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>MOD = 10**9 + 7</line-4>
<line-5></line-5>
<line-6>N = int(input())</line-6>
<line-7>ball = (tuple(int(x) for x in row.split()) for row in sys.stdin.readlines())</line-7>
<line-8></line-8>
<line-9># x座標を1,2,...,N</line-9>
<line-10># y座標をN+1,N+2,...,N+N</line-10>
<line-11></line-11>
<line-12>graph = [set() for _ in range(N+N+1)]</line-12>
<line-13>for x,y in ball:</line-13>
<line-14> graph[x].add(y+N)</line-14>
<line-15> graph[y+N].add(x)</line-15>
<line-16></line-16>
<line-17>visited = [False] * (N+N+1)</line-17>
<line-18>components = []</line-18>
<line-19>for x in range(1,N+N+1):</line-19>
<line-20> if visited[x]:</line-20>
<line-21> continue</line-21>
<line-22> V = set([x])</line-22>
<line-23> E = []</line-23>
<line-24> q = [x]</line-24>
<line-25> visited[x] = True</line-25>
<line-26> while q:</line-26>
<line-27> y = q.pop()</line-27>
<line-28> for z in graph[y]:</line-28>
<line-29> if y < z:</line-29>
<line-30> E.append((y,z))</line-30>
<line-31> if visited[z]:</line-31>
<line-32> continue</line-32>
<line-33> V.add(z)</line-33>
<line-34> visited[z] = True</line-34>
<line-35> q.append(z)</line-35>
<line-36> components.append((V,E))</line-36>
<line-37></line-37>
<line-38>def make_get_pattern(V):</line-38>
<line-39> deg1 = [x for x in V if len(graph[x]) == 1]</line-39>
<line-40> get = {}</line-40>
<line-41> while deg1:</line-41>
<line-42> x = deg1.pop()</line-42>
<line-43> if not graph[x]:</line-43>
<line-44> continue</line-44>
<line-45> y = graph[x].pop()</line-45>
<line-46> se = graph[y]; se.remove(x)</line-46>
<line-47> if len(se) == 1: deg1.append(y)</line-47>
<line-48> if x < y:</line-48>
<line-49> get[(x,y)] = 0</line-49>
<line-50> else:</line-50>
<line-51> get[(y,x)] = 1</line-51>
<line-52> for x in V:</line-52>
<line-53> if graph[x]:</line-53>
<line-54> y = graph[x].pop()</line-54>
<line-55> break</line-55>
<line-56> # 残りはサイクル</line-56>
<line-57> graph[y].remove(x)</line-57>
<line-58> if x > y: x,y = y,x</line-58>
<line-59> get[(x,y)] = 2</line-59>
<line-60> while graph[x]:</line-60>
<line-61> y = graph[x].pop()</line-61>
<line-62> graph[y].remove(x)</line-62>
<line-63> if x < y:</line-63>
<line-64> get[(x,y)] = 3</line-64>
<line-65> else:</line-65>
<line-66> get[(y,x)] = 2</line-66>
<line-67> x = y</line-67>
<line-68> return get</line-68>
<line-69></line-69>
<line-70>def F(V,E):</line-70>
<line-71> # V is connected</line-71>
<line-72> if len(E) != len(V):</line-72>
<line-73> return 0</line-73>
<line-74> ret = 0</line-74>
<line-75> E.sort()</line-75>
<line-76> get = make_get_pattern(V)</line-76>
<line-77> den1,den2 = 1,1</line-77>
<line-78> dp1 = {x:0 for x in V}</line-78>
<line-79> dp2 = {x:0 for x in V}</line-79>
<line-80> for x,y in E:</line-80>
<line-81> if get[(x,y)] == 0:</line-81>
<line-82> k1 = dp1[x] + 1; k2 = dp2[x] + 1</line-82>
<line-83> elif get[(x,y)] == 1:</line-83>
<line-84> k1 = dp1[y] + 1; k2 = dp2[y] + 1</line-84>
<line-85> elif get[(x,y)] == 2:</line-85>
<line-86> k1 = dp1[x] + 1; k2 = dp2[y] + 1</line-86>
<line-87> else:</line-87>
<line-88> k1 = dp1[y] + 1; k2 = dp2[x] + 1</line-88>
<line-89> dp1[x] += k1; dp1[y] += k1</line-89>
<line-90> dp2[x] += k2; dp2[y] += k2</line-90>
<line-91> den1 *= k1; den2 *= k2</line-91>
<line-92> den1 %= MOD; den2 %= MOD</line-92>
<line-93> return sum(pow(x,MOD-2,MOD) for x in (den1,den2))</line-93>
<line-94></line-94>
<line-95>prob = 1</line-95>
<line-96>for c in components:</line-96>
<line-97> prob *= F(*c)</line-97>
<line-98> prob %= MOD</line-98>
<line-99></line-99>
<line-100>answer = prob</line-100>
<line-101>for n in range(1,N+N+1):</line-101>
<line-102> answer *= n</line-102>
<line-104>print(answer)</line-104>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-103> answer %= MOD</line-103>", "lines": [2, 103]}
#### 0
|
<line-1>from bisect import bisect</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>class Bit:</line-5>
<line-6> def __init__(self, n, MOD):</line-6>
<line-7> self.size = n</line-7>
<line-8> self.tree = [0] * (n + 1)</line-8>
<line-9> self.depth = n.bit_length()</line-9>
<line-10> self.mod = MOD</line-10>
<line-11></line-11>
<line-12> def sum(self, i):</line-12>
<line-13> s = 0</line-13>
<line-14> while i > 0:</line-14>
<line-15> s += self.tree[i]</line-15>
<line-16> i -= i & -i</line-16>
<line-17> return s % self.mod</line-17>
<line-18></line-18>
<line-19> def add(self, i, x):</line-19>
<line-20> while i <= self.size:</line-20>
<line-21> self.tree[i] = (self.tree[i] + x) % self.mod</line-21>
<line-22> i += i & -i</line-22>
<line-23></line-23>
<line-24> def debug_print(self):</line-24>
<line-25> for i in range(1, self.size + 1):</line-25>
<line-26> j = (i & -i).bit_length()</line-26>
<line-27> print((' ' * j, self.tree[i]))</line-27>
<line-28></line-28>
<line-29> def lower_bound(self, x):</line-29>
<line-30> sum_ = 0</line-30>
<line-31> pos = 0</line-31>
<line-32> for i in range(self.depth, -1, -1):</line-32>
<line-33> k = pos + (1 << i)</line-33>
<line-34> if k <= self.size and sum_ + self.tree[k] < x:</line-34>
<line-35> sum_ += self.tree[k]</line-35>
<line-36> pos += 1 << i</line-36>
<line-37> return pos + 1, sum_</line-37>
<line-38></line-38>
<line-39></line-39>
<line-40>n, m = list(map(int, input().split()))</line-40>
<line-41>xxx = list(map(int, input().split()))</line-41>
<line-42>yyy = list(map(int, input().split()))</line-42>
<line-43>ab = defaultdict(set)</line-43>
<line-44>coordinates = set()</line-44>
<line-45></line-45>
<line-46>for x in xxx:</line-46>
<line-47> if x < yyy[0] or yyy[-1] < x:</line-47>
<line-48> continue</line-48>
<line-49> i = bisect(yyy, x)</line-49>
<line-50> a = x - yyy[i - 1]</line-50>
<line-51> b = yyy[i] - x</line-51>
<line-52> ab[a].add(b)</line-52>
<line-53> coordinates.add(b)</line-53>
<line-54></line-54>
<line-55># Bitのindexは1から始まるように作っているが、"0"を取れるようにするため、全体を1ずらす</line-55>
<line-56>cor_dict = {b: i for i, b in enumerate(sorted(coordinates), start=2)}</line-56>
<line-57>cdg = cor_dict.get</line-57>
<line-58>MOD = 10 ** 9 + 7</line-58>
<line-59>bit = Bit(len(coordinates) + 1, MOD)</line-59>
<line-60>bit.add(1, 1)</line-60>
<line-61></line-61>
<line-62>for a in sorted(ab):</line-62>
<line-63> bbb = sorted(map(cdg, ab[a]), reverse=True)</line-63>
<line-64> for b in bbb:</line-64>
<line-66></line-66>
<line-67>print((bit.sum(bit.size)))</line-67>
|
{"code": "<line-2>from collections import defaultdict</line-2>\n<line-65> bit.add(b, bit.sum(b - 1))</line-65>", "lines": [2, 65]}
#### 0
|
<line-1># seishin.py</line-1>
<line-3>P = [list(map(int, input().split())) for i in range(N)]</line-3>
<line-4></line-4>
<line-5>from heapq import heappush, heappop</line-5>
<line-6></line-6>
<line-7>l0, r0 = P[0]</line-7>
<line-8></line-8>
<line-9>L = [-l0+1]</line-9>
<line-10>R = [l0-1]</line-10>
<line-11>s = t = 0</line-11>
<line-12></line-12>
<line-13>res = 0</line-13>
<line-14>for i in range(N-1):</line-14>
<line-15> l0, r0 = P[i]</line-15>
<line-16> l1, r1 = P[i+1]</line-16>
<line-17> s += (r1 - l1); t += (r0 - l0)</line-17>
<line-18> if -s-L[0] <= l1-1 <= t+R[0]:</line-18>
<line-19> heappush(L, -l1+1-s)</line-19>
<line-20> heappush(R, l1-1-t)</line-20>
<line-21> elif l1-1 < -s-L[0]:</line-21>
<line-22> heappush(L, -l1+1-s)</line-22>
<line-23> heappush(L, -l1+1-s)</line-23>
<line-24> p = -heappop(L)-s</line-24>
<line-25> heappush(R, p-t)</line-25>
<line-26> res += (p - (l1-1))</line-26>
<line-27> elif t+R[0] < l1-1:</line-27>
<line-28> heappush(R, l1-1-t)</line-28>
<line-29> heappush(R, l1-1-t)</line-29>
<line-30> p = heappop(R) + t</line-30>
<line-31> heappush(L, -p-s)</line-31>
<line-33>print(res)</line-33>
|
{"code": "<line-2>N = int(input())</line-2>\n<line-32> res += ((l1-1) - p)</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>from sys import stdin, stdout</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>n, m, k = rd()</line-5>
<line-6>a = rd()</line-6>
<line-7>b = [rd() for _ in range(m)]</line-7>
<line-8>x = [0]*(m+1)</line-8>
<line-9>y = [0]*(n+1)</line-9>
<line-10></line-10>
<line-11>for _ in range(k):</line-11>
<line-12> l, r = rd()</line-12>
<line-13> x[l-1] += 1</line-13>
<line-14> x[r ] -= 1</line-14>
<line-15></line-15>
<line-16>s = 0</line-16>
<line-17>for i in range(m):</line-17>
<line-18> l, r, d = b[i]</line-18>
<line-19> s += x[i]</line-19>
<line-20> y[l-1] += s*d</line-20>
<line-21> y[r ] -= s*d</line-21>
<line-22></line-22>
<line-23>s = 0</line-23>
<line-24>for i in range(n):</line-24>
<line-25> s += y[i]</line-25>
<line-27>print(' '.join(map(str, a)))</line-27>
|
{"code": "<line-3>rd = lambda: list(map(int, stdin.readline().split()))</line-3>\n<line-26> a[i] += s</line-26>", "lines": [3, 26]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-3>def main():</line-3>
<line-4> n,k = map(int,stdin.readline().split())</line-4>
<line-5> X = list(map(int,stdin.readline().split()))</line-5>
<line-6> A = int(stdin.readline().strip())</line-6>
<line-7> C = list(map(int,stdin.readline().split()))</line-7>
<line-8> l = list()</line-8>
<line-9> i = 0;g = k;ans = 0;flag = True</line-9>
<line-10> while i < n and flag:</line-10>
<line-11> heappush(l,C[i])</line-11>
<line-12> if X[i] > g:</line-12>
<line-13> while len(l)!= 0 and X[i] > g:</line-13>
<line-14> ans+= heappop(l)</line-14>
<line-15> g+= A</line-15>
<line-16> if len(l) == 0 and X[i] > g:</line-16>
<line-17> flag = False</line-17>
<line-18> i+=1</line-18>
<line-19> if flag:</line-19>
<line-20> print(ans)</line-20>
<line-21> else:</line-21>
<line-23>main()</line-23>
|
{"code": "<line-2>from heapq import heappop,heappush</line-2>\n<line-22>\t\tprint(-1)</line-22>", "lines": [2, 22]}
#### 0
|
<line-1># https://codeforces.com/problemset/problem/280/C</line-1>
<line-3>import sys</line-3>
<line-4></line-4>
<line-5>nodes = int(sys.stdin.readline())</line-5>
<line-6>edges = defaultdict(list)</line-6>
<line-7>for line in sys.stdin:</line-7>
<line-8> a, b = line.split()</line-8>
<line-9> a = int(a)</line-9>
<line-10> b = int(b)</line-10>
<line-11> edges[a].append(b)</line-11>
<line-12> edges[b].append(a)</line-12>
<line-13>bfs = deque([(1, 1)])</line-13>
<line-14>depths = {}</line-14>
<line-15>while bfs:</line-15>
<line-16> nid, depth = bfs.popleft()</line-16>
<line-17> if nid in depths:</line-17>
<line-18> continue</line-18>
<line-19> depths[nid] = depth</line-19>
<line-20> for n2 in edges[nid]:</line-20>
<line-22>print(sum(1.0 / d for d in sorted(depths.values(), reverse=True)))</line-22>
|
{"code": "<line-2>from collections import defaultdict, deque</line-2>\n<line-21> bfs.append((n2, depth + 1))</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>mod = 1000000007</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>def main():</line-5>
<line-6> import sys</line-6>
<line-7> input = sys.stdin.readline</line-7>
<line-8></line-8>
<line-9> def PrimeDecomposition(N):</line-9>
<line-10> ret = {}</line-10>
<line-11> n = int(N ** 0.5)</line-11>
<line-12> for d in range(2, n + 1):</line-12>
<line-13> while N % d == 0:</line-13>
<line-14> if d not in ret:</line-14>
<line-15> ret[d] = 1</line-15>
<line-16> else:</line-16>
<line-17> ret[d] += 1</line-17>
<line-18> N //= d</line-18>
<line-19> if N == 1:</line-19>
<line-20> break</line-20>
<line-21> if N != 1:</line-21>
<line-22> ret[N] = 1</line-22>
<line-23> return ret</line-23>
<line-24></line-24>
<line-25> for _ in range(int(input())):</line-25>
<line-26> p, q = list(map(int, input().split()))</line-26>
<line-27> if p % q != 0:</line-27>
<line-28> print(p)</line-28>
<line-29> continue</line-29>
<line-30> prime = PrimeDecomposition(q)</line-30>
<line-31> C = {}</line-31>
<line-32> mi = p</line-32>
<line-33> for pr in prime:</line-33>
<line-34> C = 0</line-34>
<line-35> tmp = p</line-35>
<line-36> while tmp % pr == 0:</line-36>
<line-37> C += 1</line-37>
<line-38> tmp //= pr</line-38>
<line-39> mi = min(mi, pr ** (C - prime[pr] + 1))</line-39>
<line-40> print(p // mi)</line-40>
<line-41></line-41>
<line-42></line-42>
<line-43>def __starting_point():</line-43>
<line-45></line-45>
<line-46>__starting_point()</line-46>
|
{"code": "<line-2>eps = 10**-9</line-2>\n<line-44> main()</line-44>", "lines": [2, 44]}
#### 0
|
<line-1>for __ in range(int(input())):</line-1>
<line-3> if a == c or b == d:</line-3>
<line-4> print(abs(a - c) + abs(b - d))</line-4>
<line-6> print(abs(a - c) + abs(b - d) + 2)</line-6>
|
{"code": "<line-2> a, b, c, d = list(map(int, input().split()))</line-2>\n<line-5> else:</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>n, m, k = list(map(int,input().split()))</line-1>
<line-3>vis = {}</line-3>
<line-4>sensors = []</line-4>
<line-5>border = set()</line-5>
<line-6>for el in [(0, m), (n, 0), (0, 0), (n, m)]:</line-6>
<line-7> border.add(el)</line-7>
<line-8></line-8>
<line-9>for _ in range(k):</line-9>
<line-10> x, y = list(map(int, input().split()))</line-10>
<line-11> if not (x - y) in dm:</line-11>
<line-12> dm[x - y] = []</line-12>
<line-13> dm[x - y].append((x, y))</line-13>
<line-14> if not (x + y) in dp:</line-14>
<line-15> dp[x + y] = []</line-15>
<line-16> dp[x + y].append((x, y))</line-16>
<line-17> vis[(x, y)] = -1</line-17>
<line-18> sensors.append((x,y))</line-18>
<line-19></line-19>
<line-20>x, y = 0, 0</line-20>
<line-21>time = 0</line-21>
<line-22>move = (1,1)</line-22>
<line-23>while True:</line-23>
<line-24> if move == (1,1):</line-24>
<line-25> v = min(n - x, m - y)</line-25>
<line-26> nxt = (x + v, y + v)</line-26>
<line-27> if nxt[0] == n:</line-27>
<line-28> move = (-1, 1)</line-28>
<line-29> else:</line-29>
<line-30> move = (1, -1)</line-30>
<line-31> if (x - y) in dm:</line-31>
<line-32> for sensor in dm[x - y]:</line-32>
<line-33> if vis[sensor] == -1:</line-33>
<line-34> #print('doing', sensor)</line-34>
<line-35> vis[sensor] = time + sensor[0] - x</line-35>
<line-36> time += v</line-36>
<line-37></line-37>
<line-38> elif move == (-1,-1):</line-38>
<line-39> v = min(x, y)</line-39>
<line-40> nxt = (x - v, y - v)</line-40>
<line-41> if nxt[0] == 0:</line-41>
<line-42> move = (1, -1)</line-42>
<line-43> else:</line-43>
<line-44> move = (-1, 1)</line-44>
<line-45> if (x - y) in dm:</line-45>
<line-46> for sensor in dm[x - y]:</line-46>
<line-47> if vis[sensor] == -1:</line-47>
<line-48> #print('doing', sensor)</line-48>
<line-49> vis[sensor] = time + x - sensor[0]</line-49>
<line-50> time += v</line-50>
<line-51></line-51>
<line-52> elif move == (-1,1):</line-52>
<line-53> v = min(x, m - y)</line-53>
<line-54> nxt = (x - v, y + v)</line-54>
<line-55> if nxt[0] == 0:</line-55>
<line-56> move = (1, 1)</line-56>
<line-57> else:</line-57>
<line-58> move = (-1, -1)</line-58>
<line-59> if (x + y) in dp:</line-59>
<line-60> for sensor in dp[x + y]:</line-60>
<line-61> if vis[sensor] == -1:</line-61>
<line-62> #print('doing', sensor)</line-62>
<line-63> vis[sensor] = time + x - sensor[0]</line-63>
<line-64> time += v</line-64>
<line-65></line-65>
<line-66> else:</line-66>
<line-67> v = min(n - x, y)</line-67>
<line-68> nxt = (x + v, y - v)</line-68>
<line-69> if nxt[0] == n:</line-69>
<line-70> move = (-1, -1)</line-70>
<line-71> else:</line-71>
<line-72> move = (1, 1)</line-72>
<line-73> if (x + y) in dp:</line-73>
<line-74> for sensor in dp[x + y]:</line-74>
<line-75> if vis[sensor] == -1:</line-75>
<line-76> #print('doing', sensor)</line-76>
<line-77> vis[sensor] = time + sensor[0] - x</line-77>
<line-78> time += v</line-78>
<line-79></line-79>
<line-80> if nxt in border:</line-80>
<line-81> break</line-81>
<line-82> else:</line-82>
<line-83> border.add(nxt)</line-83>
<line-84></line-84>
<line-85> x, y = nxt</line-85>
<line-86> #print('bum', x, y)</line-86>
<line-87></line-87>
<line-88>for i in range(k):</line-88>
<line-90> print(vis[sensors[i]])</line-90>
|
{"code": "<line-2>dm, dp = {}, {}</line-2>\n<line-89> #print(sensors[i])</line-89>", "lines": [2, 89]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>L = [0 for i in range (0, n)]</line-4>
<line-5>H = [[] for i in range (0, n)]</line-5>
<line-6>for i in range (0, m):</line-6>
<line-7> x, y = list(map(int, sys.stdin.readline().strip().split()))</line-7>
<line-8> x = x - 1</line-8>
<line-9> y = y - 1</line-9>
<line-10> if x > y:</line-10>
<line-11> x, y = y, x</line-11>
<line-12> L[y] = L[y] + 1</line-12>
<line-13> H[x].append(y)</line-13>
<line-14>ans = 0</line-14>
<line-15>for i in range (0, n):</line-15>
<line-16> ans = ans + L[i] * len(H[i])</line-16>
<line-17>print(ans)</line-17>
<line-18>q = int(sys.stdin.readline().strip())</line-18>
<line-19>for i in range (0, q):</line-19>
<line-20> v = int(sys.stdin.readline().strip()) - 1</line-20>
<line-21> ans = ans - L[v] * len(H[v])</line-21>
<line-22> L[v] = L[v] + len(H[v])</line-22>
<line-23> while len(H[v]) > 0:</line-23>
<line-24> w = H[v].pop()</line-24>
<line-25> H[w].append(v)</line-25>
<line-26> L[w] = L[w] - 1</line-26>
<line-28> print(ans)</line-28>
|
{"code": "<line-3>n, m = list(map(int, sys.stdin.readline().strip().split()))</line-3>\n<line-27> ans = ans + L[w] - len(H[w]) + 1</line-27>", "lines": [3, 27]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-3>Created on Wed Feb 28 11:47:12 2018</line-3>
<line-4></line-4>
<line-5>@author: mikolajbinkowski</line-5>
<line-6>"""</line-6>
<line-7>import sys</line-7>
<line-8></line-8>
<line-9>N = int(input())</line-9>
<line-10></line-10>
<line-11>string_count = {}</line-11>
<line-12>for _ in range(N):</line-12>
<line-13> s = str(input())</line-13>
<line-14> char_count = {}</line-14>
<line-15> for c in s:</line-15>
<line-16> char_count[c] = char_count.get(c, 0) + 1</line-16>
<line-17> s0 = []</line-17>
<line-18> for a in 'abcdefghijklmnopqrstuvwxyz':</line-18>
<line-19> if char_count.get(a, 0) % 2 == 1:</line-19>
<line-20> s0.append(a)</line-20>
<line-21> s1 = ''.join(s0)</line-21>
<line-22> string_count[s1] = string_count.get(s1, 0) + 1</line-22>
<line-23></line-23>
<line-24>pairs = 0</line-24>
<line-25>for s, v in list(string_count.items()):</line-25>
<line-26> pairs += v * (v-1) // 2</line-26>
<line-27> for i in range(len(s)):</line-27>
<line-29></line-29>
<line-30>print(pairs)</line-30>
<line-31></line-31>
<line-32> </line-32>
<line-33> </line-33>
|
{"code": "<line-2>\"\"\"</line-2>\n<line-28> pairs += v * string_count.get(s[:i] + s[i+1:], 0)</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>corr = lambda x, y: 1 <= x <= n and 1 <= y <= m</line-1>
<line-2></line-2>
<line-4>a = []</line-4>
<line-5>while T:</line-5>
<line-6> a.append(T % 6)</line-6>
<line-7> T //= 6</line-7>
<line-8>L = len(a)</line-8>
<line-9>n = m = L * 2 + 2</line-9>
<line-10>ans = [(1, 2, 2, 2), (2, 1, 2, 2)]</line-10>
<line-11>f = [[1] * 9 for i in range(7)]</line-11>
<line-12>f[1][2] = f[2][2] = f[2][6] = f[3][5] = 0</line-12>
<line-13>f[4][5] = f[4][6] = f[5][2] = f[5][5] = f[5][6] = 0</line-13>
<line-14>p = [0] * 9</line-14>
<line-15>p[1] = 3, 1, 3, 2</line-15>
<line-16>p[2] = 4, 1, 4, 2</line-16>
<line-17>p[3] = 4, 2, 5, 2</line-17>
<line-18>p[4] = 4, 3, 5, 3</line-18>
<line-19>p[5] = 1, 3, 2, 3</line-19>
<line-20>p[6] = 1, 4, 2, 4</line-20>
<line-21>p[7] = 2, 4, 2, 5</line-21>
<line-22>p[8] = 3, 4, 3, 5</line-22>
<line-23>for i in range(L):</line-23>
<line-24> bit = a[L - i - 1]</line-24>
<line-25> for j in range(1, 9):</line-25>
<line-26> if not f[bit][j]: continue</line-26>
<line-27> x1, y1, x2, y2 = p[j]; D = 2 * i</line-27>
<line-28> x1 += D; y1 += D; x2 += D; y2 += D</line-28>
<line-29> if corr(x2, y2): ans.append((x1, y1, x2, y2))</line-29>
<line-30>for i in range(L - 1):</line-30>
<line-31> x1, y1 = 5 + i * 2, 1 + i * 2</line-31>
<line-32> x2, y2 = 1 + i * 2, 5 + i * 2</line-32>
<line-33> ans.append((x1, y1, x1 + 1, y1))</line-33>
<line-34> ans.append((x1, y1 + 1, x1 + 1, y1 + 1))</line-34>
<line-35> ans.append((x2, y2, x2, y2 + 1))</line-35>
<line-36> ans.append((x2 + 1, y2, x2 + 1, y2 + 1))</line-36>
<line-37>print(n, m)</line-37>
<line-39>[print(*i) for i in ans]</line-39>
|
{"code": "<line-3>T = int(input())</line-3>\n<line-38>print(len(ans))</line-38>", "lines": [3, 38]}
#### 0
|
<line-1>#!/usr/bin/env python</line-1>
<line-3>import sys,collections</line-3>
<line-4>n,q=list(map(int,input().split()))</line-4>
<line-5>M=collections.defaultdict(collections.deque)</line-5>
<line-6>Q=collections.deque()</line-6>
<line-7>L=[]</line-7>
<line-8>s=n=m=0</line-8>
<line-9>for _ in range(q):</line-9>
<line-10> y,x=list(map(int,input().split()))</line-10>
<line-11> if 2>y:</line-11>
<line-12> s+=1</line-12>
<line-13> Q.append(x)</line-13>
<line-14> M[x].append(n)</line-14>
<line-15> n+=1</line-15>
<line-16> elif 3>y:</line-16>
<line-17> y=M.get(x)</line-17>
<line-18> if y:</line-18>
<line-19> s-=len(y)</line-19>
<line-20> del M[x]</line-20>
<line-21> else:</line-21>
<line-22> while x>m:</line-22>
<line-23> z=Q.popleft()</line-23>
<line-24> y=M.get(z)</line-24>
<line-25> if y and y[0]<x:</line-25>
<line-26> s-=1</line-26>
<line-27> y.popleft()</line-27>
<line-28> if not y:del M[z]</line-28>
<line-29> m+=1</line-29>
<line-31>sys.stdout.write('\n'.join(map(str,L)))</line-31>
|
{"code": "<line-2>#-*-coding:utf-8 -*-</line-2>\n<line-30>\tL.append(s)</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>ii = lambda: int(input())</line-1>
<line-3>li = lambda: list(mi())</line-3>
<line-4>from collections import Counter as C</line-4>
<line-5>n = ii()</line-5>
<line-6>a = li()</line-6>
<line-7>oe = [C(), C()]</line-7>
<line-8>oe[1][0] = 1</line-8>
<line-9>x = 0</line-9>
<line-10>ans = 0</line-10>
<line-11>for i in range(n):</line-11>
<line-12> x ^= a[i]</line-12>
<line-13> ans += oe[i % 2][x]</line-13>
<line-15>print(ans)</line-15>
|
{"code": "<line-2>mi = lambda: map(int, input().split())</line-2>\n<line-14> oe[i % 2][x] += 1</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>n,m=list(map(int,input().split()))</line-4>
<line-5>ANS=[]</line-5>
<line-6></line-6>
<line-7>for i in range(1,n//2+1):</line-7>
<line-8> for j in range(1,m+1):</line-8>
<line-9> sys.stdout.write("".join((str(i)," ",str(j),"\n")))</line-9>
<line-10> sys.stdout.write("".join((str(n-i+1)," ",str(m-j+1),"\n")))</line-10>
<line-11></line-11>
<line-12></line-12>
<line-13></line-13>
<line-14>if n%2==1:</line-14>
<line-15> for j in range(1,m//2+1):</line-15>
<line-16> sys.stdout.write("".join((str(n//2+1)," ",str(j),"\n")))</line-16>
<line-17> sys.stdout.write("".join((str(n//2+1)," ",str(m-j+1),"\n")))</line-17>
<line-18></line-18>
<line-20> sys.stdout.write("".join((str(n//2+1)," ",str(m//2+1),"\n")))</line-20>
<line-21></line-21>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-19> if m%2==1:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>import sys</line-1>
<line-3>T = int(input())</line-3>
<line-4>for _ in range(T):</line-4>
<line-5> N = int(input())</line-5>
<line-6> A = [ord(a) - 97 for a in input()]</line-6>
<line-7> B = [ord(a) - 97 for a in input()]</line-7>
<line-8> X = [[0] * 20 for _ in range(20)]</line-8>
<line-9> for a, b in zip(A, B):</line-9>
<line-10> X[a][b] = 1</line-10>
<line-11> if a > b:</line-11>
<line-12> print(-1)</line-12>
<line-13> break</line-13>
<line-14> else:</line-14>
<line-15> ans = 0</line-15>
<line-16> for i in range(20):</line-16>
<line-17> for j in range(i+1, 20):</line-17>
<line-18> if X[i][j]:</line-18>
<line-19> ans += 1</line-19>
<line-20> for jj in range(j+1, 20):</line-20>
<line-21> if X[i][jj]:</line-21>
<line-22> X[j][jj] = 1</line-22>
<line-24> print(ans)</line-24>
|
{"code": "<line-2>input = lambda: sys.stdin.readline().rstrip()</line-2>\n<line-23> break</line-23>", "lines": [2, 23]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.