Datasets:

rootacess

/

pie-perf

like 0

u926412290

p03013

python

s804277372

s606472914

Accepted

Accepted

N, M = list(map(int, input().split())) oks = [True] * (N+1) for _ in range(M): a = int(eval(input())) oks[a] = False dp = [1] + [0] * N for now in range(N): for nxt in range(now+1, min(N, now+2)+1): if oks[nxt]: dp[nxt] += dp[now] dp[nxt] %= 1e9 + 7 print((int(dp[N])))

MOD = 10**9 + 7 N, M = list(map(int, input().split())) a = [int(eval(input())) for _ in range(M)] + [N + 1] dp = [0] * (N + 1) dp[0] = 1 s = -1 for broken in a: for j in range(s + 1, broken): if j > s + 1: dp[j] += dp[j - 1] % MOD if j > 1: dp[j] += dp[j - 2] % MOD dp[j] %= MOD s = broken print((dp[-1]))

N, M = list(map(int, input().split())) oks = [True] * (N + 1) for _ in range(M): a = int(eval(input())) oks[a] = False dp = [1] + [0] * N for now in range(N): for nxt in range(now + 1, min(N, now + 2) + 1): if oks[nxt]: dp[nxt] += dp[now] dp[nxt] %= 1e9 + 7 print((int(dp[N])))

MOD = 10**9 + 7 N, M = list(map(int, input().split())) a = [int(eval(input())) for _ in range(M)] + [N + 1] dp = [0] * (N + 1) dp[0] = 1 s = -1 for broken in a: for j in range(s + 1, broken): if j > s + 1: dp[j] += dp[j - 1] % MOD if j > 1: dp[j] += dp[j - 2] % MOD dp[j] %= MOD s = broken print((dp[-1]))

u883048396

p03965

python

s200341439

s754758366

Accepted

Accepted

#len(s)//2-s.count("p") iG = 0 iR = 0 for s in input().rstrip(): if s == "g" : if 0 < iG: iR += 1 iG -= 1 else: iG += 1 else: if 0 < iG: iG -= 1 else: iR -= 1 iG += 1 print(iR)

#len(s)//2-s.count("p") def 解(): iG = 0 iR = 0 for s in input().rstrip(): if s == "g" : if 0 < iG: iR += 1 iG -= 1 else: iG += 1 else: if 0 < iG: iG -= 1 else: iR -= 1 iG += 1 print(iR) 解()

# len(s)//2-s.count("p") iG = 0 iR = 0 for s in input().rstrip(): if s == "g": if 0 < iG: iR += 1 iG -= 1 else: iG += 1 else: if 0 < iG: iG -= 1 else: iR -= 1 iG += 1 print(iR)

# len(s)//2-s.count("p") def 解(): iG = 0 iR = 0 for s in input().rstrip(): if s == "g": if 0 < iG: iR += 1 iG -= 1 else: iG += 1 else: if 0 < iG: iG -= 1 else: iR -= 1 iG += 1 print(iR) 解()

u888092736

p02743

python

s237111377

s271810424

Accepted

Accepted

a, b, c = list(map(int, input().split())) if c - a - b > 0 and (c - a - b) ** 2 > 4 * a * b: print('Yes') else: print('No')

a, b, c = list(map(int, input().split())) d = c - a - b if d >= 0 and d * d > 4 * a * b: print("Yes") else: print("No")

a, b, c = list(map(int, input().split())) if c - a - b > 0 and (c - a - b) ** 2 > 4 * a * b: print("Yes") else: print("No")

a, b, c = list(map(int, input().split())) d = c - a - b if d >= 0 and d * d > 4 * a * b: print("Yes") else: print("No")

u977661421

p02881

python

s193607066

s117187904

Accepted

Accepted

# -*- coding: utf-8 -*- n = int(eval(input())) ans = pow(10, 30) for i in range(1, int(pow(n, 0.5)) + 1): if n / i == n // i: j = n // i if i + j - 2 < ans: ans = i + j - 2 print(ans)

# -*- coding: utf-8 -*- n = int(eval(input())) ans = [10 ** 14, 10 ** 14] for i in range(1, int(pow(n, 0.5)) + 1): if n % i == 0: tmp = n // i if tmp + i < sum(ans): ans = [i, tmp] print((sum(ans) - 2))

# -*- coding: utf-8 -*- n = int(eval(input())) ans = pow(10, 30) for i in range(1, int(pow(n, 0.5)) + 1): if n / i == n // i: j = n // i if i + j - 2 < ans: ans = i + j - 2 print(ans)

# -*- coding: utf-8 -*- n = int(eval(input())) ans = [10**14, 10**14] for i in range(1, int(pow(n, 0.5)) + 1): if n % i == 0: tmp = n // i if tmp + i < sum(ans): ans = [i, tmp] print((sum(ans) - 2))

u933140383

p02657

python

s157021841

s164424083

Accepted

Accepted

a,b=input().split(' ') print((int(a)*int(b)))

a,b=input().split(' ') if int(a)<=100 and int(b)<=100: print((int(a)*int(b))) else: pass

a, b = input().split(" ") print((int(a) * int(b)))

a, b = input().split(" ") if int(a) <= 100 and int(b) <= 100: print((int(a) * int(b))) else: pass

u815797488

p03408

python

s590456558

s051215075

Accepted

Accepted

dic = {} N = int(eval(input())) s = [eval(input()) for i in range(N)] for i in range(N): dic.setdefault(s[i],0) dic[s[i]] += 1 M = int(eval(input())) t = [eval(input()) for j in range(M)] for j in range(M): dic.setdefault(t[j],0) dic[t[j]] -= 1 if max(dic.values()) > 0: print((max(dic.values()))) else: print((0))

dic = {} N = int(eval(input())) for k in range(N): i = eval(input()) if i in dic: dic[i] += 1 else: dic[i] = 1 M = int(eval(input())) for j in range(M): i = eval(input()) if i in dic: dic[i] -= 1 print((max(max(dic.values()), 0)))

dic = {} N = int(eval(input())) s = [eval(input()) for i in range(N)] for i in range(N): dic.setdefault(s[i], 0) dic[s[i]] += 1 M = int(eval(input())) t = [eval(input()) for j in range(M)] for j in range(M): dic.setdefault(t[j], 0) dic[t[j]] -= 1 if max(dic.values()) > 0: print((max(dic.values()))) else: print((0))

dic = {} N = int(eval(input())) for k in range(N): i = eval(input()) if i in dic: dic[i] += 1 else: dic[i] = 1 M = int(eval(input())) for j in range(M): i = eval(input()) if i in dic: dic[i] -= 1 print((max(max(dic.values()), 0)))

u153729035

p02629

python

s876547006

s789702263

Accepted

Accepted

def f(n): alphabets = "abcdefghijklmnopqrstuvwxyz" s = "" while n > 0: n, mod = divmod(n, 26) if mod == 0: s += 'z' n -= 1 else: s += alphabets[mod - 1] return s[::-1] print((f(int(eval(input())))))

n = int(eval(input())) a = "abcdefghijklmnopqrstuvwxyz" s = "" while n > 0: n, m = divmod(n, 26) if not m: n -= 1 s = a[(m - 1) % 26] + s print(s)

def f(n): alphabets = "abcdefghijklmnopqrstuvwxyz" s = "" while n > 0: n, mod = divmod(n, 26) if mod == 0: s += "z" n -= 1 else: s += alphabets[mod - 1] return s[::-1] print((f(int(eval(input())))))

n = int(eval(input())) a = "abcdefghijklmnopqrstuvwxyz" s = "" while n > 0: n, m = divmod(n, 26) if not m: n -= 1 s = a[(m - 1) % 26] + s print(s)

u073549161

p03029

python

s247341133

s786455801

Accepted

Accepted

a,p = list(map(int, input().split())) p += a * 3 print((int(p/2)))

