Datasets:

rootacess

/

pie-perf

like 0

u903005414

p03309

python

s741695893

s095896324

Accepted

Accepted

N = int(eval(input())) A = list(map(int, input().split())) def f(x): v = 0 for i in range(len(A)): v += abs(A[i] - (x + i + 1)) return v left = -(10**9 + 2 * 10**5) right = 10**9 + 2 * 10**5 v = 10**18 while left + 1 < right: x = (left + right) // 2 # print('left right x', left, right, x) a = f(x) v = min(v, a) if a <= f(x + 1): right = x elif f(x - 1) >= a: left = x # ans = f(left) # print('left ans v', left, ans, v) print(v)

N = int(eval(input())) A = list(map(int, input().split())) B = sorted([A[i] - i - 1 for i in range(len(A))]) # print('B', B) def f(x): v = 0 for i in range(len(B)): v += abs(B[i] - x) return v if len(B) % 2 == 0: b1 = B[len(B) // 2 - 1] b2 = B[len(B) // 2] ans = min(f(b1), f(b2)) else: b = B[len(B) // 2] ans = f(b) print(ans)

N = int(eval(input())) A = list(map(int, input().split())) def f(x): v = 0 for i in range(len(A)): v += abs(A[i] - (x + i + 1)) return v left = -(10**9 + 2 * 10**5) right = 10**9 + 2 * 10**5 v = 10**18 while left + 1 < right: x = (left + right) // 2 # print('left right x', left, right, x) a = f(x) v = min(v, a) if a <= f(x + 1): right = x elif f(x - 1) >= a: left = x # ans = f(left) # print('left ans v', left, ans, v) print(v)

N = int(eval(input())) A = list(map(int, input().split())) B = sorted([A[i] - i - 1 for i in range(len(A))]) # print('B', B) def f(x): v = 0 for i in range(len(B)): v += abs(B[i] - x) return v if len(B) % 2 == 0: b1 = B[len(B) // 2 - 1] b2 = B[len(B) // 2] ans = min(f(b1), f(b2)) else: b = B[len(B) // 2] ans = f(b) print(ans)

u962045495

p03168

python

s244758513

s793523257

Accepted

Accepted

#!/usr/bin/env python2 """ This file is part of https://github.com/cheran-senthil/PyRival Copyright 2019 Cheran Senthilkumar <hello@cheran.io> """ import itertools import math import os import sys from atexit import register from io import BytesIO class dict(dict): """dict() -> new empty dictionary""" def items(self): """D.items() -> a set-like object providing a view on D's items""" return dict.iteritems(self) def keys(self): """D.keys() -> a set-like object providing a view on D's keys""" return dict.iterkeys(self) def values(self): """D.values() -> an object providing a view on D's values""" return dict.itervalues(self) def gcd(x, y): """greatest common divisor of x and y""" while y: x, y = y, x % y return x range = xrange filter = itertools.ifilter map = itertools.imap zip = itertools.izip sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size)) sys.stdout = BytesIO() register(lambda: os.write(1, sys.stdout.getvalue())) input = lambda: sys.stdin.readline().rstrip('\r\n') n = int(eval(input())) p = [float(i) for i in input().split()] dp = [[0.0] * (n + 1) for _ in range(n)] dp[0][0], dp[0][1] = 1 - p[0], p[0] for i in range(1, n): dp[i][0] = (1 - p[i]) * dp[i - 1][0] for j in range(1, n + 1): dp[i][j] = (p[i] * dp[i - 1][j - 1]) + ((1 - p[i]) * dp[i - 1][j]) print(sum(dp[-1][(n + 1) // 2:]))

#!/usr/bin/env python2 import os import sys from atexit import register from io import BytesIO range = xrange sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size)) sys.stdout = BytesIO() register(lambda: os.write(1, sys.stdout.getvalue())) input = lambda: sys.stdin.readline().rstrip('\r\n') n = int(eval(input())) p = [float(i) for i in input().split()] dp = [0.0] * (n + 1) dp[0], dp[1] = 1 - p[0], p[0] for i in range(1, n): _dp = [0.0] * (n + 1) _dp[0] = (1 - p[i]) * dp[0] for j in range(1, n + 1): _dp[j] = (p[i] * dp[j - 1]) + ((1 - p[i]) * dp[j]) dp = _dp print(sum(dp[(n + 1) // 2:]))

#!/usr/bin/env python2 """ This file is part of https://github.com/cheran-senthil/PyRival Copyright 2019 Cheran Senthilkumar <hello@cheran.io> """ import itertools import math import os import sys from atexit import register from io import BytesIO class dict(dict): """dict() -> new empty dictionary""" def items(self): """D.items() -> a set-like object providing a view on D's items""" return dict.iteritems(self) def keys(self): """D.keys() -> a set-like object providing a view on D's keys""" return dict.iterkeys(self) def values(self): """D.values() -> an object providing a view on D's values""" return dict.itervalues(self) def gcd(x, y): """greatest common divisor of x and y""" while y: x, y = y, x % y return x range = xrange filter = itertools.ifilter map = itertools.imap zip = itertools.izip sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size)) sys.stdout = BytesIO() register(lambda: os.write(1, sys.stdout.getvalue())) input = lambda: sys.stdin.readline().rstrip("\r\n") n = int(eval(input())) p = [float(i) for i in input().split()] dp = [[0.0] * (n + 1) for _ in range(n)] dp[0][0], dp[0][1] = 1 - p[0], p[0] for i in range(1, n): dp[i][0] = (1 - p[i]) * dp[i - 1][0] for j in range(1, n + 1): dp[i][j] = (p[i] * dp[i - 1][j - 1]) + ((1 - p[i]) * dp[i - 1][j]) print(sum(dp[-1][(n + 1) // 2 :]))

#!/usr/bin/env python2 import os import sys from atexit import register from io import BytesIO range = xrange sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size)) sys.stdout = BytesIO() register(lambda: os.write(1, sys.stdout.getvalue())) input = lambda: sys.stdin.readline().rstrip("\r\n") n = int(eval(input())) p = [float(i) for i in input().split()] dp = [0.0] * (n + 1) dp[0], dp[1] = 1 - p[0], p[0] for i in range(1, n): _dp = [0.0] * (n + 1) _dp[0] = (1 - p[i]) * dp[0] for j in range(1, n + 1): _dp[j] = (p[i] * dp[j - 1]) + ((1 - p[i]) * dp[j]) dp = _dp print(sum(dp[(n + 1) // 2 :]))

u601426916

p02657

python

s536867722

s974898135

Accepted

Accepted

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

#C A,B = list(map(float,input().split())) A = int(A+0.1) B = int(B*100+0.1) print((int((A*B)/100)))

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

# C A, B = list(map(float, input().split())) A = int(A + 0.1) B = int(B * 100 + 0.1) print((int((A * B) / 100)))

u980753441

p02552

python

s387921909

s699037100

Accepted

Accepted

ans = [1, 0] print((ans[int(eval(input()))]))

print((0 if bool(int(eval(input()))) else 1))

ans = [1, 0] print((ans[int(eval(input()))]))

print((0 if bool(int(eval(input()))) else 1))

u793868662

p02945

python

s776373218

s325409235

Accepted

Accepted

a,b = list(map(int,input().split())) c = max(a+b, a-b, a*b) print(c)

def resolve(): a, b = list(map(int, input().split())) print((max(a+b, a-b, a*b))) resolve()

a, b = list(map(int, input().split())) c = max(a + b, a - b, a * b) print(c)

def resolve(): a, b = list(map(int, input().split())) print((max(a + b, a - b, a * b))) resolve()

u814986259

p03699

python

s279363381

s267984795

Accepted

Accepted

N=int(eval(input())) s=[int(eval(input())) for i in range(N)] import collections table=collections.defaultdict(int) for x in s: if x%10!=0: table[x]+=1 if sum(s)%10==0: if len(table)==0: print((0)) else: table=list(table.keys()) table.sort() print((sum(s) - table[0])) else: print((sum(s)))

N = int(eval(input())) s = [int(eval(input())) for i in range(N)] S = sum(s) if S % 10 != 0: print(S) else: s.sort() ans = S flag = False for x in s: if x % 10 != 0: ans -= x flag = True break else: continue if flag: print(ans) else: print((0))

N = int(eval(input())) s = [int(eval(input())) for i in range(N)] import collections table = collections.defaultdict(int) for x in s: if x % 10 != 0: table[x] += 1 if sum(s) % 10 == 0: if len(table) == 0: print((0)) else: table = list(table.keys()) table.sort() print((sum(s) - table[0])) else: print((sum(s)))

N = int(eval(input())) s = [int(eval(input())) for i in range(N)] S = sum(s) if S % 10 != 0: print(S) else: s.sort() ans = S flag = False for x in s: if x % 10 != 0: ans -= x flag = True break else: continue if flag: print(ans) else: print((0))

u188827677

p03487

python

s383600145

s437831496

Accepted

Accepted

from collections import Counter n = int(eval(input())) a = list(map(int, input().split())) count = Counter(a) ans = 0 for i in list(count.items()): if i[1] < i[0]: ans += i[1] else: ans += abs(i[1]-i[0]) print(ans)

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

from collections import Counter n = int(eval(input())) a = list(map(int, input().split())) count = Counter(a) ans = 0 for i in list(count.items()): if i[1] < i[0]: ans += i[1] else: ans += abs(i[1] - i[0]) print(ans)

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

u871841829

p02899

python

s219988621

s881529224

Accepted

Accepted

N = int(eval(input())) A = list(map(int, input().split())) # AA = [ix, num for ix, num in enumerate(A)] AA = [] for ix, num in enumerate(A): AA.append((ix, num)) AA = sorted(AA, key=lambda x:x[1]) sbuf = "" for student in AA: sbuf+= str(student[0]+1) + " " print(sbuf)

N = int(eval(input())) A = list(map(int, input().split())) ans = [0] * N for i in range(N): ans[A[i]-1] = i + 1 print((" ".join([str(x) for x in ans])))

N = int(eval(input())) A = list(map(int, input().split())) # AA = [ix, num for ix, num in enumerate(A)] AA = [] for ix, num in enumerate(A): AA.append((ix, num)) AA = sorted(AA, key=lambda x: x[1]) sbuf = "" for student in AA: sbuf += str(student[0] + 1) + " " print(sbuf)

N = int(eval(input())) A = list(map(int, input().split())) ans = [0] * N for i in range(N): ans[A[i] - 1] = i + 1 print((" ".join([str(x) for x in ans])))

u218834617

p02678

python

s622871823

s825628883

Accepted

Accepted

import sys from collections import * N,M=list(map(int,input().split())) adj=defaultdict(list) for ln in sys.stdin: A,B=list(map(int,ln.split())) A,B=A-1,B-1 adj[A].append(B) adj[B].append(A) a={0:0} que=deque([0]) while que: u=que.popleft() for v in adj[u]: if v not in a: a[v]=u que.append(v) if N-1-len(a)>0: print('No') else: print('Yes') for i in range(1,N): print((a[i]+1))

import sys from collections import * N,M=list(map(int,input().split())) adj=[[] for _ in range(N+1)] for ln in sys.stdin: A,B=list(map(int,ln.split())) adj[A].append(B) adj[B].append(A) ans=[0]*(N+1) ans[1]=1 que=deque([1]) while que: A=que.popleft() for B in adj[A]: if ans[B]==0: ans[B]=A que.append(B) print('Yes') for i in range(2,N+1): print((ans[i]))

import sys from collections import * N, M = list(map(int, input().split())) adj = defaultdict(list) for ln in sys.stdin: A, B = list(map(int, ln.split())) A, B = A - 1, B - 1 adj[A].append(B) adj[B].append(A) a = {0: 0} que = deque([0]) while que: u = que.popleft() for v in adj[u]: if v not in a: a[v] = u que.append(v) if N - 1 - len(a) > 0: print("No") else: print("Yes") for i in range(1, N): print((a[i] + 1))

import sys from collections import * N, M = list(map(int, input().split())) adj = [[] for _ in range(N + 1)] for ln in sys.stdin: A, B = list(map(int, ln.split())) adj[A].append(B) adj[B].append(A) ans = [0] * (N + 1) ans[1] = 1 que = deque([1]) while que: A = que.popleft() for B in adj[A]: if ans[B] == 0: ans[B] = A que.append(B) print("Yes") for i in range(2, N + 1): print((ans[i]))

u698176039

p02892

python

s459251014

s054702677

Accepted

Accepted

N = int(eval(input())) S = [eval(input()) for _ in range(N)] import sys import copy ans = 0 adj_list = [[]for _ in range(N)] for i in range(N): for j in range(i+1,N): if int(S[i][j]): adj_list[i].append(j) adj_list[j].append(i) for kk in range(N): q = [] visited = [False] * N cnt = 1 visited[kk] = True q.append(kk) VC = 1 while VC < N: nextv = copy.copy(q) q = [] nextv = list(set(nextv)) #子の要素同士の連結チェック L = len(nextv) for i in range(L): if not(visited[nextv[i]]): visited[nextv[i]] = True VC += 1 for j in range(i+1,L): if (int(S[nextv[i]][nextv[j]])): print((-1)) sys.exit() for nv in nextv: for v in adj_list[nv]: if not(visited[v]): q.append(v) cnt += 1 ans = max(ans,cnt-1) # print(ans)

import sys sys.setrecursionlimit(10**8) input = sys.stdin.readline N = int(input()) S = [list(input()) for _ in range(N)] edge = [[] for _ in range(N)] for i in range(N): for j in range(N): if S[i][j]=='1': edge[i].append(j) ans = 0 import queue for i in range(N): q = queue.Queue() q.put(i) nums = [-1]*N nums[i] = 1 while not q.empty(): v = q.get() flag = True for nv in edge[v]: if nums[nv] == -1: nums[nv] = nums[v] + 1 q.put(nv) elif nums[nv]%2 != (nums[v]+1)%2: flag = False break if not flag: break if flag: ans = max(ans, max(nums)) print(ans) if ans != 0 else print(-1)

N = int(eval(input())) S = [eval(input()) for _ in range(N)] import sys import copy ans = 0 adj_list = [[] for _ in range(N)] for i in range(N): for j in range(i + 1, N): if int(S[i][j]): adj_list[i].append(j) adj_list[j].append(i) for kk in range(N): q = [] visited = [False] * N cnt = 1 visited[kk] = True q.append(kk) VC = 1 while VC < N: nextv = copy.copy(q) q = [] nextv = list(set(nextv)) # 子の要素同士の連結チェック L = len(nextv) for i in range(L): if not (visited[nextv[i]]): visited[nextv[i]] = True VC += 1 for j in range(i + 1, L): if int(S[nextv[i]][nextv[j]]): print((-1)) sys.exit() for nv in nextv: for v in adj_list[nv]: if not (visited[v]): q.append(v) cnt += 1 ans = max(ans, cnt - 1) # print(ans)

import sys sys.setrecursionlimit(10**8) input = sys.stdin.readline N = int(input()) S = [list(input()) for _ in range(N)] edge = [[] for _ in range(N)] for i in range(N): for j in range(N): if S[i][j] == "1": edge[i].append(j) ans = 0 import queue for i in range(N): q = queue.Queue() q.put(i) nums = [-1] * N nums[i] = 1 while not q.empty(): v = q.get() flag = True for nv in edge[v]: if nums[nv] == -1: nums[nv] = nums[v] + 1 q.put(nv) elif nums[nv] % 2 != (nums[v] + 1) % 2: flag = False break if not flag: break if flag: ans = max(ans, max(nums)) print(ans) if ans != 0 else print(-1)

u908763441

p02918

python

s342969821

s938089381

Accepted

Accepted

N, K = list(map(int, input().split())) S = list(eval(input())) count = 0 if N == 1: print('0') exit() if S[0] == 'R' and S[1] == 'R': count += 1 if S[N - 2] == 'L' and S[N - 1] == 'L': count += 1 for i in range(1, N-1): if [S[i - 1], S[i]] == ['L', 'L'] or [S[i], S[i + 1]] == ['R', 'R']: count += 1 print((str(min(N - 1, count + K * 2))))

N, K = list(map(int, input().split())) L = list(eval(input())) L.insert(0, '') L.append('') num = 0 for n in range(1, N+1): if L[n] == 'L' and L[n - 1] == 'L': num += 1 if L[n] == 'R' and L[n + 1] == 'R': num += 1 ans = min(num + K * 2, N - 1) print((str(ans)))

N, K = list(map(int, input().split())) S = list(eval(input())) count = 0 if N == 1: print("0") exit() if S[0] == "R" and S[1] == "R": count += 1 if S[N - 2] == "L" and S[N - 1] == "L": count += 1 for i in range(1, N - 1): if [S[i - 1], S[i]] == ["L", "L"] or [S[i], S[i + 1]] == ["R", "R"]: count += 1 print((str(min(N - 1, count + K * 2))))

N, K = list(map(int, input().split())) L = list(eval(input())) L.insert(0, "") L.append("") num = 0 for n in range(1, N + 1): if L[n] == "L" and L[n - 1] == "L": num += 1 if L[n] == "R" and L[n + 1] == "R": num += 1 ans = min(num + K * 2, N - 1) print((str(ans)))

u729133443

p03181

python

s225957576

s570600393

Accepted

Accepted

n,m,*t=list(map(int,open(0).read().split())) e=[[]for _ in range(n)] for a,b in zip(*[iter(t)]*2): e[a-1]+=b-1, e[b-1]+=a-1, o=[] s=[0] f=[1]*n for v in s: o+=v, f[v]=0 t=[] for w in e[v]: if f[w]: s+=w, t+=w, e[v]=t dp1=[0]*n c=[[]for _ in range(n)] for v in o[::-1]: c1,c2=[1],[1] for w in e[v]: c1+=c1[-1]*(dp1[w]+1)%m, for w in e[v][::-1]: c2+=c2[-1]*(dp1[w]+1)%m, dp1[v]=c1[-1] c[v]=c1,c2[-2::-1] dp2=[0]*n dp2[0]=1 for v in o: t=dp2[v] for w,c1,c2 in zip(e[v],*c[v]): dp2[w]=(t*c1*c2+1)%m for dp1,dp2 in zip(dp1,dp2): print((dp1*dp2%m))

n,m,*t=list(map(int,open(0).read().split())) e=[[]for _ in range(n)] for a,b in zip(*[iter(t)]*2): e[a-1]+=b-1, e[b-1]+=a-1, o=[] s=[0] f=[1]*n for v in s: o+=v, f[v]=0 t=[] for w in e[v]: if f[w]: s+=w, t+=w, e[v]=t dp1=[0]*n c=[[]for _ in range(n)] for v in o[::-1]: x,y=[1],[1] for w in e[v]:x+=x[-1]*(dp1[w]+1)%m, for w in e[v][::-1]:y+=y[-1]*(dp1[w]+1)%m, dp1[v]=x[-1] c[v]=x,y[-2::-1] dp2=[1]+[0]*n for v in o: for w,x,y in zip(e[v],*c[v]):dp2[w]=(dp2[v]*x*y+1)%m for x,y in zip(dp1,dp2):print((x*y%m))

n, m, *t = list(map(int, open(0).read().split())) e = [[] for _ in range(n)] for a, b in zip(*[iter(t)] * 2): e[a - 1] += (b - 1,) e[b - 1] += (a - 1,) o = [] s = [0] f = [1] * n for v in s: o += (v,) f[v] = 0 t = [] for w in e[v]: if f[w]: s += (w,) t += (w,) e[v] = t dp1 = [0] * n c = [[] for _ in range(n)] for v in o[::-1]: c1, c2 = [1], [1] for w in e[v]: c1 += (c1[-1] * (dp1[w] + 1) % m,) for w in e[v][::-1]: c2 += (c2[-1] * (dp1[w] + 1) % m,) dp1[v] = c1[-1] c[v] = c1, c2[-2::-1] dp2 = [0] * n dp2[0] = 1 for v in o: t = dp2[v] for w, c1, c2 in zip(e[v], *c[v]): dp2[w] = (t * c1 * c2 + 1) % m for dp1, dp2 in zip(dp1, dp2): print((dp1 * dp2 % m))

n, m, *t = list(map(int, open(0).read().split())) e = [[] for _ in range(n)] for a, b in zip(*[iter(t)] * 2): e[a - 1] += (b - 1,) e[b - 1] += (a - 1,) o = [] s = [0] f = [1] * n for v in s: o += (v,) f[v] = 0 t = [] for w in e[v]: if f[w]: s += (w,) t += (w,) e[v] = t dp1 = [0] * n c = [[] for _ in range(n)] for v in o[::-1]: x, y = [1], [1] for w in e[v]: x += (x[-1] * (dp1[w] + 1) % m,) for w in e[v][::-1]: y += (y[-1] * (dp1[w] + 1) % m,) dp1[v] = x[-1] c[v] = x, y[-2::-1] dp2 = [1] + [0] * n for v in o: for w, x, y in zip(e[v], *c[v]): dp2[w] = (dp2[v] * x * y + 1) % m for x, y in zip(dp1, dp2): print((x * y % m))

u588341295

p03172

python

s721890118

s983133600

Accepted

Accepted

