question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>N=100001</line-1>
<line-3>for i in range(1,N):</line-3>
<line-4> for j in range(i,N,i):</line-4>
<line-5> fac[j]+=1</line-5>
<line-6>def gcd(a,b):</line-6>
<line-7> if a<b:</line-7>
<line-8> a,b=b,a</line-8>
<line-9> while b>0:</line-9>
<line-10> a,b=b,a%b</line-10>
<line-11> return a</line-11>
<line-12>def ctt(A,B,C):</line-12>
<line-13> la=fac[A]</line-13>
<line-14> lb=fac[B]</line-14>
<line-15> lc=fac[C]</line-15>
<line-16> ab=gcd(A,B)</line-16>
<line-17> ac=gcd(A,C)</line-17>
<line-18> bc=gcd(B,C)</line-18>
<line-19> abc=gcd(ab,C)</line-19>
<line-20> dupabc=fac[abc]</line-20>
<line-21> dupac=fac[ac]-dupabc</line-21>
<line-22> dupbc=fac[bc]-dupabc</line-22>
<line-23> dupab=fac[ab]-dupabc</line-23>
<line-24> lax=la-dupabc-dupab-dupac</line-24>
<line-25> lbx=lb-dupabc-dupab-dupbc</line-25>
<line-26> lcx=lc-dupabc-dupac-dupbc</line-26>
<line-27> ctx=lax*lbx*lcx</line-27>
<line-28> ctx+=lax*lbx*(lc-lcx)</line-28>
<line-29> ctx+=lax*lcx*(lb-lbx)</line-29>
<line-30> ctx+=lcx*lbx*(la-lax)</line-30>
<line-31> ctx+=lax*((lb-lbx)*(lc-lcx)-(dupabc+dupbc)*(dupabc+dupbc-1)/2)</line-31>
<line-32> ctx+=lbx*((la-lax)*(lc-lcx)-(dupabc+dupac)*(dupabc+dupac-1)/2)</line-32>
<line-33> ctx+=lcx*((la-lax)*(lb-lbx)-(dupabc+dupab)*(dupabc+dupab-1)/2)</line-33>
<line-34> ctx+=dupab*dupac*dupbc</line-34>
<line-35> ctx+=dupab*dupac*(dupab+dupac+2)/2</line-35>
<line-36> ctx+=dupab*dupbc*(dupab+dupbc+2)/2</line-36>
<line-37> ctx+=dupbc*dupac*(dupbc+dupac+2)/2</line-37>
<line-38> ctx+=dupabc*(dupab*dupac+dupab*dupbc+dupbc*dupac)</line-38>
<line-39> ctx+=dupabc*(dupab*(dupab+1)+(dupbc+1)*dupbc+(dupac+1)*dupac)/2</line-39>
<line-40> ctx+=(dupabc+1)*dupabc*(dupab+dupac+dupbc)/2</line-40>
<line-41> ctx+=(dupabc*dupabc+dupabc*(dupabc-1)*(dupabc-2)/6)</line-41>
<line-42> return int(ctx)</line-42>
<line-43>n=int(input())</line-43>
<line-44>for _ in range(n):</line-44>
<line-45> a,b,c = map(int,input().split())</line-45>
<line-47>return</line-47>
|
{"code": "<line-2>fac=[0 for i in range(N)]</line-2>\n<line-46> print(ctt(a,b,c))</line-46>", "lines": [2, 46]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-2></line-2>
<line-4> </line-4>
<line-5> x = a</line-5>
<line-6> while x <= (len(bit)-1):</line-6>
<line-7> bit[x] += w</line-7>
<line-8> x += x & (-1 * x)</line-8>
<line-9> </line-9>
<line-10>def bitsum(a,bit):</line-10>
<line-11> </line-11>
<line-12> ret = 0</line-12>
<line-13> x = a</line-13>
<line-14> while x > 0:</line-14>
<line-15> ret += bit[x]</line-15>
<line-16> x -= x & (-1 * x)</line-16>
<line-17> return ret</line-17>
<line-18></line-18>
<line-19>class RangeBIT:</line-19>
<line-20></line-20>
<line-21> def __init__(self,N,indexed):</line-21>
<line-22> self.bit1 = [0] * (N+2)</line-22>
<line-23> self.bit2 = [0] * (N+2)</line-23>
<line-24> self.mode = indexed</line-24>
<line-25></line-25>
<line-26> def bitadd(self,a,w,bit):</line-26>
<line-27> </line-27>
<line-28> x = a</line-28>
<line-29> while x <= (len(bit)-1):</line-29>
<line-30> bit[x] += w</line-30>
<line-31> x += x & (-1 * x)</line-31>
<line-32> </line-32>
<line-33> def bitsum(self,a,bit):</line-33>
<line-34> </line-34>
<line-35> ret = 0</line-35>
<line-36> x = a</line-36>
<line-37> while x > 0:</line-37>
<line-38> ret += bit[x]</line-38>
<line-39> x -= x & (-1 * x)</line-39>
<line-40> return ret</line-40>
<line-41> </line-41>
<line-42> def add(self,l,r,w):</line-42>
<line-43></line-43>
<line-44> l = l + (1-self.mode)</line-44>
<line-45> r = r + (1-self.mode)</line-45>
<line-46> self.bitadd(l,-1*w*l,self.bit1)</line-46>
<line-47> self.bitadd(r,w*r,self.bit1)</line-47>
<line-48> self.bitadd(l,w,self.bit2)</line-48>
<line-49> self.bitadd(r,-1*w,self.bit2)</line-49>
<line-50></line-50>
<line-51> def sum(self,l,r):</line-51>
<line-52> l = l + (1-self.mode)</line-52>
<line-53> r = r + (1-self.mode)</line-53>
<line-54> ret = self.bitsum(r,self.bit1) + r * self.bitsum(r,self.bit2)</line-54>
<line-55> ret -= self.bitsum(l,self.bit1) + l * self.bitsum(l,self.bit2)</line-55>
<line-56></line-56>
<line-57> return ret</line-57>
<line-58></line-58>
<line-59>n,q = list(map(int,stdin.readline().split()))</line-59>
<line-60>a = list(map(int,stdin.readline().split()))</line-60>
<line-61></line-61>
<line-62>qs = [ [] for i in range(n+1) ]</line-62>
<line-63>ans = [None] * q</line-63>
<line-64></line-64>
<line-65>for loop in range(q):</line-65>
<line-66> x,y = list(map(int,stdin.readline().split()))</line-66>
<line-67> l = x+1</line-67>
<line-68> r = n-y</line-68>
<line-69> qs[r].append((l,loop))</line-69>
<line-70></line-70>
<line-71>BIT = [0] * (n+1)</line-71>
<line-72></line-72>
<line-73>for r in range(1,n+1):</line-73>
<line-74></line-74>
<line-75> b = r-a[r-1]</line-75>
<line-76></line-76>
<line-77> if b >= 0:</line-77>
<line-78></line-78>
<line-79> L = 1</line-79>
<line-80> R = r+1</line-80>
<line-81> while R-L != 1:</line-81>
<line-82> M = (L+R)//2</line-82>
<line-83></line-83>
<line-84> if bitsum(M,BIT) >= b:</line-84>
<line-85> L = M</line-85>
<line-86> else:</line-86>
<line-87> R = M</line-87>
<line-88></line-88>
<line-89> if bitsum(L,BIT) >= b:</line-89>
<line-90> bitadd(1,1,BIT)</line-90>
<line-91> bitadd(L+1,-1,BIT)</line-91>
<line-92></line-92>
<line-93></line-93>
<line-94> for ql,qind in qs[r]:</line-94>
<line-95> ans[qind] = bitsum(ql,BIT)</line-95>
<line-96></line-96>
<line-98> print (i)</line-98>
|
{"code": "<line-3>def bitadd(a,w,bit):</line-3>\n<line-97>for i in ans:</line-97>", "lines": [3, 97]}
#### 0
|
<line-1>import random</line-1>
<line-3></line-3>
<line-4>def set_color(game, color):</line-4>
<line-5> color_count[game[0]][game[2]] -= 1</line-5>
<line-6> color_count[game[1]][game[2]] -= 1</line-6>
<line-7> game[2] = color</line-7>
<line-8> color_count[game[0]][game[2]] += 1</line-8>
<line-9> color_count[game[1]][game[2]] += 1</line-9>
<line-10></line-10>
<line-11>def fix(node):</line-11>
<line-12> minimum = math.inf</line-12>
<line-13> maximum = 0</line-13>
<line-14></line-14>
<line-15> for i in range(k):</line-15>
<line-16> minimum = min(minimum, color_count[node][i])</line-16>
<line-17> maximum = max(maximum, color_count[node][i])</line-17>
<line-18></line-18>
<line-19> if maximum - minimum <= 2:</line-19>
<line-20> return False</line-20>
<line-21></line-21>
<line-22> rand = 0</line-22>
<line-23> for game in games:</line-23>
<line-24> if (game[0] == node or game[1] == node) and color_count[node][game[2]] == maximum:</line-24>
<line-25> rand = r(1,k)</line-25>
<line-26> set_color(game, rand % k)</line-26>
<line-27> return True</line-27>
<line-28></line-28>
<line-29> return False</line-29>
<line-30></line-30>
<line-31>n, m, k = list(map(int,input().split()))</line-31>
<line-32>games = [[0 for _ in range(4)] for _ in range(m)]</line-32>
<line-33>color_count = [[0 for _ in range(k)] for _ in range(n)]</line-33>
<line-34>answers = [0 for _ in range(m)]</line-34>
<line-35>_ = list(map(int,input().split()))</line-35>
<line-36></line-36>
<line-37>color = 0</line-37>
<line-38>r = lambda x,y : random.randint(x,y)</line-38>
<line-39>for i in range(m):</line-39>
<line-40> a, b = list(map(int,input().split()))</line-40>
<line-41> color = r(1,k) % k</line-41>
<line-42> games[i] = [a-1,b-1,color,i]</line-42>
<line-43> color_count[games[i][0]][color] += 1</line-43>
<line-44> color_count[games[i][1]][color] += 1</line-44>
<line-45></line-45>
<line-46>bad = True</line-46>
<line-47></line-47>
<line-48>while bad:</line-48>
<line-49> random.shuffle(games)</line-49>
<line-50> bad = False</line-50>
<line-51></line-51>
<line-52> for i in range(n):</line-52>
<line-53> while(fix(i)):</line-53>
<line-54> bad = True</line-54>
<line-55></line-55>
<line-56>for game in games:</line-56>
<line-57> answers[game[3]] = game[2] + 1</line-57>
<line-58></line-58>
<line-60> print(answers[i])</line-60>
<line-61> </line-61>
<line-62></line-62>
<line-63> </line-63>
|
{"code": "<line-2>import math</line-2>\n<line-59>for i in range(m):</line-59>", "lines": [2, 59]}
#### 0
|
<line-1>from collections import deque</line-1>
<line-2></line-2>
<line-4> k = 2 * r + 1</line-4>
<line-5> d = deque()</line-5>
<line-6> lx = len(x)</line-6>
<line-7> for i in range(lx + r):</line-7>
<line-8> if i < lx:</line-8>
<line-9> while d and d[-1][1] <= x[i]:</line-9>
<line-10> d.pop()</line-10>
<line-11> d.append((i, x[i]))</line-11>
<line-12> while d and d[0][0] <= i - k:</line-12>
<line-13> d.popleft()</line-13>
<line-14> if i >= r:</line-14>
<line-15> y[i - r] = d[0][1] - abs(i - r - a)</line-15>
<line-16></line-16>
<line-17>n, m, d = [int(x) for x in input().split()]</line-17>
<line-18>a, ball, t0 = [int(x) for x in input().split()]</line-18>
<line-19>f = [-abs(i - a) for i in range(1, n + 1)]</line-19>
<line-20>g = [0] * n</line-20>
<line-21>for _ in range(m - 1):</line-21>
<line-22> a, b, t = [int(x) for x in input().split()]</line-22>
<line-23> ball += b</line-23>
<line-24> r = min(n - 1, (t - t0) * d)</line-24>
<line-25> t0 = t </line-25>
<line-26> rollingmax(f, g, r, a - 1)</line-26>
<line-28></line-28>
<line-29>print(max(f) + ball) </line-29>
<line-30></line-30>
|
{"code": "<line-3>def rollingmax(x, y, r, a):</line-3>\n<line-27> f, g = g, f</line-27>", "lines": [3, 27]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def main():</line-4>
<line-5> R, C, N = map(int, input().split())</line-5>
<line-6> xyxy = [list(map(int, input().split())) for i in range(N)]</line-6>
<line-7></line-7>
<line-8> r = []</line-8>
<line-9></line-9>
<line-10> for i in range(N):</line-10>
<line-11> x1, y1, x2, y2 = xyxy[i]</line-11>
<line-12> # どちらも周上にある場合は周上の座標に変換してから記録</line-12>
<line-13> if ((x1 == 0 or x1 == R) or (y1 == 0 or y1 == C)) and ((x2 == 0 or x2 == R) or (y2 == 0 or y2 == C)):</line-13>
<line-14> # １つ目</line-14>
<line-15> if x1 == 0:</line-15>
<line-16> r.append((y1, i))</line-16>
<line-17> elif x1 == R:</line-17>
<line-18> r.append((C - y1 + C + R, i))</line-18>
<line-19> elif y1 == 0:</line-19>
<line-20> r.append((R - x1 + C * 2 + R, i))</line-20>
<line-21> else:</line-21>
<line-22> r.append((x1 + C, i))</line-22>
<line-23> # 2つ目</line-23>
<line-24> if x2 == 0:</line-24>
<line-25> r.append((y2, i))</line-25>
<line-26> elif x2 == R:</line-26>
<line-27> r.append((C - y2 + C + R, i))</line-27>
<line-28> elif y2 == 0:</line-28>
<line-29> r.append((R - x2 + C * 2 + R, i))</line-29>
<line-30> else:</line-30>
<line-31> r.append((x2 + C, i))</line-31>
<line-32> </line-32>
<line-33> r = sorted(r)</line-33>
<line-34> # print(r)</line-34>
<line-35> stack = []</line-35>
<line-36> for i in range(len(r)):</line-36>
<line-37> if len(stack) > 0:</line-37>
<line-38> if stack[-1] == r[i][1]:</line-38>
<line-39> stack.pop()</line-39>
<line-40> else:</line-40>
<line-41> stack.append(r[i][1])</line-41>
<line-42> else:</line-42>
<line-43> stack.append(r[i][1])</line-43>
<line-44> </line-44>
<line-45> if len(stack) > 0:</line-45>
<line-46> print("NO")</line-46>
<line-47> else:</line-47>
<line-48> print("YES")</line-48>
<line-49> </line-49>
<line-50></line-50>
<line-51></line-51>
<line-52></line-52>
<line-53>def __starting_point():</line-53>
<line-55>__starting_point()</line-55>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-54> main()</line-54>", "lines": [2, 54]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5></line-5>
<line-6>def powmod(a, x, m = M):</line-6>
<line-7> y = 1</line-7>
<line-8> while 0 < x:</line-8>
<line-9> if x % 2 == 1:</line-9>
<line-10> y *= a</line-10>
<line-11> y %= m</line-11>
<line-12> x //= 2</line-12>
<line-13> a = a ** 2</line-13>
<line-14> a %= m</line-14>
<line-15></line-15>
<line-16> return y</line-16>
<line-17></line-17>
<line-18></line-18>
<line-19>def solve(s):</line-19>
<line-20> n = len(s)</line-20>
<line-21></line-21>
<line-22> nb = nc = 0</line-22>
<line-23> ch = s[0]</line-23>
<line-24> if ch == 'b':</line-24>
<line-25> nb += 1</line-25>
<line-26> elif ch == 'c':</line-26>
<line-27> nc += 1</line-27>
<line-28> sf = True</line-28>
<line-29> tf = True</line-29>
<line-30> left = ch</line-30>
<line-31> for ch in s[1:]:</line-31>
<line-32> if ch == 'b':</line-32>
<line-33> nb += 1</line-33>
<line-34> elif ch == 'c':</line-34>
<line-35> nc += 1</line-35>
<line-36> if ch == left:</line-36>
<line-37> sf = False</line-37>
<line-38> else:</line-38>
<line-39> tf = False</line-39>
<line-40> left = ch</line-40>
<line-41></line-41>
<line-42></line-42>
<line-43> if tf:</line-43>
<line-44> return 1</line-44>
<line-45> if n == 3:</line-45>
<line-46> if (nb + nc * 2) % 3:</line-46>
<line-47> return 7 if sf else 6</line-47>
<line-48> else:</line-48>
<line-49> return 3</line-49>
<line-50> if n % 3:</line-50>
<line-51> return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M</line-51>
<line-52> else:</line-52>
<line-53> if (nb + nc * 2) % 3:</line-53>
<line-54> return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M</line-54>
<line-55> else:</line-55>
<line-56> return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M</line-56>
<line-57></line-57>
<line-58>def main():</line-58>
<line-59> s = input()</line-59>
<line-60></line-60>
<line-61> print((solve(s)))</line-61>
<line-62></line-62>
<line-63></line-63>
<line-64>def __starting_point():</line-64>
<line-66></line-66>
<line-67></line-67>
<line-68>__starting_point()</line-68>
|
{"code": "<line-4>M = 998244353</line-4>\n<line-65> main()</line-65>", "lines": [4, 65]}
#### 0
|
<line-1># ARC090E</line-1>
<line-2></line-2>
<line-4> M = 10**9 + 7</line-4>
<line-5> import sys</line-5>
<line-6> input = lambda : sys.stdin.readline().rstrip()</line-6>
<line-7></line-7>
<line-8> n, m = map(int, input().split())</line-8>
<line-9> s, t = map(int, input().split())</line-9>
<line-10> s -= 1</line-10>
<line-11> t -= 1</line-11>
<line-12> from collections import defaultdict</line-12>
<line-13> ns = defaultdict(set)</line-13>
<line-14> for i in range(m):</line-14>
<line-15> u, v, d = map(int, input().split())</line-15>
<line-16> ns[u-1].add((v-1, d))</line-16>
<line-17> ns[v-1].add((u-1, d))</line-17>
<line-18> </line-18>
<line-19> def _dijkstra(N, s, Edge):</line-19>
<line-20> import heapq</line-20>
<line-21> geta = 10**15</line-21>
<line-22> inf = geta</line-22>
<line-23> dist = [inf] * N</line-23>
<line-24> dist[s] = 0</line-24>
<line-25> Q = [(0, s)]</line-25>
<line-26> dp = [0]*N</line-26>
<line-27> dp[s] = 1</line-27>
<line-28> while Q:</line-28>
<line-29> dn, vn = heapq.heappop(Q)</line-29>
<line-30> if dn > dist[vn]:</line-30>
<line-31> continue</line-31>
<line-32> for vf, df in Edge[vn]:</line-32>
<line-33> if dist[vn] + df < dist[vf]:</line-33>
<line-34> dist[vf] = dist[vn] + df</line-34>
<line-35> dp[vf] = dp[vn]</line-35>
<line-36> heapq.heappush(Q, (dn + df,vf))</line-36>
<line-37> elif dist[vn] + df == dist[vf]:</line-37>
<line-38> dp[vf] = (dp[vf] + dp[vn]) % M</line-38>
<line-39> return dist, dp</line-39>
<line-40></line-40>
<line-41> def dijkstra(start):</line-41>
<line-42> import heapq</line-42>
<line-43> vals = [None] * n</line-43>
<line-44> nums = [None] * n</line-44>
<line-45> nums[start] = 1</line-45>
<line-46> h = [(0, start)] # (距離, ノード番号)</line-46>
<line-47> vals[start] = 0</line-47>
<line-48> while h:</line-48>
<line-49> val, u = heapq.heappop(h)</line-49>
<line-50> for v, d in ns[u]:</line-50>
<line-51> if vals[v] is None or vals[v]>val+d:</line-51>
<line-52> vals[v] = val+d</line-52>
<line-53> nums[v] = nums[u]</line-53>
<line-54> heapq.heappush(h, (vals[v], v))</line-54>
<line-55> elif vals[v] is not None and vals[v]==val+d:</line-55>
<line-56> nums[v] = (nums[v] + nums[u]) % M</line-56>
<line-57> return vals, nums</line-57>
<line-58> </line-58>
<line-59> vals1, nums1 = dijkstra(s)</line-59>
<line-60> vals2, nums2 = dijkstra(t)</line-60>
<line-61> </line-61>
<line-62> T = vals1[t]</line-62>
<line-63></line-63>
<line-64> c1 = 0 # 頂点で衝突するペアの数</line-64>
<line-65> c2 = 0 # エッジ(端点除く)で衝突するペアの数</line-65>
<line-66> </line-66>
<line-67> for u in range(n):</line-67>
<line-68> if 2*vals1[u]==T and 2*vals2[u]==T:</line-68>
<line-69> c1 = (c1 + pow((nums1[u] * nums2[u]), 2, M)) % M</line-69>
<line-70> for v,d in ns[u]:</line-70>
<line-71> if (vals1[u]+d+vals2[v]==T) and (2*vals1[u] < T < 2*(vals1[u] + d)):</line-71>
<line-72> c2 = (c2 + (nums1[u] * nums2[v])**2) % M</line-72>
<line-74>hoge()</line-74>
|
{"code": "<line-3>def hoge():</line-3>\n<line-73> print((nums1[t]*nums2[s] - (c1+c2)) % M)</line-73>", "lines": [3, 73]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5> section_start = -1</line-5>
<line-6> moved_left_max = 0</line-6>
<line-7> moved_right_max = 0</line-7>
<line-8> prev = True</line-8>
<line-9></line-9>
<line-10> for i, p in enumerate(ppp, start=1):</line-10>
<line-11> if i == p:</line-11>
<line-12> if prev:</line-12>
<line-13> moved_left_max = 0</line-13>
<line-14> moved_right_max = 0</line-14>
<line-15> section_start = -1</line-15>
<line-16> prev = True</line-16>
<line-17> else:</line-17>
<line-18> if not prev:</line-18>
<line-19> if moved_left_max > i - 1:</line-19>
<line-20> return False</line-20>
<line-21></line-21>
<line-22> moved_left_max = 0</line-22>
<line-23> moved_right_max = 0</line-23>
<line-24> section_start = i</line-24>
<line-25></line-25>
<line-26> if section_start == -1:</line-26>
<line-27> section_start = i</line-27>
<line-28></line-28>
<line-29> if i > p:</line-29>
<line-30> if section_start > p:</line-30>
<line-31> return False</line-31>
<line-32> if moved_right_max > p:</line-32>
<line-33> return False</line-33>
<line-34> moved_right_max = p</line-34>
<line-35> else:</line-35>
<line-36> if moved_left_max > p:</line-36>
<line-37> return False</line-37>
<line-38> moved_left_max = p</line-38>
<line-39></line-39>
<line-40> prev = False</line-40>
<line-41> return True</line-41>
<line-42></line-42>
<line-43></line-43>
<line-45>print(('Yes' if solve(ppp) else 'No'))</line-45>
|
{"code": "<line-4>def solve(ppp):</line-4>\n<line-44>n, *ppp = list(map(int, sys.stdin))</line-44>", "lines": [4, 44]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>N,M=list(map(int,input().split()))</line-5>
<line-6></line-6>
<line-7># N: 処理する区間の長さ</line-7>
<line-8>INF = 2**31-1</line-8>
<line-9></line-9>
<line-10>LV = (M+2-1).bit_length()</line-10>
<line-11>N0 = 2**LV</line-11>
<line-12>data = [0]*(2*N0)</line-12>
<line-13>lazy = [0]*(2*N0)</line-13>
<line-14></line-14>
<line-15>def gindex(l, r):</line-15>
<line-16> L = (l + N0) >> 1; R = (r + N0) >> 1</line-16>
<line-17> lc = 0 if l & 1 else (L & -L).bit_length()</line-17>
<line-18> rc = 0 if r & 1 else (R & -R).bit_length()</line-18>
<line-19> for i in range(LV):</line-19>
<line-20> if rc <= i:</line-20>
<line-21> yield R</line-21>
<line-22> if L < R and lc <= i:</line-22>
<line-23> yield L</line-23>
<line-24> L >>= 1; R >>= 1</line-24>
<line-25></line-25>
<line-26># 遅延伝搬処理</line-26>
<line-27>def propagates(*ids):</line-27>
<line-28> for i in reversed(ids):</line-28>
<line-29> v = lazy[i-1]</line-29>
<line-30> if not v:</line-30>
<line-31> continue</line-31>
<line-32> lazy[2*i-1] += v; lazy[2*i] += v</line-32>
<line-33> data[2*i-1] += v; data[2*i] += v</line-33>
<line-34> lazy[i-1] = 0</line-34>
<line-35></line-35>
<line-36># 区間[l, r)にxを加算</line-36>
<line-37>def update(l, r, x):</line-37>
<line-38> *ids, = gindex(l, r)</line-38>
<line-39> propagates(*ids)</line-39>
<line-40></line-40>
<line-41> L = N0 + l; R = N0 + r</line-41>
<line-42> while L < R:</line-42>
<line-43> if R & 1:</line-43>
<line-44> R -= 1</line-44>
<line-45> lazy[R-1] += x; data[R-1] += x</line-45>
<line-46> if L & 1:</line-46>
<line-47> lazy[L-1] += x; data[L-1] += x</line-47>
<line-48> L += 1</line-48>
<line-49> L >>= 1; R >>= 1</line-49>
<line-50> for i in ids:</line-50>
<line-51> data[i-1] = min(data[2*i-1], data[2*i])</line-51>
<line-52></line-52>
<line-53># 区間[l, r)内の最小値を求める</line-53>
<line-54>def query(l, r):</line-54>
<line-55> propagates(*gindex(l, r))</line-55>
<line-56> L = N0 + l; R = N0 + r</line-56>
<line-57></line-57>
<line-58> s = INF</line-58>
<line-59> while L < R:</line-59>
<line-60> if R & 1:</line-60>
<line-61> R -= 1</line-61>
<line-62> s = min(s, data[R-1])</line-62>
<line-63> if L & 1:</line-63>
<line-64> s = min(s, data[L-1])</line-64>
<line-65> L += 1</line-65>
<line-66> L >>= 1; R >>= 1</line-66>
<line-67> return s</line-67>
<line-68></line-68>
<line-69>for i in range(1,M+1):</line-69>
<line-70> update(0,i+1,1)</line-70>
<line-71></line-71>
<line-72>add=M-N</line-72>
<line-73>hito=[]</line-73>
<line-74>for i in range(N):</line-74>
<line-75> L,R=list(map(int,input().split()))</line-75>
<line-76> hito.append((L,R))</line-76>
<line-77>hito.sort()</line-77>
<line-78>#test=[query(i,i+1) for i in range(M+2)]</line-78>
<line-79>#print(test)</line-79>
<line-80>for l,r in hito:</line-80>
<line-81> update(0,r+1,-1)</line-81>
<line-82> #test=[query(i,i+1) for i in range(M+2)]</line-82>
<line-83> #print(test)</line-83>
<line-84> m=query(l+1,M+2)+l</line-84>
<line-86></line-86>
<line-87>print((max(-add,0)))</line-87>
|
{"code": "<line-3>input=sys.stdin.readline</line-3>\n<line-85> add=min(m,add)</line-85>", "lines": [3, 85]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>input=sys.stdin.readline</line-4>
<line-5></line-5>
<line-6>N=int(input())</line-6>
<line-7>edge=[[] for i in range(N)]</line-7>
<line-8>for i in range(N-1):</line-8>
<line-9> x,y=list(map(int,input().split()))</line-9>
<line-10> edge[x-1].append(y-1)</line-10>
<line-11> edge[y-1].append(x-1)</line-11>
<line-12></line-12>
<line-13>c=input()[:N]</line-13>
<line-14></line-14>
<line-15>deg=[len(edge[i]) for i in range(N)]</line-15>
<line-16>leaf=set([])</line-16>
<line-17>for i in range(N):</line-17>
<line-18> if deg[i]==1 and c[i]=="B":</line-18>
<line-19> leaf.add(i)</line-19>
<line-20></line-20>
<line-21>ban=set([])</line-21>
<line-22>while leaf:</line-22>
<line-23> v=leaf.pop()</line-23>
<line-24> ban.add(v)</line-24>
<line-25> deg[v]=0</line-25>
<line-26> for nv in edge[v]:</line-26>
<line-27> deg[nv]-=1</line-27>
<line-28> if deg[nv]==1 and c[nv]=="B":</line-28>
<line-29> leaf.add(nv)</line-29>
<line-30></line-30>
<line-31>for i in range(N):</line-31>
<line-32> edge[i]=[nv for nv in edge[i] if nv not in ban]</line-32>
<line-33></line-33>
<line-34>root=-1</line-34>
<line-35>for i in range(N):</line-35>
<line-36> if i not in ban:</line-36>
<line-37> root=i</line-37>
<line-38></line-38>
<line-39>parent=[-2]*N</line-39>
<line-40>deq=deque([(root,-1)])</line-40>
<line-41>node=[]</line-41>
<line-42>while deq:</line-42>
<line-43> v,pv=deq.popleft()</line-43>
<line-44> parent[v]=pv</line-44>
<line-45> node.append(v)</line-45>
<line-46> for nv in edge[v]:</line-46>
<line-47> if nv!=pv:</line-47>
<line-48> deq.append((nv,v))</line-48>
<line-49></line-49>
<line-50>node=node[::-1]</line-50>
<line-51></line-51>
<line-52>for i in range(N):</line-52>
<line-53> edge[i]=[nv for nv in edge[i] if nv!=parent[i]]</line-53>
<line-54></line-54>
<line-55>check=True</line-55>
<line-56>for i in range(N):</line-56>
<line-57> check&=(deg[i]<=0)</line-57>
<line-58>if check:</line-58>
<line-59> print((int(c[root]=="W")))</line-59>
<line-60> return</line-60>
<line-61></line-61>
<line-62>cond=[0]*N</line-62>
<line-63>for v in range(N):</line-63>
<line-64> if (deg[v]%2==1 and c[v]=="B") or (deg[v]%2==0 and c[v]=="W"):</line-64>
<line-65> cond[v]+=1</line-65>
<line-66> else:</line-66>
<line-67> cond[v]-=1</line-67>
<line-68></line-68>
<line-69>lower=[0]*N</line-69>
<line-70>for v in node:</line-70>
<line-71> res=0</line-71>
<line-72> for nv in edge[v]:</line-72>
<line-73> res=max(res,lower[nv])</line-73>
<line-74> res+=1+cond[v]</line-74>
<line-75> lower[v]=res</line-75>
<line-76></line-76>
<line-77>upper=[0]*N</line-77>
<line-78>node=node[::-1]</line-78>
<line-79>for v in node:</line-79>
<line-80> n=len(edge[v])</line-80>
<line-81> if n>1:</line-81>
<line-82> left=[0]*n</line-82>
<line-83> right=[0]*n</line-83>
<line-84> for i in range(n-1):</line-84>
<line-85> nv=edge[v][i]</line-85>
<line-86> left[i]=max(left[i-1],lower[nv]+2+cond[v])</line-86>
<line-87> nv=edge[v][-1]</line-87>
<line-88> upper[nv]=left[n-2]+cond[nv]</line-88>
<line-89> right[n-1]=lower[nv]+2+cond[v]</line-89>
<line-90> for i in range(n-2,0,-1):</line-90>
<line-91> nv=edge[v][i]</line-91>
<line-92> upper[nv]=max(left[i-1],right[i+1])+cond[nv]</line-92>
<line-93> right[i]=max(right[i+1],lower[nv]+2+cond[v])</line-93>
<line-94> if edge[v][0]!=pv:</line-94>
<line-95> nv=edge[v][0]</line-95>
<line-96> upper[nv]=right[1]+cond[nv]</line-96>
<line-97> if v!=root:</line-97>
<line-98> for nv in edge[v]:</line-98>
<line-99> upper[nv]=max(upper[nv],upper[v]+1+cond[nv])</line-99>
<line-100></line-100>
<line-101>base=sum(deg[i] for i in range(N))+sum(cond[i]==1 for i in range(N))</line-101>
<line-102>#print(deg)</line-102>
<line-103>#print(base)</line-103>
<line-104>#print(lower)</line-104>
<line-105>#print(upper)</line-105>
<line-107>print((base-max(max(upper),max(lower))))</line-107>
|
{"code": "<line-2>from collections import deque</line-2>\n<line-106>#print(base)</line-106>", "lines": [2, 106]}
#### 0
|
<line-1>import sys</line-1>
<line-3>n = int(input())</line-3>
<line-4>p = list(map(int, input().split()))</line-4>
<line-5>c = [[] for _ in range(n)]</line-5>
<line-6>is_leaf = [True for _ in range(n)]</line-6>
<line-7>for i in range(n):</line-7>
<line-8> p[i] -= 1</line-8>
<line-9> c[p[i]].append(i)</line-9>
<line-10> is_leaf[p[i]] = False</line-10>
<line-11></line-11>
<line-12>if sum(is_leaf) == 0:</line-12>
<line-13> if n%2 == 0:</line-13>
<line-14> print("POSSIBLE")</line-14>
<line-15> else:</line-15>
<line-16> print("IMPOSSIBLE")</line-16>
<line-17> return</line-17>
<line-18></line-18>
<line-19>for i in range(n):</line-19>
<line-20> if is_leaf[i]:</line-20>
<line-21> cur = i</line-21>
<line-22> break</line-22>
<line-23></line-23>
<line-24>visited_set = {cur}</line-24>
<line-25>visited_list = [cur]</line-25>
<line-26>while p[cur] not in visited_set:</line-26>
<line-27> visited_list.append(p[cur])</line-27>
<line-28> visited_set.add(p[cur])</line-28>
<line-29> cur = p[cur]</line-29>
<line-30></line-30>
<line-31>root = p[cur]</line-31>
<line-32></line-32>
<line-33>grundy = [-1 for _ in range(n)]</line-33>
<line-34>g_set = [set() for _ in range(n)]</line-34>
<line-35></line-35>
<line-36>def dfs(x):</line-36>
<line-37> res = 0</line-37>
<line-38> for v in c[x]:</line-38>
<line-39> dfs(v)</line-39>
<line-40> g_set[x].add(grundy[v])</line-40>
<line-41> while res in g_set[x]:</line-41>
<line-42> res += 1</line-42>
<line-43> grundy[x] = res</line-43>
<line-44> return res</line-44>
<line-45></line-45>
<line-46>loop = [False for _ in range(n)]</line-46>
<line-47>loop[root] = True</line-47>
<line-48>ind = len(visited_list)-1</line-48>
<line-49>while visited_list[ind] != root:</line-49>
<line-50> loop[visited_list[ind]] = True</line-50>
<line-51> ind -= 1</line-51>
<line-52>#print(loop)</line-52>
<line-53></line-53>
<line-54>for i in range(n):</line-54>
<line-55> if loop[i]:</line-55>
<line-56> for x in c[i]:</line-56>
<line-57> if not loop[x]:</line-57>
<line-58> dfs(x)</line-58>
<line-59> g_set[i].add(grundy[x])</line-59>
<line-60></line-60>
<line-61>cand = []</line-61>
<line-62>num = 0</line-62>
<line-63>while num in g_set[root]:</line-63>
<line-64> num += 1</line-64>
<line-65>cand.append(num)</line-65>
<line-66>num += 1</line-66>
<line-67>while num in g_set[root]:</line-67>
<line-68> num += 1</line-68>
<line-69>cand.append(num)</line-69>
<line-70></line-70>
<line-71>for x in cand:</line-71>
<line-72> cur = root</line-72>
<line-73> grundy[root] = x</line-73>
<line-74> while True:</line-74>
<line-75> num = 0</line-75>
<line-76> while num in g_set[p[cur]] or num == grundy[cur]:</line-76>
<line-77> num += 1</line-77>
<line-78> grundy[p[cur]] = num</line-78>
<line-79> if p[cur] == root:</line-79>
<line-80> break</line-80>
<line-81> cur = p[cur]</line-81>
<line-82> if grundy[root] == x:</line-82>
<line-83> #print(grundy)</line-83>
<line-84> print("POSSIBLE")</line-84>
<line-86></line-86>
<line-87>print("IMPOSSIBLE")</line-87>
|
{"code": "<line-2>sys.setrecursionlimit(10**6)</line-2>\n<line-85>\t\treturn</line-85>", "lines": [2, 85]}
#### 0
|
<line-1>from collections import deque</line-1>
<line-2></line-2>
<line-4>adj = [[1 for _ in range(N + 1)] for _ in range(N + 1)]</line-4>
<line-5>for _ in range(M):</line-5>
<line-6> a, b = list(map(int, input().split()))</line-6>
<line-7> adj[a][b] = 0</line-7>
<line-8> adj[b][a] = 0</line-8>
<line-9>adj_inv = [[] for _ in range(N + 1)]</line-9>
<line-10>for i in range(1, N+1):</line-10>
<line-11> for j in range(i+1, N+1):</line-11>
<line-12> if adj[i][j] == 1:</line-12>
<line-13> adj_inv[i].append(j)</line-13>
<line-14> adj_inv[j].append(i)</line-14>
<line-15></line-15>
<line-16>seen = [0] * (N+1)</line-16>
<line-17>num = []</line-17>
<line-18>for i in range(1, N+1):</line-18>
<line-19> if seen[i] == 0:</line-19>
<line-20> plus = 0</line-20>
<line-21> minus = 0</line-21>
<line-22> que = deque()</line-22>
<line-23> que.append(i)</line-23>
<line-24> seen[i] = 1</line-24>
<line-25> plus += 1</line-25>
<line-26> while que:</line-26>
<line-27> v = que.pop()</line-27>
<line-28> u_list = adj_inv[v]</line-28>
<line-29> for u in u_list:</line-29>
<line-30> if seen[u] == 0:</line-30>
<line-31> que.append(u)</line-31>
<line-32> seen[u] = -seen[v]</line-32>
<line-33> if seen[u] == 1:</line-33>
<line-34> plus += 1</line-34>
<line-35> else:</line-35>
<line-36> minus += 1</line-36>
<line-37> else:</line-37>
<line-38> if seen[u] == seen[v]:</line-38>
<line-39> print((-1))</line-39>
<line-40> return</line-40>
<line-41> num.append((min(plus, minus), max(plus, minus)))</line-41>
<line-42></line-42>
<line-43>min_sum = 0</line-43>
<line-44>add = []</line-44>
<line-45>for i in range(len(num)):</line-45>
<line-46> min_sum += num[i][0]</line-46>
<line-47> add.append(num[i][1] - num[i][0])</line-47>
<line-48></line-48>
<line-49>dp = [[0 for _ in range((N // 2) + 1)] for _ in range(len(add) + 1)]</line-49>
<line-50>dp[0][min_sum] = 1</line-50>
<line-51>for i in range(len(add)):</line-51>
<line-52> for j in range(min_sum, (N // 2) + 1):</line-52>
<line-53> if dp[i][j] == 1:</line-53>
<line-54> if j + add[i] <= (N // 2):</line-54>
<line-55> dp[i+1][j+add[i]] = 1</line-55>
<line-56> dp[i+1][j] = 1</line-56>
<line-57></line-57>
<line-58>dp_last = dp[-1]</line-58>
<line-59>for i in range(len(dp_last)-1, -1, -1):</line-59>
<line-60> if dp_last[i] == 1:</line-60>
<line-61> N1 = i</line-61>
<line-63></line-63>
<line-64>print(((N1 * (N1 - 1)) // 2 + ((N - N1) * (N - N1 - 1)) // 2))</line-64>
|
{"code": "<line-3>N, M = list(map(int, input().split()))</line-3>\n<line-62> break</line-62>", "lines": [3, 62]}
#### 0
|
<line-1># coding: utf-8</line-1>
<line-3>import sys</line-3>
<line-4>read = sys.stdin.read</line-4>
<line-5>readline = sys.stdin.readline</line-5>
<line-6></line-6>
<line-7>n,X,Y,Z = list(map(int,read().split()))</line-7>
<line-8></line-8>
<line-9>N = 1<<(X+Y+Z)</line-9>
<line-10>NX = 1<<X</line-10>
<line-11>NY = 1<<(X+Y)</line-11>
<line-12>NZ = 1<<(X+Y+Z)</line-12>
<line-13></line-13>
<line-14>MX = (1<<X) - 1</line-14>
<line-15>MY = (1<<(Y+X)) - (1<<X)</line-15>
<line-16>MZ = (1<<(X+Y+Z)) - (1<<(Y+X))</line-16>
<line-17></line-17>
<line-18>MMX = MX<<1</line-18>
<line-19>MMY = MY<<1</line-19>
<line-20>MMZ = MZ<<1</line-20>
<line-21></line-21>
<line-22>dp = [0]*N</line-22>
<line-23>dp[1] = 1</line-23>
<line-24></line-24>
<line-25>MOD = 10**9+7</line-25>
<line-26></line-26>
<line-27>for _ in range(n):</line-27>
<line-28> ndp = [0]*N</line-28>
<line-29> #cnt = 0</line-29>
<line-30> #bad = 0</line-30>
<line-31> for mask in range(N):</line-31>
<line-32> if dp[mask]==0: continue</line-32>
<line-33> mx = mask&MX</line-33>
<line-34> my = mask&MY</line-34>
<line-35> mz = mask&MZ</line-35>
<line-36> </line-36>
<line-37> for j in range(1,11):</line-37>
<line-38> nmx = mx << j</line-38>
<line-39> nmx &= MMX</line-39>
<line-40></line-40>
<line-41> nmy = my << j</line-41>
<line-42> nmy &= MMY</line-42>
<line-43></line-43>
<line-44> nmz = mz << j</line-44>
<line-45> nmz &= MMZ</line-45>
<line-46></line-46>
<line-47> nmask = nmx|nmy|nmz|1</line-47>
<line-48> if not nmask&(1<<(X+Y+Z)):</line-48>
<line-49> ndp[nmask] += dp[mask]</line-49>
<line-50> ndp[nmask] %= MOD</line-50>
<line-51></line-51>
<line-52> dp = ndp</line-52>
<line-53> #print(sum(dp),"sum")</line-53>
<line-54></line-54>
<line-56>print((ans%MOD))</line-56>
<line-57></line-57>
<line-58></line-58>
|
{"code": "<line-2># Your code here!</line-2>\n<line-55>ans = (pow(10,n,MOD)-sum(dp))</line-55>", "lines": [2, 55]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>class UnionFind(object):</line-4>
<line-5> def __init__(self, n):</line-5>
<line-6> self._par = list(range(n))</line-6>
<line-7> self.size = [1]*n</line-7>
<line-8></line-8>
<line-9> def root(self, v):</line-9>
<line-10> if self._par[v] == v:</line-10>
<line-11> return v</line-11>
<line-12> self._par[v] = self.root(self._par[v])</line-12>
<line-13> return self._par[v]</line-13>
<line-14> </line-14>
<line-15> def unite(self, u, v):</line-15>
<line-16> u, v = self.root(u), self.root(v)</line-16>
<line-17> if u==v:</line-17>
<line-18> return False</line-18>
<line-19> if self.size[u] > self.size[v]:</line-19>
<line-20> u, v = v, u</line-20>
<line-21> self.size[v] += self.size[u]</line-21>
<line-22> self._par[u] = v</line-22>
<line-23></line-23>
<line-24> def is_connected(self, u, v):</line-24>
<line-25> return self.root(u)==self.root(v)</line-25>
<line-26></line-26>
<line-27>n, m = map(int, readline().split())</line-27>
<line-28>P = list(map(lambda x:int(x)-1, readline().split()))</line-28>
<line-29>uf = UnionFind(n)</line-29>
<line-30>for _ in range(m):</line-30>
<line-31> x, y = map(lambda x:int(x)-1, readline().split())</line-31>
<line-32> uf.unite(x,y)</line-32>
<line-33></line-33>
<line-34>ans = 0</line-34>
<line-35>for i in range(n):</line-35>
<line-36> if uf.is_connected(i, P[i]):</line-36>
<line-38>print(ans)</line-38>
|
{"code": "<line-2>readline = sys.stdin.readline</line-2>\n<line-37> ans += 1</line-37>", "lines": [2, 37]}
#### 0
|
<line-1>#!/usr/bin/env python3</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> B = list(map(int, input().split()))</line-6>
<line-7> ans = 0</line-7>
<line-8> for k in range(30):</line-8>
<line-9> C = [x & ((1 << (k+1)) - 1) for x in A]</line-9>
<line-10> D = [x & ((1 << (k+1)) - 1) for x in B]</line-10>
<line-11> C.sort()</line-11>
<line-12> D.sort()</line-12>
<line-13> # print(f'k = {k}')</line-13>
<line-14> # print(f'C = {C}')</line-14>
<line-15> # print(f'D = {D}')</line-15>
<line-16> p, q, r = 0, 0, 0</line-16>
<line-17> for i in range(N-1, -1, -1):</line-17>
<line-18> while p < N:</line-18>
<line-19> if C[i] + D[p] >= 1 << k: break</line-19>
<line-20> p += 1</line-20>
<line-21> while q < N:</line-21>
<line-22> if C[i] + D[q] >= 2 << k: break</line-22>
<line-23> q += 1</line-23>
<line-24> while r < N:</line-24>
<line-25> if C[i] + D[r] >= 3 << k: break</line-25>
<line-26> r += 1</line-26>
<line-27> x = ((q - p) + (N - r)) % 2</line-27>
<line-28> # print(p, q, r, x)</line-28>
<line-29> ans = ans ^ (x << k)</line-29>
<line-31></line-31>
<line-32>main()</line-32>
|
{"code": "<line-3>def main():</line-3>\n<line-30> print(ans)</line-30>", "lines": [3, 30]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> n = int(input())</line-4>
<line-5> l = [int(x) for x in input().split()]</line-5>
<line-7> print("YES" if len(set(vals)) == n else "NO")</line-7>
|
{"code": "<line-3>for _ in range(t):</line-3>\n<line-6> vals = [(x + i) % n for i, x in enumerate(l)]</line-6>", "lines": [3, 6]}
#### 0
|
<line-1>n, r = [int(x) for x in input().split()]</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>xs = [int(x) for x in input().split()]</line-5>
<line-6></line-6>
<line-7>s = sum(xs)</line-7>
<line-8></line-8>
<line-9>res = [0 for _ in range(r+1)]</line-9>
<line-10>for i in range(r):</line-10>
<line-11> res[i] = s / n</line-11>
<line-12> i, val = [int(x) for x in input().split()]</line-12>
<line-13> s += val - xs[i]</line-13>
<line-14> xs[i] = val</line-14>
<line-16>print("\n".join(map(str, res)))</line-16>
|
{"code": "<line-3>n = 2 ** n</line-3>\n<line-15>res[r] = s / n</line-15>", "lines": [3, 15]}
#### 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>t = int(input())</line-6>
<line-7>for _ in range(t):</line-7>
<line-8> n, p = list(map(int, input().split()))</line-8>
<line-9> l = list(map(int, input().split()))</line-9>
<line-10> if p == 1:</line-10>
<line-11> print(n % 2)</line-11>
<line-12> else:</line-12>
<line-13> l.sort(reverse = True)</line-13>
<line-14> curr = l[0]</line-14>
<line-15> out = 0</line-15>
<line-16> real = True</line-16>
<line-17></line-17>
<line-18> for v in l:</line-18>
<line-19> if v < curr:</line-19>
<line-20> diff = curr - v</line-20>
<line-21> if 10 ** (7/diff) < p and out > 0:</line-21>
<line-22> real = False</line-22>
<line-23> out *= pow(p, diff, MOD)</line-23>
<line-24> if out > 10 ** 7:</line-24>
<line-25> real = False</line-25>
<line-26> out %= MOD</line-26>
<line-27></line-27>
<line-28> curr = v</line-28>
<line-29> if out > 0 or not real:</line-29>
<line-30> out -= 1</line-30>
<line-31> else:</line-31>
<line-32> out += 1</line-32>
<line-33> out %= MOD</line-33>
<line-34></line-34>
<line-36> print(out % MOD)</line-36>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-35> out *= pow(p, curr, MOD)</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>rnd_mod = 1234567890133</line-1>
<line-3>def rnd():</line-3>
<line-4> nonlocal rnd_x</line-4>
<line-5> rnd_x = rnd_x**2 % rnd_mod</line-5>
<line-6> return (rnd_x>>5) % (1<<20)</line-6>
<line-7>def randrange(a):</line-7>
<line-8> return rnd() % a</line-8>
<line-9></line-9>
<line-10>T = int(input())</line-10>
<line-11>for _ in range(T):</line-11>
<line-12> N, M = list(map(int, input().split()))</line-12>
<line-13> X = []</line-13>
<line-14> for __ in range(N):</line-14>
<line-15> X.append([int(a) for a in input().split()])</line-15>
<line-16> Y = [[X[i][j] for i in range(N)] for j in range(M)]</line-16>
<line-17> ma = 0</line-17>
<line-18> for t in range(577):</line-18>
<line-19> for i in range(M):</line-19>
<line-20> a = randrange(N)</line-20>
<line-21> Y[i] = [Y[i][j-a] for j in range(N)]</line-21>
<line-23> print(ma)</line-23>
|
{"code": "<line-2>rnd_x = 987654321098</line-2>\n<line-22> ma = max(ma, sum([max([Y[i][j] for i in range(M)]) for j in range(N)]))</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>import sys</line-1>
<line-2> </line-2>
<line-4></line-4>
<line-5>n, m, q = inp[0], inp[1], inp[2]</line-5>
<line-6></line-6>
<line-7>p = [inp[idx] for idx in range(3, n + 3)]</line-7>
<line-8></line-8>
<line-9>index_arr = [0] * (n + 1)</line-9>
<line-10>for i in range(n): index_arr[p[i]] = i</line-10>
<line-11></line-11>
<line-12>a = [inp[idx] for idx in range(n + 3, n + 3 + m)]</line-12>
<line-13></line-13>
<line-14>leftmost_pos = [m] * (n + 1)</line-14>
<line-15>next = [-1] * m</line-15>
<line-16></line-16>
<line-17>for i in range(m - 1, -1, -1):</line-17>
<line-18> index = index_arr[a[i]]</line-18>
<line-19> right_index = 0 if index == n - 1 else index + 1</line-19>
<line-20> right = p[right_index]</line-20>
<line-21> next[i] = leftmost_pos[right]</line-21>
<line-22> leftmost_pos[a[i]] = i</line-22>
<line-23> </line-23>
<line-24>log = 0</line-24>
<line-25>while (1 << log) <= n: log += 1</line-25>
<line-26>log += 1</line-26>
<line-27>dp = [[m for _ in range(m + 1)] for _ in range(log)]</line-27>
<line-28></line-28>
<line-29>for i in range(m):</line-29>
<line-30> dp[0][i] = next[i]</line-30>
<line-31></line-31>
<line-32>for j in range(1, log):</line-32>
<line-33> for i in range(m):</line-33>
<line-34> dp[j][i] = dp[j - 1][dp[j - 1][i]]</line-34>
<line-35></line-35>
<line-36>last = [0] * m</line-36>
<line-37>for i in range(m):</line-37>
<line-38> p = i</line-38>
<line-39> len = n - 1</line-39>
<line-40> for j in range(log - 1, -1, -1):</line-40>
<line-41> if (1 << j) <= len:</line-41>
<line-42> p = dp[j][p]</line-42>
<line-43> len -= (1 << j)</line-43>
<line-44> last[i] = p</line-44>
<line-45> </line-45>
<line-46>for i in range(m - 2, -1, -1):</line-46>
<line-47> last[i] = min(last[i], last[i + 1])</line-47>
<line-48> </line-48>
<line-49>inp_idx = n + m + 3</line-49>
<line-50>ans = []</line-50>
<line-51>for i in range(q):</line-51>
<line-52> l, r = inp[inp_idx] - 1, inp[inp_idx + 1] - 1</line-52>
<line-53> inp_idx += 2</line-53>
<line-54> if last[l] <= r:</line-54>
<line-55> ans.append('1')</line-55>
<line-56> else:</line-56>
<line-58>print(''.join(ans))</line-58>
|
{"code": "<line-3>inp = [int(x) for x in sys.stdin.read().split()]</line-3>\n<line-57>\t\tans.append('0')</line-57>", "lines": [3, 57]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>rows = [(int(x),int(y)) for x,y in rows]</line-3>
<line-4>points = {}</line-4>
<line-5>for x,y in rows:</line-5>
<line-6> if x in points:</line-6>
<line-7> points[x] = max(y, points[x])</line-7>
<line-8> else:</line-8>
<line-9> points[x] = y</line-9>
<line-10>points = sorted(points.items(),key=lambda point: point[0])</line-10>
<line-11></line-11>
<line-12></line-12>
<line-13>def above(p,p1,p2):</line-13>
<line-14> """</line-14>
<line-15> x1 < x2</line-15>
<line-16> y1 = x1^2 + bx1 + c</line-16>
<line-17> y2 = x2^2 + bx2 + c</line-17>
<line-18> y >? x^2 + bx + c</line-18>
<line-19></line-19>
<line-20> y2 - y1 = x2^2 - x1^2 + bx2 - bx1</line-20>
<line-21> b = (y2 - y1 - x2^2 + x1^2) / (x2 - x1)</line-21>
<line-22> b * (x2 - x1) = y2 - y1 - x2^2 + x1^2</line-22>
<line-23></line-23>
<line-24> c = y1 - x1^2 - bx1</line-24>
<line-25> c * (x2 - x1) = (y1 - x1^2) * (x2 - x1) - x1 * (y2 - y1 - x2^2 + x1^2)</line-25>
<line-26></line-26>
<line-27> y * (x2 - x1) >? (x^2 + bx + c) * (x2 - x1)</line-27>
<line-28> y * (x2 - x1) >?</line-28>
<line-29> x^2 * (x2 - x1)</line-29>
<line-30> + x * (y2 - y1 - x2^2 + x1^2)</line-30>
<line-31> + (y1 - x1^2) * (x2 - x1) - x1 * (y2 - y1 - x2^2 + x1^2)</line-31>
<line-32> """</line-32>
<line-33> x,y = p</line-33>
<line-34> x1,y1 = p1</line-34>
<line-35> x2,y2 = p2</line-35>
<line-36></line-36>
<line-37> x_2 = x**2</line-37>
<line-38> x12 = x1**2</line-38>
<line-39> x22 = x2**2</line-39>
<line-40> x2_x1 = x2 - x1</line-40>
<line-41> eq_b = y2 - y1 - x22 + x12</line-41>
<line-42></line-42>
<line-43> term_y = y * x2_x1</line-43>
<line-44> term_x2 = x_2 * x2_x1</line-44>
<line-45> term_x = x * eq_b</line-45>
<line-46> term_c = (y1 - x12) * x2_x1 - (x1 * eq_b)</line-46>
<line-47></line-47>
<line-48> return term_y >= term_x2 + term_x + term_c</line-48>
<line-49></line-49>
<line-50>#print(above(points[2],points[0],points[1]))</line-50>
<line-51></line-51>
<line-52></line-52>
<line-53>Us = []</line-53>
<line-54>for i, p in enumerate(points):</line-54>
<line-55> while len(Us) >= 2:</line-55>
<line-56> p1, p2 = Us[-2:]</line-56>
<line-57> if above(p,p1,p2):</line-57>
<line-58> Us.pop()</line-58>
<line-59> else:</line-59>
<line-60> break</line-60>
<line-61> Us.append(p)</line-61>
<line-62></line-62>
<line-64>print(out)</line-64>
|
{"code": "<line-2>rows = [input().split() for _ in range(n)]</line-2>\n<line-63>out = len(Us) - 1</line-63>", "lines": [2, 63]}
#### 0
|
<line-1>import os</line-1>
<line-3>from io import BytesIO, IOBase</line-3>
<line-4></line-4>
<line-5></line-5>
<line-6>def main():</line-6>
<line-7> pass</line-7>
<line-8></line-8>
<line-9></line-9>
<line-10># region fastio</line-10>
<line-11></line-11>
<line-12>BUFSIZE = 8192</line-12>
<line-13></line-13>
<line-14></line-14>
<line-15>class FastIO(IOBase):</line-15>
<line-16> newlines = 0</line-16>
<line-17></line-17>
<line-18> def __init__(self, file):</line-18>
<line-19> self._fd = file.fileno()</line-19>
<line-20> self.buffer = BytesIO()</line-20>
<line-21> self.writable = "x" in file.mode or "r" not in file.mode</line-21>
<line-22> self.write = self.buffer.write if self.writable else None</line-22>
<line-23></line-23>
<line-24> def read(self):</line-24>
<line-25> while True:</line-25>
<line-26> b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))</line-26>
<line-27> if not b:</line-27>
<line-28> break</line-28>
<line-29> ptr = self.buffer.tell()</line-29>
<line-30> self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)</line-30>
<line-31> self.newlines = 0</line-31>
<line-32> return self.buffer.read()</line-32>
<line-33></line-33>
<line-34> def readline(self):</line-34>
<line-35> while self.newlines == 0:</line-35>
<line-36> b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))</line-36>
<line-37> self.newlines = b.count(b"\n") + (not b)</line-37>
<line-38> ptr = self.buffer.tell()</line-38>
<line-39> self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)</line-39>
<line-40> self.newlines -= 1</line-40>
<line-41> return self.buffer.readline()</line-41>
<line-42></line-42>
<line-43> def flush(self):</line-43>
<line-44> if self.writable:</line-44>
<line-45> os.write(self._fd, self.buffer.getvalue())</line-45>
<line-46> self.buffer.truncate(0), self.buffer.seek(0)</line-46>
<line-47></line-47>
<line-48></line-48>
<line-49>class IOWrapper(IOBase):</line-49>
<line-50> def __init__(self, file):</line-50>
<line-51> self.buffer = FastIO(file)</line-51>
<line-52> self.flush = self.buffer.flush</line-52>
<line-53> self.writable = self.buffer.writable</line-53>
<line-54> self.write = lambda s: self.buffer.write(s.encode("ascii"))</line-54>
<line-55> self.read = lambda: self.buffer.read().decode("ascii")</line-55>
<line-56> self.readline = lambda: self.buffer.readline().decode("ascii")</line-56>
<line-57></line-57>
<line-58></line-58>
<line-59>sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)</line-59>
<line-60>input = lambda: sys.stdin.readline().rstrip("\r\n")</line-60>
<line-61></line-61>
<line-62>primes = []</line-62>
<line-63>prime = [True] * (10 ** 6 +5)</line-63>
<line-64>prime[0] = False</line-64>
<line-65></line-65>
<line-66>for i in range(2, 10 ** 6):</line-66>
<line-67> if prime[i]:</line-67>
<line-68> for j in range(2 * i, 10 ** 6 + 5, i):</line-68>
<line-69> prime[j] = False</line-69>
<line-70></line-70>
<line-71>pref = [0]</line-71>
<line-72>for i in range(1, 10 ** 6 + 5):</line-72>
<line-73> pref.append(pref[-1])</line-73>
<line-74> if prime[i]:</line-74>
<line-75> pref[-1] += 1</line-75>
<line-76> s = round(i ** .5)</line-76>
<line-77> if s * s == i and prime[s] and i != 1:</line-77>
<line-78> pref[-1] -= 1</line-78>
<line-79></line-79>
<line-80>n = int(input())</line-80>
<line-81>l = list(map(int, input().split()))</line-81>
<line-82>out = []</line-82>
<line-83>for v in l:</line-83>
<line-85>print('\n'.join(map(str,out)))</line-85>
|
{"code": "<line-2>import sys</line-2>\n<line-84> out.append(pref[v])</line-84>", "lines": [2, 84]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from itertools import accumulate</line-3>
<line-4>from collections import Counter</line-4>
<line-5>from bisect import bisect as br, bisect_left as bl</line-5>
<line-6>class PMS:</line-6>
<line-7> #1-indexed</line-7>
<line-8> def __init__(self, A, B, issum = False):</line-8>
<line-9> #Aに初期状態の要素をすべて入れる,Bは値域のリスト</line-9>
<line-10> self.X, self.comp = self.compress(B)</line-10>
<line-11> self.size = len(self.X)</line-11>
<line-12> self.tree = [0] * (self.size + 1)</line-12>
<line-13> self.p = 2**(self.size.bit_length() - 1)</line-13>
<line-14> self.dep = self.size.bit_length()</line-14>
<line-15> </line-15>
<line-16> CA = Counter(A)</line-16>
<line-17> S = [0] + list(accumulate([CA[self.X[i]] for i in range(self.size)]))</line-17>
<line-18> for i in range(1, 1+self.size):</line-18>
<line-19> self.tree[i] = S[i] - S[i - (i&-i)]</line-19>
<line-20> if issum:</line-20>
<line-21> self.sumtree = [0] * (self.size + 1)</line-21>
<line-22> Ssum = [0] + list(accumulate([CA[self.X[i]]*self.X[i] for i in range(self.size)]))</line-22>
<line-23> for i in range(1, 1+self.size):</line-23>
<line-24> self.sumtree[i] = Ssum[i] - Ssum[i - (i&-i)]</line-24>
<line-25> </line-25>
<line-26> def compress(self, L):</line-26>
<line-27> #座圧</line-27>
<line-28> L2 = list(set(L))</line-28>
<line-29> L2.sort()</line-29>
<line-30> C = {v : k for k, v in enumerate(L2, 1)}</line-30>
<line-31> # 1-indexed</line-31>
<line-32> return L2, C</line-32>
<line-33> </line-33>
<line-34> def leng(self):</line-34>
<line-35> #今入っている個数を取得</line-35>
<line-36> return self.count(self.X[-1])</line-36>
<line-37> </line-37>
<line-38> def count(self, v):</line-38>
<line-39> #v(Bの元)以下の個数を取得</line-39>
<line-40> i = self.comp[v]</line-40>
<line-41> s = 0</line-41>
<line-42> while i > 0:</line-42>
<line-43> s += self.tree[i]</line-43>
<line-44> i -= i & -i</line-44>
<line-45> return s</line-45>
<line-46> </line-46>
<line-47> def less(self, v):</line-47>
<line-48> #v(Bの元である必要はない)未満の個数を取得</line-48>
<line-49> i = bl(self.X, v)</line-49>
<line-50> s = 0</line-50>
<line-51> while i > 0:</line-51>
<line-52> s += self.tree[i]</line-52>
<line-53> i -= i & -i</line-53>
<line-54> return s</line-54>
<line-55> </line-55>
<line-56> def leq(self, v):</line-56>
<line-57> #v(Bの元である必要はない)以下の個数を取得</line-57>
<line-58> i = br(self.X, v)</line-58>
<line-59> s = 0</line-59>
<line-60> while i > 0:</line-60>
<line-61> s += self.tree[i]</line-61>
<line-62> i -= i & -i</line-62>
<line-63> return s</line-63>
<line-64> </line-64>
<line-65> def add(self, v, x):</line-65>
<line-66> #vをx個入れる,負のxで取り出す,iの個数以上取り出すとエラーを出さずにバグる</line-66>
<line-67> i = self.comp[v]</line-67>
<line-68> while i <= self.size:</line-68>
<line-69> self.tree[i] += x</line-69>
<line-70> i += i & -i</line-70>
<line-71></line-71>
<line-72> def get(self, i):</line-72>
<line-73> # i番目の値を取得</line-73>
<line-74> if i <= 0:</line-74>
<line-75> return -1</line-75>
<line-76> s = 0</line-76>
<line-77> k = self.p</line-77>
<line-78> for _ in range(self.dep):</line-78>
<line-79> if s + k <= self.size and self.tree[s+k] < i:</line-79>
<line-80> s += k</line-80>
<line-81> i -= self.tree[s]</line-81>
<line-82> k //= 2</line-82>
<line-83> return self.X[s]</line-83>
<line-84> </line-84>
<line-85> def gets(self, v):</line-85>
<line-86> #累積和がv以下となる最大のindexを返す</line-86>
<line-87> v1 = v</line-87>
<line-88> s = 0</line-88>
<line-89> k = self.p</line-89>
<line-90> for _ in range(self.dep):</line-90>
<line-91> if s + k <= self.size and self.sumtree[s+k] < v:</line-91>
<line-92> s += k</line-92>
<line-93> v -= self.sumtree[s]</line-93>
<line-94> k //= 2</line-94>
<line-95> if s == self.size:</line-95>
<line-96> return self.leng()</line-96>
<line-97> return self.count(self.X[s]) + (v1 - self.countsum(self.X[s]))//self.X[s]</line-97>
<line-98> </line-98>
<line-99> def addsum(self, i, x):</line-99>
<line-100> #sumを扱いたいときにaddの代わりに使う</line-100>
<line-101> self.add(i, x)</line-101>
<line-102> x *= i</line-102>
<line-103> i = self.comp[i]</line-103>
<line-104> while i <= self.size:</line-104>
<line-105> self.sumtree[i] += x</line-105>
<line-106> i += i & -i</line-106>
<line-107> </line-107>
<line-108> def countsum(self, v):</line-108>
<line-109> #v(Bの元)以下のsumを取得</line-109>
<line-110> i = self.comp[v]</line-110>
<line-111> s = 0</line-111>
<line-112> while i > 0:</line-112>
<line-113> s += self.sumtree[i]</line-113>
<line-114> i -= i & -i</line-114>
<line-115> return s</line-115>
<line-116> </line-116>
<line-117> def getsum(self, i):</line-117>
<line-118> #i番目までのsumを取得</line-118>
<line-119> x = self.get(i)</line-119>
<line-120> return self.countsum(x) - x*(self.count(x) - i)</line-120>
<line-121> </line-121>
<line-122>N, Q = map(int, readline().split())</line-122>
<line-123>P = list(map(int, readline().split()))</line-123>
<line-124>MOD = 998244353</line-124>
<line-125>T = [100*pow(pi, MOD-2, MOD)%MOD for pi in P]</line-125>
<line-126></line-126>
<line-127>AT = [None]*N</line-127>
<line-128>AT[0] = T[0]</line-128>
<line-129>for i in range(1, N):</line-129>
<line-130> AT[i] = (AT[i-1]+1)*T[i]%MOD</line-130>
<line-131>AM = [None]*N</line-131>
<line-132>AMi = [None]*N</line-132>
<line-133>AM[0] = T[0]</line-133>
<line-134>for i in range(1, N):</line-134>
<line-135> AM[i] = AM[i-1]*T[i]%MOD</line-135>
<line-136>AMi[N-1] = pow(AM[N-1], MOD-2, MOD)</line-136>
<line-137>for i in range(N-2, -1, -1):</line-137>
<line-138> AMi[i] = AMi[i+1]*T[i+1]%MOD</line-138>
<line-139>AT += [0]</line-139>
<line-140>AM += [1]</line-140>
<line-141>AMi += [1]</line-141>
<line-142></line-142>
<line-143>Ans = [None]*Q</line-143>
<line-144>kk = set([0, N])</line-144>
<line-145>PM = PMS([0, N], list(range(N+1)))</line-145>
<line-146>ans = AT[N-1]</line-146>
<line-147>for qu in range(Q):</line-147>
<line-148> f = int(readline()) - 1</line-148>
<line-149> if f not in kk:</line-149>
<line-150> kk.add(f)</line-150>
<line-151> PM.add(f, 1)</line-151>
<line-152> fidx = PM.count(f)</line-152>
<line-153> fm = PM.get(fidx-1)</line-153>
<line-154> fp = PM.get(fidx+1)</line-154>
<line-155> am = (AT[f-1] - AM[f-1]*AMi[fm-1]*AT[fm-1])%MOD</line-155>
<line-156> ap = (AT[fp-1] - AM[fp-1]*AMi[f-1]*AT[f-1])%MOD</line-156>
<line-157> aa = (AT[fp-1] - AM[fp-1]*AMi[fm-1]*AT[fm-1])%MOD</line-157>
<line-158> ans = (ans - aa + am + ap)%MOD</line-158>
<line-159> else:</line-159>
<line-160> kk.remove(f)</line-160>
<line-161> fidx = PM.count(f)</line-161>
<line-162> fm = PM.get(fidx-1)</line-162>
<line-163> fp = PM.get(fidx+1)</line-163>
<line-164> PM.add(f, -1)</line-164>
<line-165> am = (AT[f-1] - AM[f-1]*AMi[fm-1]*AT[fm-1])%MOD</line-165>
<line-166> ap = (AT[fp-1] - AM[fp-1]*AMi[f-1]*AT[f-1])%MOD</line-166>
<line-167> aa = (AT[fp-1] - AM[fp-1]*AMi[fm-1]*AT[fm-1])%MOD</line-167>
<line-168> ans = (ans + aa - am - ap)%MOD</line-168>
<line-170>print('\n'.join(map(str, Ans)))</line-170>
|
{"code": "<line-2>readline = sys.stdin.readline</line-2>\n<line-169> Ans[qu] = ans</line-169>", "lines": [2, 169]}
#### 0
|
<line-1>class BIT():</line-1>
<line-3> add: 区間[begin, end)にvalを加える</line-3>
<line-4> get_val: i番目(0-indexed)の値を求める</line-4>
<line-5> """</line-5>
<line-6> def __init__(self, n):</line-6>
<line-7> self.n = n</line-7>
<line-8> self.bit = [0] * (n + 1)</line-8>
<line-9></line-9>
<line-10> def get_val(self, i):</line-10>
<line-11> i = i + 1</line-11>
<line-12> s = 0</line-12>
<line-13> while i <= self.n:</line-13>
<line-14> s += self.bit[i]</line-14>
<line-15> i += i & -i</line-15>
<line-16> return s</line-16>
<line-17></line-17>
<line-18> def _add(self, i, val):</line-18>
<line-19> while i > 0:</line-19>
<line-20> self.bit[i] += val</line-20>
<line-21> i -= i & -i</line-21>
<line-22></line-22>
<line-23> def add(self, i, j, val):</line-23>
<line-24> self._add(j, val)</line-24>
<line-25> self._add(i, -val)</line-25>
<line-26></line-26>
<line-27></line-27>
<line-28>from collections import deque</line-28>
<line-29>import sys</line-29>
<line-30>input = sys.stdin.readline</line-30>
<line-31></line-31>
<line-32></line-32>
<line-33>def eular_tour(tree: list, root: int):</line-33>
<line-34> """頂点に対するオイラーツアーを行う</line-34>
<line-35> posの部分木に区間[begin[pos], end[pos])が対応する</line-35>
<line-36> """</line-36>
<line-37> n = len(tree)</line-37>
<line-38> res = []</line-38>
<line-39> begin = [-1] * n</line-39>
<line-40> end = [-1] * n</line-40>
<line-41> visited = [False] * n</line-41>
<line-42> visited[root] = True</line-42>
<line-43> q = deque([root])</line-43>
<line-44> while q:</line-44>
<line-45> pos = q.pop()</line-45>
<line-46> res.append(pos)</line-46>
<line-47> end[pos] = len(res)</line-47>
<line-48> if begin[pos] == -1:</line-48>
<line-49> begin[pos] = len(res) - 1</line-49>
<line-50> for next_pos in tree[pos]:</line-50>
<line-51> if visited[next_pos]:</line-51>
<line-52> continue</line-52>
<line-53> else:</line-53>
<line-54> visited[next_pos] = True</line-54>
<line-55> q.append(pos)</line-55>
<line-56> q.append(next_pos)</line-56>
<line-57></line-57>
<line-58> return res, begin, end</line-58>
<line-59></line-59>
<line-60>n, q = map(int, input().split())</line-60>
<line-61>init_cost = list(map(int, input().split()))</line-61>
<line-62>info = [list(map(int, input().split())) for i in range(n-1)]</line-62>
<line-63>query = [list(map(int, input().split())) for i in range(q)]</line-63>
<line-64></line-64>
<line-65>tree = [[] for i in range(n)]</line-65>
<line-66>for i in range(n-1):</line-66>
<line-67> a, b = info[i]</line-67>
<line-68> a -= 1</line-68>
<line-69> b -= 1</line-69>
<line-70> tree[a].append(b)</line-70>
<line-71> tree[b].append(a)</line-71>
<line-72></line-72>
<line-73>res, begin, end = eular_tour(tree, 0)</line-73>
<line-74>even_res = []</line-74>
<line-75>odd_res = []</line-75>
<line-76>for i in range(len(res)):</line-76>
<line-77> if i % 2 == 0:</line-77>
<line-78> even_res.append(res[i])</line-78>
<line-79> else:</line-79>
<line-80> odd_res.append(res[i])</line-80>
<line-81></line-81>
<line-82>even_bit = BIT(len(even_res))</line-82>
<line-83>odd_bit = BIT(len(odd_res))</line-83>
<line-84></line-84>
<line-85>for i in range(q):</line-85>
<line-86> if query[i][0] == 1:</line-86>
<line-87> _, pos, cost = query[i]</line-87>
<line-88> pos -= 1</line-88>
<line-89> if begin[pos] % 2 == 0:</line-89>
<line-90> even_bit.add(begin[pos] // 2, (end[pos] + 1) // 2, cost)</line-90>
<line-91> odd_bit.add(begin[pos] // 2, end[pos] // 2, -cost) </line-91>
<line-92> else:</line-92>
<line-93> odd_bit.add(begin[pos] // 2, end[pos] // 2, cost) </line-93>
<line-94> even_bit.add((begin[pos] + 1) // 2, end[pos] // 2, -cost) </line-94>
<line-95> else:</line-95>
<line-96> _, pos = query[i]</line-96>
<line-97> pos -= 1</line-97>
<line-98> if begin[pos] % 2 == 0:</line-98>
<line-99> ans = even_bit.get_val(begin[pos] // 2)</line-99>
<line-100> else:</line-100>
<line-102> print(ans + init_cost[pos])</line-102>
|
{"code": "<line-2> \"\"\"区間加算、一点取得クエリをそれぞれO(logN)で応えるデータ構造を構築する</line-2>\n<line-101> ans = odd_bit.get_val(begin[pos] // 2)</line-101>", "lines": [2, 101]}
#### 0
|
<line-1>n =int(input())</line-1>
<line-3>h=[]</line-3>
<line-4>c=[]</line-4>
<line-5>cntw={}</line-5>
<line-6>cnth={}</line-6>
<line-7>gcdC=0</line-7>
<line-8>cntC=0</line-8>
<line-9>def insert1(a,b,c):</line-9>
<line-10> if not a in b :</line-10>
<line-11> b[a]=c</line-11>
<line-12> else :</line-12>
<line-13> b[a]=b[a]+c</line-13>
<line-14></line-14>
<line-15>def gcd(a,b): </line-15>
<line-16> if a % b == 0 :</line-16>
<line-17> return b</line-17>
<line-18> else :</line-18>
<line-19> return gcd(b,a%b)</line-19>
<line-20></line-20>
<line-21>for i in range(0, n):</line-21>
<line-22> a,b,d = map(int,input().split())</line-22>
<line-23> w.append(a)</line-23>
<line-24> h.append(b)</line-24>
<line-25> c.append(d)</line-25>
<line-26> insert1(a,cntw,d)</line-26>
<line-27> insert1(b,cnth,d)</line-27>
<line-28> cntC += d</line-28>
<line-29> if gcdC == 0 :</line-29>
<line-30> gcdC = d</line-30>
<line-31> else :</line-31>
<line-32> gcdC = gcd(gcdC, d)</line-32>
<line-33></line-33>
<line-34>for i in range(0, n):</line-34>
<line-35> if cntw[w[i]] * cnth[h[i]] != cntC * c[i]:</line-35>
<line-36> print (0)</line-36>
<line-37> return</line-37>
<line-38></line-38>
<line-39>ans = 0</line-39>
<line-40>i = 1</line-40>
<line-41>while (i * i <= gcdC) :</line-41>
<line-42> if gcdC % i == 0 :</line-42>
<line-43> ans += 1</line-43>
<line-44> if i * i != gcdC :</line-44>
<line-45> ans += 1</line-45>
<line-47></line-47>
<line-48>print (ans)</line-48>
|
{"code": "<line-2>w=[]</line-2>\n<line-46>\ti += 1</line-46>", "lines": [2, 46]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-3>def NC_Dij(lis,start):</line-3>
<line-4></line-4>
<line-5> ret = [float("inf")] * len(lis)</line-5>
<line-6> ret[start] = 0</line-6>
<line-7> </line-7>
<line-8> q = deque([start])</line-8>
<line-9> plis = [i for i in range(len(lis))]</line-9>
<line-10></line-10>
<line-11> while len(q) > 0:</line-11>
<line-12> now = q.popleft()</line-12>
<line-13></line-13>
<line-14> for nex in lis[now]:</line-14>
<line-15></line-15>
<line-16> if ret[nex] > ret[now] + 1:</line-16>
<line-17> ret[nex] = ret[now] + 1</line-17>
<line-18> plis[nex] = now</line-18>
<line-19> q.append(nex)</line-19>
<line-20></line-20>
<line-21> return ret,plis</line-21>
<line-22></line-22>
<line-23>tt = int(stdin.readline())</line-23>
<line-24></line-24>
<line-25>for loop in range(tt):</line-25>
<line-26></line-26>
<line-27> n,a,b,da,db = list(map(int,stdin.readline().split()))</line-27>
<line-28> N = n</line-28>
<line-29> a -= 1</line-29>
<line-30> b -= 1</line-30>
<line-31> lis = [ [] for i in range(n)]</line-31>
<line-32></line-32>
<line-33> for i in range(n-1):</line-33>
<line-34> u,v = list(map(int,stdin.readline().split()))</line-34>
<line-35> u -= 1</line-35>
<line-36> v -= 1</line-36>
<line-37> lis[u].append(v)</line-37>
<line-38> lis[v].append(u)</line-38>
<line-39></line-39>
<line-40> if 2*da >= db:</line-40>
<line-41> print ("Alice")</line-41>
<line-42> continue</line-42>
<line-43></line-43>
<line-44> fa,tmp = NC_Dij(lis,a)</line-44>
<line-45> if fa[b] <= da:</line-45>
<line-46> print ("Alice")</line-46>
<line-47> continue</line-47>
<line-48></line-48>
<line-49> mv = 0</line-49>
<line-50> for i in range(N):</line-50>
<line-51> if fa[i] > fa[mv]:</line-51>
<line-52> mv = i</line-52>
<line-53></line-53>
<line-54> fv,tmp = NC_Dij(lis,mv)</line-54>
<line-55> if max(fv) <= 2*da:</line-55>
<line-56> print ("Alice")</line-56>
<line-58> print ("Bob")</line-58>
<line-59> </line-59>
|
{"code": "<line-2>from collections import deque</line-2>\n<line-57> else:</line-57>", "lines": [2, 57]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>S = list([ord(x)-97 for x in readline().strip()])</line-4>
<line-5>N = len(S)</line-5>
<line-6>table = [[0]*26 for _ in range(N)]</line-6>
<line-7>for i in range(N):</line-7>
<line-8> table[i][S[i]] = 1</line-8>
<line-9>for i in range(1, N):</line-9>
<line-10> for j in range(26):</line-10>
<line-11> table[i][j] += table[i-1][j]</line-11>
<line-12></line-12>
<line-13>Q = int(readline())</line-13>
<line-14>Ans = [None]*Q</line-14>
<line-15>for qu in range(Q):</line-15>
<line-16> l, r = list(map(int, readline().split()))</line-16>
<line-17> l -= 1</line-17>
<line-18> r -= 1 </line-18>
<line-19> if l == r or S[l] != S[r]:</line-19>
<line-20> Ans[qu] = True</line-20>
<line-21> continue</line-21>
<line-22> K = [table[r][j] - table[l][j] for j in range(26)]</line-22>
<line-23> if len([k for k in K if k]) <= 2:</line-23>
<line-24> Ans[qu] = False</line-24>
<line-25> else:</line-25>
<line-27>print('\n'.join(['Yes' if s else 'No' for s in Ans]))</line-27>
|
{"code": "<line-2>readline = sys.stdin.readline</line-2>\n<line-26> Ans[qu] = True</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>for __ in range(int(input())):</line-1>
<line-3> s = list(map(int, input()))</line-3>
<line-4> r = [0] * n</line-4>
<line-5> for i in range(10):</line-5>
<line-6> left_lim = 0</line-6>
<line-7> for j, c in enumerate(s):</line-7>
<line-8> if c < i: left_lim = j + 1</line-8>
<line-9> prv = [-1, -1, -1]</line-9>
<line-10> flg = True</line-10>
<line-11> for j, c in enumerate(s):</line-11>
<line-12> r[j] = 1 if c < i or (c == i and j >= left_lim) else 2</line-12>
<line-13> if c < prv[r[j]]: flg = False; break</line-13>
<line-14> prv[r[j]] = c</line-14>
<line-15> if flg:</line-15>
<line-16> print(''.join(map(str, r)))</line-16>
<line-17> break</line-17>
<line-19> print('-')</line-19>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-18> if not flg:</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>k,n = map(int,input().split())</line-1>
<line-3> ans = []</line-3>
<line-4> ans.append(k//2)</line-4>
<line-5> for i in range(n-1):</line-5>
<line-6> ans.append(k)</line-6>
<line-7> print(*ans)</line-7>
<line-8>else:</line-8>
<line-9> ans = []</line-9>
<line-10> for i in range(n):</line-10>
<line-11> ans.append(k//2+1)</line-11>
<line-12> sage = (n)//2</line-12>
<line-13> for i in range(sage):</line-13>
<line-14> if ans[-1] == 1:</line-14>
<line-15> ans.pop()</line-15>
<line-16> else:</line-16>
<line-17> ans[-1] -= 1</line-17>
<line-18> while len(ans) < n:</line-18>
<line-20> print(*ans)</line-20>
|
{"code": "<line-2>if k %2 ==0:</line-2>\n<line-19> ans.append(k)</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>from collections import deque</line-4>
<line-5>N = int(input())</line-5>
<line-6>X = [[] for i in range(N)]</line-6>
<line-7>for i in range(N-1):</line-7>
<line-8> x, y = map(int, input().split())</line-8>
<line-9> X[x-1].append(y-1)</line-9>
<line-10> X[y-1].append(x-1)</line-10>
<line-11></line-11>
<line-12>Y = [(-10**9, 10**9) for _ in range(N)]</line-12>
<line-13>K = int(input())</line-13>
<line-14>for _ in range(K):</line-14>
<line-15> v, p = map(int, input().split())</line-15>
<line-16> Y[v-1] = (p, p)</line-16>
<line-17></line-17>
<line-18>P = [-1] * N</line-18>
<line-19>Q = deque([0])</line-19>
<line-20>R = []</line-20>
<line-21>while Q:</line-21>
<line-22> i = deque.popleft(Q)</line-22>
<line-23> R.append(i)</line-23>
<line-24> for a in X[i]:</line-24>
<line-25> if a != P[i]:</line-25>
<line-26> P[a] = i</line-26>
<line-27> X[a].remove(i)</line-27>
<line-28> deque.append(Q, a)</line-28>
<line-29></line-29>
<line-30></line-30>
<line-31>def calc():</line-31>
<line-32> for i in R[::-1]:</line-32>
<line-33> e, o = 0, 0</line-33>
<line-34> l, r = Y[i]</line-34>
<line-35> if r != 10 ** 9:</line-35>
<line-36> if l % 2:</line-36>
<line-37> o = 1</line-37>
<line-38> else:</line-38>
<line-39> e = 1</line-39>
<line-40> for j in X[i]:</line-40>
<line-41> a, b = Y[j]</line-41>
<line-42> if b == 10**9: continue</line-42>
<line-43> if a % 2:</line-43>
<line-44> e = 1</line-44>
<line-45> else:</line-45>
<line-46> o = 1</line-46>
<line-47> l = max(l, a - 1)</line-47>
<line-48> r = min(r, b + 1)</line-48>
<line-49> if (e and o) or (l > r):</line-49>
<line-50> print("No")</line-50>
<line-51> return 0</line-51>
<line-52> elif e or o:</line-52>
<line-53> Y[i] = (l, r)</line-53>
<line-54> </line-54>
<line-55> for i in R[1:]:</line-55>
<line-56> if Y[P[i]][0] - 1 >= Y[i][0]:</line-56>
<line-57> Y[i] = (Y[P[i]][0] - 1, 0)</line-57>
<line-58> else:</line-58>
<line-59> Y[i] = (Y[P[i]][0] + 1, 0)</line-59>
<line-60> </line-60>
<line-61> print("Yes")</line-61>
<line-62> for i in range(N):</line-62>
<line-64></line-64>
<line-65>calc()</line-65>
|
{"code": "<line-2>input = lambda: sys.stdin.readline().rstrip()</line-2>\n<line-63> print(Y[i][0])</line-63>", "lines": [2, 63]}
#### 0
|
<line-1>import bisect</line-1>
<line-3></line-3>
<line-4>X = int(input())</line-4>
<line-5>K = int(input())</line-5>
<line-6>r = [0] + inpl()</line-6>
<line-7>stu = [()]*(K+1)</line-7>
<line-8>stu[0] = (X, 0, 0)</line-8>
<line-9>for i, v in enumerate(r[1:], 1):</line-9>
<line-10> s, t, u = stu[i-1]</line-10>
<line-11> if i%2:</line-11>
<line-12> rs = r[i-1] - r[i]</line-12>
<line-13> ap = - rs - t</line-13>
<line-14> if ap >= s:</line-14>
<line-15> stu[i] = 0, 0, 0</line-15>
<line-16> elif ap >= u:</line-16>
<line-17> stu[i] = s, t+rs, ap</line-17>
<line-18> else:</line-18>
<line-19> stu[i] = s, t+rs, u</line-19>
<line-20> else:</line-20>
<line-21> rs = r[i] - r[i-1]</line-21>
<line-22> ap = X - rs - t</line-22>
<line-23> if ap >= s:</line-23>
<line-24> stu[i] = s, t+rs, u</line-24>
<line-25> elif ap >= u:</line-25>
<line-26> stu[i] = ap, t+rs, u</line-26>
<line-27> else:</line-27>
<line-28> stu[i] = X, 0, X</line-28>
<line-29>Q = int(input())</line-29>
<line-30>for _ in range(Q):</line-30>
<line-31> ti, a = inpl()</line-31>
<line-32> x = bisect.bisect_right(r, ti)</line-32>
<line-33> ti -= r[x-1]</line-33>
<line-34> s, t, u = stu[x-1]</line-34>
<line-35> if a >= s:</line-35>
<line-36> R = s + t</line-36>
<line-37> elif a >= u:</line-37>
<line-38> R = a + t</line-38>
<line-39> else:</line-39>
<line-40> R = u + t</line-40>
<line-41> if x % 2:</line-41>
<line-42> print(max(0, R - ti))</line-42>
<line-44> print(min(X, R + ti))</line-44>
|
{"code": "<line-2>def inpl(): return [int(i) for i in input().split()]</line-2>\n<line-43> else:</line-43>", "lines": [2, 43]}
#### 0
|
<line-1>A = [ord(a)-97 for a in input()]</line-1>
<line-3>X = [0] * 26</line-3>
<line-4>Y = [0] * (N + 2)</line-4>
<line-5>NE = [0] * N</line-5>
<line-6>R = [N] * 26</line-6>
<line-7>s = 0</line-7>
<line-8>t = 1</line-8>
<line-9>for i in range(N)[::-1]:</line-9>
<line-10> a = A[i]</line-10>
<line-11> if X[a] == 0:</line-11>
<line-12> X[a] = 1</line-12>
<line-13> s += 1</line-13>
<line-14> if s == 26:</line-14>
<line-15> s = 0</line-15>
<line-16> X = [0] * 26</line-16>
<line-17> t += 1</line-17>
<line-18> Y[i] = t</line-18>
<line-19> NE[i] = R[a]</line-19>
<line-20> R[a] = i</line-20>
<line-21></line-21>
<line-22>ANS = []</line-22>
<line-23>ii = 0</line-23>
<line-24>for i, a in enumerate(A):</line-24>
<line-25> if i == ii:</line-25>
<line-26> for j in range(26):</line-26>
<line-27> if Y[R[j]+1] < Y[i]:</line-27>
<line-28> ANS.append(j)</line-28>
<line-29> ii = R[j]+1</line-29>
<line-30> break</line-30>
<line-32></line-32>
<line-33>print("".join([chr(a+97) for a in ANS]))</line-33>
|
{"code": "<line-2>N = len(A)</line-2>\n<line-31> R[a] = NE[i]</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>import sys</line-1>
<line-3> return sys.stdin.readline()[:-1]</line-3>
<line-4></line-4>
<line-5>H, W = map(int, input().split())</line-5>
<line-6>s = [input() for _ in range(H)]</line-6>
<line-7>ans = max(H, W)</line-7>
<line-8></line-8>
<line-9>def max_rect(a):</line-9>
<line-10> res = 0</line-10>
<line-11> stack = [a[0]]</line-11>
<line-12> for i in range(1, W-1):</line-12>
<line-13> new_pos = i</line-13>
<line-14> while stack and stack[-1] % 10000 >= a[i]:</line-14>
<line-15> pos, hght = stack[-1] // 10000, stack[-1] % 10000</line-15>
<line-16> res = max(res, (i - pos + 1) * (hght + 1))</line-16>
<line-17> new_pos = pos</line-17>
<line-18> stack.pop()</line-18>
<line-19> stack.append(new_pos * 10000 + a[i])</line-19>
<line-20> while stack:</line-20>
<line-21> pos, hght = stack[-1] // 10000, stack[-1] % 10000</line-21>
<line-22> res = max(res, (W - pos) * (hght + 1))</line-22>
<line-23> stack.pop()</line-23>
<line-24> return res</line-24>
<line-25></line-25>
<line-26>dp = [[0 for _ in range(W-1)] for _ in range(H-1)]</line-26>
<line-27></line-27>
<line-28>for j in range(W-1):</line-28>
<line-29> if not ((s[0][j] == s[1][j]) ^ (s[0][j+1] == s[1][j+1])):</line-29>
<line-30> dp[0][j] = 1</line-30>
<line-31>ans = max(ans, max_rect(dp[0]))</line-31>
<line-32></line-32>
<line-33>for i in range(1, H-1):</line-33>
<line-34> for j in range(W-1):</line-34>
<line-35> if not ((s[i][j] == s[i+1][j]) ^ (s[i][j+1] == s[i+1][j+1])):</line-35>
<line-36> dp[i][j] = dp[i-1][j] + 1</line-36>
<line-38></line-38>
<line-39>print(ans)</line-39>
|
{"code": "<line-2>def input():</line-2>\n<line-37>\tans = max(ans, max_rect(dp[i]))</line-37>", "lines": [2, 37]}
#### 0
|
<line-1>from collections import defaultdict</line-1>
<line-3>C = defaultdict(int)</line-3>
<line-4>for i in range(N):</line-4>
<line-5> D = int(input())</line-5>
<line-6> C[D] = i + 1</line-6>
<line-7>E = []</line-7>
<line-8>H = [1] * (N + 1)</line-8>
<line-9>DD = sorted([[k, v] for k, v in C.items()], reverse=True)</line-9>
<line-10>Adj = [[] for i in range(N)]</line-10>
<line-11>for D, n in DD[:-1]:</line-11>
<line-12> try:</line-12>
<line-13> p = C[D - N + 2 * H[n]]</line-13>
<line-14> if n == p:</line-14>
<line-15> raise Error</line-15>
<line-16> E.append([n, p])</line-16>
<line-17> Adj[n - 1].append(p - 1)</line-17>
<line-18> Adj[p - 1].append(n - 1)</line-18>
<line-19> H[p] += H[n]</line-19>
<line-20> except:</line-20>
<line-21> print(-1)</line-21>
<line-22> break</line-22>
<line-23>else:</line-23>
<line-24> dist = [N] * N</line-24>
<line-25> dist[DD[-1][1] - 1] = 0</line-25>
<line-26> Q = [DD[-1][1] - 1] + [N] * N</line-26>
<line-27> tail = 1</line-27>
<line-28> for i in range(N):</line-28>
<line-29> s = Q[i]</line-29>
<line-30> if s == N:</line-30>
<line-31> print(-1)</line-31>
<line-32> break</line-32>
<line-33> for adj in Adj[s]:</line-33>
<line-34> if dist[adj] == N:</line-34>
<line-35> dist[adj] = dist[s] + 1</line-35>
<line-36> Q[tail] = adj</line-36>
<line-37> tail += 1</line-37>
<line-38> else:</line-38>
<line-39> if sum(dist) == DD[-1][0]:</line-39>
<line-40> for e in E:</line-40>
<line-41> print(e[0], e[1])</line-41>
<line-43> print(-1)</line-43>
|
{"code": "<line-2>N = int(input())</line-2>\n<line-42> else:</line-42>", "lines": [2, 42]}
#### 0
|
<line-1>w=list(input());n=len(w);t=-1</line-1>
<line-3> m=len(s);z=[0]*m;c=0;f=[1]*m;</line-3>
<line-4> for i in range(1,m):</line-4>
<line-5> if i+z[i-c]<c+z[c]:z[i]=z[i-c]</line-5>
<line-6> else:</line-6>
<line-7> j=max(0,c+z[c]-i)</line-7>
<line-8> while i+j<n and s[j]==s[i+j]:j=j+1</line-8>
<line-9> z[i]=j;c=i</line-9>
<line-10> for p in range(1,m):</line-10>
<line-11> for k in range(2,z[p]//p+2):f[k*p-1]=0</line-11>
<line-12> return f</line-12>
<line-13>for j in range(1,n//2+1):</line-13>
<line-14> if n%j==0 and w[:n-j]==w[j:]:t=j;break;</line-14>
<line-15>if t==-1:print ('1\n1')</line-15>
<line-16>elif t==1:print (n);print((1))</line-16>
<line-17>else:</line-17>
<line-18> zl=Z(w)</line-18>
<line-19> w.reverse()</line-19>
<line-20> zr=Z(w)</line-20>
<line-21> cnt=0</line-21>
<line-22> for i in range(0,n-1):</line-22>
<line-24> print((2));print(cnt);</line-24>
|
{"code": "<line-2>def Z(s):</line-2>\n<line-23> if zl[i] and zr[n-2-i]:cnt=cnt+1</line-23>", "lines": [2, 23]}
#### 0
|
<line-2>a=[[0,int(s)]for s in input().split()]</line-2>
<line-3>while j>1:j>>=1;a=[sorted(a[i]+a[i^j]*(i&j>0))[-2:]for i in range(n)]</line-3>
<line-4>for s,f in a[1:]:j=max(j,s+f);print(j)</line-4>
|
{"code": "<line-1>j=n=1<<int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>import sys</line-1>
<line-3> return sys.stdin.readline()[:-1]</line-3>
<line-4></line-4>
<line-5>n = int(input())</line-5>
<line-6>d = []</line-6>
<line-7>M, m = 0, 10**30</line-7>
<line-8>M_of_m, m_of_M = 0, 10**30</line-8>
<line-9>for _ in range(n):</line-9>
<line-10> x, y = map(int, input().split())</line-10>
<line-11> g, l = max(x, y), min(x, y)</line-11>
<line-12> d.append([l, g])</line-12>
<line-13> M = max(M, g)</line-13>
<line-14> m = min(m, l)</line-14>
<line-15> M_of_m = max(M_of_m, l)</line-15>
<line-16> m_of_M = min(m_of_M, g)</line-16>
<line-17>ans1 = (M - m_of_M) * (M_of_m - m)</line-17>
<line-18></line-18>
<line-19>M_other, m_other = M_of_m, m</line-19>
<line-20>m_reversed = 10**30</line-20>
<line-21>gap = M_other - m_other</line-21>
<line-22>d.sort(key=min)</line-22>
<line-23>for i in range(n-1):</line-23>
<line-24> M_other = max(M_other, d[i][1])</line-24>
<line-25> m_reversed = min(m_reversed, d[i][1])</line-25>
<line-26> m_other = min(m_reversed, d[i+1][0])</line-26>
<line-27> gap = min(gap, M_other - m_other)</line-27>
<line-28>M_other = max(M_other, d[n-1][1])</line-28>
<line-29>m_reversed = min(m_reversed, d[i][1])</line-29>
<line-30>gap = min(gap, M_other - m_reversed)</line-30>
<line-31>ans2 = (M - m) * gap</line-31>
<line-32></line-32>
<line-34>print(min(ans1, ans2))</line-34>
|
{"code": "<line-2>def input():</line-2>\n<line-33>#print(ans1, ans2)</line-33>", "lines": [2, 33]}
#### 0
|
<line-1>#from collections import deque,defaultdict</line-1>
<line-3>inn = lambda : int(input())</line-3>
<line-4>inl = lambda: list(map(int, input().split()))</line-4>
<line-5>inm = lambda: map(int, input().split())</line-5>
<line-6>ins = lambda : input().strip()</line-6>
<line-7>DBG = True # and False</line-7>
<line-8>BIG = 10**18</line-8>
<line-9>R = 10**9 + 7</line-9>
<line-10>#R = 998244353</line-10>
<line-11></line-11>
<line-12>def ddprint(x):</line-12>
<line-13> if DBG:</line-13>
<line-14> print(x)</line-14>
<line-15></line-15>
<line-16>n = inn()</line-16>
<line-17>a = []</line-17>
<line-18>b = []</line-18>
<line-19>xb = 10**9+1</line-19>
<line-20>for i in range(n):</line-20>
<line-21> aa,bb = inm()</line-21>
<line-22> a.append(aa)</line-22>
<line-23> b.append(bb)</line-23>
<line-24> if aa>bb and xb>bb:</line-24>
<line-25> xb = bb</line-25>
<line-26> xi = i</line-26>
<line-27>if n==-2 and a[0]==1:</line-27>
<line-29>print(0 if xb>10**9 else sum(a)-b[xi])</line-29>
|
{"code": "<line-2>printn = lambda x: print(x,end='')</line-2>\n<line-28> 3/0</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>import collections</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5> def __init__(self, l):</line-5>
<line-6> self.size = l</line-6>
<line-7> self.bit = [0] * (self.size+1)</line-7>
<line-8></line-8>
<line-9> def sum(self, i):</line-9>
<line-10> s = 0</line-10>
<line-11> while i > 0:</line-11>
<line-12> s += self.bit[i]</line-12>
<line-13> i -= i & -i</line-13>
<line-14> return s</line-14>
<line-15></line-15>
<line-16> def add(self, i, x):</line-16>
<line-17> while i <= self.size:</line-17>
<line-18> self.bit[i] += x</line-18>
<line-19> i += i & -i</line-19>
<line-20></line-20>
<line-21> def __str__(self):</line-21>
<line-22> return str(self.bit)</line-22>
<line-23></line-23>
<line-24></line-24>
<line-25>S = str(input())</line-25>
<line-26>N = len(S)</line-26>
<line-27>index = collections.defaultdict(list)</line-27>
<line-28></line-28>
<line-29>for i, c in enumerate(S):</line-29>
<line-30> index[c].append(i)</line-30>
<line-31></line-31>
<line-32>ctr = N // 2</line-32>
<line-33>B = [0] * N</line-33>
<line-34>flag = 0</line-34>
<line-35>P = []</line-35>
<line-36></line-36>
<line-37>for c, k in list(index.items()):</line-37>
<line-38> cnt = len(k)</line-38>
<line-39> if cnt % 2:</line-39>
<line-40> if flag == 1:</line-40>
<line-41> print((-1))</line-41>
<line-42> return</line-42>
<line-43> flag = 1</line-43>
<line-44> B[k[cnt // 2]] = ctr + 1</line-44>
<line-45> for i in range(cnt // 2):</line-45>
<line-46> l, r = k[i], k[-(i+1)]</line-46>
<line-47> P.append((l, r))</line-47>
<line-48></line-48>
<line-49>P.sort()</line-49>
<line-50></line-50>
<line-51>for i, (l, r) in enumerate(P):</line-51>
<line-52> B[l], B[r] = i + 1, N - i</line-52>
<line-53></line-53>
<line-54>ans = 0</line-54>
<line-55>bit = Bit(N)</line-55>
<line-56>for i, b in enumerate(B):</line-56>
<line-57> ans += i - bit.sum(b)</line-57>
<line-59></line-59>
<line-60>print(ans)</line-60>
|
{"code": "<line-4>class Bit():</line-4>\n<line-58> bit.add(b, 1)</line-58>", "lines": [4, 58]}
#### 0
|
<line-1>class dsu:</line-1>
<line-3> self._n = n</line-3>
<line-4> self.parent_or_size = [-1] * n</line-4>
<line-5> </line-5>
<line-6> def merge(self, a: int, b: int) -> int:</line-6>
<line-7> x = self.leader(a)</line-7>
<line-8> y = self.leader(b)</line-8>
<line-9> if x == y:</line-9>
<line-10> return x</line-10>
<line-11> if self.parent_or_size[x] > self.parent_or_size[y]:</line-11>
<line-12> x, y = y, x</line-12>
<line-13> self.parent_or_size[x] += self.parent_or_size[y]</line-13>
<line-14> self.parent_or_size[y] = x</line-14>
<line-15> return x</line-15>
<line-16> </line-16>
<line-17> def same(self, a: int, b: int) -> bool:</line-17>
<line-18> return self.leader(a) == self.leader(b)</line-18>
<line-19> </line-19>
<line-20> def leader(self, a: int) -> int:</line-20>
<line-21> x = a</line-21>
<line-22> while self.parent_or_size[x] >= 0:</line-22>
<line-23> x = self.parent_or_size[x]</line-23>
<line-24> while a != x:</line-24>
<line-25> self.parent_or_size[a], a = x, self.parent_or_size[a]</line-25>
<line-26> return x</line-26>
<line-27> </line-27>
<line-28> def size(self, a: int) -> int:</line-28>
<line-29> return -self.parent_or_size[self.leader(a)]</line-29>
<line-30> </line-30>
<line-31> def groups(self):</line-31>
<line-32> g = [[] for _ in range(self._n)]</line-32>
<line-33> for i in range(self._n):</line-33>
<line-34> g[self.leader(i)].append(i)</line-34>
<line-35> return list(c for c in g if c)</line-35>
<line-36></line-36>
<line-37>n, m = list(map(int, input().split()))</line-37>
<line-38>vdata = [] # (required, gain)</line-38>
<line-39>for _ in range(n):</line-39>
<line-40> a, b = list(map(int, input().split()))</line-40>
<line-41> vdata.append((max(a - b, 0), b))</line-41>
<line-42>to = [[] for _ in range(n)]</line-42>
<line-43>for _ in range(m):</line-43>
<line-44> u, v = list(map(int, input().split()))</line-44>
<line-45> u -= 1; v -= 1</line-45>
<line-46> to[u].append(v)</line-46>
<line-47> to[v].append(u)</line-47>
<line-48>s = dsu(n)</line-48>
<line-49>dp = vdata.copy() # (extra, tot_gain)</line-49>
<line-50>visited = [False] * n</line-50>
<line-51>for u in sorted(list(range(n)), key=lambda i: vdata[i][0]):</line-51>
<line-52> req, gain = vdata[u]</line-52>
<line-53> frm = {u}</line-53>
<line-54> for v in to[u]:</line-54>
<line-55> if visited[v]:</line-55>
<line-56> frm.add(s.leader(v))</line-56>
<line-57> mnextra = 10 ** 18</line-57>
<line-58> for v in frm:</line-58>
<line-59> e, g = dp[v]</line-59>
<line-60> e += max(req - (e + g), 0)</line-60>
<line-61> if e < mnextra:</line-61>
<line-62> mnextra, mni = e, v</line-62>
<line-63> extra, tot_gain = mnextra, sum(dp[v][1] for v in frm)</line-63>
<line-64> for v in frm:</line-64>
<line-65> s.merge(u, v)</line-65>
<line-66> dp[s.leader(u)] = extra, tot_gain</line-66>
<line-67> visited[u] = True</line-67>
<line-69>print(ans)</line-69>
|
{"code": "<line-2> def __init__(self, n=0):</line-2>\n<line-68>ans = sum(dp[s.leader(0)])</line-68>", "lines": [2, 68]}
#### 0
|
<line-1>N,T = list(map(int,input().split()))</line-1>
<line-3></line-3>
<line-4>cummax = [A[-1]]</line-4>
<line-5>for a in reversed(A[:-1]):</line-5>
<line-6> cummax.append(max(cummax[-1], a))</line-6>
<line-7>cummax.reverse()</line-7>
<line-8></line-8>
<line-9>maxgain = n = 0</line-9>
<line-10>for buy,sell in zip(A,cummax):</line-10>
<line-11> gain = sell - buy</line-11>
<line-12> if gain > maxgain:</line-12>
<line-13> maxgain = gain</line-13>
<line-14> n = 1</line-14>
<line-15> elif gain == maxgain:</line-15>
<line-17>print(n)</line-17>
|
{"code": "<line-2>A = list(map(int,input().split()))</line-2>\n<line-16> n += 1</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>import sys</line-1>
<line-3>import numpy as np</line-3>
<line-4>from heapq import heappush, heappop</line-4>
<line-5></line-5>
<line-6>N = int(input())</line-6>
<line-7>A = np.array(input().split(), dtype=np.int32)</line-7>
<line-8>a_to_i = {a:i for i,a in enumerate(A)}</line-8>
<line-9></line-9>
<line-10># sparse table を使ってRMQ</line-10>
<line-11># parityの同じところだけを見るようにしておく</line-11>
<line-12></line-12>
<line-13>U = len(A).bit_length()</line-13>
<line-14>sp = [None,A]</line-14>
<line-15>for i in range(2,U):</line-15>
<line-16> L = 1 << (i-1)</line-16>
<line-17> sp.append(np.minimum(sp[-1][:-L], sp[-1][L:]))</line-17>
<line-18></line-18>
<line-19>def RMQ(x,y):</line-19>
<line-20> # x番目から偶数番目だけ見て[x,y]での最小値を返す</line-20>
<line-21> d = y - x</line-21>
<line-22> if d <= 1:</line-22>
<line-23> return A[x]</line-23>
<line-24> n = d.bit_length()</line-24>
<line-25> return min(sp[n-1][x], sp[n-1][y+2-(1<<(n-1))])</line-25>
<line-26></line-26>
<line-27>def F(x,y):</line-27>
<line-28> # 辞書式で最小の2つ組をとる</line-28>
<line-29> # そのあと、今後調べないといけない区間の一覧を返す</line-29>
<line-30> x1 = RMQ(x,y-1)</line-30>
<line-31> i1 = a_to_i[x1]</line-31>
<line-32> x2 = RMQ(i1+1,y)</line-32>
<line-33> i2 = a_to_i[x2]</line-33>
<line-34> task = ((x,y) for x,y in ((x,i1-1), (i1+1,i2-1), (i2+1,y)) if y > x)</line-34>
<line-35> return x1,x2,task</line-35>
<line-36></line-36>
<line-37>q = [(None,None,((0,N-1),))]</line-37>
<line-38>answer = []</line-38>
<line-39>while q:</line-39>
<line-40> x,y,task = heappop(q)</line-40>
<line-41> answer.append(x)</line-41>
<line-42> answer.append(y)</line-42>
<line-43> for left,right in task:</line-43>
<line-45></line-45>
<line-46>print(' '.join(map(str,answer[2:])))</line-46>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-44> heappush(q,F(left,right))</line-44>", "lines": [2, 44]}
#### 0
|
<line-1># coding: utf-8</line-1>
<line-3>import sys</line-3>
<line-4>read = sys.stdin.read</line-4>
<line-5>readline = sys.stdin.readline</line-5>
<line-6></line-6>
<line-7>n, = list(map(int, readline().split()))</line-7>
<line-8>p = [-1] + [*list(map(int, readline().split()))]</line-8>
<line-9></line-9>
<line-10>MOD = 10**9+7</line-10>
<line-11>child = [[] for i in range(n+1)]</line-11>
<line-12>tot = [None for i in range(n+1)]</line-12>
<line-13>one = [None for i in range(n+1)]</line-13>
<line-14>dep = [0]*(n+1)</line-14>
<line-15>p2 = [1]*(n+1)</line-15>
<line-16>for i in range(n):</line-16>
<line-17> p2[i+1] = p2[i]*2%MOD</line-17>
<line-18></line-18>
<line-19>for v in range(n,-1,-1):</line-19>
<line-20> if dep[v]==0:</line-20>
<line-21> tot[v] = []</line-21>
<line-22> one[v] = []</line-22>
<line-23> else:</line-23>
<line-24> child[v].sort(key=lambda i: dep[i])</line-24>
<line-25> one[v] = one[child[v][-1]]</line-25>
<line-26> tot[v] = tot[child[v][-1]]</line-26>
<line-27> #one_sum = [0]*(dep[v])</line-27>
<line-28> #zero_sum = [0]*(dep[v])</line-28>
<line-29> child[v].pop()</line-29>
<line-30> if child[v]:</line-30>
<line-31> zero = [p2[tot[v][j]]-one[v][j] for j in range(-len(one[child[v][-1]]),0)]</line-31>
<line-32> for c in child[v]:</line-32>
<line-33> for j in range(-len(one[c]),0):</line-33>
<line-34> z = p2[tot[c][j]]-one[c][j]</line-34>
<line-35> one[v][j] = (one[v][j]*z+zero[j]*one[c][j])%MOD</line-35>
<line-36> zero[j] = zero[j]*z%MOD</line-36>
<line-37> tot[v][j] += tot[c][j]</line-37>
<line-38></line-38>
<line-39> tot[v].append(1)</line-39>
<line-40> one[v].append(1)</line-40>
<line-41></line-41>
<line-42> child[p[v]].append(v)</line-42>
<line-43> dep[p[v]] = max(dep[p[v]],dep[v]+1) </line-43>
<line-44></line-44>
<line-45> #print(v,tot[v],one[v])</line-45>
<line-46> </line-46>
<line-47>#print("tot",tot[0])</line-47>
<line-48>#print("one",one[0])</line-48>
<line-49></line-49>
<line-50>ans = 0</line-50>
<line-51>for i,j in zip(tot[0],one[0]):</line-51>
<line-52> ans += pow(2,n+1-i,MOD)*j%MOD</line-52>
<line-53></line-53>
<line-55>#print(sum(tot[0]))</line-55>
|
{"code": "<line-2># Your code here!</line-2>\n<line-54>print((ans%MOD))</line-54>", "lines": [2, 54]}
#### 0
|
<line-1># なんだか釈然としていないが解説の通りに</line-1>
<line-3>import sys</line-3>
<line-4></line-4>
<line-5>def MI(): return list(map(int, sys.stdin.readline().split()))</line-5>
<line-6></line-6>
<line-7>class water:</line-7>
<line-8> def __init__(self, t, v):</line-8>
<line-9> self.v = v</line-9>
<line-10> self.tv = v * t</line-10>
<line-11></line-11>
<line-12> def __le__(self, other):</line-12>
<line-13> return self.v * other.tv - self.tv * other.v >= 0</line-13>
<line-14></line-14>
<line-15> def __isub__(self, other):</line-15>
<line-16> t = self.tv / self.v</line-16>
<line-17> self.v -= other</line-17>
<line-18> self.tv = t * self.v</line-18>
<line-19> return self</line-19>
<line-20></line-20>
<line-21> def __iadd__(self, other):</line-21>
<line-22> self.v+=other.v</line-22>
<line-23> self.tv+=other.tv</line-23>
<line-24> return self</line-24>
<line-25></line-25>
<line-26>def main():</line-26>
<line-27> n, l = MI()</line-27>
<line-28> dam = deque()</line-28>
<line-29> t, v = MI()</line-29>
<line-30> print(t)</line-30>
<line-31> dam.append(water(t, v))</line-31>
<line-32> # stvはtvの合計（vがlのときのvt）</line-32>
<line-33> stv = t * v</line-33>
<line-34> for _ in range(n-1):</line-34>
<line-35> t, v = MI()</line-35>
<line-36> # 朝に水をもらう</line-36>
<line-37> dam.appendleft(water(t, v))</line-37>
<line-38> over = v</line-38>
<line-39> stv += t * v</line-39>
<line-40> # 増えた分の水を古い方から捨てる</line-40>
<line-41> # ベクトルごと削除できるもの</line-41>
<line-42> while dam[-1].v <= over:</line-42>
<line-43> w = dam.pop()</line-43>
<line-44> over -= w.v</line-44>
<line-45> stv -= w.tv</line-45>
<line-46> # 最後のはみ出しているベクトルは縮める</line-46>
<line-47> stv -= dam[-1].tv # 一度合計から取り出して</line-47>
<line-48> dam[-1] -= over # 縮めて</line-48>
<line-49> stv += dam[-1].tv # 元に戻す</line-49>
<line-50> # その日の水温を出力</line-50>
<line-51> print((stv / l))</line-51>
<line-52> # グラフの左側が凹んでいたらベクトルを合成して凸に直す</line-52>
<line-53> while len(dam)>1 and dam[0] <= dam[1]:</line-53>
<line-54> w = dam.popleft()</line-54>
<line-56></line-56>
<line-57>main()</line-57>
|
{"code": "<line-2>from collections import deque</line-2>\n<line-55> dam[0] += w</line-55>", "lines": [2, 55]}
#### 0
|
<line-1>n, d = list(map(int, input().split()))</line-1>
<line-3>A = [0]*(n+1)</line-3>
<line-4>P = [0]*(n+1)</line-4>
<line-5></line-5>
<line-6>P[0] = pos = d</line-6>
<line-7>for i, x in enumerate(D):</line-7>
<line-8> if x <= 2*pos:</line-8>
<line-9> pos = abs(x-pos)</line-9>
<line-10> P[i+1] = pos</line-10>
<line-11> if pos == 0:</line-11>
<line-12> break</line-12>
<line-13></line-13>
<line-14>for i in range(n-1, -1, -1):</line-14>
<line-15> if D[i] <= 2*A[i+1]+1:</line-15>
<line-16> A[i] = A[i+1] + D[i]</line-16>
<line-17> else:</line-17>
<line-18> A[i] = A[i+1]</line-18>
<line-19></line-19>
<line-20>q = input()</line-20>
<line-21>Q = list(map(int, input().split()))</line-21>
<line-22>for i in Q:</line-22>
<line-23> if P[i-1] <= A[i] and pos == 0:</line-23>
<line-24> print("NO")</line-24>
<line-26> print("YES")</line-26>
|
{"code": "<line-2>D = list(map(int, input().split()))</line-2>\n<line-25> else:</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-3>input = sys.stdin.readline</line-3>
<line-4>from collections import deque</line-4>
<line-5>INF = 10**9</line-5>
<line-6></line-6>
<line-7>n, m = map(int, input().split())</line-7>
<line-8>pqc = []</line-8>
<line-9></line-9>
<line-10>seen = set()</line-10>
<line-11>for i in range(n):</line-11>
<line-12> seen.add((i, 0))</line-12>
<line-13>for _ in range(m):</line-13>
<line-14> p, q, c = map(int, input().split())</line-14>
<line-15> p -= 1; q -= 1</line-15>
<line-16> pqc.append((p, q, c))</line-16>
<line-17> seen.add((p, c))</line-17>
<line-18> seen.add((q, c))</line-18>
<line-19>comp = dict()</line-19>
<line-20>for i, node in enumerate(seen):</line-20>
<line-21> comp[node] = i</line-21>
<line-22></line-22>
<line-23>edge = [[] for _ in range(len(comp))]</line-23>
<line-24>for key in comp.keys():</line-24>
<line-25> v, c = key</line-25>
<line-26> if c != 0:</line-26>
<line-27> frm = comp[(v, c)]</line-27>
<line-28> too = comp[(v, 0)]</line-28>
<line-29> edge[frm].append((too, 0))</line-29>
<line-30> edge[too].append((frm, 1))</line-30>
<line-31></line-31>
<line-32>for p, q, c in pqc:</line-32>
<line-33> frm = comp[(p, c)]</line-33>
<line-34> too = comp[(q, c)]</line-34>
<line-35> edge[frm].append((too, 0))</line-35>
<line-36> edge[too].append((frm, 0))</line-36>
<line-37></line-37>
<line-38>class BFS:</line-38>
<line-39> def __init__(self, adj):</line-39>
<line-40> self.adj = adj</line-40>
<line-41> self.dist = [INF] * len(adj)</line-41>
<line-42> self.q = deque()</line-42>
<line-43></line-43>
<line-44> def calc(self, start):</line-44>
<line-45> self.dist[start] = 0</line-45>
<line-46> self.q.append((0, start))</line-46>
<line-47> while len(self.q) != 0:</line-47>
<line-48> prov_cost, src = self.q.popleft()</line-48>
<line-49> if self.dist[src] < prov_cost:</line-49>
<line-50> continue</line-50>
<line-51> for dest, cost in self.adj[src]:</line-51>
<line-52> if self.dist[dest] > self.dist[src] + cost:</line-52>
<line-53> self.dist[dest] = self.dist[src] + cost</line-53>
<line-54> if cost == 1:</line-54>
<line-55> self.q.append((self.dist[dest], dest))</line-55>
<line-56> else:</line-56>
<line-57> self.q.appendleft((self.dist[dest], dest))</line-57>
<line-58> return self.dist</line-58>
<line-59></line-59>
<line-60>bfs = BFS(edge)</line-60>
<line-61>bfs.calc(comp[(0, 0)])</line-61>
<line-62>ans = bfs.dist[comp[(n-1, 0)]]</line-62>
<line-63>if ans == INF:</line-63>
<line-64> print(-1)</line-64>
<line-66> print(ans)</line-66>
|
{"code": "<line-2>import sys</line-2>\n<line-65>else:</line-65>", "lines": [2, 65]}
#### 0
|
<line-1>N=int(input())</line-1>
<line-3>O=10**9+7</line-3>
<line-4>D=[pow(-~O//2,M,O)]+[0]*N</line-4>
<line-6>print(D[M])</line-6>
|
{"code": "<line-2>M=len(input())</line-2>\n<line-5>for _ in'_'*N:D=[D[0]+D[1]]+[(i+2*j)%O for i,j in zip(D[2:]+[0],D[:-1])]</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>def diameter(n, links):</line-5>
<line-6> q = deque([(0, -1)])</line-6>
<line-7> v = 0</line-7>
<line-8> while q:</line-8>
<line-9> v, p = q.popleft()</line-9>
<line-10> q.extend((u, v) for u in links[v] if u != p)</line-10>
<line-11></line-11>
<line-12> q = deque([(v, -1)])</line-12>
<line-13> w = 0</line-13>
<line-14> parents = [-1] * n</line-14>
<line-15> while q:</line-15>
<line-16> w, p = q.popleft()</line-16>
<line-17> parents[w] = p</line-17>
<line-18> q.extend((u, w) for u in links[w] if u != p)</line-18>
<line-19> parents_rev = [-1] * n</line-19>
<line-20> p = w</line-20>
<line-21> while parents[p] != -1:</line-21>
<line-22> parents_rev[parents[p]] = p</line-22>
<line-23> p = parents[p]</line-23>
<line-24> return v, w, parents, parents_rev</line-24>
<line-25></line-25>
<line-26></line-26>
<line-27>def construct(s, links, parents, parents_rev):</line-27>
<line-28> v = s</line-28>
<line-29> result = []</line-29>
<line-30> while v != -1:</line-30>
<line-31> pv, rv = parents[v], parents_rev[v]</line-31>
<line-32> child_count = 0</line-32>
<line-33> for u in links[v]:</line-33>
<line-34> if u == pv or u == rv:</line-34>
<line-35> continue</line-35>
<line-36> if len(links[u]) != 1:</line-36>
<line-37> return False</line-37>
<line-38> child_count += 1</line-38>
<line-39> my_value = len(result) + 1</line-39>
<line-40> result.extend(list(range(my_value + 1, my_value + child_count + 1)))</line-40>
<line-41> result.append(my_value)</line-41>
<line-42> v = parents[v]</line-42>
<line-43> return result</line-43>
<line-44></line-44>
<line-45></line-45>
<line-46>def solve(n, links):</line-46>
<line-47> d1, d2, parents, parents_rev = diameter(n, links)</line-47>
<line-48> result1 = construct(d1, links, parents_rev, parents)</line-48>
<line-49> if result1 is False:</line-49>
<line-50> return [-1]</line-50>
<line-51> result2 = construct(d2, links, parents, parents_rev)</line-51>
<line-52> return min(result1, result2)</line-52>
<line-53></line-53>
<line-54></line-54>
<line-55>n = int(input())</line-55>
<line-56>links = [set() for _ in range(n)]</line-56>
<line-57>INF = 10 ** 9</line-57>
<line-58></line-58>
<line-59>for line in sys.stdin:</line-59>
<line-60> v, w = list(map(int, line.split()))</line-60>
<line-61> v -= 1</line-61>
<line-62> w -= 1</line-62>
<line-63> links[v].add(w)</line-63>
<line-65></line-65>
<line-66>print((*solve(n, links)))</line-66>
|
{"code": "<line-2>from collections import deque</line-2>\n<line-64> links[w].add(v)</line-64>", "lines": [2, 64]}
#### 0
|
<line-1>N, a, b = list(map(int, input().split())); a -= 1; b -= 1</line-1>
<line-3>Q = []</line-3>
<line-4>for i in range(N):</line-4>
<line-5> x, y = list(map(int, input().split()))</line-5>
<line-6> P.append((x-y, x+y, i))</line-6>
<line-7> Q.append((x+y, x-y, i))</line-7>
<line-8></line-8>
<line-9>d = max(abs(P[a][0] - P[b][0]), abs(P[a][1] - P[b][1]))</line-9>
<line-10></line-10>
<line-11>*parent, = list(range(N))</line-11>
<line-12>def root(x):</line-12>
<line-13> if x == parent[x]:</line-13>
<line-14> return x</line-14>
<line-15> y = parent[x] = root(parent[x])</line-15>
<line-16> return y</line-16>
<line-17>def unite(x, y):</line-17>
<line-18> px = root(x); py = root(y)</line-18>
<line-19> if px < py:</line-19>
<line-20> parent[py] = px</line-20>
<line-21> else:</line-21>
<line-22> parent[px] = py</line-22>
<line-23>C = [0]*N</line-23>
<line-24>D = [0]*N</line-24>
<line-25></line-25>
<line-26>def check(P0, i0, j0):</line-26>
<line-27> return abs(P0[i0][0] - P0[j0][0]) == abs(P0[i0][1] - P0[j0][1])</line-27>
<line-28></line-28>
<line-29>def solve(P0):</line-29>
<line-30> P = P0[:]</line-30>
<line-31> P.sort()</line-31>
<line-32></line-32>
<line-33> s = t = 0; prev = -1</line-33>
<line-34> for i in range(N):</line-34>
<line-35> x, y, i0 = P[i]</line-35>
<line-36> while t < N and P[t][0] < x-d or (P[t][0] == x-d and P[t][1] <= y+d): t += 1</line-36>
<line-37> while s < N and (P[s][0] < x-d or (P[s][0] == x-d and P[s][1] < y-d)): s += 1</line-37>
<line-38> if s < t:</line-38>
<line-39> j0 = P[s][2]</line-39>
<line-40> unite(i0, j0)</line-40>
<line-41> if check(P0, i0, j0):</line-41>
<line-42> D[i0] += 1</line-42>
<line-43> else:</line-43>
<line-44> C[i0] += 1</line-44>
<line-45> if s < t-1:</line-45>
<line-46> j0 = P[t-1][2]</line-46>
<line-47> if check(P0, i0, j0):</line-47>
<line-48> D[i0] += 1</line-48>
<line-49> C[i0] += t-s-2</line-49>
<line-50> else:</line-50>
<line-51> C[i0] += t-s-1</line-51>
<line-52> for j in range(max(prev, s), t-1):</line-52>
<line-53> unite(P[j][2], P[j+1][2])</line-53>
<line-54> prev = t-1</line-54>
<line-55>solve(P)</line-55>
<line-56>solve(Q)</line-56>
<line-57></line-57>
<line-58>S = T = 0</line-58>
<line-59>r = root(a)</line-59>
<line-60>for i in range(N):</line-60>
<line-61> if root(i) == r:</line-61>
<line-63>print((S + T//2))</line-63>
|
{"code": "<line-2>P = []</line-2>\n<line-62> S += C[i]; T += D[i]</line-62>", "lines": [2, 62]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>ip=lambda: int(sp())</line-4>
<line-5>fp=lambda: float(sp())</line-5>
<line-6>lp=lambda:list(map(int,stdin.readline().split()))</line-6>
<line-7>sp=lambda:stdin.readline().rstrip()</line-7>
<line-8>yp=lambda:print('Yes')</line-8>
<line-9>np=lambda:print('No')</line-9>
<line-10></line-10>
<line-11>n,a,b=lp()</line-11>
<line-12>x=lp()</line-12>
<line-13>ans=0</line-13>
<line-14>for i in range(n-1):</line-14>
<line-16>print(ans)</line-16>
|
{"code": "<line-2>stdin=sys.stdin</line-2>\n<line-15> ans+=min(b,a*(x[i+1]-x[i]))</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from collections import deque</line-3>
<line-4>def slidemax(X, k):</line-4>
<line-5> q = deque([])</line-5>
<line-6> ret = []</line-6>
<line-7> for i in range(len(X)):</line-7>
<line-8> while q and q[-1][1] <= X[i]:</line-8>
<line-9> q.pop()</line-9>
<line-10> deque.append(q, (i+k, X[i]))</line-10>
<line-11> if q[0][0] == i:</line-11>
<line-12> deque.popleft(q)</line-12>
<line-13> if i >= k-1:</line-13>
<line-14> ret.append(q[0][1])</line-14>
<line-15> return ret</line-15>
<line-16> </line-16>
<line-17>N, W = list(map(int, input().split()))</line-17>
<line-18>A = [0] * W</line-18>
<line-19>s = 0</line-19>
<line-20>for _ in range(N):</line-20>
<line-21> l, *B = list(map(int, input().split()))</line-21>
<line-22> if l*2 < W:</line-22>
<line-23> C = slidemax([0]*(l-1)+B+[0]*(l-1), l)</line-23>
<line-24> m = max(B + [0])</line-24>
<line-25> s += m</line-25>
<line-26> for i in range(l-1):</line-26>
<line-27> A[i] += C[i] - m</line-27>
<line-28> A[-i-1] += C[-i-1] - m</line-28>
<line-29> else:</line-29>
<line-30> C = slidemax([0]*(W-l)+B+[0]*(W-l), W - l + 1)</line-30>
<line-32></line-32>
<line-33>print(*[a+s for a in A])</line-33>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-31> A = [a+c for a, c in zip(A, C)]</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>d = [-1] * 1000001</line-1>
<line-3> n, a = int(input()), list(map(int, input().split()))</line-3>
<line-4> a.sort()</line-4>
<line-5> for i in range(n):</line-5>
<line-6> for j in range(i + 1, n): d[a[j] - a[i]] = t</line-6>
<line-7> i = 1</line-7>
<line-9> print("YES\n" + ' '.join(str(j * i + 1) for j in range(n)))</line-9>
|
{"code": "<line-2>for t in range(int(input())):</line-2>\n<line-8> while any(d[i * j] == t for j in range(1, n)): i += 1</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>r, c = list(map(int, input().split()))</line-1>
<line-3> print('>vv')</line-3>
<line-4> print('^<.')</line-4>
<line-5> print('^.<')</line-5>
<line-6> print('1 3')</line-6>
<line-7>elif r == 5:</line-7>
<line-8> print('>...v')</line-8>
<line-9> print('v.<..')</line-9>
<line-10> print('..^..')</line-10>
<line-11> print('>....')</line-11>
<line-12> print('..^.<')</line-12>
<line-13> print('1 1')</line-13>
<line-14>elif r == 100:</line-14>
<line-15> for i in range(25):</line-15>
<line-16> print('>'*50+'.>'*24+'.v')</line-16>
<line-17> print('^'+'<.'*25+'<'*49)</line-17>
<line-18> print('v.'+'<.'*24+'<'*50)</line-18>
<line-19> print('>'*49+'.>'*25+'^')</line-19>
<line-20> print('1 1')</line-20>
<line-21>else:</line-21>
<line-23> d[1] = 1</line-23>
|
{"code": "<line-2>if r == 3:</line-2>\n<line-22> d = []</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>import math</line-1>
<line-3></line-3>
<line-4>input = sys.stdin.readline</line-4>
<line-5></line-5>
<line-6>def main():</line-6>
<line-7></line-7>
<line-8></line-8>
<line-9></line-9>
<line-10> MAX_N = int(1e6) + 1</line-10>
<line-11></line-11>
<line-12> dp = [0 for i in range(MAX_N)]</line-12>
<line-13> vals = [[] for i in range(10)]</line-13>
<line-14></line-14>
<line-15> for i in range(10):</line-15>
<line-16> dp[i] = i</line-16>
<line-17> vals[i].append(i)</line-17>
<line-18></line-18>
<line-19></line-19>
<line-20> for i in range(10, MAX_N):</line-20>
<line-21> prod = 1</line-21>
<line-22> for j in str(i):</line-22>
<line-23> if j != '0':</line-23>
<line-24> prod *= int(j)</line-24>
<line-25></line-25>
<line-26> dp[i] = dp[prod]</line-26>
<line-27> vals[dp[prod]].append(i)</line-27>
<line-28></line-28>
<line-29> q = int(input())</line-29>
<line-30></line-30>
<line-31> for i in range(len(vals)):</line-31>
<line-32> vals[i] = sorted(vals[i])</line-32>
<line-33></line-33>
<line-34> for i in range(q):</line-34>
<line-35> l,r, k = [int(x) for x in input().split(' ')]</line-35>
<line-36> posl = -1</line-36>
<line-37> posr = -1</line-37>
<line-38> for j in range(25, -1, -1):</line-38>
<line-39> jump = 2**j</line-39>
<line-40></line-40>
<line-41> if posl + jump < len(vals[k]) and vals[k][posl+jump] < l:</line-41>
<line-42> posl += jump</line-42>
<line-43></line-43>
<line-44> if posr + jump < len(vals[k]) and vals[k][posr+jump] <= r:</line-44>
<line-45> posr += jump</line-45>
<line-46></line-46>
<line-47> print(posr - posl)</line-47>
<line-48></line-48>
<line-49>def __starting_point():</line-49>
<line-51></line-51>
<line-52></line-52>
<line-53>__starting_point()</line-53>
|
{"code": "<line-2>import sys</line-2>\n<line-50> main()</line-50>", "lines": [2, 50]}
#### 0
|
<line-1>from bisect import bisect_left as bl</line-1>
<line-3>from heapq import heappush,heappop,heapify</line-3>
<line-4>import math</line-4>
<line-5>from collections import *</line-5>
<line-6>from functools import reduce,cmp_to_key</line-6>
<line-7>import sys</line-7>
<line-8>input = sys.stdin.readline</line-8>
<line-9></line-9>
<line-10>from itertools import accumulate</line-10>
<line-11>from functools import lru_cache</line-11>
<line-12></line-12>
<line-13>M = mod = 998244353</line-13>
<line-14>def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))</line-14>
<line-15>def inv_mod(n):return pow(n, mod - 2, mod)</line-15>
<line-16> </line-16>
<line-17>def li():return [int(i) for i in input().rstrip('\n').split()]</line-17>
<line-18>def st():return input().rstrip('\n')</line-18>
<line-19>def val():return int(input().rstrip('\n'))</line-19>
<line-20>def li2():return [i for i in input().rstrip('\n')]</line-20>
<line-21>def li3():return [int(i) for i in input().rstrip('\n')]</line-21>
<line-22></line-22>
<line-23></line-23>
<line-24></line-24>
<line-25></line-25>
<line-26>n, q = li()</line-26>
<line-27></line-27>
<line-28></line-28>
<line-29>queue = [-1] * 20</line-29>
<line-30></line-30>
<line-31>ans = [[-1] * 20 for i in range(n + 1)]</line-31>
<line-32>l = li()</line-32>
<line-33>for i, curr in enumerate(l):</line-33>
<line-34></line-34>
<line-35> for j in range(20):</line-35>
<line-36> if curr >> j & 1:</line-36>
<line-37> for k in range(20): </line-37>
<line-38> ans[i][k] = max(ans[i][k], ans[queue[j]][k])</line-38>
<line-39> ans[i][j] = i</line-39>
<line-40> </line-40>
<line-41> for j in range(20):queue[j] = max(queue[j], ans[i][j])</line-41>
<line-42></line-42>
<line-43></line-43>
<line-44>queries = []</line-44>
<line-45>for i in range(q):queries.append(li()) </line-45>
<line-46>for i in range(q):</line-46>
<line-47> a, b = queries[i]</line-47>
<line-48> a -= 1</line-48>
<line-49> b -= 1</line-49>
<line-50></line-50>
<line-51> currans = 0</line-51>
<line-52></line-52>
<line-53> for j in range(20):</line-53>
<line-54> if (l[a] >> j) & 1 and ans[b][j] >= a:</line-54>
<line-55> currans = 1</line-55>
<line-57> print('Shi' if currans else 'Fou')</line-57>
|
{"code": "<line-2>from bisect import bisect_right as br</line-2>\n<line-56> break</line-56>", "lines": [2, 56]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>b = list(map(int, input().split()))</line-3>
<line-4>c = [0] * n</line-4>
<line-5>stk = [0]</line-5>
<line-6>for i in range(1, n):</line-6>
<line-7> while len(stk) > 1 and c[stk[1]] - c[stk[0]] <= a[i] * (b[stk[0]] -</line-7>
<line-8> b[stk[1]]):</line-8>
<line-9> del stk[0]</line-9>
<line-10> c[i] = c[stk[0]] + a[i] * b[stk[0]]</line-10>
<line-11> while len(stk) > 1 and ((c[stk[-1]] - c[stk[-2]]) * (b[stk[-1]] - b[i]) ></line-11>
<line-12> (b[stk[-2]] - b[stk[-1]]) * (c[i] - c[stk[-1]])):</line-12>
<line-13> del stk[-1]</line-13>
<line-15>print(c[n - 1])</line-15>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-14> stk.append(i)</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>dp = [[0 for i in range(n + 1)] for j in range(n + 1)]</line-3>
<line-4>for i in range(n):</line-4>
<line-5> dp[0][i] = a[i]</line-5>
<line-6>for i in range(1, n):</line-6>
<line-7> for j in range(n - i + 1):</line-7>
<line-8> dp[i][j] = dp[i - 1][j] ^ dp[i - 1][j + 1]</line-8>
<line-9>for i in range(1, n):</line-9>
<line-10> for j in range(n - i):</line-10>
<line-11> dp[i][j] = max(dp[i][j], dp[i - 1][j], dp[i - 1][j + 1])</line-11>
<line-12>for i in range(int(input())):</line-12>
<line-14> print(dp[r - l][l - 1])</line-14>
|
{"code": "<line-2>*a, = map(int, input().split())</line-2>\n<line-13> l, r = map(int, input().split())</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>T = int(input())</line-4>
<line-5>for _ in range(T):</line-5>
<line-6> n = int(input())</line-6>
<line-7> l = list(map(int, input().split()))</line-7>
<line-8> </line-8>
<line-9> stack = []</line-9>
<line-10> out = [-1] * n</line-10>
<line-11> curr = 0</line-11>
<line-12> works = True</line-12>
<line-13> for i in range(n):</line-13>
<line-14> while stack and stack[-1][0] == i:</line-14>
<line-15> _, j = stack.pop()</line-15>
<line-16> curr += 1</line-16>
<line-17> out[j] = curr</line-17>
<line-18> </line-18>
<line-19> nex = l[i] - 1</line-19>
<line-20> if nex == -2:</line-20>
<line-21> curr += 1</line-21>
<line-22> out[i] = curr</line-22>
<line-23> else:</line-23>
<line-24> if stack and nex > stack[-1][0]:</line-24>
<line-25> works = False</line-25>
<line-26> else:</line-26>
<line-27> stack.append((nex, i))</line-27>
<line-28> </line-28>
<line-29> while stack:</line-29>
<line-30> _, j = stack.pop()</line-30>
<line-31> curr += 1</line-31>
<line-32> out[j] = curr</line-32>
<line-33> </line-33>
<line-34> if works:</line-34>
<line-35> print(*out)</line-35>
<line-37> print(-1)</line-37>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-36> else:</line-36>", "lines": [2, 36]}
#### 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 = [int(a) for a in input().split()]</line-6>
<line-7> X = [0] * 30</line-7>
<line-8> for a in A:</line-8>
<line-9> for i in range(30):</line-9>
<line-10> if a & (1 << i):</line-10>
<line-11> X[i] += 1</line-11>
<line-12> for i in range(30)[::-1]:</line-12>
<line-13> if X[i] % 2:</line-13>
<line-14> if X[i] == 1:</line-14>
<line-15> print("WIN")</line-15>
<line-16> elif N % 2 == 0:</line-16>
<line-17> print("WIN")</line-17>
<line-18> elif X[i] % 4 == 1:</line-18>
<line-19> print("WIN")</line-19>
<line-20> else:</line-20>
<line-21> print("LOSE")</line-21>
<line-22> break</line-22>
<line-24> print("DRAW")</line-24>
|
{"code": "<line-2>input = lambda: sys.stdin.readline().rstrip()</line-2>\n<line-23> else:</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>t = int(input())</line-5>
<line-6>for _ in range(t):</line-6>
<line-7> n = int(input())</line-7>
<line-8> a = list(map(int, input().split()))</line-8>
<line-9> </line-9>
<line-10> ans = 0</line-10>
<line-11> for i in range(n - 1):</line-11>
<line-12> diff = a[i] - a[i + 1]</line-12>
<line-13> if diff <= 0:</line-13>
<line-14> continue</line-14>
<line-15> else:</line-15>
<line-16> ans = max(len(bin(diff)) - 2, ans)</line-16>
<line-18> print(ans)</line-18>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-17> a[i + 1] = a[i]</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>n, k = list(map(int, input().split()))</line-1>
<line-3>for e in [int(i) for i in input().split()]:</line-3>
<line-4> d = m - c * (n - c - 1) * e</line-4>
<line-5> r+= 1</line-5>
<line-6> if d < k:</line-6>
<line-7> n -= 1</line-7>
<line-8> l += [r]</line-8>
<line-9> else:</line-9>
<line-10> m += c * e</line-10>
<line-11> c += 1</line-11>
<line-13>for e in l: print(e)</line-13>
<line-14> </line-14>
<line-15> </line-15>
|
{"code": "<line-2>c, m, l, r = 0, 0, [], 0</line-2>\n<line-12>l.sort()</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>T = int(readline())</line-4>
<line-5>MOD = 998244353</line-5>
<line-6>Ans = [None]*T</line-6>
<line-7>for qu in range(T):</line-7>
<line-8> N, K = map(int, readline().split())</line-8>
<line-9> A = [0] + list(map(int, readline().split())) + [0]</line-9>
<line-10> B = list(map(int, readline().split()))</line-10>
<line-11> C = [None]*(N+1)</line-11>
<line-12> for i in range(1, N+1):</line-12>
<line-13> C[A[i]] = i</line-13>
<line-14> ans = 1</line-14>
<line-15> for b in B[::-1]:</line-15>
<line-16> bi = C[b]</line-16>
<line-17> res = 0</line-17>
<line-18> if A[bi-1]:</line-18>
<line-19> res += 1</line-19>
<line-20> if A[bi+1]:</line-20>
<line-21> res += 1</line-21>
<line-22> A[bi] = 0</line-22>
<line-23> ans = ans*res%MOD</line-23>
<line-25>print('\n'.join(map(str, Ans))) </line-25>
|
{"code": "<line-2>readline = sys.stdin.readline</line-2>\n<line-24> Ans[qu] = ans</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>"""</line-1>
<line-3> Date : </line-3>
<line-4> Algo : </line-4>
<line-5> Difficulty : </line-5>
<line-6>"""</line-6>
<line-7>from sys import stdin, stdout, setrecursionlimit</line-7>
<line-8>import threading</line-8>
<line-9></line-9>
<line-10></line-10>
<line-11>def main():</line-11>
<line-12> m = int(stdin.readline().strip())</line-12>
<line-13> a = [int(_) for _ in stdin.readline().strip().split()]</line-13>
<line-14> b = [int(_) for _ in stdin.readline().strip().split()]</line-14>
<line-15></line-15>
<line-16> c = []</line-16>
<line-17> for i, v in enumerate(b):</line-17>
<line-18> c.append((v, i))</line-18>
<line-19></line-19>
<line-20> a = sorted(a, reverse=True)</line-20>
<line-21> c = sorted(c)</line-21>
<line-22></line-22>
<line-23> ans = [0 for i in range(m)]</line-23>
<line-24> j = 0</line-24>
<line-25> for v, i in c:</line-25>
<line-26> ans[i] = a[j]</line-26>
<line-27> j += 1</line-27>
<line-28></line-28>
<line-29> stdout.write(' '.join(str(_) for _ in ans))</line-29>
<line-30> </line-30>
<line-31></line-31>
<line-32></line-32>
<line-33>def __starting_point():</line-33>
<line-34> # the following 4 lines of code are required to increase </line-34>
<line-35> # the recursion limit and stack size</line-35>
<line-36> # * if is cause any problem, comment out the lines, </line-36>
<line-37> # * and just call main()</line-37>
<line-38> setrecursionlimit(10**6)</line-38>
<line-39> threading.stack_size(134217728) # 128MB</line-39>
<line-40> thread = threading.Thread(target=main)</line-40>
<line-42></line-42>
<line-43>__starting_point()</line-43>
|
{"code": "<line-2> Author : Arif Ahmad</line-2>\n<line-41> thread.start()</line-41>", "lines": [2, 41]}
#### 0
|
<line-1>from cmath import rect</line-1>
<line-3>import math</line-3>
<line-4>from functools import reduce</line-4>
<line-5></line-5>
<line-6>class SegmentTree():</line-6>
<line-7> def __init__(self, L, function = lambda x,y: x+y):</line-7>
<line-8> self.function = function</line-8>
<line-9> N = self.size = len(L)</line-9>
<line-10> M = 1 << N.bit_length()</line-10>
<line-11> self.margin = 2*M - N</line-11>
<line-12> self.L = [None for i in range(self.margin)] + L</line-12>
<line-13> for i in range(M-1, 0, -1):</line-13>
<line-14> x, y = self.L[i<<1], self.L[i<<1|1]</line-14>
<line-15> self.L[i] = None if x is None or y is None else function(x, y)</line-15>
<line-16> def modify(self, pos, value):</line-16>
<line-17> p = pos + self.margin</line-17>
<line-18> self.L[p] = value </line-18>
<line-19> while p > 1:</line-19>
<line-20> x, y = self.L[p], self.L[p^1]</line-20>
<line-21> if p&1: x, y = y, x</line-21>
<line-22> self.L[p>>1] = None if x is None or y is None else self.function(x, y)</line-22>
<line-23> p>>=1</line-23>
<line-24> def query(self, left, right):</line-24>
<line-25> l, r = left + self.margin, right + self.margin</line-25>
<line-26> stack = []</line-26>
<line-27> void = True</line-27>
<line-28> while l < r:</line-28>
<line-29> if l&1:</line-29>
<line-30> if void:</line-30>
<line-31> result = self.L[l]</line-31>
<line-32> void = False</line-32>
<line-33> else:</line-33>
<line-34> result = self.function(result, self.L[l])</line-34>
<line-35> l+=1</line-35>
<line-36> if r&1:</line-36>
<line-37> r-=1</line-37>
<line-38> stack.append(self.L[r])</line-38>
<line-39> l>>=1</line-39>
<line-40> r>>=1</line-40>
<line-41> init = stack.pop() if void else result</line-41>
<line-42> return reduce(self.function, reversed(stack), init)</line-42>
<line-43></line-43>
<line-44>def degrect(r, phi):</line-44>
<line-45> return rect(r, math.radians(phi))</line-45>
<line-46></line-46>
<line-47>def vsum(u, v): #u = (x + y*1j, phi)</line-47>
<line-48> return (u[0] + v[0]*degrect(1, u[1]), (u[1] + v[1])%360)</line-48>
<line-49></line-49>
<line-50>def solve(f):</line-50>
<line-51> n, m = [int(x) for x in f.readline().split()]</line-51>
<line-52> segments = [[1,0] for i in range(n)]</line-52>
<line-53> arm = SegmentTree([(1,0) for i in range(n)], vsum)</line-53>
<line-54> for line in f:</line-54>
<line-55> q, i, a = [int(x) for x in line.split()]</line-55>
<line-56> if q == 1:</line-56>
<line-57> segments[i-1][0] += a</line-57>
<line-58> else:</line-58>
<line-59> segments[i-1][1] -= a</line-59>
<line-60> arm.modify(i-1, (degrect(segments[i-1][0], segments[i-1][1]), segments[i-1][1]))</line-60>
<line-61> query = arm.query(0,n)[0]</line-61>
<line-63></line-63>
<line-64>solve(sys.stdin)</line-64>
|
{"code": "<line-2>import sys</line-2>\n<line-62> print(query.real, query.imag)</line-62>", "lines": [2, 62]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>n = int(input())</line-4>
<line-5></line-5>
<line-6>x = [0]*n</line-6>
<line-7>y = [0]*n</line-7>
<line-8></line-8>
<line-9>for i in range(n):</line-9>
<line-10> x[i], y[i] = list(map(int, input().split()))</line-10>
<line-11></line-11>
<line-12>sx = sum(x)</line-12>
<line-13>sy = sum(y)</line-13>
<line-14> </line-14>
<line-15>for i in range(n):</line-15>
<line-16> x[i] = n * x[i] - sx</line-16>
<line-17> y[i] = n * y[i] - sy</line-17>
<line-18></line-18>
<line-19>m = int(input())</line-19>
<line-20></line-20>
<line-21>d = [0]*n</line-21>
<line-22>e = [0]*n</line-22>
<line-23></line-23>
<line-24>HD = 0</line-24>
<line-25></line-25>
<line-26>def check(a, b):</line-26>
<line-27> nonlocal HD</line-27>
<line-28> HE = 0</line-28>
<line-29> for i in range(n):</line-29>
<line-30> HE ^= hash((a-x[i])*(a-x[i])+(b-y[i])*(b-y[i]))</line-30>
<line-31> return HD == HE</line-31>
<line-32></line-32>
<line-33>def sqrt(x):</line-33>
<line-34> nn = int(x)</line-34>
<line-35> if nn == 0:</line-35>
<line-36> return 0</line-36>
<line-37> fa, fb = divmod(nn.bit_length(), 2)</line-37>
<line-38> x = 2**(fa+fb)</line-38>
<line-39> while True:</line-39>
<line-40> y = (x + nn//x)//2</line-40>
<line-41> if y >= x:</line-41>
<line-42> return x</line-42>
<line-43> x = y</line-43>
<line-44></line-44>
<line-45>def hash(x):</line-45>
<line-46> return x * 9991 + 43</line-46>
<line-47></line-47>
<line-48>pans = []</line-48>
<line-49></line-49>
<line-50>def solve():</line-50>
<line-51> nonlocal d</line-51>
<line-52> d = list(map(int, input().split()))</line-52>
<line-53> c = 0</line-53>
<line-54> d = [p * n * n for p in d]</line-54>
<line-55> for i in range(n):</line-55>
<line-56> c += d[i] - x[i] * x[i] - y[i] * y[i]</line-56>
<line-57></line-57>
<line-58> assert(c % n == 0)</line-58>
<line-59> c //= n</line-59>
<line-60> ans = []</line-60>
<line-61> ax = x[0]</line-61>
<line-62> ay = y[0]</line-62>
<line-63> if ax is 0 and ay is 0:</line-63>
<line-64> ax = x[1]</line-64>
<line-65> ay = y[1]</line-65>
<line-66> rev = 0</line-66>
<line-67> if ay == 0:</line-67>
<line-68> ay = ax</line-68>
<line-69> ax = 0</line-69>
<line-70> rev = 1</line-70>
<line-71> d.sort()</line-71>
<line-72> nonlocal HD</line-72>
<line-73> HD = 0</line-73>
<line-74> for p in d:</line-74>
<line-75> HD ^= hash(p)</line-75>
<line-76> old = -1</line-76>
<line-77> for p in d:</line-77>
<line-78> if (p == old):</line-78>
<line-79> continue</line-79>
<line-80> old = p</line-80>
<line-81> a = c + ax * ax + ay * ay - p</line-81>
<line-82> if (a % 2 != 0):</line-82>
<line-83> continue</line-83>
<line-84> a //= 2</line-84>
<line-85> A = ax * ax + ay * ay</line-85>
<line-86> B = a * ax</line-86>
<line-87> C = a * a - ay * ay * c</line-87>
<line-88> D = B * B - A * C</line-88>
<line-89> if (D < 0):</line-89>
<line-90> continue</line-90>
<line-91> sD = sqrt(D)</line-91>
<line-92> if D != sD * sD:</line-92>
<line-93> continue</line-93>
<line-94> if (B + sD) % A == 0:</line-94>
<line-95> qx = (B + sD) // A</line-95>
<line-96> qy = (a - ax * qx) // ay</line-96>
<line-97> if rev:</line-97>
<line-98> t = qx</line-98>
<line-99> qx = qy</line-99>
<line-100> qy = t</line-100>
<line-101> if ((qx + sx) % n == 0 and (qy + sy) % n == 0 and check(qx, qy)):</line-101>
<line-102> qx = (qx + sx) // n</line-102>
<line-103> qy = (qy + sy) // n</line-103>
<line-104> ans.append([qx, qy])</line-104>
<line-105> if sD == 0:</line-105>
<line-106> continue</line-106>
<line-107> if (B - sD) % A == 0:</line-107>
<line-108> qx = (B - sD) // A</line-108>
<line-109> qy = (a - ax * qx) // ay</line-109>
<line-110> if rev:</line-110>
<line-111> t = qx</line-111>
<line-112> qx = qy</line-112>
<line-113> qy = t</line-113>
<line-114> if ((qx + sx) % n == 0 and (qy + sy) % n == 0 and check(qx, qy)):</line-114>
<line-115> qx = (qx + sx) // n</line-115>
<line-116> qy = (qy + sy) // n</line-116>
<line-117> ans.append([qx, qy])</line-117>
<line-118> </line-118>
<line-119> ans.sort()</line-119>
<line-120> buf=[]</line-120>
<line-121> buf.append(len(ans))</line-121>
<line-122> for p in ans:</line-122>
<line-123> buf.append(p[0])</line-123>
<line-124> buf.append(p[1])</line-124>
<line-125> nonlocal pans</line-125>
<line-126> pans.append(" ".join(map(str,buf)))</line-126>
<line-127></line-127>
<line-128>while m > 0:</line-128>
<line-129> m -= 1</line-129>
<line-131> </line-131>
<line-132>sys.stdout.write("\n".join(pans))</line-132>
<line-133> </line-133>
|
{"code": "<line-2>import math</line-2>\n<line-130> solve()</line-130>", "lines": [2, 130]}
#### 0
|
<line-1>def main():</line-1>
<line-3> from array import array</line-3>
<line-4> input = sys.stdin.readline</line-4>
<line-5></line-5>
<line-6> class Bit:</line-6>
<line-7> def __init__(self, n):</line-7>
<line-8> self.size = n</line-8>
<line-9> self.size_bit_length = n.bit_length()</line-9>
<line-10> self.tree = array('h', [0] * (n+1))</line-10>
<line-11></line-11>
<line-12> def reset(self):</line-12>
<line-13> self.tree = array('h', [0] * (self.size+1))</line-13>
<line-14></line-14>
<line-15> def sum(self, i):</line-15>
<line-16> s = 0</line-16>
<line-17> while i > 0:</line-17>
<line-18> s += self.tree[i]</line-18>
<line-19> i -= i & -i</line-19>
<line-20> return s</line-20>
<line-21></line-21>
<line-22> def add(self, i, x):</line-22>
<line-23> while i <= self.size:</line-23>
<line-24> self.tree[i] += x</line-24>
<line-25> i += i & -i</line-25>
<line-26></line-26>
<line-27> def lower_bound(self, w):</line-27>
<line-28> if w <= 0:</line-28>
<line-29> return 0</line-29>
<line-30> x = 0</line-30>
<line-31> k = 1 << (self.size_bit_length - 1)</line-31>
<line-32> while k:</line-32>
<line-33> if x + k <= self.size and self.tree[x + k] < w:</line-33>
<line-34> w -= self.tree[x + k]</line-34>
<line-35> x += k</line-35>
<line-36> k >>= 1</line-36>
<line-37> return x + 1</line-37>
<line-38></line-38>
<line-39> N, M = list(map(int, input().split()))</line-39>
<line-40> dist = [0] + list(map(int, input().split()))</line-40>
<line-41> for i in range(N-1):</line-41>
<line-42> dist[i+1] += dist[i]</line-42>
<line-43> B = [0] * (M * N)</line-43>
<line-44> for i in range(N):</line-44>
<line-45> BB = list(map(int, input().split()))</line-45>
<line-46> for j in range(M):</line-46>
<line-47> B[j * N + i] = BB[j] * (N+1) + i+1</line-47>
<line-48></line-48>
<line-49> imos = []</line-49>
<line-50> for i in range(N+1):</line-50>
<line-51> imos.append([0] * (N+1 - i))</line-51>
<line-52> bit = Bit(N)</line-52>
<line-53> for m in range(M):</line-53>
<line-54> bit.reset()</line-54>
<line-55> for bi in sorted(B[m*N: (m+1) * N], reverse=True):</line-55>
<line-56> b, i = divmod(bi, N+1)</line-56>
<line-57> k = bit.sum(i)</line-57>
<line-58> l = bit.lower_bound(k)</line-58>
<line-59> r = bit.lower_bound(k+1)</line-59>
<line-60> imos[l+1][i - (l+1)] += b</line-60>
<line-61> if i != N:</line-61>
<line-62> imos[i+1][0] -= b</line-62>
<line-63> if r != N+1:</line-63>
<line-64> imos[l+1][r - (l+1)] -= b</line-64>
<line-65> if i != N and r != N+1:</line-65>
<line-66> imos[i+1][r - (i+1)] += b</line-66>
<line-67> bit.add(i, 1)</line-67>
<line-68></line-68>
<line-69> for i in range(1, N+1):</line-69>
<line-70> for j in range(i+1, N+1):</line-70>
<line-71> imos[i][j - i] += imos[i][j-1-i]</line-71>
<line-72> for i in range(2, N + 1):</line-72>
<line-73> for j in range(i, N + 1):</line-73>
<line-74> imos[i][j-i] += imos[i - 1][j - (i-1)]</line-74>
<line-75> ans = 0</line-75>
<line-76> for i in range(1, N + 1):</line-76>
<line-77> for j in range(i, N + 1):</line-77>
<line-78> ans = max(ans, imos[i][j-i] - (dist[j - 1] - dist[i - 1]))</line-78>
<line-79> print(ans)</line-79>
<line-80></line-80>
<line-81></line-81>
<line-82>def __starting_point():</line-82>
<line-84></line-84>
<line-85>__starting_point()</line-85>
|
{"code": "<line-2> import sys</line-2>\n<line-83> main()</line-83>", "lines": [2, 83]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-2></line-2>
<line-4>sys.setrecursionlimit(10 ** 6)</line-4>
<line-5></line-5>
<line-6>def main():</line-6>
<line-7> n = int(input())</line-7>
<line-8> adj_list = [[] for i in range(n)]</line-8>
<line-9> for i in range(n - 1):</line-9>
<line-10> a1, b1 = list(map(int, sys.stdin.readline().split()))</line-10>
<line-11> adj_list[a1 - 1].append(b1 - 1)</line-11>
<line-12> adj_list[b1 - 1].append(a1 - 1)</line-12>
<line-13> path = list(reversed(dfs(0, -1, adj_list, n)))</line-13>
<line-14> assert len(path) >= 2</line-14>
<line-15> fpath = len(path) - len(path) // 2</line-15>
<line-16> cut = set(path[fpath - 1:fpath + 1])</line-16>
<line-17> f = dfs2(0, -1, adj_list, n, cut)</line-17>
<line-18> s = dfs2(n - 1, -1, adj_list, n, cut)</line-18>
<line-19> assert f + s == n</line-19>
<line-20> print(("Fennec" if f > s else "Snuke"))</line-20>
<line-21></line-21>
<line-22>def dfs(now, prev, adj_list, n):</line-22>
<line-23> if now == n - 1:</line-23>
<line-24> return [now]</line-24>
<line-25> for next in adj_list[now]:</line-25>
<line-26> if next == prev:</line-26>
<line-27> continue</line-27>
<line-28> p = dfs(next, now, adj_list, n)</line-28>
<line-29> if p is not None:</line-29>
<line-30> p.append(now)</line-30>
<line-31> return p</line-31>
<line-32></line-32>
<line-33>def dfs2(now, prev, adj_list, n, cut):</line-33>
<line-34> size = 1</line-34>
<line-35> for next in adj_list[now]:</line-35>
<line-36> if next == prev:</line-36>
<line-37> continue</line-37>
<line-38> if {now, next} == cut:</line-38>
<line-39> continue</line-39>
<line-40> s = dfs2(next, now, adj_list, n, cut)</line-40>
<line-41> size += s</line-41>
<line-42> return size</line-42>
<line-43></line-43>
<line-44>def __starting_point():</line-44>
<line-46></line-46>
<line-47>__starting_point()</line-47>
|
{"code": "<line-3>import sys</line-3>\n<line-45> main()</line-45>", "lines": [3, 45]}
#### 0
|
<line-1>S = input()</line-1>
<line-3>n = 0</line-3>
<line-4>for c in S:</line-4>
<line-5> if c=='A': n+=1</line-5>
<line-6> SA.append(n)</line-6>
<line-7></line-7>
<line-8>T = input()</line-8>
<line-9>TA = [0]</line-9>
<line-10>n = 0</line-10>
<line-11>for c in T:</line-11>
<line-12> if c=='A': n+=1</line-12>
<line-13> TA.append(n)</line-13>
<line-14></line-14>
<line-15></line-15>
<line-16>q = int(input())</line-16>
<line-17>for _ in range(q):</line-17>
<line-18> a, b, c, d = list(map(int, input().split()))</line-18>
<line-19></line-19>
<line-20> nSA = SA[b]-SA[a-1]</line-20>
<line-21> nSB = b-a+1-nSA</line-21>
<line-22> nTA = TA[d]-TA[c-1]</line-22>
<line-24></line-24>
<line-25> print(('YES' if (nSA-nSB)%3 == (nTA-nTB)%3 else 'NO'))</line-25>
|
{"code": "<line-2>SA = [0]</line-2>\n<line-23> nTB = d-c+1-nTA</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>from collections import defaultdict</line-1>
<line-2></line-2>
<line-4>a = [int(i) for i in input().split()]</line-4>
<line-5></line-5>
<line-6>b = defaultdict(lambda : [float('inf'), 0])</line-6>
<line-7>for i in range(N) :</line-7>
<line-8> b[a[i]][0] = min(b[a[i]][0], i)</line-8>
<line-9> b[a[i]][1] += 1</line-9>
<line-10></line-10>
<line-11># [value, first_appearance, count]</line-11>
<line-12>c = [(0, 0, 0)]</line-12>
<line-13>for k, v in b.items() :</line-13>
<line-14> c.append((k, v[0], v[1]))</line-14>
<line-15>c.sort()</line-15>
<line-16></line-16>
<line-17>ret = [0] * N</line-17>
<line-18>pre_v, pre_i, pre_c = c.pop()</line-18>
<line-19>while c :</line-19>
<line-20> cur_v, cur_i, cur_c = c.pop()</line-20>
<line-21> ret[pre_i] += (pre_v - cur_v) * pre_c</line-21>
<line-22> cur_c += pre_c</line-22>
<line-23> pre_v, pre_i, pre_c = cur_v, min(pre_i, cur_i), cur_c</line-23>
<line-24> </line-24>
<line-26> print(r)</line-26>
|
{"code": "<line-3>N = int(input())</line-3>\n<line-25>for r in ret :</line-25>", "lines": [3, 25]}
#### 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> LR = [list(map(int, input().split())) for _ in range(n)]</line-6>
<line-7> </line-7>
<line-8> BIT = [0]*(m+2)</line-8>
<line-9> def add(i, a):</line-9>
<line-10> while i <= m+1:</line-10>
<line-11> BIT[i] += a</line-11>
<line-12> i += i&(-i)</line-12>
<line-13> def bit_sum(i):</line-13>
<line-14> res = 0</line-14>
<line-15> while i > 0:</line-15>
<line-16> res += BIT[i]</line-16>
<line-17> i -= i&(-i)</line-17>
<line-18> return res</line-18>
<line-19> </line-19>
<line-20> for l, r in LR:</line-20>
<line-21> add(l, 1)</line-21>
<line-22> add(r+1, -1)</line-22>
<line-23> </line-23>
<line-24> S = sorted([(r-l+1, l, r) for l, r in LR])</line-24>
<line-25> cnt = 0</line-25>
<line-26> L = []</line-26>
<line-27> for i in range(m, 0, -1):</line-27>
<line-28> while S and S[-1][0] == i:</line-28>
<line-29> c, l, r = S.pop()</line-29>
<line-30> cnt += 1</line-30>
<line-31> add(l, -1)</line-31>
<line-32> add(r+1, 1)</line-32>
<line-33> res = cnt</line-33>
<line-34> for j in range(0, m+1, i):</line-34>
<line-35> res += bit_sum(j)</line-35>
<line-36> L.append(res)</line-36>
<line-37> print(*L[::-1], sep="\n")</line-37>
<line-38></line-38>
<line-39>def __starting_point():</line-39>
<line-41>__starting_point()</line-41>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-40> main()</line-40>", "lines": [2, 40]}
#### 0
|
<line-1>def fx(s,n,xsum):</line-1>
<line-3> for i in range(n+1):</line-3>
<line-4> sub[0][i]=True</line-4>
<line-5> for i in range(1,xsum+1):</line-5>
<line-6> sub[i][0]=False</line-6>
<line-7> for i in range(1,xsum+1):</line-7>
<line-8> for j in range(1,n+1):</line-8>
<line-9> sub[i][j]=sub[i][j-1]</line-9>
<line-10> if i>=s[j-1]:</line-10>
<line-11> sub[i][j]=sub[i][j] or sub[i-s[j-1]][j-1]</line-11>
<line-12> if sub[xsum][n]:</line-12>
<line-13> print('Yes')</line-13>
<line-14> else:</line-14>
<line-15> print('No')</line-15>
<line-16> </line-16>
<line-17>n,t=list(map(int,input().split()))</line-17>
<line-18>a=list(map(int,input().split()))</line-18>
<line-19>for _ in range(t):</line-19>
<line-20> q=list(map(int,input().split()))</line-20>
<line-21> if q[0]==1:</line-21>
<line-22> a[q[1]-1]=q[2]</line-22>
<line-23> continue</line-23>
<line-24> if q[0]==2:</line-24>
<line-25> w=a[q[1]-1:q[2]]</line-25>
<line-26> a[q[1]-1:q[2]]=w[::-1]</line-26>
<line-27> continue</line-27>
<line-28> if q[0]==3:</line-28>
<line-29> e=a[q[1]-1:q[2]]</line-29>
<line-30> if q[3]<min(e) or q[3]>sum(e):</line-30>
<line-31> print('No')</line-31>
<line-32> continue</line-32>
<line-33> if q[3] in e:</line-33>
<line-34> print('Yes')</line-34>
<line-36> fx(e,len(e),q[3])</line-36>
|
{"code": "<line-2>\tsub=[[None for x in range(n+2)]for y in range(xsum+2)]</line-2>\n<line-35>\t\t\tcontinue</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>mod =(10**9)+7</line-1>
<line-3>a = [int(i) for i in input().split()]</line-3>
<line-4>b = [int(i) for i in input().split()]</line-4>
<line-5>dp = []</line-5>
<line-6>for i in range(n):</line-6>
<line-7> dp += [[0]*m]</line-7>
<line-8>dp[-1][-1]=1</line-8>
<line-9>for i in range(n-2,-1,-1):</line-9>
<line-10> dp[i][-1]=1</line-10>
<line-11> for j in range(m-1):</line-11>
<line-12> x = (a[i]+b[j])-(b[j+1])</line-12>
<line-13> temp = 0</line-13>
<line-14> for k in range(i+1,n):</line-14>
<line-15> if(a[k]>=x):</line-15>
<line-16> temp += dp[k][j+1]</line-16>
<line-17> dp[i][j]=temp</line-17>
<line-18>ans = 0</line-18>
<line-19>for i in range(n):</line-19>
<line-21>print(ans%mod)</line-21>
<line-22> </line-22>
|
{"code": "<line-2>n,m = list(map(int,input().split()))</line-2>\n<line-20> ans += dp[i][0]</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>s = input()</line-1>
<line-2></line-2>
<line-4> print((-1))</line-4>
<line-5>elif s[:-1] != s[-2::-1]:</line-5>
<line-6> print((-1))</line-6>
<line-7>else:</line-7>
<line-8> half = len(s) // 2</line-8>
<line-9> one_indices = [i+1 for i in range(1, half) if s[i] == '1'] # not including 0 or larger than n//2</line-9>
<line-10></line-10>
<line-11> parents = [0] * (len(s) + 1)</line-11>
<line-12> parent_index = 1</line-12>
<line-13> for index in one_indices:</line-13>
<line-14> for i in range(parent_index, index):</line-14>
<line-15> parents[i] = index</line-15>
<line-16> parent_index = index</line-16>
<line-17></line-17>
<line-18> root = parent_index + 1</line-18>
<line-19> parents[parent_index] = root</line-19>
<line-20> for index in range(root + 1, len(s) + 1):</line-20>
<line-21> parents[index] = root</line-21>
<line-22></line-22>
<line-23> for node, parent in enumerate(parents):</line-23>
<line-24> if parent == 0: # This means node is 0 or the root of the tree.</line-24>
<line-26> print((node, parent))</line-26>
|
{"code": "<line-3>if s[0] == '0' or s[-2] == '0' or s[-1] == '1': # 's' should be like \"1xx...x0\"</line-3>\n<line-25> continue</line-25>", "lines": [3, 25]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-3>input = stdin.readline</line-3>
<line-4>def getint(): return int(input())</line-4>
<line-5>def getints(): return list(map(int, input().split()))</line-5>
<line-6>def getint1(): return list([int(x) - 1 for x in input().split()])</line-6>
<line-7>def getstr(): return input()[:-1]</line-7>
<line-8></line-8>
<line-9></line-9>
<line-10>def solve():</line-10>
<line-11> n, a, b = getint1()</line-11>
<line-12> n += 1</line-12>
<line-13> adj = [[] for _ in range(n)]</line-13>
<line-14> for _ in range(n - 1):</line-14>
<line-15> u, v = getint1()</line-15>
<line-16> adj[u].append(v)</line-16>
<line-17> adj[v].append(u)</line-17>
<line-18> # dfs 1</line-18>
<line-19> max_child = [[-1] * 3 for _ in range(n)]</line-19>
<line-20> stack = [(a, -1, 1)] # (node, parent)</line-20>
<line-21> while stack:</line-21>
<line-22> u, p, flag = stack.pop()</line-22>
<line-23> if p != -1 and len(adj[u]) < 2:</line-23>
<line-24> max_child[u][0] = 1</line-24>
<line-25> continue</line-25>
<line-26> if flag == 1:</line-26>
<line-27> stack.append((u, p, 0))</line-27>
<line-28> for v in adj[u]:</line-28>
<line-29> if v == p:</line-29>
<line-30> continue</line-30>
<line-31> stack.append((v, u, 1))</line-31>
<line-32> else:</line-32>
<line-33> for v in adj[u]:</line-33>
<line-34> if v == p:</line-34>
<line-35> continue</line-35>
<line-36> len_v = max_child[v][0] + 1</line-36>
<line-37> if len_v > max_child[u][0]:</line-37>
<line-38> max_child[u][2] = max_child[u][1]</line-38>
<line-39> max_child[u][1] = max_child[u][0]</line-39>
<line-40> max_child[u][0] = len_v</line-40>
<line-41> elif len_v > max_child[u][1]:</line-41>
<line-42> max_child[u][2] = max_child[u][1]</line-42>
<line-43> max_child[u][1] = len_v</line-43>
<line-44> elif len_v > max_child[u][2]:</line-44>
<line-45> max_child[u][2] = len_v</line-45>
<line-46> # end of dfs 1</line-46>
<line-47> # dfs 2</line-47>
<line-48> body = []</line-48>
<line-49> ret = [False] * n</line-49>
<line-50> max_parent = [-1] * n</line-50>
<line-51> stack.clear()</line-51>
<line-52> stack = [(a, -1, 0)] # (node, parent, max len from parent)</line-52>
<line-53> while stack:</line-53>
<line-54> u, p, mxp = stack.pop()</line-54>
<line-55> if mxp >= 0:</line-55>
<line-56> stack.append((u, p, -1))</line-56>
<line-57> if p != -1 and len(adj[u]) < 2:</line-57>
<line-58> continue</line-58>
<line-59> max_parent[u] = mxp + 1</line-59>
<line-60> chlen = [max_parent[u], -3]</line-60>
<line-61> for v in adj[u]:</line-61>
<line-62> if v == p:</line-62>
<line-63> continue</line-63>
<line-64> len_v = max_child[v][0] + 1</line-64>
<line-65> if len_v > chlen[0]:</line-65>
<line-66> chlen[1] = chlen[0]</line-66>
<line-67> chlen[0] = len_v</line-67>
<line-68> elif len_v > chlen[1]:</line-68>
<line-69> chlen[1] = len_v</line-69>
<line-70> for v in adj[u]:</line-70>
<line-71> if v == p:</line-71>
<line-72> continue</line-72>
<line-73> stack.append(</line-73>
<line-74> (v, u, chlen[int(max_child[v][0] + 1 == chlen[0])]))</line-74>
<line-75> else:</line-75>
<line-76> is_body = (u == b)</line-76>
<line-77> if not is_body:</line-77>
<line-78> for v in adj[u]:</line-78>
<line-79> if v != p and ret[v]:</line-79>
<line-80> is_body = True</line-80>
<line-81> break</line-81>
<line-82> if is_body:</line-82>
<line-83> body.append(u)</line-83>
<line-84> ret[u] = is_body</line-84>
<line-85> del ret</line-85>
<line-86> # end of dfs2</line-86>
<line-87> ok = False</line-87>
<line-88> body_len = len(body)</line-88>
<line-89> can_turn = [False] * n</line-89>
<line-90> for i in range(n):</line-90>
<line-91> if 3 <= sum(1 for l in max_child[i] + [max_parent[i]] if l >= body_len):</line-91>
<line-92> can_turn[i] = True</line-92>
<line-93> ok = True</line-93>
<line-94> if not ok:</line-94>
<line-95> print("NO")</line-95>
<line-96> return</line-96>
<line-97> treelen = [1] * body_len</line-97>
<line-98> # print(body)</line-98>
<line-99> for i in range(body_len):</line-99>
<line-100> cur = body[i]</line-100>
<line-101> pre = -1 if i == 0 else body[i - 1]</line-101>
<line-102> nxt = -1 if i + 1 == body_len else body[i + 1]</line-102>
<line-103> for v in adj[cur]:</line-103>
<line-104> if v == pre or v == nxt:</line-104>
<line-105> continue</line-105>
<line-106> treelen[i] = max(treelen[i], max_child[v][0] + 1)</line-106>
<line-107> if can_turn[v]:</line-107>
<line-108> can_turn[cur] = True</line-108>
<line-109> continue</line-109>
<line-110> # dfs 3</line-110>
<line-111> stack = [(v, cur)]</line-111>
<line-112> while stack and not can_turn[cur]:</line-112>
<line-113> u, p = stack.pop()</line-113>
<line-114> for w in adj[u]:</line-114>
<line-115> if w == p:</line-115>
<line-116> continue</line-116>
<line-117> if can_turn[w]:</line-117>
<line-118> can_turn[cur] = True</line-118>
<line-119> break</line-119>
<line-120> stack.append((w, u))</line-120>
<line-121> stack.clear()</line-121>
<line-122> # end of dfs 3</line-122>
<line-123> # print(i, cur, can_turn[cur])</line-123>
<line-124> # use two pointer to find if we can enter the turing point</line-124>
<line-125> # print(body_len, treelen)</line-125>
<line-126> l = 0</line-126>
<line-127> r = body_len - 1</line-127>
<line-128> lmax = treelen[r] - 1</line-128>
<line-129> rmin = body_len - treelen[l]</line-129>
<line-130> ok = (can_turn[body[l]] or can_turn[body[r]])</line-130>
<line-131> while not ok and (l < lmax or rmin < r):</line-131>
<line-132> if l < lmax:</line-132>
<line-133> l += 1</line-133>
<line-134> rmin = min(rmin, l + (body_len - treelen[l]))</line-134>
<line-135> if rmin < r:</line-135>
<line-136> r -= 1</line-136>
<line-137> lmax = max(lmax, r - (body_len - treelen[r]))</line-137>
<line-138> if can_turn[body[l]] or can_turn[body[r]]:</line-138>
<line-139> ok = True</line-139>
<line-140> ##</line-140>
<line-141> print("YES" if ok else "NO")</line-141>
<line-142> return</line-142>
<line-143> # end of solve</line-143>
<line-144></line-144>
<line-145></line-145>
<line-146>def __starting_point():</line-146>
<line-147> # solve()</line-147>
<line-148> # for t in range(getint()):</line-148>
<line-149> # print('Case #', t + 1, ': ', sep='')</line-149>
<line-150> # solve()</line-150>
<line-151> for _ in range(getint()):</line-151>
<line-153></line-153>
<line-154>__starting_point()</line-154>
|
{"code": "<line-2>import itertools</line-2>\n<line-152> solve()</line-152>", "lines": [2, 152]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>from collections import deque</line-4>
<line-5></line-5>
<line-6>t=int(input())</line-6>
<line-7>for testcaess in range(t):</line-7>
<line-8> n,m,a,b=list(map(int,input().split()))</line-8>
<line-9> E=[[] for i in range(n+1)]</line-9>
<line-10></line-10>
<line-11> for i in range(m):</line-11>
<line-12> x,y=list(map(int,input().split()))</line-12>
<line-13> E[x].append(y)</line-13>
<line-14> E[y].append(x)</line-14>
<line-15></line-15>
<line-16> USE1=[0]*(n+1)</line-16>
<line-17></line-17>
<line-18> Q=deque()</line-18>
<line-19> Q.append(a)</line-19>
<line-20></line-20>
<line-21> USE1[a]=1</line-21>
<line-22></line-22>
<line-23> while Q:</line-23>
<line-24> x=Q.pop()</line-24>
<line-25></line-25>
<line-26> for to in E[x]:</line-26>
<line-27> if to==b:</line-27>
<line-28> continue</line-28>
<line-29> if USE1[to]==0:</line-29>
<line-30> USE1[to]=1</line-30>
<line-31> Q.append(to)</line-31>
<line-32></line-32>
<line-33> USE2=[0]*(n+1)</line-33>
<line-34></line-34>
<line-35> Q=deque()</line-35>
<line-36> Q.append(b)</line-36>
<line-37></line-37>
<line-38> USE2[b]=1</line-38>
<line-39></line-39>
<line-40> while Q:</line-40>
<line-41> x=Q.pop()</line-41>
<line-42></line-42>
<line-43> for to in E[x]:</line-43>
<line-44> if to==a:</line-44>
<line-45> continue</line-45>
<line-46> if USE2[to]==0:</line-46>
<line-47> USE2[to]=1</line-47>
<line-48> Q.append(to)</line-48>
<line-49></line-49>
<line-50> #print(USE1,USE2)</line-50>
<line-51></line-51>
<line-52> ANS1=0</line-52>
<line-53> ANS2=0</line-53>
<line-54></line-54>
<line-55> for i in range(n+1):</line-55>
<line-56> if i==a or i==b:</line-56>
<line-57> continue</line-57>
<line-58> if USE1[i]==1 and USE2[i]==0:</line-58>
<line-59> ANS1+=1</line-59>
<line-60> elif USE1[i]==0 and USE2[i]==1:</line-60>
<line-62></line-62>
<line-63> print(ANS1*ANS2)</line-63>
<line-64> </line-64>
<line-65></line-65>
<line-66> </line-66>
<line-67></line-67>
<line-68> </line-68>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-61> ANS2+=1</line-61>", "lines": [2, 61]}
#### 0
|
<line-1>import sys</line-1>
<line-3>out = []</line-3>
<line-4></line-4>
<line-5>t = int(input())</line-5>
<line-6>for _ in range(t):</line-6>
<line-7> n = int(input())</line-7>
<line-8> n -= 1</line-8>
<line-9> rem = n % 3</line-9>
<line-10> n //= 3</line-10>
<line-11> </line-11>
<line-12> s = []</line-12>
<line-13> if n:</line-13>
<line-14> n -= 1</line-14>
<line-15> while n >= 0:</line-15>
<line-16> s.append([['00','00','00'],['01','10','11'],['10','11','01'],['11','01','10']][n % 4][rem])</line-16>
<line-17> n //= 4</line-17>
<line-18> n -= 1</line-18>
<line-19></line-19>
<line-20> s.append(['1','10','11'][rem])</line-20>
<line-21></line-21>
<line-22> s.reverse()</line-22>
<line-23></line-23>
<line-25>print('\n'.join(map(str,out)))</line-25>
<line-26> </line-26>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-24> out.append(int(''.join(s),2))</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>T = int(readline())</line-4>
<line-5>Ans = [None]*T</line-5>
<line-6>for qu in range(T):</line-6>
<line-7> S = [1 if s == 'A' else 0 for s in readline().strip()]</line-7>
<line-8> stack = []</line-8>
<line-9> for s in S:</line-9>
<line-10> if s:</line-10>
<line-11> stack.append(s)</line-11>
<line-12> else:</line-12>
<line-13> if stack and stack[-1] == 1:</line-13>
<line-14> stack.pop()</line-14>
<line-15> else:</line-15>
<line-16> stack.append(s)</line-16>
<line-17> stack2 = []</line-17>
<line-18> for s in stack:</line-18>
<line-19> if s:</line-19>
<line-20> stack2.append(s)</line-20>
<line-21> else:</line-21>
<line-22> if stack2 and stack2[-1] == 0:</line-22>
<line-23> stack2.pop()</line-23>
<line-24> else:</line-24>
<line-25> stack2.append(s)</line-25>
<line-27></line-27>
<line-28>print('\n'.join(map(str, Ans)))</line-28>
|
{"code": "<line-2>readline = sys.stdin.readline</line-2>\n<line-26> Ans[qu] = len(stack2)</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>import sys</line-1>
<line-3>t = int(input())</line-3>
<line-4>out = []</line-4>
<line-5>for _ in range(t):</line-5>
<line-6> n = int(input())</line-6>
<line-7> l = list(map(int,input().split()))</line-7>
<line-8></line-8>
<line-9> smol = l[0]</line-9>
<line-10> works = True</line-10>
<line-11> for i in range(1, n):</line-11>
<line-12> if l[i] == l[i-1] + 1:</line-12>
<line-13> pass</line-13>
<line-14> else:</line-14>
<line-15> if l[i] > smol:</line-15>
<line-16> works = False</line-16>
<line-17> break</line-17>
<line-18> smol = min(smol, l[i])</line-18>
<line-19></line-19>
<line-20> if works:</line-20>
<line-21> out.append('Yes')</line-21>
<line-22> else:</line-22>
<line-24>print('\n'.join(out))</line-24>
|
{"code": "<line-2>input= sys.stdin.readline</line-2>\n<line-23> out.append('No')</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>parity = 0</line-3>
<line-4>explore = set(l)</line-4>
<line-5>while len(explore) > 0:</line-5>
<line-6> x = explore.pop()</line-6>
<line-7> tmp = x</line-7>
<line-8> found = [x]</line-8>
<line-9> while l[tmp] != x:</line-9>
<line-10> tmp = l[tmp]</line-10>
<line-11> found.append(tmp)</line-11>
<line-12> for i in found[1:]:</line-12>
<line-13> explore.remove(i)</line-13>
<line-14> parity ^= (len(found) - 1) % 2</line-14>
<line-15></line-15>
<line-16>if parity == n % 2:</line-16>
<line-17> print("Petr")</line-17>
<line-19> print("Um_nik")</line-19>
|
{"code": "<line-2>l = [int(x) - 1 for x in input().split()]</line-2>\n<line-18>else:</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from collections import Counter</line-3>
<line-4></line-4>
<line-5>t=int(input())</line-5>
<line-6>for testcases in range(t):</line-6>
<line-7> n=int(input())</line-7>
<line-8> P=list(map(int,input().split()))</line-8>
<line-9> C=Counter(P)</line-9>
<line-10> PLIST=sorted(set(P),reverse=True)</line-10>
<line-11></line-11>
<line-12> g=C[PLIST[0]]</line-12>
<line-13> s=0</line-13>
<line-14> b=0</line-14>
<line-15></line-15>
<line-16> sflag=1</line-16>
<line-17></line-17>
<line-18> for i in PLIST[1:]:</line-18>
<line-19></line-19>
<line-20> if sflag:</line-20>
<line-21> if s<=g:</line-21>
<line-22> s+=C[i]</line-22>
<line-23> else:</line-23>
<line-24> sflag=0</line-24>
<line-25> bflag=1</line-25>
<line-26> b+=C[i]</line-26>
<line-27></line-27>
<line-28> elif bflag:</line-28>
<line-29> if b<=g:</line-29>
<line-30> b+=C[i]</line-30>
<line-31> elif g+s+b+C[i]<=n//2:</line-31>
<line-32> b+=C[i]</line-32>
<line-33> else:</line-33>
<line-34> break</line-34>
<line-35></line-35>
<line-36> #print(i,g,s,b)</line-36>
<line-37></line-37>
<line-38> if g+s+b<=n//2:</line-38>
<line-39> print(g,s,b)</line-39>
<line-41> print(0,0,0)</line-41>
<line-42> </line-42>
<line-43> </line-43>
<line-44> </line-44>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-40> else:</line-40>", "lines": [2, 40]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from collections import deque</line-3>
<line-4></line-4>
<line-5>t=int(input())</line-5>
<line-6>for tests in range(t):</line-6>
<line-7> n=int(input())</line-7>
<line-8></line-8>
<line-9> a=input().strip()</line-9>
<line-10> b=input().strip()</line-10>
<line-11></line-11>
<line-12></line-12>
<line-13> Q=deque(a)</line-13>
<line-14></line-14>
<line-15> L=[]</line-15>
<line-16> while Q:</line-16>
<line-17> L.append(Q.popleft())</line-17>
<line-18></line-18>
<line-19> if Q:</line-19>
<line-20> L.append(Q.pop())</line-20>
<line-21></line-21>
<line-22> ANS=[]</line-22>
<line-23> for i in range(n):</line-23>
<line-24> if i%2==0:</line-24>
<line-25> if L[i]==b[-1-i]:</line-25>
<line-26> ANS.append(1)</line-26>
<line-27> else:</line-27>
<line-28> if L[i]!=b[-1-i]:</line-28>
<line-29> ANS.append(1)</line-29>
<line-30></line-30>
<line-32></line-32>
<line-33> print(len(ANS),*ANS)</line-33>
<line-34> </line-34>
<line-35></line-35>
<line-36> </line-36>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-31> ANS.append(n-i)</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from collections import deque</line-3>
<line-4></line-4>
<line-5>t=int(input())</line-5>
<line-6>for tests in range(t):</line-6>
<line-7> n=int(input())</line-7>
<line-8></line-8>
<line-9> a=input().strip()</line-9>
<line-10> b=input().strip()</line-10>
<line-11></line-11>
<line-12></line-12>
<line-13> Q=deque(a)</line-13>
<line-14></line-14>
<line-15> L=[]</line-15>
<line-16> while Q:</line-16>
<line-17> L.append(Q.popleft())</line-17>
<line-18></line-18>
<line-19> if Q:</line-19>
<line-20> L.append(Q.pop())</line-20>
<line-21></line-21>
<line-22> ANS=[]</line-22>
<line-23> for i in range(n):</line-23>
<line-24> if i%2==0:</line-24>
<line-25> if L[i]==b[-1-i]:</line-25>
<line-26> ANS.append(1)</line-26>
<line-27> else:</line-27>
<line-28> if L[i]!=b[-1-i]:</line-28>
<line-29> ANS.append(1)</line-29>
<line-30></line-30>
<line-32></line-32>
<line-33> print(len(ANS),*ANS)</line-33>
<line-34> </line-34>
<line-35></line-35>
<line-36> </line-36>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-31> ANS.append(n-i)</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> n = int(input())</line-4>
<line-5> l = [int(x) for x in input().split()]</line-5>
<line-6> cur = l[0]</line-6>
<line-7> cll = 1</line-7>
<line-8> blocks = []</line-8>
<line-9> for x in l[1:]:</line-9>
<line-10> if x > cur:</line-10>
<line-11> blocks.append(cll)</line-11>
<line-12> cur = x</line-12>
<line-13> cll = 1</line-13>
<line-14> else:</line-14>
<line-15> cll += 1</line-15>
<line-16> blocks.append(cll)</line-16>
<line-17></line-17>
<line-18> poss = [[False]*(n+1) for _ in range(len(blocks) + 1)]</line-18>
<line-19> poss[0][0] = True</line-19>
<line-20> for i, b in enumerate(blocks):</line-20>
<line-21> for j in range(n+1):</line-21>
<line-22> poss[i+1][j] = poss[i][j]</line-22>
<line-23> if b <= j:</line-23>
<line-24> poss[i+1][j] |= poss[i][j-b]</line-24>
<line-25></line-25>
<line-26> # print()</line-26>
<line-27> # print(blocks)</line-27>
<line-28> # for r in poss:</line-28>
<line-30> print("YES" if poss[len(blocks)][n] else "NO")</line-30>
|
{"code": "<line-3>for _ in range(t):</line-3>\n<line-29> # print(r)</line-29>", "lines": [3, 29]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>class Segtree:</line-4>
<line-5> def __init__(self, A, intv, initialize = True, segf = max):</line-5>
<line-6> self.N = len(A)</line-6>
<line-7> self.N0 = 2**(self.N-1).bit_length()</line-7>
<line-8> self.intv = intv</line-8>
<line-9> self.segf = segf</line-9>
<line-10> if initialize:</line-10>
<line-11> self.data = [intv]*self.N0 + A + [intv]*(self.N0 - self.N)</line-11>
<line-12> for i in range(self.N0-1, 0, -1):</line-12>
<line-13> self.data[i] = self.segf(self.data[2*i], self.data[2*i+1]) </line-13>
<line-14> else:</line-14>
<line-15> self.data = [intv]*(2*self.N0)</line-15>
<line-16> </line-16>
<line-17> def update(self, k, x):</line-17>
<line-18> k += self.N0</line-18>
<line-19> self.data[k] = x</line-19>
<line-20> while k > 0 :</line-20>
<line-21> k = k >> 1</line-21>
<line-22> self.data[k] = self.segf(self.data[2*k], self.data[2*k+1])</line-22>
<line-23> </line-23>
<line-24> def query(self, l, r):</line-24>
<line-25> L, R = l+self.N0, r+self.N0</line-25>
<line-26> s = self.intv</line-26>
<line-27> while L < R:</line-27>
<line-28> if R & 1:</line-28>
<line-29> R -= 1</line-29>
<line-30> s = self.segf(s, self.data[R])</line-30>
<line-31> if L & 1:</line-31>
<line-32> s = self.segf(s, self.data[L])</line-32>
<line-33> L += 1</line-33>
<line-34> L >>= 1</line-34>
<line-35> R >>= 1</line-35>
<line-36> return s</line-36>
<line-37> </line-37>
<line-38> def binsearch(self, l, r, check, reverse = False):</line-38>
<line-39> L, R = l+self.N0, r+self.N0</line-39>
<line-40> SL, SR = [], []</line-40>
<line-41> while L < R:</line-41>
<line-42> if R & 1:</line-42>
<line-43> R -= 1</line-43>
<line-44> SR.append(R)</line-44>
<line-45> if L & 1:</line-45>
<line-46> SL.append(L)</line-46>
<line-47> L += 1</line-47>
<line-48> L >>= 1</line-48>
<line-49> R >>= 1</line-49>
<line-50> </line-50>
<line-51> if reverse:</line-51>
<line-52> for idx in (SR + SL[::-1]):</line-52>
<line-53> if check(self.data[idx]):</line-53>
<line-54> break</line-54>
<line-55> else:</line-55>
<line-56> return -1</line-56>
<line-57> while idx < self.N0:</line-57>
<line-58> if check(self.data[2*idx+1]):</line-58>
<line-59> idx = 2*idx + 1</line-59>
<line-60> else:</line-60>
<line-61> idx = 2*idx</line-61>
<line-62> return idx - self.N0</line-62>
<line-63> else:</line-63>
<line-64> for idx in (SL + SR[::-1]):</line-64>
<line-65> if check(self.data[idx]):</line-65>
<line-66> break</line-66>
<line-67> else:</line-67>
<line-68> return -1</line-68>
<line-69> while idx < self.N0:</line-69>
<line-70> if check(self.data[2*idx]):</line-70>
<line-71> idx = 2*idx</line-71>
<line-72> else:</line-72>
<line-73> idx = 2*idx + 1</line-73>
<line-74> return idx - self.N0</line-74>
<line-75></line-75>
<line-76>Tc = int(readline())</line-76>
<line-77>Ans = [None]*Tc</line-77>
<line-78></line-78>
<line-79>for qu in range(Tc):</line-79>
<line-80> N, M, K = list(map(int, readline().split()))</line-80>
<line-81> A = list(map(int, readline().split()))</line-81>
<line-82> Ai = A[::-1]</line-82>
<line-83> table = [None]*M</line-83>
<line-84> for i in range(M):</line-84>
<line-85> j = (M-1)-i</line-85>
<line-86> table[i] = max(A[i], Ai[j])</line-86>
<line-87> inf = 10**9+7</line-87>
<line-88> T = Segtree(table, inf, initialize = True, segf = min)</line-88>
<line-89> ans = min(table)</line-89>
<line-90> K = min(K, M-1)</line-90>
<line-91> R = M-1-K</line-91>
<line-92> for ki in range(K+1):</line-92>
<line-93> ans = max(ans, T.query(ki, ki+R+1))</line-93>
<line-95>print('\n'.join(map(str, Ans)))</line-95>
<line-96> </line-96>
<line-97> </line-97>
|
{"code": "<line-2>readline = sys.stdin.readline</line-2>\n<line-94> Ans[qu] = ans</line-94>", "lines": [2, 94]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>for _ in range(int(input())):</line-5>
<line-6> n = int(input())</line-6>
<line-7> a = list(map(int,input().split()))</line-7>
<line-8> for i in range(n-1,0,-1):</line-8>
<line-9> a[i] -= a[i-1]</line-9>
<line-10></line-10>
<line-11> minus = 0</line-11>
<line-12> for i in range(1,n):</line-12>
<line-13> if a[i]<0:</line-13>
<line-14> minus -= a[i]</line-14>
<line-15></line-15>
<line-16> if a[0] - minus >=0:</line-16>
<line-17> print("YES")</line-17>
<line-19> print("NO")</line-19>
|
{"code": "<line-3>input = sys.stdin.readline</line-3>\n<line-18> else:</line-18>", "lines": [3, 18]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> d, m = list(map(int, input().split()))</line-3>
<line-4> d += 1</line-4>
<line-5> out = 1</line-5>
<line-6> curr = 2</line-6>
<line-7> while curr < d:</line-7>
<line-8> out *= (curr // 2) + 1</line-8>
<line-9> out %= m</line-9>
<line-10> curr *= 2</line-10>
<line-12> print((out - 1) % m)</line-12>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-11> out *= (d - curr // 2 + 1)</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>T = int(input())</line-4>
<line-5>for _ in range(T):</line-5>
<line-6> N, M = list(map(int, input().split()))</line-6>
<line-7> X = [[] for i in range(3*N)]</line-7>
<line-8> for i in range(M):</line-8>
<line-9> x, y = list(map(int, input().split()))</line-9>
<line-10> x, y = min(x,y), max(x,y)</line-10>
<line-11> X[x-1].append((y-1, i+1))</line-11>
<line-12> </line-12>
<line-13> MAT = []</line-13>
<line-14> IND = []</line-14>
<line-15> DONE = [0] * 3*N</line-15>
<line-16> for i in range(3*N):</line-16>
<line-17> if DONE[i]: continue</line-17>
<line-18> for j, ind in X[i]:</line-18>
<line-19> if DONE[j] == 0:</line-19>
<line-20> MAT.append(ind)</line-20>
<line-21> DONE[i] = 1</line-21>
<line-22> DONE[j] = 1</line-22>
<line-23> break</line-23>
<line-24> else:</line-24>
<line-25> IND.append(i+1)</line-25>
<line-26></line-26>
<line-27> if len(MAT) >= N:</line-27>
<line-28> print("Matching")</line-28>
<line-29> print(*MAT[:N])</line-29>
<line-30> else:</line-30>
<line-32> print(*IND[:N])</line-32>
<line-33></line-33>
<line-34></line-34>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-31> print(\"IndSet\")</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>mod = 998244353</line-1>
<line-3>f1 = [ [0 for i in range(11)] for j in range(2010) ]</line-3>
<line-4>fac = [0 for i in range(2010)]</line-4>
<line-5>tab = [0 for i in range(11)]</line-5>
<line-6>C = [ [0 for i in range(2010)] for j in range(2010) ]</line-6>
<line-7></line-7>
<line-8>def Init() :</line-8>
<line-9> fac[0] = 1</line-9>
<line-10> for i in range(2010) :</line-10>
<line-11> if i > 0 : fac[i] = fac[i - 1] * i % mod</line-11>
<line-12> C[i][0] = 1</line-12>
<line-13> for j in range(1, 2010) :</line-13>
<line-14> C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod</line-14>
<line-15></line-15>
<line-16>def len(x) :</line-16>
<line-17> res = 0</line-17>
<line-18> while x > 0 :</line-18>
<line-19> res += 1</line-19>
<line-20> x = x // 10</line-20>
<line-21> return res</line-21>
<line-22> </line-22>
<line-23>def solve() :</line-23>
<line-24> n = int(input())</line-24>
<line-25> f0[0][0] = f1[0][0] = 1</line-25>
<line-26> a = list(map(int, input().split()))</line-26>
<line-27> c0, c1 = 0, 0</line-27>
<line-28> s0, s1 = 0, 0</line-28>
<line-29> for nu in a :</line-29>
<line-30> m = nu % 11</line-30>
<line-31> if len(nu) & 1 :</line-31>
<line-32> c1 += 1</line-32>
<line-33> s1 += m</line-33>
<line-34> for i in range(11) :</line-34>
<line-35> f1[c1][i] = 0</line-35>
<line-36> for i in range(c1 - 1, -1, -1) :</line-36>
<line-37> for j in range(11) :</line-37>
<line-38> if f1[i][j] == 0 : continue</line-38>
<line-39> f1[i + 1][(j + m) % 11] += f1[i][j]</line-39>
<line-40> f1[i + 1][(j + m) % 11] %= mod</line-40>
<line-41> else :</line-41>
<line-42> c0 += 1</line-42>
<line-43> s0 += m</line-43>
<line-44> for i in range(11) :</line-44>
<line-45> f0[c0][i] = 0</line-45>
<line-46> for i in range(c0 - 1, -1, -1) :</line-46>
<line-47> for j in range(11) :</line-47>
<line-48> if f0[i][j] == 0 : continue</line-48>
<line-49> f0[i + 1][(j + m) % 11] += f0[i][j]</line-49>
<line-50> f0[i + 1][(j + m) % 11] %= mod</line-50>
<line-51> s1 %= 11</line-51>
<line-52> s0 %= 11</line-52>
<line-53> part = c1 // 2</line-53>
<line-54> for i in range(11) :</line-54>
<line-55> tab[i] = 0</line-55>
<line-56> for i in range(11) :</line-56>
<line-57> tab[(i + i + 11 - s1) % 11] = f1[c1 - part][i]</line-57>
<line-58> for i in range(11) :</line-58>
<line-59> tab[i] = tab[i] * fac[part] % mod * fac[c1 - part] % mod</line-59>
<line-60></line-60>
<line-61> ans = 0</line-61>
<line-62> if c1 == 0 :</line-62>
<line-63> ans = f0[c0][0] * fac[c0]</line-63>
<line-64> elif c0 == 0 :</line-64>
<line-65> ans = tab[0]</line-65>
<line-66> else :</line-66>
<line-67> for i in range(c0 + 1) :</line-67>
<line-68> for j in range(11) :</line-68>
<line-69> if f0[i][j] == 0 : continue</line-69>
<line-70> # print(f0[i][j], tab[(j + j + 11 - s0) % 11] \</line-70>
<line-71> # , fac[i] % mod * fac[c0 - i] % mod, C[j + (c1 - part) - 1][(c1 - part) - 1] % mod * C[part + c0 - i][part] % mod )</line-71>
<line-72> ans = ( ans \</line-72>
<line-73> + fac[i] % mod * fac[c0 - i] % mod \</line-73>
<line-74> * f0[i][j] * tab[(j + j + 11 - s0) % 11] % mod \</line-74>
<line-75> * C[i + (c1 - part) - 1][(c1 - part) - 1] % mod \</line-75>
<line-76> * C[part + c0 - i][part]</line-76>
<line-77> ) % mod</line-77>
<line-78> print(ans)</line-78>
<line-79></line-79>
<line-80>Init()</line-80>
<line-82>for ttt in range(T) : solve()</line-82>
|
{"code": "<line-2>f0 = [ [0 for i in range(11)] for j in range(2010) ]</line-2>\n<line-81>T = int(input())</line-81>", "lines": [2, 81]}
#### 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,d=mii()</line-8>
<line-9> a=list(mii())</line-9>
<line-10> ans=0</line-10>
<line-11> for i in range(n):</line-11>
<line-12> while d>=i and a[i]:</line-12>
<line-13> a[i]-=1</line-13>
<line-14> ans+=1</line-14>
<line-16> print(ans)</line-16>
|
{"code": "<line-3>#sys.stdin=open(\"data.txt\")</line-3>\n<line-15> d-=i</line-15>", "lines": [3, 15]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>t = int(input())</line-4>
<line-5>for _ in range(t):</line-5>
<line-6> n, k = list(map(int, input().split()))</line-6>
<line-7> s = input()</line-7>
<line-8> l = ['']*k</line-8>
<line-9> works = True</line-9>
<line-10> for i in range(n):</line-10>
<line-11> c = s[i]</line-11>
<line-12> if c != '?':</line-12>
<line-13> if l[i%k] == c or l[i%k] == '':</line-13>
<line-14> l[i%k] = c</line-14>
<line-15> else:</line-15>
<line-16> works = False</line-16>
<line-17> break</line-17>
<line-18> if works:</line-18>
<line-19> smol = 0</line-19>
<line-20> big = k</line-20>
<line-21> for c in l:</line-21>
<line-22> if c == '0':</line-22>
<line-23> big -= 1</line-23>
<line-24> elif c == '1':</line-24>
<line-25> smol += 1</line-25>
<line-26> goal = k//2</line-26>
<line-27> if smol <= goal <= big:</line-27>
<line-28> print('YES')</line-28>
<line-29> else:</line-29>
<line-30> print('NO')</line-30>
<line-32> print('NO')</line-32>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-31> else:</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>N = int(input())</line-1>
<line-3>L = int(input())</line-3>
<line-4></line-4>
<line-5>def one_step(i):</line-5>
<line-6> goal = X[i] + L</line-6>
<line-7> </line-7>
<line-8> # find largest j s.t. X[j] <= X[i] + L</line-8>
<line-9> low = 0</line-9>
<line-10> high = N</line-10>
<line-11> while high - low > 1:</line-11>
<line-12> mid = (high + low)//2</line-12>
<line-13> if X[mid] <= goal:</line-13>
<line-14> low = mid</line-14>
<line-15> else:</line-15>
<line-16> high = mid</line-16>
<line-17> </line-17>
<line-18> return low</line-18>
<line-19></line-19>
<line-20>onesteps = [one_step(i) for i in range(N)]</line-20>
<line-21></line-21>
<line-22>def double(layer):</line-22>
<line-23> return [layer[layer[i]] for i in range(N)]</line-23>
<line-24></line-24>
<line-25>NUM_LAYERS = 20</line-25>
<line-26>layers = [onesteps]</line-26>
<line-27>for _ in range(NUM_LAYERS):</line-27>
<line-28> layers.append(double(layers[-1]))</line-28>
<line-29> </line-29>
<line-30>def query(a, b):</line-30>
<line-31> if a > b:</line-31>
<line-32> a, b = b, a</line-32>
<line-33> </line-33>
<line-34> ans = 0</line-34>
<line-35> while a < b:</line-35>
<line-36> ind = 0</line-36>
<line-37> while layers[ind + 1][a] < b:</line-37>
<line-38> ind += 1</line-38>
<line-39> ans += 2 ** ind</line-39>
<line-40> a = layers[ind][a]</line-40>
<line-41> return ans</line-41>
<line-42> </line-42>
<line-43>Q = int(input())</line-43>
<line-44>for _ in range(Q):</line-44>
<line-45> a, b = map(int, input().split())</line-45>
<line-46> a -= 1</line-46>
<line-48> print(query(a, b))</line-48>
|
{"code": "<line-2>X = list(map(int, input().split()))</line-2>\n<line-47> b -= 1</line-47>", "lines": [2, 47]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>k = float(sys.stdin.readline())</line-4>
<line-5>answer = int(log(2.0, 2.0/k))</line-5>
<line-6>print(2*answer)</line-6>
<line-7></line-7>
<line-8>m = 2 ** (1.0/answer)</line-8>
<line-9># m = 2.0/k</line-9>
<line-10>thesum = 0</line-10>
<line-11>for i in range(answer):</line-11>
<line-12> thesum += m**i</line-12>
<line-13># print [m**i/thesum for i in xrange(answer)]</line-13>
<line-14>loaves = [1]</line-14>
<line-15></line-15>
<line-16>def maxIndex(list):</line-16>
<line-17> max = -1</line-17>
<line-18> mi = -1</line-18>
<line-19> for i, x in enumerate(list):</line-19>
<line-20> if x > max:</line-20>
<line-21> max = x</line-21>
<line-22> mi = i</line-22>
<line-23> return mi</line-23>
<line-24></line-24>
<line-25>desired = [m**i/thesum for i in range(answer)]</line-25>
<line-26>desired.reverse()</line-26>
<line-27># print desired</line-27>
<line-28>cuts = []</line-28>
<line-29>while len(desired) > 1:</line-29>
<line-30> cuts.append(desired[-1])</line-30>
<line-31> lastsum = desired[-1] + desired[-2]</line-31>
<line-32> del desired[-2:]</line-32>
<line-33> desired[0:0] = [lastsum]</line-33>
<line-34></line-34>
<line-35># print cuts</line-35>
<line-36></line-36>
<line-37>while cuts:</line-37>
<line-38> length = cuts.pop()</line-38>
<line-39> i = maxIndex(loaves)</line-39>
<line-40> print(i, length)</line-40>
<line-41> loaves[i] -= length</line-41>
<line-42> loaves.append(length)</line-42>
<line-43> # print loaves</line-43>
<line-44></line-44>
<line-45># print loaves</line-45>
<line-46>for i in range(answer):</line-46>
<line-47> i = maxIndex(loaves[:answer])</line-47>
<line-48> x = loaves[i]/2.0</line-48>
<line-49> print(i, x)</line-49>
<line-50> loaves.append(x)</line-50>
<line-52># print loaves</line-52>
|
{"code": "<line-2>from math import log</line-2>\n<line-51> loaves[i] -= x</line-51>", "lines": [2, 51]}
#### 0
|
<line-1></line-1>
<line-2>"""</line-2>
<line-4>#it takes about 2 hours.</line-4>
<line-5>class Graph:</line-5>
<line-6> def __init__(self,n):</line-6>
<line-7> self.edge=[[0 for j in xrange(n)] for i in xrange(n)]</line-7>
<line-8> self.n=n</line-8>
<line-9></line-9>
<line-10> def addedge(self,i,j,m=1):</line-10>
<line-11> assert i!=j and 0<=i<self.n and 0<=j<self.n</line-11>
<line-12> self.edge[i][j]+=m</line-12>
<line-13> self.edge[j][i]+=m</line-13>
<line-14></line-14>
<line-15> def deledge(self,i,j,m=1):</line-15>
<line-16> assert i!=j and 0<=i<self.n and 0<=j<self.n</line-16>
<line-17> self.edge[i][j]-=m</line-17>
<line-18> self.edge[j][i]-=m</line-18>
<line-19></line-19>
<line-20> def strongconnect(self):</line-20>
<line-21> ret = True</line-21>
<line-22> n=self.n</line-22>
<line-23> for i in xrange(n):</line-23>
<line-24> for j in xrange(i+1,n):</line-24>
<line-25> if self.edge[i][j]:</line-25>
<line-26> self.deledge(i,j)</line-26>
<line-27> ret=self.connect()</line-27>
<line-28> self.addedge(i,j)</line-28>
<line-29> if ret==False:return ret</line-29>
<line-30> return True</line-30>
<line-31></line-31>
<line-32> def connect(self):</line-32>
<line-33> n=self.n</line-33>
<line-34> edge=self.edge</line-34>
<line-35> z=[0 for _ in xrange(n)]</line-35>
<line-36> def f(i):</line-36>
<line-37> assert 0<=i<n</line-37>
<line-38> if z[i]==1:return</line-38>
<line-39> z[i]=1</line-39>
<line-40> for j in xrange(n):</line-40>
<line-41> if edge[i][j]:f(j)</line-41>
<line-42> f(0)</line-42>
<line-43> return sum(z)==n</line-43>
<line-44></line-44>
<line-45> def Nconnect(self):</line-45>
<line-46> n=self.n</line-46>
<line-47> edge=self.edge</line-47>
<line-48> z=[0 for _ in xrange(n)]</line-48>
<line-49> def f(i):</line-49>
<line-50> assert 0<=i<n</line-50>
<line-51> if z[i]==1:return</line-51>
<line-52> z[i]=1</line-52>
<line-53> for j in xrange(n):</line-53>
<line-54> if edge[i][j]:f(j)</line-54>
<line-55> ret=0</line-55>
<line-56> for ver in xrange(n):</line-56>
<line-57> if z[ver]==0:</line-57>
<line-58> ret+=1</line-58>
<line-59> f(ver)</line-59>
<line-60> return ret</line-60>
<line-61></line-61>
<line-62>def search(nv,ne):</line-62>
<line-63> graph=Graph(nv)</line-63>
<line-64> init=( graph, (0,0), ne)</line-64>
<line-65> def f(state):</line-65>
<line-66> ret=0</line-66>
<line-67> g,(i,j),e=state</line-67>
<line-68> if e==0:</line-68>
<line-69> if g.strongconnect():</line-69>
<line-70> return fact(ne)</line-70>
<line-71> else:return 0</line-71>
<line-72></line-72>
<line-73> if e<g.Nconnect():</line-73>
<line-74> return 0</line-74>
<line-75> for i2 in xrange(nv):</line-75>
<line-76> for j2 in xrange(i2+1,nv):</line-76>
<line-77> if (i2,j2)>(i,j):</line-77>
<line-78> for k in xrange(1,e+1):</line-78>
<line-79> g.addedge(i2,j2,k)</line-79>
<line-80> ret += f((g,(i2,j2),e-k)) / fact(k)</line-80>
<line-81> g.deledge(i2,j2,k)</line-81>
<line-82> return ret</line-82>
<line-83> return f(init)</line-83>
<line-84></line-84>
<line-85>def fact(n):</line-85>
<line-86> assert n>=0</line-86>
<line-87> ret=1</line-87>
<line-88> for i in xrange(n):ret*=i+1</line-88>
<line-89> return ret</line-89>
<line-90></line-90>
<line-91>def comb(a,b):</line-91>
<line-92> return fact(a+b)/fact(a)/fact(b)</line-92>
<line-93> pass</line-93>
<line-94></line-94>
<line-95>nnn=17</line-95>
<line-96>sve=dict( ( (v,e),search(v,e) ) for v in xrange(nnn+1) for e in xrange(nnn+1) if e>=v and e+v<=nnn)</line-96>
<line-97>sve[(1,0)]=1</line-97>
<line-98>print sve</line-98>
<line-99>"""</line-99>
<line-100></line-100>
<line-101></line-101>
<line-102>output="""</line-102>
<line-103>{(6, 9): 10559808000, (0, 7): 0, (1, 6): 0, (0, 10): 0, (3, 7): 2142, (2, 5): 1, (1, 11): 0, (5, 8): 48094200, (6, 7): 6350400, (5, 5): 1440, (6, 10): 247973140800, (0, 17): 0, (0, 4): 0, (1, 1): 0, (4, 10): 57808440, (2, 6): 1, (5, 11): 84587745000, (4, 5): 2160, (0, 1): 0, (3, 12): 531366, (1, 12): 0, (2, 11): 1, (7, 8): 482630400, (0, 14): 0, (3, 11): 177078, (1, 15): 0, (8, 9): 45113241600, (4, 12): 2148847272, (2, 12): 1, (1, 16): 0, (1, 5): 0, (0, 11): 0, (3, 6): 690, (2, 2): 1, (1, 10): 0, (6, 11): 4928158065600, (0, 5): 0, (1, 0): 1, (0, 8): 0, (4, 11): 354158640, (3, 5): 210, (2, 7): 1, (5, 10): 7639380000, (4, 6): 25560, (5, 7): 2835000, (0, 2): 0, (1, 3): 0, (4, 8): 1433544, (2, 8): 1, (0, 15): 0, (3, 10): 58986, (1, 14): 0, (4, 13): 12970756656, (2, 13): 1, (1, 4): 0, (0, 12): 0, (3, 9): 19626, (2, 3): 1, (1, 9): 0, (2, 14): 1, (6, 8): 336268800, (0, 6): 0, (1, 7): 0, (0, 9): 0, (3, 4): 54, (2, 4): 1, (5, 9): 644550480, (4, 7): 206640, (6, 6): 43200, (5, 6): 104400, (7, 7): 1814400, (0, 16): 0, (0, 3): 0, (3, 14): 4782882, (1, 2): 0, (4, 9): 9265200, (3, 3): 6, (2, 9): 1, (5, 12): 900380296200, (4, 4): 72, (7, 10): 2379856852800, (0, 0): 1, (3, 13): 1594242, (1, 13): 0, (2, 10): 1, (7, 9): 44808422400, (0, 13): 0, (3, 8): 6510, (1, 8): 0, (8, 8): 101606400, (2, 15): 1}</line-103>
<line-104>"""</line-104>
<line-105>sve=eval( "".join( output.split("\n") ) )</line-105>
<line-106></line-106>
<line-107></line-107>
<line-108>def fact(n):</line-108>
<line-109> assert n>=0</line-109>
<line-110> ret=1</line-110>
<line-111> for i in range(n):ret*=i+1</line-111>
<line-112> return ret</line-112>
<line-113></line-113>
<line-114>def comb(a,b):</line-114>
<line-115> return fact(a+b)/fact(a)/fact(b)</line-115>
<line-116> pass</line-116>
<line-117></line-117>
<line-118>"python 2.5 cannot use fractions."</line-118>
<line-119>"I used fractions for local computation."</line-119>
<line-120>#import fractions</line-120>
<line-121>#fr=fractions.Fraction(1)</line-121>
<line-122>memo_ff={}</line-122>
<line-123>def powpoly(x,t):</line-123>
<line-124> ret=[1]+[0]*( len(x)-1 )</line-124>
<line-125> n=len(x)</line-125>
<line-126> for _ in range(t):</line-126>
<line-127> ret2=[0 for _ in range(n)]</line-127>
<line-128> for i in range(n):</line-128>
<line-129> for j in range(n):</line-129>
<line-130> if i+j<n:</line-130>
<line-131> ret2[i+j]+=ret[i]*x[j]</line-131>
<line-132> ret=ret2</line-132>
<line-133> return ret</line-133>
<line-134></line-134>
<line-135>def ing(x):</line-135>
<line-136> n=len(x)</line-136>
<line-137> assert x[0]==0</line-137>
<line-138> ret=[0 for _ in range(n)]</line-138>
<line-139> for t in range(0,n):</line-139>
<line-140> ret2=powpoly(x,t)</line-140>
<line-141> for i in range(n):</line-141>
<line-142> ret[i]+=fr*ret2[i]/fact(t)</line-142>
<line-143> return ret</line-143>
<line-144></line-144>
<line-145></line-145>
<line-146>def ff(Y):</line-146>
<line-147> if Y in memo_ff:</line-147>
<line-148> return memo_ff[Y]</line-148>
<line-149> t=Y[0]</line-149>
<line-150> if t==0:</line-150>
<line-151> n=Y[1]</line-151>
<line-152> ret=0</line-152>
<line-153> for (v,e) in sve:</line-153>
<line-154> if v+e>n or v==0:continue</line-154>
<line-155> val=sve[(v,e)]</line-155>
<line-156> for l1 in range(n-v+1):</line-156>
<line-157> l2=n-v-l1</line-157>
<line-158> p1=ff((2,l1,e))</line-158>
<line-159> p2=ff((3,l2,v))</line-159>
<line-160> a = fr * val * fact(n-1) / fact(v-1) / fact(l1) / fact(l2) * p1 * p2 / fact(e)</line-160>
<line-161> ret += a</line-161>
<line-162> elif t==1:</line-162>
<line-163> n=Y[1]</line-163>
<line-164> ret=0</line-164>
<line-165> for (v,e) in sve:</line-165>
<line-166> val=sve[(v,e)]</line-166>
<line-167> e-=1</line-167>
<line-168> if e==-1 or v+e>n or v==0:continue</line-168>
<line-169> for l1 in range(n-v+1):</line-169>
<line-170> l2=n-v-l1</line-170>
<line-171> p1=ff((2,l1,e))</line-171>
<line-172> p2=ff((3,l2,v))</line-172>
<line-173> ret += fr * val * fact(n) / fact(v) / fact(l1) / fact(l2) * p1 * p2 / fact(e)</line-173>
<line-174> elif t==2:</line-174>
<line-175> n=Y[1]</line-175>
<line-176> e=Y[2]</line-176>
<line-177> F=[ fr*i*ff((0,i))/fact(i) for i in range(n+1) ]</line-177>
<line-178> Fa=powpoly(F,e)</line-178>
<line-179> ret=Fa[n]*fact(n)</line-179>
<line-180> elif t==3:</line-180>
<line-181> n=Y[1]</line-181>
<line-182> v=Y[2]</line-182>
<line-183> G=[v*fr*ff((1,i))/fact(i) for i in range(n+1)]</line-183>
<line-184> Ga=ing(G)</line-184>
<line-185> ret = Ga[n]*fact(n)</line-185>
<line-186> memo_ff[Y]=ret</line-186>
<line-187> return ret</line-187>
<line-188></line-188>
<line-189>memo={}</line-189>
<line-190></line-190>
<line-191>def g(Y):</line-191>
<line-192> if Y in memo:</line-192>
<line-193> return memo[Y]</line-193>
<line-194> k,c=Y</line-194>
<line-195> if c==0:</line-195>
<line-196> return ff((0,k))</line-196>
<line-197> if 2*c>=k:return 0</line-197>
<line-198> ret=0</line-198>
<line-199> for k1 in range(1,18):</line-199>
<line-200> for k2 in range(1,18):</line-200>
<line-201> k3=k-k1-k2</line-201>
<line-202> if k3<=0:break</line-202>
<line-203> for c1 in range(18):</line-203>
<line-204> if 2*c1>=k1:break</line-204>
<line-205> for c2 in range(18):</line-205>
<line-206> if 2*c2>=k2:break</line-206>
<line-207> c3=c-1-c1-c2</line-207>
<line-208> if 2*c3>=k3:continue</line-208>
<line-209> ret += g((k1,c1)) * g((k2,c2)) * g((k3,c3)) * fact(k1+k2+k3)/fact(k1)/fact(k2)/fact(k3)*k1*k2*k3</line-209>
<line-210> r=ret/(6*c)</line-210>
<line-211> memo[Y]=r</line-211>
<line-212> return r</line-212>
<line-213></line-213>
<line-214></line-214>
<line-215>def ans(n):</line-215>
<line-216> return sum(g((n,i)) for i in range(n))</line-216>
<line-217></line-217>
<line-218></line-218>
<line-219>def brute(n):</line-219>
<line-220> m=[(i1,i2,i3) for i1 in range(n) for i2 in range(i1+1,n) for i3 in range(i2+1,n)]</line-220>
<line-221> init=[]</line-221>
<line-222> memob={}</line-222>
<line-223> def f(vs):</line-223>
<line-224> ret=0</line-224>
<line-225> if vs:</line-225>
<line-226> g=Graph(n)</line-226>
<line-227> for v in vs:</line-227>
<line-228> i1,i2,i3=v</line-228>
<line-229> g.addedge(i1,i2)</line-229>
<line-230> g.addedge(i1,i3)</line-230>
<line-231> a=g.Nconnect()</line-231>
<line-232> for notv in vs:</line-232>
<line-233> g=Graph(n)</line-233>
<line-234> for v in vs:</line-234>
<line-235> if v==notv:continue</line-235>
<line-236> i1,i2,i3=v</line-236>
<line-237> g.addedge(i1,i2)</line-237>
<line-238> g.addedge(i1,i3)</line-238>
<line-239> if g.Nconnect()==a:</line-239>
<line-240> return 0</line-240>
<line-241> if a==1:return 1</line-241>
<line-242> ret = 0</line-242>
<line-243> for v in m:</line-243>
<line-244> if len(vs)==0 or v>vs[-1]:</line-244>
<line-245> ret += f(vs+[v])</line-245>
<line-246> return ret</line-246>
<line-247> return f(init)</line-247>
<line-248></line-248>
<line-249>def brute2(n):</line-249>
<line-250> m=[(i1,i2,i3) for i1 in range(n) for i2 in range(i1+1,n) for i3 in range(i2+1,n)]</line-250>
<line-251> init=[]</line-251>
<line-252> def f(vs):</line-252>
<line-253> ret=0</line-253>
<line-254> if vs:</line-254>
<line-255> g=Graph(n)</line-255>
<line-256> for v in vs:</line-256>
<line-257> i1,i2,i3=v</line-257>
<line-258> g.addedge(i1,i2)</line-258>
<line-259> g.addedge(i1,i3)</line-259>
<line-260> a=g.Nconnect()</line-260>
<line-261> for notv in vs:</line-261>
<line-262> g=Graph(n)</line-262>
<line-263> for v in vs:</line-263>
<line-264> if v==notv:continue</line-264>
<line-265> i1,i2,i3=v</line-265>
<line-266> g.addedge(i1,i2)</line-266>
<line-267> g.addedge(i1,i3)</line-267>
<line-268> if g.Nconnect()==a or ( a==1 and g.Nconnect()==3):</line-268>
<line-269> return 0</line-269>
<line-270> if a==1:</line-270>
<line-271> return 1</line-271>
<line-272> ret = 0</line-272>
<line-273> for v in m:</line-273>
<line-274> if len(vs)==0 or v>vs[-1]:</line-274>
<line-275> ret += f(vs+[v])</line-275>
<line-276> return ret</line-276>
<line-277> return f(init)</line-277>
<line-278></line-278>
<line-279>def main():</line-279>
<line-280> t=eval(input())</line-280>
<line-281> #z=[int(ans(i)) for i in xrange(18)] it takes about 10 seconds</line-281>
<line-282> z=[0, 1, 0, 1, 6, 25, 495, 5586, 93268, 2052513, 43258365, 1167393700, 34010847486,</line-282>
<line-283> 1078391538159, 38595111963499, 1476893151785520, 61479081902937000, 2761923686066698561]</line-283>
<line-284> for _ in range(t):</line-284>
<line-285> print(z[eval(input())])</line-285>
<line-287>main()</line-287>
|
{"code": "<line-3>#this code is a precomputation part.</line-3>\n<line-286>#test()</line-286>", "lines": [3, 286]}
#### 0
|
<line-1>import decimal;</line-1>
<line-3></line-3>
<line-4>def solve(a, b, min1, min2, min3, min4, x, y):</line-4>
<line-5> if a > b:</line-5>
<line-6> return [];</line-6>
<line-7> solMin1 = (a/y+b)/(y-1/y);</line-7>
<line-8> solMin2 = (b/y+a)/(y-1/y);</line-8>
<line-9> solMin1 *= (x*y);</line-9>
<line-10> solMin2 *= (x*y);</line-10>
<line-11></line-11>
<line-12> if solMin1 >= min1 and solMin1 <= min2 and solMin2 >= min3 and solMin2 <= min4:</line-12>
<line-13> # Solution found</line-13>
<line-14> return [a, solMin1, b, solMin2];</line-14>
<line-15> return [];</line-15>
<line-16></line-16>
<line-17>def integerPart(x):</line-17>
<line-18> return Decimal(str(x).split(".")[0]);</line-18>
<line-19></line-19>
<line-20>def fractionalPart(x):</line-20>
<line-21> t = str(x).split(".");</line-21>
<line-22> if len(t) > 0:</line-22>
<line-23> return "." + t[1];</line-23>
<line-24> return 0;</line-24>
<line-25></line-25>
<line-26>getcontext().prec = 30;</line-26>
<line-27>for i in range(eval(input())):</line-27>
<line-28> (x,y) = input().split();</line-28>
<line-29> (a,b,c,d,e,f,g,h) = input().split();</line-29>
<line-30> x=Decimal(x);y=Decimal(y);a=Decimal(a);b=Decimal(b);c=Decimal(c);d=Decimal(d);e=Decimal(e);f=Decimal(f);g=Decimal(g);h=Decimal(h);</line-30>
<line-31></line-31>
<line-32> if a > g or (a == g and b > h):</line-32>
<line-33> print("-1");</line-33>
<line-34> continue;</line-34>
<line-35></line-35>
<line-36> solutionh = Decimal("-1");</line-36>
<line-37> solutionm = Decimal("-1");</line-37>
<line-38> diff = Decimal("-10000000000000000");</line-38>
<line-39></line-39>
<line-40> solution1 = [];solution2=[];solution3=[];solution4=[];solution5=[];solution6=[];solution7=[];solution8=[];solution9=[];</line-40>
<line-41> solution10 = [];solution11=[];solution12=[];solution13=[];solution14=[];</line-41>
<line-42> l1 = 0;</line-42>
<line-43> if g == e:</line-43>
<line-44> l1 = f;</line-44>
<line-45> solution1 = solve(a+0,g+0,b,x*y,l1,h,x,y);</line-45>
<line-46> if a < y - 1 and len(solution1) == 0:</line-46>
<line-47> solution2 = solve(a+1,g+0,0,x*y,l1,h,x,y);</line-47>
<line-48> if g >= 1 and len(solution1) == 0 and len(solution2) == 0:</line-48>
<line-49> solution4 = solve(a+0,g-1,b,x*y,0,x*y,x,y);</line-49>
<line-50> if g-e >= 2 and c-a>=2 :</line-50>
<line-51> solution5 = solve(a+1,g-1,0,x*y,0,x*y,x,y);</line-51>
<line-52> </line-52>
<line-53> if len(solution1) == 0 and len(solution2) == 0 and len(solution4) == 0:</line-53>
<line-54> solution10 = solve(a, e, 0, x*y, 0, x*y, x, y);</line-54>
<line-55> solution11 = solve(c, e, 0, x*y, 0, x*y, x, y);</line-55>
<line-56> solution12 = solve(c, g, 0, x*y, 0, x*y, x, y);</line-56>
<line-57> if a < y - 1 and len(solution1) == 0 and len(solution2) == 0 and len(solution4) == 0 and c - a >= 2:</line-57>
<line-58> solution13 = solve(a + 1, e, 0, x*y, 0, x*y, x, y);</line-58>
<line-59> if g >= 1 and len(solution1) == 0 and len(solution2) == 0 and len(solution4) == 0 and g - e >= 2:</line-59>
<line-60> solution14 = solve(c, g - 1, 0, x*y, 0, x*y, x, y);</line-60>
<line-61></line-61>
<line-62></line-62>
<line-63> if len(solution1) > 0:</line-63>
<line-64> if solution1[0] < c or (solution1[0] == c and solution1[1] <= d):</line-64>
<line-65> if solution1[2] > e or (solution1[2] == e and solution1[3] >= f):</line-65>
<line-66> t = (solution1[2]-solution1[0])*x*y + (solution1[3]-solution1[1]);</line-66>
<line-67> if t > diff:</line-67>
<line-68> diff = t;</line-68>
<line-69> solutionh = solution1[0];</line-69>
<line-70> solutionm = solution1[1];</line-70>
<line-71> if len(solution2) > 0:</line-71>
<line-72> if solution2[0] < c or (solution2[0] == c and solution2[1] <= d):</line-72>
<line-73> if solution2[2] > e or (solution2[2] == e and solution2[3] >= f):</line-73>
<line-74> t = (solution2[2]-solution2[0])*x*y + (solution2[3]-solution2[1]);</line-74>
<line-75> if t > diff:</line-75>
<line-76> diff = t;</line-76>
<line-77> solutionh = solution2[0];</line-77>
<line-78> solutionm = solution2[1];</line-78>
<line-79> if len(solution4) > 0:</line-79>
<line-80> if solution4[0] < c or (solution4[0] == c and solution4[1] <= d):</line-80>
<line-81> if solution4[2] > e or (solution4[2] == e and solution4[3] >= f):</line-81>
<line-82> t = (solution4[2]-solution4[0])*x*y + (solution4[3]-solution4[1]);</line-82>
<line-83> if t > diff:</line-83>
<line-84> diff = t;</line-84>
<line-85> solutionh = solution4[0];</line-85>
<line-86> solutionm = solution4[1];</line-86>
<line-87> if len(solution5) > 0:</line-87>
<line-88> if solution5[0] < c or (solution5[0] == c and solution5[1] <= d):</line-88>
<line-89> if solution5[2] > e or (solution5[2] == e and solution5[3] >= f):</line-89>
<line-90> t = (solution5[2]-solution5[0])*x*y + (solution5[3]-solution5[1]);</line-90>
<line-91> if t > diff:</line-91>
<line-92> diff = t;</line-92>
<line-93> solutionh = solution5[0];</line-93>
<line-94> solutionm = solution5[1];</line-94>
<line-95> if len(solution10) > 0:</line-95>
<line-96> if solution10[0] > a or (solution10[0] == a and solution10[1] >= b):</line-96>
<line-97> if solution10[0] < c or (solution10[0] == c and solution10[1] <= d):</line-97>
<line-98> if solution10[2] > e or (solution10[2] == e and solution10[3] >= f):</line-98>
<line-99> if solution10[2] < g or (solution10[2] == g and solution10[3] <= h):</line-99>
<line-100> t = (solution10[2]-solution10[0])*x*y + (solution10[3]-solution10[1]);</line-100>
<line-101> if t > diff:</line-101>
<line-102> diff = t;</line-102>
<line-103> solutionh = solution10[0];</line-103>
<line-104> solutionm = solution10[1];</line-104>
<line-105> if len(solution11) > 0:</line-105>
<line-106> if solution11[0] > a or (solution11[0] == a and solution11[1] >= b):</line-106>
<line-107> if solution11[0] < c or (solution11[0] == c and solution11[1] <= d):</line-107>
<line-108> if solution11[2] > e or (solution11[2] == e and solution11[3] >= f):</line-108>
<line-109> if solution11[2] < g or (solution11[2] == g and solution11[3] <= h):</line-109>
<line-110> t = (solution11[2]-solution11[0])*x*y + (solution11[3]-solution11[1]);</line-110>
<line-111> if t > diff:</line-111>
<line-112> diff = t;</line-112>
<line-113> solutionh = solution11[0];</line-113>
<line-114> solutionm = solution11[1];</line-114>
<line-115> if len(solution12) > 0:</line-115>
<line-116> if solution12[0] > a or (solution12[0] == a and solution12[1] >= b):</line-116>
<line-117> if solution12[0] < c or (solution12[0] == c and solution12[1] <= d):</line-117>
<line-118> if solution12[2] > e or (solution12[2] == e and solution12[3] >= f):</line-118>
<line-119> if solution12[2] < g or (solution12[2] == g and solution12[3] <= h):</line-119>
<line-120> t = (solution12[2]-solution12[0])*x*y + (solution12[3]-solution12[1]);</line-120>
<line-121> if t > diff:</line-121>
<line-122> diff = t;</line-122>
<line-123> solutionh = solution12[0];</line-123>
<line-124> solutionm = solution12[1];</line-124>
<line-125> if len(solution13) > 0:</line-125>
<line-126> if solution13[0] > a or (solution13[0] == a and solution13[1] >= b):</line-126>
<line-127> if solution13[0] < c or (solution13[0] == c and solution13[1] <= d):</line-127>
<line-128> if solution13[2] > e or (solution13[2] == e and solution13[3] >= f):</line-128>
<line-129> if solution13[2] < g or (solution13[2] == g and solution13[3] <= h):</line-129>
<line-130> t = (solution13[2]-solution13[0])*x*y + (solution13[3]-solution13[1]);</line-130>
<line-131> if t > diff:</line-131>
<line-132> diff = t;</line-132>
<line-133> solutionh = solution13[0];</line-133>
<line-134> solutionm = solution13[1];</line-134>
<line-135> if len(solution14) > 0:</line-135>
<line-136> if solution14[0] > a or (solution14[0] == a and solution14[1] >= b):</line-136>
<line-137> if solution14[0] < c or (solution14[0] == c and solution14[1] <= d):</line-137>
<line-138> if solution14[2] > e or (solution14[2] == e and solution14[3] >= f):</line-138>
<line-139> if solution14[2] < g or (solution14[2] == g and solution14[3] <= h):</line-139>
<line-140> t = (solution14[2]-solution14[0])*x*y + (solution14[3]-solution14[1]);</line-140>
<line-141> if t > diff:</line-141>
<line-142> diff = t;</line-142>
<line-143> solutionh = solution14[0];</line-143>
<line-144> solutionm = solution14[1];</line-144>
<line-145> </line-145>
<line-146> limit1 = (y-1/y)*(f/(x*y))-e/y;</line-146>
<line-147> if limit1 <= a + 1:</line-147>
<line-148> limit1 = a + 1;</line-148>
<line-149> limit1 = Decimal(str(int(limit1)));</line-149>
<line-150> limit2 = (y-1/y)*(d/(x*y))-c/y;</line-150>
<line-151> if limit2 >= g-1:</line-151>
<line-152> limit2=g-1;</line-152>
<line-153> limit2 = Decimal(str(int(limit2)));</line-153>
<line-154></line-154>
<line-155> if limit1 >= a + 1 and limit1 <= c-1:</line-155>
<line-156> solutionNew = solve(limit1, e, 0, x*y, 0, x*y, x, y);</line-156>
<line-157> if len(solutionNew) > 0:</line-157>
<line-158> if solutionNew[0] > a or (solutionNew[0] == a and solutionNew[1] >= b):</line-158>
<line-159> if solutionNew[0] < c or (solutionNew[0] == c and solutionNew[1] <= d):</line-159>
<line-160> if solutionNew[2] > e or (solutionNew[2] == e and solutionNew[3] >= f):</line-160>
<line-161> if solutionNew[2] < g or (solutionNew[2] == g and solutionNew[3] <= h):</line-161>
<line-162> t = (solutionNew[2]-solutionNew[0])*x*y + (solutionNew[3]-solutionNew[1]);</line-162>
<line-163> if t > diff:</line-163>
<line-164> diff = t;</line-164>
<line-165> solutionh = solutionNew[0];</line-165>
<line-166> solutionm = solutionNew[1];</line-166>
<line-167> if limit1 + 1 >= a + 1 and limit1 + 1 <= c-1:</line-167>
<line-168> solutionNew = solve(limit1 + 1, e, 0, x*y, 0, x*y, x, y);</line-168>
<line-169> if len(solutionNew) > 0:</line-169>
<line-170> if solutionNew[0] > a or (solutionNew[0] == a and solutionNew[1] >= b):</line-170>
<line-171> if solutionNew[0] < c or (solutionNew[0] == c and solutionNew[1] <= d):</line-171>
<line-172> if solutionNew[2] > e or (solutionNew[2] == e and solutionNew[3] >= f):</line-172>
<line-173> if solutionNew[2] < g or (solutionNew[2] == g and solutionNew[3] <= h):</line-173>
<line-174> t = (solutionNew[2]-solutionNew[0])*x*y + (solutionNew[3]-solutionNew[1]);</line-174>
<line-175> if t > diff:</line-175>
<line-176> diff = t;</line-176>
<line-177> solutionh = solutionNew[0];</line-177>
<line-178> solutionm = solutionNew[1];</line-178>
<line-179> if limit2 >= e + 1 and limit2 <= g-1:</line-179>
<line-180> solutionNew = solve(c, limit2, 0, x*y, 0, x*y, x, y);</line-180>
<line-181> if len(solutionNew) > 0:</line-181>
<line-182> if solutionNew[0] > a or (solutionNew[0] == a and solutionNew[1] >= b):</line-182>
<line-183> if solutionNew[0] < c or (solutionNew[0] == c and solutionNew[1] <= d):</line-183>
<line-184> if solutionNew[2] > e or (solutionNew[2] == e and solutionNew[3] >= f):</line-184>
<line-185> if solutionNew[2] < g or (solutionNew[2] == g and solutionNew[3] <= h):</line-185>
<line-186> t = (solutionNew[2]-solutionNew[0])*x*y + (solutionNew[3]-solutionNew[1]);</line-186>
<line-187> if t > diff:</line-187>
<line-188> diff = t;</line-188>
<line-189> solutionh = solutionNew[0];</line-189>
<line-190> solutionm = solutionNew[1];</line-190>
<line-191> if limit1 - 1 >= e + 1 and limit2 - 1 <= g-1:</line-191>
<line-192> solutionNew = solve(c, limit2 - 1, 0, x*y, 0, x*y, x, y);</line-192>
<line-193> if len(solutionNew) > 0:</line-193>
<line-194> if solutionNew[0] > a or (solutionNew[0] == a and solutionNew[1] >= b):</line-194>
<line-195> if solutionNew[0] < c or (solutionNew[0] == c and solutionNew[1] <= d):</line-195>
<line-196> if solutionNew[2] > e or (solutionNew[2] == e and solutionNew[3] >= f):</line-196>
<line-197> if solutionNew[2] < g or (solutionNew[2] == g and solutionNew[3] <= h):</line-197>
<line-198> t = (solutionNew[2]-solutionNew[0])*x*y + (solutionNew[3]-solutionNew[1]);</line-198>
<line-199> if t > diff:</line-199>
<line-200> diff = t;</line-200>
<line-201> solutionh = solutionNew[0];</line-201>
<line-202> solutionm = solutionNew[1];</line-202>
<line-203></line-203>
<line-204> if solutionh == -1 or diff < 0:</line-204>
<line-205> print("-1");</line-205>
<line-206> else:</line-206>
<line-207> tz = solutionm;</line-207>
<line-208> solutionm *= 100;</line-208>
<line-209> try:</line-209>
<line-210> r1 = integerPart(solutionm);</line-210>
<line-211> r1 = str(r1);</line-211>
<line-212> r1 = Decimal(r1);</line-212>
<line-213> r2 = solutionm - r1;</line-213>
<line-214> if r2 >= Decimal(".5"):</line-214>
<line-215> r1 += Decimal("1");</line-215>
<line-216> t1 = (r1 - r1%100)/100;</line-216>
<line-217> t2 = r1%100;</line-217>
<line-218> t1 = int(t1);</line-218>
<line-219> if t2 == 0:</line-219>
<line-220> t2 = "00";</line-220>
<line-221> elif t2 < 10:</line-221>
<line-222> t2 = "0" + str(t2);</line-222>
<line-223> else:</line-223>
<line-224> t2 = str(t2);</line-224>
<line-225> except:</line-225>
<line-226> exit(0);</line-226>
<line-228> print(str(solutionh)+":%d.%s"%(t1, t2));</line-228>
|
{"code": "<line-2>from decimal import *;</line-2>\n<line-227>\t\t#print str(solutionh)+\":%.2f\"%(solutionm);</line-227>", "lines": [2, 227]}
#### 0
|
<line-1>s=""</line-1>
<line-3>s=input()</line-3>
<line-4>k=0</line-4>
<line-5>r=0</line-5>
<line-6>c=0</line-6>
<line-7>if s[0]=='h':</line-7>
<line-8> L.append('http://')</line-8>
<line-9> c=4</line-9>
<line-10> s=s[c:]</line-10>
<line-11>elif s[0]=='f':</line-11>
<line-12> L.append('ftp://')</line-12>
<line-13> c=3</line-13>
<line-14> s=s[c:]</line-14>
<line-15>r=s.find('ru',1)</line-15>
<line-16>L.append(s[:r])</line-16>
<line-17>L.append('.ru')</line-17>
<line-18></line-18>
<line-19>k=r+2</line-19>
<line-20></line-20>
<line-21>if k<len(s):</line-21>
<line-22> L.append('/')</line-22>
<line-24> </line-24>
<line-25>print(''.join(L))</line-25>
<line-26></line-26>
|
{"code": "<line-2>L=[]</line-2>\n<line-23> L.append(s[k:])</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>n, a = int(input()), [int(i) for i in input().split()]</line-1>
<line-3>b.sort()</line-3>
<line-4>for i in range(len(b) - 1):</line-4>
<line-5> m[b[i]] = b[i + 1]</line-5>
<line-6>m[b[-1]] = b[0]</line-6>
<line-7>for i in range(len(a)):</line-7>
<line-8> a[i] = m[a[i]]</line-8>
<line-9>if len(set(b)) == n:</line-9>
<line-10> print(*a)</line-10>
<line-12> print(-1)</line-12>
|
{"code": "<line-2>b, m = a[:], dict()</line-2>\n<line-11>else:</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>s = input()</line-1>
<line-3>a = [input() for i in range(n)]</line-3>
<line-4>for i in range(n):</line-4>
<line-5> for j in range(n):</line-5>
<line-6> if a[i] == s or a[i][1] + a[j][0] == s:</line-6>
<line-7> print("YES")</line-7>
<line-9>print("NO")</line-9>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-8> return</line-8>", "lines": [2, 8]}
#### 0
|
<line-1></line-1>
<line-2>import numpy as np</line-2>
<line-4>A=np.array(list(map(int,input().split())))</line-4>
<line-5>mod = 998244353</line-5>
<line-6></line-6>
<line-7>fact = [1]*(K+1)</line-7>
<line-8>for i in range(1,K+1):</line-8>
<line-9> fact[i]=i*fact[i-1]%mod</line-9>
<line-10>inv_fact = [pow(f,mod-2,mod) for f in fact]</line-10>
<line-11></line-11>
<line-12># r = [sum(pow(aa,t,mod) for aa in A)%mod for t in range(K+1)]##遅い</line-12>
<line-13>r = [0]*(K+1)</line-13>
<line-14>r[0] = N</line-14>
<line-15>temp = np.ones(N,dtype="int32")</line-15>
<line-16>for i in range(1,K+1):</line-16>
<line-17> temp = temp*A%mod</line-17>
<line-18> r[i] = int(np.sum(temp))%mod</line-18>
<line-19></line-19>
<line-20>inv2 = pow(2,mod-2,mod)</line-20>
<line-21>for x in range(1,K+1):</line-21>
<line-22> ans = sum((fact[x]*inv_fact[t]*inv_fact[x-t] *r[x-t]*r[t]) %mod </line-22>
<line-23> for t in range(x+1))%mod</line-23>
<line-25> print(((ans*inv2)%mod))</line-25>
<line-26></line-26>
|
{"code": "<line-3>N,K = list(map(int,input().split()))</line-3>\n<line-24> ans-= r[x]*pow(2,x,mod) %mod</line-24>", "lines": [3, 24]}
#### 0
|
<line-1>n,k=map(int,input().split())</line-1>
<line-3>dp=[0]*(n+1)</line-3>
<line-4>dp[0]=1</line-4>
<line-5>for i in range(1,n+1):</line-5>
<line-6> for j in range(i,-1,-1):</line-6>
<line-7> dp[j]=dp[j-1]</line-7>
<line-8> if 2*j<=i:</line-8>
<line-9> dp[j]+=dp[2*j]</line-9>
<line-11>print(dp[k])</line-11>
|
{"code": "<line-2>mod=998244353</line-2>\n<line-10> dp[j]%=mod</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>from functools import reduce</line-1>
<line-2></line-2>
<line-4> if n == 0:</line-4>
<line-5> return 1</line-5>
<line-6> tmp = modpow(a, n // 2, m)</line-6>
<line-7> if n % 2 == 0:</line-7>
<line-8> return tmp * tmp % m</line-8>
<line-9> else:</line-9>
<line-10> return tmp * tmp * a % m</line-10>
<line-11></line-11>
<line-12>def modinv(a, m):</line-12>
<line-13> return modpow(a, m - 2, m)</line-13>
<line-14></line-14>
<line-15>n, m = [int(_) for _ in input().split(' ')]</line-15>
<line-16>s = sum([int(_) for _ in input().split(' ')])</line-16>
<line-17></line-17>
<line-18>M = 1_000_000_007</line-18>
<line-20></line-20>
<line-21>print((reduce(product, list(range(m - s + 1, m + n + 1))) * modinv(reduce(product, list(range(1, s + n + 1))), M) % M))</line-21>
|
{"code": "<line-3>def modpow(a, n, m):</line-3>\n<line-19>product = lambda x1, x2: x1 * x2 % M</line-19>", "lines": [3, 19]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.