input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
#!/usr/bin/env python3
import sys
def solve(N: int, S: str):
answer = 0
for i in range(0,1000):
i = str(i).zfill(3)
index = 0
for ss in S:
if ss == i[index]:
index += 1
if index >= 3:
answer += 1
break
print(answer)
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
S = next(tokens) # type: int
solve(N, S)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, S: str):
answer = 0
for i in range(0,1000):
i = str(i).zfill(3)
x = S.find(i[0])
if x == -1:
continue
y = S.find(i[1],x+1)
if y == -1:
continue
z = S.find(i[2],y+1)
if z == -1:
continue
answer +=1
print(answer)
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
S = next(tokens) # type: str
solve(N, S)
if __name__ == '__main__':
main()
| p02844 |
from pprint import pprint
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
count = 0
for i in range(1000):
pin = str(i).zfill(3)
start = 0
flags = [False] * 3
for i, pin_i in enumerate(pin):
flag = False
for j, s_j in enumerate(s):
if j < start:
continue
if s_j == pin_i:
flag = True
start = j + 1
break
flags[i] = flag
if flags[0] and flags[1] and flags[2]:
# print(pin)
count += 1
print(count) | import sys
N = int(sys.stdin.readline())
S = sys.stdin.readline()
ans = 0
for i in range(1000):
password = str(i).zfill(3)
p_i = 0
s_i = 0
while s_i < len(S) and p_i < 3:
# print(p_i, s_i)
if S[s_i] == password[p_i]:
p_i += 1
s_i += 1
if p_i == 3:
ans += 1
print(ans) | p02844 |
import math
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
# 初期入力 ２０２０－０７２７ 21：50
from collections import Counter
import sys
input = sys.stdin.readline #文字列では使わない
N = int(eval(input()))
*S, =input().strip()
"""
c =Counter(S)
ans =combinations_count(N, 3) -len(c)
"""
count =0
x100=0
x10=0
x1=0
for i in range(10):
for j in range(10):
for k in range(10):
if str(i) in S:
x100 =S.index(str(i)) +1
if str(j) in S[x100:]:
x10 =S[x100:].index(str(j)) +1
if str(k) in S[x100 +x10:]:
x1 =S[x100+x10:].index(str(k)) +1
count +=1
#print("aa",i,j,k,"bb",x100,x100+x10,x100+x10+x1)
print(count) | # forしながらif、ifでないときはforしないので、計算量減
# 初期入力 ２０２０－０７２７ 21：50
from collections import Counter
import sys
input = sys.stdin.readline #文字列では使わない
N = int(eval(input()))
*S, =input().strip()
"""
c =Counter(S)
ans =combinations_count(N, 3) -len(c)
"""
count =0
x100=0
x10=0
x1=0
for i in range(10):
if str(i) in S:
x100 =S.index(str(i)) +1
for j in range(10):
if str(j) in S[x100:]:
x10 =S[x100:].index(str(j)) +1
for k in range(10):
if str(k) in S[x100 +x10:]:
x1 =S[x100+x10:].index(str(k)) +1
count +=1
#print("aa",i,j,k,"bb",x100,x100+x10,x100+x10+x1)
print(count) | p02844 |
def strKey(key):
if key == 0:
return '000'
if 1<= key <= 9:
return '00' + str(key)
if 10<= key <=99:
return '0' + str(key)
return str(key)
N = int(eval(input()))
s = input().strip()
cnt = 0
for key in range(1000):
key = strKey(key) #; print(key)
isFlag = False
for i0 in range(N-2):
if isFlag == True:
break
if s[i0] == key[0]:
for i1 in range(i0+1, N-1):
if isFlag == True:
break
if s[i1] == key[1]:
for i2 in range(i1+1, N):
if s[i2] == key[2]:
cnt += 1 #; print(i0, i1, i2, key)
isFlag = True
break
print(cnt) | N = int(eval(input()))
s = input().strip()
cnt = 0
for key in range(1000):
key = '{:0>3}'.format(str(key)) #; print(key)
i0 = s.find(key[0])
if 0 <= i0 < N-2:
i1 = s.find(key[1], i0+1)
if 0 < i1 < N-1:
i2 = s.find(key[2], i1+1)
if i2 != -1:
cnt += 1
else:
continue
else:
continue
else:
continue
print(cnt) | p02844 |
#!/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())
S = readline()
count = 0
for i in range(0,1000):
c = (i//100,(i//10)%10,i%10)
f = 0
for j in range(0,N):
if int(S[j]) == int(c[f]):
f += 1
if f == 3:
break
if f == 3:
count += 1
print(count) | #!/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())
S = readline()
count = 0
for i in range(10):
a = S.find(str(i))
if a == -1:
continue
for j in range(10):
b = S.find(str(j),a+1)
if b == -1:
continue
for k in range(10):
c = S.find(str(k),b+1)
if c != -1: count +=1
print(count) | p02844 |
# coding: utf-8
def solve(*args: str) -> str:
n = int(args[0])
s = args[1]
ret = 0
for i in range(1000):
iii = '{:03d}'.format(i)
j = 0
for k in range(n):
if s[k] == iii[j]:
j += 1
if j == 3:
ret += 1
break
return str(ret)
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
| # coding: utf-8
def solve(*args: str) -> str:
n = int(args[0])
s = args[1]
ret = 0
index = [[] for _ in range(10)]
for i in range(n):
index[int(s[i])].append(i)
for i in range(1000):
iii = '{:03d}'.format(i)
cur = -1
found = False
for e, j in enumerate(iii):
found = False
for k in index[int(j)]:
if cur < k:
found = True
cur = k
break
if not found:
break
if found:
ret += 1
return str(ret)
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
| p02844 |
import sys
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
def sumitrust2019_d(a,b,c,s):
a,b,c = list(map(str,[a,b,c]))
for idx_a in range(len(s)-2):
if s[idx_a] == a:
for idx_b in range(idx_a+1,len(s)-1):
if s[idx_b] == b:
for idx_c in range(idx_b+1,len(s)):
if s[idx_c] == c:
return True
else:
return False
def main():
n = ni()
s = ns()
ans = 0
for a in range(10):
for b in range(10):
for c in range(10):
if sumitrust2019_d(a,b,c,s):
ans += 1
print(ans)
return
if __name__ == '__main__':
main() | import sys
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
def sumitrust2019_d(a,b,c,s):
abc = list(map(str,[a,b,c]))
now = 0
for i in range(len(s)):
if s[i] == abc[now]:
now += 1
if now == 3:
return True
return False
def main():
n = ni()
s = ns()
ans = 0
for a in range(10):
for b in range(10):
for c in range(10):
if sumitrust2019_d(a,b,c,s):
ans += 1
print(ans)
return
if __name__ == '__main__':
main()
| p02844 |
import sys
from itertools import product
from string import digits
def main():
n, s = sys.stdin.read().split()
n = int(n)
cand = list(''.join(p) for p in product(digits, repeat=3))
res = set()
for c in cand:
i = s.find(c[0])
if i == -1:
continue
j = s.find(c[1], i+1)
if j == -1:
continue
k = s.find(c[2], j+1)
if k == -1:
continue
res.add(c)
ans = len(res)
print(ans)
if __name__ == '__main__':
main() | import sys
from string import digits
def main():
n, s = sys.stdin.read().split()
res = []
for i in digits:
x = s.find(i)
if x == -1:
continue
for j in digits:
y = s.find(j, x+1)
if y == -1:
continue
for k in digits:
z = s.find(k, y+1)
if z == -1:
continue
res.append((i, j, k))
print((len(res)))
if __name__ == '__main__':
main() | p02844 |
import sys
from string import digits
def main():
n, s = sys.stdin.read().split()
n = int(n)
place = dict((i, set()) for i in digits)
for i in range(n):
place[s[i]].add(i)
l = [None] * n
l[0] = set()
for i in range(1, n):
l[i] = l[i-1] | set([s[i-1]])
r = [None] * n
r[n-1] = set()
for i in range(n-2, -1, -1):
r[i] = r[i+1] | set([s[i+1]])
res = set()
for j in digits:
for c in place[j]:
for i in digits:
if i in l[c]:
for k in digits:
if k in r[c]:
res.add((i, j, k))
print((len(res)))
if __name__ == '__main__':
main() | import sys
from string import digits
def main():
n, s = sys.stdin.read().split()
n = int(n)
place = dict((i, set()) for i in digits)
for i in range(n):
place[s[i]].add(i)
l = [None] * n
l[0] = set()
for i in range(1, n):
l[i] = l[i-1] | set([s[i-1]])
r = [None] * n
r[n-1] = set()
for i in range(n-2, -1, -1):
r[i] = r[i+1] | set([s[i+1]])
res = set()
for j in digits:
for i in digits:
for k in digits:
for c in place[j]:
if not i in l[c]:
continue
if not k in r[c]:
continue
res.add((i, j, k))
break
print((len(res)))
if __name__ == '__main__':
main() | p02844 |
import sys
from string import digits
def main():
n, s = sys.stdin.read().split()
n = int(n)
place = dict((i, set()) for i in digits)
for i in range(n):
place[s[i]].add(i)
l = [None] * n
l[0] = set()
for i in range(1, n):
l[i] = l[i-1] | set([s[i-1]])
r = [None] * n
r[n-1] = set()
for i in range(n-2, -1, -1):
r[i] = r[i+1] | set([s[i+1]])
res = set()
for j in digits:
for i in digits:
for k in digits:
for c in place[j]:
if not i in l[c]:
continue
if not k in r[c]:
continue
res.add((i, j, k))
break
print((len(res)))
if __name__ == '__main__':
main() | import sys
from string import digits
def main():
n, s = sys.stdin.read().split()
n = int(n)
place = dict((i, list()) for i in digits)
for i in range(n):
place[s[i]].append(i)
l = [None] * n
l[0] = set()
for i in range(1, n):
l[i] = l[i-1] | set([s[i-1]])
r = [None] * n
r[n-1] = set()
for i in range(n-2, -1, -1):
r[i] = r[i+1] | set([s[i+1]])
res = set()
for j in digits:
p = place[j]
if not p:
continue
for i in digits:
for k in digits:
for c in p:
if not k in r[c]:
break
if not i in l[c]:
continue
res.add((i, j, k))
break
print((len(res)))
if __name__ == '__main__':
main() | p02844 |
import sys
from string import digits
def main():
n, s = sys.stdin.read().split()
n = int(n)
place = dict((i, list()) for i in digits)
for i in range(n):
place[s[i]].append(i)
l = [None] * n
l[0] = set()
for i in range(1, n):
l[i] = l[i-1] | set([s[i-1]])
r = [None] * n
r[n-1] = set()
for i in range(n-2, -1, -1):
r[i] = r[i+1] | set([s[i+1]])
res = set()
for j in digits:
p = place[j]
if not p:
continue
for i in digits:
for k in digits:
for c in p:
if not k in r[c]:
break
if not i in l[c]:
continue
res.add((i, j, k))
break
print((len(res)))
if __name__ == '__main__':
main() | import sys
from string import digits
def main():
n, s = sys.stdin.read().split()
cnt = 0
for i in digits:
x = s.find(i)
if x == -1:
continue
for j in digits:
y = s.find(j, x + 1)
if y == -1:
continue
for k in digits:
z = s.find(k, y + 1)
if z == -1:
continue
cnt += 1
print(cnt)
if __name__ == '__main__':
main() | p02844 |
import bisect
import collections
def read():
N = int(input().strip())
S = str(input().strip())
return N, S
def dig(S, T, N):
for i in range(N):
if S[i] == T[0]:
for j in range(i+1, N):
if S[j] == T[1]:
for k in range(j+1, N):
if S[k] == T[2]:
return True
return False
def solve(N, S):
d = [collections.deque() for i in range(10)]
count = 0
for p in range(1000):
T = '{:03d}'.format(p)
count += 1 if dig(S, T, N) else 0
return count
if __name__ == '__main__':
inputs = read()
output = solve(*inputs)
print(("%d" % output))
| import bisect
import collections
def read():
N = int(input().strip())
S = str(input().strip())
return N, S
def dig(S, T, N):
k0, k1, k2 = -1, -1, -1
for i in range(N):
if S[i] == T[0]:
k0 = i
break
if k0 == -1:
return False
for i in range(k0+1, N):
if S[i] == T[1]:
k1 = i
break
if k1 == -1:
return False
for i in range(k1+1, N):
if S[i] == T[2]:
k2 = i
break
if k2 == -1:
return False
return True
def solve(N, S):
d = [collections.deque() for i in range(10)]
count = 0
for p in range(1000):
T = '{:03d}'.format(p)
count += 1 if dig(S, T, N) else 0
return count
if __name__ == '__main__':
inputs = read()
output = solve(*inputs)
print(("%d" % output))
| p02844 |
import sys
import itertools
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N = int(eval(input()))
S = input().rstrip()
s = set()
l = list(itertools.combinations(S, 3))
for x in l:
s.add(x[0]+x[1]+x[2])
print((len(s)))
| import sys
import itertools
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N = int(eval(input()))
S = input().rstrip()
s = set()
for i in range(0, N-2):
for j in range(i+1, N-1):
for k in range(j+1, N):
s.add(S[i]+S[j]+S[k])
print((len(s)))
| p02844 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N = int(eval(input()))
S = input().rstrip()
ans = 0
for i in range(1000):
t = str(i).zfill(3)
ti = 0
for j in range(N):
if S[j] == t[ti]:
ti += 1
if ti == 3:
break
if ti == 3:
ans += 1
print(ans)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N = int(eval(input()))
S = input().rstrip()
ans = 0
for i in range(1000):
t = str(i).zfill(3)
t1 = S.find(t[0])
if t1 == -1:
continue
t2 = S.find(t[1], t1+1)
if t2 == -1:
continue
t3 = S.find(t[2], t2+1)
if t3 == -1:
continue
ans += 1
print(ans)
| p02844 |
N = int(eval(input()))
S = input().rstrip()
dp = [[[[False for _ in range(11)] for _ in range(11)]
for _ in range(11)] for _ in range(N + 1)]
for i in range(N):
num = int(S[i])
for j in range(11):
for k in range(11):
for l in range(11):
dp[i + 1][num][10][10] = True
dp[i + 1][j][10][10] = dp[i][j][10][10]
dp[i + 1][j][num][10] = dp[i][j][10][10]
dp[i + 1][j][k][10] = dp[i][j][k][10]
dp[i + 1][j][k][num] = dp[i][j][k][10]
dp[i + 1][j][k][l] = dp[i][j][k][l]
ans = 0
for i in range(10):
for j in range(10):
for k in range(10):
if dp[N][i][j][k]:
# print(i, j, k)
ans += 1
print(ans)
| N = int(eval(input()))
S = input().rstrip()
ans = 0
for i in range(10):
for j in range(10):
for k in range(10):
num = str(i) + str(j) + str(k)
tmp = 0
for s in S:
if num[tmp] == s:
tmp += 1
if tmp >= 3:
break
if tmp == 3:
ans += 1
print(ans)
| p02844 |
import sys
import math
input = sys.stdin.readline
def main():
sc = Scan()
N = sc.intarr()[0]
S = sc.strarr()[0]
count = 0
for i in range(1000):
# print("--------")
lucky = format_str(i)
Flag = 0
for j in range(N):
if S[j] == lucky[Flag]:
Flag += 1
if Flag == 3:
count += 1
break
print(count)
def format_str(num):
if num < 10:
return "00" + str(num)
elif num < 100:
return "0" + str(num)
else:
return str(num)
class Scan():
def intarr(self):
line = input()
array = line.split(' ')
num_array = [int(n) for n in array]
return num_array
def intarr_ver(self, n):
return [int(input()) for _ in range(n)]
def strarr(self):
line = input()
array = line.split(' ')
array[-1] = array[-1].strip('\n')
return array
def display(array):
for a in range(len(array)):
if len(array) - a != 1:
print(array[a], end=' ')
else:
print(array[a])
main()
| import sys
import math
input = sys.stdin.readline
def main():
sc = Scan()
_ = sc.intarr()[0]
S = sc.strarr()[0]
count = 0
for i in range(1000):
# print("--------")
lucky = format_str(i)
first = S.find(lucky[0])
third = S.rfind(lucky[2])
if first == -1 or third == -1:
continue
elif first < third:
if lucky[1] in S[first + 1:third]:
count += 1
print(count)
def format_str(num):
if num < 10:
return "00" + str(num)
elif num < 100:
return "0" + str(num)
else:
return str(num)
class Scan():
def intarr(self):
line = input()
array = line.split(' ')
num_array = [int(n) for n in array]
return num_array
def intarr_ver(self, n):
return [int(input()) for _ in range(n)]
def strarr(self):
line = input()
array = line.split(' ')
array[-1] = array[-1].strip('\n')
return array
def display(array):
for a in range(len(array)):
if len(array) - a != 1:
print(array[a], end=' ')
else:
print(array[a])
main()
| p02844 |
import sys
input = sys.stdin.readline # 改行コード「\n」を呼んでしまうため、文字数など、注意！！
n = int(input().replace("\n",""))
s = input().replace("\n","")
anslist = []
ans = 0
for i in range(1000):
if i < 10:
chk = '00' + str(i)
elif i < 100:
chk = '0' + str(i)
else:
chk = str(i)
for j in range(len(s)):
if s[j] == chk[0]:
for k in range(j+1, len(s)):
if s[k] == chk[1]:
for l in range(k+1, len(s)):
if s[l] == chk[2]:
# print(chk)
anslist.append(chk)
continue
ans = len(set(anslist))
print(ans) | import sys
input = sys.stdin.readline # 改行コード「\n」を呼んでしまうため、文字数など、注意！！
n = int(input().replace("\n",""))
s = input().replace("\n","")
ans = 0
for i in range(1000):
i = str(i).zfill(3)
x = s.find(i[0])
y = s.find(i[1], x+1)
z = s.find(i[2], y+1)
if x != -1 and y != -1 and z != -1:
ans += 1
print(ans) | p02844 |
#三井住友2019 D 貪欲法
def main():
import sys
N = int(sys.stdin.readline())
S = sys.stdin.readline().rstrip()
ans = 0
for i in range(1000):
num = str(i).zfill(3)
L = []
k = 0
for j in range(N):
#print(num, S[j])
if int(S[j])==int(num[k]):
#print('Yes', num)
L.append(S[j])
k+=1
if len(L)==3:
#print(L)
ans +=1
break
print(ans)
if __name__=='__main__':
main()
| #三井住友2019 D
def main():
import sys
N = int(sys.stdin.readline())
S = sys.stdin.readline().rstrip()
cnt = 0
for i in range(0, 10):
for j in range(0, 10):
for k in range(0, 10):
st1 = S.find(str(i))
if st1 ==-1:
continue
st2 = S[st1+1:].find(str(j))
if st2 ==-1:
continue
st3 = S[st1+st2+2:].find(str(k))
if st3 ==-1:
continue
#print(st1,st2,st3, i,j,k)
cnt +=1
print(cnt)
if __name__=='__main__':
main() | p02844 |
import sys
from collections import deque
from itertools import *
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
n = I()
s = S()
ans = 0
for i in range(1000):
t = str(i).zfill(3)
t_index = 0
for s_index in range(n):
if s[s_index] == t[t_index]:
t_index += 1
if t_index == 3:
break
if t_index == 3:
ans += 1
print(ans)
| import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
s = S()
ans = 0
for i in range(1000):
num = str(i).zfill(3)
if s.find(num[0]) == -1:
continue
s1 = s[s.find(num[0])+1:]
if s1.find(num[1]) == -1:
continue
s2 = s1[s1.find(num[1])+1:]
if s2.find(num[2]) == -1:
continue
ans+=1
print(ans)
| p02844 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n = I()
s = S()
cnt = 0
for i in range(10 ** 3):
flag = 0
for j in range(n):
for k in range(3):
if flag == k and str(i).zfill(3)[k] == s[j]:
flag += 1
break
if flag == 3:
cnt += 1
break
print(cnt) | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n = I()
s = S()
cnt = 0
ans = set()
one_digit_set = set()
two_digit_set = set()
for i in range(n):
for two_d in two_digit_set:
ans.add(s[i] + two_d)
for one_d in one_digit_set:
two_digit_set.add(s[i] + one_d)
one_digit_set.add(s[i])
print((len(ans)))
| p02844 |
import sys
input = sys.stdin.readline
lists = ['{0:03d}'.format(i) for i in range(1000)]
import re
def check(target, a):
ans = re.search(a, target)
if ans == None:
return None
else:
return target[ans.start()+1:]
def print_ans(N, S):
"""Test Case
>>> print_ans(4, "0224")
3
>>> print_ans(6, "123123")
17
>>> print_ans(19, "3141592653589793238")
329
"""
# s = set()
# for i in range(N):
# for k in range(i+1,N):
# for l in range(k+1, N):
# s.add(S[i] + S[k] + S[l])
# print(len(s))
ans = 0
for a in lists:
tmp = S
for i in range(3):
tmp = check(tmp, a[i])
if tmp == None:
break
if tmp != None:
ans += 1
print(ans)
# print(check('123','4'))
if __name__ == '__main__':
N = int(input().rstrip())
S = input().rstrip()
print_ans(N, S)
| import sys
input = sys.stdin.readline
lists = ['{0:03d}'.format(i) for i in range(1000)]
import re
def check(target, a):
ans = re.search(a, target)
if ans == None:
return None
else:
return target[ans.start()+1:]
def print_ans(N, S):
"""Test Case
>>> print_ans(4, "0224")
3
>>> print_ans(6, "123123")
17
>>> print_ans(19, "3141592653589793238")
329
"""
ans = 0
for a in lists:
tmp = S
for i in range(3):
tmp = check(tmp, a[i])
if tmp == None:
break
if tmp != None:
ans += 1
print(ans)
if __name__ == '__main__':
N = int(input().rstrip())
S = input().rstrip()
print_ans(N, S)
| p02844 |
import sys
sys.setrecursionlimit(10 ** 9)
stdin = sys.stdin
ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))
rs = lambda: stdin.readline().rstrip() # ignore trailing spaces
# 上限は1000
N = ri()
S = list(rs())
answer = set()
for i in range(len(S)-2):
se2 = set()
for j in range(i+1, len(S)-1):
if j in se2:
continue
se2.add(j)
se = set(S[j+1:])
x = S[i]
y = S[j]
for z in se:
answer.add((x, y, z))
print((len(answer))) | import sys
sys.setrecursionlimit(10 ** 9)
stdin = sys.stdin
ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))
rs = lambda: stdin.readline().rstrip() # ignore trailing spaces
# 上限は1000
N = ri()
S = list(rs())
answer = set()
se1 = set()
for i in range(len(S)-2):
x = S[i]
if x in se1:
continue
se1.add(x)
se2 = set()
for j in range(i+1, len(S)-1):
y = S[j]
if y in se2:
continue
se2.add(y)
se = set(S[j+1:])
for z in se:
answer.add((x, y, z))
print((len(answer)))
| p02844 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
import re
n = ni()
s = ns()
cnt = 0
for i in range(10):
for j in range(10):
for k in range(10):
pattern = ".*" + str(i) + ".*" + str(j) + ".*" + str(k) + ".*"
reptn = re.compile(pattern)
if re.search(reptn, s):
cnt += 1
print(cnt)
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
import re
n = ni()
s = ns()
cnt = 0
cand = []
for i in range(10):
for j in range(10):
for k in range(10):
stri = str(i)
strj = str(j)
strk = str(k)
first = False
second = False
for si in s:
if si == strk and first and second:
cnt += 1
break
elif si == strj and first:
second = True
elif si == stri:
first = True
print(cnt)
| p02844 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
S = readline().strip()
ans = 0
for p in range(1000):
pattern = str(p).zfill(3)
key = 0
cnt = 0
for n in pattern:
for i in range(key,N):
if S[i] == n:
key = i+1
cnt += 1
break
if cnt == 3:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
S = readline().strip()
ans = 0
for p in range(1000):
pattern = str(p).zfill(3)
cnt = 0
T = S
for n in pattern:
i = T.find(n)
if i != -1:
T = T[i+1:]
cnt += 1
if cnt == 3:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| p02844 |
import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list([x-1 for x in MII()])
## dp ##
def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]
## math ##
def to_bin(x: int) -> str: return format(x, 'b') # rev => int(res, 2)
def to_oct(x: int) -> str: return format(x, 'o') # rev => int(res, 8)
def to_hex(x: int) -> str: return format(x, 'x') # rev => int(res, 16)
MOD=10**9+7
def divc(x,y) -> int: return -(-x//y)
def divf(x,y) -> int: return x//y
def gcd(x,y):
while y: x,y = y,x%y
return x
def lcm(x,y): return x*y//gcd(x,y)
def enumerate_divs(n):
"""Return a tuple list of divisor of n"""
return [(i,n//i) for i in range(1,int(n**0.5)+1) if n%i==0]
def get_primes(MAX_NUM=10**3):
"""Return a list of prime numbers n or less"""
is_prime = [True]*(MAX_NUM+1)
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX_NUM**0.5)+1):
if not is_prime[i]: continue
for j in range(i*2, MAX_NUM+1, i):
is_prime[j] = False
return [i for i in range(MAX_NUM+1) if is_prime[i]]
## libs ##
from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left
#======================================================#
def main():
n = II()
s = IS()
def check(A):
for i in range(n-2):
if s[i] == A[0]:
for j in range(i+1, n-1):
if s[j] == A[1]:
for k in range(j+1, n):
if s[k] == A[2]:
return 1
return 0
def dfs(A):
if len(A) == 3:
return check(A)
res = 0
for v in range(10):
A.append(str(v))
res += dfs(A)
A.pop()
return res
print((dfs([])))
if __name__ == '__main__':
main() | import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list([x-1 for x in MII()])
## dp ##
def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]
## math ##
def to_bin(x: int) -> str: return format(x, 'b') # rev => int(res, 2)
def to_oct(x: int) -> str: return format(x, 'o') # rev => int(res, 8)
def to_hex(x: int) -> str: return format(x, 'x') # rev => int(res, 16)
MOD=10**9+7
def divc(x,y) -> int: return -(-x//y)
def divf(x,y) -> int: return x//y
def gcd(x,y):
while y: x,y = y,x%y
return x
def lcm(x,y): return x*y//gcd(x,y)
def enumerate_divs(n):
"""Return a tuple list of divisor of n"""
return [(i,n//i) for i in range(1,int(n**0.5)+1) if n%i==0]
def get_primes(MAX_NUM=10**3):
"""Return a list of prime numbers n or less"""
is_prime = [True]*(MAX_NUM+1)
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX_NUM**0.5)+1):
if not is_prime[i]: continue
for j in range(i*2, MAX_NUM+1, i):
is_prime[j] = False
return [i for i in range(MAX_NUM+1) if is_prime[i]]
## libs ##
from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left
#======================================================#
def main():
n = II()
s = IS()
c = [str(i).zfill(3) for i in range(1000)]
cnt = 0
for ci in c:
id_1 = s.find(ci[0])
if id_1 == -1: continue
id_2 = s.find(ci[1], id_1+1)
if id_2 == -1: continue
id_3 = s.find(ci[2], id_2+1)
if id_3 == -1: continue
cnt += 1
print(cnt)
if __name__ == '__main__':
main() | p02844 |
N = int(eval(input()))
S = input().strip()
cnt = 0
for i in range(10):
for j in range(10):
for k in range(10):
cur = [i,j,k]
ind = 0
for n in range(N):
if int(S[n])==cur[ind]:
ind += 1
if ind==3:break
if ind==3:
cnt += 1
print(cnt) | N = int(eval(input()))
S = list(map(int,list(input().strip())))
cnt = 0
for i in range(10):
for j in range(10):
for k in range(10):
cur = [i,j,k]
ind = 0
for n in range(N):
if S[n]==cur[ind]:
ind += 1
if ind==3:
cnt += 1
break
print(cnt) | p02844 |
N = int(eval(input()))
S = input().strip()
cnt = 0
for i in range(10):
for j in range(10):
for k in range(10):
flag = 0
for n in range(N):
if flag==0 and S[n]==str(i):
flag = 1
elif flag==1 and S[n]==str(j):
flag = 2
elif flag==2 and S[n]==str(k):
flag = 3
break
if flag==3:
cnt += 1
print(cnt) | def chk(x):
cur = 0
cnt = 0
while cur<N:
if S[cur]==str(x[cnt]):
cnt += 1
if cnt==3:
break
cur += 1
if cnt==3:
return 1
else:
return 0
N = int(eval(input()))
S = input().strip()
cnt = 0
for i in range(0,10):
for j in range(0,10):
for k in range(0,10):
cnt += chk((i,j,k))
print(cnt) | p02844 |
import sys
from itertools import combinations
input = sys.stdin.readline
def main():
# 種類
N = int(eval(input()))
S = input().strip()
print((len(set(combinations(S, 3)))))
if __name__ == "__main__":
main()
| import sys
from itertools import combinations
input = sys.stdin.readline
def check_num(text):
cnt = 0
for i in range(10):
index = text.find(str(i))
if index != -1:
cnt += 1
return cnt
def main():
# 種類
# N = int(input())
# S = input().strip()
S = sum(str(i) for i in range(10))
for i in range(10):
index = S.find(str(i))
if index != -1:
a = check_num(S[index:])
# 10個の数字
# 最大1000件
# 0-9:0-9:0-9
# print(len(set(combinations(S, 3))))
def hoge():
N = int(eval(input()))
S = input().strip()
count = 0
for x in range(10):
xindex = S.find(str(x))
if xindex == -1:
continue
for y in range(10):
yindex = S[xindex + 1 :].find(str(y))
if yindex == -1:
continue
for z in range(10):
zindex = S[xindex + 1 :][yindex + 1 :].find(str(z))
if zindex == -1:
continue
count += 1
print(count)
if __name__ == "__main__":
hoge()
| p02844 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n = int(readline())
s = read().rstrip().decode()
cnt = 0
for i in range(1000):
num = ''
if i < 100:
num += '0'
if i < 10:
num += '0'
num += str(i)
index = 0
for ss in s:
if ss == num[index]:
index += 1
if index == 3:
cnt += 1
break
print(cnt)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n = int(readline())
s = read().rstrip().decode()
cnt = 0
for i in range(1000):
num = str(i).zfill(3)
idx = -1
for m in num:
idx = s.find(m, idx + 1)
if idx == -1:
break
else:
cnt += 1
print(cnt)
| p02844 |
import sys
readline = sys.stdin.readline
n = int(readline())
s = readline().rstrip()
from collections import deque
q = deque([])
ss = set(s)
for i in ss:
q.append(["",0,str(i)])
ans = 0
while q:
num, ind, target = q.popleft()
#print(num, ind, target)
while ind < len(s):
if s[ind] == target: #s[ind]が０から9の中のどれかを見てる
break
ind += 1
else:
continue
num += target
if len(num) == 3:
ans += 1
continue
for i in range(10):
q.append([num, ind +1, str(i)]) #出現した数字に関するキューを追加（例：一回目は024）
print(ans) | import sys
readline = sys.stdin.readline
n = int(readline())
s = readline().rstrip()
from collections import deque
q = deque([])
ss = set(s)
for i in ss:
q.append(["",0,str(i)])
ans = 0
while q:
num, ind, target = q.popleft()
#print(num, ind, target)
while ind < len(s):
if s[ind] == target: #s[ind]が０から9の中のどれかを見てる
break
ind += 1
else:
continue
num += target
if len(num) == 3:
ans += 1
continue
sss = set(s[ind+1:])
for i in sss:
q.append([num, ind +1, str(i)]) #出現した数字に関するキューを追加（例：一回目は024）
print(ans) | p02844 |
import sys
input = sys.stdin.readline
import copy
N=int(eval(input()))
S=input().strip()
SUB={""}
ANS=set()
for s in S:
NSUB=copy.deepcopy(SUB)
for t in SUB:
x=t+s
if len(x)<=2:
NSUB.add(x)
else:
ANS.add(x)
SUB=NSUB
print((len(ANS))) | import sys
input = sys.stdin.readline
N=int(eval(input()))
S=input().strip()
SUB={""}
ANS=set()
for s in S:
N=set()
for t in SUB:
x=t+s
if len(x)<=2:
N.add(x)
else:
ANS.add(x)
SUB|=N
print((len(ANS))) | p02844 |
_,s=open(0)
x,y,z=eval('set(),'*3)
for c in s[:-1]:
for t in y:z.add(t+c)
for t in x:y.add(t+c)
x.add(c)
print((len(z))) | _,s=open(0)
x,y,z=eval('set(),'*3)
for c in s[:-1]:
z|={t+c for t in y}
y|={t+c for t in x}
x|={c}
print((len(z))) | p02844 |
from collections import*
_,s=open(0)
dp=defaultdict(bool)
for c in s[:-1]:
for i in range(100):
j=str(i).zfill(2)
dp[j+c]|=dp[j]
for i in range(10):
j=str(i)
dp[j+c]|=dp[j]
dp[c]=True
print((sum(dp[str(i).zfill(3)]for i in range(1000)))) | from collections import*
_,s=open(0)
dp=defaultdict(bool)
d1=[str(i)for i in range(10)]
d2=[str(i).zfill(2)for i in range(100)]
for c in s[:-1]:
for i in d2:
dp[i+c]|=dp[i]
for i in d1:
dp[i+c]|=dp[i]
dp[c]=True
print((sum(dp[str(i).zfill(3)]for i in range(1000)))) | p02844 |
import re
N = int(eval(input()))
S = input().strip()
count = 0
for c1 in range(10):
for c2 in range(10):
for c3 in range(10):
if re.search("{}.*{}.*{}".format(c1, c2, c3), S):
count += 1
print(count)
| import re
N = int(eval(input()))
S = [int(c) for c in input().strip()]
length = len(S)
count = 0
for c1 in range(10):
index1 = 0
while index1 < length:
if S[index1] == c1:
index1 += 1
break
index1 += 1
if index1 < length:
for c2 in range(10):
index2 = index1
while index2 < length:
if S[index2] == c2:
index2 += 1
break
index2 += 1
if index2 < length:
for c3 in range(10):
index3 = index2
while index3 < length:
if S[index3] == c3:
count += 1
break
index3 += 1
print(count)
| p02844 |
#
# ⋀_⋀
# (･ω･)
# .／ Ｕ ∽ Ｕ＼
# │＊ 合 ＊│
# │＊ 格 ＊│
# │＊ 祈 ＊│
# │＊ 願 ＊│
# │＊ ＊│
# ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def pprint(*A):
for a in A: print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
N=I()
S=ST()
can = set([""])
ans = set()
for s in S:
for c in deepcopy(can):
res = c+s
if len(res) == 3:
ans.add(res)
elif len(res) < 3:
can.add(res)
print(len(ans))
if __name__ == '__main__':
main()
| #
# ⋀_⋀
# (･ω･)
# .／ Ｕ ∽ Ｕ＼
# │＊ 合 ＊│
# │＊ 格 ＊│
# │＊ 祈 ＊│
# │＊ 願 ＊│
# │＊ ＊│
# ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def pprint(*A):
for a in A: print(*a,sep='\n')
def main():
N=int(input())
S=input()[:-1]
can = set([""]) ## 2文字以下で現在構築可能な文字列(最大10+10*10 = 1010)
ans = set() ## 3文字で現在構築可能な文字列(最大10*10*10 = 1,000)
for s in S:
for c in can.copy(): #途中でcanという集合に追加されるのでcopyする
res = c+s #2文字以下 + 1文字 で結合する
if len(res) == 3: #3文字なので暗証番号の候補
ans.add(res)
elif len(res) < 3: #2文字以下なのでcanに挿入
can.add(res)
print(len(ans))
"""
copyする回数 = N * len(can) <= 10^3 * N
for文の走査回数 = N * len(can) <= 10^3 * N
全体で 2 * (10^3 * N)
N<=3*10^4なので
2*3* 10^3 * 10^4 = 6 * 10^7 -> 間に合わない？んですか・・・？
"""
if __name__ == '__main__':
main()
| p02844 |
n = int(eval(input()))
s = list(map(int, input().rstrip()))
ans = 0
for i in range(1000):
if i < 10:
x, y, z = 0, 0, i
elif i < 100:
x, y, z = 0, i // 10, i % 10
else:
x = i // 100
y = (i - x * 100) // 10
z = i % 10
flg = 0
for a in range(len(s) - 2):
if flg == 1:
break
elif x != s[a]:
continue
else:
for b in range(a + 1, len(s) - 1):
if flg == 1:
break
elif y != s[b]:
continue
else:
for c in range(b + 1, len(s)):
if z != s[c]:
continue
else:
ans += 1
flg = 1
break
print(ans) | n = int(eval(input()))
s = list(map(int, input().rstrip()))
ans = 0
for i in range(10):
if i in s[:n - 2]:
x = s.index(i)
for j in range(10):
if j in s[x + 1:n - 1]:
y = x + s[x + 1:n - 1].index(j) + 1
for k in range(10):
if k in s[y + 1:]:
ans += 1
print(ans) | p02844 |
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip.split())
def main():
n = I()
s = list(S())
itr = itertools.combinations(s,3)
st = set()
for i in itr:
st.add(i)
print((len(st)))
main() | import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip.split())
def main():
sys.setrecursionlimit(10**5)
n = I()
s = S()
global cnt
cnt = 0
def tansaku(st,depth):
global cnt
for i in range(10):
index = st.find(str(i))
if index != -1:
if depth == 0:
cnt += 1
# print(i)
# print(st,i,index,depth)
else:
tansaku(st[index+1:],depth-1)
tansaku(s,2)
print(cnt)
main() | p02844 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)
N = int(readline())
S = readline().decode().rstrip()
ans = 0
for i in range(1000):
i_ = str(i).zfill(3)
idx = 0
for s in S:
if s == i_[idx]:
idx += 1
if idx == 3:
ans += 1
break
print(ans)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)
N = int(readline())
S = readline().decode().rstrip()
ans = 0
for i in range(1000):
num = str(i).zfill(3)
idx = 0
flag = True
for s in num:
acc = S[idx:].find(s)
if acc == -1:
flag = False
break
else:
idx += acc + 1
if flag:
ans += 1
print(ans)
| p02844 |
from sys import stdin
n = int(stdin.readline().rstrip())
s = stdin.readline().rstrip()
point = 0
for i in range(1000):
bango = str(i).zfill(3)
count = 0
for j in range(n):
if s[j] == bango[count]:
count += 1
if count == 3:
point += 1
break
print(point) | from sys import stdin
n = int(stdin.readline().rstrip())
s = stdin.readline().rstrip()
def count(poi):
point = 0
for i in range(poi):
bango = str(i).zfill(3)
count = 0
for j in range(n):
if s[j] == bango[count]:
count += 1
if count == 3:
point += 1
break
return point
print((count(1000))) | p02844 |
from itertools import groupby
def main():
n=int(eval(input()))
aa=sorted(map(int,input().split()))
d={}
for k,g in groupby(aa):
d[k] = len(list(g))
q=int(eval(input()))
bc=[]
for _ in range(q):
b,c=list(map(int,input().split()))
bc.append((b,c))
for b,c in bc:
if b in d:
d[c] = d.setdefault(c, 0) + d[b]
del d[b]
print((sum(k*v for k,v in list(d.items()))))
main() | from itertools import groupby
def main():
n=int(eval(input()))
aa=sorted(map(int,input().split()))
d={}
for k,g in groupby(aa):
d[k] = len(list(g))
q=int(eval(input()))
bc=[]
for _ in range(q):
b,c=list(map(int,input().split()))
bc.append((b,c))
s = sum(k*v for k,v in list(d.items()))
for b,c in bc:
if b in d:
s += (c-b)*d[b]
d[c] = d.setdefault(c, 0) + d[b]
del d[b]
print(s)
main() | p02630 |
n = int(eval(input()))
a = list(map(int, input().split()))
dicts = {}
for tmp in a:
if tmp in list(dicts.keys()):
dicts[tmp] += 1
else:
dicts[tmp] = 1
m = int(eval(input()))
result = 0
for key, value in list(dicts.items()):
result += key*value
for _ in range(m):
b,c = list(map(int, input().split()))
if b in list(dicts.keys()):
tmp = dicts[b]
del dicts[b]
if c in list(dicts.keys()):
dicts[c] += tmp
else:
dicts[c] = tmp
result = 0
for key, value in list(dicts.items()):
result += key*value
print(result)
else:
print(result)
| n = int(eval(input()))
a = list(map(int, input().split()))
dicts = {}
for tmp in a:
if tmp in list(dicts.keys()):
dicts[tmp] += 1
else:
dicts[tmp] = 1
m = int(eval(input()))
result = 0
for key, value in list(dicts.items()):
result += key*value
for _ in range(m):
b,c = list(map(int, input().split()))
if b in list(dicts.keys()):
tmp = dicts[b]
diff = dicts[b]*b
add = tmp*c
del dicts[b]
if c in list(dicts.keys()):
dicts[c] += tmp
else:
dicts[c] = tmp
result -= diff
result += add
print(result)
else:
print(result)
| p02630 |
from collections import defaultdict
n = int(eval(input()))
alist = list(map(int,input().split()))
q = int(eval(input()))
dict_n = defaultdict(lambda:0)
for i in alist:
dict_n[i] += 1
bclist = []
for i in range(q):
b,c = list(map(int,input().split()))
bclist.append([b,c])
for i in range(q):
b = bclist[i][0]
c = bclist[i][1]
dict_n[c] += dict_n[b]
del(dict_n[b])
sum = 0
for key in dict_n:
sum += key * dict_n[key]
print(sum) | from collections import defaultdict
n = int(eval(input()))
alist = list(map(int,input().split()))
q = int(eval(input()))
dict_n = defaultdict(lambda:0)
for i in alist:
dict_n[i] += 1
bclist = []
for i in range(q):
b,c = list(map(int,input().split()))
bclist.append([b,c])
sum = sum(alist)
for i in range(q):
b = bclist[i][0]
c = bclist[i][1]
sum += dict_n[b]*c - dict_n[b]*b
dict_n[c] += dict_n[b]
del(dict_n[b])
print(sum) | p02630 |
n = int(input().rstrip())
line = input().rstrip().split(' ')
a = []
for i in range(n):
a.append(int(line[i]))
a.sort()
q = int(input().rstrip())
b = []
c = []
for i in range(q):
line = input().rstrip().split(' ')
b = int(line[0])
c = int(line[1])
for j in range(len(a)):
if a[j] == b:
a[j] = c
ans = 0
for j in range(len(a)):
ans += a[j]
print(ans)
| n = int(input().rstrip())
line = input().rstrip().split(' ')
a = {}
ans = 0
for i in range(n):
n = int(line[i])
ans += n
if n in a:
a[n] += 1
else:
a[n] = 1
q = int(input().rstrip())
for i in range(q):
line = input().rstrip().split(' ')
b = int(line[0])
c = int(line[1])
if b in a:
ab = a[b]
a[b] = 0
if c in a:
ac = a[c]
a[c] += ab
else:
a[c] = ab
else:
ab = 0
ans -= ab * b
ans += ab * c
print(ans)
| p02630 |
N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
BC = [list(map(int, input().split())) for i in range(Q)]
# print(N)
# print(A)
# print(Q)
# print(B)
total = sum(A)
for i in range(Q):
Bi = BC[i][0]
Ci = BC[i][1]
diff = 0
for j in range(len(A)):
if A[j] == Bi:
diff += Ci - A[j]
A[j] = Ci
total += diff
print(total)
| import itertools
N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
BC = [list(map(int, input().split())) for i in range(Q)]
# print(N)
# print(A)
# print(Q)
# print(B)
distribution = {}
max_A = max(A)
max_BC = max(list(itertools.chain.from_iterable(BC)))
maximum = max([max_A, max_BC])
# print(max_A, max_BC, maximum)
for i in range(maximum + 1):
distribution[i] = 0
for Ai in A:
distribution[Ai] += 1
# print(distribution)
total = sum(A)
for i in range(Q):
Bi = BC[i][0]
Ci = BC[i][1]
num_Bi = distribution.get(Bi)
diff = (Ci - Bi) * num_Bi
distribution[Bi] = 0
# print(num_Bi, distribution.get(Bi), Ci)
distribution[Ci] += num_Bi
total += diff
print(total)
| p02630 |
from collections import Counter
R = lambda: list(map(int, input().split()))
R()
d = Counter(R())
s = sum(k * v for k,v in list(d.items()))
q, = R()
for _ in range(q):
b, c = R()
s += (c - b) * d[b]
print(s)
d[c]+=d[b]
d[b] = 0
| from collections import Counter
R = lambda: list(map(int, input().split()))
R()
d = Counter(R())
s = sum(d.elements())
q, = R()
for _ in range(q):
b, c = R()
s += (c - b) * d[b]
print(s)
d[c]+=d[b]
d[b] = 0
| p02630 |
from collections import Counter
R = lambda: list(map(int, input().split()))
R()
d = Counter(R())
s = sum(d.elements())
q, = R()
for _ in range(q):
b, c = R()
s += (c - b) * d[b]
print(s)
d[c]+=d[b]
d[b] = 0
| R = lambda: list(map(int, input().split()))
R()
a = [0] * 100001
s = 0
for x in R():
s += x
a[x] += 1
q, = R()
for _ in range(q):
b, c = R()
s += (c - b) * a[b]
print(s)
a[c]+=a[b]
a[b] = 0
| p02630 |
import collections
N = int(eval(input()))
Line = [int(s) for s in input().split()]
c = collections.Counter(Line)
# print(c)
Q = int(eval(input()))
for _ in range(Q):
Line = [int(s) for s in input().split()]
try:
c[Line[1]] += c[Line[0]]
c.pop(Line[0])
except:
pass
# print('Error')
# print(c)
s=0
for i in c:
# print(i)
s += i * c[i]
print(s)
| import collections
N = int(eval(input()))
Line = [int(s) for s in input().split()]
c = collections.Counter(Line)
# print(c)
v = 0
for i in c:
# print(i)
v += i * c[i]
# print(v)
Q = int(eval(input()))
for _ in range(Q):
Line = [int(s) for s in input().split()]
try:
c[Line[1]] += c[Line[0]]
# print(c[Line[1]],c[Line[0]])
v += c[Line[0]] * (Line[1] - Line[0])
c.pop(Line[0])
# v += c[Line[0]] * (C[Line[1]-C[Line[0]]])
except:
pass
# print('Error')
# print(c)
# s=0
# for i in c:
# # print(i)
# s += i * c[i]
print(v)
| p02630 |
from collections import Counter
N = int(eval(input()))
As = list(map(int, input().split()))
d = Counter(As)
Q = int(eval(input()))
for _ in range(Q):
B, C = list(map(int, input().split()))
if B in d:
d[C] += d[B]
d[B] = 0
print((sum(k*v for k, v in list(d.items())))) | from collections import Counter
N = int(eval(input()))
As = list(map(int, input().split()))
d = Counter(As)
S = sum(k*v for k, v in list(d.items()))
Q = int(eval(input()))
for _ in range(Q):
B, C = list(map(int, input().split()))
if B in d:
S += d[B] * (C-B)
d[C] += d[B]
d[B] = 0
print(S)
| p02630 |
N = int(eval(input()))
numbers = list(map(int,input().split()))
numOfOperation = int(eval(input()))
sums = sum(numbers)
for i in range(numOfOperation):
B,C = list(map(int,input().split()))
cnt = 0
for j in range(len(numbers)):
if numbers[j] == B :
cnt += 1
numbers[j] = C
sums += cnt * (C - B)
print(sums)
| N = int(eval(input()))
numbers = list(map(int,input().split()))
numOfOperation = int(eval(input()))
dic = {}
for num in numbers:
if num in dic : dic[num] += 1
else: dic[num] = 1
sums = sum(numbers)
for i in range(numOfOperation):
B,C = list(map(int,input().split()))
if (B in dic) :
cnt = dic[B]
dic[B] = 0
if (C not in dic) : dic[C] = cnt
else : dic[C] += cnt
sums += cnt * (C - B)
print(sums)
| p02630 |
n=int(eval(input()))
ar=list(map(int,input().split()))
di={}
for i in range(n):
if ar[i] not in di:
di[ar[i]]=1
else:
di[ar[i]]+=1
q=int(eval(input()))
for i in range(q):
b,c=list(map(int,input().split()))
if(b in di):
x=di[b]
del di[b]
if(c in di):
di[c]+=x
else:
di[c]=x
s=0
for j in list(di.keys()):
s+=j*(di[j])
print(s)
| n=int(eval(input()))
ar=list(map(int,input().split()))
di={}
for i in ar:
di[i]=di.get(i,0)+1
sm=sum(ar)
q=int(eval(input()))
for i in range(q):
b,c=list(map(int,input().split()))
if(b not in di):
print(sm)
elif(b in di):
x=di[b]
del di[b]
if(c in di):
di[c]+=x
else:
di[c]=x
s=0
s=sm-(b*x)+(x*c)
sm=s
print(s)
| p02630 |
def main():
n = int(eval(input()))
As = list(map(int, input().split()))
nums = [0] * (10**5+1)
ans = 0
for a in As:
ans += a
nums[a] += 1
q = int(eval(input()))
for i in range(q):
b, c = list(map(int, input().split()))
ans += (c-b) * nums[b]
nums[c] += nums[b]
nums[b] = 0
print(ans)
if __name__ == "__main__":
main()
| def main():
n = int(eval(input()))
As = list(map(int, input().split()))
As_Count = [0] * (10**5+1)
q = int(eval(input()))
bcs = [list(map(int, input().split())) for _ in range(q)]
for A in As:
As_Count[A] += 1
ans = sum(As)
for b, c in bcs:
ans -= As_Count[b] * b
ans += c * As_Count[b]
As_Count[c] += As_Count[b]
As_Count[b] = 0
print(ans)
if __name__ == "__main__":
main()
| p02630 |
from collections import Counter
def solve(string):
n, *aqbc = list(map(int, string.split()))
a, _, bc = aqbc[:n], aqbc[n], aqbc[n + 1:]
s = sum(a)
t = Counter(a)
ans = []
for b, c in zip(*[iter(bc)] * 2):
if c in list(t.keys()):
t[c] += t[b]
else:
t[c] = t[b]
s += (c - b) * t[b]
del t[b]
ans.append(s)
return "\n".join(map(str, ans))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| from collections import Counter
def solve(string):
n, *aqbc = list(map(int, string.split()))
a, _, bc = aqbc[:n], aqbc[n], aqbc[n + 1:]
s = sum(a)
t = Counter(a)
ans = []
for b, c in zip(*[iter(bc)] * 2):
s += (c - b) * t[b]
t[c] += t[b]
t[b] = 0
ans.append(s)
return "\n".join(map(str, ans))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| p02630 |
from collections import Counter
def solve(string):
n, *aqbc = list(map(int, string.split()))
a, _, bc = aqbc[:n], aqbc[n], aqbc[n + 1:]
s = sum(a)
t = Counter(a)
ans = []
for b, c in zip(*[iter(bc)] * 2):
s += (c - b) * t[b]
t[c] += t[b]
t[b] = 0
ans.append(s)
return "\n".join(map(str, ans))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| from collections import Counter
def solve(string):
n, *aqbc = list(map(int, string.split()))
a, _, bc = aqbc[:n], aqbc[n], aqbc[n + 1:]
s = sum(a)
t = Counter(a)
ans = []
for b, c in zip(*[iter(bc)] * 2):
if b not in list(t.keys()):
ans.append(s)
continue
s += (c - b) * t[b]
t[c] += t[b]
t[b] = 0
ans.append(s)
return "\n".join(map(str, ans))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| p02630 |
from collections import Counter
def solve(string):
n, *aqbc = list(map(int, string.split()))
a, _, bc = aqbc[:n], aqbc[n], aqbc[n + 1:]
s = sum(a)
t = Counter(a)
ans = []
for b, c in zip(*[iter(bc)] * 2):
if b not in list(t.keys()):
ans.append(s)
continue
s += (c - b) * t[b]
t[c] += t[b]
t[b] = 0
ans.append(s)
return "\n".join(map(str, ans))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| from collections import Counter
def solve(string):
n, *aqbc = list(map(int, string.split()))
a, _, bc = aqbc[:n], aqbc[n], aqbc[n + 1:]
s = sum(a)
t = Counter(a)
ans = []
for b, c in zip(*[iter(bc)] * 2):
if b in list(t.keys()):
s += (c - b) * t[b]
t[b], t[c] = 0, t[b] + t[c]
ans.append(s)
return "\n".join(map(str, ans))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| p02630 |
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
X = [list(map(int, input().split())) for _ in range(Q)]
ctr = Counter(A)
ans = sum(A)
for b, c in X:
v = ctr[b]
ans = ans - b * v + c * v
ctr[b] -= v
ctr[c] += v
print(ans)
|
from collections import Counter
N = int(eval(input()))
X = list(map(int, input().split()))
Q = int(eval(input()))
Y = [list(map(int, input().split())) for _ in range(Q)]
ctr = Counter(X)
ans = sum(X)
for b, c in Y:
n = ctr[b]
ctr[b] = 0
ctr[c] += n
ans = ans - b * n + c * n
print(ans)
| p02630 |
n = int(eval(input()))
a = list(map(int,input().split()))
q = int(eval(input()))
a_list = [[i, 0] for i in range(10**5 +1)]
for elem in a:
a_list[elem][1] += 1
for i in range(q):
b, c = list(map(int,(input().split())))
a_list[c][1] += a_list[b][1]
a_list[b][1] = 0
ans = 0
for j in a_list:
ans += j[0] * j[1]
print(ans) | n = int(eval(input()))
a = list(map(int,input().split()))
q = int(eval(input()))
a_dic = {}
for elem in a:
if elem not in a_dic:
a_dic[elem] = 1
else:
a_dic[elem] += 1
a_sum = sum(a)
for i in range(q):
b, c = list(map(int,input().split()))
if b in a_dic:
diff = c - b
a_sum += diff * a_dic[b]
print(a_sum)
if c in a_dic:
a_dic[c] += a_dic[b]
del a_dic[b]
else:
a_dic[c] = a_dic[b]
del a_dic[b]
else:
print(a_sum) | p02630 |
import sys
sys.setrecursionlimit(1000000000)
input = sys.stdin.readline
n=int(eval(input()))
a=list(map(int,input().split()))
q=int(eval(input()))
x=[0]*(10**5)
for i in range(n):
x[a[i]-1]+=a[i]
for _ in range(q):
b,c=list(map(int,input().split()))
if x[b-1]!=0:
x[c-1]+=x[b-1]//b*c
x[b-1]=0
print((sum(x)))
else:
print((sum(x))) | import sys
sys.setrecursionlimit(1000000000)
input = sys.stdin.readline
n=int(eval(input()))
a=list(map(int,input().split()))
q=int(eval(input()))
ans=sum(a)
x=[0]*(10**5+10)
for i in a:
x[i]+=1
for _ in range(q):
b,c=list(map(int,input().split()))
ans+=x[b]*c-x[b]*b
print(ans)
x[c]+=x[b]
x[b]=0 | p02630 |
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
BC = []
for _ in range(Q):
b, c = list(map(int, input().split()))
BC.append([b, c])
C = Counter(A)
for bc in BC:
b = bc[0]
c = bc[1]
if b in C:
if c in C:
C[c] += C[b]
C[b] = 0
else:
C[c] = C[b]
C[b] = 0
print((sum([k*v for k, v in list(C.items())])))
| from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
BC = []
for _ in range(Q):
b, c = list(map(int, input().split()))
BC.append([b, c])
C = Counter(A)
S = sum([k*v for k, v in list(C.items())])
for bc in BC:
b = bc[0]
c = bc[1]
if b in C:
bf = C[b]
S += (c-b) * bf
if c in C:
C[c] += C[b]
C[b] = 0
else:
C[c] = C[b]
C[b] = 0
print(S)
| p02630 |
from collections import Counter
from collections import defaultdict
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
ac = Counter(a)
acl = defaultdict(int)
for ae in ac:
acl[ae] = ac[ae]
for _ in range(q):
b, c = list(map(int, input().split()))
rmed = acl[b]
acl[c] += rmed
acl[b] = 0
r = sum([i * v for i, v in list(acl.items())])
print(r)
if __name__ == '__main__':
main()
| from collections import Counter
from collections import defaultdict
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
asum = sum(a)
ac = Counter(a)
acl = defaultdict(int)
for ae in ac:
acl[ae] = ac[ae]
for _ in range(q):
b, c = list(map(int, input().split()))
rmed = acl[b]
acl[c] += rmed
acl[b] = 0
asum -= b * rmed
asum += c * rmed
print(asum)
if __name__ == '__main__':
main()
| p02630 |
# D - Replacing
from collections import defaultdict
def main():
N, *X = list(map(int, open(0).read().split()))
A, BC = X[:N], X[N + 1 :]
cnt = defaultdict(int)
for a in A:
cnt[a] += 1
total = sum(A)
res = []
for b, c in zip(*[iter(BC)] * 2):
total += (c - b) * cnt[b]
res.append(total)
cnt[c] += cnt[b]
cnt[b] = 0
print(("\n".join(map(str, res))))
if __name__ == "__main__":
main()
| # D - Replacing
def main():
N, *X = list(map(int, open(0).read().split()))
A, BC = X[:N], X[N + 1 :]
cnt = [0] * (10 ** 5 + 1)
for a in A:
cnt[a] += 1
total = sum(A)
res = []
for b, c in zip(*[iter(BC)] * 2):
total += (c - b) * cnt[b]
res.append(total)
cnt[c] += cnt[b]
cnt[b] = 0
print(("\n".join(map(str, res))))
if __name__ == "__main__":
main()
| p02630 |
if __name__=='__main__':
N = int(eval(input()))
A = input().split(" ")
#A_i = [int(s) for s in A]
Q=int(eval(input()))
str_list=[]
S=[]
for i in range(Q):
str_list.append(list(input().split()))
for j in range(Q):
A=[s.replace(str_list[j][0],str_list[j][1]) for s in A]
A_i = [int(s) for s in A]
print((sum(A_i))) | if __name__=='__main__':
N = int(eval(input()))
A = input().split(" ")
#A_i = [int(s) for s in A]
Q=int(eval(input()))
str_list=[]
S=[]
for i in range(Q):
str_list.append(list(input().split()))
for j in range(Q):
if str_list[j][0] in A:
A=[s.replace(str_list[j][0],str_list[j][1]) for s in A]
A_i = [int(s) for s in A]
print((sum(A_i))) | p02630 |
N = int(eval(input()))
A = [int(x) for x in input().split()]
Q = int(eval(input()))
B_to_C = []
for i in range(Q):
B_to_C.append([int(x) for x in input().split()])
dict_A = {}
for a in A:
if a in dict_A:
dict_A[a] += 1
else:
dict_A[a] = 1
for B, C in B_to_C:
if B in dict_A:
if C in dict_A:
dict_A[C] += dict_A[B]
del dict_A[B]
else:
dict_A[C] = dict_A[B]
del dict_A[B]
sums = 0
for k, v in list(dict_A.items()):
sums += k*v
print(sums)
| N = int(eval(input()))
A = [int(x) for x in input().split()]
Q = int(eval(input()))
B_to_C = []
for i in range(Q):
B_to_C.append([int(x) for x in input().split()])
dict_A = {}
sums = 0
for a in A:
if a in dict_A:
dict_A[a] += 1
else:
dict_A[a] = 1
for k, v in list(dict_A.items()):
sums += k*v
for B, C in B_to_C:
if B in dict_A:
count_of_num = dict_A[B]
if C in dict_A:
dict_A[C] += dict_A[B]
del dict_A[B]
else:
dict_A[C] = dict_A[B]
del dict_A[B]
sums = sums - B*count_of_num + C*count_of_num
print(sums)
else:
print(sums) | p02630 |
n=int(eval(input()))
elements= input().split()
q=int(eval(input()))
actions=[]
for i in range(q):
actions.append(input().split())
number_list=[]
count_list=[]
for e in elements:
if int(e) in number_list:
count_list[number_list.index(int(e))]+=1
else:
number_list.append(int(e))
count_list.append(1)
sum=0
for i in range(len(count_list)):
sum+=number_list[i]* count_list[i]
for act in actions:
if int(act[0]) in number_list:
index0=number_list.index(int(act[0]))
if int(act[1]) in number_list:
index1=number_list.index(int(act[1]))
sum+=(number_list[index1]-number_list[index0])* count_list[index0]
count_list[index1]+=count_list[index0]
else:
sum+=(int(act[1])-number_list[index0])* count_list[index0]
number_list.append(int(act[1]))
count_list.append(count_list[index0])
count_list[index0]=0
print((str(sum))) | n=int(eval(input()))
elements= input().split()
q=int(eval(input()))
actions=[]
for i in range(q):
actions.append(input().split())
dict={}
for e in elements:
count=dict.get(e,0)
count+=1
dict[e]=count
sum=0
for key in list(dict.keys()):
sum+=int(key)* dict[key]
for act in actions:
count=dict.get(act[0],0)
sum+=(int(act[1])-int(act[0]))*count
count+=dict.get(act[1],0)
dict[act[1]]=count
dict[act[0]]=0
print((str(sum))) | p02630 |
# import sys
# input = sys.stdin.readline
# import re
# import itertools
import collections
def main():
n = int(eval(input()))
s = input_list()
sc = collections.Counter(s)
q = int(eval(input()))
ans = []
for i in range(q):
b, c = input_list()
sc[c] += sc[b]
if b in sc:
sc.pop(b)
a = 0
for k, v in list(sc.items()):
a += k*v
ans.append(a)
for a in ans:
print(a)
def count_tento(l, cur):
count = 0
for v in l:
if v > cur:
count += 1
return count
def input_list():
return list(map(int, input().split()))
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
if __name__ == '__main__':
main()
| # import sys
# input = sys.stdin.readline
# import re
# import itertools
import collections
def main():
n = int(eval(input()))
s = input_list()
sc = collections.Counter(s)
q = int(eval(input()))
data = []
for i in range(q):
b, c = input_list()
sc[c] += sc[b]
if i > 0:
data.append(c*sc[b] - b * sc[b])
if b in sc:
sc.pop(b)
ans = 0
for k, v in list(sc.items()):
ans += k*v
aa = [ans]
for i, v in enumerate(data[::-1]):
aa.append(aa[i] - v)
for a in aa[::-1]:
print(a)
def count_tento(l, cur):
count = 0
for v in l:
if v > cur:
count += 1
return count
def input_list():
return list(map(int, input().split()))
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
if __name__ == '__main__':
main()
| p02630 |
from collections import Counter
N = int(eval(input()))
val2ind = Counter(list(map(int, input().split())))
Q = int(eval(input()))
for _ in range(Q):
B, C = list(map(int, input().split()))
if B in val2ind:
cand = val2ind[B]
del val2ind[B]
if C not in val2ind:
val2ind[C] = cand
else:
val2ind[C] += cand
print((sum([key*val2ind[key] for key in val2ind]))) | from collections import Counter
N = int(eval(input()))
val2ind = Counter(list(map(int, input().split())))
ans = sum([key*val2ind[key] for key in val2ind])
Q = int(eval(input()))
for _ in range(Q):
B, C = list(map(int, input().split()))
if B in val2ind:
cand = val2ind[B]
del val2ind[B]
if C not in val2ind:
val2ind[C] = cand
else:
val2ind[C] += cand
ans = ans+(C-B)*cand
print(ans) | p02630 |
from collections import defaultdict
d = defaultdict(int)
n=int(eval(input()))
a = list(map(int,input().split()))
q=int(eval(input()))
bc = [list(map(int, input().split())) for i in range(q)]
for el in a:
d[el] += 1
def s_sum(dd):
res = 0
for k,v in list(dd.items()):
res += k * v
return res
for ss in bc:
b = ss[0]
c = ss[1]
b_cnt = d[b]
c_cnt = d[c]
d[b] = 0
d[c] += b_cnt
print((s_sum(d)))
| from collections import defaultdict
d = defaultdict(int)
n=int(eval(input()))
a = list(map(int,input().split()))
q=int(eval(input()))
bc = [list(map(int, input().split())) for i in range(q)]
#print(bc)
for el in a:
d[el] += 1
def s_sum(dd):
res = 0
for k,v in list(dd.items()):
res += k * v
return res
wk = s_sum(d)
for ss in bc:
b = ss[0]
c = ss[1]
b_cnt = d[b]
c_cnt = d[c]
d[b] = 0
d[c] += b_cnt
wk = wk + b_cnt*c - b_cnt*b
print(wk)
| p02630 |
import collections
_ = eval(input())
a = [*list(map(int, input().split()))]
q = int(eval(input()))
b = [[*list(map(int,input().split()))] for _ in range(q)]
c = collections.Counter(a)
for i,j in b:
if j not in c:
c[j] = 0
if i not in c:
c[i] = 0
c[j]+=c[i]
c[i] = 0
print((sum(k*v for k,v in list(c.items())))) | import collections
_ = eval(input())
a = [*list(map(int, input().split()))]
q = int(eval(input()))
s = sum(a)
b = [[*list(map(int,input().split()))] for _ in range(q)]
c = collections.Counter(a)
for i,j in b:
if j not in c:
c[j] = 0
if i not in c:
c[i] = 0
s += (j-i)*c[i]
c[j]+=c[i]
c[i] = 0
print(s) | p02630 |
import sys
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [int(x) for x in input().split()]
Q = int(eval(input()))
BC = [[int(x) for x in input().split()] for _ in range(Q)]
cnt = collections.Counter(A)
ans = sum(A)
for b, c in BC:
ans -= cnt[b] * b
cnt[c] += cnt[b]
ans += cnt[b] * c
cnt[b] = 0
print(ans)
if __name__ == '__main__':
main()
| import sys
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [int(x) for x in input().split()]
Q = int(eval(input()))
BC = [[int(x) for x in input().split()] for _ in range(Q)]
ans = sum(A)
cnt = collections.Counter(A)
for i in range(Q):
b, c = BC[i]
ans -= cnt[b] * b
ans += c * cnt[b]
cnt[c] += cnt[b]
cnt[b] = 0
print(ans)
if __name__ == '__main__':
main()
| p02630 |
import collections
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
dic = collections.Counter(a)
for i in range(q):
b, c = list(map(int, input().split()))
if b in dic and c not in dic:
dic[c] = dic[b]
del dic[b]
elif b in dic and c in dic:
dic[c] += dic[b]
del dic[b]
sum_list = [x * y for (x, y) in list(dic.items())]
print((sum(sum_list)))
| import collections
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
dic = collections.Counter(a)
sum_list = [x * y for (x, y) in list(dic.items())]
sum = sum(sum_list)
for i in range(q):
b, c = list(map(int, input().split()))
if b in dic and c not in dic:
sum -= (b - c) * dic[b]
print(sum)
dic[c] = dic[b]
del dic[b]
elif b in dic and c in dic:
sum -= (b - c) * dic[b]
print(sum)
dic[c] += dic[b]
del dic[b]
else:
print(sum)
| p02630 |
def sum_dict(d, b, c):
val = 0
sum = 0
if b in d:
val = d[b]
del d[b]
d[c] = d.get(c, 0) + val
for i in list(d.items()):
sum += (i[0] * i[1])
return sum, d
n = int(eval(input()))
a = [int(x) for x in input().split()]
d = {}
for i in a:
d[i] = d.get(i, 0) + 1
s = sum(a)
q = int(eval(input()))
for i in range(q):
b, c = list(map(int, input().split()))
s, d = sum_dict(d, b, c)
print(s) | def sum_dict(d, sum, b, c):
val = 0
if b in d:
val = d[b]
sum -= (b * val)
del d[b]
d[c] = d.get(c, 0) + val
sum += (c * val)
return sum, d
n = int(eval(input()))
a = [int(x) for x in input().split()]
d = {}
for i in a:
d[i] = d.get(i, 0) + 1
s = sum(a)
q = int(eval(input()))
for i in range(q):
b, c = list(map(int, input().split()))
s, d = sum_dict(d, s, b, c)
print(s) | p02630 |
N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
BC = [list(map(int, input().split())) for _ in range(Q)]
ans = [0]*(10**5+1)
for i in range (len(A)):
ans[A[i]] += 1
maxlen = max(max(A),max(max(BC)))
for i in range(Q):
ans[BC[i][1]] += ans[BC[i][0]]
ans[BC[i][0]] = 0
S = 0
for i in range(maxlen+1):
S += ans [i]*i
print(S) | N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
BC = [list(map(int, input().split())) for _ in range(Q)]
ans = [0]*(10**5+1)
for i in range (len(A)):
ans[A[i]] += 1
maxlen = max(max(A),max(max(BC)))
S = 0
for i in range(maxlen+1):
S += ans [i]*i
for i in range(Q):
ans[BC[i][1]] += ans[BC[i][0]]
S = S + ans[BC[i][0]] *BC[i][1] - ans[BC[i][0]]*BC[i][0]
ans[BC[i][0]] = 0
print(S) | p02630 |
n = int(eval(input()))
a = list(map(int,input().split()))
b = {}
for x in a:
try:
if b[x]:
b[x] += 1
except:
b[x] = 1
#print(b)
ans = sum(a)
q = int(eval(input()))
for _ in range(q):
x,y = list(map(int,input().split()))
try:
if b[x] != -1:
bx = b[x]
b[x] = 0
except:
#print(b)
print(ans)
continue
try:
if b[y] != -1:
b[y] += bx
except:
b[y] = bx
#print(b)
ans += bx * (y-x)
print(ans) | n = int(eval(input()))
a = list(map(int,input().split()))
b = {}
for x in a:
try:
if b[x] != -1:
b[x] += 1
except:
b[x] = 1
q = int(eval(input()))
ans = sum(a)
for _ in range(q):
x,y = list(map(int,input().split()))
try:
if b[x] != -1:
bx = b[x]
b[x] = 0
except:
print(ans)
continue
try:
if b[y] != -1:
b[y] += bx
except:
b[y] = bx
ans += bx * (y-x)
print(ans) | p02630 |
n = int(eval(input()))
a = list(map(int,input().split()))
b = [0 for _ in range(100001)]
for x in a:
b[x] += 1
ans = sum(a)
q = int(eval(input()))
for _ in range(q):
x,y = list(map(int,input().split()))
ans += (y-x) * b[x]
b[x],b[y] = 0,b[x]+b[y]
print(ans) | #15:30
n = int(eval(input()))
a = list(map(int,input().split()))
b = {}
for x in a:
b[x] = 0
q = int(eval(input()))
inp = []
for _ in range(q):
x,y = list(map(int,input().split()))
b[x] = 0
b[y] = 0
inp.append([x,y])
for x in a:
b[x] += 1
ans = sum(a)
for z in inp:
x,y = z
ans += (y-x) * b[x]
b[x],b[y] = 0,b[x]+b[y]
print(ans) | p02630 |
n=int(eval(input()))
a=list(map(int,input().split()))
sum_num=sum(a)
mylist=[]
for i in range(1,10**5+1):
mylist.append(a.count(i))
q=int(eval(input()))
for i in range(q):
b,c=list(map(int,input().split()))
sum_num+=(c-b)*mylist[b-1]
print(sum_num)
mylist[c-1]+=mylist[b-1]
mylist[b-1]=0 | from collections import Counter
n=int(eval(input()))
a=list(map(int,input().split()))
sum_num=sum(a)
cnt=Counter(a)
q=int(eval(input()))
for i in range(q):
b,c=list(map(int,input().split()))
sum_num+=(c-b)*cnt[b]
print(sum_num)
cnt[c]+=cnt[b]
cnt[b]=0 | p02630 |
nb=int(eval(input()))
liste = [int(x) for x in input().split()]
liste2= [0]*((10**5)+1)
for loop in range(len(liste)):
liste2[liste[loop]] +=1
nba = int(eval(input()))
somme = sum(liste)
for loop in range(nba):
n,r = list(map(int,input().split()))
roger = liste2[n]
for loop in range(len(liste)):
if liste[loop]==n:
liste[loop] = r
diff = r-n
somme += diff * roger
liste2[r] += liste2[n]
liste2[n] = 0
print(somme) | nb=int(eval(input()))
liste = [int(x) for x in input().split()]
liste2= [0]*((10**5)+1)
for loop in range(len(liste)):
liste2[liste[loop]] +=1
nba = int(eval(input()))
somme = sum(liste)
for loop in range(nba):
n,r = list(map(int,input().split()))
roger = liste2[n]
diff = r-n
somme += diff * roger
liste2[r] += liste2[n]
liste2[n] = 0
print(somme) | p02630 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
from collections import Counter
N = I()
A = LI()
sum = sum(A)
a = Counter(A)
Q = I()
for i in range(Q):
b,c = LI()
sum += a[b]*(c-b)
print(sum)
a[c] += a[b]
a[b] = 0 | import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
from collections import Counter
N = I()
A = LI()
sum = sum(A)
a = Counter(A)
Q = I()
for i in range(Q):
b,c = LI()
sum += a[b]*(c-b)
print(sum)
a[c] += a[b]
a[b] = 0 | p02630 |
n = int(eval(input()))
li_a = list(map(int, input().split()))
dic_a = {}
for a in li_a:
dic_a[a] = dic_a.get(a, 0) + 1
q = int(eval(input()))
li_bc = list()
for i in range(q):
li_bc.append(tuple(map(int, input().split())))
for l in li_bc:
b = l[0]
c = l[1]
if b in list(dic_a.keys()):
dic_a[c] = dic_a.get(c, 0) + dic_a.get(b, 0)
dic_a[b] = 0
sum = 0
for key, val in list(dic_a.items()):
sum += (key * val)
print(sum)
| n = int(eval(input()))
li_a = list(map(int, input().split()))
dic_a = {}
for a in li_a:
dic_a[a] = dic_a.get(a, 0) + 1
q = int(eval(input()))
li_bc = list()
for i in range(q):
li_bc.append(tuple(map(int, input().split())))
answer = sum(li_a)
for l in li_bc:
b = l[0]
c = l[1]
diff = (c - b) * dic_a.get(b, 0)
if b in list(dic_a.keys()):
dic_a[c] = dic_a.get(c, 0) + dic_a.get(b, 0)
dic_a[b] = 0
answer += diff
else:
pass
print(answer)
| p02630 |
n=int(eval(input()))
a=sorted([int(i) for i in input().split()])
m={}
for i in range(n):
x=m.get(a[i],0)
m[a[i]]=x+1
q=int(eval(input()))
b=[]
c=[]
for i in range(q):
b,c=[int(i) for i in input().split()]
x=m.get(b,0)
y=m.get(c,0)
m[b]=0
m[c]=x+y
print((sum([x*m[x] for x in list(m.keys())])))
| n=int(eval(input()))
m={}
s=0
for i in input().split():
i=int(i)
x=m.get(i,0)
m[i]=x+1
s+=i
q=int(eval(input()))
for i in range(q):
b,c=[int(i) for i in input().split()]
x=m.get(b,0)
y=m.get(c,0)
m[b]=0
m[c]=x+y
s=s-(b*x)+(c*x)
print(s)
| p02630 |
f=lambda:[*list(map(int,input().split()))]
f(); l,q=f(),f()[0]
from collections import *
C,s=Counter(l),sum(l)
for _ in range(q): b,c=f(); s+=(c-b)*C[b]; C[c]+=C[b]; C[b]=0; print(s) | f=lambda:[*list(map(int,input().split()))]
f()
s,*l=[0]*100002
for i in f(): s+=i; l[i]+=1
q=f()[0]
for _ in range(q): b,c=f(); s+=(c-b)*l[b]; l[c]+=l[b]; l[b]=0; print(s) | p02630 |
f=lambda:list(map(int,input().split()))
f()
s,*l=[0]*100002
for i in f(): s+=i; l[i]+=1
q,=f()
for _ in range(q): b,c=f(); s+=(c-b)*l[b]; l[c]+=l[b]; l[b]=0; print(s) | n,*L=list(map(int,open(0).read().split()))
A,q,Q=L[:n],L[n],L[n+1:]
s,*l=[0]*100002
for i in A: s+=i; l[i]+=1
for b,c in zip(*[iter(Q)]*2): s+=(c-b)*l[b]; l[c]+=l[b]; l[b]=0; print(s) | p02630 |
n = int(eval(input()))
a = list(map(int,input().split()))
q = int(eval(input()))
a_set = set(a)
a_dict = dict([(i, a.count(i))for i in a_set])
a_sum = sum(a)
for i in range(q):
b,c = list(map(int,input().split()))
if not b in a_dict:
print(a_sum)
continue
a_sum = a_sum - a_dict[b]*b + a_dict[b]*c
if c in a_dict:
a_dict[c] = a_dict[c] + a_dict[b]
else:
a_dict[c] = a_dict[b]
a_dict[b] = 0
print(a_sum) | n = int(eval(input()))
a = list(map(int,input().split()))
q = int(eval(input()))
a_dict = dict()
for i in a:
if i in a_dict:
a_dict[i] = a_dict[i] + 1
else:
a_dict[i] = 1
a_sum = sum(a)
for i in range(q):
b,c = list(map(int,input().split()))
if not b in a_dict:
print(a_sum)
continue
a_sum = a_sum - a_dict[b]*b + a_dict[b]*c
if c in a_dict:
a_dict[c] = a_dict[c] + a_dict[b]
else:
a_dict[c] = a_dict[b]
a_dict[b] = 0
print(a_sum) | p02630 |
n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
B,C = [], []
for _ in range(q):
b, c = list(map(int, input().split()))
B.append(b)
C.append(c)
d = {}
for a in A:
d.setdefault(a, 0)
d[a] += 1
for b, c in zip(B,C):
d.setdefault(b, 0)
d.setdefault(c, 0)
d[c] += d[b]
d[b] = 0
ans = 0
for i, v in list(d.items()):
ans += i*v
print(ans)
| n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
B,C = [], []
for _ in range(q):
b, c = list(map(int, input().split()))
B.append(b)
C.append(c)
ans = sum(A)
d = {}
for a in A:
d.setdefault(a, 0)
d[a] += 1
for b, c in zip(B,C):
d.setdefault(b, 0)
d.setdefault(c, 0)
ans -= d[c] * c
ans -= d[b] * b
d[c] += d[b]
d[b] = 0
ans += d[c] * c
ans += d[b] * b
print(ans)
| p02630 |
n=int(eval(input()))
a=list(map(int,input().split()))
q=int(eval(input()))
bc=[list(map(int,input().split())) for i in range(q)]
A=[0]*(10**5+1)
for i in range(10**5+1):
A[i] = a.count(i)
sum_tmp = sum(a)
for i in range(q):
b = bc[i][0]
c = bc[i][1]
A[c] += A[b]
sum_tmp += (c-b) * A[b]
A[b] = 0
print(sum_tmp) | n=int(eval(input()))
a=list(map(int,input().split()))
q=int(eval(input()))
bc=[list(map(int,input().split())) for i in range(q)]
A=[0]*(10**5+1)
for i in range(n):
A[a[i]] += 1
sum_tmp = sum(a)
for i in range(q):
b = bc[i][0]
c = bc[i][1]
A[c] += A[b]
sum_tmp += (c-b) * A[b]
A[b] = 0
print(sum_tmp) | p02630 |
N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
dic = dict()
for i in A:
if i in dic:
dic[i] += 1
else:
dic[i] = 1
for i in range(Q):
b, c = list(map(int, input().split()))
if b in dic:
if c in dic:
dic[c] += dic.pop(b)
else:
dic[c] = dic.pop(b)
ans = 0
for num in dic:
ans += num * dic[num]
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
dic = dict()
for i in A:
if i in dic:
dic[i] += 1
else:
dic[i] = 1
ans = 0
for num in dic:
ans += num * dic[num]
for i in range(Q):
b, c = list(map(int, input().split()))
x = 0
if b in dic:
x = dic.pop(b)
if c in dic:
dic[c] += x
else:
dic[c] = x
ans += x * (c-b)
print(ans) | p02630 |
import collections
n = int(eval(input()))
li = list(map(int,input().split()))
q = int(eval(input()))
num_li=[list(map(int,input().split())) for i in range(q)]
c = collections.Counter(li)
for i,j in num_li:
s = 0
if i in c:
cnt = c.pop(i)
c[j] += cnt
for k, v in list(c.items()):
s += k * v
print(s) | import collections
n = int(eval(input()))
li = list(map(int,input().split()))
q = int(eval(input()))
num_li=[list(map(int,input().split())) for i in range(q)]
c = collections.Counter(li)
li_sum = sum(li)
for i,j in num_li:
s = 0
if i in c:
cnt = c.pop(i)
c[j] += cnt
li_sum = li_sum - (i*cnt) + (j*cnt)
print(li_sum) | p02630 |
n = int(eval(input()))
a = list(map(int,input().split()));
q = int(eval(input()))
aa = 0;
for i in range(n):
aa += a[i];
b = [input().split() for l in range(q)]
bu = [0]*(100000);
for i in range(100000):
bu[i] = a.count(i+1);
for x in range(q):
c = int(b[x][0])
d = int(b[x][1])
aa += (d-c)*(bu[c-1]);
bu[d-1] += bu[c-1];
bu[c-1] = 0;
print(aa); |
n = int(eval(input()))
a = list(map(int,input().split()));
q = int(eval(input()))
aa = 0;
for i in range(n):
aa += a[i];
b = [input().split() for l in range(q)]
bu = [0]*(100000);
for i in range(n):
bu[a[i]-1] += 1;
for x in range(q):
c = int(b[x][0])
d = int(b[x][1])
aa += (d-c)*(bu[c-1]);
bu[d-1] += bu[c-1];
bu[c-1] = 0;
print(aa);
| p02630 |
import collections
N = int(eval(input()))
a = list(map(int,input().split()))
Q = int(eval(input()))
c = collections.Counter(a)
for i in range(Q):
arr = list(map(int,input().split()))
B = arr[0]
C = arr[1]
if(C not in c):
c[C] = 0
c[C] += c[B]
del c[B]
sum = 0
for key, cnt in list(c.items()):
sum += key*cnt
print(sum) | import collections
N = int(eval(input()))
a = list(map(int,input().split()))
su = sum(a)
Q = int(eval(input()))
c = collections.Counter(a)
for i in range(Q):
arr = list(map(int,input().split()))
B = arr[0]
C = arr[1]
if(C not in c):
c[C] = 0
num_B = c[B] # 配列に含まれるBの個数
c[B] = 0
c[C] += num_B
# c[C] += c[B]
# del c[B]
# for key, cnt in c.items():
# sum -= items():
# sum += key*cnt
su -= num_B * B # bのやつを減らす
su += num_B * C # cのやつを増やすitems():
print(su) | p02630 |
import collections
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
data = collections.Counter(a)
count, key = list(data.values()), list(data.keys())
for i in range(q):
b, c = list(map(int, input().split()))
if b in key and c in key:
count[key.index(c)] += count[key.index(b)]
count[key.index(b)] = 0
elif b in key:
key.append(c)
count.append(count[key.index(b)])
count[key.index(b)] = 0
res = 0
for j in range(len(key)):
res += count[j] * key[j]
print(res)
| n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
data = [0] * (10**5 + 1)
for i in a:
data[i] += 1
res = sum(a)
for j in range(q):
b, c = list(map(int, input().split()))
res += (c - b) * data[b]
data[c] += data[b]
data[b] = 0
print(res) | p02630 |
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
bc = [list(map(int,input().split())) for _ in range(q)]
# sum_first = sum(a)
for i in bc:
a = [i[1] if j==i[0] else j for j in a]
# print(a)
print((sum(a))) | n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
query = [list(map(int,input().split())) for _ in range(q)]
all_sum = sum(a)
cnt = {}
for i in a:
if i not in cnt:
cnt[i] = 0
cnt[i] += 1
for (b, c) in query:
if b in cnt:
all_sum -= b * cnt[b]
all_sum += c * cnt[b]
if c not in cnt:
cnt[c]=0
cnt[c] += cnt[b]
cnt[b] = 0
print(all_sum) | p02630 |
n = int(eval(input()))
lst = [int(i) for i in input().split()]
dic = {}
for i in range(n):
key = lst[i]
if key not in dic:
dic[key] = 0
dic[key] += 1
#print(dic)
m = int(eval(input()))
for _ in range(m):
sum = 0
lst_s = list(map(int, input().split()))
number = dic.get(lst_s[0])
if number is not None:
if lst_s[1] in dic:
dic[lst_s[1]] += number
else:
dic[lst_s[1]] = number
dic.pop(lst_s[0])
for key, value in list(dic.items()):
sum += key * value
print(sum) | n = int(eval(input()))
lst = [int(i) for i in input().split()]
dic = {}
for i in range(n):
key = lst[i]
if key not in dic:
dic[key] = 0
dic[key] += 1
#print(dic)
sum = 0
for key, value in list(dic.items()):
sum += key * value
m = int(eval(input()))
for _ in range(m):
lst_s = list(map(int, input().split()))
number = dic.get(lst_s[0])
if number is not None:
if lst_s[1] in dic:
dic[lst_s[1]] += number
else:
dic[lst_s[1]] = number
sum += lst_s[1] * number
sum -= lst_s[0] * number
dic.pop(lst_s[0])
print(sum) | p02630 |
import collections
eval(input())
math_dic = collections.Counter((list(map(int,input().split()))))
num = int(eval(input()))
for i in range(num):
a,b = list(map(int,input().split()))
if a not in math_dic:
print((sum([index*value for index,value in list(math_dic.items())])))
continue
if b not in math_dic:
math_dic[b] = 0
math_dic[b] += math_dic.pop(a)
print((sum([index*value for index,value in list(math_dic.items())]))) | import collections
eval(input())
math_dic = collections.Counter((list(map(int,input().split()))))
num = int(eval(input()))
total_num = sum([index*value for index,value in list(math_dic.items())])
for i in range(num):
a,b = list(map(int,input().split()))
if a not in math_dic:
print(total_num)
continue
if b not in math_dic:
math_dic[b] = 0
total_num -= a*math_dic[a]
total_num += b*math_dic[a]
math_dic[b] += math_dic.pop(a)
print(total_num) | p02630 |
import sys
input = sys.stdin.buffer.readline
n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
from collections import Counter
C = Counter(A)
C = dict(C)
S = sum(A)
for i in range(q):
b, c = list(map(int, input().split()))
if b in C:
vb = C[b]
C[b] = 0
S -= b*vb
S += c*vb
print(S)
if c in C:
C[c] += vb
else:
C[c] = vb
else:
print(S)
| import sys
input = sys.stdin.buffer.readline
n = int(eval(input()))
A = list(map(int, input().split()))
S = sum(A)
D = [0]*(10**5+1)
for a in A:
D[a] += 1
q = int(eval(input()))
for i in range(q):
b, c = list(map(int, input().split()))
S -= D[b]*b
S += D[b]*c
D[c] += D[b]
D[b] = 0
print(S)
| p02630 |
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
A = Counter(A)
bc = [tuple(map(int, input().split())) for i in range(Q)]
ans = 0
for b, c in bc:
v = A.pop(b, None)
if v:
A[c] += v
ans = 0
ans = sum(i*j for i, j in list(A.items()))
print(ans) | from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
ans = sum(A)
A = Counter(A)
bc = [tuple(map(int, input().split())) for i in range(Q)]
for b, c in bc:
v = A.pop(b, None)
if v:
A[c] += v
ans = ans+((c-b)*v)
print(ans)
| p02630 |
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
m = 10**5+1
nums = [0]*m
for i in a: nums[i] += 1
for _ in range(q):
b,c = list(map(int, input().split()))
nums[c] += nums[b]
nums[b] = 0
ans = 0
for i in range(1,m): ans += i*nums[i]
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
m = 10**5+1
nums = [0]*m
ans = 0
for i in a:
nums[i] += 1
ans += i
for _ in range(q):
b,c = list(map(int, input().split()))
ans -= b*nums[b]
ans += c*nums[b]
nums[c] += nums[b]
nums[b] = 0
print(ans) | p02630 |
N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
count = [0]*(10**5+1)
for i in range(len(A)):
count[A[i]] += 1
A = list(set(A))
for i in range(Q):
B, C = list(map(int, input().split()))
count[C] += count[B]
count[B] = 0
ans = 0
for i in range(10**5+1):
ans += count[i] * i
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
S = sum(A)
count = [0]*(10**5+1)
for i in range(len(A)):
count[A[i]] += 1
A = list(set(A))
for i in range(Q):
B, C = list(map(int, input().split()))
S = S - B*count[B] + C*count[B]
count[C] += count[B]
count[B] = 0
print(S)
| p02630 |
n=int(eval(input()))
a=list(map(int, input().split()))
q=int(eval(input()))
bc=[]
for i in range (q):
bc.append(list(map(int, input().split())))
num=[0]*(10**5+1)
for i in range(n):
x=a[i]
num[x]+=1
for k in range (q):
b=bc[k][0]
c=bc[k][1]
num[c]+=num[b]
num[b]=0
kk=0
for l in range(10**5+1):
kk+=l*num[l]
print(kk) | n=int(eval(input()))
a=list(map(int, input().split()))
q=int(eval(input()))
bc=[]
for i in range (q):
bc.append(list(map(int, input().split())))
num=[0]*(10**5+1)
for i in range(n):
x=a[i]
num[x]+=1
kk=0
for l in range(10**5+1):
kk+=l*num[l]
for k in range (q):
b=bc[k][0]
c=bc[k][1]
kk+=c*num[b]-b*num[b]
num[c]+=num[b]
num[b]=0
print(kk)
| p02630 |
N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
A_cnt = [0] * 100001
A_sum = 0
for a in A:
A_cnt[a]+=1
for _ in range(Q):
B, C = list(map(int, input().split()))
A_cnt[C] = A_cnt[C] + A_cnt[B]
A_cnt[B] = 0
for i, x in enumerate(A_cnt):
if A_cnt[i] > 0:
A_sum = A_sum + (i * A_cnt[i])
print(A_sum)
A_sum = 0 | N = int(eval(input()))
A = list(map(int, input().split()))
Q = int(eval(input()))
A_cnt = [0] * 100001
A_sum = 0
# 各数値の数を数えておく
for a in A:
A_cnt[a]+=1
# ついでに現時点の総和も出しておく
A_sum+=a
for _ in range(Q):
B, C = list(map(int, input().split()))
A_cnt[C] = A_cnt[C] + A_cnt[B]
A_sum = A_sum + ((C-B) * A_cnt[B])
A_cnt[B] = 0
print(A_sum)
| p02630 |
n, *bc = list(map(int, open(0).read().split()))
a = [bc.pop(0) for _ in range(n)]
q = bc.pop(0)
d = {}
for x in a:
if x in d:
d[x] += 1
else:
d[x] = 1
ret = sum(a)
for i in range(0, min(q*2, len(bc)), 2):
b = bc[i]
c = bc[i+1]
if b in d:
v = d.pop(b)
if c in d:
d[c] += v
else:
d[c] = v
ret += c * v - b * v
#ret = sum([k * v for k, v in d.items()])
print(ret) | n, r = open(0).read().split(maxsplit=1)
n = int(n)
*a, r = r.split(maxsplit=n)
a = list(map(int, a))
q, *bc = list(map(int, r.split()))
d = {}
for x in a:
if x in d:
d[x] += 1
else:
d[x] = 1
ret = sum(a)
for i in range(0, min(q*2, len(bc)), 2):
b = bc[i]
c = bc[i+1]
if b in d:
v = d.pop(b)
if c in d:
d[c] += v
else:
d[c] = v
ret += c * v - b * v
#ret = sum([k * v for k, v in d.items()])
print(ret)
| p02630 |
n, r = open(0).read().split(maxsplit=1)
n = int(n)
*a, r = r.split(maxsplit=n)
a = list(map(int, a))
q, *bc = list(map(int, r.split()))
d = {}
for x in a:
if x in d:
d[x] += 1
else:
d[x] = 1
ret = sum(a)
for i in range(0, min(q*2, len(bc)), 2):
b = bc[i]
c = bc[i+1]
if b in d:
v = d.pop(b)
if c in d:
d[c] += v
else:
d[c] = v
ret += c * v - b * v
#ret = sum([k * v for k, v in d.items()])
print(ret)
| n, *r = list(map(int, open(0).read().split()))
a = r[:n]
q = r[n]
bc = r[n+1:]
d = {}
for x in a:
if x in d:
d[x] += 1
else:
d[x] = 1
ret = sum(a)
for i in range(0, min(q*2, len(bc)), 2):
b = bc[i]
c = bc[i+1]
if b in d:
v = d.pop(b)
if c in d:
d[c] += v
else:
d[c] = v
ret += c * v - b * v
#ret = sum([k * v for k, v in d.items()])
print(ret)
| p02630 |
from collections import deque
from bisect import bisect_left
n=int(eval(input()))
a=sorted(list(map(int,input().split())))
sus=deque([sum(a)])
q=int(eval(input()))
for i in range(q):
count=0
b,c=list(map(int,input().split()))
idx=bisect_left(a,b)
while True:
if idx>=n:break
if a[idx]==b:
a[idx]=c
count+=1
idx+=1
else:
break
a=sorted(a)
sus.append(sus[-1]+(c-b)*count)
print((sus[-1])) | n=int(eval(input()))
a=[0]*(10**5)
A=list(map(int,input().split()))
su=0
for i in range(n):
su+=A[i]
a[A[i]-1]+=1
q=int(eval(input()))
sus=[su]
for i in range(q):
b,c=[int(x)-1 for x in input().split()]
sus.append(sus[-1]+(c-b)*a[b])
a[c]+=a[b]
a[b]-=a[b]
print((sus[-1]))
| p02630 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.