# -*- coding: utf-8 -*- import sys, re from collections import deque, defaultdict, Counter from math import sqrt, hypot, factorial, pi, sin, cos, radians if sys.version_info.minor >= 5: from math import gcd else: from fractions import gcd from heapq import heappop, heappush, heapify, heappushpop from bisect import bisect_left, bisect_right from itertools import permutations, combinations, product from operator import itemgetter, mul from copy import deepcopy from functools import reduce, partial from fractions import Fraction from string import ascii_lowercase, ascii_uppercase, digits def input(): return sys.stdin.readline().strip() def ceil(a, b=1): return int(-(-a // b)) def round(x): return int((x*2+1) // 2) def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD def lcm(x, y): return (x * y) // gcd(x, y) def lcm_list(nums): return reduce(lcm, nums, 1) def gcd_list(nums): return reduce(gcd, nums, nums[0]) def INT(): return int(eval(input())) def MAP(): return list(map(int, input().split())) def LIST(): return list(map(int, input().split())) sys.setrecursionlimit(10 ** 9) INF = float('inf') MOD = 10 ** 9 + 7 N, K = MAP() aN = LIST() # dp[この子までの範囲で][飴を配る総数] = 場合の数 dp = [[0] * (K+1) for i in range(N+1)] # 0番目まで(誰もいない)の範囲で0個配る場合の数は1通り dp[0][0] = 1 for i in range(N): sm = [0] * (K+2) # 今回送るi行について累積和を取る for j in range(1, K+2): sm[j] = sm[j-1] + dp[i][j-1] sm[j] %= MOD for j in range(K+1): # iが送る予定の長さに応じた区間和を取る dp[i+1][j] = sm[j+1] - sm[max(j-aN[i], 0)] dp[i+1][j] %= MOD # for k in range(aN[i]+1): # dp[i+1][j+k] += dp[i][j] print((dp[N][K]))

# -*- coding: utf-8 -*- import sys from functools import reduce def input(): return sys.stdin.readline().strip() def ceil(a, b=1): return int(-(-a // b)) def round(x): return int((x*2+1) // 2) def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD def lcm(x, y): return (x * y) // gcd(x, y) def lcm_list(nums): return reduce(lcm, nums, 1) def gcd_list(nums): return reduce(gcd, nums, nums[0]) def INT(): return int(eval(input())) def MAP(): return list(map(int, input().split())) def LIST(): return list(map(int, input().split())) sys.setrecursionlimit(10 ** 9) INF = float('inf') MOD = 10 ** 9 + 7 N, K = MAP() aN = LIST() # dp[この子までの範囲で][飴を配る総数] = 場合の数 dp = [[0] * (K+1) for i in range(N+1)] # 0番目まで(誰もいない)の範囲で0個配る場合の数は1通り dp[0][0] = 1 for i in range(N): sm = [0] * (K+2) # 今回送るi行について累積和を取る for j in range(1, K+2): sm[j] = sm[j-1] + dp[i][j-1] sm[j] %= MOD for j in range(K+1): # iが送る予定の長さに応じた区間和を取る dp[i+1][j] = sm[j+1] - sm[max(j-aN[i], 0)] dp[i+1][j] %= MOD # for k in range(aN[i]+1): # dp[i+1][j+k] += dp[i][j] print((dp[N][K]))

# -*- coding: utf-8 -*- import sys, re from collections import deque, defaultdict, Counter from math import sqrt, hypot, factorial, pi, sin, cos, radians if sys.version_info.minor >= 5: from math import gcd else: from fractions import gcd from heapq import heappop, heappush, heapify, heappushpop from bisect import bisect_left, bisect_right from itertools import permutations, combinations, product from operator import itemgetter, mul from copy import deepcopy from functools import reduce, partial from fractions import Fraction from string import ascii_lowercase, ascii_uppercase, digits def input(): return sys.stdin.readline().strip() def ceil(a, b=1): return int(-(-a // b)) def round(x): return int((x * 2 + 1) // 2) def fermat(x, y, MOD): return x * pow(y, MOD - 2, MOD) % MOD def lcm(x, y): return (x * y) // gcd(x, y) def lcm_list(nums): return reduce(lcm, nums, 1) def gcd_list(nums): return reduce(gcd, nums, nums[0]) def INT(): return int(eval(input())) def MAP(): return list(map(int, input().split())) def LIST(): return list(map(int, input().split())) sys.setrecursionlimit(10**9) INF = float("inf") MOD = 10**9 + 7 N, K = MAP() aN = LIST() # dp[この子までの範囲で][飴を配る総数] = 場合の数 dp = [[0] * (K + 1) for i in range(N + 1)] # 0番目まで(誰もいない)の範囲で0個配る場合の数は1通り dp[0][0] = 1 for i in range(N): sm = [0] * (K + 2) # 今回送るi行について累積和を取る for j in range(1, K + 2): sm[j] = sm[j - 1] + dp[i][j - 1] sm[j] %= MOD for j in range(K + 1): # iが送る予定の長さに応じた区間和を取る dp[i + 1][j] = sm[j + 1] - sm[max(j - aN[i], 0)] dp[i + 1][j] %= MOD # for k in range(aN[i]+1): # dp[i+1][j+k] += dp[i][j] print((dp[N][K]))

# -*- coding: utf-8 -*- import sys from functools import reduce def input(): return sys.stdin.readline().strip() def ceil(a, b=1): return int(-(-a // b)) def round(x): return int((x * 2 + 1) // 2) def fermat(x, y, MOD): return x * pow(y, MOD - 2, MOD) % MOD def lcm(x, y): return (x * y) // gcd(x, y) def lcm_list(nums): return reduce(lcm, nums, 1) def gcd_list(nums): return reduce(gcd, nums, nums[0]) def INT(): return int(eval(input())) def MAP(): return list(map(int, input().split())) def LIST(): return list(map(int, input().split())) sys.setrecursionlimit(10**9) INF = float("inf") MOD = 10**9 + 7 N, K = MAP() aN = LIST() # dp[この子までの範囲で][飴を配る総数] = 場合の数 dp = [[0] * (K + 1) for i in range(N + 1)] # 0番目まで(誰もいない)の範囲で0個配る場合の数は1通り dp[0][0] = 1 for i in range(N): sm = [0] * (K + 2) # 今回送るi行について累積和を取る for j in range(1, K + 2): sm[j] = sm[j - 1] + dp[i][j - 1] sm[j] %= MOD for j in range(K + 1): # iが送る予定の長さに応じた区間和を取る dp[i + 1][j] = sm[j + 1] - sm[max(j - aN[i], 0)] dp[i + 1][j] %= MOD # for k in range(aN[i]+1): # dp[i+1][j+k] += dp[i][j] print((dp[N][K]))

u367130284

p03610

python

s073269645

s127865102

Accepted

Accepted

print(("".join([v for k,v in enumerate(list(eval(input()))) if k%2==0])))

print((input()[::2]))

print(("".join([v for k, v in enumerate(list(eval(input()))) if k % 2 == 0])))

print((input()[::2]))

u746419473

p02897

python

s189310297

s783129594

Accepted

Accepted

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

n = int(eval(input())) print((sum([x%2 == 1 for x in range(1, n+1)])/n))

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

n = int(eval(input())) print((sum([x % 2 == 1 for x in range(1, n + 1)]) / n))

u556657484

p02641

python

s229086057

s157827420

Accepted

Accepted

X, N = list(map(int,input().split())) if N == 0: print(X) exit() else: P = list(map(int,input().split())) L = [i for i in range(0,102) if i not in P] if X in L: ANS = X else: L.append(X) L = sorted(L) n = L.index(X) l = len(L) - 1 if (0 < n < l): if (L[n+1]-L[n] < L[n] - L[n-1]): ANS = L[n+1] else: ANS = L[n - 1] elif (n == l): ANS = L[l - 1] print(ANS)

X, N = list(map(int,input().split())) if N == 0: print(X) exit() else: P = list(map(int,input().split())) L = [i for i in range(0,102) if i not in P] if X in L: ANS = X else: L.append(X) L = sorted(L) n = L.index(X) if (L[n+1]-L[n] < L[n] - L[n-1]): ANS = L[n+1] else: ANS = L[n - 1] print(ANS)

X, N = list(map(int, input().split())) if N == 0: print(X) exit() else: P = list(map(int, input().split())) L = [i for i in range(0, 102) if i not in P] if X in L: ANS = X else: L.append(X) L = sorted(L) n = L.index(X) l = len(L) - 1 if 0 < n < l: if L[n + 1] - L[n] < L[n] - L[n - 1]: ANS = L[n + 1] else: ANS = L[n - 1] elif n == l: ANS = L[l - 1] print(ANS)

X, N = list(map(int, input().split())) if N == 0: print(X) exit() else: P = list(map(int, input().split())) L = [i for i in range(0, 102) if i not in P] if X in L: ANS = X else: L.append(X) L = sorted(L) n = L.index(X) if L[n + 1] - L[n] < L[n] - L[n - 1]: ANS = L[n + 1] else: ANS = L[n - 1] print(ANS)

u767797498

p02689

python

s963335581

s508743210

Accepted

Accepted

from collections import defaultdict n,m=list(map(int,input().split())) h=list(map(int,input().split())) dd=defaultdict(set) for i in range(m): a,b=list(map(int,input().split())) dd[a-1].add(b-1) dd[b-1].add(a-1) cnt=0 for i,hh in enumerate(h): flg=True for j in dd[i]: if hh <= h[j]: flg=False break if flg: cnt+=1 print(cnt)

from collections import defaultdict n,m=list(map(int,input().split())) h=list(map(int,input().split())) ma=[0 for _ in range(n)] for _ in range(m): a,b=list(map(int,input().split())) ma[a-1]=max(ma[a-1],h[b-1]) ma[b-1]=max(ma[b-1],h[a-1]) cnt=0 for i,hh in enumerate(ma): if h[i] > hh: cnt+=1 print(cnt)

from collections import defaultdict n, m = list(map(int, input().split())) h = list(map(int, input().split())) dd = defaultdict(set) for i in range(m): a, b = list(map(int, input().split())) dd[a - 1].add(b - 1) dd[b - 1].add(a - 1) cnt = 0 for i, hh in enumerate(h): flg = True for j in dd[i]: if hh <= h[j]: flg = False break if flg: cnt += 1 print(cnt)

from collections import defaultdict n, m = list(map(int, input().split())) h = list(map(int, input().split())) ma = [0 for _ in range(n)] for _ in range(m): a, b = list(map(int, input().split())) ma[a - 1] = max(ma[a - 1], h[b - 1]) ma[b - 1] = max(ma[b - 1], h[a - 1]) cnt = 0 for i, hh in enumerate(ma): if h[i] > hh: cnt += 1 print(cnt)

u316268279

p00481

python

s461830022

s585475198

Accepted

Accepted

#!/usr/bin/env python # -*- coding: utf-8 -*- import heapq import sys def check_out_of_map(pos,H,W): H = len(Map) W = len(Map[0]) if pos[0] < 0 or pos[1] < 0: return False if pos[0] >= H or pos[1] >= W: return False return True def bfs(s,g,Map,H,W): queue = [] queue.append(s) dist = [[-1 for i in range(W)] for j in range(H)] direct = [(1,0),(-1,0),(0,1),(0,-1)] count = 0 dist[s[0]][s[1]] = 0 while queue != []: q = queue.pop(0) if q == g: return dist[q[0]][q[1]] for i in range(4): nextPos = (q[0]+direct[i][0],q[1]+direct[i][1]) if check_out_of_map(nextPos,H,W) and Map[nextPos[0]][nextPos[1]] != "X": if dist[nextPos[0]][nextPos[1]] == -1: dist[nextPos[0]][nextPos[1]] = dist[q[0]][q[1]] + 1 queue.append(nextPos) H,W,N = list(map(int,input().split(" "))) cheese_queue = [] Map = [] for i in range(H): count = 0 line = [] while True: char = sys.stdin.read(1) if char == "S": s = (i,count) elif char.isnumeric(): heapq.heappush(cheese_queue,(int(char),(i,count))) elif char == "\n": break line.append(char) count += 1 Map.append(line) count = 0 while cheese_queue != []: q = heapq.heappop(cheese_queue) count += bfs(s,q[1],Map,H,W) s = q[1] print(count)

#!/usr/bin/env python # -*- coding: utf-8 -*- import heapq import sys def check_out_of_map(pos,H,W): if pos[0] < 0 or pos[1] < 0: return False if pos[0] >= H or pos[1] >= W: return False return True def bfs(s,g,Map,H,W): queue = [] queue.append(s) dist = [[-1 for i in range(W)] for j in range(H)] direct = [(1,0),(-1,0),(0,1),(0,-1)] count = 0 dist[s[0]][s[1]] = 0 while queue != []: q = queue.pop(0) if q == g: return dist[q[0]][q[1]] for i in range(4): nextPos = (q[0]+direct[i][0],q[1]+direct[i][1]) if check_out_of_map(nextPos,H,W) and Map[nextPos[0]][nextPos[1]] != "X": if dist[nextPos[0]][nextPos[1]] == -1: dist[nextPos[0]][nextPos[1]] = dist[q[0]][q[1]] + 1 queue.append(nextPos) H,W,N = list(map(int,input().split(" "))) cheese_queue = [] Map = [] for i in range(H): count = 0 line = [] while True: char = sys.stdin.read(1) if char == "S": s = (i,count) elif char.isnumeric(): heapq.heappush(cheese_queue,(int(char),(i,count))) elif char == "\n": break line.append(char) count += 1 Map.append(line) count = 0 while cheese_queue != []: q = heapq.heappop(cheese_queue) count += bfs(s,q[1],Map,H,W) s = q[1] print(count)

#!/usr/bin/env python # -*- coding: utf-8 -*- import heapq import sys def check_out_of_map(pos, H, W): H = len(Map) W = len(Map[0]) if pos[0] < 0 or pos[1] < 0: return False if pos[0] >= H or pos[1] >= W: return False return True def bfs(s, g, Map, H, W): queue = [] queue.append(s) dist = [[-1 for i in range(W)] for j in range(H)] direct = [(1, 0), (-1, 0), (0, 1), (0, -1)] count = 0 dist[s[0]][s[1]] = 0 while queue != []: q = queue.pop(0) if q == g: return dist[q[0]][q[1]] for i in range(4): nextPos = (q[0] + direct[i][0], q[1] + direct[i][1]) if check_out_of_map(nextPos, H, W) and Map[nextPos[0]][nextPos[1]] != "X": if dist[nextPos[0]][nextPos[1]] == -1: dist[nextPos[0]][nextPos[1]] = dist[q[0]][q[1]] + 1 queue.append(nextPos) H, W, N = list(map(int, input().split(" "))) cheese_queue = [] Map = [] for i in range(H): count = 0 line = [] while True: char = sys.stdin.read(1) if char == "S": s = (i, count) elif char.isnumeric(): heapq.heappush(cheese_queue, (int(char), (i, count))) elif char == "\n": break line.append(char) count += 1 Map.append(line) count = 0 while cheese_queue != []: q = heapq.heappop(cheese_queue) count += bfs(s, q[1], Map, H, W) s = q[1] print(count)

#!/usr/bin/env python # -*- coding: utf-8 -*- import heapq import sys def check_out_of_map(pos, H, W): if pos[0] < 0 or pos[1] < 0: return False if pos[0] >= H or pos[1] >= W: return False return True def bfs(s, g, Map, H, W): queue = [] queue.append(s) dist = [[-1 for i in range(W)] for j in range(H)] direct = [(1, 0), (-1, 0), (0, 1), (0, -1)] count = 0 dist[s[0]][s[1]] = 0 while queue != []: q = queue.pop(0) if q == g: return dist[q[0]][q[1]] for i in range(4): nextPos = (q[0] + direct[i][0], q[1] + direct[i][1]) if check_out_of_map(nextPos, H, W) and Map[nextPos[0]][nextPos[1]] != "X": if dist[nextPos[0]][nextPos[1]] == -1: dist[nextPos[0]][nextPos[1]] = dist[q[0]][q[1]] + 1 queue.append(nextPos) H, W, N = list(map(int, input().split(" "))) cheese_queue = [] Map = [] for i in range(H): count = 0 line = [] while True: char = sys.stdin.read(1) if char == "S": s = (i, count) elif char.isnumeric(): heapq.heappush(cheese_queue, (int(char), (i, count))) elif char == "\n": break line.append(char) count += 1 Map.append(line) count = 0 while cheese_queue != []: q = heapq.heappop(cheese_queue) count += bfs(s, q[1], Map, H, W) s = q[1] print(count)

u290563917

p03060

python

s710295195

s122824669

Accepted

Accepted

n = int(eval(input())) v = [num for num in map(int, input().split())] c = [num for num in map(int, input().split())] ans = 0 for i in range(n): val = v[i] - c[i] if val > 0: ans += val print(ans)

n = int(eval(input())) v = list(map(int, input().split())) c = list(map(int, input().split())) ans = 0 for i in range(n): if v[i] > c[i]: ans += v[i] - c[i] print(ans)

n = int(eval(input())) v = [num for num in map(int, input().split())] c = [num for num in map(int, input().split())] ans = 0 for i in range(n): val = v[i] - c[i] if val > 0: ans += val print(ans)

n = int(eval(input())) v = list(map(int, input().split())) c = list(map(int, input().split())) ans = 0 for i in range(n): if v[i] > c[i]: ans += v[i] - c[i] print(ans)

u489959379

p02959

python

s223298972

s335895939

Accepted

Accepted

n = int(eval(input())) a = list(map(int, input().split())) b = list(map(int, input().split())) ans = 0 for i in range(n): left = min(a[i], b[i]) ans += left a[i] -= left b[i] -= left right = min(a[i+1], b[i]) ans += right a[i+1] -= right b[i] -= right print(ans)

import sys sys.setrecursionlimit(10 ** 7) f_inf = float('inf') mod = 10 ** 9 + 7 def resolve(): n = int(eval(input())) A = list(map(int, input().split())) B = list(map(int, input().split())) res = 0 for i in range(n): if A[i] <= B[i]: res += A[i] B[i] -= A[i] A[i] = 0 if A[i + 1] <= B[i]: res += A[i + 1] B[i] -= A[i + 1] A[i + 1] = 0 else: res += B[i] A[i + 1] -= B[i] B[i] = 0 else: res += B[i] A[i] -= B[i] B[i] = 0 print(res) if __name__ == '__main__': resolve()

n = int(eval(input())) a = list(map(int, input().split())) b = list(map(int, input().split())) ans = 0 for i in range(n): left = min(a[i], b[i]) ans += left a[i] -= left b[i] -= left right = min(a[i + 1], b[i]) ans += right a[i + 1] -= right b[i] -= right print(ans)

import sys sys.setrecursionlimit(10**7) f_inf = float("inf") mod = 10**9 + 7 def resolve(): n = int(eval(input())) A = list(map(int, input().split())) B = list(map(int, input().split())) res = 0 for i in range(n): if A[i] <= B[i]: res += A[i] B[i] -= A[i] A[i] = 0 if A[i + 1] <= B[i]: res += A[i + 1] B[i] -= A[i + 1] A[i + 1] = 0 else: res += B[i] A[i + 1] -= B[i] B[i] = 0 else: res += B[i] A[i] -= B[i] B[i] = 0 print(res) if __name__ == "__main__": resolve()

u493520238

p03291

python

s660417706

s691924525

Accepted

Accepted

def modinv(a,m): b, u, v = m, 1, 0 while b: t = a//b a -= t*b a,b = b,a u -= t * v u,v = v,u u %= m return u s=eval(input()) all_hatena = s.count('?') a_cnt = 0 ab_cnt = 0 hatena_cnt = 0 ans = 0 MOD = 10**9+7 for si in s: if si == 'A': a_cnt += 1 elif si == 'B': ab_cnt += a_cnt*pow(3,all_hatena,MOD) if all_hatena >= 1: ab_cnt += hatena_cnt*pow(3,all_hatena-1,MOD) elif si == 'C': ans += ab_cnt else: ans += ab_cnt*modinv(3,MOD) ab_cnt += a_cnt*pow(3,all_hatena-1,MOD) if all_hatena >= 2: ab_cnt += hatena_cnt*pow(3,all_hatena-2,MOD) hatena_cnt += 1 ab_cnt%=MOD ans%=MOD print(ans)

s=eval(input()) all_hatena = s.count('?') a_cnt = 0 ab_cnt = 0 hatena_cnt = 0 ans = 0 MOD = 10**9+7 for si in s: if si == 'A': a_cnt += 1 elif si == 'B': ab_cnt += a_cnt*pow(3,all_hatena,MOD) if all_hatena >= 1: ab_cnt += hatena_cnt*pow(3,all_hatena-1,MOD) elif si == 'C': ans += ab_cnt else: ans += ab_cnt*333333336 # modinv(3,MOD) ab_cnt += a_cnt*pow(3,all_hatena-1,MOD) if all_hatena >= 2: ab_cnt += hatena_cnt*pow(3,all_hatena-2,MOD) hatena_cnt += 1 ab_cnt%=MOD ans%=MOD print(ans)

def modinv(a, m): b, u, v = m, 1, 0 while b: t = a // b a -= t * b a, b = b, a u -= t * v u, v = v, u u %= m return u s = eval(input()) all_hatena = s.count("?") a_cnt = 0 ab_cnt = 0 hatena_cnt = 0 ans = 0 MOD = 10**9 + 7 for si in s: if si == "A": a_cnt += 1 elif si == "B": ab_cnt += a_cnt * pow(3, all_hatena, MOD) if all_hatena >= 1: ab_cnt += hatena_cnt * pow(3, all_hatena - 1, MOD) elif si == "C": ans += ab_cnt else: ans += ab_cnt * modinv(3, MOD) ab_cnt += a_cnt * pow(3, all_hatena - 1, MOD) if all_hatena >= 2: ab_cnt += hatena_cnt * pow(3, all_hatena - 2, MOD) hatena_cnt += 1 ab_cnt %= MOD ans %= MOD print(ans)