a, p = list(map(int, input().split())) p += a * 3 print((p//2))

a, p = list(map(int, input().split())) p += a * 3 print((int(p / 2)))

a, p = list(map(int, input().split())) p += a * 3 print((p // 2))

u746419473

p03408

python

s970269235

s659560817

Accepted

Accepted

n=[eval(input()) for _ in range(int(eval(input())))] m=[eval(input()) for _ in range(int(eval(input())))] l=list(set(n)) print((max(0,max(n.count(l[i])-m.count(l[i]) for i in range(len(l))))))

ans = {} n = int(eval(input())) for _ in range(n): s = eval(input()) ans.setdefault(s, 0) ans[s] += 1 m = int(eval(input())) for _ in range(m): t = eval(input()) ans.setdefault(t, 0) ans[t] -= 1 ans = sorted(list(ans.items()), key=lambda x: x[1], reverse=True) print((max(0, ans[0][1])))

n = [eval(input()) for _ in range(int(eval(input())))] m = [eval(input()) for _ in range(int(eval(input())))] l = list(set(n)) print((max(0, max(n.count(l[i]) - m.count(l[i]) for i in range(len(l))))))

ans = {} n = int(eval(input())) for _ in range(n): s = eval(input()) ans.setdefault(s, 0) ans[s] += 1 m = int(eval(input())) for _ in range(m): t = eval(input()) ans.setdefault(t, 0) ans[t] -= 1 ans = sorted(list(ans.items()), key=lambda x: x[1], reverse=True) print((max(0, ans[0][1])))

u840310460

p03486

python

s443119935

s503277985

Accepted

Accepted

S = sorted(eval(input())) T = sorted(eval(input()), reverse=True) if S < T: print("Yes") else: print("No")

s = sorted(eval(input())) t = sorted(eval(input()), reverse=True) if s<t: print("Yes") else: print("No")

S = sorted(eval(input())) T = sorted(eval(input()), reverse=True) if S < T: print("Yes") else: print("No")

s = sorted(eval(input())) t = sorted(eval(input()), reverse=True) if s < t: print("Yes") else: print("No")

u564902833

p03006

python

s612977338

s397162403

Accepted

Accepted

N = int(eval(input())) x, y = ( list(zip(*(list(map(int, input().split())) for _ in range(N)))) if N else ((), ()) ) class UnionFindTree: def __init__(self, n): self.p = [i for i in range(n + 1)] self.r = [0 for _ in range(n + 1)] def find(self, x): if self.p[x] != x: self.p[x] = self.find(self.p[x]) return self.p[x] def union(self, x, y): px = self.find(x) py = self.find(y) if px != py: if self.r[px] < self.r[py]: self.p[px] = py else: self.p[py] = px if self.r[px] == self.r[py]: self.r[px] += 1 def same(self, x, y): return self.find(x) == self.find(y) ans = 10**10 for i in range(N): for j in range(N): p, q = (x[i] - x[j], y[i] - y[j]) uft = UnionFindTree(N) for u in range(N - 1): for v in range(u + 1, N): if (x[u] - x[v], y[u] - y[v]) == (p, q) or (x[u] - x[v], y[u] - y[v]) == (-p, -q): uft.union(u, v) ans = min(ans, len({uft.find(z) for z in range(N)})) print(ans)

from collections import Counter from itertools import permutations N = int(eval(input())) x, y = ( list(zip(*(list(map(int, input().split())) for _ in range(N)))) if N else ((), ()) ) # (p, q) = (x_i - x_j, y_i - y_j) を満たす組(i, j)の個数が最大となるように # p, qを定めればよい ans = ( 1 if N == 1 else N - max( Counter( (x[i] - x[j], y[i] - y[j]) for i, j in permutations(list(range(N)), 2) ).values() ) ) print(ans)

N = int(eval(input())) x, y = ( list(zip(*(list(map(int, input().split())) for _ in range(N)))) if N else ((), ()) ) class UnionFindTree: def __init__(self, n): self.p = [i for i in range(n + 1)] self.r = [0 for _ in range(n + 1)] def find(self, x): if self.p[x] != x: self.p[x] = self.find(self.p[x]) return self.p[x] def union(self, x, y): px = self.find(x) py = self.find(y) if px != py: if self.r[px] < self.r[py]: self.p[px] = py else: self.p[py] = px if self.r[px] == self.r[py]: self.r[px] += 1 def same(self, x, y): return self.find(x) == self.find(y) ans = 10**10 for i in range(N): for j in range(N): p, q = (x[i] - x[j], y[i] - y[j]) uft = UnionFindTree(N) for u in range(N - 1): for v in range(u + 1, N): if (x[u] - x[v], y[u] - y[v]) == (p, q) or ( x[u] - x[v], y[u] - y[v], ) == (-p, -q): uft.union(u, v) ans = min(ans, len({uft.find(z) for z in range(N)})) print(ans)

from collections import Counter from itertools import permutations N = int(eval(input())) x, y = ( list(zip(*(list(map(int, input().split())) for _ in range(N)))) if N else ((), ()) ) # (p, q) = (x_i - x_j, y_i - y_j) を満たす組(i, j)の個数が最大となるように # p, qを定めればよい ans = ( 1 if N == 1 else N - max( Counter( (x[i] - x[j], y[i] - y[j]) for i, j in permutations(list(range(N)), 2) ).values() ) ) print(ans)

u698176039

p03607

python

s965909519

s410517718

Accepted

Accepted

N = int(eval(input())) A = [int(eval(input())) for _ in range(N)] mydict = dict() cnt = 0 for i in range(N): if not (A[i] in mydict): mydict[A[i]] = i counter = [0] * N for a in A: counter[mydict[a]] += 1 ans = 0 for c in counter: if c%2 == 1: ans += 1 print(ans)

N = int(eval(input())) A = [int(eval(input())) for _ in range(N)] import collections c = collections.Counter(A) ans = 0 for t in list(c.values()): if t%2 == 1: ans += 1 print(ans)

N = int(eval(input())) A = [int(eval(input())) for _ in range(N)] mydict = dict() cnt = 0 for i in range(N): if not (A[i] in mydict): mydict[A[i]] = i counter = [0] * N for a in A: counter[mydict[a]] += 1 ans = 0 for c in counter: if c % 2 == 1: ans += 1 print(ans)

N = int(eval(input())) A = [int(eval(input())) for _ in range(N)] import collections c = collections.Counter(A) ans = 0 for t in list(c.values()): if t % 2 == 1: ans += 1 print(ans)

u620238824

p02712

python

s543191627

s445944723

Accepted

Accepted

N = int(eval(input())) #スペース抜きの複数行,１文字ずつ A = [] for i in range(1,N+1): if i % 3 == 0: A.append(0) elif i % 5 == 0: A.append(0) else: A.append(i) print((sum(A)))

N = int(eval(input())) sum = 0 for i in range(1, N + 1): if i % 3 == 0: continue elif i % 5 == 0: continue else: sum += i print(sum)

N = int(eval(input())) # スペース抜きの複数行,１文字ずつ A = [] for i in range(1, N + 1): if i % 3 == 0: A.append(0) elif i % 5 == 0: A.append(0) else: A.append(i) print((sum(A)))

N = int(eval(input())) sum = 0 for i in range(1, N + 1): if i % 3 == 0: continue elif i % 5 == 0: continue else: sum += i print(sum)

u021019433

p02732

python

s120288834

s025405940

Accepted

Accepted

from collections import Counter eval(input()) a = list(map(int, input().split())) c = Counter(a) s = sum(k * (k - 1) // 2 for k in list(c.values())) for x in a: print((s - c[x] + 1))

from collections import Counter eval(input()) a = list(map(int, input().split())) c = Counter(a) s = sum(k * (k - 1) // 2 for k in list(c.values())) + 1 for x in a: print((s - c[x]))

from collections import Counter eval(input()) a = list(map(int, input().split())) c = Counter(a) s = sum(k * (k - 1) // 2 for k in list(c.values())) for x in a: print((s - c[x] + 1))

from collections import Counter eval(input()) a = list(map(int, input().split())) c = Counter(a) s = sum(k * (k - 1) // 2 for k in list(c.values())) + 1 for x in a: print((s - c[x]))

u785989355

p02901

python

s260003436

s593292573

Accepted

Accepted

N,M = list(map(int,input().split())) A = [] C = [] for i in range(M): a,b = list(map(int,input().split())) c = list(map(int,input().split())) A.append(a) d = 0 for j in range(b): d += pow(2, c[j]-1) C.append(d) goal = pow(2, N)-1 e_list = [[] for i in range(goal+1)] for i in range(goal+1): for j in range(M): e_list[i].append((i|C[j],A[j])) #dijkstra #you need to prepare e_list = [[orient,dist]] import heapq vi = 0 min_d_list = [10**27 for i in range(goal+1)] min_d_list[vi] = 0 q = [] for i in range(N): heapq.heappush(q,[min_d_list[i],i]) while len(q)>0: d,v = heapq.heappop(q) for e in e_list[v]: v1,d1=e if min_d_list[v1]>d+d1: min_d_list[v1]=d+d1 heapq.heappush(q,[d+d1,v1]) if min_d_list[goal]>=10**27: print((-1)) else: print((min_d_list[goal]))

N,M = list(map(int,input().split())) a_list = [] c_list = [] for i in range(M): a,b = list(map(int,input().split())) a_list.append(a) c = list(map(int,input().split())) d = 0 for cc in c: d += 2**(cc-1) c_list.append(d) DP = [[10**27]*(2**N) for i in range(M+1)] DP[0][0]=0 for i in range(1,M+1): for j in range(2**N): #print(c_list[i-1] | j) DP[i][j] = min(DP[i][j],DP[i-1][j]) DP[i][c_list[i-1] | j] = min(DP[i][c_list[i-1] | j],DP[i-1][j] + a_list[i-1]) #print(DP) if DP[M][2**N-1]>=10**27: print((-1)) else: print((DP[M][2**N-1]))

N, M = list(map(int, input().split())) A = [] C = [] for i in range(M): a, b = list(map(int, input().split())) c = list(map(int, input().split())) A.append(a) d = 0 for j in range(b): d += pow(2, c[j] - 1) C.append(d) goal = pow(2, N) - 1 e_list = [[] for i in range(goal + 1)] for i in range(goal + 1): for j in range(M): e_list[i].append((i | C[j], A[j])) # dijkstra # you need to prepare e_list = [[orient,dist]] import heapq vi = 0 min_d_list = [10**27 for i in range(goal + 1)] min_d_list[vi] = 0 q = [] for i in range(N): heapq.heappush(q, [min_d_list[i], i]) while len(q) > 0: d, v = heapq.heappop(q) for e in e_list[v]: v1, d1 = e if min_d_list[v1] > d + d1: min_d_list[v1] = d + d1 heapq.heappush(q, [d + d1, v1]) if min_d_list[goal] >= 10**27: print((-1)) else: print((min_d_list[goal]))

N, M = list(map(int, input().split())) a_list = [] c_list = [] for i in range(M): a, b = list(map(int, input().split())) a_list.append(a) c = list(map(int, input().split())) d = 0 for cc in c: d += 2 ** (cc - 1) c_list.append(d) DP = [[10**27] * (2**N) for i in range(M + 1)] DP[0][0] = 0 for i in range(1, M + 1): for j in range(2**N): # print(c_list[i-1] | j) DP[i][j] = min(DP[i][j], DP[i - 1][j]) DP[i][c_list[i - 1] | j] = min( DP[i][c_list[i - 1] | j], DP[i - 1][j] + a_list[i - 1] ) # print(DP) if DP[M][2**N - 1] >= 10**27: print((-1)) else: print((DP[M][2**N - 1]))

u620084012

p03611

python

s636015571

s012568991

Accepted

Accepted

from collections import Counter N = int(eval(input())) A = list(map(int,input().split())) C = Counter(A) ans = 0 for e in C: ans = max(ans,C[e]+C[e-1]+C[e+1]) print(ans)

N = int(eval(input())) a = list(map(int,input().split())) b = [0]*(10**5+10) for e in a: b[e+1] += 1 ans = 0 for k in range(10**5+2): ans = max(ans,b[k]+b[k+1]+b[k+2]) print(ans)

from collections import Counter N = int(eval(input())) A = list(map(int, input().split())) C = Counter(A) ans = 0 for e in C: ans = max(ans, C[e] + C[e - 1] + C[e + 1]) print(ans)

N = int(eval(input())) a = list(map(int, input().split())) b = [0] * (10**5 + 10) for e in a: b[e + 1] += 1 ans = 0 for k in range(10**5 + 2): ans = max(ans, b[k] + b[k + 1] + b[k + 2]) print(ans)

u989345508

p02696

python

s594594747

s076659012

Accepted

Accepted

a,b,n=list(map(int,input().split()));print((a*min(n,b-1)//b))

a,b,n=list(map(int,input().split()));print((a*min(b-1,n)//b))

a, b, n = list(map(int, input().split())) print((a * min(n, b - 1) // b))

a, b, n = list(map(int, input().split())) print((a * min(b - 1, n) // b))

u334712262

p02679

python

s017717836

s240810239

Accepted

Accepted

# -*- coding: utf-8 -*- from fractions import Fraction from collections import Counter import math import sys # sys.setrecursionlimit(10**6) # buff_readline = sys.stdin.buffer.readline buff_readline = sys.stdin.readline readline = sys.stdin.readline INF = 2**62-1 def read_int(): return int(buff_readline()) def read_int_n(): return list(map(int, buff_readline().split())) def read_float(): return float(buff_readline()) def read_float_n(): return list(map(float, buff_readline().split())) def read_str(): return readline().strip() def read_str_n(): return readline().strip().split() def error_print(*args): print(*args, file=sys.stderr) def mt(f): import time def wrap(*args, **kwargs): s = time.time() ret = f(*args, **kwargs) e = time.time() error_print(e - s, 'sec') return ret return wrap def fract(a, b): if a == 0 and b == 0: return (0, 0) if b == 0: return (1, 0) f = Fraction(a, b) a = f.numerator b = f.denominator return a, b class Mod: def __init__(self, m): self.m = m def add(self, a, b): return (a + b) % self.m def sub(self, a, b): return (a - b) % self.m def mul(self, a, b): return ((a % self.m) * (b % self.m)) % self.m def div(self, a, b): return self.mul(a, pow(b, self.m-2, self.m)) def pow(self, a, b): return pow(a, b, self.m) @mt def slv(N, AB): adb = Counter() for a, b in AB: k = fract(a, b) adb[k] += 1 M = Mod(1000000007) ans = 1 done = {(0, 0)} for k, v in adb.items(): if k in done: continue a, b = k kk = fract(-b, a) done.add(k) done.add(kk) n = adb[kk] t = M.sub(M.pow(2, v) + M.pow(2, n), 1) ans = M.mul(ans, t) ans = M.add(ans, adb[(0, 0)]) return M.sub(ans, 1) def main(): N = read_int() AB = [read_int_n() for _ in range(N)] print(slv(N, AB)) if __name__ == '__main__': main()

# -*- coding: utf-8 -*- from fractions import Fraction from collections import Counter import math import sys # sys.setrecursionlimit(10**6) # buff_readline = sys.stdin.buffer.readline buff_readline = sys.stdin.readline readline = sys.stdin.readline INF = 2**62-1 def read_int(): return int(buff_readline()) def read_int_n(): return list(map(int, buff_readline().split())) def read_float(): return float(buff_readline()) def read_float_n(): return list(map(float, buff_readline().split())) def read_str(): return readline().strip() def read_str_n(): return readline().strip().split() def error_print(*args): print(*args, file=sys.stderr) def mt(f): import time def wrap(*args, **kwargs): s = time.time() ret = f(*args, **kwargs) e = time.time() error_print(e - s, 'sec') return ret return wrap class Mod: def __init__(self, m): self.m = m def add(self, a, b): return (a + b) % self.m def sub(self, a, b): return (a - b) % self.m def mul(self, a, b): return ((a % self.m) * (b % self.m)) % self.m def div(self, a, b): return self.mul(a, pow(b, self.m-2, self.m)) def pow(self, a, b): return pow(a, b, self.m) def fract(a, b): if a == 0 and b == 0: return (0, 0) if b == 0: return (1, 0) f = Fraction(a, b) return f.numerator, f.denominator @mt def slv(N, AB): adb = Counter() for a, b in AB: k = fract(a, b) adb[k] += 1 M = Mod(1000000007) ans = 1 done = {(0, 0)} for k, v in adb.items(): if k in done: continue a, b = k kk = fract(-b, a) done.add(k) done.add(kk) n = adb[kk] t = M.sub(M.pow(2, v) + M.pow(2, n), 1) ans = M.mul(ans, t) ans = M.add(ans, adb[(0, 0)]) return M.sub(ans, 1) def main(): N = read_int() AB = [read_int_n() for _ in range(N)] print(slv(N, AB)) if __name__ == '__main__': main()

# -*- coding: utf-8 -*- from fractions import Fraction from collections import Counter import math import sys # sys.setrecursionlimit(10**6) # buff_readline = sys.stdin.buffer.readline buff_readline = sys.stdin.readline readline = sys.stdin.readline INF = 2**62 - 1 def read_int(): return int(buff_readline()) def read_int_n(): return list(map(int, buff_readline().split())) def read_float(): return float(buff_readline()) def read_float_n(): return list(map(float, buff_readline().split())) def read_str(): return readline().strip() def read_str_n(): return readline().strip().split() def error_print(*args): print(*args, file=sys.stderr) def mt(f): import time def wrap(*args, **kwargs): s = time.time() ret = f(*args, **kwargs) e = time.time() error_print(e - s, "sec") return ret return wrap def fract(a, b): if a == 0 and b == 0: return (0, 0) if b == 0: return (1, 0) f = Fraction(a, b) a = f.numerator b = f.denominator return a, b class Mod: def __init__(self, m): self.m = m def add(self, a, b): return (a + b) % self.m def sub(self, a, b): return (a - b) % self.m def mul(self, a, b): return ((a % self.m) * (b % self.m)) % self.m def div(self, a, b): return self.mul(a, pow(b, self.m - 2, self.m)) def pow(self, a, b): return pow(a, b, self.m) @mt def slv(N, AB): adb = Counter() for a, b in AB: k = fract(a, b) adb[k] += 1 M = Mod(1000000007) ans = 1 done = {(0, 0)} for k, v in adb.items(): if k in done: continue a, b = k kk = fract(-b, a) done.add(k) done.add(kk) n = adb[kk] t = M.sub(M.pow(2, v) + M.pow(2, n), 1) ans = M.mul(ans, t) ans = M.add(ans, adb[(0, 0)]) return M.sub(ans, 1) def main(): N = read_int() AB = [read_int_n() for _ in range(N)] print(slv(N, AB)) if __name__ == "__main__": main()

# -*- coding: utf-8 -*- from fractions import Fraction from collections import Counter import math import sys # sys.setrecursionlimit(10**6) # buff_readline = sys.stdin.buffer.readline buff_readline = sys.stdin.readline readline = sys.stdin.readline INF = 2**62 - 1 def read_int(): return int(buff_readline()) def read_int_n(): return list(map(int, buff_readline().split())) def read_float(): return float(buff_readline()) def read_float_n(): return list(map(float, buff_readline().split())) def read_str(): return readline().strip() def read_str_n(): return readline().strip().split() def error_print(*args): print(*args, file=sys.stderr) def mt(f): import time def wrap(*args, **kwargs): s = time.time() ret = f(*args, **kwargs) e = time.time() error_print(e - s, "sec") return ret return wrap class Mod: def __init__(self, m): self.m = m def add(self, a, b): return (a + b) % self.m def sub(self, a, b): return (a - b) % self.m def mul(self, a, b): return ((a % self.m) * (b % self.m)) % self.m def div(self, a, b): return self.mul(a, pow(b, self.m - 2, self.m)) def pow(self, a, b): return pow(a, b, self.m) def fract(a, b): if a == 0 and b == 0: return (0, 0) if b == 0: return (1, 0) f = Fraction(a, b) return f.numerator, f.denominator @mt def slv(N, AB): adb = Counter() for a, b in AB: k = fract(a, b) adb[k] += 1 M = Mod(1000000007) ans = 1 done = {(0, 0)} for k, v in adb.items(): if k in done: continue a, b = k kk = fract(-b, a) done.add(k) done.add(kk) n = adb[kk] t = M.sub(M.pow(2, v) + M.pow(2, n), 1) ans = M.mul(ans, t) ans = M.add(ans, adb[(0, 0)]) return M.sub(ans, 1) def main(): N = read_int() AB = [read_int_n() for _ in range(N)] print(slv(N, AB)) if __name__ == "__main__": main()

u334712262

p02692

python

s514960455

s524052362

Accepted

Accepted

# -*- coding: utf-8 -*- import bisect import heapq import math import random import sys from collections import Counter, defaultdict, deque from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal from functools import lru_cache, reduce from itertools import combinations, combinations_with_replacement, product, permutations from operator import add, mul, sub sys.setrecursionlimit(10**6) buff_readline = sys.stdin.buffer.readline readline = sys.stdin.readline INF = 2**62-1 def read_int(): return int(buff_readline()) def read_int_n(): return list(map(int, buff_readline().split())) def read_float(): return float(buff_readline()) def read_float_n(): return list(map(float, buff_readline().split())) def read_str(): return readline().strip() def read_str_n(): return readline().strip().split() def error_print(*args): print(*args, file=sys.stderr) def mt(f): import time def wrap(*args, **kwargs): s = time.time() ret = f(*args, **kwargs) e = time.time() error_print(e - s, 'sec') return ret return wrap @mt def slv(N, A, B, C, S): D = [A, B, C] ans = [] def f(s): t = [] if 'A' in s: t.append(0) if 'B' in s: t.append(1) if 'C' in s: t.append(2) return t for i, s in enumerate(S): t = f(s) if D[t[0]] == 0 and D[t[1]] == 0: print('No') return else: if D[t[0]] == D[t[1]] == 1 and i != N-1: ns = S[i+1] if s == ns: ans.append(t[1]) D[t[0]] -= 1 D[t[1]] += 1 else: n = set(t) & set(f(ns)) m = set(t) - n n = n.pop() m = m.pop() ans.append(n) D[n] += 1 D[m] -= 1 elif D[t[0]] > D[t[1]]: ans.append(t[1]) D[t[0]] -= 1 D[t[1]] += 1 else: ans.append(t[0]) D[t[0]] += 1 D[t[1]] -= 1 print('Yes') for a in ans: if a == 0: print('A') elif a == 1: print('B') else: print('C') def main(): N, A, B, C = read_int_n() S = [read_str() for _ in range(N)] (slv(N, A, B, C, S)) # N = 10**5 # A = random.randint(1, 10**9) # B = random.randint(1, 10**9) # C = random.randint(1, 10**9) # S = random.choices(['AB', 'AC', 'BC'], k=N) # (slv(N, A, B, C, S)) if __name__ == '__main__': main()

# -*- coding: utf-8 -*- import sys buff_readline = sys.stdin.buffer.readline readline = sys.stdin.readline def read_int_n(): return list(map(int, buff_readline().split())) def read_str(): return readline().strip() def slv(N, A, B, C, S): D = [A, B, C] ans = [] def f(s): t = [] if 'A' in s: t.append(0) if 'B' in s: t.append(1) if 'C' in s: t.append(2) return t for i, s in enumerate(S): t = f(s) if D[t[0]] == 0 and D[t[1]] == 0: print('No') return else: if D[t[0]] == D[t[1]] == 1 and i != N-1: ns = S[i+1] if s == ns: ans.append(t[1]) D[t[0]] -= 1 D[t[1]] += 1 else: n = set(t) & set(f(ns)) m = set(t) - n n = n.pop() m = m.pop() ans.append(n) D[n] += 1 D[m] -= 1 elif D[t[0]] > D[t[1]]: ans.append(t[1]) D[t[0]] -= 1 D[t[1]] += 1 else: ans.append(t[0]) D[t[0]] += 1 D[t[1]] -= 1 print('Yes') for a in ans: if a == 0: print('A') elif a == 1: print('B') else: print('C') def main(): N, A, B, C = read_int_n() S = [read_str() for _ in range(N)] (slv(N, A, B, C, S)) if __name__ == '__main__': main()

# -*- coding: utf-8 -*- import bisect import heapq import math import random import sys from collections import Counter, defaultdict, deque from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal from functools import lru_cache, reduce from itertools import combinations, combinations_with_replacement, product, permutations from operator import add, mul, sub sys.setrecursionlimit(10**6) buff_readline = sys.stdin.buffer.readline readline = sys.stdin.readline INF = 2**62 - 1 def read_int(): return int(buff_readline()) def read_int_n(): return list(map(int, buff_readline().split())) def read_float(): return float(buff_readline()) def read_float_n(): return list(map(float, buff_readline().split())) def read_str(): return readline().strip() def read_str_n(): return readline().strip().split() def error_print(*args): print(*args, file=sys.stderr) def mt(f): import time def wrap(*args, **kwargs): s = time.time() ret = f(*args, **kwargs) e = time.time() error_print(e - s, "sec") return ret return wrap @mt def slv(N, A, B, C, S): D = [A, B, C] ans = [] def f(s): t = [] if "A" in s: t.append(0) if "B" in s: t.append(1) if "C" in s: t.append(2) return t for i, s in enumerate(S): t = f(s) if D[t[0]] == 0 and D[t[1]] == 0: print("No") return else: if D[t[0]] == D[t[1]] == 1 and i != N - 1: ns = S[i + 1] if s == ns: ans.append(t[1]) D[t[0]] -= 1 D[t[1]] += 1 else: n = set(t) & set(f(ns)) m = set(t) - n n = n.pop() m = m.pop() ans.append(n) D[n] += 1 D[m] -= 1 elif D[t[0]] > D[t[1]]: ans.append(t[1]) D[t[0]] -= 1 D[t[1]] += 1 else: ans.append(t[0]) D[t[0]] += 1 D[t[1]] -= 1 print("Yes") for a in ans: if a == 0: print("A") elif a == 1: print("B") else: print("C") def main(): N, A, B, C = read_int_n() S = [read_str() for _ in range(N)] (slv(N, A, B, C, S)) # N = 10**5 # A = random.randint(1, 10**9) # B = random.randint(1, 10**9) # C = random.randint(1, 10**9) # S = random.choices(['AB', 'AC', 'BC'], k=N) # (slv(N, A, B, C, S)) if __name__ == "__main__": main()

# -*- coding: utf-8 -*- import sys buff_readline = sys.stdin.buffer.readline readline = sys.stdin.readline def read_int_n(): return list(map(int, buff_readline().split())) def read_str(): return readline().strip() def slv(N, A, B, C, S): D = [A, B, C] ans = [] def f(s): t = [] if "A" in s: t.append(0) if "B" in s: t.append(1) if "C" in s: t.append(2) return t for i, s in enumerate(S): t = f(s) if D[t[0]] == 0 and D[t[1]] == 0: print("No") return else: if D[t[0]] == D[t[1]] == 1 and i != N - 1: ns = S[i + 1] if s == ns: ans.append(t[1]) D[t[0]] -= 1 D[t[1]] += 1 else: n = set(t) & set(f(ns)) m = set(t) - n n = n.pop() m = m.pop() ans.append(n) D[n] += 1 D[m] -= 1 elif D[t[0]] > D[t[1]]: ans.append(t[1]) D[t[0]] -= 1 D[t[1]] += 1 else: ans.append(t[0]) D[t[0]] += 1 D[t[1]] -= 1 print("Yes") for a in ans: if a == 0: print("A") elif a == 1: print("B") else: print("C") def main(): N, A, B, C = read_int_n() S = [read_str() for _ in range(N)] (slv(N, A, B, C, S)) if __name__ == "__main__": main()

u922449550

p02564

python

s460846341

s822154396

Accepted

Accepted

class CSR: def __init__(self, n: int, edges: list): self.start = [0] * (n+1) self.elist = [0] * len(edges) for e in edges: self.start[e[0]+1] += 1 for i in range(1, n+1): self.start[i] += self.start[i-1] counter = self.start[::] # copy for e in edges: self.elist[counter[e[0]]] = e[1] counter[e[0]] += 1 class SccGraph: def __init__(self, n: int = 0): self.__n = n self.__edges = [] def __len__(self): return self.__n def add_edge(self, s: int, t: int): assert 0 <= s < self.__n and 0 <= t < self.__n self.__edges.append([s, t]) def __scc_ids(self): g = CSR(self.__n, self.__edges) now_ord = group_num = 0 visited = [] low = [0] * self.__n order = [-1] * self.__n ids = [0] * self.__n parent = [-1] * self.__n for root in range(self.__n): if order[root] == -1: stack = [root, root] while stack: v = stack.pop() if order[v] == -1: visited.append(v) low[v] = order[v] = now_ord now_ord += 1 for i in range(g.start[v], g.start[v+1]): t = g.elist[i] if order[t] == -1: stack += [t, t] parent[t] = v else: low[v] = min(low[v], order[t]) else: if low[v] == order[v]: while True: u = visited.pop() order[u] = self.__n ids[u] = group_num if u == v: break group_num += 1 if parent[v] != -1: low[parent[v]] = min(low[parent[v]], low[v]) for i, x in enumerate(ids): ids[i] = group_num - 1 - x return group_num, ids def scc(self): group_num, ids = self.__scc_ids() counts = [0] * group_num for x in ids: counts[x] += 1 groups = [[] for _ in range(group_num)] for i, x in enumerate(ids): groups[x].append(i) return groups N, M = list(map(int, input().split())) sg = SccGraph(N) for _ in range(M): a, b = list(map(int, input().split())) sg.add_edge(a, b) scc = sg.scc() print((len(scc))) for group in scc: print((*([len(group)] + group)))

class CSR: def __init__(self, n: int, edges: list): self.start = [0] * (n+1) self.elist = [0] * len(edges) for e in edges: self.start[e[0]+1] += 1 for i in range(1, n+1): self.start[i] += self.start[i-1] counter = self.start[::] # copy for e in edges: self.elist[counter[e[0]]] = e[1] counter[e[0]] += 1 class SccGraph: def __init__(self, n: int = 0): self.__n = n self.__edges = [] def __len__(self): return self.__n def add_edge(self, s: int, t: int): assert 0 <= s < self.__n and 0 <= t < self.__n self.__edges.append([s, t]) def __scc_ids(self): g = CSR(self.__n, self.__edges) now_ord = group_num = 0 visited = [] low = [0] * self.__n order = [-1] * self.__n ids = [0] * self.__n parent = [-1] * self.__n for root in range(self.__n): if order[root] == -1: stack = [root, root] while stack: v = stack.pop() if order[v] == -1: visited.append(v) low[v] = order[v] = now_ord now_ord += 1 for i in range(g.start[v], g.start[v+1]): t = g.elist[i] if order[t] == -1: stack += [t, t] parent[t] = v else: low[v] = min(low[v], order[t]) else: if low[v] == order[v]: while True: u = visited.pop() order[u] = self.__n ids[u] = group_num if u == v: break group_num += 1 if parent[v] != -1: low[parent[v]] = min(low[parent[v]], low[v]) for i, x in enumerate(ids): ids[i] = group_num - 1 - x return group_num, ids def scc(self): group_num, ids = self.__scc_ids() counts = [0] * group_num for x in ids: counts[x] += 1 groups = [[] for _ in range(group_num)] for i, x in enumerate(ids): groups[x].append(i) return groups import sys read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline readlines = sys.stdin.buffer.readlines N, M = list(map(int,readline().split())) data = list(map(int,read().split())) sg = SccGraph(N) it = iter(data) for a, b in zip(it, it): sg.add_edge(a,b) scc = sg.scc() print((len(scc))) for group in scc: print((*([len(group)] + group)))

class CSR: def __init__(self, n: int, edges: list): self.start = [0] * (n + 1) self.elist = [0] * len(edges) for e in edges: self.start[e[0] + 1] += 1 for i in range(1, n + 1): self.start[i] += self.start[i - 1] counter = self.start[::] # copy for e in edges: self.elist[counter[e[0]]] = e[1] counter[e[0]] += 1 class SccGraph: def __init__(self, n: int = 0): self.__n = n self.__edges = [] def __len__(self): return self.__n def add_edge(self, s: int, t: int): assert 0 <= s < self.__n and 0 <= t < self.__n self.__edges.append([s, t]) def __scc_ids(self): g = CSR(self.__n, self.__edges) now_ord = group_num = 0 visited = [] low = [0] * self.__n order = [-1] * self.__n ids = [0] * self.__n parent = [-1] * self.__n for root in range(self.__n): if order[root] == -1: stack = [root, root] while stack: v = stack.pop() if order[v] == -1: visited.append(v) low[v] = order[v] = now_ord now_ord += 1 for i in range(g.start[v], g.start[v + 1]): t = g.elist[i] if order[t] == -1: stack += [t, t] parent[t] = v else: low[v] = min(low[v], order[t]) else: if low[v] == order[v]: while True: u = visited.pop() order[u] = self.__n ids[u] = group_num if u == v: break group_num += 1 if parent[v] != -1: low[parent[v]] = min(low[parent[v]], low[v]) for i, x in enumerate(ids): ids[i] = group_num - 1 - x return group_num, ids def scc(self): group_num, ids = self.__scc_ids() counts = [0] * group_num for x in ids: counts[x] += 1 groups = [[] for _ in range(group_num)] for i, x in enumerate(ids): groups[x].append(i) return groups N, M = list(map(int, input().split())) sg = SccGraph(N) for _ in range(M): a, b = list(map(int, input().split())) sg.add_edge(a, b) scc = sg.scc() print((len(scc))) for group in scc: print((*([len(group)] + group)))

class CSR: def __init__(self, n: int, edges: list): self.start = [0] * (n + 1) self.elist = [0] * len(edges) for e in edges: self.start[e[0] + 1] += 1 for i in range(1, n + 1): self.start[i] += self.start[i - 1] counter = self.start[::] # copy for e in edges: self.elist[counter[e[0]]] = e[1] counter[e[0]] += 1 class SccGraph: def __init__(self, n: int = 0): self.__n = n self.__edges = [] def __len__(self): return self.__n def add_edge(self, s: int, t: int): assert 0 <= s < self.__n and 0 <= t < self.__n self.__edges.append([s, t]) def __scc_ids(self): g = CSR(self.__n, self.__edges) now_ord = group_num = 0 visited = [] low = [0] * self.__n order = [-1] * self.__n ids = [0] * self.__n parent = [-1] * self.__n for root in range(self.__n): if order[root] == -1: stack = [root, root] while stack: v = stack.pop() if order[v] == -1: visited.append(v) low[v] = order[v] = now_ord now_ord += 1 for i in range(g.start[v], g.start[v + 1]): t = g.elist[i] if order[t] == -1: stack += [t, t] parent[t] = v else: low[v] = min(low[v], order[t]) else: if low[v] == order[v]: while True: u = visited.pop() order[u] = self.__n ids[u] = group_num if u == v: break group_num += 1 if parent[v] != -1: low[parent[v]] = min(low[parent[v]], low[v]) for i, x in enumerate(ids): ids[i] = group_num - 1 - x return group_num, ids def scc(self): group_num, ids = self.__scc_ids() counts = [0] * group_num for x in ids: counts[x] += 1 groups = [[] for _ in range(group_num)] for i, x in enumerate(ids): groups[x].append(i) return groups import sys read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline readlines = sys.stdin.buffer.readlines N, M = list(map(int, readline().split())) data = list(map(int, read().split())) sg = SccGraph(N) it = iter(data) for a, b in zip(it, it): sg.add_edge(a, b) scc = sg.scc() print((len(scc))) for group in scc: print((*([len(group)] + group)))

u363407238

p03042

python

s804351765

s630310232

Accepted

Accepted

import sys input = sys.stdin.readline s = eval(input()) s1 = int(s[:2]) s2 = int(s[2:]) isS1MM = 1 <= s1 <= 12 isS2MM = 1 <= s2 <= 12 if isS1MM and isS2MM: print("AMBIGUOUS") elif not isS1MM and isS2MM: print("YYMM") elif isS1MM and not isS2MM: print("MMYY") else: print('NA')

import sys input = sys.stdin.readline s = eval(input()) s1 = int(s[:2]) s2 = int(s[2:]) isS1YYMM = 1 <= s1 <= 12 isS2MMYY = 1 <= s2 <= 12 if isS1YYMM: if isS2MMYY: print("AMBIGUOUS") else: print("MMYY") else: if isS2MMYY: print("YYMM") else: print('NA')

import sys input = sys.stdin.readline s = eval(input()) s1 = int(s[:2]) s2 = int(s[2:]) isS1MM = 1 <= s1 <= 12 isS2MM = 1 <= s2 <= 12 if isS1MM and isS2MM: print("AMBIGUOUS") elif not isS1MM and isS2MM: print("YYMM") elif isS1MM and not isS2MM: print("MMYY") else: print("NA")

import sys input = sys.stdin.readline s = eval(input()) s1 = int(s[:2]) s2 = int(s[2:]) isS1YYMM = 1 <= s1 <= 12 isS2MMYY = 1 <= s2 <= 12 if isS1YYMM: if isS2MMYY: print("AMBIGUOUS") else: print("MMYY") else: if isS2MMYY: print("YYMM") else: print("NA")

u813098295

p03776

python

s098556324

s628180170

Accepted

Accepted

from math import factorial def comb(n, k): f = factorial return f(n) / f(k) / f(n-k) N, A, B = list(map(int, input().split())) v = list(map(int, input().split())) v.sort(reverse = True) print(float(sum(v[0:A]))/A) X, Y = 0, 0 ans = 0 for i in range(N): if (v[i] == v[A-1]): X += 1 if (v[i] == v[A-1]) and (i < A): Y += 1 if (v[0] != v[A-1]): ans = comb(X, Y) else: for i in range(A, B+1): if(i <= X): ans += comb(X, i) print(ans)

from math import factorial def comb(n, k): f = factorial return f(n) / f(k) / f(n-k) N, A, B = list(map(int, input().split())) v = list(map(int, input().split())) v.sort(reverse = True) t = v[A-1] ans = 0 X, Y = v.count(t), v[:A].count(t) if (v[0] != v[A-1]): ans = comb(X, Y) else: for i in range(A, B+1): if(i <= X): ans += comb(X, i) print(float(sum(v[0:A]))/A) print(ans)

from math import factorial def comb(n, k): f = factorial return f(n) / f(k) / f(n - k) N, A, B = list(map(int, input().split())) v = list(map(int, input().split())) v.sort(reverse=True) print(float(sum(v[0:A])) / A) X, Y = 0, 0 ans = 0 for i in range(N): if v[i] == v[A - 1]: X += 1 if (v[i] == v[A - 1]) and (i < A): Y += 1 if v[0] != v[A - 1]: ans = comb(X, Y) else: for i in range(A, B + 1): if i <= X: ans += comb(X, i) print(ans)

from math import factorial def comb(n, k): f = factorial return f(n) / f(k) / f(n - k) N, A, B = list(map(int, input().split())) v = list(map(int, input().split())) v.sort(reverse=True) t = v[A - 1] ans = 0 X, Y = v.count(t), v[:A].count(t) if v[0] != v[A - 1]: ans = comb(X, Y) else: for i in range(A, B + 1): if i <= X: ans += comb(X, i) print(float(sum(v[0:A])) / A) print(ans)

u562935282

p03946

python

s789116982

s469896534

Accepted

Accepted

def main(): from heapq import heappush inf = 1 << 30 N, T = list(map(int, input().split())) *A, = list(map(int, input().split())) h = [inf] ma = -1 cnt = 0 for x in A: d = x - h[0] if ma < d: ma = d cnt = 1 elif ma == d: cnt += 1 heappush(h, x) print(cnt) if __name__ == '__main__': main()

def main(): N, T = list(map(int, input().split())) *A, = list(map(int, input().split())) mi = A[0] d_ma = -1 cnt = 0 for x in A: d = x - mi if d_ma < d: d_ma = d cnt = 1 elif d_ma == d: cnt += 1 if mi > x: mi = x print(cnt) if __name__ == '__main__': main()

def main(): from heapq import heappush inf = 1 << 30 N, T = list(map(int, input().split())) (*A,) = list(map(int, input().split())) h = [inf] ma = -1 cnt = 0 for x in A: d = x - h[0] if ma < d: ma = d cnt = 1 elif ma == d: cnt += 1 heappush(h, x) print(cnt) if __name__ == "__main__": main()

def main(): N, T = list(map(int, input().split())) (*A,) = list(map(int, input().split())) mi = A[0] d_ma = -1 cnt = 0 for x in A: d = x - mi if d_ma < d: d_ma = d cnt = 1 elif d_ma == d: cnt += 1 if mi > x: mi = x print(cnt) if __name__ == "__main__": main()

u654470292

p03379

python

s689015110

s940733261

Accepted

Accepted

import bisect n=int(eval(input())) x=list(map(int,input().split())) y=[] for i in range(n): y.append(x[i]) x.sort() for i in range(n): if bisect.bisect_left(x,y[i])+1 <= len(x)/2: print((x[int(len(x)/2)])) else: print((x[int(len(x)/2)-1]))

import bisect import copy import heapq import math import sys from collections import * from functools import lru_cache from itertools import accumulate, combinations, permutations, product def input(): return sys.stdin.readline()[:-1] def ruiseki(lst): return [0]+list(accumulate(lst)) sys.setrecursionlimit(500000) mod=pow(10,9)+7 al=[chr(ord('a') + i) for i in range(26)] direction=[[1,0],[0,1],[-1,0],[0,-1]] n=int(eval(input())) x=list(map(int,input().split())) tmp=sorted(x) if n%2==0: heikin=(tmp[n//2]+tmp[n//2-1])/2 for i in range(n): if heikin<x[i]: print((tmp[n//2-1])) else: print((tmp[n//2]))

import bisect n = int(eval(input())) x = list(map(int, input().split())) y = [] for i in range(n): y.append(x[i]) x.sort() for i in range(n): if bisect.bisect_left(x, y[i]) + 1 <= len(x) / 2: print((x[int(len(x) / 2)])) else: print((x[int(len(x) / 2) - 1]))

import bisect import copy import heapq import math import sys from collections import * from functools import lru_cache from itertools import accumulate, combinations, permutations, product def input(): return sys.stdin.readline()[:-1] def ruiseki(lst): return [0] + list(accumulate(lst)) sys.setrecursionlimit(500000) mod = pow(10, 9) + 7 al = [chr(ord("a") + i) for i in range(26)] direction = [[1, 0], [0, 1], [-1, 0], [0, -1]] n = int(eval(input())) x = list(map(int, input().split())) tmp = sorted(x) if n % 2 == 0: heikin = (tmp[n // 2] + tmp[n // 2 - 1]) / 2 for i in range(n): if heikin < x[i]: print((tmp[n // 2 - 1])) else: print((tmp[n // 2]))

u816631826

p03160

python

s980593438

s687708164

Accepted

Accepted

n = int(eval(input())) h = [int(x) for x in input().split()] def abs(x): if x >= 0: return x return -x c = [0] c.append(abs(h[1] - h[0])) for k in range(2, n): cnext = min(c[k-2] + abs(h[k]-h[k-2]), c[k-1] + abs(h[k] - h[k-1])) c.append(cnext) print((c[-1]))

n = int(eval(input())) h = input().split() h = [int(i) for i in h] aux = [10000000000 for i in range(n)] aux[0] = 0 aux[1] = abs(h[1] - h[0]) for i in range(2,n): aux[i] = min(aux[i - 2] + abs(h[i] - h[i - 2]), aux[i - 1] + abs(h[i] - h[i - 1])) print((aux[n-1]))

n = int(eval(input())) h = [int(x) for x in input().split()] def abs(x): if x >= 0: return x return -x c = [0] c.append(abs(h[1] - h[0])) for k in range(2, n): cnext = min(c[k - 2] + abs(h[k] - h[k - 2]), c[k - 1] + abs(h[k] - h[k - 1])) c.append(cnext) print((c[-1]))

n = int(eval(input())) h = input().split() h = [int(i) for i in h] aux = [10000000000 for i in range(n)] aux[0] = 0 aux[1] = abs(h[1] - h[0]) for i in range(2, n): aux[i] = min(aux[i - 2] + abs(h[i] - h[i - 2]), aux[i - 1] + abs(h[i] - h[i - 1])) print((aux[n - 1]))

u836737505

p02947

python

s656908970

s489732174

Accepted

Accepted

from collections import Counter n = int(eval(input())) b = [] for i in range(n): a = "".join(sorted(eval(input()))) b.append(a) c = list(Counter(b).values()) ans = 0 for j in c: ans += int((j-1)*j/2) print(ans)

from collections import Counter n = int(eval(input())) s = list(Counter([''.join(sorted(eval(input()))) for _ in range(n)]).values()) print((sum([i*(i-1)//2 for i in s if i != 1])))

from collections import Counter n = int(eval(input())) b = [] for i in range(n): a = "".join(sorted(eval(input()))) b.append(a) c = list(Counter(b).values()) ans = 0 for j in c: ans += int((j - 1) * j / 2) print(ans)

from collections import Counter n = int(eval(input())) s = list(Counter(["".join(sorted(eval(input()))) for _ in range(n)]).values()) print((sum([i * (i - 1) // 2 for i in s if i != 1])))

u876438858

p03290

python

s694321853

s926850692

Accepted

Accepted

import sys import math input = sys.stdin.readline def I(): return int(eval(input())) def MI(): return list(map(int, input().split())) def LI(): return list(MI()) inf = float("inf") def main(): d, g = MI() pc = [LI() for _ in range(d)] ans = inf for bit in range(2 << d): c = 0 score = 0 for i in range(d): if bit & (1 << i): c += pc[i][0] score += pc[i][0] * 100 * (i + 1) + pc[i][1] if score >= g: ans = min(ans, c) else: for i in reversed(list(range(d))): if bit & (1 << i): continue res = math.ceil((g - score) / (100 * (i + 1))) if res < pc[i][0]: ans = min(ans, c + res) break print(ans) if __name__ == "__main__": main()

import sys import math input = sys.stdin.readline def I(): return int(eval(input())) def MI(): return list(map(int, input().split())) def LI(): return list(MI()) inf = float("inf") def main(): d, g = MI() pc = [LI() for _ in range(d)] ans = inf for bit in range(1 << d): c = 0 score = 0 for i in range(d): if bit & (1 << i): c += pc[i][0] score += pc[i][0] * 100 * (i + 1) + pc[i][1] if score >= g: ans = min(ans, c) else: for i in reversed(list(range(d))): if bit & (1 << i): continue res = math.ceil((g - score) / (100 * (i + 1))) if res < pc[i][0]: ans = min(ans, c + res) break print(ans) if __name__ == "__main__": main()

import sys import math input = sys.stdin.readline def I(): return int(eval(input())) def MI(): return list(map(int, input().split())) def LI(): return list(MI()) inf = float("inf") def main(): d, g = MI() pc = [LI() for _ in range(d)] ans = inf for bit in range(2 << d): c = 0 score = 0 for i in range(d): if bit & (1 << i): c += pc[i][0] score += pc[i][0] * 100 * (i + 1) + pc[i][1] if score >= g: ans = min(ans, c) else: for i in reversed(list(range(d))): if bit & (1 << i): continue res = math.ceil((g - score) / (100 * (i + 1))) if res < pc[i][0]: ans = min(ans, c + res) break print(ans) if __name__ == "__main__": main()

import sys import math input = sys.stdin.readline def I(): return int(eval(input())) def MI(): return list(map(int, input().split())) def LI(): return list(MI()) inf = float("inf") def main(): d, g = MI() pc = [LI() for _ in range(d)] ans = inf for bit in range(1 << d): c = 0 score = 0 for i in range(d): if bit & (1 << i): c += pc[i][0] score += pc[i][0] * 100 * (i + 1) + pc[i][1] if score >= g: ans = min(ans, c) else: for i in reversed(list(range(d))): if bit & (1 << i): continue res = math.ceil((g - score) / (100 * (i + 1))) if res < pc[i][0]: ans = min(ans, c + res) break print(ans) if __name__ == "__main__": main()

u116002573

p02773

python

s276290919

s239166557

Accepted

Accepted

def main(): N = int(eval(input())) d = dict() for _ in range(N): s = eval(input()) d[s] = d.get(s, 0) + 1 max_c = 0 for s in d: max_c = max(max_c, d[s]) ans = [] for s in d: if d[s] == max_c: ans.append(s) ans.sort() for s in ans: print(s) if __name__ == '__main__': main()

def main(): N = int(eval(input())) d = dict() cnt = 0 for _ in range(N): s = eval(input()) d[s] = d.get(s, 0) + 1 cnt = max(cnt, d[s]) ans = [] for s in d: if d[s] == cnt: ans.append(s) ans = sorted(ans) for s in ans: print(s) # return " ".join(map(str, sorted(ans))) if __name__ == '__main__': main() # print(main())

def main(): N = int(eval(input())) d = dict() for _ in range(N): s = eval(input()) d[s] = d.get(s, 0) + 1 max_c = 0 for s in d: max_c = max(max_c, d[s]) ans = [] for s in d: if d[s] == max_c: ans.append(s) ans.sort() for s in ans: print(s) if __name__ == "__main__": main()

def main(): N = int(eval(input())) d = dict() cnt = 0 for _ in range(N): s = eval(input()) d[s] = d.get(s, 0) + 1 cnt = max(cnt, d[s]) ans = [] for s in d: if d[s] == cnt: ans.append(s) ans = sorted(ans) for s in ans: print(s) # return " ".join(map(str, sorted(ans))) if __name__ == "__main__": main() # print(main())

u057109575

p02983

python

s308240710

s460574436

Accepted

Accepted

L, R = list(map(int, input().split())) MOD = 2019 ub = max(R % MOD, L % MOD) lb = min(R % MOD, L % MOD) if ub == lb or R // MOD != L // MOD: print((0)) exit() ans = float('inf') for i in range(lb, ub + 1): for j in range(i + 1, ub + 1): ans = min(ans, i * j % MOD) print(ans)

L, R = list(map(int, open(0).read().split())) ans = 2020 m = min(L + 2020, R) + 1 for i in range(L, m): for j in range(i + 1, m): ans = min(ans, i * j % 2019) print(ans)

L, R = list(map(int, input().split())) MOD = 2019 ub = max(R % MOD, L % MOD) lb = min(R % MOD, L % MOD) if ub == lb or R // MOD != L // MOD: print((0)) exit() ans = float("inf") for i in range(lb, ub + 1): for j in range(i + 1, ub + 1): ans = min(ans, i * j % MOD) print(ans)

L, R = list(map(int, open(0).read().split())) ans = 2020 m = min(L + 2020, R) + 1 for i in range(L, m): for j in range(i + 1, m): ans = min(ans, i * j % 2019) print(ans)

u614314290

p03111

python

s121485123

s730261007

Accepted

Accepted

N, A, B, C = list(map(int, input().split())) L = [int(eval(input())) for _ in range(N)] min_cost = 10 ** 18 def func(n, select): global min_cost if n == 0: if len(set(select) - {0}) < 3: return #print(select) cost = 0 a, b, c = 0, 0, 0 for i, t in enumerate(select): if t == 1: if a != 0: cost += 10 a += L[i] if t == 2: if b != 0: cost += 10 b += L[i] if t == 3: if c != 0: cost += 10 c += L[i] cost += abs(A - a) cost += abs(B - b) cost += abs(C - c) min_cost = min(min_cost, cost) return for i in range(4): func(n - 1, select + [i]) func(N, []) print(min_cost)

N, A, B, C = list(map(int, input().split())) L = [int(eval(input())) for _ in range(N)] INF = 10 ** 12 def solve(n, cost, a, b, c): if n == N: if 0 == min(a, b, c): return INF return abs(a - A) + abs(b - B) + abs(c - C) + cost - 30 ret1 = solve(n + 1, cost, a, b, c) ret2 = solve(n + 1, cost + 10, a + L[n], b, c) ret3 = solve(n + 1, cost + 10, a, b + L[n], c) ret4 = solve(n + 1, cost + 10, a, b, c + L[n]) return min(ret1, ret2, ret3, ret4) print((solve(0, 0, 0, 0, 0)))

N, A, B, C = list(map(int, input().split())) L = [int(eval(input())) for _ in range(N)] min_cost = 10**18 def func(n, select): global min_cost if n == 0: if len(set(select) - {0}) < 3: return # print(select) cost = 0 a, b, c = 0, 0, 0 for i, t in enumerate(select): if t == 1: if a != 0: cost += 10 a += L[i] if t == 2: if b != 0: cost += 10 b += L[i] if t == 3: if c != 0: cost += 10 c += L[i] cost += abs(A - a) cost += abs(B - b) cost += abs(C - c) min_cost = min(min_cost, cost) return for i in range(4): func(n - 1, select + [i]) func(N, []) print(min_cost)

N, A, B, C = list(map(int, input().split())) L = [int(eval(input())) for _ in range(N)] INF = 10**12 def solve(n, cost, a, b, c): if n == N: if 0 == min(a, b, c): return INF return abs(a - A) + abs(b - B) + abs(c - C) + cost - 30 ret1 = solve(n + 1, cost, a, b, c) ret2 = solve(n + 1, cost + 10, a + L[n], b, c) ret3 = solve(n + 1, cost + 10, a, b + L[n], c) ret4 = solve(n + 1, cost + 10, a, b, c + L[n]) return min(ret1, ret2, ret3, ret4) print((solve(0, 0, 0, 0, 0)))

u562935282

p02770

python

s328466373

s375223270

Accepted

Accepted

# 解説放送 # tee, isliceをやめた def main(): k, q = list(map(int, input().split())) *d, = list(map(int, input().split())) for _ in range(q): n, x, m = list(map(int, input().split())) *g, = [x % m for x in d] rep, rest = divmod(n - 1, k) last = x + (sum(g) * rep) + sum(g[:rest]) eq = sum(rep + (1 if i < rest else 0) for i, gg in enumerate(g) if gg == 0) ans = (n - 1) - eq - (last // m - x // m) print(ans) if __name__ == '__main__': main()

# 解説放送 def solve(): from itertools import islice, tee k, q = map(int, input().split()) *d, = map(int, input().split()) for g in tee(d, q): n, x, m = map(int, input().split()) g = map(lambda x: x % m, g) g1, g2, g3 = tee(g, 3) rep, rest = divmod(n - 1, k) last = x + (sum(g1) * rep) + sum(islice(g2, 0, rest)) eq = sum(rep + (1 if i < rest else 0) for i, gg in enumerate(g3) if gg == 0) ans = (n - 1) - eq - (last // m - x // m) yield ans def main(): print(*solve(), sep='\n') if __name__ == '__main__': main()

# 解説放送 # tee, isliceをやめた def main(): k, q = list(map(int, input().split())) (*d,) = list(map(int, input().split())) for _ in range(q): n, x, m = list(map(int, input().split())) (*g,) = [x % m for x in d] rep, rest = divmod(n - 1, k) last = x + (sum(g) * rep) + sum(g[:rest]) eq = sum(rep + (1 if i < rest else 0) for i, gg in enumerate(g) if gg == 0) ans = (n - 1) - eq - (last // m - x // m) print(ans) if __name__ == "__main__": main()

# 解説放送 def solve(): from itertools import islice, tee k, q = map(int, input().split()) (*d,) = map(int, input().split()) for g in tee(d, q): n, x, m = map(int, input().split()) g = map(lambda x: x % m, g) g1, g2, g3 = tee(g, 3) rep, rest = divmod(n - 1, k) last = x + (sum(g1) * rep) + sum(islice(g2, 0, rest)) eq = sum(rep + (1 if i < rest else 0) for i, gg in enumerate(g3) if gg == 0) ans = (n - 1) - eq - (last // m - x // m) yield ans def main(): print(*solve(), sep="\n") if __name__ == "__main__": main()

u678167152

p02881

python

s598737004

s210716805

Accepted

Accepted

N = int(eval(input())) i = int(N**0.5) while N%i!=0: i -= 1 print((i+N//i-2))

def solve(): N = int(eval(input())) n = int(N**0.5)+1 for i in range(n,0,-1): if N%i==0: ans = i+N//i-2 break return ans print((solve()))

N = int(eval(input())) i = int(N**0.5) while N % i != 0: i -= 1 print((i + N // i - 2))

def solve(): N = int(eval(input())) n = int(N**0.5) + 1 for i in range(n, 0, -1): if N % i == 0: ans = i + N // i - 2 break return ans print((solve()))

u777283665

p03425

python

s846710982

s920410253

Accepted

Accepted

import itertools n = int(eval(input())) d = {"M": 0, "A": 0, "R": 0, "C": 0, "H": 0} for _ in range(n): s = eval(input()) if s[0] in d: d[s[0]] += 1 l = list(d.keys()) comb = list(itertools.combinations(l, 3)) ans = 0 for i in comb: temp = 1 for j in i: temp *= d[j] ans += temp print(ans)

from itertools import combinations n = int(eval(input())) d = [0] * 5 for _ in range(n): s = eval(input()) if s[0] == "M": d[0] += 1 if s[0] == "A": d[1] += 1 if s[0] == "R": d[2] += 1 if s[0] == "C": d[3] += 1 if s[0] == "H": d[4] += 1 d = [n for n in d if n !=0] comb = combinations(d, 3) ans = 0 for c in comb: ans += c[0]*c[1]*c[2] print(ans)

import itertools n = int(eval(input())) d = {"M": 0, "A": 0, "R": 0, "C": 0, "H": 0} for _ in range(n): s = eval(input()) if s[0] in d: d[s[0]] += 1 l = list(d.keys()) comb = list(itertools.combinations(l, 3)) ans = 0 for i in comb: temp = 1 for j in i: temp *= d[j] ans += temp print(ans)

from itertools import combinations n = int(eval(input())) d = [0] * 5 for _ in range(n): s = eval(input()) if s[0] == "M": d[0] += 1 if s[0] == "A": d[1] += 1 if s[0] == "R": d[2] += 1 if s[0] == "C": d[3] += 1 if s[0] == "H": d[4] += 1 d = [n for n in d if n != 0] comb = combinations(d, 3) ans = 0 for c in comb: ans += c[0] * c[1] * c[2] print(ans)

u132687480

p03161

python

s862881540

s872338255

Accepted

Accepted

N, K = list(map(int, input().split())) *h, = list(map(int, input().split())) dp = [float("inf") for _ in range(N)] dp[0] = 0 for i in range(N - 1): for j in range(1, min(K + 1, N - i)): dp[i + j] = min(dp[i + j], dp[i] + abs(h[i + j] - h[i])) print((dp[N - 1]))

import sys input = sys.stdin.readline def Main(N, K, h): dp =[float('inf')]*N dp[0] = 0 for i in range(N): for j in range(1, min(N-i,K+1)): dp[i+j] = min(dp[i+j], dp[i] + abs(h[i] - h[i+j])) return dp[N-1] def main(): N, K = list(map(int, input().split())) h = list(map(int, input().split())) print((Main(N, K, h))) if __name__ == '__main__': main()

N, K = list(map(int, input().split())) (*h,) = list(map(int, input().split())) dp = [float("inf") for _ in range(N)] dp[0] = 0 for i in range(N - 1): for j in range(1, min(K + 1, N - i)): dp[i + j] = min(dp[i + j], dp[i] + abs(h[i + j] - h[i])) print((dp[N - 1]))

import sys input = sys.stdin.readline def Main(N, K, h): dp = [float("inf")] * N dp[0] = 0 for i in range(N): for j in range(1, min(N - i, K + 1)): dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j])) return dp[N - 1] def main(): N, K = list(map(int, input().split())) h = list(map(int, input().split())) print((Main(N, K, h))) if __name__ == "__main__": main()

u139614630

p03013

python

s376011552

s356393358

Accepted

Accepted

#!/usr/bin/env python3 import sys P_NUM = 1000000007 def solv(n, m, a): comb = [1] * (n+1) for i in a: comb[i] = 0 for i in range(2, n+1): comb[i] *= (comb[i-1] + comb[i-2]) % P_NUM return comb[-1] if __name__ == '__main__': n, m = list(map(int, input().split())) if m: a = list(map(int, sys.stdin)) else: a = [] ans = solv(n, m, a) print(ans)

#!/usr/bin/env python3 import sys P_NUM = 1000000007 def solv(n, m, a): comb_m2 = 1 if 1 in a: comb_m1 = 0 else: comb_m1 = 1 comb = 1 for i in range(2, n+1): if i in a: comb = 0 else: comb = (comb_m1 + comb_m2) % P_NUM comb_m1, comb_m2 = comb, comb_m1 return comb if __name__ == '__main__': n, m = list(map(int, input().split())) if m: a = set(map(int, sys.stdin)) else: a = set() ans = solv(n, m, a) print(ans)

#!/usr/bin/env python3 import sys P_NUM = 1000000007 def solv(n, m, a): comb = [1] * (n + 1) for i in a: comb[i] = 0 for i in range(2, n + 1): comb[i] *= (comb[i - 1] + comb[i - 2]) % P_NUM return comb[-1] if __name__ == "__main__": n, m = list(map(int, input().split())) if m: a = list(map(int, sys.stdin)) else: a = [] ans = solv(n, m, a) print(ans)

#!/usr/bin/env python3 import sys P_NUM = 1000000007 def solv(n, m, a): comb_m2 = 1 if 1 in a: comb_m1 = 0 else: comb_m1 = 1 comb = 1 for i in range(2, n + 1): if i in a: comb = 0 else: comb = (comb_m1 + comb_m2) % P_NUM comb_m1, comb_m2 = comb, comb_m1 return comb if __name__ == "__main__": n, m = list(map(int, input().split())) if m: a = set(map(int, sys.stdin)) else: a = set() ans = solv(n, m, a) print(ans)

u796942881

p03309

python

s092161809

s089685884

Accepted

Accepted

def main(): N, *A = list(map(int, open(0).read().split())) for i in range(N): A[i] -= i + 1 A.sort() b = A[N // 2] print((sum([abs(A[i] - b) for i in range(N)]))) return main()

def main(): N, *A = list(map(int, open(0).read().split())) for i in range(N): A[i] -= i + 1 A.sort() print((sum(A[N // 2 + N % 2:]) - sum(A[:N // 2]))) return main()

def main(): N, *A = list(map(int, open(0).read().split())) for i in range(N): A[i] -= i + 1 A.sort() b = A[N // 2] print((sum([abs(A[i] - b) for i in range(N)]))) return main()

def main(): N, *A = list(map(int, open(0).read().split())) for i in range(N): A[i] -= i + 1 A.sort() print((sum(A[N // 2 + N % 2 :]) - sum(A[: N // 2]))) return main()

u583507988

p03633

python

s145228636

s623174464

Accepted

Accepted

import math from functools import reduce def lcm_base(x, y): return (x*y)//math.gcd(x, y) def lcm(*numbers): return reduce(lcm_base, numbers, 1) def lcm_list(umbers): return reduce(lcm_base, numbers, 1) n = int(eval(input())) t = [] for i in range(n): t_ = int(eval(input())) t.append(t_) print((lcm(*t)))

import math n=int(eval(input())) t=[int(eval(input())) for i in range(n)] res=t[0] for i in range(1,n): res=res*t[i]//math.gcd(res,t[i]) print(res)

import math from functools import reduce def lcm_base(x, y): return (x * y) // math.gcd(x, y) def lcm(*numbers): return reduce(lcm_base, numbers, 1) def lcm_list(umbers): return reduce(lcm_base, numbers, 1) n = int(eval(input())) t = [] for i in range(n): t_ = int(eval(input())) t.append(t_) print((lcm(*t)))

import math n = int(eval(input())) t = [int(eval(input())) for i in range(n)] res = t[0] for i in range(1, n): res = res * t[i] // math.gcd(res, t[i]) print(res)

u790710233

p02892

python

s616250677

s272104853

Accepted

Accepted

from collections import deque import sys input = sys.stdin.readline sys.setrecursionlimit(10**7) n = int(eval(input())) edges = [[]for _ in range(n)] for i in range(n): s = list(map(int, list(input().rstrip()))) for j in range(n): if s[j]: edges[i].append(j) def dfs(v): for v2 in edges[v]: if color[v2] != -1: if color[v] == color[v2]: global is_ok is_ok = 0 continue color[v2] = color[v] ^ 1 dfs(v2) color = [-1]*n color[0] = 0 is_ok = 1 dfs(0) def bfs(init_v): next_v = deque([init_v]) INF = 10**18 dist = [INF]*n dist[init_v] = 0 while next_v: v = next_v.popleft() for v2 in edges[v]: if dist[v2] <= dist[v]+1: continue dist[v2] = dist[v]+1 next_v.append(v2) return dist if is_ok: ans = 0 for i in range(n): dist = bfs(i) x = max(dist) if ans < x: ans = x print((ans+1)) else: print((-1))

from collections import deque import sys input = sys.stdin.readline sys.setrecursionlimit(10**7) n = int(eval(input())) edges = [[]for _ in range(n)] for i in range(n): s = list(map(int, list(input().rstrip()))) for j in range(n): if s[j]: edges[i].append(j) def dfs(v, c=0): color[v] = c for v2 in edges[v]: if color[v2] != -1: if color[v] == color[v2]: global is_ok is_ok = 0 continue dfs(v2, color[v] ^ 1) color = [-1]*n is_ok = 1 dfs(0) def bfs(init_v): next_v = deque([init_v]) INF = 10**18 dist = [INF]*n dist[init_v] = 0 while next_v: v = next_v.popleft() for v2 in edges[v]: if dist[v2] <= dist[v]+1: continue dist[v2] = dist[v]+1 next_v.append(v2) return dist if is_ok: ans = 0 for i in range(n): dist = bfs(i) x = max(dist) if ans < x: ans = x print((ans+1)) else: print((-1))

from collections import deque import sys input = sys.stdin.readline sys.setrecursionlimit(10**7) n = int(eval(input())) edges = [[] for _ in range(n)] for i in range(n): s = list(map(int, list(input().rstrip()))) for j in range(n): if s[j]: edges[i].append(j) def dfs(v): for v2 in edges[v]: if color[v2] != -1: if color[v] == color[v2]: global is_ok is_ok = 0 continue color[v2] = color[v] ^ 1 dfs(v2) color = [-1] * n color[0] = 0 is_ok = 1 dfs(0) def bfs(init_v): next_v = deque([init_v]) INF = 10**18 dist = [INF] * n dist[init_v] = 0 while next_v: v = next_v.popleft() for v2 in edges[v]: if dist[v2] <= dist[v] + 1: continue dist[v2] = dist[v] + 1 next_v.append(v2) return dist if is_ok: ans = 0 for i in range(n): dist = bfs(i) x = max(dist) if ans < x: ans = x print((ans + 1)) else: print((-1))

from collections import deque import sys input = sys.stdin.readline sys.setrecursionlimit(10**7) n = int(eval(input())) edges = [[] for _ in range(n)] for i in range(n): s = list(map(int, list(input().rstrip()))) for j in range(n): if s[j]: edges[i].append(j) def dfs(v, c=0): color[v] = c for v2 in edges[v]: if color[v2] != -1: if color[v] == color[v2]: global is_ok is_ok = 0 continue dfs(v2, color[v] ^ 1) color = [-1] * n is_ok = 1 dfs(0) def bfs(init_v): next_v = deque([init_v]) INF = 10**18 dist = [INF] * n dist[init_v] = 0 while next_v: v = next_v.popleft() for v2 in edges[v]: if dist[v2] <= dist[v] + 1: continue dist[v2] = dist[v] + 1 next_v.append(v2) return dist if is_ok: ans = 0 for i in range(n): dist = bfs(i) x = max(dist) if ans < x: ans = x print((ans + 1)) else: print((-1))

u265506056

p02837

python

s973418436

s960498775

Accepted

Accepted

N=int(eval(input())) g=[[-1]*N for _ in range(N)] ans=0 for i in range(N): A=int(eval(input())) for _ in range(A): x,y=list(map(int,input().split())) g[i][x-1]=y for s in range(2**N): flag=1 for i in range(N): if (s>>i&1): for j in range(N): if g[i][j]!=-1 and (s>>j&1)!=g[i][j]: flag=0 if flag==1: t=0 x=s while x>0: t+=x%2 x//=2 ans=max(ans,t) print(ans)

N=int(eval(input())) g=[[-1]*N for _ in range(N)] ans=0 for i in range(N): A=int(eval(input())) for _ in range(A): x,y=list(map(int,input().split())) g[i][x-1]=y for s in range(2**N): flag=1 for i in range(N): if (s>>i&1): for j in range(N): if g[i][j]!=-1 and (s>>j&1)!=g[i][j]: flag=0 break if flag==0:break if flag==1: t=0 x=s while x>0: t+=x%2 x//=2 ans=max(ans,t) print(ans)

N = int(eval(input())) g = [[-1] * N for _ in range(N)] ans = 0 for i in range(N): A = int(eval(input())) for _ in range(A): x, y = list(map(int, input().split())) g[i][x - 1] = y for s in range(2**N): flag = 1 for i in range(N): if s >> i & 1: for j in range(N): if g[i][j] != -1 and (s >> j & 1) != g[i][j]: flag = 0 if flag == 1: t = 0 x = s while x > 0: t += x % 2 x //= 2 ans = max(ans, t) print(ans)

N = int(eval(input())) g = [[-1] * N for _ in range(N)] ans = 0 for i in range(N): A = int(eval(input())) for _ in range(A): x, y = list(map(int, input().split())) g[i][x - 1] = y for s in range(2**N): flag = 1 for i in range(N): if s >> i & 1: for j in range(N): if g[i][j] != -1 and (s >> j & 1) != g[i][j]: flag = 0 break if flag == 0: break if flag == 1: t = 0 x = s while x > 0: t += x % 2 x //= 2 ans = max(ans, t) print(ans)

u604839890

p02687

python

s579211096

s954451795

Accepted

Accepted

S = eval(input()) print(('ABC' if S == 'ARC' else 'ARC'))

s = eval(input()) print(('ABC' if s == 'ARC' else 'ARC'))

S = eval(input()) print(("ABC" if S == "ARC" else "ARC"))

s = eval(input()) print(("ABC" if s == "ARC" else "ARC"))

u698176039

p02793

python

s811342921

s526307132

Accepted

Accepted

from fractions import gcd MOD = 10**9+7 N = int(eval(input())) A = list(map(int,input().split())) #%% def modinv(x,mod): return pow(x,mod-2,mod) B = [] for a in A: b = modinv(a,MOD) B.append(b) def lcm(a,b): return a//gcd(a,b)*b ans = 0 cur = 1 for a in A: cur = lcm(cur,a) for b in B: ans += cur*b ans %= MOD print(ans)

class PrimeNum: def __init__(self, N): self.N = N [self.is_prime, self.primes, self.min_factor] = self.Eratosthenes(N) def Eratosthenes(self, n): # 素数テーブル is_prime = [True] * (n+1) is_prime[0] = False is_prime[1] = False # nを割り切る最小の素数を記録 min_factor = [0] * (n+1) min_factor[1] = 1 primes = [] for i in range(2,n+1): if not is_prime[i]: continue primes.append(i) min_factor[i] = i for cur in range(i*2, n+1, i): is_prime[cur] = False if min_factor[cur] == 0: min_factor[cur] = i cur += i return [is_prime, primes, min_factor] def PrimeFactorization(self, K): # Kの素因数分解を返す number = [] exponent = [] while K>1: ex = 0 p = self.min_factor[K] while K%p==0: K //= p ex += 1 number.append(p) exponent.append(ex) return [number, exponent] N = int(eval(input())) A = list(map(int,input().split())) MOD = 10**9+7 # 素因数分解の形でLCMを求める Prime = PrimeNum(max(A)) lcm_e = [0]*(max(A)+1) for i in range(N): nums,exs = Prime.PrimeFactorization(A[i]) for n,e in zip(nums,exs): lcm_e[n] = max(lcm_e[n], e) LCM = 1 for i in range(len(lcm_e)): if lcm_e[i] != 0: LCM *= pow(i, lcm_e[i], MOD) LCM %= MOD ans = 0 for a in A: ans += LCM * pow(a, MOD-2, MOD) ans %= MOD print(ans)

from fractions import gcd MOD = 10**9 + 7 N = int(eval(input())) A = list(map(int, input().split())) #%% def modinv(x, mod): return pow(x, mod - 2, mod) B = [] for a in A: b = modinv(a, MOD) B.append(b) def lcm(a, b): return a // gcd(a, b) * b ans = 0 cur = 1 for a in A: cur = lcm(cur, a) for b in B: ans += cur * b ans %= MOD print(ans)

class PrimeNum: def __init__(self, N): self.N = N [self.is_prime, self.primes, self.min_factor] = self.Eratosthenes(N) def Eratosthenes(self, n): # 素数テーブル is_prime = [True] * (n + 1) is_prime[0] = False is_prime[1] = False # nを割り切る最小の素数を記録 min_factor = [0] * (n + 1) min_factor[1] = 1 primes = [] for i in range(2, n + 1): if not is_prime[i]: continue primes.append(i) min_factor[i] = i for cur in range(i * 2, n + 1, i): is_prime[cur] = False if min_factor[cur] == 0: min_factor[cur] = i cur += i return [is_prime, primes, min_factor] def PrimeFactorization(self, K): # Kの素因数分解を返す number = [] exponent = [] while K > 1: ex = 0 p = self.min_factor[K] while K % p == 0: K //= p ex += 1 number.append(p) exponent.append(ex) return [number, exponent] N = int(eval(input())) A = list(map(int, input().split())) MOD = 10**9 + 7 # 素因数分解の形でLCMを求める Prime = PrimeNum(max(A)) lcm_e = [0] * (max(A) + 1) for i in range(N): nums, exs = Prime.PrimeFactorization(A[i]) for n, e in zip(nums, exs): lcm_e[n] = max(lcm_e[n], e) LCM = 1 for i in range(len(lcm_e)): if lcm_e[i] != 0: LCM *= pow(i, lcm_e[i], MOD) LCM %= MOD ans = 0 for a in A: ans += LCM * pow(a, MOD - 2, MOD) ans %= MOD print(ans)

u647999897

p03964

python

s836877926

s404868169

Accepted

Accepted

from math import ceil def solve(): N = int(eval(input())) T = [] A = [] for _ in range(N): t, a = list(map(int,input().split())) T.append(t) A.append(a) now_t = T[0] now_a = A[0] for i in range(1,N): mul = f(now_t,now_a,T[i],A[i]) now_t = T[i] * mul now_a = A[i] * mul print((now_t + now_a)) def f(now_t, now_a, t, a): left = 0 right = 10 ** 18 while right - left > 1: mid = (right + left) // 2 if now_t > t * mid or now_a > a * mid: left = mid else: right = mid return right if __name__ == '__main__': solve()

def solve(): N = int(eval(input())) now_t, now_a = 1,1 for _ in range(N): t, a = list(map(int,input().split())) n = max(-(-now_t//t), -(-now_a//a)) now_t = t * n now_a = a * n print((now_t + now_a)) if __name__ == '__main__': solve()

from math import ceil def solve(): N = int(eval(input())) T = [] A = [] for _ in range(N): t, a = list(map(int, input().split())) T.append(t) A.append(a) now_t = T[0] now_a = A[0] for i in range(1, N): mul = f(now_t, now_a, T[i], A[i]) now_t = T[i] * mul now_a = A[i] * mul print((now_t + now_a)) def f(now_t, now_a, t, a): left = 0 right = 10**18 while right - left > 1: mid = (right + left) // 2 if now_t > t * mid or now_a > a * mid: left = mid else: right = mid return right if __name__ == "__main__": solve()

def solve(): N = int(eval(input())) now_t, now_a = 1, 1 for _ in range(N): t, a = list(map(int, input().split())) n = max(-(-now_t // t), -(-now_a // a)) now_t = t * n now_a = a * n print((now_t + now_a)) if __name__ == "__main__": solve()

u736443076

p02693

python

s050227324

s665277145

Accepted

Accepted

import sys sys.setrecursionlimit(10 ** 7) rl = sys.stdin.readline def solve(): K = int(rl()) A, B = list(map(int,rl().split())) for i in range(A, B + 1): if i % K == 0: print("OK") exit() print("NG") if __name__ == '__main__': solve()

def solve(): K = int(eval(input())) A, B = list(map(int,input().split())) k = B // K if k * K >= A: print("OK") else: print("NG") if __name__ == '__main__': solve()

import sys sys.setrecursionlimit(10**7) rl = sys.stdin.readline def solve(): K = int(rl()) A, B = list(map(int, rl().split())) for i in range(A, B + 1): if i % K == 0: print("OK") exit() print("NG") if __name__ == "__main__": solve()

def solve(): K = int(eval(input())) A, B = list(map(int, input().split())) k = B // K if k * K >= A: print("OK") else: print("NG") if __name__ == "__main__": solve()

u347600233

p02571

python

s270773283

s755002287

Accepted

Accepted

s = eval(input()) t = eval(input()) n = len(s) m = len(t) max_cnt = 0 for i in range(n - m + 1): cnt = 0 u = s[i:i + m] for j in range(m): if t[j] == u[j]: cnt += 1 max_cnt = max(max_cnt, cnt) print((m - max_cnt))

s, t = eval(input()), eval(input()) n, m = len(s), len(t) print((min(sum(t[j] != s[i + j] for j in range(m)) for i in range(n - m + 1))))

s = eval(input()) t = eval(input()) n = len(s) m = len(t) max_cnt = 0 for i in range(n - m + 1): cnt = 0 u = s[i : i + m] for j in range(m): if t[j] == u[j]: cnt += 1 max_cnt = max(max_cnt, cnt) print((m - max_cnt))

s, t = eval(input()), eval(input()) n, m = len(s), len(t) print((min(sum(t[j] != s[i + j] for j in range(m)) for i in range(n - m + 1))))

u604774382

p02408

python

s181818324

s545870261

Accepted

Accepted

import sys n = int( sys.stdin.readline() ) cards = { 'S': [ False ] * 13, 'H': [ False ] * 13, 'C': [ False ] * 13, 'D': [ False ] * 13 } for i in range( n ): pattern, num = sys.stdin.readline().split( " " ) if "S" == pattern: cards[ 'S' ][ int( num )-1 ] = True elif "H" == pattern: cards[ 'H' ][ int( num )-1 ] = True elif "C" == pattern: cards[ 'C' ][ int( num )-1 ] = True elif "D" == pattern: cards[ 'D' ][ int( num )-1 ] = True for pattern in ( 'S', 'H', 'C', 'D' ): for i in range( 13 ): if not cards[ pattern ][ i ]: print(( "{:s} {:d}".format( pattern, i+1 ) ))

import sys n = int( sys.stdin.readline() ) cards = { 'S': [ False ] * 13, 'H': [ False ] * 13, 'C': [ False ] * 13, 'D': [ False ] * 13 } for i in range( n ): pattern, num = sys.stdin.readline().split( " " ) cards[ pattern ][ int( num )-1 ] = True for pattern in ( 'S', 'H', 'C', 'D' ): for i in range( 13 ): if not cards[ pattern ][ i ]: print(( "{:s} {:d}".format( pattern, i+1 ) ))

import sys n = int(sys.stdin.readline()) cards = {"S": [False] * 13, "H": [False] * 13, "C": [False] * 13, "D": [False] * 13} for i in range(n): pattern, num = sys.stdin.readline().split(" ") if "S" == pattern: cards["S"][int(num) - 1] = True elif "H" == pattern: cards["H"][int(num) - 1] = True elif "C" == pattern: cards["C"][int(num) - 1] = True elif "D" == pattern: cards["D"][int(num) - 1] = True for pattern in ("S", "H", "C", "D"): for i in range(13): if not cards[pattern][i]: print(("{:s} {:d}".format(pattern, i + 1)))

import sys n = int(sys.stdin.readline()) cards = {"S": [False] * 13, "H": [False] * 13, "C": [False] * 13, "D": [False] * 13} for i in range(n): pattern, num = sys.stdin.readline().split(" ") cards[pattern][int(num) - 1] = True for pattern in ("S", "H", "C", "D"): for i in range(13): if not cards[pattern][i]: print(("{:s} {:d}".format(pattern, i + 1)))

u844646164

p03487

python

s793211130

s242339911

Accepted

Accepted

from collections import Counter n = int(eval(input())) l = list(map(int, input().split())) c = Counter(l) ans = 0 for k, v in list(c.items()): if k < v: ans += v - k elif k > v: ans += v print(ans)

from collections import Counter N = int(eval(input())) a = list(map(int, input().split())) ca = Counter(a) ans = 0 for k, v in list(ca.items()): if v < k: ans += v elif v > k: ans += v-k print(ans)

from collections import Counter n = int(eval(input())) l = list(map(int, input().split())) c = Counter(l) ans = 0 for k, v in list(c.items()): if k < v: ans += v - k elif k > v: ans += v print(ans)

from collections import Counter N = int(eval(input())) a = list(map(int, input().split())) ca = Counter(a) ans = 0 for k, v in list(ca.items()): if v < k: ans += v elif v > k: ans += v - k print(ans)

u201234972

p02900

python

s169106220

s652244994

Accepted

Accepted

def gcd(a, b): while b != 0: a, b = b, a % b return a def is_prime(n): if n == 1: return False for i in range(2, int(n**(1/2)) + 1): if n%i == 0: return False return True def factors(N): #約数を全て求める。ただし、順不同 from collections import deque ret = 0 middle = int( N**(1/2)) for i in range(1, middle): if N%i == 0: if is_prime(i): ret += 1 if is_prime(N//i): ret += 1 if N%middle == 0: if is_prime(middle): ret += 1 if middle != N//middle: if is_prime(N//middle): ret += 1 return ret def main(): a, b = list(map( int, input().split())) d = gcd(a,b) # print(2, is_prime(2)) if d == 1: print((1)) return if is_prime(d): print((2)) return print((factors(d)+1)) if __name__ == '__main__': main()

def gcd(a, b): while b != 0: a, b = b, a % b return a def factors(N): #約数を全て求める。ただし、順不同 ret = 1 middle = int( N**(1/2)) tmp = N # if tmp%2 == 0: # while tmp%2 == 0: # tmp //= 2 for i in range(2, middle+1): if tmp%i == 0: ret += 1 while tmp%i == 0: tmp //= i if tmp != 1: ret += 1 return ret def main(): a, b = list(map( int, input().split())) d = gcd(a,b) # print(2, is_prime(2)) if d == 1: print((1)) return print((factors(d))) if __name__ == '__main__': main()

def gcd(a, b): while b != 0: a, b = b, a % b return a def is_prime(n): if n == 1: return False for i in range(2, int(n ** (1 / 2)) + 1): if n % i == 0: return False return True def factors(N): # 約数を全て求める。ただし、順不同 from collections import deque ret = 0 middle = int(N ** (1 / 2)) for i in range(1, middle): if N % i == 0: if is_prime(i): ret += 1 if is_prime(N // i): ret += 1 if N % middle == 0: if is_prime(middle): ret += 1 if middle != N // middle: if is_prime(N // middle): ret += 1 return ret def main(): a, b = list(map(int, input().split())) d = gcd(a, b) # print(2, is_prime(2)) if d == 1: print((1)) return if is_prime(d): print((2)) return print((factors(d) + 1)) if __name__ == "__main__": main()

def gcd(a, b): while b != 0: a, b = b, a % b return a def factors(N): # 約数を全て求める。ただし、順不同 ret = 1 middle = int(N ** (1 / 2)) tmp = N # if tmp%2 == 0: # while tmp%2 == 0: # tmp //= 2 for i in range(2, middle + 1): if tmp % i == 0: ret += 1 while tmp % i == 0: tmp //= i if tmp != 1: ret += 1 return ret def main(): a, b = list(map(int, input().split())) d = gcd(a, b) # print(2, is_prime(2)) if d == 1: print((1)) return print((factors(d))) if __name__ == "__main__": main()

u677121387

p02691

python

s880930291

s722967139

Accepted

Accepted

from collections import defaultdict n = int(eval(input())) a = [int(i) for i in input().split()] d = defaultdict(int) for i in range(n): d[i+1+a[i]] += 1 ans = 0 for j in range(n): ans += d[j+1-a[j]] print(ans)

from collections import defaultdict n = int(eval(input())) a = [int(i) for i in input().split()] ans = 0 d = defaultdict(int) for i in range(n): ans += d[i+1-a[i]] d[i+1+a[i]] += 1 print(ans)

from collections import defaultdict n = int(eval(input())) a = [int(i) for i in input().split()] d = defaultdict(int) for i in range(n): d[i + 1 + a[i]] += 1 ans = 0 for j in range(n): ans += d[j + 1 - a[j]] print(ans)

from collections import defaultdict n = int(eval(input())) a = [int(i) for i in input().split()] ans = 0 d = defaultdict(int) for i in range(n): ans += d[i + 1 - a[i]] d[i + 1 + a[i]] += 1 print(ans)

u324197506

p02691

python

s804344221

s500210001

Accepted

Accepted

import sys input = sys.stdin.readline N = int(eval(input())) heights = list(map(int, input().split())) cnt_height_plus_ind = {} cnt_height_minus_ind = {} cnt_ind_minus_height = {} cnt_minus_height_minus_ind = {} for ind in range(N): height = heights[ind] if ind - height not in cnt_ind_minus_height: cnt_ind_minus_height[ind - height] = 0 cnt_ind_minus_height[ind - height] += 1 if ind + height not in cnt_height_plus_ind: cnt_height_plus_ind[ind + height] = 0 cnt_height_plus_ind[ind + height] += 1 if height - ind not in cnt_height_minus_ind: cnt_height_minus_ind[height - ind] = 0 cnt_height_minus_ind[height - ind] += 1 if - ind - height not in cnt_minus_height_minus_ind: cnt_minus_height_minus_ind[-ind-height] = 0 cnt_minus_height_minus_ind[-ind-height] += 1 ans = 0 #for val in cnt_height_minus_ind: # if val in cnt_minus_height_minus_ind: # ans += cnt_height_minus_ind[val] * cnt_minus_height_minus_ind[val] for val in cnt_height_plus_ind: if val in cnt_ind_minus_height: ans += cnt_height_plus_ind[val] * cnt_ind_minus_height[val] print(ans)

N = int(eval(input())) heights = list(map(int, input().split())) cnt_height_plus_ind = {} cnt_ind_minus_height = {} for ind in range(N): height = heights[ind] if ind - height not in cnt_ind_minus_height: cnt_ind_minus_height[ind - height] = 0 cnt_ind_minus_height[ind - height] += 1 if ind + height not in cnt_height_plus_ind: cnt_height_plus_ind[ind + height] = 0 cnt_height_plus_ind[ind + height] += 1 ans = 0 for val in cnt_height_plus_ind: if val in cnt_ind_minus_height: ans += cnt_height_plus_ind[val] * cnt_ind_minus_height[val] print(ans)

import sys input = sys.stdin.readline N = int(eval(input())) heights = list(map(int, input().split())) cnt_height_plus_ind = {} cnt_height_minus_ind = {} cnt_ind_minus_height = {} cnt_minus_height_minus_ind = {} for ind in range(N): height = heights[ind] if ind - height not in cnt_ind_minus_height: cnt_ind_minus_height[ind - height] = 0 cnt_ind_minus_height[ind - height] += 1 if ind + height not in cnt_height_plus_ind: cnt_height_plus_ind[ind + height] = 0 cnt_height_plus_ind[ind + height] += 1 if height - ind not in cnt_height_minus_ind: cnt_height_minus_ind[height - ind] = 0 cnt_height_minus_ind[height - ind] += 1 if -ind - height not in cnt_minus_height_minus_ind: cnt_minus_height_minus_ind[-ind - height] = 0 cnt_minus_height_minus_ind[-ind - height] += 1 ans = 0 # for val in cnt_height_minus_ind: # if val in cnt_minus_height_minus_ind: # ans += cnt_height_minus_ind[val] * cnt_minus_height_minus_ind[val] for val in cnt_height_plus_ind: if val in cnt_ind_minus_height: ans += cnt_height_plus_ind[val] * cnt_ind_minus_height[val] print(ans)

N = int(eval(input())) heights = list(map(int, input().split())) cnt_height_plus_ind = {} cnt_ind_minus_height = {} for ind in range(N): height = heights[ind] if ind - height not in cnt_ind_minus_height: cnt_ind_minus_height[ind - height] = 0 cnt_ind_minus_height[ind - height] += 1 if ind + height not in cnt_height_plus_ind: cnt_height_plus_ind[ind + height] = 0 cnt_height_plus_ind[ind + height] += 1 ans = 0 for val in cnt_height_plus_ind: if val in cnt_ind_minus_height: ans += cnt_height_plus_ind[val] * cnt_ind_minus_height[val] print(ans)

u879226672

p00593

python

s592159297

s666937352

Accepted

Accepted

case = 1 while True: N = int(input()) if N == 0: break mat = [[0 for i in range(N)] for j in range(N)] n = 1 for i in range(N): # upper half for j in range(i,-1,-1): if i%2==0: mat[j][i-j] = n n += 1 elif i%2==1: mat[i-j][j] = n n += 1 for i in range(N,2*N-1): # lower half for j in range(N-1,i-N,-1): if i%2==0: mat[j][i-j] = n n += 1 elif i%2==1: mat[i-j][j] = n n += 1 print('Case %d:'%(case)); case += 1 for s in mat: print(''.join(map(str,[str(st).rjust(3) for st in s])))

# coding: utf-8 # Here your code ! case = 1 while True: N = int(input()) if N == 0: break mat = [[0 for i in range(N)] for j in range(N)] n = 1 for i in range(N): # upper half for j in reversed(range(i+1)): if i%2==0: mat[j][i-j] = n n += 1 elif i%2==1: mat[i-j][j] = n n += 1 for i in range(N,2*N-1): # lower half for j in reversed(range(i-N+1,N)): if i%2==0: mat[j][i-j] = n n += 1 elif i%2==1: mat[i-j][j] = n n += 1 print('Case %d:'%(case)); case += 1 for s in mat: print(''.join(map(str,[str(st).rjust(3) for st in s])))

case = 1 while True: N = int(input()) if N == 0: break mat = [[0 for i in range(N)] for j in range(N)] n = 1 for i in range(N): # upper half for j in range(i, -1, -1): if i % 2 == 0: mat[j][i - j] = n n += 1 elif i % 2 == 1: mat[i - j][j] = n n += 1 for i in range(N, 2 * N - 1): # lower half for j in range(N - 1, i - N, -1): if i % 2 == 0: mat[j][i - j] = n n += 1 elif i % 2 == 1: mat[i - j][j] = n n += 1 print("Case %d:" % (case)) case += 1 for s in mat: print("".join(map(str, [str(st).rjust(3) for st in s])))

# coding: utf-8 # Here your code ! case = 1 while True: N = int(input()) if N == 0: break mat = [[0 for i in range(N)] for j in range(N)] n = 1 for i in range(N): # upper half for j in reversed(range(i + 1)): if i % 2 == 0: mat[j][i - j] = n n += 1 elif i % 2 == 1: mat[i - j][j] = n n += 1 for i in range(N, 2 * N - 1): # lower half for j in reversed(range(i - N + 1, N)): if i % 2 == 0: mat[j][i - j] = n n += 1 elif i % 2 == 1: mat[i - j][j] = n n += 1 print("Case %d:" % (case)) case += 1 for s in mat: print("".join(map(str, [str(st).rjust(3) for st in s])))

u057109575

p03078

python

s385725790

s065985582

Accepted

Accepted

X, Y, Z, K = list(map(int, input().split())) A = list(map(int, input().split())) B = list(map(int, input().split())) C = list(map(int, input().split())) res = [] for a in A: for b in B: res.append(a + b) res.sort(reverse=True) res2 = [] for v in res[:K]: for c in C: res2.append(v + c) res2.sort(reverse=True) for i in range(K): print((res2[i]))

from heapq import heappop, heappush X, Y, Z, K = list(map(int, input().split())) A = list(map(int, input().split())) B = list(map(int, input().split())) C = list(map(int, input().split())) A.sort(reverse=True) B.sort(reverse=True) C.sort(reverse=True) pq = [] heappush(pq, (-A[0] - B[0] - C[0], 0, 0, 0)) appeared = set((0, 0, 0)) for _ in range(K): # Pop maximum value val, i, j, k = heappop(pq) print((-val)) # Add next value if i + 1 < X and (i + 1, j, k) not in appeared: heappush(pq, (-A[i + 1] - B[j] - C[k], i + 1, j, k)) appeared.add((i + 1, j, k)) if j + 1 < Y and (i, j + 1, k) not in appeared: heappush(pq, (-A[i] - B[j + 1] - C[k], i, j + 1, k)) appeared.add((i, j + 1, k)) if k + 1 < Z and (i, j, k + 1) not in appeared: heappush(pq, (-A[i] - B[j] - C[k + 1], i, j, k + 1)) appeared.add((i, j, k + 1))

X, Y, Z, K = list(map(int, input().split())) A = list(map(int, input().split())) B = list(map(int, input().split())) C = list(map(int, input().split())) res = [] for a in A: for b in B: res.append(a + b) res.sort(reverse=True) res2 = [] for v in res[:K]: for c in C: res2.append(v + c) res2.sort(reverse=True) for i in range(K): print((res2[i]))

from heapq import heappop, heappush X, Y, Z, K = list(map(int, input().split())) A = list(map(int, input().split())) B = list(map(int, input().split())) C = list(map(int, input().split())) A.sort(reverse=True) B.sort(reverse=True) C.sort(reverse=True) pq = [] heappush(pq, (-A[0] - B[0] - C[0], 0, 0, 0)) appeared = set((0, 0, 0)) for _ in range(K): # Pop maximum value val, i, j, k = heappop(pq) print((-val)) # Add next value if i + 1 < X and (i + 1, j, k) not in appeared: heappush(pq, (-A[i + 1] - B[j] - C[k], i + 1, j, k)) appeared.add((i + 1, j, k)) if j + 1 < Y and (i, j + 1, k) not in appeared: heappush(pq, (-A[i] - B[j + 1] - C[k], i, j + 1, k)) appeared.add((i, j + 1, k)) if k + 1 < Z and (i, j, k + 1) not in appeared: heappush(pq, (-A[i] - B[j] - C[k + 1], i, j, k + 1)) appeared.add((i, j, k + 1))

u712082626

p03102

python

s696032555

s447582152

Accepted

Accepted

import numpy as np from operator import mul from functools import reduce N, M, C = [int(x) for x in input().split()] B = np.array([int(x) for x in input().split()]) #A = np.array([[0]*M,N]) A = np.empty((N,M)) result = np.array([]) count = 0 for n in range(N): A[n] = [int(m) for m in input().split()] #result = A[n] * B if sum(A[n] * B)+C > 0: count +=1 print(count)

import numpy as np N, M, C = [int(x) for x in input().split()] B = np.array([int(x) for x in input().split()]) A = np.empty((N,M)) count = 0 for n in range(N): A[n] = [int(m) for m in input().split()] count = count + 1 if sum(A[n] * B)+C > 0 else count print(count)

import numpy as np from operator import mul from functools import reduce N, M, C = [int(x) for x in input().split()] B = np.array([int(x) for x in input().split()]) # A = np.array([[0]*M,N]) A = np.empty((N, M)) result = np.array([]) count = 0 for n in range(N): A[n] = [int(m) for m in input().split()] # result = A[n] * B if sum(A[n] * B) + C > 0: count += 1 print(count)

import numpy as np N, M, C = [int(x) for x in input().split()] B = np.array([int(x) for x in input().split()]) A = np.empty((N, M)) count = 0 for n in range(N): A[n] = [int(m) for m in input().split()] count = count + 1 if sum(A[n] * B) + C > 0 else count print(count)

u449108605

p02784

python

s727734296

s233356614

Accepted

Accepted

H,N = list(map(int,input().split())) A = list(map(int, input().split())) sum=0 for Ai in A: sum += Ai if sum >= H: print('Yes') else: print('No')

H,N = list(map(int,input().split())) Ai = list(map(int, input().split())) if sum(Ai) >= H: print('Yes') else: print('No')

H, N = list(map(int, input().split())) A = list(map(int, input().split())) sum = 0 for Ai in A: sum += Ai if sum >= H: print("Yes") else: print("No")

H, N = list(map(int, input().split())) Ai = list(map(int, input().split())) if sum(Ai) >= H: print("Yes") else: print("No")

u644907318

p03017

python

s001923684

s084963952

Accepted

Accepted

N,A,B,C,D = list(map(int,input().split())) S = input().strip() S = "."+S flag=0 if C<B: for i in range(A,C): if S[i:i+2]=="##": flag=1 break for i in range(B,D): if S[i:i+2]=="##": flag=1 break if flag==1: print("No") else: print("Yes") elif B<C<D: for i in range(A,D): if S[i:i+2]=="##": flag=1 break if flag==1: print("No") else: print("Yes") else: for i in range(A,C): if S[i:i+2]=="##": flag = 1 break if flag==1: print("No") else: flag = 1 for i in range(B+1,D): if S[i]=="#":continue if (S[i-1]=="#" and S[i+1]=="#") or (S[i-2:i]=="#." and S[i+1]=="#") or (S[i-1]=="#" and S[i+1:i+3]==".#"):continue else: flag=0 break if flag==1: if S[B+1]=="#" or (S[B-1]=="#" and S[B+1:B+3]==".#"): flag=1 else: flag=0 if flag==1: print("No") else: print("Yes")

N,A,B,C,D = list(map(int,input().split())) S = list(input().strip()) S.insert(0,0) if C<D: flag = 0 for i in range(A+1,C+1): if S[i-1]=="#" and S[i]=="#": flag = 1 break for i in range(B+1,D+1): if S[i-1]=="#" and S[i]=="#": flag = 1 break if flag==0: print("Yes") else: print("No") else: flag = 0 for i in range(A+1,C+1): if S[i]=="#" and S[i-1]=="#": flag = 1 break if flag == 0: flag1 = 1 for i in range(B,D+1): if i+1<=N and S[i-1]=="." and S[i]=="." and S[i+1]==".": flag1 = 0 break if flag1==1: flag = 1 if flag==0: print("Yes") else: print("No")

N, A, B, C, D = list(map(int, input().split())) S = input().strip() S = "." + S flag = 0 if C < B: for i in range(A, C): if S[i : i + 2] == "##": flag = 1 break for i in range(B, D): if S[i : i + 2] == "##": flag = 1 break if flag == 1: print("No") else: print("Yes") elif B < C < D: for i in range(A, D): if S[i : i + 2] == "##": flag = 1 break if flag == 1: print("No") else: print("Yes") else: for i in range(A, C): if S[i : i + 2] == "##": flag = 1 break if flag == 1: print("No") else: flag = 1 for i in range(B + 1, D): if S[i] == "#": continue if ( (S[i - 1] == "#" and S[i + 1] == "#") or (S[i - 2 : i] == "#." and S[i + 1] == "#") or (S[i - 1] == "#" and S[i + 1 : i + 3] == ".#") ): continue else: flag = 0 break if flag == 1: if S[B + 1] == "#" or (S[B - 1] == "#" and S[B + 1 : B + 3] == ".#"): flag = 1 else: flag = 0 if flag == 1: print("No") else: print("Yes")

N, A, B, C, D = list(map(int, input().split())) S = list(input().strip()) S.insert(0, 0) if C < D: flag = 0 for i in range(A + 1, C + 1): if S[i - 1] == "#" and S[i] == "#": flag = 1 break for i in range(B + 1, D + 1): if S[i - 1] == "#" and S[i] == "#": flag = 1 break if flag == 0: print("Yes") else: print("No") else: flag = 0 for i in range(A + 1, C + 1): if S[i] == "#" and S[i - 1] == "#": flag = 1 break if flag == 0: flag1 = 1 for i in range(B, D + 1): if i + 1 <= N and S[i - 1] == "." and S[i] == "." and S[i + 1] == ".": flag1 = 0 break if flag1 == 1: flag = 1 if flag == 0: print("Yes") else: print("No")

u794173881

p03150

python

s525612304

s724834013

Accepted

Accepted

import fnmatch S=[] S.append(eval(input())) if S == fnmatch.filter(S, "*keyence") or S == fnmatch.filter(S, "k*eyence") or S == fnmatch.filter(S, "ke*yence") or S == fnmatch.filter(S, "key*ence") or S == fnmatch.filter(S, "keye*nce") or S == fnmatch.filter(S, "keyen*ce") or S == fnmatch.filter(S, "keyenc*e") or S == fnmatch.filter(S, "keyence*"): print("YES") else: print("NO")

import fnmatch S=[] S.append(eval(input())) if S == fnmatch.filter(S, "k*eyence") or S == fnmatch.filter(S, "ke*yence") or S == fnmatch.filter(S, "key*ence") or S == fnmatch.filter(S, "keye*nce") or S == fnmatch.filter(S, "keyen*ce") or S == fnmatch.filter(S, "keyenc*e") : print("YES") else: print("NO")

import fnmatch S = [] S.append(eval(input())) if ( S == fnmatch.filter(S, "*keyence") or S == fnmatch.filter(S, "k*eyence") or S == fnmatch.filter(S, "ke*yence") or S == fnmatch.filter(S, "key*ence") or S == fnmatch.filter(S, "keye*nce") or S == fnmatch.filter(S, "keyen*ce") or S == fnmatch.filter(S, "keyenc*e") or S == fnmatch.filter(S, "keyence*") ): print("YES") else: print("NO")

import fnmatch S = [] S.append(eval(input())) if ( S == fnmatch.filter(S, "k*eyence") or S == fnmatch.filter(S, "ke*yence") or S == fnmatch.filter(S, "key*ence") or S == fnmatch.filter(S, "keye*nce") or S == fnmatch.filter(S, "keyen*ce") or S == fnmatch.filter(S, "keyenc*e") ): print("YES") else: print("NO")

u210987097

p02658

python

s797134329

s047100955

Accepted

Accepted

n = int(eval(input())) a =list(map(int, input().split())) if 0 in a: print((0)) else : prod = 1 for x in a: prod *= x if prod: if prod > 10**18: print((-1)) break else : print((0)) break else : print(prod)

n = int(eval(input())) a = list(map(int, input().split())) if 0 in a: print((0)) else : prod = 1 for x in a: prod *= x if prod > 10**18: print((-1)) break else : print(prod)

n = int(eval(input())) a = list(map(int, input().split())) if 0 in a: print((0)) else: prod = 1 for x in a: prod *= x if prod: if prod > 10**18: print((-1)) break else: print((0)) break else: print(prod)

n = int(eval(input())) a = list(map(int, input().split())) if 0 in a: print((0)) else: prod = 1 for x in a: prod *= x if prod > 10**18: print((-1)) break else: print(prod)

u780565479

p03280

python

s859175013

s930244334

Accepted

Accepted

A,B=list(map(int,input().split())) print(((A-1) * (B-1)))

print((eval('('+input().replace(' ','-1)*(')+'-1)')))

A, B = list(map(int, input().split())) print(((A - 1) * (B - 1)))

print((eval("(" + input().replace(" ", "-1)*(") + "-1)")))

u766684188

p02897

python

s377569240

s592410146

Accepted

Accepted

n=int(eval(input())) if n%2: print(((n//2+1)/n)) else: print((0.5))

n=int(eval(input())) print((1-n//2/n))

n = int(eval(input())) if n % 2: print(((n // 2 + 1) / n)) else: print((0.5))

n = int(eval(input())) print((1 - n // 2 / n))

u002459665

p04031

python

s236001546

s774343041

Accepted

Accepted

def main(): N = int(eval(input())) A = list(map(int, input().split())) avg = sum(A) // N ans = 10 ** 10 for i in [avg, avg+1]: tmp = 0 for ai in A: x = (i - ai) ** 2 tmp += x ans = min(ans, tmp) print(ans) if __name__ == "__main__": main()

def main(): N = int(eval(input())) A = list(map(int, input().split())) # avg = sum(A) // N avg = sum(A) / N avg = round(avg) # ans = 10 ** 10 # for i in [avg, avg+1]: # tmp = 0 # for ai in A: # x = (i - ai) ** 2 # tmp += x # ans = min(ans, tmp) ans = 0 for ai in A: x = (avg - ai) ** 2 ans += x print(ans) if __name__ == "__main__": main()

def main(): N = int(eval(input())) A = list(map(int, input().split())) avg = sum(A) // N ans = 10**10 for i in [avg, avg + 1]: tmp = 0 for ai in A: x = (i - ai) ** 2 tmp += x ans = min(ans, tmp) print(ans) if __name__ == "__main__": main()

def main(): N = int(eval(input())) A = list(map(int, input().split())) # avg = sum(A) // N avg = sum(A) / N avg = round(avg) # ans = 10 ** 10 # for i in [avg, avg+1]: # tmp = 0 # for ai in A: # x = (i - ai) ** 2 # tmp += x # ans = min(ans, tmp) ans = 0 for ai in A: x = (avg - ai) ** 2 ans += x print(ans) if __name__ == "__main__": main()

u633068244

p00687

python

s235917926

s119226523

Accepted

Accepted

while 1: n,a,b = list(map(int,input().split())) if n == 0: break dp = [0]*(n+1) if a < n+1: dp[a] = 1 if b < n+1: dp[b] = 1 for i in range(n+1): if dp[i]: if i+a < n+1: dp[i+a] = 1 if i+b < n+1: dp[i+b] = 1 print(n - sum(dp))

while 1: n,a,b = list(map(int,input().split())) if n == 0: break dp = [0]*(n+max(a,b)+1) dp[a] = dp[b] = 1 for i in range(n+1): if dp[i]: dp[i+a] = dp[i+b] = 1 print(n - sum(dp[:n+1]))

while 1: n, a, b = list(map(int, input().split())) if n == 0: break dp = [0] * (n + 1) if a < n + 1: dp[a] = 1 if b < n + 1: dp[b] = 1 for i in range(n + 1): if dp[i]: if i + a < n + 1: dp[i + a] = 1 if i + b < n + 1: dp[i + b] = 1 print(n - sum(dp))

while 1: n, a, b = list(map(int, input().split())) if n == 0: break dp = [0] * (n + max(a, b) + 1) dp[a] = dp[b] = 1 for i in range(n + 1): if dp[i]: dp[i + a] = dp[i + b] = 1 print(n - sum(dp[: n + 1]))

u374531474

p03805

python

s893838512

s450576824

Accepted

Accepted

N, M = list(map(int, input().split())) adjacent = [[] for i in range(N)] for i in range(M): a, b = list(map(int, input().split())) a -= 1 b -= 1 adjacent[a].append(b) adjacent[b].append(a) def dfs(visited, v): if visited == (1 << N) - 1: return 1 ans = 0 for u in adjacent[v]: if visited >> u & 1 == 1: continue visited += 1 << u ans += dfs(visited, u) visited -= 1 << u return ans print((dfs(1, 0)))

from collections import defaultdict N, M = list(map(int, input().split())) adjacent = [[] for i in range(N)] for i in range(M): a, b = list(map(int, input().split())) a -= 1 b -= 1 adjacent[a].append(b) adjacent[b].append(a) dp = defaultdict(int) dp[(1, 0)] = 1 for S in range(1 << N): for v in range(N): if S & (1 << v) == 0: continue sub = S ^ (1 << v) for u in adjacent[v]: if sub & (1 << u): dp[(S, v)] += dp[(sub, u)] print((sum(dp[((1 << N) - 1, u)] for u in range(1, N))))

N, M = list(map(int, input().split())) adjacent = [[] for i in range(N)] for i in range(M): a, b = list(map(int, input().split())) a -= 1 b -= 1 adjacent[a].append(b) adjacent[b].append(a) def dfs(visited, v): if visited == (1 << N) - 1: return 1 ans = 0 for u in adjacent[v]: if visited >> u & 1 == 1: continue visited += 1 << u ans += dfs(visited, u) visited -= 1 << u return ans print((dfs(1, 0)))

from collections import defaultdict N, M = list(map(int, input().split())) adjacent = [[] for i in range(N)] for i in range(M): a, b = list(map(int, input().split())) a -= 1 b -= 1 adjacent[a].append(b) adjacent[b].append(a) dp = defaultdict(int) dp[(1, 0)] = 1 for S in range(1 << N): for v in range(N): if S & (1 << v) == 0: continue sub = S ^ (1 << v) for u in adjacent[v]: if sub & (1 << u): dp[(S, v)] += dp[(sub, u)] print((sum(dp[((1 << N) - 1, u)] for u in range(1, N))))

u620480037

p02889

python

s540856984

s332890893

Accepted

Accepted

from scipy.sparse.csgraph import floyd_warshall N,M,L=list(map(int,input().split())) A=[[10**12 for i in range(N+1)]for j in range(N+1)] B=[[10**12 for i in range(N+1)]for j in range(N+1)] for i in range(M): a,b,c=list(map(int,input().split())) if c<=L: A[a][b]=c A[b][a]=c B[a][b]=1 B[b][a]=1 #print(A) A= floyd_warshall(A,directed = False) #print(A) for i in range(N+1): for j in range(N+1): if A[i][j]<=L: B[i][j]=1 """for c in range(1,N+1): for a in range(1,N+1): for b in range(1,N+1): A[a][b]=min(A[a][b],A[a][c]+A[c][b]) if A[a][b]<=L: B[a][b]=1""" #print(B) B= floyd_warshall(B,directed = False) """for c in range(1,N+1): for a in range(1,N+1): for b in range(1,N+1): B[a][b]=min(B[a][b],B[a][c]+B[c][b])""" #print(B) Q=int(eval(input())) for i in range(Q): s,t=list(map(int,input().split())) if B[s][t]==10**12: print((-1)) else: print((int(B[s][t]-1)))

import sys input = sys.stdin.readline N,M,L=list(map(int,input().split())) A=[[10**12 for i in range(N+1)]for j in range(N+1)] B=[[10**12 for i in range(N+1)]for j in range(N+1)] for i in range(M): a,b,c=list(map(int,input().split())) if c<=L: A[a][b]=c A[b][a]=c B[a][b]=1 B[b][a]=1 for i in range(N+1): A[i][i]=0 B[i][i]=0 #print(A) for c in range(1,N+1): for a in range(1,N+1): for b in range(1,N+1): A[a][b]=min(A[a][b],A[a][c]+A[c][b]) if A[a][b]<=L: B[a][b]=1 #print(A) for c in range(1,N+1): for a in range(1,N+1): for b in range(1,N+1): B[a][b]=min(B[a][b],B[a][c]+B[c][b]) #print(B) Q=int(eval(input())) for i in range(Q): s,t=list(map(int,input().split())) if B[s][t]==10**12: print((-1)) else: print((B[s][t]-1))

from scipy.sparse.csgraph import floyd_warshall N, M, L = list(map(int, input().split())) A = [[10**12 for i in range(N + 1)] for j in range(N + 1)] B = [[10**12 for i in range(N + 1)] for j in range(N + 1)] for i in range(M): a, b, c = list(map(int, input().split())) if c <= L: A[a][b] = c A[b][a] = c B[a][b] = 1 B[b][a] = 1 # print(A) A = floyd_warshall(A, directed=False) # print(A) for i in range(N + 1): for j in range(N + 1): if A[i][j] <= L: B[i][j] = 1 """for c in range(1,N+1): for a in range(1,N+1): for b in range(1,N+1): A[a][b]=min(A[a][b],A[a][c]+A[c][b]) if A[a][b]<=L: B[a][b]=1""" # print(B) B = floyd_warshall(B, directed=False) """for c in range(1,N+1): for a in range(1,N+1): for b in range(1,N+1): B[a][b]=min(B[a][b],B[a][c]+B[c][b])""" # print(B) Q = int(eval(input())) for i in range(Q): s, t = list(map(int, input().split())) if B[s][t] == 10**12: print((-1)) else: print((int(B[s][t] - 1)))

import sys input = sys.stdin.readline N, M, L = list(map(int, input().split())) A = [[10**12 for i in range(N + 1)] for j in range(N + 1)] B = [[10**12 for i in range(N + 1)] for j in range(N + 1)] for i in range(M): a, b, c = list(map(int, input().split())) if c <= L: A[a][b] = c A[b][a] = c B[a][b] = 1 B[b][a] = 1 for i in range(N + 1): A[i][i] = 0 B[i][i] = 0 # print(A) for c in range(1, N + 1): for a in range(1, N + 1): for b in range(1, N + 1): A[a][b] = min(A[a][b], A[a][c] + A[c][b]) if A[a][b] <= L: B[a][b] = 1 # print(A) for c in range(1, N + 1): for a in range(1, N + 1): for b in range(1, N + 1): B[a][b] = min(B[a][b], B[a][c] + B[c][b]) # print(B) Q = int(eval(input())) for i in range(Q): s, t = list(map(int, input().split())) if B[s][t] == 10**12: print((-1)) else: print((B[s][t] - 1))

u631277801

p03457

python

s605130879

s103394138

Accepted

Accepted

N = int(input()) TXY = [(0,0,0)] for i in range(N): TXY.append(tuple(map(int, input().split()))) def judge(N:int, TXY:tuple) -> bool: for i in range(N): delta_t = TXY[i+1][0] - TXY[i][0] delta_x = abs(TXY[i+1][1] - TXY[i][1]) delta_y = abs(TXY[i+1][2] - TXY[i][2]) if (delta_t%2 != (delta_x+delta_y)%2)\ or (delta_t < (delta_x+delta_y)): return False return True if judge(N,TXY): print("Yes") else: print("No")

import sys stdin = sys.stdin sys.setrecursionlimit(10**5) def li(): return list(map(int, stdin.readline().split())) def li_(): return [int(x)-1 for x in stdin.readline().split()] def lf(): return list(map(float, stdin.readline().split())) def ls(): return stdin.readline().split() def ns(): return stdin.readline().rstrip() def lc(): return list(ns()) def ni(): return int(stdin.readline()) def nf(): return float(stdin.readline()) n = ni() txy = [(0,0,0)] for _ in range(n): txy.append(tuple(li())) exist = True for i in range(n): tp,xp,yp = txy[i] tn,xn,yn = txy[i+1] dt = tn-tp dx = xn-xp dy = yn-yp if abs(dx) + abs(dy) > dt: exist = False break if (dx+dy)%2 != dt%2: exist = False break if exist: print("Yes") else: print("No")

N = int(input()) TXY = [(0, 0, 0)] for i in range(N): TXY.append(tuple(map(int, input().split()))) def judge(N: int, TXY: tuple) -> bool: for i in range(N): delta_t = TXY[i + 1][0] - TXY[i][0] delta_x = abs(TXY[i + 1][1] - TXY[i][1]) delta_y = abs(TXY[i + 1][2] - TXY[i][2]) if (delta_t % 2 != (delta_x + delta_y) % 2) or (delta_t < (delta_x + delta_y)): return False return True if judge(N, TXY): print("Yes") else: print("No")

import sys stdin = sys.stdin sys.setrecursionlimit(10**5) def li(): return list(map(int, stdin.readline().split())) def li_(): return [int(x) - 1 for x in stdin.readline().split()] def lf(): return list(map(float, stdin.readline().split())) def ls(): return stdin.readline().split() def ns(): return stdin.readline().rstrip() def lc(): return list(ns()) def ni(): return int(stdin.readline()) def nf(): return float(stdin.readline()) n = ni() txy = [(0, 0, 0)] for _ in range(n): txy.append(tuple(li())) exist = True for i in range(n): tp, xp, yp = txy[i] tn, xn, yn = txy[i + 1] dt = tn - tp dx = xn - xp dy = yn - yp if abs(dx) + abs(dy) > dt: exist = False break if (dx + dy) % 2 != dt % 2: exist = False break if exist: print("Yes") else: print("No")

u729939940

p02802

python

s663897120

s823164852

Accepted

Accepted

N, M = list(map(int, input().split())) ac = [False] * N # index means p wa = [0] * N # index means p wa_cnt = 0 for i in range(M): p, s = list(map(str, input().split())) p = int(p) - 1 # index starts from 0 if ac[p] is False and s == "AC": wa_cnt += wa[p] ac[p] = True elif s == "WA": wa[p] += 1 print((ac.count(True), wa_cnt))

from sys import stdin,setrecursionlimit setrecursionlimit(10 ** 6) input = stdin.readline N, M = list(map(int, input().split())) ac = [False] * N # index means p wa = [0] * N # index means p wa_cnt = 0 for i in range(M): p, s = input().split() p = int(p) - 1 # index starts from 0 if ac[p] is False and s == "AC": wa_cnt += wa[p] ac[p] = True elif s == "WA": wa[p] += 1 print((ac.count(True), wa_cnt))

N, M = list(map(int, input().split())) ac = [False] * N # index means p wa = [0] * N # index means p wa_cnt = 0 for i in range(M): p, s = list(map(str, input().split())) p = int(p) - 1 # index starts from 0 if ac[p] is False and s == "AC": wa_cnt += wa[p] ac[p] = True elif s == "WA": wa[p] += 1 print((ac.count(True), wa_cnt))

from sys import stdin, setrecursionlimit setrecursionlimit(10**6) input = stdin.readline N, M = list(map(int, input().split())) ac = [False] * N # index means p wa = [0] * N # index means p wa_cnt = 0 for i in range(M): p, s = input().split() p = int(p) - 1 # index starts from 0 if ac[p] is False and s == "AC": wa_cnt += wa[p] ac[p] = True elif s == "WA": wa[p] += 1 print((ac.count(True), wa_cnt))

u546285759

p00292

python

s417624072

s231772358

Accepted

Accepted

n = int(eval(input())) for _ in range(n): K, P = list(map(int, input().split())) a = K - (K // P) * P print((P * (a == 0) + (a) * (a != 0)))

n = int(eval(input())) for _ in range(n): K, P = list(map(int, input().split())) a = K % P print((P * (a == 0) + (a) * (a != 0)))

n = int(eval(input())) for _ in range(n): K, P = list(map(int, input().split())) a = K - (K // P) * P print((P * (a == 0) + (a) * (a != 0)))

n = int(eval(input())) for _ in range(n): K, P = list(map(int, input().split())) a = K % P print((P * (a == 0) + (a) * (a != 0)))

u117053676

p02390

python

s125645853

s814170833

Accepted

Accepted

in_sec = int(eval(input())) sec = in_sec % 60 min = (in_sec // 60) % 60 hour = (in_sec // 3600 ) print(("{}:{}:{}".format(hour,min,sec)))

time = int(input()) h = int(time/ 3600) m = int((time%3600)/60) s = int((time%3600)%60) print(h,m,s,sep=':')

in_sec = int(eval(input())) sec = in_sec % 60 min = (in_sec // 60) % 60 hour = in_sec // 3600 print(("{}:{}:{}".format(hour, min, sec)))

time = int(input()) h = int(time / 3600) m = int((time % 3600) / 60) s = int((time % 3600) % 60) print(h, m, s, sep=":")

u183422236

p03775

python

s262966266

s958138288

Accepted

Accepted

from math import sqrt n = int(eval(input())) m = int(sqrt(n)) lst = [] for i in range(2, m + 1): if n % i == 0: j = 0 while True: if n % i == 0: n //= i j += 1 else: for k in range(j): lst.append(i) break lst.append(n) ans = float("INF") for i in range(2 ** len(lst)): num1 = 1 num2 = 1 for j in range(len(lst)): if (i >> j) & 1: num1 *= lst[j] else: num2 *= lst[j] ans = min(ans, max(len(str(num1)), len(str(num2)))) print(ans)

n = int(eval(input())) i = 1 ans = n lst = [] while i * i <= n: if n % i == 0: ans = n // i i += 1 print((len(str(ans))))

from math import sqrt n = int(eval(input())) m = int(sqrt(n)) lst = [] for i in range(2, m + 1): if n % i == 0: j = 0 while True: if n % i == 0: n //= i j += 1 else: for k in range(j): lst.append(i) break lst.append(n) ans = float("INF") for i in range(2 ** len(lst)): num1 = 1 num2 = 1 for j in range(len(lst)): if (i >> j) & 1: num1 *= lst[j] else: num2 *= lst[j] ans = min(ans, max(len(str(num1)), len(str(num2)))) print(ans)

n = int(eval(input())) i = 1 ans = n lst = [] while i * i <= n: if n % i == 0: ans = n // i i += 1 print((len(str(ans))))

u562935282

p03254

python

s673000316

s917622184

Accepted

Accepted

N, X = list(map(int, input().split())) a = list(map(int, input().split())) a = sorted(a) ans = 0 ttl = sum(a) if ttl < X: ans = N - 1 elif ttl == X: ans = N else: s = 0 for ax in a: if s + ax <= X: s += ax ans += 1 else: break print(ans)

N, x = list(map(int, input().split())) a = list(map(int, input().split())) a = list(sorted(a)) X = x ans = 0 for i, aa in enumerate(a, 0): if X >= aa: if i == N - 1: if X == aa: ans += 1 else: X -= aa ans += 1 else: break print(ans)

N, X = list(map(int, input().split())) a = list(map(int, input().split())) a = sorted(a) ans = 0 ttl = sum(a) if ttl < X: ans = N - 1 elif ttl == X: ans = N else: s = 0 for ax in a: if s + ax <= X: s += ax ans += 1 else: break print(ans)

N, x = list(map(int, input().split())) a = list(map(int, input().split())) a = list(sorted(a)) X = x ans = 0 for i, aa in enumerate(a, 0): if X >= aa: if i == N - 1: if X == aa: ans += 1 else: X -= aa ans += 1 else: break print(ans)

u337626942

p02597

python

s181531010

s807113898

Accepted

Accepted

n=int(eval(input())) c=eval(input()) r=0 w=0 for i in range(n): if c[i]=="R": r+=1 else: w+=1 umeru=0 for j in range(r): if c[j]=="W": umeru+=1 if r>=umeru: print(umeru) else: print((umeru + (r-umeru)))

n=int(eval(input())) c=eval(input()) r=0 w=0 for i in range(n): if c[i]=="R": r+=1 else: w+=1 delete=0 for j in range(r): if c[j]=="W": delete+=1 if r>=delete: print(delete) else: print((delete + (r-delete)))

n = int(eval(input())) c = eval(input()) r = 0 w = 0 for i in range(n): if c[i] == "R": r += 1 else: w += 1 umeru = 0 for j in range(r): if c[j] == "W": umeru += 1 if r >= umeru: print(umeru) else: print((umeru + (r - umeru)))

n = int(eval(input())) c = eval(input()) r = 0 w = 0 for i in range(n): if c[i] == "R": r += 1 else: w += 1 delete = 0 for j in range(r): if c[j] == "W": delete += 1 if r >= delete: print(delete) else: print((delete + (r - delete)))

u069838609

p03111

python

s917141958

s314462221

Accepted

Accepted

import sys from itertools import combinations fin = sys.stdin.readline N, A, B, C = [int(elem) for elem in fin().split()] l_list = sorted([int(fin()) for _ in range(N)], reverse=True) min_mp = float('inf') for num_conc_A in range(1, N - 1): # mp = 0 rest_indices = set(range(N)) for A_indices in combinations(rest_indices, num_conc_A): mp_A = 10 * (num_conc_A - 1) + abs(sum(l_list[i] for i in A_indices) - A) rest_indices -= set(A_indices) for num_conc_B in range(1, N - num_conc_A): for B_indices in combinations(rest_indices, num_conc_B): mp_B = 10 * (num_conc_B - 1) + abs(sum(l_list[i] for i in B_indices) - B) rest_indices -= set(B_indices) for num_conc_C in range(1, N - num_conc_A - num_conc_B + 1): for C_indices in combinations(rest_indices, num_conc_C): mp_C = 10 * (num_conc_C - 1) + abs(sum(l_list[i] for i in C_indices) - C) min_mp = min(min_mp, mp_A + mp_B + mp_C) rest_indices.update(set(B_indices)) rest_indices.update(set(A_indices)) print(min_mp)

import sys from itertools import combinations, product fin = sys.stdin.readline N, A, B, C = [int(elem) for elem in fin().split()] l_list = [int(fin()) for _ in range(N)] min_mp = float('inf') for flags in product(list(range(4)), repeat=N): powers = [0] * 3 num_items = [0] * 3 for l, flag in zip(l_list, flags): if flag == 3: continue powers[flag] += l num_items[flag] += 1 if not all(powers): continue mp = sum( abs(power - necessary_power) for power, necessary_power in zip(powers, (A, B, C)) ) + 10 * (sum(num_items) - 3) min_mp = min(mp, min_mp) print(min_mp)

import sys from itertools import combinations fin = sys.stdin.readline N, A, B, C = [int(elem) for elem in fin().split()] l_list = sorted([int(fin()) for _ in range(N)], reverse=True) min_mp = float("inf") for num_conc_A in range(1, N - 1): # mp = 0 rest_indices = set(range(N)) for A_indices in combinations(rest_indices, num_conc_A): mp_A = 10 * (num_conc_A - 1) + abs(sum(l_list[i] for i in A_indices) - A) rest_indices -= set(A_indices) for num_conc_B in range(1, N - num_conc_A): for B_indices in combinations(rest_indices, num_conc_B): mp_B = 10 * (num_conc_B - 1) + abs( sum(l_list[i] for i in B_indices) - B ) rest_indices -= set(B_indices) for num_conc_C in range(1, N - num_conc_A - num_conc_B + 1): for C_indices in combinations(rest_indices, num_conc_C): mp_C = 10 * (num_conc_C - 1) + abs( sum(l_list[i] for i in C_indices) - C ) min_mp = min(min_mp, mp_A + mp_B + mp_C) rest_indices.update(set(B_indices)) rest_indices.update(set(A_indices)) print(min_mp)

import sys from itertools import combinations, product fin = sys.stdin.readline N, A, B, C = [int(elem) for elem in fin().split()] l_list = [int(fin()) for _ in range(N)] min_mp = float("inf") for flags in product(list(range(4)), repeat=N): powers = [0] * 3 num_items = [0] * 3 for l, flag in zip(l_list, flags): if flag == 3: continue powers[flag] += l num_items[flag] += 1 if not all(powers): continue mp = sum( abs(power - necessary_power) for power, necessary_power in zip(powers, (A, B, C)) ) + 10 * (sum(num_items) - 3) min_mp = min(mp, min_mp) print(min_mp)

u314050667

p02861

python

s661871171

s250447570

Accepted

Accepted

N = int(eval(input())) x,y = [],[] for _ in range(N): xt, yt = list(map(int, input().split())) x.append(xt) y.append(yt) def solve(ite): a = 0 for i in range(len(ite)-1): a += ((x[ite[i]] - x[ite[i+1]])**2 + (y[ite[i]] - y[ite[i+1]])**2) ** (1/2) return a def next_permutation(n, flg, perm): S = [] if flg.count(0) == 0: return solve(perm) a = 0 for i in range(n): if flg[i] != 0: continue flg[i] = 1 perm.append(i) a += next_permutation(n, flg, perm) flg[i] = 0 perm.pop() return a flg = [0] * N perm = [] A = next_permutation(N,flg,perm) for i in range(1,N+1): A /= i print(A)

import itertools N = int(eval(input())) XY = [list(map(int, input().split())) for _ in range(N)] ans = 0 for trans in itertools.permutations(list(range(N))): distance = 0 for i in range(1,N): ind_2, ind_1 = trans[i], trans[i-1] x2,y2 = XY[ind_2] x1,y1 = XY[ind_1] distance += ((x2-x1)**2 + (y2-y1)**2)**(1/2) ans += distance for i in range(1,N+1): ans /= i print(ans)

N = int(eval(input())) x, y = [], [] for _ in range(N): xt, yt = list(map(int, input().split())) x.append(xt) y.append(yt) def solve(ite): a = 0 for i in range(len(ite) - 1): a += ((x[ite[i]] - x[ite[i + 1]]) ** 2 + (y[ite[i]] - y[ite[i + 1]]) ** 2) ** ( 1 / 2 ) return a def next_permutation(n, flg, perm): S = [] if flg.count(0) == 0: return solve(perm) a = 0 for i in range(n): if flg[i] != 0: continue flg[i] = 1 perm.append(i) a += next_permutation(n, flg, perm) flg[i] = 0 perm.pop() return a flg = [0] * N perm = [] A = next_permutation(N, flg, perm) for i in range(1, N + 1): A /= i print(A)

import itertools N = int(eval(input())) XY = [list(map(int, input().split())) for _ in range(N)] ans = 0 for trans in itertools.permutations(list(range(N))): distance = 0 for i in range(1, N): ind_2, ind_1 = trans[i], trans[i - 1] x2, y2 = XY[ind_2] x1, y1 = XY[ind_1] distance += ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** (1 / 2) ans += distance for i in range(1, N + 1): ans /= i print(ans)

u984276646

p03044

python

s083822168

s313205457

Accepted

Accepted

import sys sys.setrecursionlimit(10**7) N = int(eval(input())) L = [-1 for i in range(N)] flg = [0 for i in range(N)] M = [[] for i in range(N)] for i in range(N-1): u, v, w = list(map(int, input().split())) M[u-1].append([v-1, w%2]) M[v-1].append([u-1, w%2]) L[0] = 0 def dist(m, d): L[m] = d % 2 for i in M[m]: if L[i[0]] == -1: dist(i[0], i[1] + d) dist(0, 0) for i in range(N): print((L[i]))

N = int(eval(input())) D = {i: [] for i in range(N)} distD = {} for i in range(N-1): u, v, w = list(map(int, input().split())) u -= 1 v -= 1 D[u].append(v) D[v].append(u) distD[u*N+v], distD[v*N+u] = w, w clr = [-1 for _ in range(N)] clr[0] = 0 s = [0] pnt = 0 cnt = 1 while pnt < cnt: n = cnt for i in range(pnt, cnt): L = D[s[i]] for j in L: if clr[j] == -1: clr[j] = (clr[s[i]] + distD[s[i]*N+j]) % 2 s.append(j) cnt += 1 pnt = n for i in range(N): print((clr[i]))

import sys sys.setrecursionlimit(10**7) N = int(eval(input())) L = [-1 for i in range(N)] flg = [0 for i in range(N)] M = [[] for i in range(N)] for i in range(N - 1): u, v, w = list(map(int, input().split())) M[u - 1].append([v - 1, w % 2]) M[v - 1].append([u - 1, w % 2]) L[0] = 0 def dist(m, d): L[m] = d % 2 for i in M[m]: if L[i[0]] == -1: dist(i[0], i[1] + d) dist(0, 0) for i in range(N): print((L[i]))

N = int(eval(input())) D = {i: [] for i in range(N)} distD = {} for i in range(N - 1): u, v, w = list(map(int, input().split())) u -= 1 v -= 1 D[u].append(v) D[v].append(u) distD[u * N + v], distD[v * N + u] = w, w clr = [-1 for _ in range(N)] clr[0] = 0 s = [0] pnt = 0 cnt = 1 while pnt < cnt: n = cnt for i in range(pnt, cnt): L = D[s[i]] for j in L: if clr[j] == -1: clr[j] = (clr[s[i]] + distD[s[i] * N + j]) % 2 s.append(j) cnt += 1 pnt = n for i in range(N): print((clr[i]))

u408325839

p03045

python

s005158374

s111450410

Accepted

Accepted

import sys sys.setrecursionlimit(10**9) N, M = list(map(int, input().split())) paths = [[] for _ in range(N)] for _ in range(M): a, b, z = list(map(int, input().split())) paths[a-1].append(b-1) paths[b-1].append(a-1) visited = [False] * N def dfs(node, prev): if visited[node]: return visited[node] = True for n in paths[node]: if n != prev: dfs(n, node) count = 0 for i in range(N): if visited[i] == False: count += 1 dfs(i,-1) print(count)

import sys sys.setrecursionlimit(10**9) N, M = list(map(int, input().split())) class Union_Find: def __init__(self,n): self.parent = [i for i in range(n)] self.rank = [1 for i in range(n)] def find(self,x): if self.parent[x] == x: return x else: return self.find(self.parent[x]) def unite(self, x, y): px = self.find(x) py = self.find(y) if px == py: return else: if self.rank[px] == self.rank[py]: self.parent[py] = px self.rank[px] += 1 elif self.rank[px] > self.rank[py]: self.parent[py] = px else: self.parent[px] = py uftree = Union_Find(N+1) for i in range(M): x, y, _ = list(map(int, input().split())) uftree.unite(x, y) result = 0 for i in range(1, N+1): if uftree.find(i) == i: result += 1 print(result)

import sys sys.setrecursionlimit(10**9) N, M = list(map(int, input().split())) paths = [[] for _ in range(N)] for _ in range(M): a, b, z = list(map(int, input().split())) paths[a - 1].append(b - 1) paths[b - 1].append(a - 1) visited = [False] * N def dfs(node, prev): if visited[node]: return visited[node] = True for n in paths[node]: if n != prev: dfs(n, node) count = 0 for i in range(N): if visited[i] == False: count += 1 dfs(i, -1) print(count)

import sys sys.setrecursionlimit(10**9) N, M = list(map(int, input().split())) class Union_Find: def __init__(self, n): self.parent = [i for i in range(n)] self.rank = [1 for i in range(n)] def find(self, x): if self.parent[x] == x: return x else: return self.find(self.parent[x]) def unite(self, x, y): px = self.find(x) py = self.find(y) if px == py: return else: if self.rank[px] == self.rank[py]: self.parent[py] = px self.rank[px] += 1 elif self.rank[px] > self.rank[py]: self.parent[py] = px else: self.parent[px] = py uftree = Union_Find(N + 1) for i in range(M): x, y, _ = list(map(int, input().split())) uftree.unite(x, y) result = 0 for i in range(1, N + 1): if uftree.find(i) == i: result += 1 print(result)

u102461423

p04006

python

s130134121

s617792596

Accepted

Accepted

import sys read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline readlines = sys.stdin.buffer.readlines """ ・変色の回数を決め打つ ・どの色として捕獲しておくべきだったかが決まる ・左とのminをとることで遷移 """ import numpy as np N,X = list(map(int,readline().split())) A = np.array(read().split(),np.int64) INF = 10 ** 18 answer = INF for change in range(N+100): x = A.sum() + change * X if answer > x: answer = x x = min(A[0],A[-1]) A[1:] = np.minimum(A[:-1],A[1:]) A[0] = x print(answer)

import sys import numpy as np read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline readlines = sys.stdin.buffer.readlines N, X = list(map(int, readline().split())) A = np.array(read().split(), np.int64) INF = 10**18 dp = np.full((N, N + N), INF, np.int64) dp[0] = np.concatenate((A, A)) for n in range(1, N): dp[n, 1:] = np.minimum(dp[n - 1, 1:], dp[n - 1, :-1]) dp = dp[:, N:] x = dp.sum(axis=1) + X * np.arange(N) print((x.min()))

import sys read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline readlines = sys.stdin.buffer.readlines """ ・変色の回数を決め打つ ・どの色として捕獲しておくべきだったかが決まる ・左とのminをとることで遷移 """ import numpy as np N, X = list(map(int, readline().split())) A = np.array(read().split(), np.int64) INF = 10**18 answer = INF for change in range(N + 100): x = A.sum() + change * X if answer > x: answer = x x = min(A[0], A[-1]) A[1:] = np.minimum(A[:-1], A[1:]) A[0] = x print(answer)

import sys import numpy as np read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline readlines = sys.stdin.buffer.readlines N, X = list(map(int, readline().split())) A = np.array(read().split(), np.int64) INF = 10**18 dp = np.full((N, N + N), INF, np.int64) dp[0] = np.concatenate((A, A)) for n in range(1, N): dp[n, 1:] = np.minimum(dp[n - 1, 1:], dp[n - 1, :-1]) dp = dp[:, N:] x = dp.sum(axis=1) + X * np.arange(N) print((x.min()))

u948911484

p03557

python

s803333964

s835220475

Accepted

Accepted

import bisect n = int(eval(input())) a = list(map(int,input().split())) b = list(map(int,input().split())) c = list(map(int,input().split())) a.sort() b.sort() c.sort() memo = [0]*(n+1) for i in range(n): memo[bisect.bisect_left(b,c[i])] += 1 for i in range(n-1,-1,-1): memo[i] += memo[i+1] for i in range(n-1,-1,-1): memo[i] += memo[i+1] memo = memo[1:]+[0] ans = 0 for i in range(n): ans += memo[bisect.bisect_right(b,a[i])] print(ans)

import bisect n = int(eval(input())) a = list(map(int,input().split())) b = list(map(int,input().split())) c = list(map(int,input().split())) a.sort() b.sort() c.sort() ans = 0 for i in range(n): t = b[i] ci = bisect.bisect_right(c,t) ai = bisect.bisect_left(a,t) ans += ai*(n-ci) print(ans)

import bisect n = int(eval(input())) a = list(map(int, input().split())) b = list(map(int, input().split())) c = list(map(int, input().split())) a.sort() b.sort() c.sort() memo = [0] * (n + 1) for i in range(n): memo[bisect.bisect_left(b, c[i])] += 1 for i in range(n - 1, -1, -1): memo[i] += memo[i + 1] for i in range(n - 1, -1, -1): memo[i] += memo[i + 1] memo = memo[1:] + [0] ans = 0 for i in range(n): ans += memo[bisect.bisect_right(b, a[i])] print(ans)

import bisect n = int(eval(input())) a = list(map(int, input().split())) b = list(map(int, input().split())) c = list(map(int, input().split())) a.sort() b.sort() c.sort() ans = 0 for i in range(n): t = b[i] ci = bisect.bisect_right(c, t) ai = bisect.bisect_left(a, t) ans += ai * (n - ci) print(ans)

u592547545

p02850

python

s961163185

s609850139

Accepted

Accepted

from collections import deque def readinput(): n=int(eval(input())) nList=[] for _ in range(n+1): nList.append([]) edges=[] for _ in range(n-1): a,b=list(map(int,input().split())) edges.append((a,b)) nList[a].append(b) nList[b].append(a) return n,nList,edges def bfs(s,nList): #print(nList) WHITE=0 GRAY=1 BLACK=2 status=[WHITE]*(n+1) parent=[0]*(n+1) color=[0]*(n+1) maxcolor=0 Q=deque([]) Q.append(s) while(len(Q)>0): u=Q.popleft() usedcolor=color[u] col=1 for t in nList[u]: if status[t]==WHITE: status[t]=GRAY parent[t]=u if col==usedcolor: col+=1 color[t]=col Q.append(t) col+=1 maxcolor=max(maxcolor,col-1) status[u]=BLACK #print(u,usedcolor) return color, maxcolor def main(n,nList,edges): color, maxcolor=bfs(1,nList) print(maxcolor) for a,b in edges: print((color[b])) if __name__=='__main__': n,nList,edges=readinput() main(n,nList,edges)

from collections import deque def readinput(): n=int(eval(input())) nList=[] for _ in range(n+1): nList.append([]) edges=[] for _ in range(n-1): a,b=list(map(int,input().split())) edges.append((a,b)) nList[a].append(b) nList[b].append(a) return n,nList,edges def bfs(s,nList): #print(nList) WHITE=0 GRAY=1 BLACK=2 status=[WHITE]*(n+1) parent=[0]*(n+1) color=[0]*(n+1) maxcolor=0 Q=deque([]) Q.append(s) while(len(Q)>0): u=Q.popleft() usedcolor=color[u] col=1 for t in nList[u]: if status[t]==WHITE: status[t]=GRAY parent[t]=u if col==usedcolor: col+=1 color[t]=col Q.append(t) col+=1 maxcolor=max(maxcolor,col-1) status[u]=BLACK #print(u,usedcolor) return color, maxcolor def main(n,nList,edges): color, maxcolor=bfs(1,nList) print(maxcolor) for a,b in edges: print((color[b])) if __name__=='__main__': n,nList,edges=readinput() main(n,nList,edges)

from collections import deque def readinput(): n = int(eval(input())) nList = [] for _ in range(n + 1): nList.append([]) edges = [] for _ in range(n - 1): a, b = list(map(int, input().split())) edges.append((a, b)) nList[a].append(b) nList[b].append(a) return n, nList, edges def bfs(s, nList): # print(nList) WHITE = 0 GRAY = 1 BLACK = 2 status = [WHITE] * (n + 1) parent = [0] * (n + 1) color = [0] * (n + 1) maxcolor = 0 Q = deque([]) Q.append(s) while len(Q) > 0: u = Q.popleft() usedcolor = color[u] col = 1 for t in nList[u]: if status[t] == WHITE: status[t] = GRAY parent[t] = u if col == usedcolor: col += 1 color[t] = col Q.append(t) col += 1 maxcolor = max(maxcolor, col - 1) status[u] = BLACK # print(u,usedcolor) return color, maxcolor def main(n, nList, edges): color, maxcolor = bfs(1, nList) print(maxcolor) for a, b in edges: print((color[b])) if __name__ == "__main__": n, nList, edges = readinput() main(n, nList, edges)

from collections import deque def readinput(): n = int(eval(input())) nList = [] for _ in range(n + 1): nList.append([]) edges = [] for _ in range(n - 1): a, b = list(map(int, input().split())) edges.append((a, b)) nList[a].append(b) nList[b].append(a) return n, nList, edges def bfs(s, nList): # print(nList) WHITE = 0 GRAY = 1 BLACK = 2 status = [WHITE] * (n + 1) parent = [0] * (n + 1) color = [0] * (n + 1) maxcolor = 0 Q = deque([]) Q.append(s) while len(Q) > 0: u = Q.popleft() usedcolor = color[u] col = 1 for t in nList[u]: if status[t] == WHITE: status[t] = GRAY parent[t] = u if col == usedcolor: col += 1 color[t] = col Q.append(t) col += 1 maxcolor = max(maxcolor, col - 1) status[u] = BLACK # print(u,usedcolor) return color, maxcolor def main(n, nList, edges): color, maxcolor = bfs(1, nList) print(maxcolor) for a, b in edges: print((color[b])) if __name__ == "__main__": n, nList, edges = readinput() main(n, nList, edges)

u194225526

p02730

python

s305675928

s716816566

Accepted

Accepted

# 入力 s = eval(input()) # 処理 leftLen = len(s) // 2 # 文字列の長さの半分 left = s[:leftLen] # sの左半分 # leftの回文チェック leftLenHalf = leftLen // 2 isPalindromeLeft = True for i in range(0, leftLenHalf): if left[i] != left[leftLen - i - 1]: isPalindromeLeft = False # 全体の回文チェック right = s[leftLen * -1:] # sの右半分 isPalindrome = isPalindromeLeft and left == right # 結果 result = "Yes" if isPalindrome else "No" # 出力 print(result)

# 入力 s = eval(input()) # 処理 leftLen = len(s) // 2 # 文字列の長さの半分 left = s[:leftLen] # sの左半分 # leftの回文チェック leftReverse = left[::-1] isPalindromeLeft = left == leftReverse; # 全体の回文チェック right = s[leftLen * -1:] # sの右半分 isPalindrome = isPalindromeLeft and (left == right) # 結果 result = "Yes" if isPalindrome else "No" # 出力 print(result)

# 入力 s = eval(input()) # 処理 leftLen = len(s) // 2 # 文字列の長さの半分 left = s[:leftLen] # sの左半分 # leftの回文チェック leftLenHalf = leftLen // 2 isPalindromeLeft = True for i in range(0, leftLenHalf): if left[i] != left[leftLen - i - 1]: isPalindromeLeft = False # 全体の回文チェック right = s[leftLen * -1 :] # sの右半分 isPalindrome = isPalindromeLeft and left == right # 結果 result = "Yes" if isPalindrome else "No" # 出力 print(result)

# 入力 s = eval(input()) # 処理 leftLen = len(s) // 2 # 文字列の長さの半分 left = s[:leftLen] # sの左半分 # leftの回文チェック leftReverse = left[::-1] isPalindromeLeft = left == leftReverse # 全体の回文チェック right = s[leftLen * -1 :] # sの右半分 isPalindrome = isPalindromeLeft and (left == right) # 結果 result = "Yes" if isPalindrome else "No" # 出力 print(result)

u983918956

p03043

python

s293496798

s965364035

Accepted

Accepted

from math import log2, ceil N,K = list(map(int,input().split())) ans = 0 def cal(n): l = ceil(log2(K/n)) if n >= K: return 1/N return pow(2,-l)/N for i in range(1,N+1): ans += cal(i) print(ans)

N,K = list(map(int,input().split())) ans = 0 for i in range(1,N+1): l = 0 while i < K: i *= 2 l += 1 ans += (1/N)*pow(2,-l) print(ans)

from math import log2, ceil N, K = list(map(int, input().split())) ans = 0 def cal(n): l = ceil(log2(K / n)) if n >= K: return 1 / N return pow(2, -l) / N for i in range(1, N + 1): ans += cal(i) print(ans)

N, K = list(map(int, input().split())) ans = 0 for i in range(1, N + 1): l = 0 while i < K: i *= 2 l += 1 ans += (1 / N) * pow(2, -l) print(ans)

u588341295

p03805

python

s826589840

s256336548

Accepted

Accepted

# -*- coding: utf-8 -*- import sys from itertools import permutations def input(): return sys.stdin.readline().strip() def list2d(a, b, c): return [[c] * b for i in range(a)] def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)] def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)] def ceil(x, y=1): return int(-(-x // y)) def INT(): return int(eval(input())) def MAP(): return list(map(int, input().split())) def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)] def Yes(): print('Yes') def No(): print('No') def YES(): print('YES') def NO(): print('NO') sys.setrecursionlimit(10 ** 9) INF = 10 ** 18 MOD = 10 ** 9 + 7 N, M = MAP() edges = set() for i in range(M): a, b = MAP() a -= 1; b -= 1 edges.add((a, b)) edges.add((b, a)) cnt = 0 for perm in permutations(list(range(N))): if perm[0] != 0: continue for i in range(N-1): a = perm[i] b = perm[i+1] if (a, b) not in edges: break else: cnt += 1 print(cnt)

# -*- coding: utf-8 -*- import sys def input(): return sys.stdin.readline().strip() def list2d(a, b, c): return [[c] * b for i in range(a)] def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)] def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)] def ceil(x, y=1): return int(-(-x // y)) def INT(): return int(eval(input())) def MAP(): return list(map(int, input().split())) def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)] def Yes(): print('Yes') def No(): print('No') def YES(): print('YES') def NO(): print('NO') sys.setrecursionlimit(10 ** 9) INF = 10 ** 18 MOD = 10 ** 9 + 7 N, M = MAP() G = list2d(N, N, 0) for i in range(M): a, b = MAP() a -= 1; b -= 1 G[a][b] = G[b][a] = 1 # dp[S][i] := 訪問済の頂点集合をSとして、最後に頂点iにいる場合の通り数 dp = list2d(1<<N, N, 0) # 最初は頂点1にいる状態から dp[1][0] = 1 for S in range(1, 1<<N): for i in range(N): # iが遷移元に含まれていない if not S & 1<<i: continue for j in range(N): # jが遷移元に含まれている(ので遷移先にはできない) if S & 1<<j: continue # 辺の張られた頂点間であれば遷移させる if G[i][j]: dp[S|1<<j][j] += dp[S][i] # 全頂点訪問できた通り数を合計する ans = sum(dp[(1<<N)-1]) print(ans)

# -*- coding: utf-8 -*- import sys from itertools import permutations def input(): return sys.stdin.readline().strip() def list2d(a, b, c): return [[c] * b for i in range(a)] def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)] def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)] def ceil(x, y=1): return int(-(-x // y)) def INT(): return int(eval(input())) def MAP(): return list(map(int, input().split())) def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)] def Yes(): print("Yes") def No(): print("No") def YES(): print("YES") def NO(): print("NO") sys.setrecursionlimit(10**9) INF = 10**18 MOD = 10**9 + 7 N, M = MAP() edges = set() for i in range(M): a, b = MAP() a -= 1 b -= 1 edges.add((a, b)) edges.add((b, a)) cnt = 0 for perm in permutations(list(range(N))): if perm[0] != 0: continue for i in range(N - 1): a = perm[i] b = perm[i + 1] if (a, b) not in edges: break else: cnt += 1 print(cnt)

# -*- coding: utf-8 -*- import sys def input(): return sys.stdin.readline().strip() def list2d(a, b, c): return [[c] * b for i in range(a)] def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)] def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)] def ceil(x, y=1): return int(-(-x // y)) def INT(): return int(eval(input())) def MAP(): return list(map(int, input().split())) def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)] def Yes(): print("Yes") def No(): print("No") def YES(): print("YES") def NO(): print("NO") sys.setrecursionlimit(10**9) INF = 10**18 MOD = 10**9 + 7 N, M = MAP() G = list2d(N, N, 0) for i in range(M): a, b = MAP() a -= 1 b -= 1 G[a][b] = G[b][a] = 1 # dp[S][i] := 訪問済の頂点集合をSとして、最後に頂点iにいる場合の通り数 dp = list2d(1 << N, N, 0) # 最初は頂点1にいる状態から dp[1][0] = 1 for S in range(1, 1 << N): for i in range(N): # iが遷移元に含まれていない if not S & 1 << i: continue for j in range(N): # jが遷移元に含まれている(ので遷移先にはできない) if S & 1 << j: continue # 辺の張られた頂点間であれば遷移させる if G[i][j]: dp[S | 1 << j][j] += dp[S][i] # 全頂点訪問できた通り数を合計する ans = sum(dp[(1 << N) - 1]) print(ans)

u895641117

p02793

python

s481557626

s050617778

Accepted

Accepted

def gcd(x, y): while y > 0: r = x%y x = y y = r return x def lcm(x, y): return x//gcd(x, y)*y n = int(eval(input())) a = list(map(int, input().split())) l = 1 for x in a: l = lcm(l, x) ans = 0 for x in a: ans += l//x print((ans%(10**9+7)))

def gcd(x, y): while y > 0: r = x%y x = y y = r return x def lcm(x, y): return x//gcd(y, x)*y n = int(eval(input())) a = list(map(int, input().split())) l = 1 for x in a: l = lcm(x, l) ans = 0 for x in a: ans += l//x print((ans%(10**9+7)))

def gcd(x, y): while y > 0: r = x % y x = y y = r return x def lcm(x, y): return x // gcd(x, y) * y n = int(eval(input())) a = list(map(int, input().split())) l = 1 for x in a: l = lcm(l, x) ans = 0 for x in a: ans += l // x print((ans % (10**9 + 7)))

def gcd(x, y): while y > 0: r = x % y x = y y = r return x def lcm(x, y): return x // gcd(y, x) * y n = int(eval(input())) a = list(map(int, input().split())) l = 1 for x in a: l = lcm(x, l) ans = 0 for x in a: ans += l // x print((ans % (10**9 + 7)))

u644907318

p04034

python

s868411133

s734641844

Accepted

Accepted

N,M = list(map(int,input().split())) R = [0 for _ in range(N+1)] R[1] = 1 B = [1 for _ in range(N+1)] B[0] = 0 for _ in range(M): x,y = list(map(int,input().split())) if R[x]==1: R[y] = 1 B[x] -= 1 B[y] += 1 if B[x]==0: R[x] = 0 print((sum(R)))

N,M = list(map(int,input().split())) A = [0 for _ in range(N+1)] B = [1 for _ in range(N+1)] A[1] = 1 B[0] = 0 for _ in range(M): x,y = list(map(int,input().split())) if A[x]==1: A[y]=1 B[y] += 1 B[x] -= 1 if B[x]==0: A[x] = 0 print((sum(A)))

N, M = list(map(int, input().split())) R = [0 for _ in range(N + 1)] R[1] = 1 B = [1 for _ in range(N + 1)] B[0] = 0 for _ in range(M): x, y = list(map(int, input().split())) if R[x] == 1: R[y] = 1 B[x] -= 1 B[y] += 1 if B[x] == 0: R[x] = 0 print((sum(R)))

N, M = list(map(int, input().split())) A = [0 for _ in range(N + 1)] B = [1 for _ in range(N + 1)] A[1] = 1 B[0] = 0 for _ in range(M): x, y = list(map(int, input().split())) if A[x] == 1: A[y] = 1 B[y] += 1 B[x] -= 1 if B[x] == 0: A[x] = 0 print((sum(A)))