s = eval(input()) all_hatena = s.count("?") a_cnt = 0 ab_cnt = 0 hatena_cnt = 0 ans = 0 MOD = 10**9 + 7 for si in s: if si == "A": a_cnt += 1 elif si == "B": ab_cnt += a_cnt * pow(3, all_hatena, MOD) if all_hatena >= 1: ab_cnt += hatena_cnt * pow(3, all_hatena - 1, MOD) elif si == "C": ans += ab_cnt else: ans += ab_cnt * 333333336 # modinv(3,MOD) ab_cnt += a_cnt * pow(3, all_hatena - 1, MOD) if all_hatena >= 2: ab_cnt += hatena_cnt * pow(3, all_hatena - 2, MOD) hatena_cnt += 1 ab_cnt %= MOD ans %= MOD print(ans)

u197968862

p02881

python

s017281464

s403225922

Accepted

Accepted

n = int(eval(input())) i = 1 ans = 10**13 while(i*i<=n): if n%i == 0: ans = min(ans,n//i+i-2) i+=1 print(ans)

n = int(eval(input())) i = 1 ele = [] while i * i <= n: if n % i == 0: ele.append([i,n//i]) i += 1 ans = 10**13 for i in range(len(ele)): ans = min(ans,ele[i][0]+ele[i][1]-2) print(ans)

n = int(eval(input())) i = 1 ans = 10**13 while i * i <= n: if n % i == 0: ans = min(ans, n // i + i - 2) i += 1 print(ans)

n = int(eval(input())) i = 1 ele = [] while i * i <= n: if n % i == 0: ele.append([i, n // i]) i += 1 ans = 10**13 for i in range(len(ele)): ans = min(ans, ele[i][0] + ele[i][1] - 2) print(ans)

u197955752

p03283

python

s958309733

s304365610

Accepted

Accepted

N, M, Q = [int(x) for x in input().split()] L = [0] * M R = [0] * M p = [0] * Q q = [0] * Q for i in range(M): L[i], R[i] = [int(x) for x in input().split()] for j in range(Q): p[j], q[j] = [int(x) for x in input().split()] train = [[0 for i in range(N + 1)] for _ in range(N + 1)] seg = [[0 for i in range(N + 1)] for _ in range(N + 2)] for i in range(M): # すべての列車について train[L[i]][R[i]] += 1 for col in range(1, N + 1): for row in range(col, 0, -1): seg[row][col] = train[row][col] + seg[row][col - 1] + seg[row + 1][col] - seg[row + 1][col - 1] for j in range(Q): print((seg[p[j]][q[j]]))

import sys input = sys.stdin.readline N, M, Q = [int(x) for x in input().split()] L = [0] * M R = [0] * M p = [0] * Q q = [0] * Q for i in range(M): L[i], R[i] = [int(x) for x in input().split()] for j in range(Q): p[j], q[j] = [int(x) for x in input().split()] train = [[0 for i in range(N + 1)] for _ in range(N + 1)] seg = [[0 for i in range(N + 1)] for _ in range(N + 2)] for i in range(M): # すべての列車について train[L[i]][R[i]] += 1 for col in range(1, N + 1): for row in range(col, 0, -1): seg[row][col] = train[row][col] + seg[row][col - 1] + seg[row + 1][col] - seg[row + 1][col - 1] for j in range(Q): print((seg[p[j]][q[j]]))

N, M, Q = [int(x) for x in input().split()] L = [0] * M R = [0] * M p = [0] * Q q = [0] * Q for i in range(M): L[i], R[i] = [int(x) for x in input().split()] for j in range(Q): p[j], q[j] = [int(x) for x in input().split()] train = [[0 for i in range(N + 1)] for _ in range(N + 1)] seg = [[0 for i in range(N + 1)] for _ in range(N + 2)] for i in range(M): # すべての列車について train[L[i]][R[i]] += 1 for col in range(1, N + 1): for row in range(col, 0, -1): seg[row][col] = ( train[row][col] + seg[row][col - 1] + seg[row + 1][col] - seg[row + 1][col - 1] ) for j in range(Q): print((seg[p[j]][q[j]]))

import sys input = sys.stdin.readline N, M, Q = [int(x) for x in input().split()] L = [0] * M R = [0] * M p = [0] * Q q = [0] * Q for i in range(M): L[i], R[i] = [int(x) for x in input().split()] for j in range(Q): p[j], q[j] = [int(x) for x in input().split()] train = [[0 for i in range(N + 1)] for _ in range(N + 1)] seg = [[0 for i in range(N + 1)] for _ in range(N + 2)] for i in range(M): # すべての列車について train[L[i]][R[i]] += 1 for col in range(1, N + 1): for row in range(col, 0, -1): seg[row][col] = ( train[row][col] + seg[row][col - 1] + seg[row + 1][col] - seg[row + 1][col - 1] ) for j in range(Q): print((seg[p[j]][q[j]]))

u223646582

p03283

python

s097545225

s358149758

Accepted

Accepted

N, M, Q = list(map(int, input().split())) X = [[0 for j in range(510)] for i in range(510)] C = [[0 for j in range(510)] for i in range(510)] LR = [] for i in range(M): L, R = list(map(int, input().split())) X[L][R] += 1 for i in range(1, N+1): for j in range(1, N+1): C[i][j] = C[i][j-1]+X[i][j] for i in range(Q): p, q = list(map(int, input().split())) sum = 0 for j in range(p, q+1): sum += C[j][q]-C[j][p-1] print(sum)

N, M, Q = list(map(int, input().split())) # 入力 A = [[0 for j in range(N+1)] for i in range(N+1)] for _ in range(M): L, R = list(map(int, input().split())) A[L][R] += 1 # 二次元累積和 Cum = [[0 for j in range(N+1)] for i in range(N+1)] for i in range(N): for j in range(N): Cum[i+1][j+1] = Cum[i][j+1] + Cum[i+1][j] - Cum[i][j] + A[i+1][j+1] # クエリ処理 for _ in range(Q): p, q = list(map(int, input().split())) print((Cum[q][q]-Cum[p-1][q]-Cum[q][p-1]+Cum[p-1][p-1]))

N, M, Q = list(map(int, input().split())) X = [[0 for j in range(510)] for i in range(510)] C = [[0 for j in range(510)] for i in range(510)] LR = [] for i in range(M): L, R = list(map(int, input().split())) X[L][R] += 1 for i in range(1, N + 1): for j in range(1, N + 1): C[i][j] = C[i][j - 1] + X[i][j] for i in range(Q): p, q = list(map(int, input().split())) sum = 0 for j in range(p, q + 1): sum += C[j][q] - C[j][p - 1] print(sum)

N, M, Q = list(map(int, input().split())) # 入力 A = [[0 for j in range(N + 1)] for i in range(N + 1)] for _ in range(M): L, R = list(map(int, input().split())) A[L][R] += 1 # 二次元累積和 Cum = [[0 for j in range(N + 1)] for i in range(N + 1)] for i in range(N): for j in range(N): Cum[i + 1][j + 1] = Cum[i][j + 1] + Cum[i + 1][j] - Cum[i][j] + A[i + 1][j + 1] # クエリ処理 for _ in range(Q): p, q = list(map(int, input().split())) print((Cum[q][q] - Cum[p - 1][q] - Cum[q][p - 1] + Cum[p - 1][p - 1]))

u204208382

p02707

python

s277231955

s449161522

Accepted

Accepted

import collections n = int(eval(input())) a = list(map(int, input().split())) a.sort() a = collections.deque(a) counter = 0 for i in range(1, n+1): while len(a) != 0: if i != a[0]: break counter += 1 a.popleft() print(counter) counter = 0

n = int(eval(input())) a = list(map(int, input().split())) ans = [0]*n counter = 0 for i in range(n-1): ans[a[i]-1] += 1 for i in range(n): print((ans[i]))

import collections n = int(eval(input())) a = list(map(int, input().split())) a.sort() a = collections.deque(a) counter = 0 for i in range(1, n + 1): while len(a) != 0: if i != a[0]: break counter += 1 a.popleft() print(counter) counter = 0

n = int(eval(input())) a = list(map(int, input().split())) ans = [0] * n counter = 0 for i in range(n - 1): ans[a[i] - 1] += 1 for i in range(n): print((ans[i]))

u130900604

p02678

python

s480041007

s486882513

Accepted

Accepted

def LI():return list(map(int,input().split())) def yes():print("Yes") def no():print("No") from collections import deque def main(): n,m=LI() edge=[[] for i in range(n)] for i in range(m): a,b=LI() a-=1;b-=1 edge[a].append(b) edge[b].append(a) ans=[-1]*(n) goal=deque([0]) while goal: g=goal.popleft() for i in edge[g]: if ans[i]==-1: ans[i]=g+1 goal.append(i) yes() print((*ans[1:])) main()

def LI():return list(map(int,input().split())) def yes():print("Yes") def no():print("No") from collections import deque def main(): n,m=LI() edge=[[]*n for i in range(n)] for i in range(m): a,b=LI() a-=1;b-=1 edge[a].append(b) edge[b].append(a) ans=[-1]*(n) goal=deque([0]) while goal: g=goal.popleft() for i in edge[g]: if ans[i]==-1: ans[i]=g+1 goal.append(i) yes() print((*ans[1:])) main()

def LI(): return list(map(int, input().split())) def yes(): print("Yes") def no(): print("No") from collections import deque def main(): n, m = LI() edge = [[] for i in range(n)] for i in range(m): a, b = LI() a -= 1 b -= 1 edge[a].append(b) edge[b].append(a) ans = [-1] * (n) goal = deque([0]) while goal: g = goal.popleft() for i in edge[g]: if ans[i] == -1: ans[i] = g + 1 goal.append(i) yes() print((*ans[1:])) main()

def LI(): return list(map(int, input().split())) def yes(): print("Yes") def no(): print("No") from collections import deque def main(): n, m = LI() edge = [[] * n for i in range(n)] for i in range(m): a, b = LI() a -= 1 b -= 1 edge[a].append(b) edge[b].append(a) ans = [-1] * (n) goal = deque([0]) while goal: g = goal.popleft() for i in edge[g]: if ans[i] == -1: ans[i] = g + 1 goal.append(i) yes() print((*ans[1:])) main()

u124498235

p03611

python

s148650025

s560515804

Accepted

Accepted

from collections import Counter n = int(eval(input())) a = list(map(int, input().split())) b = [i+1 for i in a] c = [i-1 for i in a] d = dict(Counter(a) + Counter(b) + Counter(c)) print((max(d.values())))

from collections import Counter n = int(eval(input())) a = list(map(int, input().split())) c = Counter(a) d = list(c.keys()) q = 1 for i in range(1,len(d)-1): if d[i+1] - d[i] == 1 and d[i] - d[i-1] == 1: s = c[d[i-1]] + c[d[i]] + c[d[i+1]] q = max(q,s) if i == 1: if d[i] - d[i-1] == 1: s = c[d[i-1]] + c[d[i]] q = max(q, s) if d[i+1] - d[i] == 1: s = c[d[i+1]] - c[d[i]] q = max(q, s) if len(d) == 1: q = c[d[0]] if len(d) == 2: if d[1] - d[0] == 1: q = c[d[1]] + c[d[0]] else: q = max(1, c[d[1]], c[d[0]]) print (q)

from collections import Counter n = int(eval(input())) a = list(map(int, input().split())) b = [i + 1 for i in a] c = [i - 1 for i in a] d = dict(Counter(a) + Counter(b) + Counter(c)) print((max(d.values())))

from collections import Counter n = int(eval(input())) a = list(map(int, input().split())) c = Counter(a) d = list(c.keys()) q = 1 for i in range(1, len(d) - 1): if d[i + 1] - d[i] == 1 and d[i] - d[i - 1] == 1: s = c[d[i - 1]] + c[d[i]] + c[d[i + 1]] q = max(q, s) if i == 1: if d[i] - d[i - 1] == 1: s = c[d[i - 1]] + c[d[i]] q = max(q, s) if d[i + 1] - d[i] == 1: s = c[d[i + 1]] - c[d[i]] q = max(q, s) if len(d) == 1: q = c[d[0]] if len(d) == 2: if d[1] - d[0] == 1: q = c[d[1]] + c[d[0]] else: q = max(1, c[d[1]], c[d[0]]) print(q)

u079022693

p02647

python

s973201327

s660896239

Accepted

Accepted

from sys import stdin import numpy as np from numba import njit def main(): #入力 readline=stdin.readline n,k=list(map(int,readline().split())) a=np.array(list(map(int,readline().split())),dtype=np.int64) cnt=0 while cnt<k: s=f(n,a) a=np.cumsum(s) cnt+=1 if a[a==n].size==n: break print((*a)) @njit(cache=True) def f(n,a): s=np.zeros(n,dtype=np.int64) for i in range(n): x_min=i-a[i] x_max=i+a[i]+1 s[max(0,x_min)]+=1 if n-1<x_max: pass else: s[x_max]-=1 return s if __name__=="__main__": main()

from sys import stdin import numpy as np from numba import njit def main(): #入力 readline=stdin.readline n,k=list(map(int,readline().split())) a=np.array(list(map(int,readline().split())),dtype=np.int64) cnt=0 while cnt<k: s=f(n,a) a=np.cumsum(s) cnt+=1 if a[a==n].size==n: break print((*a)) @njit("i8[:](i8,i8[:])",cache=True) def f(n,a): s=np.zeros(n,dtype=np.int64) for i in range(n): x_min=i-a[i] x_max=i+a[i]+1 s[max(0,x_min)]+=1 if n-1<x_max: pass else: s[x_max]-=1 return s if __name__=="__main__": main()

from sys import stdin import numpy as np from numba import njit def main(): # 入力 readline = stdin.readline n, k = list(map(int, readline().split())) a = np.array(list(map(int, readline().split())), dtype=np.int64) cnt = 0 while cnt < k: s = f(n, a) a = np.cumsum(s) cnt += 1 if a[a == n].size == n: break print((*a)) @njit(cache=True) def f(n, a): s = np.zeros(n, dtype=np.int64) for i in range(n): x_min = i - a[i] x_max = i + a[i] + 1 s[max(0, x_min)] += 1 if n - 1 < x_max: pass else: s[x_max] -= 1 return s if __name__ == "__main__": main()

from sys import stdin import numpy as np from numba import njit def main(): # 入力 readline = stdin.readline n, k = list(map(int, readline().split())) a = np.array(list(map(int, readline().split())), dtype=np.int64) cnt = 0 while cnt < k: s = f(n, a) a = np.cumsum(s) cnt += 1 if a[a == n].size == n: break print((*a)) @njit("i8[:](i8,i8[:])", cache=True) def f(n, a): s = np.zeros(n, dtype=np.int64) for i in range(n): x_min = i - a[i] x_max = i + a[i] + 1 s[max(0, x_min)] += 1 if n - 1 < x_max: pass else: s[x_max] -= 1 return s if __name__ == "__main__": main()

u714878632

p02897

python

s606102602

s456398092

Accepted

Accepted

from sys import stdin import numpy as np # noinspection PyShadowingBuiltinsInspection def main(): n = int(eval(input())) if n % 2 == 0: print((0.5)) else: m = (n + 1) / 2 print((m / n)) return if __name__ == "__main__": main()

N = int(eval(input())) if N % 2 == 0: ret = 0.5 else: ret = (N/2 + 0.5)/(N) print(ret)

from sys import stdin import numpy as np # noinspection PyShadowingBuiltinsInspection def main(): n = int(eval(input())) if n % 2 == 0: print((0.5)) else: m = (n + 1) / 2 print((m / n)) return if __name__ == "__main__": main()

N = int(eval(input())) if N % 2 == 0: ret = 0.5 else: ret = (N / 2 + 0.5) / (N) print(ret)

u133936772

p02572

python

s544933836

s814737831

Accepted

Accepted

M=10**9+7 n=int(eval(input())) l=[*list(map(int,input().split()))] print(((sum(i for i in l)**2-sum(i**2 for i in l))//2%M))

n,*l=list(map(int,open(0).read().split())) print(((sum(l)**2-sum(i**2 for i in l))//2%(10**9+7)))

M = 10**9 + 7 n = int(eval(input())) l = [*list(map(int, input().split()))] print(((sum(i for i in l) ** 2 - sum(i**2 for i in l)) // 2 % M))

n, *l = list(map(int, open(0).read().split())) print(((sum(l) ** 2 - sum(i**2 for i in l)) // 2 % (10**9 + 7)))

u945181840

p03583

python

s240695286

s550412193

Accepted

Accepted

N = int(eval(input())) for h in range(1, 3501): for n in range(1, 3501): mod = 4 * h * n - N * (h + n) if mod > 0: w, r = divmod(N * h * n, mod) if r == 0: print((h, n, w)) exit()

N = int(eval(input())) for h in range(N // 4, 3501): for n in range(N * h // max(1, (4 * h - N)), 3501): mod = 4 * h * n - N * (h + n) if mod > 0: w, r = divmod(N * h * n, mod) if r == 0: print((h, n, w)) exit()

N = int(eval(input())) for h in range(1, 3501): for n in range(1, 3501): mod = 4 * h * n - N * (h + n) if mod > 0: w, r = divmod(N * h * n, mod) if r == 0: print((h, n, w)) exit()

N = int(eval(input())) for h in range(N // 4, 3501): for n in range(N * h // max(1, (4 * h - N)), 3501): mod = 4 * h * n - N * (h + n) if mod > 0: w, r = divmod(N * h * n, mod) if r == 0: print((h, n, w)) exit()

u852690916

p03352

python

s994064995

s551698646

Accepted

Accepted

X=int(eval(input())) ans=1 for i in range(2,int(X**0.5)+1): j = 1 n = i while n*i <= X: n *= i j += 1 ans = max(ans, n) print(ans)

X=int(eval(input())) ans=1 for i in range(1,1000): for j in range(2,1000): t=i**j if t>X: break ans = max(ans, t) print(ans)

X = int(eval(input())) ans = 1 for i in range(2, int(X**0.5) + 1): j = 1 n = i while n * i <= X: n *= i j += 1 ans = max(ans, n) print(ans)

X = int(eval(input())) ans = 1 for i in range(1, 1000): for j in range(2, 1000): t = i**j if t > X: break ans = max(ans, t) print(ans)

u691018832

p03673

python

s173825982

s051952139

Accepted

Accepted

import math import sys input = sys.stdin.readline n = int(input()) a = list(map(int, input().split())) be = [] af = [] for i in range(math.floor(n/2)): be.append(a[n-(2*i)-1]) af.append(a[n-(2*i)-2]) af.reverse() if n%2 == 1: ans = be + [a[0]] + af else: ans = be + af for i in range(n): print(ans[i], end=' ') print('\n')

import sys read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline readlines = sys.stdin.buffer.readlines sys.setrecursionlimit(10 ** 7) from collections import deque n, *a = list(map(int, read().split())) b = deque() v = 1 if n % 2 == 0 else 0 for i, aa in enumerate(a): if i % 2 == v: b.appendleft(aa) else: b.append(aa) print((*b))

import math import sys input = sys.stdin.readline n = int(input()) a = list(map(int, input().split())) be = [] af = [] for i in range(math.floor(n / 2)): be.append(a[n - (2 * i) - 1]) af.append(a[n - (2 * i) - 2]) af.reverse() if n % 2 == 1: ans = be + [a[0]] + af else: ans = be + af for i in range(n): print(ans[i], end=" ") print("\n")

import sys read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline readlines = sys.stdin.buffer.readlines sys.setrecursionlimit(10**7) from collections import deque n, *a = list(map(int, read().split())) b = deque() v = 1 if n % 2 == 0 else 0 for i, aa in enumerate(a): if i % 2 == v: b.appendleft(aa) else: b.append(aa) print((*b))

u986399983

p03951

python

s147077160

s709455366

Accepted

Accepted

i=input;N=int(i());s=i();l=i();n=N;j=0 exec("j=max(n*(s[-n:]==l[:n]),j);n-=1;"*N);print((2*N-j))

i=raw_input;N=n=int(i());s,l,j=i(),i(),0; exec("j=max(n*(s[-n:]==l[:n]),j);n-=1;"*N); print(2*N-j)

i = input N = int(i()) s = i() l = i() n = N j = 0 exec("j=max(n*(s[-n:]==l[:n]),j);n-=1;" * N) print((2 * N - j))

i = raw_input N = n = int(i()) s, l, j = i(), i(), 0 exec("j=max(n*(s[-n:]==l[:n]),j);n-=1;" * N) print(2 * N - j)

u162911959

p02837

python

s584968879

s286274411

Accepted

Accepted

#!/usr/bin/env python3 import sys read = sys.stdin.read readline = sys.stdin.readline readlines = sys.stdin.readlines sys.setrecursionlimit(10 ** 7) N = int(readline()) tes = [[-1]*N for i in range(N)] for i in range(N): A = int(readline()) for j in range(A): x,y = list(map(int,readline().rstrip().split())) tes[i][x-1] = y cnt = 0 for i in range(2**N): hon = [0]*N for j in range(N): if (i>>j)&1: hon[j] = 1 flag = True for j in range(N): if not flag: break if hon[j]: for k in range(N): if tes[j][k] == -1: continue if tes[j][k] != hon[k]: flag = False break if flag: cnt = max(cnt,hon.count(1)) print(cnt)

#!/usr/bin/env python3 import sys read = sys.stdin.read readline = sys.stdin.readline readlines = sys.stdin.readlines sys.setrecursionlimit(10 ** 7) N = int(readline()) tes = [[] for i in range(N)] for i in range(N): A = int(readline()) for j in range(A): x,y = list(map(int,readline().rstrip().split())) tes[i].append((x-1,y)) cnt = 0 for i in range(2**N): flag = True for j in range(N): if (i>>j)&1 == 1: for x,y in tes[j]: if (i>>x)&1 != y: flag = False break if flag: cnt = max(cnt,bin(i)[2:].count("1")) print(cnt)

#!/usr/bin/env python3 import sys read = sys.stdin.read readline = sys.stdin.readline readlines = sys.stdin.readlines sys.setrecursionlimit(10**7) N = int(readline()) tes = [[-1] * N for i in range(N)] for i in range(N): A = int(readline()) for j in range(A): x, y = list(map(int, readline().rstrip().split())) tes[i][x - 1] = y cnt = 0 for i in range(2**N): hon = [0] * N for j in range(N): if (i >> j) & 1: hon[j] = 1 flag = True for j in range(N): if not flag: break if hon[j]: for k in range(N): if tes[j][k] == -1: continue if tes[j][k] != hon[k]: flag = False break if flag: cnt = max(cnt, hon.count(1)) print(cnt)

#!/usr/bin/env python3 import sys read = sys.stdin.read readline = sys.stdin.readline readlines = sys.stdin.readlines sys.setrecursionlimit(10**7) N = int(readline()) tes = [[] for i in range(N)] for i in range(N): A = int(readline()) for j in range(A): x, y = list(map(int, readline().rstrip().split())) tes[i].append((x - 1, y)) cnt = 0 for i in range(2**N): flag = True for j in range(N): if (i >> j) & 1 == 1: for x, y in tes[j]: if (i >> x) & 1 != y: flag = False break if flag: cnt = max(cnt, bin(i)[2:].count("1")) print(cnt)

u218834617

p02762

python

s250997492

s732442872

Accepted

Accepted

import sys ris=lambda:list(map(int,next(sys.stdin).split())) N,M,K=ris() adj=[set() for _ in range(N)] for _ in range(M): A,B=ris() A,B=A-1,B-1 adj[A].add(B) adj[B].add(A) colors=[-1]*N ct={} color=-1 for u in range(N): if colors[u]!=-1: continue color+=1 colors[u]=color stk=[u] while stk: u=stk.pop() ct[color]=ct.get(color,0)+1 for v in adj[u]: if colors[v]==-1: colors[v]=color stk.append(v) blk=[{*()} for _ in range(N)] for _ in range(K): A,B=ris() A,B=A-1,B-1 if colors[A]==colors[B]: blk[A].add(B) blk[B].add(A) ans=[0]*N for u in range(N): c=colors[u] g=len(adj[u]) b=len(blk[u]) k=ct[c]-1-g-b ans[u]=k print((*ans))

import sys rl=lambda:next(sys.stdin) rfs=lambda:rl().split() ris=lambda:list(map(int,rfs())) N,M,K=ris() adj=[{*()} for _ in range(N)] for _ in range(M): A,B=ris() A,B=A-1,B-1 adj[A].add(B) adj[B].add(A) c=-1 cs=[c]*N ct={} for u in range(N): if cs[u]!=-1: continue c+=1 cs[u]=c stk=[u] while stk: u=stk.pop() if c not in ct: ct[c]=0 ct[c]+=1 for v in adj[u]: if cs[v]!=-1: continue cs[v]=c stk.append(v) ans=[0]*N for u in range(N): g=ct[cs[u]]-1 f=len(adj[u]) ans[u]=g-f for _ in range(K): A,B=ris() A,B=A-1,B-1 if cs[A]==cs[B]: ans[A]-=1 ans[B]-=1 print((*ans))

import sys ris = lambda: list(map(int, next(sys.stdin).split())) N, M, K = ris() adj = [set() for _ in range(N)] for _ in range(M): A, B = ris() A, B = A - 1, B - 1 adj[A].add(B) adj[B].add(A) colors = [-1] * N ct = {} color = -1 for u in range(N): if colors[u] != -1: continue color += 1 colors[u] = color stk = [u] while stk: u = stk.pop() ct[color] = ct.get(color, 0) + 1 for v in adj[u]: if colors[v] == -1: colors[v] = color stk.append(v) blk = [{*()} for _ in range(N)] for _ in range(K): A, B = ris() A, B = A - 1, B - 1 if colors[A] == colors[B]: blk[A].add(B) blk[B].add(A) ans = [0] * N for u in range(N): c = colors[u] g = len(adj[u]) b = len(blk[u]) k = ct[c] - 1 - g - b ans[u] = k print((*ans))

import sys rl = lambda: next(sys.stdin) rfs = lambda: rl().split() ris = lambda: list(map(int, rfs())) N, M, K = ris() adj = [{*()} for _ in range(N)] for _ in range(M): A, B = ris() A, B = A - 1, B - 1 adj[A].add(B) adj[B].add(A) c = -1 cs = [c] * N ct = {} for u in range(N): if cs[u] != -1: continue c += 1 cs[u] = c stk = [u] while stk: u = stk.pop() if c not in ct: ct[c] = 0 ct[c] += 1 for v in adj[u]: if cs[v] != -1: continue cs[v] = c stk.append(v) ans = [0] * N for u in range(N): g = ct[cs[u]] - 1 f = len(adj[u]) ans[u] = g - f for _ in range(K): A, B = ris() A, B = A - 1, B - 1 if cs[A] == cs[B]: ans[A] -= 1 ans[B] -= 1 print((*ans))

u162612857

p03652

python

s444010540

s316370091

Accepted

Accepted

# chokudaiブログの典型力の話を意識しつつ考えたら思いついた! # 「ある集合の部分集合の中で、〜〜〜の値が最小になるものを求めよ」のパターン # 愚直にやると2^Nを調べねばならず無理。 # したがって「一部を調べればよい」に帰着するのが多いだろう。 # 何らかの形でソートしておいて、空集合から1つずつ付け加えるとか。全体集合から1つずつ取り去るとか。 # 今回は全体集合から1つずつ取り去るのを考えるとできる。 # 全体集合である競技m0が最多の人数p0人を集めたとする。 # すると、全ての部分集合のうち「m0を含む集合」を考えると、競技m0は必ずp0人以上集まるので解もp0以上。 # ここで「m0を含む集合」について一気に計算できていることに注意! 一撃で多数の集合について計算が終わる。 # 次に全体集合からm0を取り去ったものを考える。 # ここである競技m1が最多の人数p1人を集めたとする。すると……以下同様。 # なお複数種目の競技が同率1位になった場合は全て一度に取り除いて良い。 # これで空集合までやって、最大が最小のものを出力すればOK! n, m = list(map(int, input().split())) preference = [list([int(x) - 1 for x in input().split()]) for _ in range(n)] # 1-index → 0-index ans = n held_sports = set(range(m)) while held_sports: # 各競技に参加する人数を求める parti = [0] * m for person in range(n): for s in range(m): if preference[person][s] in held_sports: parti[preference[person][s]] += 1 break temp = max(parti) ans = min(ans, temp) # 集合から最大人数を取った要素を除外 for idx, par in enumerate(parti): if par == temp: held_sports.remove(idx) print(ans)

# chokudaiブログの典型力の話を意識しつつ考えたら思いついた! # 「ある集合の部分集合の中で、〜〜〜の値が最小になるものを求めよ」のパターン # 愚直にやると2^Nを調べねばならず無理。 # したがって「一部を調べればよい」に帰着するのが多いだろう。 # 何らかの形でソートしておいて、空集合から1つずつ付け加えるとか。全体集合から1つずつ取り去るとか。 # 今回は全体集合から1つずつ取り去るのを考えるとできる。 # 全体集合である競技m0が最多の人数p0人を集めたとする。 # すると、全ての部分集合のうち「m0を含む集合」を考えると、競技m0は必ずp0人以上集まるので解もp0以上。 # ここで「m0を含む集合」について一気に計算できていることに注意! 一撃で多数の集合について計算が終わる。 # 次に全体集合からm0を取り去ったものを考える。 # ここである競技m1が最多の人数p1人を集めたとする。すると……以下同様。 # なお複数種目の競技が同率1位になった場合は全て一度に取り除いて良い。 # これで空集合までやって、最大が最小のものを出力すればOK! n, m = list(map(int, input().split())) preference = [list([int(x) - 1 for x in input().split()]) for _ in range(n)] # 1-index → 0-index ans = n held_sports = set(range(m)) while held_sports: # 各競技に参加する人数を求める parti = [0] * m for pref in preference: for s in range(m): if pref[s] in held_sports: parti[pref[s]] += 1 break temp = max(parti) ans = min(ans, temp) # 集合から最大人数を取った要素を除外 for idx, par in enumerate(parti): if par == temp: held_sports.remove(idx) print(ans)

# chokudaiブログの典型力の話を意識しつつ考えたら思いついた! # 「ある集合の部分集合の中で、〜〜〜の値が最小になるものを求めよ」のパターン # 愚直にやると2^Nを調べねばならず無理。 # したがって「一部を調べればよい」に帰着するのが多いだろう。 # 何らかの形でソートしておいて、空集合から1つずつ付け加えるとか。全体集合から1つずつ取り去るとか。 # 今回は全体集合から1つずつ取り去るのを考えるとできる。 # 全体集合である競技m0が最多の人数p0人を集めたとする。 # すると、全ての部分集合のうち「m0を含む集合」を考えると、競技m0は必ずp0人以上集まるので解もp0以上。 # ここで「m0を含む集合」について一気に計算できていることに注意! 一撃で多数の集合について計算が終わる。 # 次に全体集合からm0を取り去ったものを考える。 # ここである競技m1が最多の人数p1人を集めたとする。すると……以下同様。 # なお複数種目の競技が同率1位になった場合は全て一度に取り除いて良い。 # これで空集合までやって、最大が最小のものを出力すればOK! n, m = list(map(int, input().split())) preference = [ list([int(x) - 1 for x in input().split()]) for _ in range(n) ] # 1-index → 0-index ans = n held_sports = set(range(m)) while held_sports: # 各競技に参加する人数を求める parti = [0] * m for person in range(n): for s in range(m): if preference[person][s] in held_sports: parti[preference[person][s]] += 1 break temp = max(parti) ans = min(ans, temp) # 集合から最大人数を取った要素を除外 for idx, par in enumerate(parti): if par == temp: held_sports.remove(idx) print(ans)

# chokudaiブログの典型力の話を意識しつつ考えたら思いついた! # 「ある集合の部分集合の中で、〜〜〜の値が最小になるものを求めよ」のパターン # 愚直にやると2^Nを調べねばならず無理。 # したがって「一部を調べればよい」に帰着するのが多いだろう。 # 何らかの形でソートしておいて、空集合から1つずつ付け加えるとか。全体集合から1つずつ取り去るとか。 # 今回は全体集合から1つずつ取り去るのを考えるとできる。 # 全体集合である競技m0が最多の人数p0人を集めたとする。 # すると、全ての部分集合のうち「m0を含む集合」を考えると、競技m0は必ずp0人以上集まるので解もp0以上。 # ここで「m0を含む集合」について一気に計算できていることに注意! 一撃で多数の集合について計算が終わる。 # 次に全体集合からm0を取り去ったものを考える。 # ここである競技m1が最多の人数p1人を集めたとする。すると……以下同様。 # なお複数種目の競技が同率1位になった場合は全て一度に取り除いて良い。 # これで空集合までやって、最大が最小のものを出力すればOK! n, m = list(map(int, input().split())) preference = [ list([int(x) - 1 for x in input().split()]) for _ in range(n) ] # 1-index → 0-index ans = n held_sports = set(range(m)) while held_sports: # 各競技に参加する人数を求める parti = [0] * m for pref in preference: for s in range(m): if pref[s] in held_sports: parti[pref[s]] += 1 break temp = max(parti) ans = min(ans, temp) # 集合から最大人数を取った要素を除外 for idx, par in enumerate(parti): if par == temp: held_sports.remove(idx) print(ans)

u052499405

p03061

python

s293203028

s264209695

Accepted

Accepted

#!/usr/bin/env python3 import sys from fractions import gcd input = sys.stdin.readline class DisjointSparseTable: def __init__(self, a): # Identity element self.e = 0 self.level = (len(a) - 1).bit_length() self.size = 2**self.level self.table = [[self.e] * self.size for _ in range(self.level)] # Set bottom first for i, item in enumerate(a): self.table[-1][i] = item self.build() def build(self): for i in range(1, self.level): step = 2**i lv = self.level - 1 - i for mid in range(step, self.size, step*2): # Forward val = self.e for j in range(step): val = gcd(self.table[-1][mid + j], val) self.table[lv][mid + j] = val # Backward val = self.e for j in range(step): val = gcd(self.table[-1][mid - 1 - j], val) self.table[lv][mid - 1 - j] = val # Returns f[l:r) def query(self, l, r): if l == r: return self.e elif l == r - 1: return self.table[-1][l] lv = self.level - (l ^ r-1).bit_length() return gcd(self.table[lv][l], self.table[lv][r-1]) if __name__ == "__main__": n = int(eval(input())) a = [int(item) for item in input().split()] DST = DisjointSparseTable(a) ans = 0 for i in range(0, n): ans = max(ans, gcd(DST.query(0, i), DST.query(i+1, n))) print(ans)

#!/usr/bin/env python3 import sys from fractions import gcd input = sys.stdin.readline class DisjointSparseTable: def __init__(self, a): # Identity element self.e = 0 self.n = len(a) self.level = (len(a) - 1).bit_length() self.size = 2**self.level self.table = [[self.e] * self.size for _ in range(self.level)] # Set bottom first for i, item in enumerate(a): self.table[-1][i] = item self.build() def build(self): for i in range(1, self.level): step = 2**i lv = self.level - 1 - i for mid in range(step, self.size, step*2): if mid - step >= self.n: continue # Forward val = self.e for j in range(step): val = gcd(self.table[-1][mid + j], val) self.table[lv][mid + j] = val # Backward val = self.e for j in range(step): val = gcd(self.table[-1][mid - 1 - j], val) self.table[lv][mid - 1 - j] = val # Returns f[l:r) def query(self, l, r): if l == r: return self.e elif l == r - 1: return self.table[-1][l] lv = self.level - (l ^ r-1).bit_length() return gcd(self.table[lv][l], self.table[lv][r-1]) if __name__ == "__main__": n = int(eval(input())) a = [int(item) for item in input().split()] DST = DisjointSparseTable(a) ans = 0 for i in range(0, n): ans = max(ans, gcd(DST.query(0, i), DST.query(i+1, n))) print(ans)

#!/usr/bin/env python3 import sys from fractions import gcd input = sys.stdin.readline class DisjointSparseTable: def __init__(self, a): # Identity element self.e = 0 self.level = (len(a) - 1).bit_length() self.size = 2**self.level self.table = [[self.e] * self.size for _ in range(self.level)] # Set bottom first for i, item in enumerate(a): self.table[-1][i] = item self.build() def build(self): for i in range(1, self.level): step = 2**i lv = self.level - 1 - i for mid in range(step, self.size, step * 2): # Forward val = self.e for j in range(step): val = gcd(self.table[-1][mid + j], val) self.table[lv][mid + j] = val # Backward val = self.e for j in range(step): val = gcd(self.table[-1][mid - 1 - j], val) self.table[lv][mid - 1 - j] = val # Returns f[l:r) def query(self, l, r): if l == r: return self.e elif l == r - 1: return self.table[-1][l] lv = self.level - (l ^ r - 1).bit_length() return gcd(self.table[lv][l], self.table[lv][r - 1]) if __name__ == "__main__": n = int(eval(input())) a = [int(item) for item in input().split()] DST = DisjointSparseTable(a) ans = 0 for i in range(0, n): ans = max(ans, gcd(DST.query(0, i), DST.query(i + 1, n))) print(ans)

#!/usr/bin/env python3 import sys from fractions import gcd input = sys.stdin.readline class DisjointSparseTable: def __init__(self, a): # Identity element self.e = 0 self.n = len(a) self.level = (len(a) - 1).bit_length() self.size = 2**self.level self.table = [[self.e] * self.size for _ in range(self.level)] # Set bottom first for i, item in enumerate(a): self.table[-1][i] = item self.build() def build(self): for i in range(1, self.level): step = 2**i lv = self.level - 1 - i for mid in range(step, self.size, step * 2): if mid - step >= self.n: continue # Forward val = self.e for j in range(step): val = gcd(self.table[-1][mid + j], val) self.table[lv][mid + j] = val # Backward val = self.e for j in range(step): val = gcd(self.table[-1][mid - 1 - j], val) self.table[lv][mid - 1 - j] = val # Returns f[l:r) def query(self, l, r): if l == r: return self.e elif l == r - 1: return self.table[-1][l] lv = self.level - (l ^ r - 1).bit_length() return gcd(self.table[lv][l], self.table[lv][r - 1]) if __name__ == "__main__": n = int(eval(input())) a = [int(item) for item in input().split()] DST = DisjointSparseTable(a) ans = 0 for i in range(0, n): ans = max(ans, gcd(DST.query(0, i), DST.query(i + 1, n))) print(ans)

u905203728

p03286

python

s894649389

s669081971

Accepted

Accepted

n=int(eval(input())) ans="" if n==0:print("0");exit() while n!=0: ans +=str(n%2) n=-(n//2) print(("".join(ans[::-1])))

n=int(eval(input())) ans="" if n==0:print((0));exit() while n!=0: ans +=str(n%2) n=-(n//2) print((ans[::-1]))

n = int(eval(input())) ans = "" if n == 0: print("0") exit() while n != 0: ans += str(n % 2) n = -(n // 2) print(("".join(ans[::-1])))

n = int(eval(input())) ans = "" if n == 0: print((0)) exit() while n != 0: ans += str(n % 2) n = -(n // 2) print((ans[::-1]))

u543954314

p02975

python

s949800185

s696545240

Accepted

Accepted

n = int(eval(input())) l = list(map(int,input().split())) if not any(l): print("Yes") elif n%3 != 0: print("No") else: nx = n//3 d = dict() for x in l: if x not in d: d[x] = 0 d[x] += 1 for x in d: if d[x] != nx and d[x] !=2*nx: print("No") break else: s = 0 for x in d: if d[x] == nx: s ^= x if s == 0: print("Yes") else: print("No")

n = eval(input()) s = list(map(int, input().split())) a = 0 for x in s: a ^= x if a==0: print("Yes") else: print("No")

n = int(eval(input())) l = list(map(int, input().split())) if not any(l): print("Yes") elif n % 3 != 0: print("No") else: nx = n // 3 d = dict() for x in l: if x not in d: d[x] = 0 d[x] += 1 for x in d: if d[x] != nx and d[x] != 2 * nx: print("No") break else: s = 0 for x in d: if d[x] == nx: s ^= x if s == 0: print("Yes") else: print("No")

n = eval(input()) s = list(map(int, input().split())) a = 0 for x in s: a ^= x if a == 0: print("Yes") else: print("No")

u670961163

p02597

python

s528857812

s771820415

Accepted

Accepted

def main(): n = int(eval(input())) s = eval(input()) wcount = s.count("W") rcount = s.count("R") ans = 0 for i in range(rcount): if s[i] == "W": ans+=1 print(ans) if __name__ == "__main__": main()

def main(): n = int(eval(input())) s = eval(input()) rcount = s.count('R') diff = s[0:rcount].count("W") print(diff) if __name__ == "__main__": main()

def main(): n = int(eval(input())) s = eval(input()) wcount = s.count("W") rcount = s.count("R") ans = 0 for i in range(rcount): if s[i] == "W": ans += 1 print(ans) if __name__ == "__main__": main()

def main(): n = int(eval(input())) s = eval(input()) rcount = s.count("R") diff = s[0:rcount].count("W") print(diff) if __name__ == "__main__": main()

u094999522

p03645

python

s893895868

s488270759

Accepted

Accepted

#!/usr/bin/env python3 from collections import deque n, m = list(map(int, input().split())) graph = [deque([]) for _ in range(n + 1)] for _ in range(m): a, b = list(map(int, input().split())) graph[a].append(b) graph[b].append(a) for i in graph[1]: if n in graph[i]: print("POSSIBLE") exit() print("IMPOSSIBLE")

#!/usr/bin/env python3 n, m = input().split() a = set() b = set() for _ in range(int(m)): r = set(input().split()) if "1" in r: a |= r if n in r: b |= r print(("POSSIBLE" if len(a & b) > 0 else "IMPOSSIBLE"))

#!/usr/bin/env python3 from collections import deque n, m = list(map(int, input().split())) graph = [deque([]) for _ in range(n + 1)] for _ in range(m): a, b = list(map(int, input().split())) graph[a].append(b) graph[b].append(a) for i in graph[1]: if n in graph[i]: print("POSSIBLE") exit() print("IMPOSSIBLE")

#!/usr/bin/env python3 n, m = input().split() a = set() b = set() for _ in range(int(m)): r = set(input().split()) if "1" in r: a |= r if n in r: b |= r print(("POSSIBLE" if len(a & b) > 0 else "IMPOSSIBLE"))

u133936772

p02748

python

s286328293

s800849800

Accepted

Accepted

f=lambda:list(map(int,input().split())) _,_,n=f() a,b=list(f()),list(f()) m=min(a)+min(b) for _ in range(n): x,y,c=f(); m=min(m,a[x-1]+b[y-1]-c) print(m)

import sys f=lambda:list(map(int,sys.stdin.readline().split())) _,_,n=f() a,b=list(f()),list(f()) m=min(a)+min(b) for _ in range(n): x,y,c=f(); m=min(m,a[x-1]+b[y-1]-c) print(m)

f = lambda: list(map(int, input().split())) _, _, n = f() a, b = list(f()), list(f()) m = min(a) + min(b) for _ in range(n): x, y, c = f() m = min(m, a[x - 1] + b[y - 1] - c) print(m)

import sys f = lambda: list(map(int, sys.stdin.readline().split())) _, _, n = f() a, b = list(f()), list(f()) m = min(a) + min(b) for _ in range(n): x, y, c = f() m = min(m, a[x - 1] + b[y - 1] - c) print(m)

u814271993

p02597

python

s349727698

s154251672

Accepted

Accepted

n=int(eval(input())) c=eval(input()) r=c.count("R") r_1=c[:r].count("R") ans=r-r_1 print(ans)

n=int(eval(input())) s = eval(input()) Ra = s.count('R') t = s[:Ra] Rb = t.count('R') print((Ra-Rb))

n = int(eval(input())) c = eval(input()) r = c.count("R") r_1 = c[:r].count("R") ans = r - r_1 print(ans)

n = int(eval(input())) s = eval(input()) Ra = s.count("R") t = s[:Ra] Rb = t.count("R") print((Ra - Rb))

u888092736

p02609

python

s955581176

s694376532

Accepted

Accepted

def pop_count(n): return sum(n >> i & 1 for i in range(n.bit_length())) def f(n): if n == 0: return 0 return f(n % pop_count(n)) + 1 N = int(eval(input())) X = eval(input()) p = X.count("1") rem_plus = 0 rem_minus = 0 for i in range(N): k = N - i - 1 if X[i] == "0": continue elif p > 1: rem_minus = (rem_minus + pow(2, k, p - 1)) % (p - 1) rem_plus = (rem_plus + pow(2, k, p + 1)) % (p + 1) for i in range(N): k = N - i - 1 if X[i] == "0": print((f((rem_plus + pow(2, k, p + 1)) % (p + 1)) + 1)) elif p > 1: print((f((rem_minus - pow(2, k, p - 1)) % (p - 1)) + 1)) else: print((0))

def f(n): if n == 0: return 0 return f(n % bin(n).count("1")) + 1 N = int(eval(input())) X = eval(input()) p = X.count("1") rem_plus = 0 rem_minus = 0 for i in range(N): k = N - i - 1 if X[i] == "0": continue elif p > 1: rem_minus = (rem_minus + pow(2, k, p - 1)) % (p - 1) rem_plus = (rem_plus + pow(2, k, p + 1)) % (p + 1) for i in range(N): k = N - i - 1 if X[i] == "0": print((f((rem_plus + pow(2, k, p + 1)) % (p + 1)) + 1)) elif p > 1: print((f((rem_minus - pow(2, k, p - 1)) % (p - 1)) + 1)) else: print((0))

def pop_count(n): return sum(n >> i & 1 for i in range(n.bit_length())) def f(n): if n == 0: return 0 return f(n % pop_count(n)) + 1 N = int(eval(input())) X = eval(input()) p = X.count("1") rem_plus = 0 rem_minus = 0 for i in range(N): k = N - i - 1 if X[i] == "0": continue elif p > 1: rem_minus = (rem_minus + pow(2, k, p - 1)) % (p - 1) rem_plus = (rem_plus + pow(2, k, p + 1)) % (p + 1) for i in range(N): k = N - i - 1 if X[i] == "0": print((f((rem_plus + pow(2, k, p + 1)) % (p + 1)) + 1)) elif p > 1: print((f((rem_minus - pow(2, k, p - 1)) % (p - 1)) + 1)) else: print((0))

def f(n): if n == 0: return 0 return f(n % bin(n).count("1")) + 1 N = int(eval(input())) X = eval(input()) p = X.count("1") rem_plus = 0 rem_minus = 0 for i in range(N): k = N - i - 1 if X[i] == "0": continue elif p > 1: rem_minus = (rem_minus + pow(2, k, p - 1)) % (p - 1) rem_plus = (rem_plus + pow(2, k, p + 1)) % (p + 1) for i in range(N): k = N - i - 1 if X[i] == "0": print((f((rem_plus + pow(2, k, p + 1)) % (p + 1)) + 1)) elif p > 1: print((f((rem_minus - pow(2, k, p - 1)) % (p - 1)) + 1)) else: print((0))

u630211216

p02684

python

s278667883

s202897892

Accepted

Accepted

N,K=list(map(int,input().split())) A=list(map(int,input().split())) move=[] for i in range(0,N): move.append([]) A[i]-=1 move[i].append(A[i]) for j in range(1,64): for i in range(0,N): move[i].append(move[move[i][j-1]][j-1]) town=0 for i in range(0,64): if K%2==1: town=move[town][i] K//=2 print((town+1))

N,K=list(map(int,input().split())) A=list(map(int,input().split())) cycle=[] for i in range(0,N): cycle.append(-1) A[i]-=1 count=0 cycle[0]=count town=0 mod=0 while True: count+=1 K-=1 town=A[town] if K==0: mod=1 break if cycle[town]==-1: cycle[town]=count else: mod=count-cycle[town] break K%=mod while K>0: town=A[town] K-=1 print((town+1))

N, K = list(map(int, input().split())) A = list(map(int, input().split())) move = [] for i in range(0, N): move.append([]) A[i] -= 1 move[i].append(A[i]) for j in range(1, 64): for i in range(0, N): move[i].append(move[move[i][j - 1]][j - 1]) town = 0 for i in range(0, 64): if K % 2 == 1: town = move[town][i] K //= 2 print((town + 1))

N, K = list(map(int, input().split())) A = list(map(int, input().split())) cycle = [] for i in range(0, N): cycle.append(-1) A[i] -= 1 count = 0 cycle[0] = count town = 0 mod = 0 while True: count += 1 K -= 1 town = A[town] if K == 0: mod = 1 break if cycle[town] == -1: cycle[town] = count else: mod = count - cycle[town] break K %= mod while K > 0: town = A[town] K -= 1 print((town + 1))

u759434129

p02996

python

s315681649

s824736944

Accepted

Accepted

n = eval(input()) l = [] for i in range(n): a, b = list(map(int, input().split())) l.append((b, -a)) curtime = 0 l.sort() for i in l: if curtime - i[1] > i[0]: print("No") exit(0) else: curtime -= i[1] print("Yes")

n = eval(input()) l = [] for i in range(n): a, b = list(map(int, input().split())) l.append((b, a)) curtime = 0 l.sort() for i in l: if curtime + i[1] > i[0]: print("No") exit(0) else: curtime += i[1] print("Yes")

n = eval(input()) l = [] for i in range(n): a, b = list(map(int, input().split())) l.append((b, -a)) curtime = 0 l.sort() for i in l: if curtime - i[1] > i[0]: print("No") exit(0) else: curtime -= i[1] print("Yes")

n = eval(input()) l = [] for i in range(n): a, b = list(map(int, input().split())) l.append((b, a)) curtime = 0 l.sort() for i in l: if curtime + i[1] > i[0]: print("No") exit(0) else: curtime += i[1] print("Yes")

u172147273

p02720

python

s194937304

s604621308

Accepted

Accepted

import queue q=queue.Queue() K=int(eval(input())) for i in range(1,10):q.put(i) while(not q.empty()): a=q.get() K-=1 if K==0: print(a) exit() for i in range(a%10-1,a%10+1+1): if i<0 or i>9:continue q.put(a*10+i)

import collections ans=[] s=collections.deque() k=int(eval(input())) ans.append(1) for i in range(1,k): for x in str(ans[i-1]): s.append(int(x)) ls=len(s)-1 while ls>=0 and s[ls]==9: s[ls]=0 ls-=1 if ls==-1:s.appendleft(1) else:s[ls]+=1 while True: b=-1 for i in range(0,len(s)-1): if abs(s[i+1]-s[i])>1: b=i break if b==-1:break if s[b+1]>s[b]:s[b]+=1 l=max(s[b]-1,0) for i in range(b+1,len(s)): s[i]=l l=max(l-1,0) #print(s) t=0 while len(s)>=1: x=s.popleft() #print("*",x) t=t*10+x ans.append(t) print((ans[k-1]))

import queue q = queue.Queue() K = int(eval(input())) for i in range(1, 10): q.put(i) while not q.empty(): a = q.get() K -= 1 if K == 0: print(a) exit() for i in range(a % 10 - 1, a % 10 + 1 + 1): if i < 0 or i > 9: continue q.put(a * 10 + i)

import collections ans = [] s = collections.deque() k = int(eval(input())) ans.append(1) for i in range(1, k): for x in str(ans[i - 1]): s.append(int(x)) ls = len(s) - 1 while ls >= 0 and s[ls] == 9: s[ls] = 0 ls -= 1 if ls == -1: s.appendleft(1) else: s[ls] += 1 while True: b = -1 for i in range(0, len(s) - 1): if abs(s[i + 1] - s[i]) > 1: b = i break if b == -1: break if s[b + 1] > s[b]: s[b] += 1 l = max(s[b] - 1, 0) for i in range(b + 1, len(s)): s[i] = l l = max(l - 1, 0) # print(s) t = 0 while len(s) >= 1: x = s.popleft() # print("*",x) t = t * 10 + x ans.append(t) print((ans[k - 1]))

u329565519

p03220

python

s413661909

s766815643

Accepted

Accepted

N = int(eval(input())) T, A = list(map(int, input().split())) H = list(map(int, input().split())) mn = None for i, h in enumerate(H): d = abs(A - (T - h * 0.006)) mn = (i, d) if mn is None or mn[1] > d else mn print((mn[0] + 1))

N = int(eval(input())) T, A = list(map(int, input().split())) H = list(map(int, input().split())) mn = None for i in range(N): x = abs(A - (T - H[i] * 0.006)) if mn is None or x < mn[1]: mn = (i, x) print((mn[0] + 1))

N = int(eval(input())) T, A = list(map(int, input().split())) H = list(map(int, input().split())) mn = None for i, h in enumerate(H): d = abs(A - (T - h * 0.006)) mn = (i, d) if mn is None or mn[1] > d else mn print((mn[0] + 1))

N = int(eval(input())) T, A = list(map(int, input().split())) H = list(map(int, input().split())) mn = None for i in range(N): x = abs(A - (T - H[i] * 0.006)) if mn is None or x < mn[1]: mn = (i, x) print((mn[0] + 1))

u466335531

p03338

python

s973128080

s666564913

Accepted

Accepted

N=int(eval(input())) S=eval(input()) #Tに含まれた文字の種類を数える def countletter(T): S=[] for t in T: if t not in S: S.append(t) return len(S) ans=0 for i in range(1,N): A=S[:i] B=S[i:] ans=max(ans,countletter(A)+countletter(B)-countletter(S)) print(ans)

N=int(eval(input())) S=eval(input()) ans=0 for i in range(1,N): A=set(S[:i]) B=set(S[i:]) ans=max(ans,len(A&B)) print(ans)

N = int(eval(input())) S = eval(input()) # Tに含まれた文字の種類を数える def countletter(T): S = [] for t in T: if t not in S: S.append(t) return len(S) ans = 0 for i in range(1, N): A = S[:i] B = S[i:] ans = max(ans, countletter(A) + countletter(B) - countletter(S)) print(ans)

N = int(eval(input())) S = eval(input()) ans = 0 for i in range(1, N): A = set(S[:i]) B = set(S[i:]) ans = max(ans, len(A & B)) print(ans)

u992910889

p03999

python

s769374647

s777777103

Accepted

Accepted

import sys sys.setrecursionlimit(10 ** 5 + 10) def input(): return sys.stdin.readline().strip() def resolve(): S = str(eval(input())) ls=len(S) # bit全探索 # https://qiita.com/gogotealove/items/11f9e83218926211083a#%E4%BE%8B%E9%A1%8C-1 n = ls-1 # 昇順での探索だよ val = 0 for i in range(2 ** n): split=[] for j in range(n): # このループが一番のポイント if ((i >> j) & 1): # 順に右にシフトさせ最下位bitのチェックを行う split.append(j) temp=0 for k in range(len(split)): val+=int(S[temp:split[k]+1]) temp=split[k]+1 if k==len(split)-1: val+=int(S[split[k]+1:]) print((val+int(S))) resolve()

import sys sys.setrecursionlimit(10 ** 5 + 10) def input(): return sys.stdin.readline().strip() def resolve(): def main(): S=str(eval(input())) # bit全探索 # https://qiita.com/gogotealove/items/11f9e83218926211083a#%E4%BE%8B%E9%A1%8C-1 n = len(S)-1 if n==0: return int(S) else: # 昇順での探索だよ ans=0 for i in range(2 ** n): temp = n+1 for j in range(n): # このループが一番のポイント if ((i >> j) & 1): ans+=int(S[-j-1:temp]) temp=-j-1 if j==n-1: ans+=int(S[:temp])# 順 return ans# に右にシフトさせ最下位bitのチェックを行う print((main())) resolve()

import sys sys.setrecursionlimit(10**5 + 10) def input(): return sys.stdin.readline().strip() def resolve(): S = str(eval(input())) ls = len(S) # bit全探索 # https://qiita.com/gogotealove/items/11f9e83218926211083a#%E4%BE%8B%E9%A1%8C-1 n = ls - 1 # 昇順での探索だよ val = 0 for i in range(2**n): split = [] for j in range(n): # このループが一番のポイント if (i >> j) & 1: # 順に右にシフトさせ最下位bitのチェックを行う split.append(j) temp = 0 for k in range(len(split)): val += int(S[temp : split[k] + 1]) temp = split[k] + 1 if k == len(split) - 1: val += int(S[split[k] + 1 :]) print((val + int(S))) resolve()

import sys sys.setrecursionlimit(10**5 + 10) def input(): return sys.stdin.readline().strip() def resolve(): def main(): S = str(eval(input())) # bit全探索 # https://qiita.com/gogotealove/items/11f9e83218926211083a#%E4%BE%8B%E9%A1%8C-1 n = len(S) - 1 if n == 0: return int(S) else: # 昇順での探索だよ ans = 0 for i in range(2**n): temp = n + 1 for j in range(n): # このループが一番のポイント if (i >> j) & 1: ans += int(S[-j - 1 : temp]) temp = -j - 1 if j == n - 1: ans += int(S[:temp]) # 順 return ans # に右にシフトさせ最下位bitのチェックを行う print((main())) resolve()

u342869120

p02623

python

s334112152

s833831266

Accepted

Accepted

import bisect N, M, K = list(map(int, input().split())) *A, = list(map(int, input().split())) *B, = list(map(int, input().split())) for i in range(1, N): A[i] += A[i-1] for i in range(1, M): B[i] += B[i-1] A = [0]+A ans = 0 for i in range(N+1): b = K-A[i] if b < 0: break j = bisect.bisect_right(B, b) if ans < (i+j): ans = i+j print(ans)

N, M, K = list(map(int, input().split())) *A, = list(map(int, input().split())) *B, = list(map(int, input().split())) for i in range(1, N): A[i] += A[i-1] for i in range(1, M): B[i] += B[i-1] A = [0]+A B = [0]+B j = M ans = 0 for i in range(N+1): k = K-A[i] if k < 0: break while B[j] > k: j -= 1 ans = max(ans, i+j) print(ans)

import bisect N, M, K = list(map(int, input().split())) (*A,) = list(map(int, input().split())) (*B,) = list(map(int, input().split())) for i in range(1, N): A[i] += A[i - 1] for i in range(1, M): B[i] += B[i - 1] A = [0] + A ans = 0 for i in range(N + 1): b = K - A[i] if b < 0: break j = bisect.bisect_right(B, b) if ans < (i + j): ans = i + j print(ans)

N, M, K = list(map(int, input().split())) (*A,) = list(map(int, input().split())) (*B,) = list(map(int, input().split())) for i in range(1, N): A[i] += A[i - 1] for i in range(1, M): B[i] += B[i - 1] A = [0] + A B = [0] + B j = M ans = 0 for i in range(N + 1): k = K - A[i] if k < 0: break while B[j] > k: j -= 1 ans = max(ans, i + j) print(ans)

u808429775

p00118

python

s278697705

s391092316

Accepted

Accepted

def Labeling(terrain): label = terrain offset = [[-1, 0], [0, -1], [1, 0], [0, 1]] signs = ["@", "#", "*"] step = 0 for row in range(1, len(label) - 1): for col in range(1, len(label[row]) - 1): mark = label[row][col] if mark in signs: pointStack = [[row, col]] label[row][col] = step while 0 < len(pointStack): rowIndex, colIndex = pointStack.pop() for x, y in offset: offsetRow, offsetCol = rowIndex + x, colIndex + y if label[offsetRow][offsetCol] == mark: pointStack.append([offsetRow, offsetCol]) label[offsetRow][offsetCol] = step step += 1 return step Sentinel = "1" while True: col, row = [int(item) for item in input().split()] if row == 0 and col == 0: break land = [] land.append([item for item in Sentinel * row + Sentinel * 2]) for lp in range(col): part = [item for item in eval(input())] land.append([]) land[-1].extend([Sentinel]) land[-1].extend(part) land[-1].extend([Sentinel]) land.append([item for item in Sentinel * row + Sentinel * 2]) result = Labeling(land) print(result)

def Labeling(terrain): label = terrain offset = [[-1, 0], [0, -1], [1, 0], [0, 1]] signs = ["@", "#", "*"] rowLength, colLength = len(label) - 1, len(label[0]) - 1 step = 0 for row in range(1, rowLength): for col in range(1, colLength): mark = label[row][col] if mark in signs: pointStack = [[row, col]] label[row][col] = step while 0 < len(pointStack): rowIndex, colIndex = pointStack.pop() for x, y in offset: offsetRow, offsetCol = rowIndex + x, colIndex + y if label[offsetRow][offsetCol] == mark: pointStack.append([offsetRow, offsetCol]) label[offsetRow][offsetCol] = step step += 1 return step Sentinel = "1" while True: col, row = [int(item) for item in input().split()] if row == 0 and col == 0: break land = [] land.append([item for item in Sentinel * row + Sentinel * 2]) for lp in range(col): part = [item for item in eval(input())] land.append([]) land[-1].extend([Sentinel]) land[-1].extend(part) land[-1].extend([Sentinel]) land.append([item for item in Sentinel * row + Sentinel * 2]) result = Labeling(land) print(result)

def Labeling(terrain): label = terrain offset = [[-1, 0], [0, -1], [1, 0], [0, 1]] signs = ["@", "#", "*"] step = 0 for row in range(1, len(label) - 1): for col in range(1, len(label[row]) - 1): mark = label[row][col] if mark in signs: pointStack = [[row, col]] label[row][col] = step while 0 < len(pointStack): rowIndex, colIndex = pointStack.pop() for x, y in offset: offsetRow, offsetCol = rowIndex + x, colIndex + y if label[offsetRow][offsetCol] == mark: pointStack.append([offsetRow, offsetCol]) label[offsetRow][offsetCol] = step step += 1 return step Sentinel = "1" while True: col, row = [int(item) for item in input().split()] if row == 0 and col == 0: break land = [] land.append([item for item in Sentinel * row + Sentinel * 2]) for lp in range(col): part = [item for item in eval(input())] land.append([]) land[-1].extend([Sentinel]) land[-1].extend(part) land[-1].extend([Sentinel]) land.append([item for item in Sentinel * row + Sentinel * 2]) result = Labeling(land) print(result)

def Labeling(terrain): label = terrain offset = [[-1, 0], [0, -1], [1, 0], [0, 1]] signs = ["@", "#", "*"] rowLength, colLength = len(label) - 1, len(label[0]) - 1 step = 0 for row in range(1, rowLength): for col in range(1, colLength): mark = label[row][col] if mark in signs: pointStack = [[row, col]] label[row][col] = step while 0 < len(pointStack): rowIndex, colIndex = pointStack.pop() for x, y in offset: offsetRow, offsetCol = rowIndex + x, colIndex + y if label[offsetRow][offsetCol] == mark: pointStack.append([offsetRow, offsetCol]) label[offsetRow][offsetCol] = step step += 1 return step Sentinel = "1" while True: col, row = [int(item) for item in input().split()] if row == 0 and col == 0: break land = [] land.append([item for item in Sentinel * row + Sentinel * 2]) for lp in range(col): part = [item for item in eval(input())] land.append([]) land[-1].extend([Sentinel]) land[-1].extend(part) land[-1].extend([Sentinel]) land.append([item for item in Sentinel * row + Sentinel * 2]) result = Labeling(land) print(result)

u330661451

p03013

python

s095252435

s001080309

Accepted

Accepted

MOD = 1000000007 n , m = list(map(int,input().split())) a = [0 for i in range(n+1)] for i in range(m): a[int(eval(input()))] = 1 count = [0 for i in range(n+1)] for i in range(1,n+1): if a[i] == 1: continue if i == 1: count[i] = 1 elif i == 2: count[i] = count[i-1] + 1 else: count[i] = (count[i-1] + count[i-2]) % MOD print((count[n]))

import sys MOD = 1000000007 n , m = list(map(int,input().split())) count = [0 for i in range(n+1)] nxt = 0 def scount(s,e): #print(s,e,file=sys.stderr) global count for i in range(s,e): if i == 0: count[i] = 1 elif i == 1: count[i] = 1 else: count[i] = (count[i-1] + count[i-2]) % MOD for i in range(m): a = int(eval(input())) if nxt == a: print((0)) exit(0) scount(nxt,a) nxt = a+1 scount(nxt,n+1) #print(count,file=sys.stderr) print((count[n]))

MOD = 1000000007 n, m = list(map(int, input().split())) a = [0 for i in range(n + 1)] for i in range(m): a[int(eval(input()))] = 1 count = [0 for i in range(n + 1)] for i in range(1, n + 1): if a[i] == 1: continue if i == 1: count[i] = 1 elif i == 2: count[i] = count[i - 1] + 1 else: count[i] = (count[i - 1] + count[i - 2]) % MOD print((count[n]))

import sys MOD = 1000000007 n, m = list(map(int, input().split())) count = [0 for i in range(n + 1)] nxt = 0 def scount(s, e): # print(s,e,file=sys.stderr) global count for i in range(s, e): if i == 0: count[i] = 1 elif i == 1: count[i] = 1 else: count[i] = (count[i - 1] + count[i - 2]) % MOD for i in range(m): a = int(eval(input())) if nxt == a: print((0)) exit(0) scount(nxt, a) nxt = a + 1 scount(nxt, n + 1) # print(count,file=sys.stderr) print((count[n]))

u078349616

p02725

python

s352509496

s234142252

Accepted

Accepted

K, N = list(map(int, input().split())) A = list(map(int,input().split())) for i in range(N): A.append(A[i]+K) d = [0]*(N) max_d, max_i = 0, -1 for i in range(N): d[i] = A[i+1] - A[i] if d[i] > max_d: max_d = d[i] max_i = i + 1 ans = 0 for i in range(N-1): ans += A[i+max_i+1] - A[i+max_i] print(ans)

K, N = list(map(int, input().split())) A = list(map(int,input().split())) A.append(A[0] + K) d = 0 for i in range(N): d = max(d, A[i+1] - A[i]) print((K - d))

K, N = list(map(int, input().split())) A = list(map(int, input().split())) for i in range(N): A.append(A[i] + K) d = [0] * (N) max_d, max_i = 0, -1 for i in range(N): d[i] = A[i + 1] - A[i] if d[i] > max_d: max_d = d[i] max_i = i + 1 ans = 0 for i in range(N - 1): ans += A[i + max_i + 1] - A[i + max_i] print(ans)

K, N = list(map(int, input().split())) A = list(map(int, input().split())) A.append(A[0] + K) d = 0 for i in range(N): d = max(d, A[i + 1] - A[i]) print((K - d))

u762420987

p02820

python

s164422768

s827539629

Accepted

Accepted

N, K = list(map(int, input().split())) R, S, P = list(map(int, input().split())) T = list(eval(input())) sp_T = [] for i in range(K): sp_T.append(T[i::K]) ans = 0 win_d = {"s": "r", "r": "p", "p": "s"} point = {"r": R, "s": S, "p": P} for t in sp_T: sakki = "" for i in range(len(t)): if win_d[t[i]] != sakki: my_hand = win_d[t[i]] ans += point[my_hand] sakki = my_hand else: if i == len(t) - 1: pass else: next_want_hand = win_d[t[i + 1]] if sakki == next_want_hand: sakki = "X" else: sakki = "X" print(ans)

N, K = list(map(int, input().split())) R, S, P = list(map(int, input().split())) score = {"r": P, "s": R, "p": S, "x": 0} T = eval(input()) ans = 0 for i in range(K): temp = [] for j in range(i, N, K): if not temp: temp.append(T[j]) else: if temp[-1] == T[j]: temp.append("x") else: temp.append(T[j]) ans += score[temp[-1]] print(ans)

N, K = list(map(int, input().split())) R, S, P = list(map(int, input().split())) T = list(eval(input())) sp_T = [] for i in range(K): sp_T.append(T[i::K]) ans = 0 win_d = {"s": "r", "r": "p", "p": "s"} point = {"r": R, "s": S, "p": P} for t in sp_T: sakki = "" for i in range(len(t)): if win_d[t[i]] != sakki: my_hand = win_d[t[i]] ans += point[my_hand] sakki = my_hand else: if i == len(t) - 1: pass else: next_want_hand = win_d[t[i + 1]] if sakki == next_want_hand: sakki = "X" else: sakki = "X" print(ans)

N, K = list(map(int, input().split())) R, S, P = list(map(int, input().split())) score = {"r": P, "s": R, "p": S, "x": 0} T = eval(input()) ans = 0 for i in range(K): temp = [] for j in range(i, N, K): if not temp: temp.append(T[j]) else: if temp[-1] == T[j]: temp.append("x") else: temp.append(T[j]) ans += score[temp[-1]] print(ans)

u775681539

p03038

python

s925228336

s935090246

Accepted

Accepted

#python3 from heapq import heappop, heappush def main(): n, m = list(map(int, input().split())) hq = [] for i in input().split(): heappush(hq, (-int(i), 1)) for _ in range(m): b, c = list(map(int, input().split())) heappush(hq, (-c, b)) ans = 0 for i in range(n): v, u = heappop(hq) u = u - 1 if u >= 1: heappush(hq, (v, u)) v = - v ans = ans + v print(ans) main()

#python3 def main(): n, m = list(map(int, input().split())) cards = [(int(i), 1) for i in input().split()] for _ in range(m): b, c = list(map(int, input().split())) cards.append((c, b)) cards.sort(reverse=True) ans = 0 sumv = 0 for i in range(n): v = cards[i][1] cv = cards[i][0] * v ans += cv sumv += v if sumv >= n: ans -= cards[i][0] * (sumv - n) break print(ans) main()

# python3 from heapq import heappop, heappush def main(): n, m = list(map(int, input().split())) hq = [] for i in input().split(): heappush(hq, (-int(i), 1)) for _ in range(m): b, c = list(map(int, input().split())) heappush(hq, (-c, b)) ans = 0 for i in range(n): v, u = heappop(hq) u = u - 1 if u >= 1: heappush(hq, (v, u)) v = -v ans = ans + v print(ans) main()

# python3 def main(): n, m = list(map(int, input().split())) cards = [(int(i), 1) for i in input().split()] for _ in range(m): b, c = list(map(int, input().split())) cards.append((c, b)) cards.sort(reverse=True) ans = 0 sumv = 0 for i in range(n): v = cards[i][1] cv = cards[i][0] * v ans += cv sumv += v if sumv >= n: ans -= cards[i][0] * (sumv - n) break print(ans) main()

u477977638

p02937

python

s695531609

s557659970

Accepted

Accepted

from collections import defaultdict import bisect d=defaultdict(list) s=eval(input()) t=eval(input()) ns=len(s) nt=len(t) for i in range(ns): d[s[i]].append(i) for k,v in list(d.items()): d[k].append(ns) #print(d) ans=0 cnt=-1 for i in range(nt): tt=d[t[i]] # print(t[i],tt,ans,cnt) if tt==[]: print((-1)) exit(0) else: a=bisect.bisect_right(tt,cnt) # print("ind",a) if tt[a]==ns: ans+=ns+tt[0]-cnt cnt=tt[0] else: ans+=tt[a]-cnt cnt=tt[a] print(ans)

import sys #input = sys.stdin.readline input = sys.stdin.buffer.readline # mod=10**9+7 # rstrip().decode('utf-8') # map(int,input().split()) # import numpy as np from collections import defaultdict import bisect def main(): s=input().rstrip().decode('utf-8') t=input().rstrip().decode('utf-8') D=defaultdict(list) for i in range(len(s)): D[s[i]].append(i+1) now=0 cnt=0 for i in t: if D[i]==[]: print((-1)) exit(0) else: idx=bisect.bisect_right(D[i],now) try: now=D[i][idx] except: now=D[i][0] cnt+=1 print((cnt*len(s)+now)) if __name__ == "__main__": main()

from collections import defaultdict import bisect d = defaultdict(list) s = eval(input()) t = eval(input()) ns = len(s) nt = len(t) for i in range(ns): d[s[i]].append(i) for k, v in list(d.items()): d[k].append(ns) # print(d) ans = 0 cnt = -1 for i in range(nt): tt = d[t[i]] # print(t[i],tt,ans,cnt) if tt == []: print((-1)) exit(0) else: a = bisect.bisect_right(tt, cnt) # print("ind",a) if tt[a] == ns: ans += ns + tt[0] - cnt cnt = tt[0] else: ans += tt[a] - cnt cnt = tt[a] print(ans)

import sys # input = sys.stdin.readline input = sys.stdin.buffer.readline # mod=10**9+7 # rstrip().decode('utf-8') # map(int,input().split()) # import numpy as np from collections import defaultdict import bisect def main(): s = input().rstrip().decode("utf-8") t = input().rstrip().decode("utf-8") D = defaultdict(list) for i in range(len(s)): D[s[i]].append(i + 1) now = 0 cnt = 0 for i in t: if D[i] == []: print((-1)) exit(0) else: idx = bisect.bisect_right(D[i], now) try: now = D[i][idx] except: now = D[i][0] cnt += 1 print((cnt * len(s) + now)) if __name__ == "__main__": main()

u163783894

p03354

python

s833204773

s503105741

Accepted

Accepted

import sys read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline in_n = lambda: int(readline()) in_nn = lambda: list(map(int, readline().split())) in_nl = lambda: list(map(int, readline().split())) in_na = lambda: list(map(int, read().split())) in_s = lambda: readline().rstrip().decode('utf-8') class UnionFind(): def __init__(self, n): self.n = n self.parents = [-1] * n def find(self, x): if self.parents[x] < 0: return x else: self.parents[x] = self.find(self.parents[x]) return self.parents[x] def union(self, x, y): x = self.find(x) y = self.find(y) if x == y: return if self.parents[x] > self.parents[y]: x, y = y, x self.parents[x] += self.parents[y] self.parents[y] = x def size(self, x): return -self.parents[self.find(x)] def same(self, x, y): return self.find(x) == self.find(y) def members(self, x): root = self.find(x) return [i for i in range(self.n) if self.find(i) == root] def roots(self): return [i for i, x in enumerate(self.parents) if x < 0] def group_count(self): return len(self.roots()) def all_group_members(self): return {r: self.members(r) for r in self.roots()} def __str__(self): return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots()) def main(): N, M = in_nn() p = in_nl() uni = UnionFind(N) for i in range(M): x, y = in_nn() x, y = x - 1, y - 1 uni.union(x, y) edge = [[] for i in range(N)] for i in range(N): x = uni.find(i) edge[x].append(i) ans = 0 for i in range(N): if edge[i]: s = set(edge[i]) for e in edge[i]: if p[e] - 1 in s: ans += 1 print(ans) if __name__ == '__main__': main()

import sys read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline in_n = lambda: int(readline()) in_nn = lambda: list(map(int, readline().split())) in_nl = lambda: list(map(int, readline().split())) in_na = lambda: list(map(int, read().split())) in_s = lambda: readline().rstrip().decode('utf-8') class UnionFind(): def __init__(self, n): self.n = n self.parents = [-1] * n def find(self, x): if self.parents[x] < 0: return x else: self.parents[x] = self.find(self.parents[x]) return self.parents[x] def union(self, x, y): x = self.find(x) y = self.find(y) if x == y: return if self.parents[x] > self.parents[y]: x, y = y, x self.parents[x] += self.parents[y] self.parents[y] = x def size(self, x): return -self.parents[self.find(x)] def same(self, x, y): return self.find(x) == self.find(y) def members(self, x): root = self.find(x) return [i for i in range(self.n) if self.find(i) == root] def roots(self): return [i for i, x in enumerate(self.parents) if x < 0] def group_count(self): return len(self.roots()) def all_group_members(self): ret = dict() for i in range(self.n): r = self.find(i) if r in ret: ret[r].append(i) else: ret[r] = [i] return ret def __str__(self): return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots()) def main(): N, M = in_nn() p = in_nl() uni = UnionFind(N) for i in range(M): x, y = in_nn() x, y = x - 1, y - 1 uni.union(x, y) ans = 0 for root, group in list(uni.all_group_members().items()): s = set(group) for g in group: if p[g] - 1 in s: ans += 1 print(ans) if __name__ == '__main__': main()

import sys read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline in_n = lambda: int(readline()) in_nn = lambda: list(map(int, readline().split())) in_nl = lambda: list(map(int, readline().split())) in_na = lambda: list(map(int, read().split())) in_s = lambda: readline().rstrip().decode("utf-8") class UnionFind: def __init__(self, n): self.n = n self.parents = [-1] * n def find(self, x): if self.parents[x] < 0: return x else: self.parents[x] = self.find(self.parents[x]) return self.parents[x] def union(self, x, y): x = self.find(x) y = self.find(y) if x == y: return if self.parents[x] > self.parents[y]: x, y = y, x self.parents[x] += self.parents[y] self.parents[y] = x def size(self, x): return -self.parents[self.find(x)] def same(self, x, y): return self.find(x) == self.find(y) def members(self, x): root = self.find(x) return [i for i in range(self.n) if self.find(i) == root] def roots(self): return [i for i, x in enumerate(self.parents) if x < 0] def group_count(self): return len(self.roots()) def all_group_members(self): return {r: self.members(r) for r in self.roots()} def __str__(self): return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots()) def main(): N, M = in_nn() p = in_nl() uni = UnionFind(N) for i in range(M): x, y = in_nn() x, y = x - 1, y - 1 uni.union(x, y) edge = [[] for i in range(N)] for i in range(N): x = uni.find(i) edge[x].append(i) ans = 0 for i in range(N): if edge[i]: s = set(edge[i]) for e in edge[i]: if p[e] - 1 in s: ans += 1 print(ans) if __name__ == "__main__": main()

import sys read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline in_n = lambda: int(readline()) in_nn = lambda: list(map(int, readline().split())) in_nl = lambda: list(map(int, readline().split())) in_na = lambda: list(map(int, read().split())) in_s = lambda: readline().rstrip().decode("utf-8") class UnionFind: def __init__(self, n): self.n = n self.parents = [-1] * n def find(self, x): if self.parents[x] < 0: return x else: self.parents[x] = self.find(self.parents[x]) return self.parents[x] def union(self, x, y): x = self.find(x) y = self.find(y) if x == y: return if self.parents[x] > self.parents[y]: x, y = y, x self.parents[x] += self.parents[y] self.parents[y] = x def size(self, x): return -self.parents[self.find(x)] def same(self, x, y): return self.find(x) == self.find(y) def members(self, x): root = self.find(x) return [i for i in range(self.n) if self.find(i) == root] def roots(self): return [i for i, x in enumerate(self.parents) if x < 0] def group_count(self): return len(self.roots()) def all_group_members(self): ret = dict() for i in range(self.n): r = self.find(i) if r in ret: ret[r].append(i) else: ret[r] = [i] return ret def __str__(self): return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots()) def main(): N, M = in_nn() p = in_nl() uni = UnionFind(N) for i in range(M): x, y = in_nn() x, y = x - 1, y - 1 uni.union(x, y) ans = 0 for root, group in list(uni.all_group_members().items()): s = set(group) for g in group: if p[g] - 1 in s: ans += 1 print(ans) if __name__ == "__main__": main()

u512212329

p02572

python

s020019064

s234122198

Accepted

Accepted

from itertools import accumulate def main(): n = int(eval(input())) array = [int(x) for x in input().split()] acc = accumulate(array) mod = 10 ** 9 + 7 ans = 0 for i, ai in enumerate(acc): if i == n - 1: continue ans += ai * array[i + 1] ans %= mod return ans if __name__ == '__main__': print((main()))

def main(): eval(input()) # n array = [int(x) for x in input().split()] mod = 10 ** 9 + 7 total = 0 center_blocks = 0 for x in array: total += x center_blocks += x ** 2 total = total ** 2 return (total - center_blocks) // 2 % mod if __name__ == '__main__': print((main()))

from itertools import accumulate def main(): n = int(eval(input())) array = [int(x) for x in input().split()] acc = accumulate(array) mod = 10**9 + 7 ans = 0 for i, ai in enumerate(acc): if i == n - 1: continue ans += ai * array[i + 1] ans %= mod return ans if __name__ == "__main__": print((main()))

def main(): eval(input()) # n array = [int(x) for x in input().split()] mod = 10**9 + 7 total = 0 center_blocks = 0 for x in array: total += x center_blocks += x**2 total = total**2 return (total - center_blocks) // 2 % mod if __name__ == "__main__": print((main()))

u303039933

p02912

python

s896691498

s237237338

Accepted

Accepted

# -*- coding: utf-8 -*- import sys import math import os import itertools import string import heapq import _collections from collections import Counter from collections import defaultdict from functools import lru_cache import bisect import re import queue from decimal import * class Scanner(): @staticmethod def int(): return int(sys.stdin.readline().rstrip()) @staticmethod def string(): return sys.stdin.readline().rstrip() @staticmethod def map_int(): return [int(x) for x in Scanner.string().split()] @staticmethod def string_list(n): return [eval(input()) for i in range(n)] @staticmethod def int_list_list(n): return [Scanner.map_int() for i in range(n)] @staticmethod def int_cols_list(n): return [int(eval(input())) for i in range(n)] class Math(): @staticmethod def gcd(a, b): if b == 0: return a return Math.gcd(b, a % b) @staticmethod def lcm(a, b): return (a * b) // Math.gcd(a, b) @staticmethod def divisor(n): res = [] i = 1 for i in range(1, int(n ** 0.5) + 1): if n % i == 0: res.append(i) if i != n // i: res.append(n // i) return res @staticmethod def round_up(a, b): return -(-a // b) @staticmethod def is_prime(n): if n < 2: return False if n == 2: return True if n % 2 == 0: return False d = int(n ** 0.5) + 1 for i in range(3, d + 1, 2): if n % i == 0: return False return True def pop_count(x): x = x - ((x >> 1) & 0x5555555555555555) x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333) x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f x = x + (x >> 8) x = x + (x >> 16) x = x + (x >> 32) return x & 0x0000007f MOD = int(1e09) + 7 INF = int(1e15) def main(): # sys.stdin = open("sample.txt") N, M = Scanner.map_int() A = [-a for a in Scanner.map_int()] heapq.heapify(A) for _ in range(M): a = heapq.heappop(A) a = -(-a // 2) heapq.heappush(A, a) print((-sum(A))) if __name__ == "__main__": main()

# -*- coding: utf-8 -*- import sys import math import os import itertools import string import heapq import _collections from collections import Counter from collections import defaultdict from collections import deque from functools import lru_cache import bisect import re import queue import decimal class Scanner(): @staticmethod def int(): return int(sys.stdin.readline().rstrip()) @staticmethod def string(): return sys.stdin.readline().rstrip() @staticmethod def map_int(): return [int(x) for x in Scanner.string().split()] @staticmethod def string_list(n): return [Scanner.string() for i in range(n)] @staticmethod def int_list_list(n): return [Scanner.map_int() for i in range(n)] @staticmethod def int_cols_list(n): return [Scanner.int() for i in range(n)] class Math(): @staticmethod def gcd(a, b): if b == 0: return a return Math.gcd(b, a % b) @staticmethod def lcm(a, b): return (a * b) // Math.gcd(a, b) @staticmethod def divisor(n): lower, upper = [], [] i = 1 while i * i <= n: if n % i == 0: lower.append(i) if i != n // i: upper.append(n // i) i += 1 return lower + upper[::-1] @staticmethod def round_up(a, b): return -(-a // b) @staticmethod def is_prime(n): if n < 2: return False if n == 2: return True if n % 2 == 0: return False d = int(n ** 0.5) + 1 for i in range(3, d + 1, 2): if n % i == 0: return False return True @staticmethod def fact(N): res = {} tmp = N for i in range(2, int(N ** 0.5 + 1) + 1): cnt = 0 while tmp % i == 0: cnt += 1 tmp //= i if cnt > 0: res[i] = cnt if tmp != 1: res[tmp] = 1 if res == {}: res[N] = 1 return res def pop_count(x): x = x - ((x >> 1) & 0x5555555555555555) x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333) x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f x = x + (x >> 8) x = x + (x >> 16) x = x + (x >> 32) return x & 0x0000007f MOD = int(1e09) + 7 INF = int(1e15) def solve(): N, M = Scanner.map_int() A = Scanner.map_int() A = [-a for a in A] heapq.heapify(A) for _ in range(M): x = -heapq.heappop(A) x //= 2 heapq.heappush(A, -x) print((-sum(A))) def main(): # sys.setrecursionlimit(1000000) # sys.stdin = open("sample.txt") # T = Scanner.int() # for _ in range(T): # solve() # print('YNeos'[not solve()::2]) solve() if __name__ == "__main__": main()

# -*- coding: utf-8 -*- import sys import math import os import itertools import string import heapq import _collections from collections import Counter from collections import defaultdict from functools import lru_cache import bisect import re import queue from decimal import * class Scanner: @staticmethod def int(): return int(sys.stdin.readline().rstrip()) @staticmethod def string(): return sys.stdin.readline().rstrip() @staticmethod def map_int(): return [int(x) for x in Scanner.string().split()] @staticmethod def string_list(n): return [eval(input()) for i in range(n)] @staticmethod def int_list_list(n): return [Scanner.map_int() for i in range(n)] @staticmethod def int_cols_list(n): return [int(eval(input())) for i in range(n)] class Math: @staticmethod def gcd(a, b): if b == 0: return a return Math.gcd(b, a % b) @staticmethod def lcm(a, b): return (a * b) // Math.gcd(a, b) @staticmethod def divisor(n): res = [] i = 1 for i in range(1, int(n**0.5) + 1): if n % i == 0: res.append(i) if i != n // i: res.append(n // i) return res @staticmethod def round_up(a, b): return -(-a // b) @staticmethod def is_prime(n): if n < 2: return False if n == 2: return True if n % 2 == 0: return False d = int(n**0.5) + 1 for i in range(3, d + 1, 2): if n % i == 0: return False return True def pop_count(x): x = x - ((x >> 1) & 0x5555555555555555) x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333) x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0F x = x + (x >> 8) x = x + (x >> 16) x = x + (x >> 32) return x & 0x0000007F MOD = int(1e09) + 7 INF = int(1e15) def main(): # sys.stdin = open("sample.txt") N, M = Scanner.map_int() A = [-a for a in Scanner.map_int()] heapq.heapify(A) for _ in range(M): a = heapq.heappop(A) a = -(-a // 2) heapq.heappush(A, a) print((-sum(A))) if __name__ == "__main__": main()

# -*- coding: utf-8 -*- import sys import math import os import itertools import string import heapq import _collections from collections import Counter from collections import defaultdict from collections import deque from functools import lru_cache import bisect import re import queue import decimal class Scanner: @staticmethod def int(): return int(sys.stdin.readline().rstrip()) @staticmethod def string(): return sys.stdin.readline().rstrip() @staticmethod def map_int(): return [int(x) for x in Scanner.string().split()] @staticmethod def string_list(n): return [Scanner.string() for i in range(n)] @staticmethod def int_list_list(n): return [Scanner.map_int() for i in range(n)] @staticmethod def int_cols_list(n): return [Scanner.int() for i in range(n)] class Math: @staticmethod def gcd(a, b): if b == 0: return a return Math.gcd(b, a % b) @staticmethod def lcm(a, b): return (a * b) // Math.gcd(a, b) @staticmethod def divisor(n): lower, upper = [], [] i = 1 while i * i <= n: if n % i == 0: lower.append(i) if i != n // i: upper.append(n // i) i += 1 return lower + upper[::-1] @staticmethod def round_up(a, b): return -(-a // b) @staticmethod def is_prime(n): if n < 2: return False if n == 2: return True if n % 2 == 0: return False d = int(n**0.5) + 1 for i in range(3, d + 1, 2): if n % i == 0: return False return True @staticmethod def fact(N): res = {} tmp = N for i in range(2, int(N**0.5 + 1) + 1): cnt = 0 while tmp % i == 0: cnt += 1 tmp //= i if cnt > 0: res[i] = cnt if tmp != 1: res[tmp] = 1 if res == {}: res[N] = 1 return res def pop_count(x): x = x - ((x >> 1) & 0x5555555555555555) x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333) x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0F x = x + (x >> 8) x = x + (x >> 16) x = x + (x >> 32) return x & 0x0000007F MOD = int(1e09) + 7 INF = int(1e15) def solve(): N, M = Scanner.map_int() A = Scanner.map_int() A = [-a for a in A] heapq.heapify(A) for _ in range(M): x = -heapq.heappop(A) x //= 2 heapq.heappush(A, -x) print((-sum(A))) def main(): # sys.setrecursionlimit(1000000) # sys.stdin = open("sample.txt") # T = Scanner.int() # for _ in range(T): # solve() # print('YNeos'[not solve()::2]) solve() if __name__ == "__main__": main()

u671211357

p04001

python

s140845265

s504080404

Accepted

Accepted

S=list(eval(input())) ans=0 for i in range(2**(len(S)-1)): kari=[""]*(len(S)-1) for j in range(len(S)-1): if ((i>>j)&1): kari[j]="+" hako=[] kotae=0 kasu=0 gomi=0 for j in range(len(kari)+len(S)): if j%2==0: hako.append(S[kasu]) kasu+=1 else: hako.append(kari[gomi]) gomi+=1 #print(hako) hako="".join(hako) #hako=hako.replace(",","") #print(hako) kotae=eval(hako) ans+=kotae print(ans)

S=list(eval(input())) ans=0 for i in range(2**(len(S)-1)): kari=[""]*(len(S)-1) for j in range(len(S)-1): if ((i>>j)&1): kari[j]="+" hako=[] kasu=0 gomi=0 for j in range(len(kari)+len(S)): if j%2==0: hako.append(S[kasu]) kasu+=1 else: hako.append(kari[gomi]) gomi+=1 #print(hako) hako="".join(hako) #hako=hako.replace(",","") #print(hako) ans+=eval(hako) print(ans)

S = list(eval(input())) ans = 0 for i in range(2 ** (len(S) - 1)): kari = [""] * (len(S) - 1) for j in range(len(S) - 1): if (i >> j) & 1: kari[j] = "+" hako = [] kotae = 0 kasu = 0 gomi = 0 for j in range(len(kari) + len(S)): if j % 2 == 0: hako.append(S[kasu]) kasu += 1 else: hako.append(kari[gomi]) gomi += 1 # print(hako) hako = "".join(hako) # hako=hako.replace(",","") # print(hako) kotae = eval(hako) ans += kotae print(ans)

S = list(eval(input())) ans = 0 for i in range(2 ** (len(S) - 1)): kari = [""] * (len(S) - 1) for j in range(len(S) - 1): if (i >> j) & 1: kari[j] = "+" hako = [] kasu = 0 gomi = 0 for j in range(len(kari) + len(S)): if j % 2 == 0: hako.append(S[kasu]) kasu += 1 else: hako.append(kari[gomi]) gomi += 1 # print(hako) hako = "".join(hako) # hako=hako.replace(",","") # print(hako) ans += eval(hako) print(ans)

u463848480

p03448

python

s891804260

s082438747

Accepted

Accepted

def main(): A = int(input().strip()) B = int(input().strip()) C = int(input().strip()) X = int(input().strip()) if 500 > X: A = 0 if 100 > X: B = 0 count = 0 for ai in [x*500 for x in range(A+1)]: Xa = X - ai for bi in [x*100 for x in range(B+1)]: Xb = Xa - bi for ci in [x*50 for x in range(C+1)]: Xc = Xb - ci if Xc == 0: count += 1 return count if __name__ == '__main__': print((main()))

def main(): A = int(input().strip()) B = int(input().strip()) C = int(input().strip()) X = int(input().strip()) count = 0 for ai in [x*500 for x in range(A+1)]: Xa = X - ai if Xa < 0: break for bi in [x*100 for x in range(B+1)]: Xb = Xa - bi if Xb < 0: break for ci in [x*50 for x in range(C+1)]: Xc = Xb - ci if Xc < 0: break if Xc == 0: count += 1 return count if __name__ == '__main__': print((main()))

def main(): A = int(input().strip()) B = int(input().strip()) C = int(input().strip()) X = int(input().strip()) if 500 > X: A = 0 if 100 > X: B = 0 count = 0 for ai in [x * 500 for x in range(A + 1)]: Xa = X - ai for bi in [x * 100 for x in range(B + 1)]: Xb = Xa - bi for ci in [x * 50 for x in range(C + 1)]: Xc = Xb - ci if Xc == 0: count += 1 return count if __name__ == "__main__": print((main()))

def main(): A = int(input().strip()) B = int(input().strip()) C = int(input().strip()) X = int(input().strip()) count = 0 for ai in [x * 500 for x in range(A + 1)]: Xa = X - ai if Xa < 0: break for bi in [x * 100 for x in range(B + 1)]: Xb = Xa - bi if Xb < 0: break for ci in [x * 50 for x in range(C + 1)]: Xc = Xb - ci if Xc < 0: break if Xc == 0: count += 1 return count if __name__ == "__main__": print((main()))

u608088992

p03197

python

s195008840

s168220208

Accepted

Accepted

N = int(eval(input())) A = [int(eval(input()))%2 for n in range(N)] for i in range(N): if A[i] == 1: print("first") break else: print("second")

import sys from collections import deque def solve(): input = sys.stdin.readline N = int(eval(input())) first = False for _ in range(N): a = int(eval(input())) if a % 2 == 1: first = True if first: print("first") else: print("second") return 0 if __name__ == "__main__": solve()

N = int(eval(input())) A = [int(eval(input())) % 2 for n in range(N)] for i in range(N): if A[i] == 1: print("first") break else: print("second")

import sys from collections import deque def solve(): input = sys.stdin.readline N = int(eval(input())) first = False for _ in range(N): a = int(eval(input())) if a % 2 == 1: first = True if first: print("first") else: print("second") return 0 if __name__ == "__main__": solve()

u645487439

p02702

python

s186675099

s705913698

Accepted

Accepted

s = input()[::-1] d = 1 num = 0 ans = 0 mod_list = [0] * 2019 mod_list[0] = 1 for char in s: num += int(char) * d num %= 2019 d *= 10 d %= 2019 mod_list[num % 2019] += 1 for i in range(2019): ans += mod_list[i] * (mod_list[i] - 1) //2 print(ans)

s = input()[::-1] d = 1 num = 0 ans = 0 mod_list = [0] * 2019 mod_list[0] = 1 for char in s: num += int(char) * d mod_list[num % 2019] += 1 d *= 10 d %= 2019 for i in range(2019): ans += mod_list[i] * (mod_list[i] - 1) //2 print(ans)

s = input()[::-1] d = 1 num = 0 ans = 0 mod_list = [0] * 2019 mod_list[0] = 1 for char in s: num += int(char) * d num %= 2019 d *= 10 d %= 2019 mod_list[num % 2019] += 1 for i in range(2019): ans += mod_list[i] * (mod_list[i] - 1) // 2 print(ans)

s = input()[::-1] d = 1 num = 0 ans = 0 mod_list = [0] * 2019 mod_list[0] = 1 for char in s: num += int(char) * d mod_list[num % 2019] += 1 d *= 10 d %= 2019 for i in range(2019): ans += mod_list[i] * (mod_list[i] - 1) // 2 print(ans)

u346812984

p03557

python

s168986526

s847677055

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() ans = 0 for b in B: na = bisect.bisect_left(A, b) nb = N - bisect.bisect_right(C, b) ans += na * nb print(ans)

import bisect import sys sys.setrecursionlimit(10 ** 6) INF = float("inf") MOD = 10 ** 9 + 7 def input(): return sys.stdin.readline().strip() def main(): 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 b in B: upper = bisect.bisect_left(A, b) bottom = N - bisect.bisect_right(C, b) ans += upper * bottom print(ans) if __name__ == "__main__": main()

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 b in B: na = bisect.bisect_left(A, b) nb = N - bisect.bisect_right(C, b) ans += na * nb print(ans)

import bisect import sys sys.setrecursionlimit(10**6) INF = float("inf") MOD = 10**9 + 7 def input(): return sys.stdin.readline().strip() def main(): 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 b in B: upper = bisect.bisect_left(A, b) bottom = N - bisect.bisect_right(C, b) ans += upper * bottom print(ans) if __name__ == "__main__": main()

u408260374

p01130

python

s335432045

s294464813

Accepted

Accepted

while True: N, M, s, g1, g2 = list(map(int, input().split())) if N == M == s == g1 == g2 == 0: break s, g1, g2 = s - 1, g1 - 1, g2 - 1 INF = 10 ** 5 D = [[INF] * N for _ in range(N)] for i in range(N): D[i][i] = 0 for _ in range(M): b1, b2, c = list(map(int, input().split())) b1, b2 = b1 - 1, b2 - 1 D[b1][b2] = c for k in range(N): for i in range(N): for j in range(N): D[i][j] = min(D[i][j], D[i][k] + D[k][j]) print((min(D[s][i] + D[i][g1] + D[i][g2] for i in range(N))))

while True: N, M, s, g1, g2 = list(map(int, input().split())) if N == M == s == g1 == g2 == 0: break s, g1, g2 = s - 1, g1 - 1, g2 - 1 INF = 10 ** 5 D = [[INF] * N for _ in range(N)] for i in range(N): D[i][i] = 0 for _ in range(M): b1, b2, c = list(map(int, input().split())) b1, b2 = b1 - 1, b2 - 1 D[b1][b2] = c for k in range(N): for i in range(N): for j in range(N): if D[i][j] > D[i][k] + D[k][j]: D[i][j] = D[i][k] + D[k][j] print((min(D[s][i] + D[i][g1] + D[i][g2] for i in range(N))))

while True: N, M, s, g1, g2 = list(map(int, input().split())) if N == M == s == g1 == g2 == 0: break s, g1, g2 = s - 1, g1 - 1, g2 - 1 INF = 10**5 D = [[INF] * N for _ in range(N)] for i in range(N): D[i][i] = 0 for _ in range(M): b1, b2, c = list(map(int, input().split())) b1, b2 = b1 - 1, b2 - 1 D[b1][b2] = c for k in range(N): for i in range(N): for j in range(N): D[i][j] = min(D[i][j], D[i][k] + D[k][j]) print((min(D[s][i] + D[i][g1] + D[i][g2] for i in range(N))))

while True: N, M, s, g1, g2 = list(map(int, input().split())) if N == M == s == g1 == g2 == 0: break s, g1, g2 = s - 1, g1 - 1, g2 - 1 INF = 10**5 D = [[INF] * N for _ in range(N)] for i in range(N): D[i][i] = 0 for _ in range(M): b1, b2, c = list(map(int, input().split())) b1, b2 = b1 - 1, b2 - 1 D[b1][b2] = c for k in range(N): for i in range(N): for j in range(N): if D[i][j] > D[i][k] + D[k][j]: D[i][j] = D[i][k] + D[k][j] print((min(D[s][i] + D[i][g1] + D[i][g2] for i in range(N))))

u622045059

p04012

python

s153869551

s304231642

Accepted

Accepted

W = eval(input()) cnt = {} for w in W: if w not in list(cnt.keys()): cnt[w] = 1 else: cnt[w] += 1 ans = 'Yes' for v in list(cnt.values()): if v % 2 == 1: ans = 'No' break print(ans)

import collections w = eval(input()) c = collections.Counter(w) ans = 'Yes' for v in list(c.values()): if v % 2 == 1: ans = 'No' break print(ans)

W = eval(input()) cnt = {} for w in W: if w not in list(cnt.keys()): cnt[w] = 1 else: cnt[w] += 1 ans = "Yes" for v in list(cnt.values()): if v % 2 == 1: ans = "No" break print(ans)

import collections w = eval(input()) c = collections.Counter(w) ans = "Yes" for v in list(c.values()): if v % 2 == 1: ans = "No" break print(ans)

u385244248

p02768

python

s874806135

s536636495

Accepted

Accepted

import sys import math import fractions import itertools from collections import deque import copy import bisect MOD = 10 ** 9 + 7 INF = 10 ** 18 + 7 input = lambda: sys.stdin.readline().strip() def inv_mod(a, N): """ Fermatの小定理より(Nが素数のときしか使えない) aの逆元 ax = 1 (mod N)を満たすx = a^(N-2) mod Nを返す。 O(log N) """ def bpm(x, y, N): """ Bisection power method : 二分累乗法 O(log y)でx^(y) mod N を求める。 """ ans = 1 x %= MOD digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数 for i in range(digit): if (y >> i) & 1 == 1: ans *= x ans %= MOD x **= 2 x %= MOD return ans return bpm(a, N - 2, N) def bpm(x, y, N): """ Bisection power method : 二分累乗法 O(log y)でx^(y) mod N を求める。 """ ans = 1 x %= MOD digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数 for i in range(digit): if (y >> i) & 1 == 1: ans *= x ans %= MOD x **= 2 x %= MOD return ans n, a, b = list(map(int, input().split())) nCa = 1 nCb = 1 inv_list = [] for i in range(max(a, b)): inv_list.append(inv_mod(i + 1, MOD)) for i in range(a): nCa *= inv_list[i] nCa %= MOD nCa *= n - i nCa %= MOD for i in range(b): nCb *= inv_list[i] nCb %= MOD nCb *= n - i nCb %= MOD print(((bpm(2, n, MOD) - 1 - nCa - nCb) % MOD))

import sys import math import fractions import itertools from collections import deque import copy import bisect MOD = 10 ** 9 + 7 INF = 10 ** 18 + 7 input = lambda: sys.stdin.readline().strip() def inv_mod(a, N): """ Fermatの小定理より(Nが素数のときしか使えない) aの逆元 ax = 1 (mod N)を満たすx = a^(N-2) mod Nを返す。 O(log N) """ def bpm(x, y, N): """ Bisection power method : 二分累乗法 O(log y)でx^(y) mod N を求める。 """ ans = 1 x %= MOD digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数 for i in range(digit): if (y >> i) & 1 == 1: ans *= x ans %= MOD x **= 2 x %= MOD return ans return bpm(a, N - 2, N) def bpm(x, y, N): """ Bisection power method : 二分累乗法 O(log y)でx^(y) mod N を求める。 """ ans = 1 x %= MOD digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数 for i in range(digit): if (y >> i) & 1 == 1: ans *= x ans %= MOD x **= 2 x %= MOD return ans n, a, b = list(map(int, input().split())) nCa = 1 nCb = 1 inv_list = [1] # 0で割るというのは定義されないので無視。 for i in range(max(a, b)): inv_list.append(int(MOD - inv_list[(MOD % (i + 2)) - 1] * (MOD // (i + 2)) % MOD)) for i in range(a): nCa *= inv_list[i] nCa %= MOD nCa *= n - i nCa %= MOD for i in range(b): nCb *= inv_list[i] nCb %= MOD nCb *= n - i nCb %= MOD print(((bpm(2, n, MOD) - 1 - nCa - nCb) % MOD))

import sys import math import fractions import itertools from collections import deque import copy import bisect MOD = 10**9 + 7 INF = 10**18 + 7 input = lambda: sys.stdin.readline().strip() def inv_mod(a, N): """ Fermatの小定理より(Nが素数のときしか使えない) aの逆元 ax = 1 (mod N)を満たすx = a^(N-2) mod Nを返す。 O(log N) """ def bpm(x, y, N): """ Bisection power method : 二分累乗法 O(log y)でx^(y) mod N を求める。 """ ans = 1 x %= MOD digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数 for i in range(digit): if (y >> i) & 1 == 1: ans *= x ans %= MOD x **= 2 x %= MOD return ans return bpm(a, N - 2, N) def bpm(x, y, N): """ Bisection power method : 二分累乗法 O(log y)でx^(y) mod N を求める。 """ ans = 1 x %= MOD digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数 for i in range(digit): if (y >> i) & 1 == 1: ans *= x ans %= MOD x **= 2 x %= MOD return ans n, a, b = list(map(int, input().split())) nCa = 1 nCb = 1 inv_list = [] for i in range(max(a, b)): inv_list.append(inv_mod(i + 1, MOD)) for i in range(a): nCa *= inv_list[i] nCa %= MOD nCa *= n - i nCa %= MOD for i in range(b): nCb *= inv_list[i] nCb %= MOD nCb *= n - i nCb %= MOD print(((bpm(2, n, MOD) - 1 - nCa - nCb) % MOD))

import sys import math import fractions import itertools from collections import deque import copy import bisect MOD = 10**9 + 7 INF = 10**18 + 7 input = lambda: sys.stdin.readline().strip() def inv_mod(a, N): """ Fermatの小定理より(Nが素数のときしか使えない) aの逆元 ax = 1 (mod N)を満たすx = a^(N-2) mod Nを返す。 O(log N) """ def bpm(x, y, N): """ Bisection power method : 二分累乗法 O(log y)でx^(y) mod N を求める。 """ ans = 1 x %= MOD digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数 for i in range(digit): if (y >> i) & 1 == 1: ans *= x ans %= MOD x **= 2 x %= MOD return ans return bpm(a, N - 2, N) def bpm(x, y, N): """ Bisection power method : 二分累乗法 O(log y)でx^(y) mod N を求める。 """ ans = 1 x %= MOD digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数 for i in range(digit): if (y >> i) & 1 == 1: ans *= x ans %= MOD x **= 2 x %= MOD return ans n, a, b = list(map(int, input().split())) nCa = 1 nCb = 1 inv_list = [1] # 0で割るというのは定義されないので無視。 for i in range(max(a, b)): inv_list.append(int(MOD - inv_list[(MOD % (i + 2)) - 1] * (MOD // (i + 2)) % MOD)) for i in range(a): nCa *= inv_list[i] nCa %= MOD nCa *= n - i nCa %= MOD for i in range(b): nCb *= inv_list[i] nCb %= MOD nCb *= n - i nCb %= MOD print(((bpm(2, n, MOD) - 1 - nCa - nCb) % MOD))

u217627525

p03631

python

s829414467

s804031592

Accepted

Accepted

n=int(eval(input())) if n//100==n%10: print("Yes") else: print("No")

n=eval(input()) if n[0]==n[2]: print("Yes") else: print("No")

n = int(eval(input())) if n // 100 == n % 10: print("Yes") else: print("No")

n = eval(input()) if n[0] == n[2]: print("Yes") else: print("No")

u221264296

p02773

python

s183129570

s135269020

Accepted

Accepted

n=int(eval(input())) mx = 0 t=[] d={} for i in range(n): s=eval(input()) t+=[s] d[s] = d.get(s,0)+1 mx = max(mx,d[s]) v=[] d2={} for s in t: if(d[s]==mx and d2.get(s,0)==0): v+=[s] d2[s] = d2.get(s,0)+1 v.sort() for s in v: print(s)

n = int(eval(input())) d = {} for i in range(n): s = eval(input()) d[s] = d.get(s,0)+1 m = max(d[i] for i in d) for s in sorted(d): if d[s]==m: print(s)

n = int(eval(input())) mx = 0 t = [] d = {} for i in range(n): s = eval(input()) t += [s] d[s] = d.get(s, 0) + 1 mx = max(mx, d[s]) v = [] d2 = {} for s in t: if d[s] == mx and d2.get(s, 0) == 0: v += [s] d2[s] = d2.get(s, 0) + 1 v.sort() for s in v: print(s)

n = int(eval(input())) d = {} for i in range(n): s = eval(input()) d[s] = d.get(s, 0) + 1 m = max(d[i] for i in d) for s in sorted(d): if d[s] == m: print(s)

u237493274

p02936

python

s616977234

s213990498

Accepted

Accepted

N,Q = list(map(int,input().split())) AB = [[int(x) for x in input().split()] for _ in range(N-1)] PX = [[int(x) for x in input().split()] for _ in range(Q)] graph = [[] for _ in range(N+1)] for a,b in AB: graph[a].append(b) graph[b].append(a) value = [0] * (N+1) for p,x in PX: value[p] += x q = [(1,0)] while q: x,parent = q.pop() value[x] += value[parent] for y in graph[x]: if y == parent: continue q.append((y,x)) answer = ' '.join(map(str,value[1:])) print(answer)

import sys input = sys.stdin.readline sys.setrecursionlimit(10 ** 7) N,Q = list(map(int,input().split())) AB = [[int(x) for x in input().split()] for _ in range(N-1)] PX = [[int(x) for x in input().split()] for _ in range(Q)] graph = [[] for _ in range(N+1)] for a,b in AB: graph[a].append(b) graph[b].append(a) value = [0] * (N+1) for p,x in PX: value[p] += x q = [(1,0)] while q: x,parent = q.pop() value[x] += value[parent] for y in graph[x]: if y == parent: continue q.append((y,x)) answer = ' '.join(map(str,value[1:])) print(answer)

N, Q = list(map(int, input().split())) AB = [[int(x) for x in input().split()] for _ in range(N - 1)] PX = [[int(x) for x in input().split()] for _ in range(Q)] graph = [[] for _ in range(N + 1)] for a, b in AB: graph[a].append(b) graph[b].append(a) value = [0] * (N + 1) for p, x in PX: value[p] += x q = [(1, 0)] while q: x, parent = q.pop() value[x] += value[parent] for y in graph[x]: if y == parent: continue q.append((y, x)) answer = " ".join(map(str, value[1:])) print(answer)

import sys input = sys.stdin.readline sys.setrecursionlimit(10**7) N, Q = list(map(int, input().split())) AB = [[int(x) for x in input().split()] for _ in range(N - 1)] PX = [[int(x) for x in input().split()] for _ in range(Q)] graph = [[] for _ in range(N + 1)] for a, b in AB: graph[a].append(b) graph[b].append(a) value = [0] * (N + 1) for p, x in PX: value[p] += x q = [(1, 0)] while q: x, parent = q.pop() value[x] += value[parent] for y in graph[x]: if y == parent: continue q.append((y, x)) answer = " ".join(map(str, value[1:])) print(answer)

u760569096

p03295

python

s753262700

s772170597

Accepted

Accepted

n,m = list(map(int, input().split())) g = [[n] for i in range(n)] for i in range(m): a,b = list(map(int, input().split())) g[a-1].append(b-1) k = 0 ans=0 while k <=n-1: e = n for i in g[k:]: e = min(e,min(i)) if e==n: break ans+=1 k = e print(ans)

n,m = list(map(int, input().split())) t = [[n] for i in range(n)] for i in range(m): a,b = list(map(int, input().split())) t[a-1].append(b-1) g = [] for i in t: g.append(sorted(i)) k = 0 ans=0 while k <=n-1: e = n for i in g[k:]: e = min(e,i[0]) if e==n: break ans+=1 k = e print(ans)

n, m = list(map(int, input().split())) g = [[n] for i in range(n)] for i in range(m): a, b = list(map(int, input().split())) g[a - 1].append(b - 1) k = 0 ans = 0 while k <= n - 1: e = n for i in g[k:]: e = min(e, min(i)) if e == n: break ans += 1 k = e print(ans)

n, m = list(map(int, input().split())) t = [[n] for i in range(n)] for i in range(m): a, b = list(map(int, input().split())) t[a - 1].append(b - 1) g = [] for i in t: g.append(sorted(i)) k = 0 ans = 0 while k <= n - 1: e = n for i in g[k:]: e = min(e, i[0]) if e == n: break ans += 1 k = e print(ans)

u190178779

p03829

python

s745335012

s932153856

Accepted

Accepted

import sys N,A,B = list(map(int,input().split())) array = list(map(int,input().split())) if not ( 2 <= N <= 10**5 and 1 <= A <= 10**9 and 1 <= B <= 10**9 ): sys.exit() for I in range(len(array)): if not ( 1 <= array[I] <= 10**9 ): sys.exit() if array[I] != array[-1]: if not ( array[I] < array[I+1] ): sys.exit() cost = 0 for J in range(len(array)): if array[J] != array[-1]: walk_cost = (array[J+1] - array[J])*A if walk_cost < B: cost += walk_cost else: cost += B print(cost)

import sys N,A,B = list(map(int,input().split())) array = list(map(int,input().split())) cost = 0 for J in range(len(array)-1): walk_cost = (array[J+1] - array[J])*A if walk_cost < B: cost += walk_cost else: cost += B print(cost)

import sys N, A, B = list(map(int, input().split())) array = list(map(int, input().split())) if not (2 <= N <= 10**5 and 1 <= A <= 10**9 and 1 <= B <= 10**9): sys.exit() for I in range(len(array)): if not (1 <= array[I] <= 10**9): sys.exit() if array[I] != array[-1]: if not (array[I] < array[I + 1]): sys.exit() cost = 0 for J in range(len(array)): if array[J] != array[-1]: walk_cost = (array[J + 1] - array[J]) * A if walk_cost < B: cost += walk_cost else: cost += B print(cost)

import sys N, A, B = list(map(int, input().split())) array = list(map(int, input().split())) cost = 0 for J in range(len(array) - 1): walk_cost = (array[J + 1] - array[J]) * A if walk_cost < B: cost += walk_cost else: cost += B print(cost)

u672475305

p03835

python

s871738099

s183552293

Accepted

Accepted

k,s = list(map(int,input().split())) cnt = 0 for x in range(k+1): for y in range(k+1): z = s-x-y if 0 <= z <= k: cnt += 1 print(cnt)

k,s = list(map(int,input().split())) ans = 0 for x in range(k+1): for y in range(x, k+1): z = s - x - y if y<=z and z<=k: tmp = set([x,y,z]) if len(tmp)==3: ans += 6 elif len(tmp)==2: ans += 3 else: ans += 1 print(ans)

k, s = list(map(int, input().split())) cnt = 0 for x in range(k + 1): for y in range(k + 1): z = s - x - y if 0 <= z <= k: cnt += 1 print(cnt)

k, s = list(map(int, input().split())) ans = 0 for x in range(k + 1): for y in range(x, k + 1): z = s - x - y if y <= z and z <= k: tmp = set([x, y, z]) if len(tmp) == 3: ans += 6 elif len(tmp) == 2: ans += 3 else: ans += 1 print(ans)

u020390084

p03013

python

s057682473

s339350446

Accepted

Accepted

n, m = list(map(int,input().split())) a = [int(eval(input())) for i in range(m)] dp = [float("inf")] * (n+1) dp[0] = 1 dp[1] = 1 for i in a: dp[i] = 0 for i in range(2, n+1): dp[i] = min(dp[i], (dp[i-1] + dp[i-2])%(10**9+7)) print((dp[n]))

#!/usr/bin/env python3 import sys MOD = 1000000007 # type: int def solve(N: int, M: int, a: "List[int]"): #dp[i] = i段目までの移動総数 dp = [-1]*(N+1) dp[0]=1 dp[1]=1 for i in range(M): dp[a[i]] = 0 for i in range(2,N+1): if dp[i] == 0: continue dp[i] = dp[i-1]+dp[i-2] dp[i]%=MOD print((dp[N]%MOD)) return def main(): def iterate_tokens(): for line in sys.stdin: for word in line.split(): yield word tokens = iterate_tokens() N = int(next(tokens)) # type: int M = int(next(tokens)) # type: int a = [int(next(tokens)) for _ in range(M)] # type: "List[int]" solve(N, M, a) if __name__ == '__main__': main()

n, m = list(map(int, input().split())) a = [int(eval(input())) for i in range(m)] dp = [float("inf")] * (n + 1) dp[0] = 1 dp[1] = 1 for i in a: dp[i] = 0 for i in range(2, n + 1): dp[i] = min(dp[i], (dp[i - 1] + dp[i - 2]) % (10**9 + 7)) print((dp[n]))

#!/usr/bin/env python3 import sys MOD = 1000000007 # type: int def solve(N: int, M: int, a: "List[int]"): # dp[i] = i段目までの移動総数 dp = [-1] * (N + 1) dp[0] = 1 dp[1] = 1 for i in range(M): dp[a[i]] = 0 for i in range(2, N + 1): if dp[i] == 0: continue dp[i] = dp[i - 1] + dp[i - 2] dp[i] %= MOD print((dp[N] % MOD)) return def main(): def iterate_tokens(): for line in sys.stdin: for word in line.split(): yield word tokens = iterate_tokens() N = int(next(tokens)) # type: int M = int(next(tokens)) # type: int a = [int(next(tokens)) for _ in range(M)] # type: "List[int]" solve(N, M, a) if __name__ == "__main__": main()

u585482323

p03031

python

s340861998

s325530444

Accepted

Accepted

#!usr/bin/env python3 from collections import defaultdict from collections import deque from heapq import heappush, heappop import sys import math import bisect import random def LI(): return list(map(int, sys.stdin.readline().split())) def I(): return int(sys.stdin.readline()) def LS():return list(map(list, sys.stdin.readline().split())) def S(): return list(sys.stdin.readline())[:-1] def IR(n): l = [None for i in range(n)] for i in range(n):l[i] = I() return l def LIR(n): l = [None for i in range(n)] for i in range(n):l[i] = LI() return l def SR(n): l = [None for i in range(n)] for i in range(n):l[i] = S() return l def LSR(n): l = [None for i in range(n)] for i in range(n):l[i] = LS() return l sys.setrecursionlimit(1000000) mod = 1000000007 #A def A(): a,p = LI() print(((a*3+p)//2)) return #B def B(): n = I() s = [None for i in range(n)] for i in range(n): l = input().split() s[i] = l+[i] s.sort(key = lambda x:(x[0],-int(x[1]))) for i,a,b in s: print((b+1)) return #C def C(): def dfs(d,k): if d == n: l.append(k) else: dfs(d+1,k+[0]) dfs(d+1,k+[1]) n,m = LI() l = [] dfs(0,[]) qu = LIR(m) p = LI() ans = 0 for k in l: s = 0 for q in range(m): num = qu[q][0] lis = list([x-1 for x in qu[q][1:]]) su = 0 for i in lis: su ^= k[i] if su == p[q]: s += 1 if s == m: ans += 1 print(ans) return #D def D(): n = I() return #E def E(): n = I() return #F def F(): n = I() return #Solve if __name__ == "__main__": C()

#!usr/bin/env python3 from collections import defaultdict,deque from heapq import heappush, heappop import sys import math import bisect import random def LI(): return [int(x) for x in sys.stdin.readline().split()] def I(): return int(sys.stdin.readline()) def LS():return [list(x) for x in sys.stdin.readline().split()] def S(): res = list(sys.stdin.readline()) if res[-1] == "\n": return res[:-1] return res def IR(n): return [I() for i in range(n)] def LIR(n): return [LI() for i in range(n)] def SR(n): return [S() for i in range(n)] def LSR(n): return [LS() for i in range(n)] sys.setrecursionlimit(1000000) mod = 1000000007 def solve(): n,m = LI() s = LIR(m) p = LI() ans = 0 for i in range(m): s[i] = sum([1<<(j-1) for j in s[i][1:]]) for b in range(1<<n): for i in range(m): if bin(s[i]&b).count("1")&1 != p[i]: break else:ans += 1 print(ans) return #Solve if __name__ == "__main__": solve()

#!usr/bin/env python3 from collections import defaultdict from collections import deque from heapq import heappush, heappop import sys import math import bisect import random def LI(): return list(map(int, sys.stdin.readline().split())) def I(): return int(sys.stdin.readline()) def LS(): return list(map(list, sys.stdin.readline().split())) def S(): return list(sys.stdin.readline())[:-1] def IR(n): l = [None for i in range(n)] for i in range(n): l[i] = I() return l def LIR(n): l = [None for i in range(n)] for i in range(n): l[i] = LI() return l def SR(n): l = [None for i in range(n)] for i in range(n): l[i] = S() return l def LSR(n): l = [None for i in range(n)] for i in range(n): l[i] = LS() return l sys.setrecursionlimit(1000000) mod = 1000000007 # A def A(): a, p = LI() print(((a * 3 + p) // 2)) return # B def B(): n = I() s = [None for i in range(n)] for i in range(n): l = input().split() s[i] = l + [i] s.sort(key=lambda x: (x[0], -int(x[1]))) for i, a, b in s: print((b + 1)) return # C def C(): def dfs(d, k): if d == n: l.append(k) else: dfs(d + 1, k + [0]) dfs(d + 1, k + [1]) n, m = LI() l = [] dfs(0, []) qu = LIR(m) p = LI() ans = 0 for k in l: s = 0 for q in range(m): num = qu[q][0] lis = list([x - 1 for x in qu[q][1:]]) su = 0 for i in lis: su ^= k[i] if su == p[q]: s += 1 if s == m: ans += 1 print(ans) return # D def D(): n = I() return # E def E(): n = I() return # F def F(): n = I() return # Solve if __name__ == "__main__": C()

#!usr/bin/env python3 from collections import defaultdict, deque from heapq import heappush, heappop import sys import math import bisect import random def LI(): return [int(x) for x in sys.stdin.readline().split()] def I(): return int(sys.stdin.readline()) def LS(): return [list(x) for x in sys.stdin.readline().split()] def S(): res = list(sys.stdin.readline()) if res[-1] == "\n": return res[:-1] return res def IR(n): return [I() for i in range(n)] def LIR(n): return [LI() for i in range(n)] def SR(n): return [S() for i in range(n)] def LSR(n): return [LS() for i in range(n)] sys.setrecursionlimit(1000000) mod = 1000000007 def solve(): n, m = LI() s = LIR(m) p = LI() ans = 0 for i in range(m): s[i] = sum([1 << (j - 1) for j in s[i][1:]]) for b in range(1 << n): for i in range(m): if bin(s[i] & b).count("1") & 1 != p[i]: break else: ans += 1 print(ans) return # Solve if __name__ == "__main__": solve()

u624689667

p03111

python

s927984891

s335460373

Accepted

Accepted

import itertools n_bamboo, b1, b2, b3 = [int(i) for i in input().split()] bamboos = [int(eval(input())) for _ in range(n_bamboo)] ans = float("inf") # すべての竹について、b1, b2, b3のどの竹に使うかを列挙 # 0のときはどの竹にも使わない for bit in itertools.product((0, 1, 2, 3), repeat=n_bamboo): l1, l2, l3 = 0, 0, 0 c1, c2, c3 = 0, 0, 0 # 選択した竹を足す（2つ目以降はMP10消費） for b, bamboo in zip(bit, bamboos): if b == 1: if l1 > 0: c1 += 10 l1 += bamboo elif b == 2: if l2 > 0: c2 += 10 l2 += bamboo elif b == 3: if l3 > 0: c3 += 10 l3 += bamboo # 1つも構成する竹がない竹がある場合はスキップ if l1 * l2 * l3 == 0: continue # 延長、短縮のコスト c1 += abs(b1 - l1) c2 += abs(b2 - l2) c3 += abs(b3 - l3) # 合計コストが今までより低ければ更新 ans = min(ans, c1 + c2 + c3) print(ans)

def dfs(cursor, a, b, c): if cursor == N: return abs(A - a) + abs(B - b) + abs(C - c) - 30 if min(a, b, c) > 0 else float("inf") ret0 = dfs(cursor + 1, a, b, c) ret1 = dfs(cursor + 1, a + l[cursor], b, c) + 10 ret2 = dfs(cursor + 1, a, b + l[cursor], c) + 10 ret3 = dfs(cursor + 1, a, b, c + l[cursor]) + 10 return min(ret0, ret1, ret2, ret3) N, A, B, C = [int(i) for i in input().split()] l = [int(eval(input())) for _ in range(N)] print((dfs(0, 0, 0, 0)))

import itertools n_bamboo, b1, b2, b3 = [int(i) for i in input().split()] bamboos = [int(eval(input())) for _ in range(n_bamboo)] ans = float("inf") # すべての竹について、b1, b2, b3のどの竹に使うかを列挙 # 0のときはどの竹にも使わない for bit in itertools.product((0, 1, 2, 3), repeat=n_bamboo): l1, l2, l3 = 0, 0, 0 c1, c2, c3 = 0, 0, 0 # 選択した竹を足す（2つ目以降はMP10消費） for b, bamboo in zip(bit, bamboos): if b == 1: if l1 > 0: c1 += 10 l1 += bamboo elif b == 2: if l2 > 0: c2 += 10 l2 += bamboo elif b == 3: if l3 > 0: c3 += 10 l3 += bamboo # 1つも構成する竹がない竹がある場合はスキップ if l1 * l2 * l3 == 0: continue # 延長、短縮のコスト c1 += abs(b1 - l1) c2 += abs(b2 - l2) c3 += abs(b3 - l3) # 合計コストが今までより低ければ更新 ans = min(ans, c1 + c2 + c3) print(ans)

def dfs(cursor, a, b, c): if cursor == N: return ( abs(A - a) + abs(B - b) + abs(C - c) - 30 if min(a, b, c) > 0 else float("inf") ) ret0 = dfs(cursor + 1, a, b, c) ret1 = dfs(cursor + 1, a + l[cursor], b, c) + 10 ret2 = dfs(cursor + 1, a, b + l[cursor], c) + 10 ret3 = dfs(cursor + 1, a, b, c + l[cursor]) + 10 return min(ret0, ret1, ret2, ret3) N, A, B, C = [int(i) for i in input().split()] l = [int(eval(input())) for _ in range(N)] print((dfs(0, 0, 0, 0)))

u188827677

p03339

python

s500297093

s248071109

Accepted

Accepted

n = int(eval(input())) s = eval(input()) w = [0]*n e = [0]*n for i in range(n): if s[i] == "W": w[i] += 1 else: e[i] += 1 if i != n-1: w[i+1] = w[i] e[i+1] = e[i] ans = e[-1]-e[0] for i in range(1,n): ans = min(ans, w[i-1] + e[-1]-e[i]) print(ans)

n = int(eval(input())) s = eval(input()) w = [0]*n e = [0]*n if s[0] == "W": w[0] = 1 else: e[0] = 1 for i in range(1,n): if s[i] == "W": w[i] = w[i-1]+1 e[i] = e[i-1] else: w[i] = w[i-1] e[i] = e[i-1]+1 ans = float("inf") for i in range(n): t = 0 if i != 0: t += w[i-1] if i != n-1: t += e[-1] - e[i] if t < ans: ans = t print(ans)

n = int(eval(input())) s = eval(input()) w = [0] * n e = [0] * n for i in range(n): if s[i] == "W": w[i] += 1 else: e[i] += 1 if i != n - 1: w[i + 1] = w[i] e[i + 1] = e[i] ans = e[-1] - e[0] for i in range(1, n): ans = min(ans, w[i - 1] + e[-1] - e[i]) print(ans)

n = int(eval(input())) s = eval(input()) w = [0] * n e = [0] * n if s[0] == "W": w[0] = 1 else: e[0] = 1 for i in range(1, n): if s[i] == "W": w[i] = w[i - 1] + 1 e[i] = e[i - 1] else: w[i] = w[i - 1] e[i] = e[i - 1] + 1 ans = float("inf") for i in range(n): t = 0 if i != 0: t += w[i - 1] if i != n - 1: t += e[-1] - e[i] if t < ans: ans = t print(ans)

u467041847

p03416

python

s490395080

s379388378

Accepted

Accepted

A,B = list(map(int,input().split())) def kaibun(m, n): key = 0 for i in range(m,n+1): if str(i) == str(i)[::-1]: key += 1 return key print((kaibun(A,B)))

A,B = list(map(int,input().split())) def kaibun(m, n): key = 0 for i in range(m,n+1): s = i//10000 t = i%10 u = i//1000 % 10 v = i//10 % 10 if (s==t)&(u==v): key += 1 return key print((kaibun(A,B)))

A, B = list(map(int, input().split())) def kaibun(m, n): key = 0 for i in range(m, n + 1): if str(i) == str(i)[::-1]: key += 1 return key print((kaibun(A, B)))

A, B = list(map(int, input().split())) def kaibun(m, n): key = 0 for i in range(m, n + 1): s = i // 10000 t = i % 10 u = i // 1000 % 10 v = i // 10 % 10 if (s == t) & (u == v): key += 1 return key print((kaibun(A, B)))

u163320134

p02930

python

s707476799

s076812140

Accepted

Accepted

n=int(eval(input())) ans=[[0]*n for _ in range(n)] for i in range(n): for j in range(n): tmp=i^j if tmp==0: ans[i][j]=1 else: tmp=format(tmp,'b')[::-1] ans[i][j]=tmp.index('1')+1 for i in range(n-1): print((*ans[i][i+1:]))

def dfs(color,l,r): if l==r: return for i in range(l,(l+r)//2+1): for j in range((l+r)//2+1,r+1): ans[i][j]=color dfs(color+1,l,(l+r)//2) dfs(color+1,(l+r)//2+1,r) n=int(eval(input())) ans=[[0]*(n+1) for _ in range(n+1)] dfs(1,1,n) for i in range(1,n): print((*ans[i][i+1:n+1]))

n = int(eval(input())) ans = [[0] * n for _ in range(n)] for i in range(n): for j in range(n): tmp = i ^ j if tmp == 0: ans[i][j] = 1 else: tmp = format(tmp, "b")[::-1] ans[i][j] = tmp.index("1") + 1 for i in range(n - 1): print((*ans[i][i + 1 :]))

def dfs(color, l, r): if l == r: return for i in range(l, (l + r) // 2 + 1): for j in range((l + r) // 2 + 1, r + 1): ans[i][j] = color dfs(color + 1, l, (l + r) // 2) dfs(color + 1, (l + r) // 2 + 1, r) n = int(eval(input())) ans = [[0] * (n + 1) for _ in range(n + 1)] dfs(1, 1, n) for i in range(1, n): print((*ans[i][i + 1 : n + 1]))