input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import itertools as i,collections as c
b=c.Counter(s[0]for s in open(0).readlines()[1:] if s[0]in"MARCH")
print((sum(p*q*r for p,q,r in i.combinations(list(b.values()),3)))) | import itertools as i,collections as c;print((sum(p*q*r for p,q,r in i.combinations(list(c.Counter(s[0]for s in open(0).readlines()[1:] if s[0]in"MARCH").values()),3)))) | p03425 |
n = int(eval(input()))
m = ["M", "A", "R", "C", "H"]
s = {}
for _ in range(n):
s_ = input()[0]
if s_ not in m: continue
else:
if s_ not in list(s.keys()):
s[s_] = 0
s[s_] += 1
if len(list(s.keys())) <= 2:
print((0))
exit()
l = list(s.values())
n = len(l)
a = 0
for i in range(n-2):
for j in range(i+1, n-1):
for k in range(j+1, n):
a += l[i] * l[j] * l[k]
print(a) | n = int(eval(input()))
m = "MARCH"
l = {}
cnt = 0
for _ in range(n):
init = input()[0]
if init not in m:
continue
if init not in l:
cnt += 1
l[init] = 0
l[init] += 1
if cnt <= 2:
print((0))
exit()
l = list(l.values())
n = len(l)
ans = 0
for i in range(n-2):
for j in range(i+1, n-1):
for k in range(j+1, n):
ans += l[i] * l[j] * l[k]
print(ans) | p03425 |
import itertools
def main():
N = int(input().strip())
S = [input().strip() for _ in range(N)]
MARCH_S = [x[0] for x in S if x[0] in ['M','A','R','C','H']]
if not MARCH_S:
return 0
pat = list(itertools.combinations(MARCH_S, 3));
pat_len = len(pat)
for x in ['M','A','R','C','H']:
pat_len -= len([p for p in pat if p.count(x) > 1])
return pat_len
if __name__ == '__main__':
print((main())) | import itertools
def main():
N = int(input().strip())
S = []
for _ in range(N):
in_s = (input().strip())[0]
if in_s in ['M','A','R','C','H']:
S.append(in_s)
if not S:
return 0
pat = itertools.combinations(S, 3);
count = 0
for x in pat:
if len(x) == len(set(x)):
count += 1
return count
if __name__ == '__main__':
print((main())) | p03425 |
import itertools as it
import collections as col
import heapq as hq
import sys
import copy as cp
sys.setrecursionlimit(10**9)
args = sys.argv
def dump(*objects):
if len(args) == 2 and args[1] == "DEBUG":
print(*objects, file=sys.stderr)
N = int(input())
S =[input() for i in range(N)]
D={'M':[],'A':[],'R':[],'C':[],'H':[]}
for Si in S:
if Si[0] in D:
D[Si[0]].append(Si)
dump(D)
ans=0
for x in it.combinations("MARCH", 3):
x0,x1,x2=x
dump(x0,x1,x2)
ans += len(D[x0])*len(D[x1])*len(D[x2])
print(ans)
| import itertools as it
import collections as col
import heapq as hq
import sys
import copy as cp
sys.setrecursionlimit(10**9)
args = sys.argv
def dump_impl(*objects):
print(*objects, file=sys.stderr)
def dump_dummy(*objects):
print(*objects, file=sys.stderr)
dump = dump_impl if len(args) == 2 and args[1] == "DEBUG" else dump_dummy
N = int(input())
S =[input() for i in range(N)]
D={'M':[],'A':[],'R':[],'C':[],'H':[]}
for Si in S:
if Si[0] in D:
D[Si[0]].append(Si)
dump(D)
ans=0
for x in it.combinations("MARCH", 3):
x0,x1,x2=x
dump(x0,x1,x2)
ans += len(D[x0])*len(D[x1])*len(D[x2])
print(ans)
| p03425 |
import itertools as it
import collections as col
import heapq as hq
import sys
import copy as cp
sys.setrecursionlimit(10**9)
args = sys.argv
def dump_impl(*objects):
print(*objects, file=sys.stderr)
def dump_dummy(*objects):
print(*objects, file=sys.stderr)
dump = dump_impl if len(args) == 2 and args[1] == "DEBUG" else dump_dummy
N = int(input())
S =[input() for i in range(N)]
D={'M':[],'A':[],'R':[],'C':[],'H':[]}
for Si in S:
if Si[0] in D:
D[Si[0]].append(Si)
dump(D)
ans=0
for x in it.combinations("MARCH", 3):
x0,x1,x2=x
dump(x0,x1,x2)
ans += len(D[x0])*len(D[x1])*len(D[x2])
print(ans)
| import itertools as it
import collections as col
import heapq as hq
import sys
import copy as cp
sys.setrecursionlimit(10**9)
args = sys.argv
def dump_impl(*objects):
print(*objects, file=sys.stderr)
def dump_dummy(*objects):
pass
dump = dump_impl if len(args) == 2 and args[1] == "DEBUG" else dump_dummy
N = int(input())
S = [input() for i in range(N)]
D = {'M': [], 'A': [], 'R': [], 'C': [], 'H': []}
for Si in S:
if Si[0] in D:
D[Si[0]].append(Si)
dump(D)
ans = 0
for x in it.combinations("MARCH", 3):
x0, x1, x2 = x
dump(x0, x1, x2)
ans += len(D[x0])*len(D[x1])*len(D[x2])
print(ans)
| p03425 |
from itertools import combinations
from collections import Counter
n = int(eval(input()))
S = Counter()
for i in range(n):
S[input()[0]] += 1 # Counter == dictionary
print((sum([S[a]*S[b]*S[c] for a, b, c in combinations("MARCH", 3)]))) | from collections import defaultdict
from itertools import combinations
N = int(eval(input()))
S = [input()[0] for _ in range(N)]
dic_S = defaultdict(int)
for s in S:
if s in "MARCH":
dic_S[s] += 1
ans = 0
for a, b, c in combinations(list(dic_S.values()), 3):
ans += a*b*c
print(ans)
| p03425 |
from itertools import combinations
from collections import Counter
N = int(eval(input()))
S = Counter()
for _ in range(N):
S[input()[0]] += 1
print((sum([S[p0]*S[p1]*S[p2] for p0,p1,p2 in combinations('MARCH', 3)])))
quit()
| from itertools import combinations
N = int(eval(input()))
d = [0]*128
for _ in range(N): d[ord(input()[0])] += 1
print((sum([d[ord(p0)]*d[ord(p1)]*d[ord(p2)] for p0,p1,p2 in combinations('MARCH', 3)])))
| p03425 |
N=int(eval(input()))
name=[input()[0] for _ in range(N)]
m,a,r,c,h=name.count("M"),name.count("A"),name.count("R"),name.count("C"),name.count("H")
print((m*a*(r+c+h)+m*r*(c+h)+m*c*h+a*r*(c+h)+a*c*h+r*c*h)) | N=int(eval(input()))
n=[input()[0] for _ in range(N)]
m,a,r,c,h=n.count("M"),n.count("A"),n.count("R"),n.count("C"),n.count("H")
print((m*a*(r+c+h)+m*r*(c+h)+m*c*h+a*r*(c+h)+a*c*h+r*c*h)) | p03425 |
from itertools import*;d={};g=d.get
for t in open(0).read().split():d[t[0]]=g(t[0],0)+1
print((sum(g(p,0)*g(q,0)*g(r,0)for p,q,r in combinations('MARCH',3)))) | from itertools import*;d=[0]*128
for t in open(0).read().split():d[ord(t[0])]+=1
print((sum(p*q*r for p,q,r in combinations([d[ord(t)]for t in'MARCH'],3)))) | p03425 |
from itertools import*;d=[0]*128
for _ in[0]*int(eval(input())):d[ord(input()[0])]+=1
print((sum(p*q*r for p,q,r in combinations([d[ord(t)]for t in'MARCH'],3)))) | from itertools import*;d=[0]*91
for _ in[0]*int(eval(input())):d[ord(input()[0])]+=1
print((sum(p*q*r for p,q,r in combinations([d[ord(t)]for t in'MARCH'],3)))) | p03425 |
from itertools import*;d={}
for t in open(0).read().split():d[t[0]]=d.get(t[0],0)+1
print((sum(p*q*r for p,q,r in combinations([d.get(t,0)for t in'MARCH'],3)))) | from itertools import*;d={};g=d.get
for t in open(0).read().split():d[t[0]]=g(t[0],0)+1
print((sum(p*q*r for p,q,r in combinations([g(t,0)for t in'MARCH'],3)))) | p03425 |
import sys
from itertools import combinations
from collections import Counter
input = sys.stdin.readline
def log(*args):
print(*args, file=sys.stderr)
def main():
n = int(input().rstrip())
s = [input()[0] for _ in range(n)]
s = [v for v in s if v in 'MARCH']
c = Counter(s)
ans = 0
for x, y, z in combinations(c, 3):
ans += c[x] * c[y] * c[z]
print(ans)
if __name__ == '__main__':
main()
| import sys
from itertools import combinations
from collections import Counter
input = sys.stdin.readline
def log(*args):
print(*args, file=sys.stderr)
def main():
n = int(input().rstrip())
s = [input()[0] for _ in range(n)]
c = Counter(s)
ans = 0
for x, y, z in combinations('MARCH', 3):
ans += c[x] * c[y] * c[z]
print(ans)
if __name__ == '__main__':
main()
| p03425 |
import collections
cc = collections.Counter()
for _ in range(int(input())):
cc[input()[0]] +=1
def dfs(i, total ,cumul, cc, k, s):
if i == len(s) or k == 0:
if k == 0: total[0] += cumul
return
if k:
dfs(i+1, total, cumul * cc[s[i]], cc,k - 1, s)
dfs(i+1, total, cumul, cc, k, s)
total = [0]
dfs(0, total, 1 , cc, 3, 'MARCH')
print(total[0]) | import collections
cc = collections.Counter([input()[0] for _ in range(int(input()))])
def dfs(i, total ,cumul, cc, k, s):
if i == len(s) or k == 0:
if k == 0: total[0] += cumul
return
dfs(i+1, total, cumul * cc[s[i]], cc,k - 1, s)
dfs(i+1, total, cumul, cc, k, s)
total = [0]
dfs(0, total, 1 , cc, 3, 'MARCH')
print(total[0]) | p03425 |
n,*s=list(map(str,open(0).read().split()))
a=[0]*5
ans=0
for i in s:
if i[0] in "MARCH":
a["MARCH".index(i[0])]+=1
for i in range(3):
for j in range(i+1,4):
for k in range(j+1,5):
ans+=a[i]*a[j]*a[k]
print(ans) | from itertools import combinations
n,*s=list(map(str,open(0).read().split()))
a=[0]*5
for i in s:
if i[0] in "MARCH":
a["MARCH".index(i[0])]+=1
print((sum([a[x]*a[y]*a[z] for x,y,z in combinations(list(range(5)),3)]))) | p03425 |
#coding=utf-8
from itertools import combinations
from collections import Counter
def solve(n, ss):
filtered_ss = list([x for x in ss if x in "MARCH"])
gc = Counter(filtered_ss)
if len(gc) < 3:
return 0
ans = 0
for permutation in combinations("MARCH", 3):
ans += (gc[permutation[0]] * gc[permutation[1]] * gc[permutation[2]])
return ans
def main():
n = int(eval(input()))
ss = []
for x in range(n):
ss = ss + [input()[0]]
print((solve(n, ss)))
if __name__ == '__main__':
main()
| #coding=utf-8
from itertools import combinations
from collections import Counter
def solve(n, gc):
#filtered_ss = list(filter(lambda x: x in "MARCH", ss))
#gc = Counter(filtered_ss)
if len(gc) < 3:
return 0
ans = 0
for permutation in combinations("MARCH", 3):
ans += (gc[permutation[0]] * gc[permutation[1]] * gc[permutation[2]])
return ans
def main():
n = int(eval(input()))
gc = {'M': 0, 'A': 0, 'R': 0, 'C': 0, 'H': 0}
for _ in range(n):
x = input()[0]
if x in "MARCH":
gc[x] += 1
print((solve(n, gc)))
if __name__ == '__main__':
main()
| p03425 |
import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right #func(リスト,値)
from heapq import heapify, heappop, heappush
from math import *
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
class counter(dict):
def __init__(self, *args):
super().__init__(args)
def add(self,x):
self.setdefault(x,0)
self[x] += 1
N = int(input())
L = [0]*26
for _ in range(N):
S = input()
L[ston(S[0],'A')] += 1
s = ['M','A','R','C','H']
ans = 0
for l in [[0,1,2],[0,1,3],[0,1,4],[0,2,3],[0,2,4],[0,3,4],[1,2,3],[1,2,4],[1,3,4],[2,3,4]]:
x,y,z = map(lambda x:ston(s[x],'A'), l)
ans += L[x]*L[y]*L[z]
print(ans)
| import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right #func(リスト,値)
from heapq import heapify, heappop, heappush
from itertools import combinations, permutations, product
from math import *
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
class counter(dict):
def __init__(self, *args):
super().__init__(args)
def add(self,x):
self.setdefault(x,0)
self[x] += 1
N = int(input())
L = [0]*26
for _ in range(N):
S = input()
L[ston(S[0],'A')] += 1
s = ['M','A','R','C','H']
ans = 0
for l in combinations(s,3):
x,y,z = map(lambda x:ston(x,'A'), l)
ans += L[x]*L[y]*L[z]
print(ans)
| p03425 |
import itertools
import collections
def main():
n = int(eval(input()))
S = [input()[0] for _ in range(n)]
array = ['M','A','R','C','H']
S_after = []
for s in S:
if s in array:
S_after.append(s)
if len(S_after) < 3:
print((0))
return
S_after_set = set(S_after)
combs = itertools.combinations(S_after_set, 3)
coll = collections.Counter(S_after)
ans = 0
for comb in combs:
if comb[0] != comb[1] != comb[2]:
ans += coll[comb[0]]*coll[comb[1]]*coll[comb[2]]
print(ans)
if __name__ == '__main__':
main()
| import itertools
import collections
def main():
n = int(eval(input()))
S = [input()[0] for _ in range(n)]
array = ['M','A','R','C','H']
combs = itertools.combinations(array, 3)
coll = collections.Counter(S)
ans = 0
for comb in combs:
ans += coll[comb[0]]*coll[comb[1]]*coll[comb[2]]
print(ans)
if __name__ == '__main__':
main()
| p03425 |
n,k = list(map(int, input().split()))
ans = k
for i in range(1, n):
ans *= k-1
print(ans) | n,k = list(map(int, input().split()))
print((k * (k-1) ** (n-1))) | p03963 |
import math
N,K=list(map(int,input().split()))
print((K*((K-1)**(N-1)))) | n,k=list(map(int,input().split()))
print((k*(k-1)**(n-1))) | p03963 |
def main():
n, k = list(map(int, input().split()))
print((k * pow(k - 1, n - 1)))
if __name__ == '__main__':
main()
| def main():
n, k = list(map(int, input().split()))
print((k * (pow(k - 1, n - 1))))
if __name__ == '__main__':
main()
| p03963 |
N, K = list(map(int,input().split()))
pat = K*((K-1)**(N-1))
print(pat) | N, K = list(map(int,input().split()))
print((K*((K-1)**(N-1))))
| p03963 |
import itertools
N,K=[int(i) for i in input().split()]
seq=[i for i in range(K)]
lst=[]
for i in itertools.product(seq, repeat=N):
lst.append(i)
ans=[]
for tup in lst:
f=0
for ind,color in enumerate(tup):
if(ind==len(tup)-1):
break
if(tup[ind+1]==color):
f=1
break
if(f==0):
ans.append(tup)
print((len(ans))) | import itertools
N,K=[int(i) for i in input().split()]
seq=[i for i in range(K)]
lst=[]
'''for i in itertools.product(seq, repeat=N):
lst.append(i)
ans=[]
for tup in lst:
f=0
for ind,color in enumerate(tup):
if(ind==len(tup)-1):
break
if(tup[ind+1]==color):
f=1
break
if(f==0):
ans.append(tup)
print(len(ans))'''
print((K*(K-1)**(N-1))) | p03963 |
import itertools
N,K=[int(i) for i in input().split()]
seq=[i for i in range(K)]
lst=[]
'''for i in itertools.product(seq, repeat=N):
lst.append(i)
ans=[]
for tup in lst:
f=0
for ind,color in enumerate(tup):
if(ind==len(tup)-1):
break
if(tup[ind+1]==color):
f=1
break
if(f==0):
ans.append(tup)
print(len(ans))'''
print((K*(K-1)**(N-1))) | n,k=[int(i) for i in input().split()]
print(((k*1)*((k-1)**(n-1))))
| p03963 |
n, k = list(map(int, input().split()))
ans = k*((k-1)**(n-1))
print(ans)
| n, k = list(map(int, input().split()))
print((k*(k-1)**(n-1)))
| p03963 |
N, K = list(map(int, input().split()))
print((K * (K-1) ** (N-1))) | n, k = list(map(int, input().split()))
print((k * (k-1) ** (n-1))) | p03963 |
N, K = list(map(int, input().split()))
print((K * (K-1) ** (N-1))) | import sys
n, k = list(map(int, sys.stdin.readline().split()))
def main():
ans = k * (k - 1)**(n-1)
return ans
if __name__ == '__main__':
ans = main()
print(ans) | p03963 |
N,K = list(map(int,input().split()))
S = K
while(1):
if N==1:
break
S *= (K-1)
N-=1
print(S) | N,K = list(map(int,input().split()))
ans = 0
for i in range(N):
if i==0:
ans = K
else:
ans *= (K-1)
print(ans) | p03963 |
from itertools import permutations
import sys
sys.setrecursionlimit(10 ** 6)
from bisect import *
from collections import *
from heapq import *
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def SI(): return sys.stdin.readline()[:-1]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
int1 = lambda x: int(x) - 1
def MI1(): return map(int1, sys.stdin.readline().split())
def LI1(): return list(map(int1, sys.stdin.readline().split()))
p2D = lambda x: print(*x, sep="\n")
dij = [(1, 0), (0, 1), (-1, 0), (0, -1)]
def main():
n,k=MI()
ans=k*pow(k-1,n-1)
print(ans)
main()
| import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
n,k=MI()
print(pow(k-1,n-1)*k)
main()
| p03963 |
N, K = list(map(int, input().split()))
print((K*((K-1)**(N-1)))) | N, K = list(map(int, input().split()))
print((K*(K-1)**(N-1))) | p03963 |
n,k = list(map(int, input().split()))
print(((k-1)**(n-1)*k)) | s=input().split()
N=int(s[0])
K=int(s[1])
print(((K-1)**(N-1)*K)) | p03963 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
n,k=list(map(int,input().split()))
print((k*((k-1)**(n-1))))
resolve() | import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
n, k = list(map(int, input().split()))
print((k * pow(k - 1, n - 1)))
resolve() | p03963 |
N,K = [int(i) for i in input().split()]
ans = K
for _ in range(N-1):
ans *= K - 1
print(ans) | N,K = list(map(int, input().split()))
ans = K
for _ in range(N - 1):
ans *= K - 1
print(ans) | p03963 |
import collections
#文字列を一文字ずつ取得したいとき
def inputStrOnebyOne():
s = list(eval(input()))
return s
#整数を一つずつリストに入れる
def inputOnebyOne_Int():
a = list(int(x) for x in input().split())
return a
def main():
n, k = list(map(int, input().split()))
print((k*(k-1)**(n-1)))
if __name__=='__main__':
main() | n, k = list(map(int, input().split()))
print((k*(k-1)**(n-1))) | p03963 |
N, K = list(map(int, input().split()))
A = K
if N != 1:
for i in range(N - 1):
A *= (K - 1)
print(A) | N, K = list(map(int, input().split()))
print((K * (K - 1) ** (N - 1))) | p03963 |
n,k=list(map(int,input().split()))
a=1
f=True
for i in range(n):
if f:
a*=k
f=False
else:
a*=k-1
print(a) | # 入力
N,K=list(map(int,input().split()))
# 出力
print((K*pow(K-1,N-1))) | p03963 |
n, k = list(map(int, input().split()))
print((k*((k-1)**(n-1)))) | n, k = list(map(int, input().split()))
print((k*(k-1)**(n-1)))
| p03963 |
# -*- coding: utf-8 -*-
x1,y1,x2,y2 = list(map(int, input().split()))
X = x2 - x1
Y = y2 - y1
if X > 0 and Y > 0:
x3 = x2 - abs(Y)
y3 = y2 + abs(X)
x4 = x3 - abs(X)
y4 = y3 - abs(Y)
elif X > 0 and Y < 0:
x3 = x2 + abs(Y)
y3 = y2 + abs(X)
x4 = x3 - abs(X)
y4 = y3 + abs(Y)
elif X < 0 and Y > 0:
x3 = x2 - abs(Y)
y3 = y2 - abs(X)
x4 = x3 + abs(X)
y4 = y3 - abs(Y)
elif X < 0 and Y < 0:
x3 = x2 + abs(Y)
y3 = y2 - abs(X)
x4 = x3 + abs(X)
y4 = y3 + abs(Y)
elif X > 0 and Y == 0:
x3 = x2
y3 = y2 + abs(X)
x4 = x3 - abs(X)
y4 = y3
elif X == 0 and Y > 0:
x3 = x2 - abs(Y)
y3 = y2
x4 = x3
y4 = y3 - abs(Y)
elif X < 0 and Y == 0:
x3 = x2
y3 = y2 - abs(X)
x4 = x3 + abs(X)
y4 = y3
elif X == 0 and Y < 0:
x3 = x2 + abs(Y)
y3 = y2
x4 = x3
y4 = y3 + abs(Y)
print((str(x3) + ' ' + str(y3) + ' ' + str(x4) + ' ' + str(y4))) | # -*- coding: utf-8 -*-
x1,y1,x2,y2 = list(map(int, input().split()))
X = x2 - x1
Y = y2 - y1
print((str(x2 - Y) + ' ' + str(y2 + X) + ' ' + str(x1 - Y) + ' ' + str(y1 + X))) | p03265 |
A, B, C, D = map(int, input().split())
def solve(A,B,C,D):
dx,dy = C-A,D-B
x,y = C-dy,D+dx
ans = [x,y]
x,y = x-dx,y-dy
ans += [x,y]
return ans
print(*solve(A,B,C,D),sep=' ')
| A, B, C, D = map(int, input().split())
def solve(A,B,C,D):
dx,dy = C-A,D-B
ans = [C-dy,D+dx,A-dy,B+dx]
return ans
print(*solve(A,B,C,D),sep=' ')
| p03265 |
import sys
import bisect
N = int(sys.stdin.readline().rstrip())
S = list(sys.stdin.readline().rstrip())
Q = int(sys.stdin.readline().rstrip())
idx = {chr(ord("a") + i): set() for i in range(26)}
for i, s in enumerate(S):
idx[s].add(i + 1)
for _ in range(Q):
t, i, c = sys.stdin.readline().rstrip().split()
i = int(i)
if t == "1":
if S[i - 1] != c:
idx[S[i - 1]].remove(i)
idx[c].add(i)
S[i - 1] = c
else:
c = int(c)
ans = 0
for a, id in list(idx.items()):
id = sorted(list(id))
x = bisect.bisect_left(id, i)
y = bisect.bisect_right(id, c)
if y - x:
ans += 1
print(ans) | import sys
import bisect
N = int(sys.stdin.readline().rstrip())
S = list(sys.stdin.readline().rstrip())
Q = int(sys.stdin.readline().rstrip())
idx = {chr(ord("a") + i): [] for i in range(26)}
for i, s in enumerate(S):
idx[s].append(i + 1)
for _ in range(Q):
t, i, c = sys.stdin.readline().rstrip().split()
i = int(i)
if t == "1":
if S[i - 1] != c:
idx[S[i - 1]].remove(i)
bisect.insort(idx[c], i)
S[i - 1] = c
else:
c = int(c)
ans = 0
for a, id in list(idx.items()):
x = bisect.bisect_left(id, i)
y = bisect.bisect_right(id, c)
if y - x:
ans += 1
print(ans) | p02763 |
#coding:utf-8
import sys,os
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
from collections import Counter, deque
from random import random
class Node:
def __init__(self,value:int=-1):
self.left = None
self.right = None
self.value = value
self.priority = random()
self.count_partial = 1
self.sum_partial = value
class Treap:
#Node [left, right, key, value, priority, num_partial, sum_partial]
def __init__(self):
self.root = None
def update(self, node):
if node.left is None:
left_count = 0
left_sum = 0
else:
left_count = node.left.count_partial
left_sum = node.left.sum_partial
if node.right is None:
right_count = 0
right_sum = 0
else:
right_count = node.right.count_partial
right_sum = node.right.sum_partial
node.count_partial = left_count + right_count + 1
node.sum_partial = left_sum + right_sum + node.value
return node
def merge(self, left :Node, right:Node):
if left is None or right is None:
return left if right is None else right
if left.priority > right.priority:
left.right = self.merge(left.right,right)
return self.update(left)
else:
right.left = self.merge(left,right.left)
return self.update(right)
def node_size(self, node:Node):
return 0 if node is None else node.count_partial
def node_key(self, node:None):
return -1 if node is None else node.key
#指定された場所のノードは右の木に含まれる
def split(self, node:Node, key:int, level=0):
if node is None:
return (None,None)
if key <= self.node_size(node.left):
left,right = self.split(node.left, key,level+1)
node.left = right
return left, self.update(node)
else:
left,right = self.split(node.right, key - self.node_size(node.left) - 1,level+1)
node.right = left
return self.update(node),right
def split(self, node:None, value):
if node is None:
return None,None
if value <= node.value:
left,right = self.split(node.left, value)
node.left = right
return left, self.update(node)
else:
left,right = self.split(node.right, value)
node.right = left
return self.update(node),right
def insert(self, pos:int,value:int =-1):
value = value if value > 0 else pos
left, right = self.split(self.root, pos)
new_node = Node(value)
self.root = self.merge(self.merge(left,new_node),right)
def erase(self, pos:int):
middle,right = self.split(self.root, pos+1)
left,middle = self.split(middle, pos)
self.root = self.merge(left,right)
def printTree(self, node=None, level=0):
node = self.root if node is None else node
if node is None:
print('level=',level,'root is None')
return
else:
print('level=',level,'v=',node.value,'c=',node.count_partial, 'p=',node.priority)
if node.left is not None:
self.printTree(node.left,level+1)
if node.right is not None:
self.printTree(node.right,level+1)
def search(self, pos):
#return self.search_recursively(pos,self.root)
v = self.root
while v:
left_count = self.node_size(v.left)
if pos < left_count:
v = v.left
elif pos == left_count:
return v.value
else:
v = v.right
pos -= left_count + 1
return -1
def search2(self, value):
v = self.root
upper = 10**18
while v:
if value == v.value:
return value
elif value < v.value:
upper = v.value
v = v.left
else:
v = v.right
return upper
def search_recursively(self, pos, node):
if node is None:
return -1
num_left = 0 if node.left is None else node.left.count_partial
if num_left + 1 == pos:
return node.value
if pos <= num_left:
return self.search_recursively(pos, node.left)
else:
return self.search_recursively(pos - num_left - 1, node.right)
def main(given=sys.stdin.readline):
input = lambda: given().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(input())
XLMIIS = lambda x: [LMIIS() for _ in range(x)]
YN = lambda c : print('Yes') if c else print('No')
MOD = 10**9+7
N = II()
S = list(input())
trees = []
for i in range(26):
trees.append(Treap())
for i,c in enumerate(S):
trees[ord(c)-ord('a')].insert(i)
Q = int(input())
out = []
for _ in range(Q):
q1,q2,q3 = input().split()
if int(q1) == 1:
iq = int(q2)-1
before = S[iq]
after = q3
S[iq] = after
trees[ord(before)-ord('a')].erase(iq)
trees[ord(after)-ord('a')].insert(iq)
else:
l,r = int(q2)-1,int(q3)-1
count = 0
for i in range(26):
if trees[i].search2(l) <= r:
count += 1
out.append(count)
print('\n'.join(map(str,out)))
if __name__ == '__main__':
main()
| #coding:utf-8
import sys,os
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
from collections import Counter, deque
from random import random
class Node:
def __init__(self,value:int=-1):
self.left = None
self.right = None
self.value = value
self.priority = random()
# self.count_partial = 1
# self.sum_partial = value
class Treap:
#Node [left, right, key, value, priority, num_partial, sum_partial]
def __init__(self):
self.root = None
# def update(self, node):
# if node.left is None:
# left_count = 0
# left_sum = 0
# else:
# left_count = node.left.count_partial
# left_sum = node.left.sum_partial
# if node.right is None:
# right_count = 0
# right_sum = 0
# else:
# right_count = node.right.count_partial
# right_sum = node.right.sum_partial
# node.count_partial = left_count + right_count + 1
# node.sum_partial = left_sum + right_sum + node.value
# return node
def merge(self, left :Node, right:Node):
if left is None or right is None:
return left if right is None else right
if left.priority > right.priority:
left.right = self.merge(left.right,right)
# return self.update(left)
return left
else:
right.left = self.merge(left,right.left)
# return self.update(right)
return right
# def node_size(self, node:Node):
# return 0 if node is None else node.count_partial
# def node_key(self, node:None):
# return -1 if node is None else node.key
#指定された場所のノードは右の木に含まれる
# def split(self, node:Node, key:int, level=0):
# if node is None:
# return (None,None)
# if key <= self.node_size(node.left):
# left,right = self.split(node.left, key,level+1)
# node.left = right
# return left, self.update(node)
# else:
# left,right = self.split(node.right, key - self.node_size(node.left) - 1,level+1)
# node.right = left
# return self.update(node),right
def split(self, node:None, value):
if node is None:
return None,None
if value <= node.value:
left,right = self.split(node.left, value)
node.left = right
return left, node
else:
left,right = self.split(node.right, value)
node.right = left
return node,right
def insert(self, pos:int,value:int =-1):
value = value if value > 0 else pos
left, right = self.split(self.root, pos)
new_node = Node(value)
self.root = self.merge(self.merge(left,new_node),right)
def erase(self, pos:int):
middle,right = self.split(self.root, pos+1)
left,middle = self.split(middle, pos)
self.root = self.merge(left,right)
def printTree(self, node=None, level=0):
node = self.root if node is None else node
if node is None:
print('level=',level,'root is None')
return
else:
print('level=',level,'v=',node.value,'c=',node.count_partial, 'p=',node.priority)
if node.left is not None:
self.printTree(node.left,level+1)
if node.right is not None:
self.printTree(node.right,level+1)
def search(self, pos):
#return self.search_recursively(pos,self.root)
v = self.root
while v:
left_count = self.node_size(v.left)
if pos < left_count:
v = v.left
elif pos == left_count:
return v.value
else:
v = v.right
pos -= left_count + 1
return -1
def search2(self, value):
v = self.root
upper = 10**18
while v:
if value == v.value:
return value
elif value < v.value:
upper = v.value
v = v.left
else:
v = v.right
return upper
def search_recursively(self, pos, node):
if node is None:
return -1
num_left = 0 if node.left is None else node.left.count_partial
if num_left + 1 == pos:
return node.value
if pos <= num_left:
return self.search_recursively(pos, node.left)
else:
return self.search_recursively(pos - num_left - 1, node.right)
def main(given=sys.stdin.readline):
input = lambda: given().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(input())
XLMIIS = lambda x: [LMIIS() for _ in range(x)]
YN = lambda c : print('Yes') if c else print('No')
MOD = 10**9+7
N = II()
S = list(map(lambda c: ord(c) - ord('a'), list(input())))
trees = []
for i in range(26):
trees.append(Treap())
for i,c in enumerate(S):
trees[c].insert(i)
Q = int(input())
out = []
for _ in range(Q):
q1,q2,q3 = input().split()
if int(q1) == 1:
iq = int(q2)-1
before = S[iq]
after = ord(q3)-ord('a')
S[iq] = after
trees[before].erase(iq)
trees[after].insert(iq)
else:
l,r = int(q2)-1,int(q3)-1
count = 0
for i in range(26):
if trees[i].search2(l) <= r:
count += 1
out.append(count)
print('\n'.join(map(str,out)))
if __name__ == '__main__':
main()
| p02763 |
class SegTree():
def segfunc(self, x, y):
return x | y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
def main():
n = int(eval(input()))
s = input().rstrip()
q = int(eval(input()))
ans = []
init = [set() for _ in range(n)]
for i in range(n):
c = s[i]
init[i].add(c)
seg = SegTree(set(), n, init)
for _ in range(q):
x, y, z = list(map(str, input().rstrip().split()))
if x == "1":
y = int(y)
y -= 1
buf = set()
buf.add(z)
seg.update(y, buf)
else:
y = int(y)
y -= 1
z = int(z)
ans.append(len(seg.query(y, z)))
for v in ans:
print(v)
if __name__ == "__main__":
main() | from bisect import bisect_left
def main():
n = int(eval(input()))
s = input().rstrip()
q = int(eval(input()))
ans = []
al = [[] for _ in range(26)]
for i in range(n):
al[ord(s[i]) - ord("a")].append(i)
for _ in range(q):
x, y, z = list(map(str, input().rstrip().split()))
if x == "1":
y = int(y)
y -= 1
if s[y] == z:
continue
al[ord(z) - ord("a")].insert(bisect_left(al[ord(z) - ord("a")], y), y)
al[ord(s[y]) - ord("a")].remove(y)
s = s[:y] + z + s[y+1:]
else:
y = int(y)
y -= 1
z = int(z)
cnt = 0
for i in range(26):
index = bisect_left(al[i], y)
if index < len(al[i]) and al[i][index] < z:
cnt += 1
ans.append(cnt)
for v in ans:
print(v)
if __name__ == "__main__":
main() | p02763 |
from bisect import bisect_left
def main():
n = int(eval(input()))
s = list(input().rstrip())
q = int(eval(input()))
ans = []
al = [[] for _ in range(26)]
for i, c in enumerate(s):
al[ord(c) - ord("a")].append(i)
for _ in range(q):
x, y, z = list(map(str, input().rstrip().split()))
if x == "1":
y = int(y) - 1
if s[y] == z:
continue
p = ord(z) - ord("a")
al[p].insert(bisect_left(al[p], y), y)
al[ord(s[y]) - ord("a")].remove(y)
s[y] = z
else:
y = int(y)
y -= 1
z = int(z)
cnt = 0
for i in range(26):
index = bisect_left(al[i], y)
if index < len(al[i]) and al[i][index] < z:
cnt += 1
ans.append(cnt)
for v in ans:
print(v)
if __name__ == "__main__":
main() | from bisect import bisect_left, insort
def main():
n = int(eval(input()))
s = list(input().rstrip())
q = int(eval(input()))
ans = []
al = [[] for _ in range(26)]
for i, c in enumerate(s):
al[ord(c) - ord("a")].append(i)
for _ in range(q):
x, y, z = list(map(str, input().rstrip().split()))
if x == "1":
y = int(y) - 1
if s[y] == z:
continue
p = bisect_left(al[ord(s[y])-ord("a")],y)
al[ord(s[y])-ord("a")].pop(p)
insort(al[ord(z)-ord("a")],y)
s[y] = z
else:
y = int(y) - 1
z = int(z)
cnt = 0
for i in range(26):
index = bisect_left(al[i], y)
if index < len(al[i]) and al[i][index] < z:
cnt += 1
ans.append(cnt)
for v in ans:
print(v)
if __name__ == "__main__":
main() | p02763 |
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
alpha = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', \
'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
def twopowerceil(n): # return m s.t. m>=n and m=2**p
for i in range(40):
m = 2**i
if m >= n:
return m
return -1
# 0
# 1 2
# 3 4 5 6
# :
# leaf i - n-1+i
# parent - (i-1)//2
# children - 2*i+1, 2*i+2
def sgtoper(x,y):
return (x or y) # min,max,gcd,...
SGTDEFAULT = False # for or ; BIG for min ; ..
# s.t. sgtoper(x,SGTDEFAULT) = x
# nn = twopowerceil(n)
# tree must be initialized to [SGTDEFAULT]*(2*nn)
def sgtinit(tree,a,n,nn): # upto N-1, not N
for i in range(n):
tree[nn-1+i] = a[i]
for i in range(nn-2,-1,-1):
tree[i] = sgtoper(tree[2*i+1], tree[2*i+2])
def sgtget(tree,x,y,nn):
return sgtgetcore(tree,x,y,0,0,nn)
# x,y: from query k: suffix at focus l,r: range for k
# right ends (y,r) not included
def sgtgetcore(tree,x,y,k,l,r):
if r<=x or y<=l:
return SGTDEFAULT
if x<=l and r<=y:
return tree[k]
vl = sgtgetcore(tree,x,y,2*k+1,l,(l+r)//2)
vr = sgtgetcore(tree,x,y,2*k+2,(l+r)//2,r)
return sgtoper(vl, vr)
def sgtupd(tree,i,x,nn):
k = i+nn-1
tree[k] = x
while k>0:
k = (k-1)//2
tree[k] = sgtoper(tree[2*k+1], tree[2*k+2])
n = inn()
nn = twopowerceil(n)
tr = {}
for c in alpha:
tr[c] = [False]*(2*nn)
ss = ins()
s = []
for i in range(n):
s.append(ss[i])
a = {}
for c in alpha:
a[c] = [False]*n
for i in range(n):
a[s[i]][i] = True
for c in alpha:
sgtinit(tr[c],a[c],n,nn)
#ddprint("tree")
#for c in alpha:
# ddprint(c)
# ddprint(tr[c])
q = inn()
for qq in range(q):
x,y,z = input().split()
#ddprint(f"x {x} y {y} z {z}")
if x == '1':
i = int(y)-1
c = z
sgtupd(tr[s[i]], i, False, nn)
sgtupd(tr[c], i, True, nn)
s[i] = c
else:
l = int(y)
r = int(z)
sm = 0
for c in alpha:
v = sgtget(tr[c],l-1,r,nn)
if v:
sm += 1
print(sm)
|
# # # # class Segtree # # # #
# 0
# 1 2
# 3 4 5 6
# :
# leaf i - n-1+i
# parent - (i-1)//2
# children - 2*i+1, 2*i+2
class Segtree:
# modify UNIT and oper depending on the reduce operation
UNIT = 0 # sum:0 min:BIG max:-BIG gcd:1 lcm:0 ..
@classmethod
def oper(c,x,y):
return x|y # sum:+ min/max/gcd/lcm:(same)
def __init__(s,l):
s.n = 1
while s.n<l:
s.n *= 2
s.ary = [Segtree.UNIT for i in range(2*s.n-1)]
def get(s,i):
return s.ary[i+s.n-1]
def set(s,i,v):
k = i+s.n-1
s.ary[k] = v
while k>0:
k = (k-1)//2
s.ary[k] = Segtree.oper( \
s.ary[2*k+1], s.ary[2*k+2])
def setary(s,a):
for i,v in enumerate(a):
s.ary[i+s.n-1] = v
for k in range(s.n-2,-1,-1):
s.ary[k] = Segtree.oper( \
s.ary[2*k+1], s.ary[2*k+2])
def query(s,x,y):
return s.querycore(x,y,0,0,s.n)
# x,y: from query k: suffix at focus l,r: range for k
# right ends (y,r) not included
def querycore(s,x,y,k,l,r):
if r<=x or y<=l:
return Segtree.UNIT
if x<=l and r<=y:
return s.ary[k]
vl = s.querycore(x,y,2*k+1,l,(l+r)//2)
vr = s.querycore(x,y,2*k+2,(l+r)//2,r)
return Segtree.oper(vl, vr)
# # # # class Segtree end # # # #
inn = lambda : int(eval(input()))
inl = lambda: list(map(int, input().split()))
inm = lambda: list(map(int, input().split()))
ins = lambda : input().strip()
n = inn()
sgt = Segtree(n)
ss = ins()
s = []
for i in range(n):
sgt.set(i, 1<<(ord(ss[i])-ord('a')))
#ddprint("tree")
#for c in alpha:
# ddprint(c)
# ddprint(tr[c])
q = inn()
for qq in range(q):
x,y,z = input().split()
#ddprint(f"x {x} y {y} z {z}")
if x == '1':
i = int(y)-1
c = z
sgt.set(i, 1<<(ord(c)-ord('a')))
else:
l = int(y)
r = int(z)
sm = 0
v = sgt.query(l-1,r)
for i in range(26):
if (v>>i)%2==1:
sm += 1
print(sm)
| p02763 |
f=input
n,s,q=int(f()),list(f()),int(f())
d={chr(97+i):[] for i in range(26)}
for i in range(n):
d[s[i]]+=[i]
from bisect import *
for i in range(q):
a,b,c=input().split()
b=int(b)-1
if a=='1':
d[s[b]].pop(bisect(d[s[b]],b)-1)
s[b]=c
insort(d[c],b)
else:
t=0
for l in list(d.values()):
m=bisect(l,b-1)
if m<len(l) and l[m]<int(c): t+=1
print(t) | f=input
n,l,q=int(f()),list(f()),int(f())
B=[[0]*-~n for i in range(26)]
def S(o,i):
s=0
while i: s+=B[o][i]; i-=i&-i
return s
def A(o,i,x):
while i<=n: B[o][i]+=x; i+=i&-i
for i in range(n): A(ord(l[i])-97,i+1,1)
for i in range(q):
a,b,c=f().split(); b=int(b)
if a>'1': print((sum(1 for o in range(26) if S(o,int(c))-S(o,b-1))))
else: A(ord(l[b-1])-97,b,-1); l[b-1]=c; A(ord(c)-97,b,1) | p02763 |
f=input
n,l,q=int(f()),list(f()),int(f())
B=[[0]*-~n for i in range(26)]
def S(o,i):
s=0
while i: s+=B[o][i]; i-=i&-i
return s
def A(o,i,x):
while i<=n: B[o][i]+=x; i+=i&-i
for i in range(n): A(ord(l[i])-97,i+1,1)
for i in range(q):
a,b,c=f().split(); b=int(b)
if a>'1': print((sum(1 for o in range(26) if S(o,int(c))-S(o,b-1))))
else: A(ord(l[b-1])-97,b,-1); l[b-1]=c; A(ord(c)-97,b,1) | f=input
n,s,q=int(f()),list(f()),int(f())
d={chr(97+i):[] for i in range(26)}
for i in range(n):
d[s[i]]+=[i]
from bisect import *
for i in range(q):
a,b,c=f().split()
b=int(b)-1
if a=='1':
if s[b]==c: continue
d[s[b]].pop(bisect(d[s[b]],b)-1)
s[b]=c
insort(d[c],b)
else:
t=0
for l in list(d.values()):
m=bisect(l,b-1)
if m<len(l) and l[m]<int(c): t+=1
print(t) | p02763 |
f=input; from bisect import bisect_left as g, insort as h
f(); s,i=list(f()),0
from collections import *
d=defaultdict(list)
for c in s: d[c]+=[i]; i+=1
for _ in range(int(f())):
a,b,c=f().split(); b=int(b)-1
if a>'1': print((sum(1 for l in list(d.values()) if g(l,b)<len(l) and l[g(l,b)]<int(c))))
elif s[b]!=c: l=d[s[b]]; l.pop(g(l,b)); s[b]=c; h(d[c],b) | f=input; from bisect import bisect_left as g, insort as h
d={chr(97+i):[] for i in range(26)}
f(); s,i=list(f()),0
for c in s: d[c]+=[i]; i+=1
for _ in range(int(f())):
a,b,c=f().split(); b=int(b)-1
if a>'1': print((sum(1 for l in list(d.values()) if g(l,b)<len(l) and l[g(l,b)]<int(c))))
elif s[b]!=c: l=d[s[b]]; l.pop(g(l,b)); s[b]=c; h(d[c],b) | p02763 |
import sys
read = sys.stdin.readline
def read_ints():
return list(map(int, read().split()))
def read_a_int():
return int(read())
def read_matrix(H):
'''
H is number of rows
'''
return [list(map(int, read().split())) for _ in range(H)]
def read_map(H):
'''
H is number of rows
文字列で与えられた盤面を読み取る用
'''
return [read()[:-1] for _ in range(H)]
def read_tuple(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_col(H, n_cols):
'''
H is number of rows
n_cols is number of cols
A列、B列が与えられるようなとき
'''
ret = [[] for _ in range(n_cols)]
for _ in range(H):
tmp = list(map(int, read().split()))
for col in range(n_cols):
ret[col].append(tmp[col])
return ret
def index(a, x):
'Locate the leftmost value exactly equal to x'
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return i
raise ValueError
# ポイント
# 文字列update
# 文字種の高速取得
# 文字種の高速取得について考えてみる
# 文字のidxを取得しておいて二分探索することで高速に取得することが可能
N = read_a_int()
S = list(read()[:-1])
from collections import defaultdict
from bisect import bisect_left, bisect_right, insort_left
char_idxs = defaultdict(lambda: [])
for i, s in enumerate(S):
char_idxs[s].append(i)
def get_syurui(char_idxs, l, r):
ret = 0
for v in list(char_idxs.values()):
l_idx = bisect_left(v, l)
r_idx = bisect_right(v, r)
# print(v,l_idx,r_idx)
if r_idx - l_idx > 0:
ret += 1
return ret
Q = read_a_int()
for q in range(Q):
com, a, b = read().split()
if int(com) == 2:
a, b = int(a) - 1, int(b) - 1
print((get_syurui(char_idxs, a, b)))
else:
i = int(a) - 1
if S[i] == b:
continue
# i文字目を消す
tmp = char_idxs[S[i]] # S[i]を更新しなきゃ
del char_idxs[S[i]][index(tmp, i)]
# cのidxに挿入し直す
insort_left(char_idxs[b], i)
# S[i]を更新しなきゃ
S[i] = b
| # https://atcoder.jp/contests/abc157/tasks/abc157_e
# セグメント木
# 各文字をビットに対応させる(セグ木を26本持っても良い)
import sys
read = sys.stdin.readline
def read_a_int():
return int(read())
class SegmentTree:
def __init__(self, ls: list, segfunc, identity_element):
'''
セグ木 (下書き)
一次元のリストlsを受け取り初期化する。O(len(ls))
区間のルールはsegfuncによって定義される
identity elementは単位元。e.g., 最小値を求めたい→inf, 和→0, 積→1, gcd→0
[単位元](https://ja.wikipedia.org/wiki/%E5%8D%98%E4%BD%8D%E5%85%83)
'''
self.ide = identity_element
self.func = segfunc
n = len(ls)
self.num = 2 ** (n - 1).bit_length() # n以上の最小の2のべき乗
self.tree = [self.ide] * (2 * self.num - 1) # −1はぴったりに作るためだけど気にしないでいい
for i, l in enumerate(ls): # 木の葉に代入
self.tree[i + self.num - 1] = l
for i in range(self.num - 2, -1, -1): # 子を束ねて親を更新
self.tree[i] = segfunc(self.tree[2 * i + 1], self.tree[2 * i + 2])
def update(self, i, x):
'''
i番目の要素をxに変更する(木の中間ノードも更新する) O(logN)
'''
i += self.num - 1
self.tree[i] = x
while i: # 木を更新
i = (i - 1) // 2
self.tree[i] = self.func(self.tree[i * 2 + 1],
self.tree[i * 2 + 2])
def query(self, l, r):
'''
区間[l,r)に対するクエリをO(logN)で処理する。例えばその区間の最小値、最大値、gcdなど
'''
if r <= l:
return ValueError('invalid index (l,rがありえないよ)')
l += self.num - 1
r += self.num - 2 # ここで半開区間でなく[l,r]で以下を処理する
res = self.ide
while r - l > 1: # 右から寄りながら結果を結合していくイメージ
if l & 1 == 0:
res = self.func(res, self.tree[l])
if r & 1 == 1:
res = self.func(res, self.tree[r])
r -= 1
l = l // 2 # 親の一つ右に移動
r = (r - 1) // 2 # 親の一つ左に移動
if l == r:
res = self.func(res, self.tree[l])
else:
res = self.func(res, self.tree[l])
res = self.func(res, self.tree[r])
return res
def segfunc(x, y):
# 処理したい内容
return x | y
def moji_to_bit(a):
return 1 << (ord(a) - ord('a'))
def bit_to_sum(n):
return sum([(n >> i) & 1 for i in range(n.bit_length())])
N = read_a_int()
S = read()[:-1]
S_bit = [moji_to_bit(s) for s in S]
# build segment tree
st = SegmentTree(S_bit, segfunc, 0)
Q = read_a_int()
for q in range(Q):
com, a, b = read().split()
if int(com) == 1:
i, c = int(a) - 1, b
st.update(i, moji_to_bit(c))
else:
l, r = int(a) - 1, int(b)
print((bit_to_sum(st.query(l, r))))
| p02763 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(300000)
class BinaryIndexedTree(object):
def __init__(self, n):
self.n = n
self.vals = [0] * (n + 1)
def add(self, i, v):
while i <= self.n:
self.vals[i] += v
i += i & -i
def sum(self, i):
ret = 0
while i > 0:
ret += self.vals[i]
i -= i & -i
return ret
def sum_range(self, l, r):
# l and r are 1-based index and inclusive
return self.sum(r) - self.sum(l - 1)
def update(i, val, n, bi_tree, sign=1):
i += 1
while i < n:
bi_tree[i][val] += (1 * sign)
i += i & -i
def get_sum(i, bi_tree):
ans = [0] * 26
while i > 0:
tmp = bi_tree[i]
for j in range(26):
ans[j] += tmp[j]
i -= i & -i
return ans
def get_range_sum(left, right, bi_tree):
r_sum = get_sum(right, bi_tree)
l_sum = get_sum(left - 1, bi_tree)
for i in range(26):
r_sum[i] -= l_sum[i]
return r_sum
from pprint import pprint
def solve(N, S, Q, queries):
#arr.insert(0, 0) # insert dummy node for 1-based indexing
#bit = [0 for i in range(n+1)]
trees = []
for i in range(26):
trees.append(BinaryIndexedTree(N))
s = []
for i, c in enumerate(S):
c_idx = ord(c) - ord('a')
if 'a' <= c <= 'z':
trees[c_idx].add(i + 1, 1)
s.append(c)
for q in queries:
if q[0] == '1':
i, c = int(q[1]), q[2]
p = s[i - 1]
s[i - 1] = c
trees[ord(p) - ord('a')].add(i, -1)
trees[ord(c) - ord('a')].add(i, 1)
if q[0] == '2':
l, r = int(q[1]), int(q[2])
ret = 0
for tree in trees:
cnt = tree.sum_range(l, r)
if cnt:
ret += 1
print(ret)
#pprint(get_range_sum(1, 5, bit))
#print(s)
#print()
return
def _solve(N, S, Q, queries):
#arr.insert(0, 0) # insert dummy node for 1-based indexing
#bit = [0 for i in range(n+1)]
bit = [[0] * 26 for i in range(N + 1)]
s = []
for i, c in enumerate(S):
if 'a' <= c <= 'z':
update(i, ord(c) - ord('a'), N + 1, bit)
s.append(c)
for q in queries:
if q[0] == '1':
i, c = int(q[1]) - 1, q[2]
p = s[i]
update(i, ord(p) - ord('a'), N + 1, bit, -1)
update(i, ord(c) - ord('a'), N + 1, bit, 1)
s[i] = c
if q[0] == '2':
l, r = int(q[1]), int(q[2])
counts = get_range_sum(l, r, bit)
ret = 0
for x in counts:
if x > 0:
ret += 1
print(ret)
#pprint(get_range_sum(1, 5, bit))
#print(s)
#print()
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))
S = str(next(tokens))
Q = int(next(tokens))
q = []
for i in range(Q):
q.append(list(map(str, input().split())))
solve(N, S, Q, q)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(300000)
class BinaryIndexedTree(object):
def __init__(self, n):
# index is 1-based so vals[0] never be used
self.n = n
self.vals = [0] * (n + 1)
def add(self, i, v):
while i <= self.n:
self.vals[i] += v
i += i & -i
def sum(self, i):
ret = 0
while i > 0:
ret += self.vals[i]
i -= i & -i
return ret
def sum_range(self, l, r):
# l and r are 1-based index and inclusive
return self.sum(r) - self.sum(l - 1)
def solve(N, S, Q, queries):
trees = []
for i in range(26):
trees.append(BinaryIndexedTree(N))
s = []
for i, c in enumerate(S):
c_idx = ord(c) - ord('a')
if 'a' <= c <= 'z':
trees[c_idx].add(i + 1, 1)
s.append(c)
for q in queries:
if q[0] == '1':
i, c = int(q[1]), q[2]
p = s[i - 1]
s[i - 1] = c
trees[ord(p) - ord('a')].add(i, -1)
trees[ord(c) - ord('a')].add(i, 1)
if q[0] == '2':
l, r = int(q[1]), int(q[2])
ret = 0
for tree in trees:
cnt = tree.sum_range(l, r)
if cnt:
ret += 1
print(ret)
#pprint(get_range_sum(1, 5, bit))
#print(s)
#print()
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))
S = str(next(tokens))
Q = int(next(tokens))
q = []
for i in range(Q):
q.append(list(map(str, input().split())))
solve(N, S, Q, q)
if __name__ == '__main__':
main()
| p02763 |
# AtCoder Beginner Contest 157
# E - Simple String Queries
# https://atcoder.jp/contests/abc157/tasks/abc157_e
from bisect import bisect_left, insort_left
import sys
input = sys.stdin.readline
OFS = ord('a')
_ = eval(input())
S = list(input()[:-1])
D = [[] for _ in [0]*26]
for i, s in enumerate(S):
D[ord(s)-OFS].append(i)
for _ in [0]*int(eval(input())):
Q = input()[:-1].split()
if Q[0] == '1':
i, c = int(Q[1])-1, Q[2]
s = ord(S[i])-OFS
deli = bisect_left(D[s], i)
del D[s][deli]
insort_left(D[ord(c)-OFS], i)
S[i] = c
else:
l, r = int(Q[1])-1, int(Q[2])-1
cnt = 0
for L in D:
i = bisect_left(L, l)
if i < len(L) and L[i] <= r:
cnt += 1
print(cnt)
| # AtCoder Beginner Contest 157
# E - Simple String Queries
# https://atcoder.jp/contests/abc157/tasks/abc157_e
from bisect import bisect_left, insort_left
import sys
input = sys.stdin.readline
OFS = ord('a')
_ = eval(input())
S = list(input()[:-1])
D = [[] for _ in [0]*26]
for i, s in enumerate(S):
D[ord(s)-OFS].append(i)
for _ in [0]*int(eval(input())):
Q = input()[:-1].split()
if Q[0] == '1':
i, c = int(Q[1])-1, Q[2]
if S[i] != c:
s = ord(S[i])-OFS
D[s].pop(bisect_left(D[s], i))
insort_left(D[ord(c)-OFS], i)
S[i] = c
else:
l, r = int(Q[1])-1, int(Q[2])-1
cnt = 0
for L in D:
i = bisect_left(L, l)
if i < len(L) and L[i] <= r:
cnt += 1
print(cnt)
| p02763 |
N = int(eval(input()))
S = list(input().strip())
Qcnt = int(eval(input()))
cidx = {}
for i in range(ord("a"), ord("z")+1):
cidx[chr(i)] = set([])
import bisect
for idx, s in enumerate(S):
cidx[s].add(idx)
for _ in range(Qcnt):
Q = list(input().strip().split(" "))
if Q[0] == "1":
q_idx = int(Q[1]) - 1
prev_c = S[q_idx]
S[q_idx] = Q[2]
cidx[prev_c].remove(q_idx)
cidx[Q[2]].add(q_idx)
else:
l = int(Q[1])
r = int(Q[2])
l -= 1
cnt = 0
for alpha in range(ord("a"), ord("z")+1):
tmp = sorted(list(cidx[chr(alpha)]))
lid = bisect.bisect_left(tmp, l)
rid = bisect.bisect_left(tmp, r)
if lid < rid:
cnt += 1
print(cnt) | class SegTree:
def __init__(self, N, S):
self.N = 2 ** ((N-1).bit_length())
self.tree = [0 for i in range(self.N * 2 - 1)]
for i in range(len(S)):
self.tree[self.N - 1 + i] = 1 << (ord(S[i]) - ord("a"))
for i in range(self.N - 2, -1, -1):
self.tree[i] = self.tree[i*2 + 1] | self.tree[i*2 + 2]
def update(self, index, char):
i = self.N - 1 + index
# アルファベットがある = bitが立っている
self.tree[i] = 1 << (ord(char) - ord("a"))
while i > 0:
i = (i-1) // 2
self.tree[i] = self.tree[i*2 + 1] | self.tree[i*2 + 2]
def get(self, a, b):
return self.query(a, b, 0, 0, self.N)
# k : ノードの番号
# l : ノードkの受け持つ区間
# r : ノードkの受け持つ区間
def query(self, a, b, k, l, r):
if r <= a or b <= l: # 区間外
return 0
elif a <= l and r <= b: # 受け持ち区間は完全に含まれている
return self.tree[k]
else: # 一部含まれてる
left = self.query(a, b, 2 * k + 1, l, (l+r)//2)
right = self.query(a, b, 2 * k + 2, (l+r)//2, r)
return left | right
def solve():
N = int(eval(input()))
S = list(input().strip())
tree = SegTree(N, S)
Q = int(eval(input()))
for _ in range(Q):
t_q, in_1, in_2 = input().split()
if t_q == "1":
i_q = int(in_1)
c_q = in_2
tree.update(i_q-1, c_q)
else:
l_q = int(in_1)
r_q = int(in_2)
print((bin(tree.get(l_q-1, r_q)).count("1")))
solve() | p02763 |
def solve():
import sys
input = sys.stdin.readline
ordA = ord('a')
N = int(eval(input()))
Ss = input().strip()
nos = [ord(S)-ordA for S in Ss]
Q = int(eval(input()))
idEle = 0
def _binOpe(x, y):
return x | y
def makeSegTree(numEle):
numPow2 = 2 ** (numEle-1).bit_length()
data = [idEle] * (2*numPow2)
return data, numPow2
def setInit(As):
for iST, A in enumerate(As, numPow2):
data[iST] = A
for iST in reversed(list(range(1, numPow2))):
data[iST] = _binOpe(data[2*iST], data[2*iST+1])
def _update1(iA, A):
iST = iA + numPow2
data[iST] = A
def update(iA, A):
_update1(iA, A)
iST = iA + numPow2
while iST > 1:
iST >>= 1
data[iST] = _binOpe(data[2*iST], data[2*iST+1])
def getValue(iSt, iEn):
L = iSt + numPow2
R = iEn + numPow2
ans = idEle
while L < R:
if L & 1:
ans = _binOpe(ans, data[L])
L += 1
if R & 1:
R -= 1
ans = _binOpe(ans, data[R])
L >>= 1
R >>= 1
return ans
data, numPow2 = makeSegTree(N)
As = [(1<<no) for no in nos]
setInit(As)
anss = []
for _ in range(Q):
tp, v1, v2 = input().split()
if tp == '1':
pos = int(v1)-1
c = ord(v2)-ordA
update(pos, 1<<c)
else:
L, R = int(v1)-1, int(v2)-1
v = getValue(L, R+1)
ans = bin(v).count('1')
anss.append(ans)
print(('\n'.join(map(str, anss))))
solve()
| import sys
input = sys.stdin.readline
def solve():
ordA = ord('a')
N = int(eval(input()))
Ss = input().rstrip()
Q = int(eval(input()))
querys = [tuple(input().split()) for _ in range(Q)]
idEle = 0
def _binOpe(x, y):
return x | y
def makeSegTree(numEle):
numPow2 = 2 ** (numEle-1).bit_length()
data = [idEle] * (2*numPow2)
return data, numPow2
def setInit(As):
for iST, A in enumerate(As, numPow2):
data[iST] = A
for iST in reversed(list(range(1, numPow2))):
data[iST] = _binOpe(data[2*iST], data[2*iST+1])
def _update1(iA, A):
iST = iA + numPow2
data[iST] = A
def update(iA, A):
_update1(iA, A)
iST = iA + numPow2
while iST > 1:
iST >>= 1
data[iST] = _binOpe(data[2*iST], data[2*iST+1])
def getValue(iSt, iEn):
L = iSt + numPow2
R = iEn + numPow2
ans = idEle
while L < R:
if L & 1:
ans = _binOpe(ans, data[L])
L += 1
if R & 1:
R -= 1
ans = _binOpe(ans, data[R])
L >>= 1
R >>= 1
return ans
data, numPow2 = makeSegTree(N)
As = [(1<<(ord(S)-ordA)) for S in Ss]
setInit(As)
anss = []
for tp, *vs in querys:
if tp == '1':
i, c = vs
i = int(i)
update(i-1, 1<<(ord(c)-ordA))
else:
L, R = vs
L, R = int(L), int(R)
v = getValue(L-1, R)
anss.append(bin(v).count('1'))
print(('\n'.join(map(str, anss))))
solve()
| p02763 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub, or_
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class SegmentTree:
def __init__(self, orig, func, unit):
_len = len(orig)
self.func = func
self.size = 1 << (_len - 1).bit_length()
self.tree = [unit] * self.size + orig + [unit] * (self.size - _len)
self.unit = unit
for i in range(self.size - 1, 0, -1):
self.tree[i] = func(self.tree[i * 2], self.tree[i * 2 + 1])
def update(self, i, v):
i += self.size
self.tree[i] = v
while i:
i //= 2
self.tree[i] = self.func(self.tree[i * 2], self.tree[i * 2 + 1])
def find(self, l, r):
l += self.size
r += self.size
ret = self.unit
while l < r:
if l & 1:
ret = self.func(ret, self.tree[l])
l += 1
if r & 1:
r -= 1
ret = self.func(ret, self.tree[r])
l //= 2
r //= 2
return ret
@mt
def slv(N, S, Q):
S = [c for c in S]
st = SegmentTree([0] * N, or_, 0)
for i, c in enumerate(S):
st.update(i, 1 << (ord(c) - ord('a')))
for q in Q:
if q[0] == '1':
i = int(q[1]) - 1
c = q[2]
st.update(i, 1 << (ord(c) - ord('a')))
if q[0] == '2':
i = int(q[1]) - 1
j = int(q[2]) - 1
ans = 0
v = st.find(i, j+1)
for k in range(26):
if (1 << k) & v:
ans += 1
print(ans)
# return ans
def main():
N = read_int()
S = read_str()
Q = [read_str_n() for _ in range(read_int())]
(slv(N, S, Q))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub, or_
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class SegmentTree:
def __init__(self, orig, func, unit):
_len = len(orig)
self.func = func
self.size = 1 << (_len - 1).bit_length()
self.tree = [unit] * self.size + orig + [unit] * (self.size - _len)
self.unit = unit
for i in range(self.size - 1, 0, -1):
self.tree[i] = func(self.tree[i * 2], self.tree[i * 2 + 1])
def update(self, i, v):
i += self.size
self.tree[i] = v
while i:
i //= 2
self.tree[i] = self.func(self.tree[i * 2], self.tree[i * 2 + 1])
def find(self, l, r):
l += self.size
r += self.size
ret = self.unit
while l < r:
if l & 1:
ret = self.func(ret, self.tree[l])
l += 1
if r & 1:
r -= 1
ret = self.func(ret, self.tree[r])
l //= 2
r //= 2
return ret
@mt
def slv(N, S, Q):
st = SegmentTree([1 << (ord(c) - ord('a')) for c in S], or_, 0)
for q in Q:
if q[0] == '1':
i = int(q[1]) - 1
c = q[2]
st.update(i, 1 << (ord(c) - ord('a')))
if q[0] == '2':
i = int(q[1]) - 1
j = int(q[2]) - 1
ans = 0
v = st.find(i, j+1)
for k in range(26):
if (1 << k) & v:
ans += 1
print(ans)
# return ans
def main():
N = read_int()
S = read_str()
Q = [read_str_n() for _ in range(read_int())]
(slv(N, S, Q))
if __name__ == '__main__':
main()
| p02763 |
#!python3
import sys
from bisect import bisect, insort_left
iim = lambda: map(int, input().rstrip().split())
def resolve():
N = int(input())
S = list(input())
Q = int(input())
c0 = ord('a')
S1 = [[] for i in range(26)]
for i, c1 in enumerate(S):
ci = ord(c1) - c0
S1[ci].append(i)
ans = []
for cmd, i, j in (line.split() for line in sys.stdin):
i = int(i) - 1
if cmd == "1":
if S[i] == j:
continue
c1 = ord(S[i]) - c0
s1 = S1[c1]
s1.remove(i)
S[i] = j
c1 = ord(j) - c0
insort_left(S1[c1], i)
elif cmd == "2":
j = int(j) - 1
num = 0
for s1 in S1:
ls = len(s1)
k = bisect(s1, i-1, 0, ls)
if k == ls:
continue
if i <= s1[k] <= j:
num += 1
ans.append(num)
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| #!python3
import sys
from bisect import bisect, insort_left
iim = lambda: map(int, input().rstrip().split())
def resolve():
N = int(input())
S = list(input())
Q = int(input())
c0 = ord('a')
S1 = [[] for i in range(26)]
for i, c1 in enumerate(S):
ci = ord(c1) - c0
S1[ci].append(i)
ans = []
for cmd, i, j in (line.split() for line in sys.stdin):
i = int(i) - 1
if cmd == "1":
if S[i] == j:
continue
c1 = ord(S[i]) - c0
s1 = S1[c1]
s1.pop(bisect(s1, i)-1)
S[i] = j
c1 = ord(j) - c0
insort_left(S1[c1], i)
elif cmd == "2":
j = int(j) - 1
num = 0
for s1 in S1:
ls = len(s1)
k = bisect(s1, i-1, 0, ls)
if k == ls:
continue
if i <= s1[k] <= j:
num += 1
ans.append(num)
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| p02763 |
#!python3
import sys
iim = lambda: map(int, input().rstrip().split())
def popcnt2(n):
a = (
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
)
ans = 0
while n:
ans += a[n&0xff]
n >>= 8
return ans
def resolve():
N = int(input())
S = list(input())
Q = int(input())
c0 = ord('a')
smap = [1<<(i-c0) for i in range(c0, ord('z')+1)]
T = [0]*N + [smap[ord(S[i])-c0] for i in range(N)]
for i in range(N-1, 0, -1):
i2 = i << 1
T[i] = T[i2] | T[i2|1]
ans = []
#print(T)
for cmd, i, j in (line.split() for line in sys.stdin.readlines()):
i = int(i) - 1
if cmd == "1":
if S[i] == j:
continue
S[i] = j
i0 = N + i
T[i0] = smap[ord(j)-c0]
while i0 > 1:
i0 = i0 >> 1
T[i0] = T[i0+i0] | T[i0-~i0]
elif cmd == "2":
i += N
j = int(j) + N
d1 = 0
while i < j:
if i & 1:
d1 |= T[i]
i += 1
if j & 1:
j -= 1
d1 |= T[j]
i >>= 1; j >>=1
ans.append(popcnt2(d1))
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| #!python3
import sys
iim = lambda: map(int, input().rstrip().split())
def popcnt2(n):
a = (
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
)
ans = 0
while n:
ans += a[n&0xff]
n >>= 8
return ans
def resolve():
N = int(input())
S = list(input())
Q = int(input())
c0 = ord('a')
smap = [1<<(i-c0) for i in range(c0, ord('z')+1)]
T = [0]*N + [smap[ord(S[i])-c0] for i in range(N)]
for i in range(N-1, 0, -1):
i2 = i << 1
T[i] = T[i2] | T[i2|1]
ans = []
#print(T)
for cmd, i, j in zip(*[iter(sys.stdin.read().split())]*3):
i = int(i) - 1
if cmd == "1":
if S[i] == j:
continue
S[i] = j
i0 = N + i
T[i0] = smap[ord(j)-c0]
while i0 > 1:
i0 = i0 >> 1
T[i0] = T[i0+i0] | T[i0-~i0]
elif cmd == "2":
i += N
j = int(j) + N
d1 = 0
while i < j:
if i & 1:
d1 |= T[i]
i += 1
if j & 1:
j -= 1
d1 |= T[j]
i >>= 1; j >>=1
ans.append(popcnt2(d1))
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| p02763 |
#!python3
import sys
iim = lambda: map(int, input().rstrip().split())
def popcnt2(n):
a = (
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
)
ans = 0
while n:
ans += a[n&0xff]
n >>= 8
return ans
def resolve():
N = int(input())
S = list(input())
Q = int(input())
c0 = ord('a')
smap = [1<<(i-c0) for i in range(c0, ord('z')+1)]
T = [0]*N + [smap[ord(S[i])-c0] for i in range(N)]
for i in range(N-1, 0, -1):
i2 = i << 1
T[i] = T[i2] | T[i2|1]
ans = []
#print(T)
for cmd, i, j in zip(*[iter(sys.stdin.read().split())]*3):
i = int(i) - 1
if cmd == "1":
if S[i] == j:
continue
S[i] = j
i0 = N + i
T[i0] = smap[ord(j)-c0]
while i0 > 1:
i0 = i0 >> 1
T[i0] = T[i0+i0] | T[i0-~i0]
elif cmd == "2":
i += N
j = int(j) + N
d1 = 0
while i < j:
if i & 1:
d1 |= T[i]
i += 1
if j & 1:
j -= 1
d1 |= T[j]
i >>= 1; j >>=1
ans.append(popcnt2(d1))
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| #!python3
import sys
iim = lambda: map(int, input().rstrip().split())
def resolve():
N = int(input())
S = list(input())
Q = int(input())
c0 = ord('a')
smap = [1<<(i-c0) for i in range(c0, ord('z')+1)]
T = [0]*N + [smap[ord(S[i])-c0] for i in range(N)]
for i in range(N-1, 0, -1):
i2 = i << 1
T[i] = T[i2] | T[i2|1]
ans = []
#print(T)
for cmd, i, j in zip(*[iter(sys.stdin.read().split())]*3):
i = int(i) - 1
if cmd == "1":
if S[i] == j:
continue
S[i] = j
i0 = N + i
T[i0] = smap[ord(j)-c0]
while i0 > 1:
i0 = i0 >> 1
T[i0] = T[i0+i0] | T[i0-~i0]
elif cmd == "2":
i += N
j = int(j) + N
d1 = 0
while i < j:
if i & 1:
d1 |= T[i]
i += 1
if j & 1:
j -= 1
d1 |= T[j]
i >>= 1; j >>=1
ans.append(bin(d1).count('1'))
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| p02763 |
import sys
input = sys.stdin.readline
class Bit:
def __init__(self, n):
self.n = n
self.tree = [0]*(n+1)
self.el = [0]*(n+1)
self.depth = n.bit_length() - 1
def sum(self, i):
""" 区間[0,i) の総和を求める """
s = 0
i -= 1
while i >= 0:
s += self.tree[i]
i = (i & (i + 1) )- 1
return s
def add(self, i, x):
""" i 番目の要素に x を足す """
self.el[i] += x
while i < self.n:
self.tree[i] += x
i |= i + 1
def get(self, i, j=None):
""" 部分区間和 [i, j) """
if j is None:
return self.el[i]
if i == 0:
return self.sum(j)
return self.sum(j) - self.sum(i)
def lower_bound(self, x, equal=False):
""" (a0+a1+...+ai < x となる最大の i, その時の a0+a1+...+ai )
a0+a1+...+ai <= x としたい場合は equal = True
二分探索であるため、ai>=0 を満たす必要がある"""
sum_ = 0
pos = -1 # 1-indexed の時は pos = 0
if not equal:
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k < self.n and sum_ + self.tree[k] < x: # 1-indexed の時は k <= self.n
sum_ += self.tree[k]
pos += 1 << i
if equal:
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k < self.n and sum_ + self.tree[k] <= x: # 1-indexed の時は k <= self.n
sum_ += self.tree[k]
pos += 1 << i
return pos, sum_
def __getitem__(self, s):
""" [a0, a1, a2, ...] """
return self.el[s]
def __iter__(self):
""" [a0, a1, a2, ...] """
for s in self.el[:self.n]:
yield s
def __str__(self):
text1 = " ".join(["element: "] + list(map(str, self)))
text2 = " ".join(["cumsum(1-indexed): "] + list(str(self.sum(i)) for i in range(1, self.n + 1)))
return "\n".join((text1, text2))
####################################################################################################
import string
N = int(eval(input()))
S = input().strip()
Q = int(eval(input()))
B = [Bit(N) for _ in range(26)]
abc = string.ascii_lowercase # [a-z] をロード
abc2 = dict()
for i, s in enumerate(abc):
abc2[s] = i
for i, s in enumerate(S):
B[abc2[s]].add(i,1)
for _ in range(Q):
q = list(input().split())
if q[0] == "1":
a = int(q[1]) - 1
b = q[2]
for i in range(26):
if B[i].el[a] == 1:
B[i].add(a,-1)
B[abc2[b]].add(a,1)
if q[0] == "2":
a = int(q[1]) - 1
b = int(q[2]) - 1
res = 0
for i in range(26):
res += (B[i].get(a, b+1) > 0)
print(res)
| # https://atcoder.jp/contests/abc157/tasks/abc157_e
import sys
input = sys.stdin.readline
class SegmentTree:
def __init__(self, n, op, e):
"""
:param n: 要素数
:param op: 二項演算
:param e: 単位減
例) 区間最小値 SegmentTree(n, lambda a, b : a if a < b else b, 10 ** 18)
区間和 SegmentTree(n, lambda a, b : a + b, 0)
"""
self.n = n
self.op = op
self.e = e
self.size = 1 << (self.n - 1).bit_length() # st[self.size + i] = array[i]
self.tree = [self.e] * (self.size << 1)
def built(self, array):
"""arrayを初期値とするセグメント木を構築"""
for i in range(self.n):
self.tree[self.size + i] = array[i]
for i in range(self.size - 1, 0, -1):
self.tree[i] = self.op(self.tree[i << 1], self.tree[(i << 1) + 1])
def update(self, i, x):
"""i 番目の要素を x に更新"""
i += self.size
self.tree[i] = x
while i > 1:
i >>= 1
self.tree[i] = self.op(self.tree[i << 1], self.tree[(i << 1) + 1])
def get_val(self, l, r):
"""[l, r)の畳み込みの結果を返す"""
l, r = l + self.size, r + self.size
res = self.e
while l < r:
if l & 1:
res = self.op(self.tree[l], res)
l += 1
if r & 1:
r -= 1
res = self.op(self.tree[r], res)
l, r = l >> 1, r >> 1
return res
##################################################################################################################
def popcount(x):
return bin(x).count("1")
N = int(eval(input()))
st = SegmentTree(N, lambda a, b: a | b, 0)
S = input().strip()
data = []
for s in S:
data.append(1 << (ord(s) - ord("a")))
st.built(data)
Q = int(eval(input()))
for _ in range(Q):
q, a, b = input().split()
if q == "1":
st.update(int(a)-1, 1 << (ord(b) - ord("a")))
if q == "2":
a = int(a) - 1
b = int(b)
print((popcount(st.get_val(a, b)))) | p02763 |
import sys
readline = sys.stdin.buffer.readline
kijun = ord("a")
n = int(readline())
s = readline().rstrip().decode('utf-8')
q = int(readline())
lst1 = [0]*n
def pow(n,p): #繰り返し二乗法(nのp乗)
res = 1
while p > 0:
if p % 2 == 0:
n = n ** 2
p //= 2
else:
res = res * n
p -= 1
return res
for i in range(n):
lst1[i] = pow(2,(ord(s[i])-kijun))
#####segfunc######
def segfunc(x,y):
return x|y
def init(init_val): #渡されたリストでsegを初期化
#set_val
for i in range(n):
seg[i+num-1]=init_val[i]
#built
for i in range(num-2,-1,-1) :
seg[i]=segfunc(seg[2*i+1],seg[2*i+2])
def update(k,x): #segの要素kをxに変更(セグ木全体の更新)
k += num-1
seg[k] = x
while k:
k = (k-1)//2
seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
def query(p,q): #区間[p,q)での、segfuncに準じた値を返す
if q<=p:
return ide_ele
p += num-1
q += num-2
res=ide_ele
while q-p>1:
if p&1 == 0:
res = segfunc(res,seg[p])
if q&1 == 1:
res = segfunc(res,seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = segfunc(res,seg[p])
else:
res = segfunc(segfunc(res,seg[p]),seg[q])
return res
#####単位元######
"""
最小値のセグ木 → 10**9 (最小値の更新に影響しないため)
和のセグ木 → 0 (上の単位元の説明を参照)
積のセグ木 → 1 (上の単位元の説明を参照)
gcdのセグ木 → 0 (gcdを更新しない値は0)
"""
ide_ele = 0
#num:n以上の最小の2のべき乗
num =2**(n-1).bit_length()
seg=[ide_ele]*2*num #単位元の配列(計算結果に影響を及ぼさない配列)を作成
init(lst1)
def judge(u):
res = 0
for i in range(27):
if u>>i & 1:
res += 1
return res
for i in range(q):
t,x,y = readline().rstrip().decode('utf-8').split()
if t == "1":
update(int(x)-1,pow(2,ord(y)-kijun))
else:
print((judge(query(int(x)-1,int(y)))))
| #ABC157-E Simple String Queries
"""
英小文字26字が含まれるか否かを、2**26のint型で管理するセグ木。
これをbitwise-segment treeと言うらしい。
解法：
葉はその英小文字のbitで管理する。
segfuncにはx|yを登録することで、区間クエリをとった時に
2進数表記で1が出てくる回数が答えになる。
"""
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
#input
n = int(readline())
s = readline().rstrip().decode('utf-8')
lst1 = [0]*n
kijun = ord("a")
for i in range(n):
res = ord(s[i])-kijun
lst1[i] = 1<<res #A:1,B:10,C:100,D:1000
#####segfunc######
def segfunc(x,y):
return x|y
def init(init_val): #渡されたリストでsegを初期化
#set_val
for i in range(len(init_val)):
seg[i+num-1]=init_val[i]
#built
for i in range(num-2,-1,-1) :
seg[i]=segfunc(seg[2*i+1],seg[2*i+2])
def update(k,x): #segの要素kをxに変更(セグ木全体の更新)
k += num-1
seg[k] = x
while k:
k = (k-1)//2
seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
def query(p,q): #区間[p,q)での、segfuncに準じた値を返す
if q<=p:
return ide_ele
p += num-1
q += num-2
res=ide_ele
while q-p>1:
if p&1 == 0:
res = segfunc(res,seg[p])
if q&1 == 1:
res = segfunc(res,seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = segfunc(res,seg[p])
else:
res = segfunc(segfunc(res,seg[p]),seg[q])
return res
#####単位元######
"""
最小値のセグ木 → 10**9 (最小値の更新に影響しないため)
和のセグ木 → 0 (上の単位元の説明を参照)
積のセグ木 → 1 (上の単位元の説明を参照)
gcdのセグ木 → 0 (gcdを更新しない値は0)
"""
ide_ele = 0
#num:n以上の最小の2のべき乗
num =2**(n-1).bit_length()
seg=[ide_ele]*2*num #単位元の配列(計算結果に影響を及ぼさない配列)を作成
init(lst1)
#query
q = int(readline())
for i in range(q):
kind,a,b = readline().rstrip().decode('utf-8').split()
if kind == "1": #a文字目をbに変更
res = ord(b)-kijun
update(int(a)-1,1<<res)
else: #[a,b]の区間に含まれる文字の種類を出力
ans = 0
a,b = int(a)-1,int(b)-1
res = query(a,b+1)
for i in range(26):
if res >> i &1:
ans += 1
print(ans) | p02763 |
from functools import reduce
import sys
input = sys.stdin.readline
class SegmentTrees:
def __init__(self, target, no_effect):
size = len(target)
length = 1
while length < size:
length *= 2
self.tree_size = length * 2 - 1
self.tree = [no_effect] * self.tree_size
self.areas = [[0, 0] for _ in range(self.tree_size)]
self.set_areas()
self.initialize_tree_by_target(target, no_effect)
self.target = target
def set_areas(self):
def decide_children_areas(node):
left, right = self.areas[node]
center = (left+right)//2
child1 = node * 2 + 1
child2 = node * 2 + 2
self.areas[child1] = [left, center]
self.areas[child2] = [center+1, right]
self.areas[0] = [0, self.tree_size//2]
for parent in range(self.tree_size//2):
decide_children_areas(parent)
@classmethod
def initialize_func(cls, value):
return {value}
@classmethod
def merge_func(cls, a, b):
return a | b
def merge_child_data(self, node):
child1 = node * 2 + 1
child2 = node * 2 + 2
merged = self.merge_func(self.tree[child1], self.tree[child2])
return merged
def initialize_tree_by_target(self, target: list, no_effect=0):
def calc_leafs():
initial_leaf = self.tree_size//2
leafs = list(range(initial_leaf, initial_leaf+len(target)))
for value, leaf in zip(target, leafs):
self.tree[leaf] = self.initialize_func(value)
residue = list(range(initial_leaf+len(target), self.tree_size))
for residual_leaf in residue:
self.tree[residual_leaf] = no_effect
calc_leafs()
for parent in range(self.tree_size//2-1, -1, -1):
self.tree[parent] = self.merge_child_data(parent)
def update(self, new_data, position):
leaf = self.tree_size//2 + position
new = self.initialize_func(new_data)
if self.tree[leaf] == new:
return
self.tree[leaf] = new
parent = (leaf-1) // 2
while parent >= 0:
new = self.merge_child_data(parent)
if self.tree[parent] == new:
break
self.tree[parent] = new
parent = (parent-1) // 2
def get_query(self, _from, to):
def get_tree_data(node):
left, right = self.areas[node]
if _from <= left and right <= to:
result.append(self.tree[node])
return
if to < left or right < _from:
return
child1 = node * 2 + 1
child2 = node * 2 + 2
get_tree_data(child1)
get_tree_data(child2)
result = []
get_tree_data(0)
ans = reduce(self.merge_func, result)
ans = len(ans)
return ans
n = int(eval(input()))
S = input().replace('\n', '')
seg_tree = SegmentTrees(target=S, no_effect=set())
Q = int(eval(input()))
for _ in range(Q):
query = input().split()
if query[0] == '1':
position, new = int(query[1])-1, query[2]
seg_tree.update(new, position)
elif query[0] == '2':
_from, to = int(query[1])-1, int(query[2])-1
print((seg_tree.get_query(_from, to)))
| import sys
input = sys.stdin.readline
class SegmentTrees:
def __init__(self, target, no_effect):
target_size = len(target)
leaves_size = 1
while leaves_size < target_size:
leaves_size *= 2
self.tree_size = leaves_size * 2 - 1
self.tree = [no_effect] * self.tree_size
self.no_effect = no_effect
self.initialize_tree(target, no_effect)
@classmethod
def initialize_func(cls, value):
return 1 << (ord(value) - ord('a'))
@classmethod
def merge_func(cls, a, b):
return a | b
def merge_child_data(self, node):
child1 = node * 2 + 1
child2 = node * 2 + 2
merged = self.merge_func(self.tree[child1], self.tree[child2])
return merged
def initialize_tree(self, target: list, no_effect=0):
initial_leaf = self.tree_size // 2
leaves = list(range(initial_leaf, initial_leaf+len(target)))
for value, leaf in zip(target, leaves):
self.tree[leaf] = self.initialize_func(value)
for parent in range(initial_leaf-1, -1, -1):
self.tree[parent] = self.merge_child_data(parent)
def update(self, new_value, index):
leaf = self.tree_size//2 + index
new_data = self.initialize_func(new_value)
if self.tree[leaf] == new_data:
return
self.tree[leaf] = new_data
parent = (leaf-1) // 2
while parent >= 0:
new_data = self.merge_child_data(parent)
if self.tree[parent] == new_data:
break
self.tree[parent] = new_data
parent = (parent-1) // 2
def resolve_query(self, _from, to):
def is_in_query(left, right):
if _from <= left and right <= to:
return 1
elif to < left or right < _from:
return 0
else:
return -1
node = 0
left, right = 0, self.tree_size//2
todo = [[node, left, right]]
result = self.no_effect
while todo:
node, left, right = todo.pop()
if is_in_query(left, right) == 1:
data = self.tree[node]
result = self.merge_func(result, data)
elif is_in_query(left, right) == 0:
continue
else:
child1 = node * 2 + 1
child2 = node * 2 + 2
center = (left+right)//2
todo.append([child1, left, center])
todo.append([child2, center+1, right])
return bin(result).count('1')
n = int(eval(input()))
S = input().replace('\n', '')
seg_tree = SegmentTrees(target=S, no_effect=0)
Q = int(eval(input()))
for _ in range(Q):
query = input().split()
if query[0] == '1':
index, new = int(query[1])-1, query[2]
seg_tree.update(new, index)
elif query[0] == '2':
_from, to = int(query[1])-1, int(query[2])-1
print((seg_tree.resolve_query(_from, to)))
| p02763 |
import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
from bisect import bisect_left
from itertools import product
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
#文字列を一文字ずつ数字に変換、'5678'を[5,6,7,8]とできる
def LSI(): return list(map(int, list(sys.stdin.readline().rstrip())))
def LSI2(N): return [list(map(int, list(sys.stdin.readline().rstrip()))) for i in range(N)]
#文字列として取得
def ST(): return sys.stdin.readline().rstrip()
def LST(): return sys.stdin.readline().split()
def LST2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**6+10)
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
self.height = 0 #ノードの高さ
class AVL:
def __init__(self):
self.root = None
def get_height(self, node):
if not node:
return -1
return node.height
def overwrite_height(self, node):
return max(self.get_height(node.left),self.get_height(node.right))+1
def get_balance(self, node):
'''
返り値が1以上の時、左がより高いので右回転
-1以下の時左回転
'''
if not node:
return 0
return self.get_height(node.left) - self.get_height(node.right)
def rotate_right(self, node): #nodeが回転の頂点、node.leftが頂点にくる。頂点を返す
temp_left = node.left
temp_left_right = temp_left.right
temp_left.right = node
node.left = temp_left_right
node.height = self.overwrite_height(node)
temp_left.height = self.overwrite_height(temp_left)
return temp_left
def rotate_left(self, node): #nodeが回転の頂点、node.leftが頂点にくる
temp_right = node.right
temp_right_left = temp_right.left
temp_right.left = node
node.right = temp_right_left
node.height = self.overwrite_height(node)
temp_right.height = self.overwrite_height(temp_right)
return temp_right
def insert(self, data):
#print('--------------')
#print('start inserting {}'.format(data))
self.root = self._insert(data, self.root)
#print('finish inserting')
#print('--------------')
def _insert(self, data, node): #dataをnodeに挿入、回転した上でrootを返す
if not node:
return Node(data)
if data < node.data:
node.left = self._insert(data,node.left)
else:
node.right = self._insert(data, node.right)
node.height = self.overwrite_height(node)
return self.settle_unbalance(data, node)
def settle_unbalance(self, data, node): #回転を行なった上でrootを返す
balance = self.get_balance(node)
if balance > 1 and data < node.left.data:
#print('right')
return self.rotate_right(node)
if balance < -1 and data > node.right.data:
#print('left')
return self.rotate_left(node)
if balance > 1 and data > node.left.data:
#print('left,right')
node.left = self.rotate_left(node.left)
return self.rotate_right(node)
if balance < -1 and data < node.right.data:
#print('right,left')
node.right = self.rotate_right(node.right)
return self.rotate_left(node)
return node
def remove(self, data):
if self.root:
self.root = self._remove(data, self.root)
def _remove(self, data, node):
if not node:
return None
if data < node.data:
node.left = self._remove(data, node.left)
elif data > node.data:
node.right = self._remove(data, node.right)
else:
if not node.right and not node.left:
del node
return None
if not node.right:
temp = node.left
del node
return temp
if not node.left:
temp = node.right
del node
return temp
def _get_max_node(node): #左側のsubtreeの最大ノードを代わりのノードとする
if node.right:
return _get_max_node(node.right)
return node
temp = _get_max_node(node.left)
node.data = temp.data
node.left = self._remove(temp.data, node.left) #この場合もとのノード削除は不要。削除ノードを、新規ノードにおきかえればよい
if not node:
return node
node.height = self.overwrite_height(node)
balance = self.get_balance(node)
if balance > 1 and self.get_balance(node.left) >= 0:
return self.rotate_right(node)
if balance < -1 and self.get_balance(node.right) <= 0:
return self.rotate_left(node)
if balance > 1 and self.get_balance(node.left) < 0:
node.left = self.rotate_left(node.left)
return self.rotate_right(node)
if balance < -1 and self.get_balance(node.right) > 0:
node.right = self.rotate_right(node.right)
return self.rotate_left(node)
return node
def search(self, search): #インターフェース
searcher = self._search(search)
if searcher is None:
pass
#print('Search target is not found.')
elif searcher == True:
pass
#print(str(search)+' is found.')
elif searcher == False:
pass
#print(str(search)+' is not found.')
def _search(self,search):
n = self.root
if n is None:
return None
else:
lst = []
lst.append(n)
while len(lst) > 0:
node = lst.pop()
if node.data == search:
return True
if node.right is not None:
lst.append(node.right)
if node.left is not None:
lst.append(node.left)
return False
def search_higher(self, search):
if self.root:
return self._search_higher(search, self.root, None)
#else:
# print('木構造がありません')
def _search_higher(self, search, node, temp_high):
'''
nodeを頂点とする部分木から、searchより大きい中でもっとも小さいnodeのデータを返す
'''
if node is None:
return temp_high
if node.data > search:
temp_high = node.data
if node.left is None:
return temp_high
else:
return self._search_higher(search, node.left, temp_high)
elif node.data < search:
if node.right is None:
return temp_high
else:
return self._search_higher(search, node.right, temp_high)
else: #nodeの値が探索値と一致する時
if node.right is None:
return temp_high
else:
if temp_high is None:
return self.end_lower(node.right)
else:
return min(temp_high, self.end_lower(node.right))
def end_lower(self, node):
#あるnodeの下の部分木のうち最小値 nodeにdataあることが前提
if node.left is None:
return node.data
else:
return self.end_lower(node.left)
def traverse_inorder(self):
if self.root:
self._traverse_inorder(self.root)
# 改行対策
print()
else:
print('木は空です。')
def _traverse_inorder(self, node):
if node.left:
self._traverse_inorder(node.left)
sepp = '|'*node.height
print_str = sepp+str(node.data)+sepp
print(print_str, end = '')
if node.right:
self._traverse_inorder(node.right)
N = I()
S = ST()
Q = I()
D = {}
for i in range(N):
letter = S[i]
D[letter] = D.get(letter,AVL())
D[letter].insert(i)
for _ in range(Q):
q = LST()
if q[0]=='1':
i = int(q[1])
c = q[2]
for letter in D:
D[letter].remove(i-1)
D[c] = D.get(c,AVL())
D[c].insert(i-1)
else:
ans = 0
l = int(q[1])
r = int(q[2])
for letter in D:
next_idx = D[letter].search_higher(l-2)
if next_idx is not None:
if r-1 >= next_idx:
ans += 1
print(ans)
| import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
from bisect import bisect_left
from itertools import product
def I(): return int(sys.stdin.readline())
def MI(): return list(map(int, sys.stdin.readline().split()))
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
#文字列を一文字ずつ数字に変換、'5678'を[5,6,7,8]とできる
def LSI(): return list(map(int, list(sys.stdin.readline().rstrip())))
def LSI2(N): return [list(map(int, list(sys.stdin.readline().rstrip()))) for i in range(N)]
#文字列として取得
def ST(): return sys.stdin.readline().rstrip()
def LST(): return sys.stdin.readline().rstrip().split()
def LST2(N): return [sys.stdin.readline().rstrip().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**6+10)
N = I()
S = list(ST())
Q = I()
bits=[[0]*(N+1) for _ in range(26)]
def ctoi(c): #アルファベットを0-25の数字に変換
return ord(c)-97
def query(pos): #各文字について1-pos番目までの文字数をカウント
ret = [0]*26
for i in range(26):
tmp = 0
p = pos
while p>0:
tmp += bits[i][p]
bit_len = p&(-p) #p&(-p)は1のたつ最小桁であり、今の区間の長さをあらわす
p -= bit_len #つぎに足すべき塊の番号は、今の値から区間の長さを引くとでる
ret[i] = tmp #アルファベットiの1-posまでの出現回数
return ret
def update(pos, a, x): #a番目のアルファベットについてpos番目の要素の値を更新
while pos <= N:
bits[a][pos] += x
pos += pos&(-pos)
for i in range(N):
update(i+1, ctoi(S[i]),1)
for _ in range(Q):
q = LST()
if q[0]=='1':
i = int(q[1])
c = q[2]
if S[i-1]==c:
continue
update(i, ctoi(S[i-1]), -1) #S[i-1]のi番目に1が立っているが、これを下ろして削除を表現
#O(logN)で削除が完了
update(i, ctoi(c), 1)
S[i-1] = c
else:
ans = 0
l = int(q[1])
r = int(q[2])
r_sum = query(r)
l_sum = query(l-1)
for i in range(26):
if r_sum[i]-l_sum[i] > 0:
ans += 1
print(ans)
| p02763 |
from collections import deque
class SegmentTree():
def __init__(self,n,ide_ele,merge_func,init_val):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def update(self,id,x):
self.val[id]=x
pos=id+1
while pos!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos+gap-1],self.merge[pos-gap-1])
pos=self.parent[pos]
def cnt(self,k):
lsb=(k)&(-k)
return (lsb<<1)-1
def lower_kth_merge(self,nd,k):
res=self.ide_ele
id=nd
if k==-1:
return res
while True:
if not id%2:
gap=((id)&(-id))//2
l=id-gap
r=id+gap
cnt=self.cnt(l)
if cnt<k:
k-=cnt+1
res=self.merge_func(res,self.val[id-1],self.merge[l-1])
id=r
elif cnt==k:
res=self.merge_func(res,self.val[id-1],self.merge[l-1])
return res
else:
id=l
else:
res=self.merge_func(res,self.val[id-1])
return res
def upper_kth_merge(self,nd,k):
res=self.ide_ele
id=nd
if k==-1:
return res
while True:
if not id%2:
gap=((id)&(-id))//2
l=id-gap
r=id+gap
cnt=self.cnt(r)
if cnt<k:
k-=cnt+1
res=self.merge_func(res,self.val[id-1],self.merge[r-1])
id=l
elif cnt==k:
res=self.merge_func(res,self.val[id-1],self.merge[r-1])
return res
else:
id=r
else:
res=self.merge_func(res,self.val[id-1])
return res
def query(self,l,r):
id=1<<(self.n-1)
while True:
if id-1<l:
id+=((id)&(-id))//2
elif id-1>r:
id-=((id)&(-id))//2
else:
res=self.val[id-1]
if id%2:
return res
gap=((id)&(-id))//2
L,R=id-gap,id+gap
#print(l,r,id,L,R)
left=self.upper_kth_merge(L,id-1-l-1)
right=self.lower_kth_merge(R,r-id)
return self.merge_func(res,left,right)
ide_ele=0
def seg_func(*args):
res=ide_ele
for val in args:
res|=val
return res
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
import sys
input=sys.stdin.readline
N=int(eval(input()))
S=input().rstrip()
init_val=[1<<(ord(S[i])-97) for i in range(N)]
test=SegmentTree(19,ide_ele,seg_func,init_val)
for _ in range(int(eval(input()))):
t,l,r=input().split()
t,l=int(t),int(l)
if t==1:
val=ord(r)-97
test.update(l-1,1<<val)
else:
r=int(r)
res=test.query(l-1,r-1)
print((popcount(res))) | class SegTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
ide_ele=0
def segfunc(x,y):
return x|y
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
import sys
input=sys.stdin.readline
N=int(eval(input()))
S=input().rstrip()
init_val=[1<<(ord(S[i])-97) for i in range(N)]
test=SegTree(init_val,segfunc,ide_ele)
for _ in range(int(eval(input()))):
t,l,r=input().split()
t,l=int(t),int(l)
if t==1:
val=ord(r)-97
test.update(l-1,1<<val)
else:
r=int(r)
res=test.query(l-1,r)
print((popcount(res)))
| p02763 |
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
import pprint
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 20
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
class BIT:
def __init__(self, size):
self.bit = [0] * size
self.size = size
self.total = 0
def add(self, i, w):
x = i + 1
self.total += w
while x <= self.size:
self.bit[x - 1] += w
x += x & -x
return
def sum(self, i):
res = 0
x = i + 1
while x:
res += self.bit[x - 1]
x -= x & -x
return res
def interval_sum(self, i, j): # i <= x < j の区間
return self.sum(j - 1) - self.sum(i - 1) if i else self.sum(j - 1)
n = I()
s = list(S())
D = defaultdict(lambda:BIT(n))
for i in range(n):
D[s[i]].add(i, 1)
q = I()
for j in range(q):
qi, i, c = LS()
if qi == '1':
i = int(i) - 1
D[s[i]].add(i, -1)
D[c].add(i, 1)
s[i] = c
else:
l, r = int(i) - 1, int(c)
ret = 0
for k in range(97, 123):
if D[chr(k)].interval_sum(l, r):
ret += 1
print(ret)
| 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
from copy import deepcopy
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 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return S().split()
def S(): return sys.stdin.readline().strip()
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)]
mod = 1000000007
class BIT:
def __init__(self, size):
self.bit = [0] * size
self.size = size
self.total = 0
def add(self, i, w):
x = i + 1
self.total += w
while x <= self.size:
self.bit[x - 1] += w
x += x & -x
return
def sum(self, i):
res = 0
x = i + 1
while x:
res += self.bit[x - 1]
x -= x & -x
return res
def interval_sum(self, i, j): # i <= x < j の区間
return self.sum(j - 1) - self.sum(i - 1) if i else self.sum(j - 1)
n = I()
s = list(S())
q = I()
D = defaultdict(lambda:BIT(n))
for j in range(n):
D[s[j]].add(j, 1)
for _ in range(q):
qi, i, c = LS()
if qi == "1":
i = int(i) - 1
D[s[i]].add(i, -1)
D[c].add(i, 1)
s[i] = c
else:
l, r = int(i) - 1, int(c)
ret = 0
for k in range(97, 123):
if D[chr(k)].interval_sum(l, r):
ret += 1
print(ret)
| p02763 |
# coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
class SegmentTree:
# 初期化処理
# f : SegmentTreeにのせるモノイド
# default : fに対する単位元
def __init__(self, size, default=0):
self.size = 2**(size-1).bit_length() # 簡単のため要素数Nを2冪にする
self.default = default
self.dat = [default]*(self.size*2) # 要素を単位元で初期化
def update(self, i, x):
i += self.size
self.dat[i] = x
while i > 0:
i >>= 1
self.dat[i] = self.dat[i*2] | self.dat[i*2+1]
def query(self, l, r):
l += self.size
r += self.size
lres, rres = self.default, self.default
while l < r:
if l & 1:
lres = lres | self.dat[l]
l += 1
if r & 1:
r -= 1
rres = self.dat[r] | rres # モノイドでは可換律は保証されていないので演算の方向に注意
l >>= 1
r >>= 1
res = lres | rres
return len(res)
N = ir()
S = sr()
seg = SegmentTree(N, default=set())
for i in range(N):
seg.update(i, set(S[i]))
Q = ir()
for _ in range(Q):
a, b, c = sr().split()
if a == '1':
seg.update(int(b)-1, set(c))
else:
print((seg.query(int(b)-1, int(c))))
# 03 | import sys
from bisect import bisect_left, bisect_right, insort
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
S = list('-' + sr())
d = [[] for _ in range(26)]
for i in range(1, N+1):
s = S[i]
o = ord(s) - ord('a')
insort(d[o], i)
Q = ir()
for _ in range(Q):
q, a, b = sr().split()
if q == '1':
a = int(a)
if S[a] == b:
continue
prev = ord(S[a]) - ord('a')
d[prev].pop(bisect_left(d[prev], a))
next = ord(b) - ord('a')
insort(d[next], a)
S[a] = b
else:
a = int(a); b = int(b)
ans = 0
for alpha in range(26):
if bisect_right(d[alpha], b) - bisect_left(d[alpha], a) >= 1:
ans += 1
print(ans)
| p02763 |
# coding: utf-8
import sys
from bisect import bisect_left, bisect_right, insort_left
from collections import defaultdict
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# 各アルファベットのindexのリストを作り,bisect_left()
N = ir()
S = list(sr())
dic = defaultdict(list)
for i, s in enumerate(S):
dic[s].append(i)
Q = ir()
for _ in range(Q):
a, b, c = sr().split()
if a == '1':
b = int(b) - 1
if S[b] == c:
continue
dic[S[b]].remove(b)
insort_left(dic[c], b)
S[b] = c
else:
b = int(b) - 1; c = int(c) - 1
kind = 0
for x in range(26):
word = chr(ord('a')+x)
if len(dic[word]) == 0:
continue
i = bisect_left(dic[word], b)
j = bisect_right(dic[word], c)
if i != j:
kind += 1
print(kind)
# 07 | import sys
from bisect import bisect_left, bisect_right, insort
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
S = list('-' + sr())
d = [[] for _ in range(26)]
for i in range(1, N+1):
s = S[i]
o = ord(s) - ord('a')
d[o].append(i)
Q = ir()
for _ in range(Q):
q, a, b = sr().split()
if q == '1':
a = int(a)
if S[a] == b:
continue
prev = ord(S[a]) - ord('a')
d[prev].remove(a)
next = ord(b) - ord('a')
insort(d[next], a)
S[a] = b
else:
a = int(a); b = int(b)
ans = 0
for alpha in range(26):
if bisect_right(d[alpha], b) - bisect_left(d[alpha], a) >= 1:
ans += 1
print(ans)
| p02763 |
import sys
input = sys.stdin.readline
N = int(eval(input()))
S = list(input().rstrip())
ord_a = ord("a")
# N: 処理する区間の長さ
INF = 2**31-1
LV = (N-1).bit_length()
N0 = 2**LV
data = [[0]*(2*N0) for _ in range(26)]
lazy = [[0]*(2*N0) for _ in range(26)]
def gindex(l, r):
L = (l + N0) >> 1; R = (r + N0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(LV):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1; R >>= 1
# 遅延伝搬処理
def propagates(k, *ids):
for i in reversed(ids):
v = lazy[k][i-1]
if not v:
continue
lazy[k][2*i-1] += v; lazy[k][2*i] += v
data[k][2*i-1] += v; data[k][2*i] += v
lazy[k][i-1] = 0
# 区間[l, r)にxを加算
def update(l, r, x, k):
*ids, = gindex(l, r)
propagates(k, *ids)
L = N0 + l; R = N0 + r
while L < R:
if R & 1:
R -= 1
lazy[k][R-1] += x; data[k][R-1] += x
if L & 1:
lazy[k][L-1] += x; data[k][L-1] += x
L += 1
L >>= 1; R >>= 1
for i in ids:
data[k][i-1] = max(data[k][2*i-1], data[k][2*i])
# 区間[l, r)内の最大値を求める
def query(l, r, k):
propagates(k, *gindex(l, r))
L = N0 + l; R = N0 + r
s = -INF
while L < R:
if R & 1:
R -= 1
s = max(s, data[k][R-1])
if L & 1:
s = max(s, data[k][L-1])
L += 1
L >>= 1; R >>= 1
return s
for j in range(N):
u = S[j]
update(j, N, 1, ord(u) - ord_a)
Q = int(eval(input()))
for _ in range(Q):
q = input().rstrip().split()
if q[0] == "2":
l, r = int(q[1]) - 1, int(q[2]) - 1
cnt = 0
for i in range(26):
if l == 0:
cnt += int(query(r, r + 1, i) > 0)
else:
cnt += int((query(r, r + 1, i) - query(l - 1, l, i) > 0))
print(cnt)
else:
i, c = int(q[1]) - 1, q[2]
update(i, N, -1, ord(S[i]) - ord_a)
S[i] = c
update(i, N, 1, ord(S[i]) - ord_a) | import sys
input = sys.stdin.readline
N = int(eval(input()))
S = list(input().rstrip())
ord_a = ord("a")
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
bits = [Bit(N) for _ in range(26)]
for i in range(N):
s = S[i]
bits[ord(s) - ord_a].add(i + 1, 1)
Q = int(eval(input()))
for _ in range(Q):
query = input().rstrip().split()
if query[0] == "1":
i, c = int(query[1]), query[2]
bits[ord(S[i - 1]) - ord_a].add(i, -1)
S[i - 1] = c
bits[ord(S[i - 1]) - ord_a].add(i, 1)
else:
l, r = int(query[1]), int(query[2])
res = 0
for bit in bits:
if l != 1:
res += int(bit.sum(r) - bit.sum(l - 1) > 0)
else:
res += int(bit.sum(r) > 0)
print(res) | p02763 |
# -*- coding: utf-8 -*-
import sys
N=eval(input())
S=["None"]+list(input())
Q=eval(input())
query=[ sys.stdin.readline().split() for _ in range(Q) ]
#BIT
bit=[ [ 0 for _ in range(N+1) ] for _ in range(27) ] #中も外も1-indexed bit[1]:aのbit, bit[2]:bのbit ...
def add(idx,a,w):
while a<=N:
bit[idx][a]+=w
a+=a&-a
def sum(idx,a):
ret=0
while 0<a:
ret+=bit[idx][a]
a-=a&-a
return ret
for i,x in enumerate(S):
if i==0: continue
add(ord(x)-96,i,1) #a~zのどのbit配列か,特定文字のbit配列の何番目,bitに代入する値
for q1,q2,q3 in query:
q1=int(q1)
q2=int(q2)
if q1==1:
before_q3=S[q2] #文字列Sの変更前の文字をbefore_q3に代入
S[q2]=q3 #文字列Sの変更部分1文字を更新
q3=ord(q3)-96 #変更後の文字をアスキーコード10進数で表現
before_q3=ord(before_q3)-96 #変更前の文字をアスキーコード10進数で表現
add(q3,q2,1) #a~zのどのbit配列か,特定文字のbit配列の何番目,bitに代入する値
add(before_q3,q2,-1) #置き代えた文字は-1しなきゃいけない
elif q1==2:
q3=int(q3)
cnt=0
for i in range(1,27):
if 0<sum(i,q3)-sum(i,q2-1):
cnt+=1
print(cnt) | # -*- coding: utf-8 -*-
import sys
N=eval(input())
S=["None"]+list(input())
Q=eval(input())
query=[ sys.stdin.readline().split() for _ in range(Q) ]
#BIT
bit=[ [ 0 for _ in range(N+1) ] for _ in range(27) ] #1-indexed bit[1]:aのbit, bit[2]:bのbit ...
def add(idx,a,w):
while a<=N:
bit[idx][a]+=w
a+=a&-a
def sum(idx,a):
ret=0
while 0<a:
ret+=bit[idx][a]
a-=a&-a
return ret
for i,x in enumerate(S):
if i==0: continue
add(ord(x)-96,i,1) #a~zのどのbit配列か,特定文字のbit配列の何番目,bitに代入する値
for q1,q2,q3 in query:
q1=int(q1)
q2=int(q2)
if q1==1:
before_q3=S[q2] #文字列Sの変更前の文字をbefore_q3に代入
S[q2]=q3 #文字列Sの変更部分1文字を更新
q3=ord(q3)-96 #変更後の文字をアスキーコード10進数で表現
before_q3=ord(before_q3)-96 #変更前の文字をアスキーコード10進数で表現
add(q3,q2,1) #a~zのどのbit配列か,特定文字のbit配列の何番目,bitに代入する値
add(before_q3,q2,-1) #置き代えた文字は-1しなきゃいけない
elif q1==2:
q3=int(q3)
cnt=0
for i in range(1,27):
if 0<sum(i,q3)-sum(i,q2-1):
cnt+=1
print(cnt) | p02763 |
# AC: 577 msec (Python3)
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def string_to_number(a):
return 1 << (ord(a) - 97)
class SegmentTree:
def __init__(self, A):
self.n = 2**(len(A)-1).bit_length()
self.identity = 0
self.seg = [self.identity] * (2 * self.n)
for i, a in enumerate(A):
self.seg[self.n-1+i] = string_to_number(a)
for i in range(self.n-2,-1,-1):
self.seg[i] = self.seg[2*i+1] | self.seg[2*i+2]
def update(self, k, a):
k += self.n - 1
self.seg[k] = string_to_number(a)
while k:
k = (k - 1) // 2
self.seg[k] = self.seg[k*2+1] | self.seg[k*2+2]
def query(self, a, b):
if b == a:
return 1
a += self.n - 1
b += self.n - 2
res = self.identity
while b - a > 1:
if not a & 1:
res |= self.seg[a]
if b & 1:
res |= self.seg[b]
b -= 2
a >>= 1
b -= 1
b >>= 1
if a == b:
res |= self.seg[a]
else:
res |= (self.seg[a] | self.seg[b])
return bin(res).count("1")
def main():
N = int(readline())
s = readline().strip()
seg = SegmentTree(list(s))
Q = int(readline())
q = list(map(str, read().split()))
ans = []
for t, a, b in zip(*[iter(q)]*3):
if t == "1":
seg.update(int(a)-1, b)
else:
ans.append(seg.query(int(a)-1, int(b)))
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def string_to_number(a):
return 1 << (ord(a) - 97)
class SegmentTree:
"""
セグ木は 1-indexed
"""
def __init__(self, n, initial=0):
self.offset = 2**(n-1).bit_length()
self.initial = initial
self.seg = [self.initial] * (2 * self.offset)
def build(self, A):
"""
A: 処理したい配列
"""
for i, a in enumerate(A, start=self.offset):
self.seg[i] = string_to_number(a)
for i in range(self.offset-1,0,-1):
self.seg[i] = self.seg[i<<1] | self.seg[(i<<1)+1]
def update(self, k, a):
k += self.offset
self.seg[k] = string_to_number(a)
while k:
k >>= 1
self.seg[k] = self.seg[k<<1] | self.seg[(k<<1)+1]
def query(self, a, b):
a += self.offset
b += self.offset
res = self.initial
while a < b:
if a & 1:
res |= self.seg[a]
a += 1
if b & 1:
res |= self.seg[b-1]
a >>= 1
b >>= 1
return bin(res).count("1")
def main():
N,s,Q,*q = read().split()
seg = SegmentTree(int(N))
seg.build(s)
#print(seg.seg)
for t, a, b in zip(*[iter(q)]*3):
if t == "1":
seg.update(int(a)-1, b)
else:
print((seg.query(int(a)-1, int(b))))
if __name__ == "__main__":
main()
| p02763 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
s = list(str(input().rstrip()))
q = int(eval(input()))
class SSQ:
def __init__(self, n, e):
# 単位元
self.e = e
# num_min:n以上の最小の2のべき乗
self.num_min = 2**(n-1).bit_length()
self.seg_min = [self.e]*2*self.num_min
def update(self, k, x):
k += self.num_min-1
self.seg_min[k] = x
while k:
k = (k-1)//2
self.seg_min[k] = self.seg_min[k*2+1] or self.seg_min[k*2+2]
def query(self, p, q):
q += 1
if q <= p:
return self.e
p += self.num_min-1
q += self.num_min-2
res = self.e
while q-p > 1:
if p & 1 == 0:
res = res or self.seg_min[p]
if q & 1 == 1:
res = res or self.seg_min[q]
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = res or self.seg_min[p]
else:
res = res or self.seg_min[p] or self.seg_min[q]
return res
ssqs = [SSQ(n, False) for i in range(26)]
for i in range(n):
ssqs[ord(s[i]) - ord('a')].update(i, True)
out = []
for i in range(q):
com, x, y = list(input().split())
if com == '1':
idx = int(x) - 1
pre_alph = ord(s[idx]) - ord('a')
ssqs[pre_alph].update(idx, False)
s[idx] = y
alph = ord(y) - ord('a')
ssqs[alph].update(idx, True)
else:
x, y = int(x) - 1, int(y) - 1
cnt = 0
for i in range(26):
cnt += 1 if ssqs[i].query(x, y) else 0
out.append(str(cnt))
print(("\n".join(out)))
| n = int(eval(input()))
s = list(str(input().rstrip()))
q = int(eval(input()))
class SSQ:
def __init__(self, n, e):
# 単位元
self.e = e
# num_min:n以上の最小の2のべき乗
self.num_min = 2**(n-1).bit_length()
self.seg_min = [self.e]*2*self.num_min
def update(self, k, x):
k += self.num_min-1
self.seg_min[k] = x
while k:
k = (k-1)//2
self.seg_min[k] = self.seg_min[k*2+1] or self.seg_min[k*2+2]
def query(self, p, q):
q += 1
if q <= p:
return self.e
p += self.num_min-1
q += self.num_min-2
res = self.e
while q-p > 1:
if p & 1 == 0:
res = res or self.seg_min[p]
if q & 1 == 1:
res = res or self.seg_min[q]
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = res or self.seg_min[p]
else:
res = res or self.seg_min[p] or self.seg_min[q]
return res
ssqs = [SSQ(n, False) for i in range(26)]
for i in range(n):
ssqs[ord(s[i]) - ord('a')].update(i, True)
out = []
for i in range(q):
com, x, y = list(input().split())
if com == '1':
idx = int(x) - 1
pre_alph = ord(s[idx]) - ord('a')
ssqs[pre_alph].update(idx, False)
s[idx] = y
alph = ord(y) - ord('a')
ssqs[alph].update(idx, True)
else:
x, y = int(x) - 1, int(y) - 1
cnt = 0
for i in range(26):
cnt += 1 if ssqs[i].query(x, y) else 0
out.append(str(cnt))
print(("\n".join(out)))
| p02763 |
from collections import Counter
def main():
n = int(input().strip())
s = list(input().strip())
bit = [Counter() for _ in range(n + 1)]
def query(i):
result = Counter()
while i:
result += bit[i]
i -= i & -i
return result
def update(i, cnt):
while i < len(bit):
bit[i] += cnt
i += i & -i
for i, c in enumerate(s, 1):
update(i, Counter({c: 1}))
q = int(input().strip())
for _ in range(q):
Q = input().strip().split()
if Q[0] == "1":
i, c = int(Q[1]), Q[2]
if s[i - 1] != c:
update(i, Counter({s[i - 1]: -1, c: 1}))
s[i - 1] = c
else:
cnt = query(int(Q[2])) - query(int(Q[1]) - 1)
print((len(cnt)))
main()
| def main():
n = int(input().strip())
s = list(input().strip())
bit = [[0] * 26 for _ in range(n + 1)]
def query(i):
result = [0] * 26
while i:
for j, x in enumerate(bit[i]):
result[j] += x
i -= i & -i
return result
def update(i, c, val):
j = ord(c) - ord("a")
while i < len(bit):
bit[i][j] += val
i += i & -i
for i, c in enumerate(s, 1):
update(i, c, 1)
q = int(input().strip())
for _ in range(q):
Q = input().strip().split()
if Q[0] == "1":
i, c = int(Q[1]), Q[2]
update(i, s[i - 1], -1)
update(i, c, 1)
s[i - 1] = c
else:
l, r = int(Q[1]), int(Q[2])
cnt = [x - y for x, y in zip(query(r), query(l - 1))]
print((sum(x > 0 for x in cnt)))
main()
| p02763 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
R = 2**(N.bit_length())
st = [0] * (R*2)
def update(i,s):
x = 2 ** (ord(s) - ord('a'))
i += R-1
st[i] = x
while i > 0:
i = (i-1) // 2
st[i] = st[i*2+1] | st[i*2+2]
def query(a,b,n,l,r):
ret = 0
if a <= l and r <= b: return st[n]
if a < r and b > l:
vl = query(a,b,n*2+1,l,(l+r)//2)
vr = query(a,b,n*2+2,(l+r)//2,r)
ret = vl | vr
return ret
for i,s in enumerate(sys.stdin.readline().rstrip()):
update(i+1,s)
Q = NI()
for _ in range(Q):
c,a,b = sys.stdin.readline().split()
if c == '1':
update(int(a),b)
else:
ret = query(int(a),int(b)+1,0,0,R)
cnt = 0
b = 1
for i in range(26):
cnt += (b & ret) > 0
b <<= 1
print(cnt)
if __name__ == '__main__':
main() | import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
R = 2**(N.bit_length())
st = [0] * (R*2)
def update(i,s):
x = 2 ** (ord(s) - ord('a'))
i += R-1
st[i] = x
while i > 0:
i = (i-1) // 2
st[i] = st[i*2+1] | st[i*2+2]
def query(l,r):
l += R-1
r += R-2
ret = 0
while l+1 < r:
if l % 2 == 0:
ret |= st[l]
if r % 2 == 1:
ret |= st[r]
r -= 1
l = l // 2
r = (r-1) // 2
if l == r:
ret |= st[l]
else:
ret |= st[l] | st[r]
return ret
for i,s in enumerate(sys.stdin.readline().rstrip()):
update(i+1,s)
Q = NI()
for _ in range(Q):
c,a,b = sys.stdin.readline().split()
if c == '1':
update(int(a),b)
else:
ret = query(int(a),int(b)+1)
cnt = 0
b = 1
for i in range(26):
cnt += (b & ret) > 0
b <<= 1
print(cnt)
if __name__ == '__main__':
main() | p02763 |
import sys
input = sys.stdin.readline
n = int(input().rstrip('\n'))
s = input().rstrip('\n')
l = [c for c in s]
q = int(input().rstrip('\n'))
Q = [input().rstrip('\n').split() for _ in range(q)]
class SegTree():
def __init__(self, n_):
self.n = 1
while self.n < n_:
self.n *= 2
self.tree = [2 for _ in range(2 * self.n - 1)]
def update(self, k, a):
k += self.n - 1
self.tree[k] = a
while k > 0:
k = (k - 1) // 2
self.tree[k] = min(self.tree[k * 2 + 1], self.tree[k * 2 + 2])
def query(self, l, r):
l += self.n - 1
r += self.n - 2
res = 2
while r-l>1:
if l&1 == 0:
res = min(res,self.tree[l])
if r&1 == 1:
res = min(res,self.tree[r])
r -= 1
l = l//2
r = (r-1)//2
if l == r:
res = min(res,self.tree[l])
else:
res = min(min(res,self.tree[l]),self.tree[r])
return res
d = { c: SegTree(n) for c in "abcdefghijklmnopqrstuvwxyz"}
for i, c in enumerate(s):
d[c].update(i, 1)
for a, b, c in Q:
if a == "1":
b = int(b) - 1
d[l[b]].update(b, 2)
d[c].update(b, 1)
l[b] = c
else:
res = 0
b, c = int(b), int(c)
for key in d:
if d[key].query(b-1, c) == 1:
res += 1
print(res)
| import sys
input = sys.stdin.readline
n = int(input().rstrip('\n'))
s = input().rstrip('\n')
q = int(input().rstrip('\n'))
Q = []
for _ in range(q):
Q.append(input().rstrip().split())
class SegTree():
def __init__(self, n_):
self.n = 1
while self.n < n_:
self.n *= 2
self.tree = []
for _ in range(2 * self.n - 1):
self.tree.append(2)
def update(self, k, a):
k += self.n - 1
self.tree[k] = a
while k > 0:
k = (k - 1) // 2
self.tree[k] = min(self.tree[k * 2 + 1], self.tree[k * 2 + 2])
def query(self, l, r):
l += self.n - 1
r += self.n - 2
res = 2
while r-l>1:
if l&1 == 0:
res = min(res,self.tree[l])
if r&1 == 1:
res = min(res,self.tree[r])
r -= 1
l = l//2
r = (r-1)//2
if l == r:
res = min(res,self.tree[l])
else:
res = min(min(res,self.tree[l]),self.tree[r])
return res
d = { c: SegTree(n) for c in "abcdefghijklmnopqrstuvwxyz"}
l = []
for i, c in enumerate(s):
d[c].update(i, 1)
l.append(c)
for a, b, c in Q:
if a == "1":
b = int(b) - 1
d[l[b]].update(b, 2)
d[c].update(b, 1)
l[b] = c
else:
res = 0
b, c = int(b), int(c)
for key in d:
if d[key].query(b-1, c) == 1:
res += 1
print(res)
| p02763 |
import sys
input = sys.stdin.readline
n = int(input().rstrip('\n'))
s = input().rstrip('\n')
q = int(input().rstrip('\n'))
Q = []
for _ in range(q):
Q.append(input().rstrip().split())
class SegTree():
def __init__(self, n_):
self.n = 1
while self.n < n_:
self.n *= 2
self.tree = []
for _ in range(2 * self.n - 1):
self.tree.append(2)
def update(self, k, a):
k += self.n - 1
self.tree[k] = a
while k > 0:
k = (k - 1) // 2
self.tree[k] = min(self.tree[k * 2 + 1], self.tree[k * 2 + 2])
def query(self, l, r):
l += self.n - 1
r += self.n - 2
res = 2
while r-l>1:
if l&1 == 0:
res = min(res,self.tree[l])
if r&1 == 1:
res = min(res,self.tree[r])
r -= 1
l = l//2
r = (r-1)//2
if l == r:
res = min(res,self.tree[l])
else:
res = min(min(res,self.tree[l]),self.tree[r])
return res
d = { c: SegTree(n) for c in "abcdefghijklmnopqrstuvwxyz"}
l = []
for i, c in enumerate(s):
d[c].update(i, 1)
l.append(c)
for a, b, c in Q:
if a == "1":
b = int(b) - 1
d[l[b]].update(b, 2)
d[c].update(b, 1)
l[b] = c
else:
res = 0
b, c = int(b), int(c)
for key in d:
if d[key].query(b-1, c) == 1:
res += 1
print(res)
| def main():
import sys
input = sys.stdin.readline
n = int(input().rstrip('\n'))
s = input().rstrip('\n')
q = int(input().rstrip('\n'))
Q = []
for _ in range(q):
Q.append(input().rstrip().split())
class SegTree():
def __init__(self, n_):
self.n = 1
while self.n < n_:
self.n *= 2
self.tree = []
for _ in range(2 * self.n - 1):
self.tree.append(2)
def update(self, k, a):
k += self.n - 1
self.tree[k] = a
while k > 0:
k = (k - 1) // 2
self.tree[k] = min(self.tree[k * 2 + 1], self.tree[k * 2 + 2])
def query(self, l, r):
l += self.n - 1
r += self.n - 2
res = 2
while r-l>1:
if l&1 == 0:
res = min(res,self.tree[l])
if r&1 == 1:
res = min(res,self.tree[r])
r -= 1
l = l//2
r = (r-1)//2
if l == r:
res = min(res,self.tree[l])
else:
res = min(min(res,self.tree[l]),self.tree[r])
return res
d = { c: SegTree(n) for c in "abcdefghijklmnopqrstuvwxyz"}
l = []
for i, c in enumerate(s):
d[c].update(i, 1)
l.append(c)
for a, b, c in Q:
if a == "1":
b = int(b) - 1
d[l[b]].update(b, 2)
d[c].update(b, 1)
l[b] = c
else:
res = 0
b, c = int(b), int(c)
for key in d:
if d[key].query(b-1, c) == 1:
res += 1
print(res)
if __name__ == '__main__':
main()
| p02763 |
import sys
input=sys.stdin.buffer.readline
n=int(eval(input()))+1
data=[0]*n*2
def update(i,x):
i+=n
data[i]=x
i//=2
while i:
data[i]=data[i*2]|data[i*2+1]
i//=2
def query(l,r):
l+=n
r+=n
s=0
while l<r:
if l&1:
s|=data[l]
l+=1
if r&1:
r-=1
s|=data[r]
l//=2
r//=2
return sum(map(int,bin(s)[2:]))
for i,c in enumerate(input()[:-1],n):data[i]=2**(c-97)
for i in range(n-1,0,-1):data[i]=data[i*2]|data[i-~i]
for _ in range(int(eval(input()))):
q,a,b=input().split()
if q[0]>49:print((query(int(a)-1,int(b))))
else:update(int(a)-1,2**(b[0]-97)) | def main():
import sys
input=sys.stdin.buffer.readline
n=int(eval(input()))+1
data=[0]*n*2
def update(i,x):
i+=n
data[i]=x
i//=2
while i:
data[i]=data[i*2]|data[i*2+1]
i//=2
def query(l,r):
l+=n
r+=n
s=0
while l<r:
if l&1:
s|=data[l]
l+=1
if r&1:
r-=1
s|=data[r]
l//=2
r//=2
return bin(s).count('1')
for i,c in enumerate(input()[:-1],n):data[i]=2**(c-97)
for i in range(n-1,0,-1):data[i]=data[i*2]|data[i-~i]
s=[]
for _ in range(int(eval(input()))):
q,a,b=input().split()
if q[0]>49:s+=query(int(a)-1,int(b)),
else:update(int(a)-1,2**(b[0]-97))
print(('\n'.join(map(str,s))))
main() | p02763 |
n,s,_,*t=open(0).read().split()
n=int(n)
d=[0]*n+[1<<ord(c)-97for c in s]
for i in range(n-1,0,-1):d[i]=d[i+i]|d[i-~i]
for q,a,b in zip(*[iter(t)]*3):
i,s=int(a)+n-1,0
if'2'>q:
d[i]=1<<ord(b)-97
while i>1:
i//=2
d[i]=d[i+i]|d[i-~i]
continue
j=int(b)+n
while i<j:
if i&1:
s|=d[i]
i+=1
if j&1:
j-=1
s|=d[j]
i//=2
j//=2
print((bin(s).count('1'))) | def main():
import sys
n,s,_,*t=sys.stdin.buffer.read().split()
n=int(n)
d=[0]*n+[1<<c-97for c in s]
for i in range(n-1,0,-1):d[i]=d[i+i]|d[i-~i]
for q,a,b in zip(*[iter(t)]*3):
i,s=int(a)+n-1,0
if q<b'2':
d[i]=1<<ord(b)-97
while i>1:
i//=2
d[i]=d[i+i]|d[i-~i]
continue
j=int(b)+n
while i<j:
if i&1:
s|=d[i]
i+=1
if j&1:
j-=1
s|=d[j]
i//=2
j//=2
print((bin(s).count('1')))
main() | p02763 |
import sys
input = sys.stdin.readline
N = int(input())
S = input().rstrip()
Q = int(input())
qs = [input().split() for i in range(Q)]
def ctoi(c):
return ord(c) - ord('a')
class BinaryIndexedTree:
def __init__(self,size):
self.N = size
self.bit = [0]*(size+1)
def add(self,x,w):
x += 1
while x <= self.N:
self.bit[x] += w
x += (x & -x)
def sum(self,x):
x += 1
ret = 0
while x > 0:
ret += self.bit[x]
x -= (x & -x)
return ret
bits = [BinaryIndexedTree(N) for _ in range(26)]
for i,c in enumerate(S):
bits[ctoi(c)].add(i,1)
s = list(S)
ans = []
for a,b,c in qs:
if a=='1':
x = int(b)-1
bits[ctoi(c)].add(x,1)
bits[ctoi(s[x])].add(x,-1)
s[x] = c
else:
b,c = int(b)-1,int(c)-1
tmp = 0
for i in range(26):
if bits[i].sum(c) - bits[i].sum(b-1) > 0:
tmp += 1
ans.append(tmp)
print(*ans, sep='\n')
| import sys
input = sys.stdin.readline
N = int(input())
S = input().rstrip()
Q = int(input())
qs = [input().split() for i in range(Q)]
def ctoi(c):
return ord(c) - ord('a')
class BinaryIndexedTree:
def __init__(self,size):
self.N = size
self.bit = [0]*(size+1)
def add(self,x,w):
x += 1
while x <= self.N:
self.bit[x] += w
x += (x & -x)
def _sum(self,x):
x += 1
ret = 0
while x > 0:
ret += self.bit[x]
x -= (x & -x)
return ret
def sum(self,l,r):
return self._sum(r-1) - self._sum(l-1)
bits = [BinaryIndexedTree(N) for _ in range(26)]
for i,c in enumerate(S):
bits[ctoi(c)].add(i,1)
s = list(S)
ans = []
for a,b,c in qs:
if a=='1':
x = int(b)-1
bits[ctoi(c)].add(x,1)
bits[ctoi(s[x])].add(x,-1)
s[x] = c
else:
b,c = int(b)-1,int(c)
tmp = 0
for i in range(26):
if bits[i].sum(b,c) > 0:
tmp += 1
ans.append(tmp)
print(*ans, sep='\n')
| p02763 |
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
return list(map(int,input().split()))
def m(): #複数文字
return list(map(int,input().split()))
def onem(): #Nとかの取得
return int(eval(input()))
def s(x): #圧縮
a = []
aa = x[0]
su = 1
for i in range(len(x)-1):
if aa != x[i+1]:
a.append([aa,su])
aa = x[i+1]
su = 1
else:
su += 1
a.append([aa,su])
return a
def jo(x): #listをスペースごとに分ける
return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
return max(list(map(max,x)))
def In(x,a): #aがリスト(sorted)
k = bs.bisect_left(a,x)
if k != len(a) and a[k] == x:
return True
else:
return False
"""
def nibu(x,n,r):
ll = 0
rr = r
while True:
mid = (ll+rr)//2
if rr == mid:
return ll
if (ここに評価入れる):
rr = mid
else:
ll = mid+1
"""
class SegmentTree:
def segfunc(self,x,y):
#ここに評価
po = [0 for i in range(26)]
for i in range(26):
po[i] = x[i]+y[i]
return po
#nは総数、initがlist,ide_eleが元
def __init__(self,n,init,ide_ele):
self.n = n
self.ide_ele = ide_ele
self.num = 2**(n-1).bit_length()
self.seg = [ide_ele for i in range(2*self.num)]
for i in range(n):
self.seg[i+self.num-1] = init[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self,k,x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[2*k+1],self.seg[2*k+2])
def query(self,p,q):
if q <= p:
po = [0] * 26
po[0] = 1
return po
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p > 1:
if p & 1 == 0:
res = self.segfunc(res,self.seg[p])
if q & 1 == 1:
res = self.segfunc(res,self.seg[q])
q -= 1
p //= 2
q = (q-1)//2
if p == q:
res = self.segfunc(res,self.seg[p])
else:
res = self.segfunc(self.segfunc(res,self.seg[p]),self.seg[q])
return res
def solver():
n = onem()
s = input().split()[0]
po = onem()
abc = [[0 for i in range(26)] for j in range(n)]
for i in range(n):
ppp = s[i]
abc[i][ord(s[i]) - ord('a')] += 1
Se = SegmentTree(n,abc,[0 for i in range(26)])
for i in range(po):
a,b,c = input().split()
a = int(a)
b = int(b)
if a == 1:
ppp = [0] * 26
ppp[ord(c) - ord('a')] = 1
Se.update(b-1,ppp)
else:
c = int(c)
op = Se.query(b-1,c)
co = 0
for i in range(26):
if op[i] >= 1:
co += 1
print(co)
if __name__ == "__main__":
solver()
| import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
return list(map(int,input().split()))
def m(): #複数文字
return list(map(int,input().split()))
def onem(): #Nとかの取得
return int(eval(input()))
def s(x): #圧縮
a = []
aa = x[0]
su = 1
for i in range(len(x)-1):
if aa != x[i+1]:
a.append([aa,su])
aa = x[i+1]
su = 1
else:
su += 1
a.append([aa,su])
return a
def jo(x): #listをスペースごとに分ける
return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
return max(list(map(max,x)))
def In(x,a): #aがリスト(sorted)
k = bs.bisect_left(a,x)
if k != len(a) and a[k] == x:
return True
else:
return False
"""
def nibu(x,n,r):
ll = 0
rr = r
while True:
mid = (ll+rr)//2
if rr == mid:
return ll
if (ここに評価入れる):
rr = mid
else:
ll = mid+1
"""
class SegmentTree:
def segfunc(self,x,y):
#ここに評価
po = [0 for i in range(26)]
for i in range(26):
po[i] = x[i]+y[i]
return po
#nは総数、initがlist,ide_eleが元
def __init__(self,n,init,ide_ele):
self.n = n
self.ide_ele = ide_ele
self.num = 2**(n-1).bit_length()
self.seg = [ide_ele for i in range(2*self.num)]
for i in range(n):
self.seg[i+self.num-1] = init[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self,k,x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[2*k+1],self.seg[2*k+2])
def query(self,p,q):
if q <= p:
return [1 if i == 0 else 0 for i in range(26)]
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p > 1:
if p & 1 == 0:
res = self.segfunc(res,self.seg[p])
if q & 1 == 1:
res = self.segfunc(res,self.seg[q])
q -= 1
p //= 2
q = (q-1)//2
if p == q:
res = self.segfunc(res,self.seg[p])
else:
res = self.segfunc(self.segfunc(res,self.seg[p]),self.seg[q])
return res
def solver():
n = onem()
s = input().split()[0]
po = onem()
abc = [[0 for i in range(26)] for j in range(n)]
for i in range(n):
ppp = s[i]
abc[i][ord(s[i]) - 97] += 1
Se = SegmentTree(n,abc,[0 for i in range(26)])
for i in range(po):
a,b,c = input().split()
a = int(a)
b = int(b)
if a == 1:
ppp = [0] * 26
ppp[ord(c) - 97] = 1
Se.update(b-1,ppp)
else:
c = int(c)
op = Se.query(b-1,c)
co = 0
for i in range(26):
if op[i] >= 1:
co += 1
print(co)
if __name__ == "__main__":
solver()
| p02763 |
import sys
# input = sys.stdin.buffer.readline
def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getlist():
return list(map(int, input().split()))
import math
import heapq
import bisect
from collections import defaultdict, Counter, deque
MOD = 10**9 + 7
INF = 10**21
class Segtree_op():
def __init__(self, n):
self.size = 1
while (n >= 1):
self.size = self.size << 1
n = n // 2
self.arr = [self.unit() for i in range(self.size * 2)]
def op(self, lch, rch):
# sum
return lch + rch
# update min with holding index
# if lch[0] <= rch[0]:
# return lch
# else:
# return rch
def unit(self):
return 0
def update(self, k, val):
k += self.size - 1
self.arr[k] = val
while (k):
k = (k - 1) // 2
self.arr[k] = self.op(self.arr[k * 2 + 1], self.arr[k * 2 + 2])
def query(self, l, r):
L = l + self.size
R = r + self.size
s = self.unit()
while L < R:
if R & 1:
R -= 1
s = self.op(s, self.arr[R - 1])
if L & 1:
s = self.op(s, self.arr[L - 1])
L += 1
L >>= 1
R >>= 1
return s
# def show(self):
# idx = 1
# while (idx <= self.size):
# print(self.arr[idx - 1:idx * 2 - 1])
# idx *= 2
def main():
n = getN()
s = [c for c in input().strip()]
q = getN()
# SegTreeをa-zぶん用意する 3文字目がbならsegs[b]の3番目にフラグ1が立つ
segs = [Segtree_op(n) for i in range(26)]
for i, c in enumerate(s):
segs[ord(c) - ord("a")].update(i, 1)
for query in range(q):
operand, a, b = input().split()
if operand == "1":
# 0-indexed
a = int(a) - 1
segs[ord(s[a]) - ord("a")].update(a, 0)
segs[ord(b) - ord("a")].update(a, 1)
s[a] = b
else: # operand == "2"
tmp = 0
# 0-indexed
a, b = int(a) - 1, int(b) - 1
for se in segs:
# a-zそれぞれのSegTreeについて、区間内にフラグが立っていれば tmp += 1
# 文字自体ではなくその間にindexが降られているので、右側を+1
if se.query(a, b+1) > 0:
tmp += 1
print(tmp)
# print(segs[0].arr)
if __name__ == '__main__':
main()
"""
7
aaaabbb
3
1 7 c
2 1 5
2 1 7
>> 2
>> 3
26
abcdefghijklmnopqrstuvwxyz
7
2 1 26
2 2 26
2 5 5
2 11 20
2 25 26
1 1 z
2 1 26
>> 26
>> 25
>> 1
>> 10
>> 2
>> 25
""" | import sys
from collections import defaultdict, deque, Counter
import math
# import copy
from bisect import bisect_left, bisect_right
# import heapq
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(eval(input()))
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
class Segtree_op():
# 単位元及び操作を設定して使うこと
# queryでは、区間の(l, r)を指定する ex: (0, 5) => [0, 1, 2, 3, 4]
# 特定の1点は (i, i+1)
def __init__(self, n):
self.size = 1
while(n >= 1):
self.size = self.size << 1
n = n//2
self.arr = [self.unit() for i in range(self.size*2)]
def op(self, lch, rch):
# update min with holding index
return max(rch, lch)
def unit(self):
return 0
def update(self, k, val):
k += self.size - 1
self.arr[k] = val
while(k):
k = (k - 1) // 2
self.arr[k] = self.op(self.arr[k*2 + 1], self.arr[k*2 + 2])
def query(self, l, r):
L = l + self.size
R = r + self.size
s = self.unit()
while L < R:
if R & 1:
R -= 1
s = self.op(s, self.arr[R - 1])
if L & 1:
s = self.op(s, self.arr[L - 1])
L += 1
L >>= 1
R >>= 1
return s
def show(self):
idx = 1
while(idx <= self.size):
print((self.arr[idx - 1:idx * 2 - 1]))
idx *= 2
def getind(c):
return ord(c) - ord("a")
def main():
N = getN()
S = list(getS())
Q = getN()
segs = [Segtree_op(N) for i in range(26)]
for i, c in enumerate(S):
segs[getind(c)].update(i, 1)
for _ in range(Q):
query = getS().split()
if query[0] == "1":
k, i, c = query
i = int(i) - 1
segs[getind(S[i])].update(i, 0)
segs[getind(c)].update(i, 1)
S[i] = c
else:
k, l, r = list(map(int, query))
ans = 0
for se in segs:
if se.query(l-1, r) == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| p02763 |
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
S = ['$'] + list(input().rstrip())
c = lambda x: ord(x) - ord('a')
bit = [BinaryIndexedTree(N) for _ in range(26)]
for i, l in enumerate(S):
if i == 0: continue
bit[c(l)].add(i, 1)
Q = int(eval(input()))
for _ in range(Q):
t, a, b = input().rstrip().split()
if t == '1':
a = int(a)
bit[c(S[a])].add(a, -1)
bit[c(b)].add(a, 1)
S[a] = b
else:
a, b = int(a), int(b)
ans = 0
for i in range(26):
t = bit[i].sum(b)
if a >= 1: t -= bit[i].sum(a-1)
ans += 1 if t else 0
print(ans)
class BinaryIndexedTree:
def __init__(self, n=None, f=lambda x,y:x+y, zero=0, initial_values=None):
assert(n or initial_values)
self.__f, self.__z, = f, zero
self.__n = n if n else len(initial_values)
self.__dat = [zero] * (self.__n + 1)
if initial_values:
for i in range(1, self.__n + 1): self.add(i, initial_values[i-1]) #slow
def add(self, i, v):
while i <= self.__n:
self.__dat[i] = self.__f(self.__dat[i], v)
i += -i&i
def sum(self, r):
ans = self.__z
while r:
ans = self.__f(ans, self.__dat[r])
r -= -r&r
return ans
if __name__ == '__main__':
main()
| class SegmentTree:
def __init__(self, initial_values, f=max, zero=0, converter=lambda x:x):
self.__f, self.__z, self.__c, self.__size = f, zero, converter, len(initial_values)
self.__n = 1 << ((self.__size - 1).bit_length())
self.__dat = [zero] * (2 * self.__n)
zi = self.__get_leaf(0)
for i, v in enumerate(initial_values): self.__dat[zi + i] = converter(v)
for i in range(zi-1, -1, -1): self.__dat[i] = f(*self.__get_children(i))
def update(self, index, value):
i, v = self.__get_leaf(index), self.__c(value)
if self.__dat[i] == v: return
self.__dat[i] = v
while i:
i = self.__get_parent(i)
self.__dat[i] = self.__f(*self.__get_children(i))
def query(self, from_inclusive, to_exclusive):
ans = self.__z
if to_exclusive <= from_inclusive: return ans
l, r = self.__get_leaf(from_inclusive), self.__get_leaf(to_exclusive) - 1
while r - l > 1:
if self.__is_right(l): ans = self.__f(ans, self.__dat[l])
if self.__is_left(r): ans, r = self.__f(ans, self.__dat[r]), r-1
l, r = l//2, self.__get_parent(r)
ans = self.__f(ans, self.__dat[l])
if l != r: ans = self.__f(ans, self.__dat[r])
return ans
def __get_leaf(self, i): return self.__n + i - 1
def __get_parent(self, i): return (i-1)//2
def __get_children(self, i): return (self.__dat[2*i+1], self.__dat[2*i+2])
def __is_left(self, i): return i&1 == 1
def __is_right(self, i): return i&1 == 0
import sys
input = sys.stdin.readline
N = int(eval(input()))
S = input().rstrip()
tree = SegmentTree(S, f=lambda x,y:x|y, converter=lambda c: 1 << (ord(c)-ord('a')))
Q = int(eval(input()))
update = tree.update
query = tree.query
for _ in range(Q):
t, a, b = input().rstrip().split()
if t == '1': update(int(a)-1, b)
else: print((bin(query(int(a)-1, int(b))).count('1')))
| p02763 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N,S,Q,*q = read().decode().split()
N = int(N)
S = list(S)
c = lambda x: ord(x) - ord('a')
tree = [SegmentTree(N, lambda x,y:x|y) for _ in range(26)]
for i, l in enumerate(S):
tree[c(l)].update(i, 1)
for t, a, b in zip(*[iter(q)]*3):
if t == '1':
a = int(a) - 1
tree[c(S[a])].update(a, 0)
tree[c(b)].update(a, 1)
S[a] = b
else:
a, b = int(a)-1, int(b)-1
ans = 0
for i in range(26):
t = tree[i].query(a, b+1)
ans += 1 if t else 0
print(ans)
class SegmentTree:
def __init__(self, n=None, f=max, zero_factory=int, converter=lambda x:x, initial_values=None):
assert(n or initial_values)
size = n if n else len(initial_values)
self.__f, self.__z, self.__c = f, zero_factory, converter
self.__n = 1 << ((size - 1).bit_length())
self.__dat = [zero_factory() for _ in range(2 * self.__n)]
if initial_values:
zi = self.__get_leaf(0)
for i, v in enumerate(initial_values): self.__dat[zi + i] = converter(v)
for i in range(zi-1, -1, -1): self.__dat[i] = f(*self.__get_children(i))
def update(self, index, value):
i, v = self.__get_leaf(index), self.__c(value)
if self.__dat[i] == v: return
self.__dat[i] = v
while i:
i = self.__get_parent(i)
self.__dat[i] = self.__f(*self.__get_children(i))
def query(self, from_inclusive, to_exclusive):
ans = self.__z()
if to_exclusive <= from_inclusive: return ans
l, r = self.__get_leaf(from_inclusive), self.__get_leaf(to_exclusive) - 1
while r - l > 1:
if self.__is_right(l): ans = self.__f(ans, self.__dat[l])
if self.__is_left(r): ans, r = self.__f(ans, self.__dat[r]), r-1
l, r = l//2, self.__get_parent(r)
ans = self.__f(ans, self.__dat[l])
if l != r: ans = self.__f(ans, self.__dat[r])
return ans
def __get_leaf(self, i): return self.__n + i - 1
def __get_parent(self, i): return (i-1)//2
def __get_children(self, i): return (self.__dat[2*i+1], self.__dat[2*i+2])
def __is_left(self, i): return i&1 == 1
def __is_right(self, i): return i&1 == 0
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N,S,Q,*q = read().split()
S = S.decode()
tree = SegmentTree(initial_values=S, f=lambda x,y:x|y, converter=lambda c: 1 << (ord(c)-ord('a')))
for t, a, b in zip(*[iter(q)]*3):
if t == b'1': tree.update(int(a)-1, b)
else: print((bin(tree.query(int(a)-1, int(b))).count('1')))
class SegmentTree:
def __init__(self, n=None, f=max, zero_factory=int, converter=lambda x:x, initial_values=None):
assert(n or initial_values)
size = n if n else len(initial_values)
self.__f, self.__z, self.__c = f, zero_factory, converter
self.__n = 1 << ((size - 1).bit_length())
self.__dat = [zero_factory() for _ in range(2 * self.__n)]
if initial_values:
zi = self.__get_leaf(0)
for i, v in enumerate(initial_values): self.__dat[zi + i] = converter(v)
for i in range(zi-1, -1, -1): self.__dat[i] = f(*self.__get_children(i))
def update(self, index, value):
i, v = self.__get_leaf(index), self.__c(value)
if self.__dat[i] == v: return
self.__dat[i] = v
while i:
i = self.__get_parent(i)
self.__dat[i] = self.__f(*self.__get_children(i))
def query(self, from_inclusive, to_exclusive):
ans = self.__z()
if to_exclusive <= from_inclusive: return ans
l, r = self.__get_leaf(from_inclusive), self.__get_leaf(to_exclusive) - 1
while r - l > 1:
if self.__is_right(l): ans = self.__f(ans, self.__dat[l])
if self.__is_left(r): ans, r = self.__f(ans, self.__dat[r]), r-1
l, r = l//2, self.__get_parent(r)
ans = self.__f(ans, self.__dat[l])
if l != r: ans = self.__f(ans, self.__dat[r])
return ans
def __get_leaf(self, i): return self.__n + i - 1
def __get_parent(self, i): return (i-1)//2
def __get_children(self, i): return (self.__dat[2*i+1], self.__dat[2*i+2])
def __is_left(self, i): return i&1 == 1
def __is_right(self, i): return i&1 == 0
if __name__ == '__main__':
main()
| p02763 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#from math import gcd
#inf = 10**17
#mod = 10**9 + 7
def segfunc(x, y):
return x | y
def init(arr):
for i in range(n):
seg[i+num-1] = set(arr[i])
for i in range(num-2,-1,-1) :
seg[i] = segfunc(seg[2*i+1],seg[2*i+2])
def update(k,x):
k += num-1
seg[k].clear()
seg[k] = set(x)
while k:
k = (k-1)//2
seg[k].clear()
seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
def query(p,q):
if q<=p:
return ide_ele
p += num-1
q += num-2
res=ide_ele
while q-p>1:
if p&1 == 0:
res = segfunc(res,seg[p])
if q&1 == 1:
res = segfunc(res,seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = segfunc(res,seg[p])
else:
res = segfunc(segfunc(res,seg[p]),seg[q])
return res
n = int(eval(input()))
s = list(input().rstrip())
ide_ele = set()
num =2**((n-1).bit_length())
# セグ木初期化
seg=[ide_ele]*2*num
init(s)
q = int(eval(input()))
for _ in range(q):
a,b,c = input().rstrip().split()
if a == '1':
b = int(b)
update(b-1, c)
else:
b = int(b)
c = int(c)
print((len(query(b-1, c))))
if __name__ == '__main__':
main() | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#from math import gcd
#inf = 10**17
#mod = 10**9 + 7
def segfunc(x, y):
return x | y
def init(arr):
for i in range(n):
seg[i+num-1] = {arr[i]}
for i in range(num-2,-1,-1) :
seg[i] = segfunc(seg[2*i+1],seg[2*i+2])
def update(k,x):
k += num-1
seg[k].clear()
seg[k] = {x}
while k:
k = (k-1)//2
seg[k].clear()
seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
def query(p,q):
if q<=p:
return ide_ele
p += num-1
q += num-2
res=ide_ele
while q-p>1:
if p&1 == 0:
res = segfunc(res,seg[p])
if q&1 == 1:
res = segfunc(res,seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = segfunc(res,seg[p])
else:
res = segfunc(segfunc(res,seg[p]),seg[q])
return res
n = int(eval(input()))
s = list(input().rstrip())
for i in range(n):
s[i] = ord(s[i]) - 97
ide_ele = set()
num =2**((n-1).bit_length())
# セグ木初期化
seg=[ide_ele]*2*num
init(s)
q = int(eval(input()))
for _ in range(q):
a,b,c = input().rstrip().split()
if a == '1':
b = int(b)
c = ord(c) - 97
update(b-1, c)
else:
b = int(b)
c = int(c)
print((len(query(b-1, c))))
if __name__ == '__main__':
main() | p02763 |
import sys
input = sys.stdin.readline
class SegmentTree:
def __init__(self, N, X):
self.N = N
self.func = lambda x, y: x | y
self.__build(X)
def __build(self, X):
# Initialize all nodes
self.node = [set() for _ in range(2 * self.N)]
# Elementary intervals are stored
for i, s in enumerate(X, self.N):
self.node[i].add(s)
# The internal nodes correspond to intervals that are the union of elementary intervals
for i in range(self.N - 1, 0, -1):
self.node[i] = self.func(self.node[i << 1], self.node[i << 1 | 1])
def update(self, i, s):
i += self.N - 1
if s in self.node[i]:
return
self.node[i] = set([s])
while i > 1:
i >>= 1
self.node[i] = self.func(self.node[i << 1], self.node[i << 1 | 1])
def query(self, l, r):
"""Query for right half-open interval [l, r).
Args:
l (int): index (1-based index)
r (int): index (1-based index)
"""
dst_l = set()
dst_r = set()
l += self.N - 1
r += self.N - 1
while l < r:
if l & 1:
dst_l = self.func(dst_l, self.node[l])
l += 1
if r & 1:
r -= 1
dst_r = self.func(self.node[r], dst_r)
l >>= 1
r >>= 1
return self.func(dst_l, dst_r)
def main():
N = int(eval(input()))
S = input().rstrip()
S = list(S)
st = SegmentTree(N, S)
ans = []
Q = int(eval(input()))
for _ in range(Q):
query = input().split()
q = int(query[0])
if q == 1:
i = int(query[1])
c = query[2]
st.update(i, c)
else:
l = int(query[1])
r = int(query[2])
res = st.query(l, r + 1)
ans.append(len(res))
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| import sys
from operator import or_
input = sys.stdin.readline
class SegmentTree:
def __init__(self, N, X):
self.N = N
self.func = or_
self.__build(X)
def __build(self, X):
# Initialize all nodes
self.node = [set() for _ in range(2 * self.N)]
# Elementary intervals are stored
for i, s in enumerate(X, self.N):
self.node[i].add(s)
# The internal nodes correspond to intervals that are the union of elementary intervals
for i in range(self.N - 1, 0, -1):
self.node[i] = self.func(self.node[i << 1], self.node[i << 1 | 1])
def update(self, i, s):
i += self.N - 1
if s in self.node[i]:
return
self.node[i] = set([s])
while i > 1:
i >>= 1
self.node[i] = self.func(self.node[i << 1], self.node[i << 1 | 1])
def query(self, l, r):
"""Query for right half-open interval [l, r).
Args:
l (int): index (1-based index)
r (int): index (1-based index)
"""
dst_l = set()
dst_r = set()
l += self.N - 1
r += self.N - 1
while l < r:
if l & 1:
dst_l = self.func(dst_l, self.node[l])
l += 1
if r & 1:
r -= 1
dst_r = self.func(self.node[r], dst_r)
l >>= 1
r >>= 1
return self.func(dst_l, dst_r)
def main():
N = int(eval(input()))
S = input().rstrip()
S = list(S)
st = SegmentTree(N, S)
ans = []
Q = int(eval(input()))
for _ in range(Q):
query = input().split()
q = int(query[0])
if q == 1:
i = int(query[1])
c = query[2]
st.update(i, c)
else:
l = int(query[1])
r = int(query[2])
res = st.query(l, r + 1)
ans.append(len(res))
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| p02763 |
import sys
from operator import or_
input = sys.stdin.readline
class SegmentTree:
def __init__(self, N, X):
self.N = N
self.func = or_
self.__build(X)
def __build(self, X):
# Initialize all nodes
self.node = [set() for _ in range(2 * self.N)]
# Elementary intervals are stored
for i, s in enumerate(X, self.N):
self.node[i].add(s)
# The internal nodes correspond to intervals that are the union of elementary intervals
for i in range(self.N - 1, 0, -1):
self.node[i] = self.func(self.node[i << 1], self.node[i << 1 | 1])
def update(self, i, s):
i += self.N - 1
if s in self.node[i]:
return
self.node[i] = set([s])
while i > 1:
i >>= 1
self.node[i] = self.func(self.node[i << 1], self.node[i << 1 | 1])
def query(self, l, r):
"""Query for right half-open interval [l, r).
Args:
l (int): index (1-based index)
r (int): index (1-based index)
"""
dst_l = set()
dst_r = set()
l += self.N - 1
r += self.N - 1
while l < r:
if l & 1:
dst_l = self.func(dst_l, self.node[l])
l += 1
if r & 1:
r -= 1
dst_r = self.func(self.node[r], dst_r)
l >>= 1
r >>= 1
return self.func(dst_l, dst_r)
def main():
N = int(eval(input()))
S = input().rstrip()
S = list(S)
st = SegmentTree(N, S)
ans = []
Q = int(eval(input()))
for _ in range(Q):
query = input().split()
q = int(query[0])
if q == 1:
i = int(query[1])
c = query[2]
st.update(i, c)
else:
l = int(query[1])
r = int(query[2])
res = st.query(l, r + 1)
ans.append(len(res))
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
class SegmentTree:
def __init__(self, N, X):
self.N = N
self.func = lambda x, y: x | y
self.__build(X)
def __build(self, X):
# Initialize all nodes
self.node = [set() for _ in range(2 * self.N)]
# Elementary intervals are stored
for i, s in enumerate(X, self.N):
self.node[i].add(s)
# The internal nodes correspond to intervals that are the union of elementary intervals
for i in range(self.N - 1, 0, -1):
self.node[i] = self.func(self.node[i << 1], self.node[i << 1 | 1])
def update(self, i, s):
i += self.N - 1
if s in self.node[i]:
return
self.node[i] = set([s])
while i > 1:
i >>= 1
self.node[i] = self.func(self.node[i << 1], self.node[i << 1 | 1])
def query(self, l, r):
"""Query for right half-open interval [l, r).
Args:
l (int): index (1-based index)
r (int): index (1-based index)
"""
dst_l = set()
dst_r = set()
l += self.N - 1
r += self.N - 1
while l < r:
if l & 1:
dst_l = self.func(dst_l, self.node[l])
l += 1
if r & 1:
r -= 1
dst_r = self.func(self.node[r], dst_r)
l >>= 1
r >>= 1
return self.func(dst_l, dst_r)
def main():
N = int(eval(input()))
S = input().rstrip()
S = list(S)
st = SegmentTree(N, S)
ans = []
Q = int(eval(input()))
for _ in range(Q):
query = input().split()
q = int(query[0])
if q == 1:
i = int(query[1])
c = query[2]
st.update(i, c)
else:
l = int(query[1])
r = int(query[2])
res = st.query(l, r + 1)
ans.append(len(res))
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| p02763 |
# どの文字を持っているかを二進数で1000101010...と表す
# or で足していく
class SegmentTree:
arr=None
tree=None
n=0
# 結果に影響を与えないdefault value
DEF=0
def __init__(self,arr):
# print("arr",arr)
self.arr=arr
size=len(arr)
# n階層目は2**(n-1)要素
self.n=1
while self.n<size:
self.n*=2
self.tree=[self.DEF]*(2*self.n-1)
# 親=(n-1)//2
# 子=2*n+1,2*n+2
# 最下階層の要素を埋めていく
for i in range(size):
# print(arr[i])
self.tree[i+self.n-1]=arr[i]
for i in range(self.n-2,-1,-1):
self.tree[i]=self.__choose__(self.tree[2*i+1],self.tree[2*i+2])
# 区間からの代表値の選び方を定義する（最小値を選ぶ場合はminなど）
def __choose__(self,a,b):
#print("a",a,"b",b)
return a | b
# 添字xをvalで更新する
def update(self,x,val):
x+=self.n-1
# print("x",x,"val",val)
self.tree[x]=val
while x>0:
x=(x-1)//2
self.tree[x]=self.__choose__(self.tree[2*x+1],self.tree[2*x+2])
# 対象区間[a,b)の値を求めるクエリ (bは含まないので注意)
# k:自分がいるノードのindex
# [l,r):検査する区間
def get_val(self,a,b,k=0,l=0,r=-1):
# 最初に呼び出されたときは対象区間が[0,N)
if r<0:
r=self.n
# 要求区間と対象区間が交わらない
if r<=a or b<=l:
return self.DEF
# 要求区間が対象区間を完全に満たす->対象区間を計算に使用する
if a<=l and r<=b:
return self.tree[k]
# 要求区間が対象区間の一部を満たす->子を探索
ll=self.get_val(a,b,2*k+1,l,(l+r)//2)
rr=self.get_val(a,b,2*k+2,(l+r)//2,r)
return self.__choose__(ll,rr)
def show(self):
print("----")
print((list(map(bin,self.tree))))
print((self.tree))
base=ord("a")
ALPHA="abcdefghijklmnopqrstuvwxyz"
def change_alpha_to_num(c):
if c not in ALPHA:
return 0
# print("c",c,"ord(c)",ord(c),"base",base)
return 1<<(ord(c)-base)
import sys
readline=sys.stdin.readline
N=int(readline())
S=readline()
Sarr=list(map(change_alpha_to_num,list(S)))
ST=SegmentTree(Sarr)
#ST.show()
Q=int(readline())
for i in range(Q):
q=list(readline().split())
if q[0]=="1":
#print("q",q)
i,c=int(q[1])-1,q[2]
ST.update(i,change_alpha_to_num(c))
#ST.show()
elif q[0]=="2":
l,r=int(q[1])-1,int(q[2])-1
# print(ST.get_val(l,r+1))
print((bin(ST.get_val(l,r+1)).count("1")))
| # どの文字を持っているかを二進数で1000101010...と表す
# or で足していく
class SegmentTree:
arr=None
tree=None
n=0
# 結果に影響を与えないdefault value
DEF=0
def __init__(self,arr):
self.arr=arr
size=len(arr)
# n階層目は2**(n-1)要素
self.n=1
while self.n<size:
self.n*=2
self.tree=[self.DEF]*(2*self.n-1)
# 親=(n-1)//2
# 子=2*n+1,2*n+2
# 最下階層の要素を埋めていく
for i in range(size):
self.tree[i+self.n-1]=arr[i]
for i in range(self.n-2,-1,-1):
self.tree[i]=self.__choose__(self.tree[2*i+1],self.tree[2*i+2])
# 区間からの代表値の選び方を定義する（最小値を選ぶ場合はminなど）
def __choose__(self,a,b):
return a | b
# 添字xをvalで更新する
def update(self,x,val):
x+=self.n-1
self.tree[x]=val
while x>0:
x=(x-1)//2
self.tree[x]=self.__choose__(self.tree[2*x+1],self.tree[2*x+2])
# 対象区間[a,b)の値を求めるクエリ (bは含まないので注意)
# k:自分がいるノードのindex
# [l,r):検査する区間
def get_val(self,a,b,k=0,l=0,r=-1):
# 最初に呼び出されたときは対象区間が[0,N)
if r<0:
r=self.n
# 要求区間と対象区間が交わらない
if r<=a or b<=l:
return self.DEF
# 要求区間が対象区間を完全に満たす->対象区間を計算に使用する
if a<=l and r<=b:
return self.tree[k]
# 要求区間が対象区間の一部を満たす->子を探索
ll=self.get_val(a,b,2*k+1,l,(l+r)//2)
rr=self.get_val(a,b,2*k+2,(l+r)//2,r)
return self.__choose__(ll,rr)
def show(self):
print("----")
print((list(map(bin,self.tree))))
print((self.tree))
base=ord("a")
ALPHA="abcdefghijklmnopqrstuvwxyz"
def change_alpha_to_num(c):
if c not in ALPHA:
return 0
return 1<<(ord(c)-base)
import sys
readline=sys.stdin.readline
N=int(readline())
S=readline()
Sarr=list(map(change_alpha_to_num,list(S)))
ST=SegmentTree(Sarr)
Q=int(readline())
for i in range(Q):
q=list(readline().split())
if q[0]=="1":
i,c=int(q[1])-1,q[2]
ST.update(i,change_alpha_to_num(c))
elif q[0]=="2":
l,r=int(q[1])-1,int(q[2])-1
print((bin(ST.get_val(l,r+1)).count("1")))
| p02763 |
import sys
input = sys.stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
if i == 0:
return 0
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
aas = "abcdefghijklmnopqrstuvwxyz"
N = int(input().strip())
S = list(input().strip())
Q = int(input().strip())
cbt = dict()
MX = 5 * 10**5 + 2
for c in aas:
cbt[c] = Bit(MX)
for i, a in enumerate(S):
if a == c:
cbt[c].add(i+1, 1)
for _ in range(Q):
t, i, c = input().split()
t = int(t)
if t == 1:
i = int(i)
if S[i-1] != c:
cbt[S[i-1]].add(i, -1)
cbt[c].add(i, 1)
S[i-1] = c
else:
# print(S)
l, r = int(i), int(c)
# print(l, r)
s = 0
for a in aas:
bt = cbt[a]
# print(a, bt.sum(r),bt.sum(l-1))
s += (bt.sum(r)-bt.sum(l-1)>0)
print(s)
| import sys
input = sys.stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
if i == 0:
return 0
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
aas = "abcdefghijklmnopqrstuvwxyz"
N = int(input().strip())
S = [" "]+list(input().strip())
Q = int(input().strip())
cbt = dict()
for c in aas:
cbt[c] = Bit(N)
for i, a in enumerate(S):
if i == 0:
continue
if a == c:
cbt[c].add(i, 1)
for _ in range(Q):
t, i, c = input().split()
t = int(t)
if t == 1:
i = int(i)
if S[i] != c:
cbt[S[i]].add(i, -1)
cbt[c].add(i, 1)
S[i] = c
else:
l, r = int(i), int(c)
s = 0
for a in aas:
bt = cbt[a]
s += (bt.sum(r)-bt.sum(l-1)>0)
print(s)
| p02763 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
def add(self, i, x=1):
i += 1
while i <= self.n:
self.data[i] += x
i += i & -i
def get_sum(self, i):
i += 1
x = 0
while i > 0:
x += self.data[i]
i -= i & -i
return x
# Return sum for [l, r)
def get_sum_range(self, l, r):
return self.get_sum(r - 1) - self.get_sum(l - 1)
def main():
N = int(readline())
S = readline().strip()
Q = int(readline())
query = [readline().split() for _ in range(Q)]
bit = [BIT(N) for _ in range(26)]
for i, c in enumerate(S):
bit[ord(c) - ord('a')].add(i)
S = list(S)
ans = []
for q in query:
if q[0] == '1':
i = int(q[1]) - 1
c = q[2]
bit[ord(S[i]) - ord('a')].add(i, -1)
bit[ord(c) - ord('a')].add(i, 1)
S[i] = c
else:
res = 0
l, r = int(q[1]) - 1, int(q[2]) - 1
for i in range(26):
if bit[i].get_sum_range(l, r + 1):
res += 1
ans.append(res)
print(*ans, sep='\n')
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
def add(self, i, x=1):
i += 1
while i <= self.n:
self.data[i] += x
i += i & -i
def get_sum(self, i):
i += 1
x = 0
while i > 0:
x += self.data[i]
i -= i & -i
return x
# Return sum for [l, r)
def get_sum_range(self, l, r):
return self.get_sum(r - 1) - self.get_sum(l - 1)
def main():
N = int(readline())
S = readline().strip()
Q = int(readline())
bit = [BIT(N) for _ in range(26)]
for i, c in enumerate(S):
bit[ord(c) - ord('a')].add(i)
S = list(S)
ans = []
for _ in range(Q):
n, a, b = readline().split()
if n == '1':
i = int(a) - 1
if b != S[i]:
bit[ord(S[i]) - ord('a')].add(i, -1)
bit[ord(b) - ord('a')].add(i, 1)
S[i] = b
else:
res = 0
l, r = int(a) - 1, int(b) - 1
for i in range(26):
if bit[i].get_sum_range(l, r + 1):
res += 1
ans.append(res)
print(*ans, sep='\n')
return
if __name__ == '__main__':
main()
| p02763 |
class BinaryIndexTree: # 1-indexed
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
if __name__ == "__main__":
N = int(input())
S = list(input())
d = {x: i for i, x in enumerate("abcdefghijklmnopqrstuvwxyz")}
BIT = [BinaryIndexTree(N) for _ in range(26)]
# initialize
for i, s in enumerate(S, start=1):
BIT[d[s]].add(i, 1)
Q = int(input())
ans = []
for _ in range(Q):
query, x, y = input().split()
if query == "1":
i = int(x)
c_new = y
c_old = S[i - 1]
BIT[d[c_new]].add(i, 1)
BIT[d[c_old]].add(i, -1)
S[i - 1] = c_new
else:
cnt = 0
l = int(x) - 1
r = int(y)
for b in BIT:
tmp = b.sum(r) - b.sum(l)
if tmp:
cnt += 1
ans.append(cnt)
print(*ans, sep="\n")
| class BinaryIndexTree: # 1-indexed
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def Alp(s):
return ord(s)-ord("a")
if __name__ == "__main__":
N = int(input())
S = list(input())
Q = int(input())
bit = [BinaryIndexTree(N) for _ in range(26)]
for i, s in enumerate(S, start=1):
bit[Alp(s)].add(i, 1)
ans = []
for _ in range(Q):
q = input().split()
if q[0] == "1":
i = int(q[1]) - 1
c = q[2]
bit[Alp(c)].add(i+1, 1)
bit[Alp(S[i])].add(i+1, -1)
S[i] = c
else:
l = int(q[1])
r = int(q[2])
tmp = 0
for i in range(26):
b = bit[i]
if b.sum(r) - b.sum(l - 1) > 0:
tmp += 1
ans.append(tmp)
print(*ans, sep="\n")
| p02763 |
import sys
N = int(eval(input()))
scores = [0]*(N*100+1)
scores[0] = 1
for _ in range(N):
a = int(eval(input()))
for i in reversed(list(range(len(scores)))):
if scores[i]>0 and 0<i+a<=N*100:
scores[i+a] += 1
for i in reversed(list(range(len(scores)))):
if scores[i] and i % 10 != 0:
print(i)
sys.exit()
print((0)) | N = int(eval(input()))
a = list(int(eval(input())) for _ in range(N))
a.sort()
ans = sum(a)
if ans%10 > 0:
print(ans)
exit()
for ai in a:
if ai%10 > 0:
print((ans - ai))
break
else:
print((0))
| p03699 |
N = int(eval(input()))
s = []
sum = 0
min_nonten = 999
all_ten = True
for i in range(N):
s.append(int(eval(input())))
sum += s[i]
if(s[i] % 10 != 0):
all_ten = False
if(min_nonten > s[i]):
min_nonten = s[i]
if(sum % 10 != 0):
print(sum)
elif(all_ten):
print((0))
else:
print((sum - min_nonten)) | n=int(eval(input()))
s=[]
for i in range(n):
s.append(int(eval(input())))
if(sum(s)%10!=0):
print((sum(s)))
else:
s.sort()
for i in range(n):
if(s[i]%10!=0):
print((sum(s)-s[i]))
break
else:
print((0))
| p03699 |
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
dp = [[] for _ in range(n+1)]
for i in range(n+1):
dp[i] += [-1 for _ in range(10010)]
dp[0][0] = 1
for i in range(n):
for j in range(10010):
if dp[i][j] == 1:
dp[i+1][j] = 1
dp[i+1][j+a[i]] = 1
ans = 0
for i in range(10010):
if dp[n][i] == 1:
if i % 10 != 0:
ans = max(ans,i)
print(ans) | n = int(eval(input()))
ary = [int(eval(input())) for _ in range(n)]
total = sum(ary)
ans = 0
if total % 10 != 0:
print(total)
exit()
for i in ary:
a = total - i
if a % 10 != 0:
ans = max(ans,a)
print(ans) | p03699 |
import itertools as it
n = int(eval(input()))
s = [int(eval(input())) for _ in range(n)]
ans = [0]
for i in range(1,n+1) :
sa = list(it.combinations(s,i))
for j in range(len(sa)) :
if sum(sa[j])%10 != 0 :
ans.append(sum(sa[j]))
print((max(ans))) | n = int(eval(input()))
sum = 0
s = []
for i in range(n) :
x = int(eval(input()))
sum += x
if x%10 != 0 :
s.append(x)
if sum %10 != 0 :
print(sum)
exit()
while len(s)>0 :
m = min(s)
sum -= m
if sum%10 != 0 :
print(sum)
exit()
print((0)) | p03699 |
N = int(eval(input()))
a = [int(eval(input())) for _ in range(N)]
def sol(i, cur):
if i == -1:
return cur
else:
tmp1 = sol(i-1, cur+a[i])
tmp1 = tmp1 if tmp1 % 10 else 0
tmp2 = sol(i-1, cur)
tmp2 = tmp2 if tmp2 % 10 else 0
return max(tmp1, tmp2)
print((sol(N-1, 0))) | N = int(eval(input()))
a = [int(eval(input())) for _ in range(N)]
ans = sum(a)
if ans % 10 == 0:
if all([i % 10 == 0 for i in a]):
print((0))
else:
ans -= min([i for i in a if i % 10 != 0])
print(ans)
else:
print(ans) | p03699 |
from itertools import chain, combinations
def powerset(iterable):
s = list(iterable)
return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
N = int(eval(input()))
s = [int(eval(input())) for i in range(N)]
list1 = list([x for x in map(sum,powerset(s)) if x % 10])
list1.append(0)
print((max(list1))) | N = int(eval(input()))
s = [int(eval(input())) for i in range(N)]
sums = sum(s)
others = list([x for x in s if x % 10])
if sums % 10:
print(sums)
elif others != []:
print((sums-min(others)))
else:
print((0)) | p03699 |
def main():
n = int(eval(input()))
s = [int(eval(input())) for _ in range(n)]
s_sum = []
def dfs(i, sum):
if i == n:
s_sum.append(sum)
else:
dfs(i + 1, sum + s[i])
dfs(i + 1, sum)
dfs(0, 0)
s_sum_c = [s for s in s_sum if s % 10 != 0]
s_sum_c.append(0)
print((max(s_sum_c)))
if __name__ == '__main__':
main() | def main():
n = int(eval(input()))
s = [int(eval(input())) for _ in range(n)]
s_sum = sum(s)
s = [i for i in s if i % 10 != 0]
s.sort()
if s_sum % 10 != 0:
print(s_sum)
exit()
for es in s:
if (s_sum - es) % 10 != 0:
print((s_sum - es))
exit()
else:
print((0))
if __name__ == '__main__':
main() | p03699 |
n = int(eval(input()))
dat_s = []
for i in range(n):
dat_s.append(int(eval(input())))
total = sum(dat_s)
f = True
if total % 10 != 0:
print(total)
f = False
else:
dat_s.sort()
for i in range(len(dat_s)):
if dat_s[i] % 10 != 0:
print((total - dat_s[i]))
f = False
break
if f:
print("0") | n = int(eval(input()))
dat_s = []
for i in range(n):
dat_s.append(int(eval(input())))
# 0個選択したときのスコア(重複は意味がないのでset)
scores = set([0])
# 1～n問まで回す
for i in range(n):
# ここまでで可能性のあるスコアをbufferにいれて
b = set(scores)
while len(b) != 0:
# いまのn問目のスコアをこのスコアに足していく
scores.add(dat_s[i] + b.pop())
# 可能性のあるスコアの中から10で割り切れるスコアは消す(=0にする)
scores = [0 if x % 10 == 0 else x for x in scores]
print((max(scores)))
| p03699 |
import itertools
import sys
N=int(eval(input()))
S=[int(eval(input())) for _ in range(N)]
ans=0
if sum(S)%10!=0:
print((sum(S)))
sys.exit()
i=N-1
while True:
if ans!=0 or i==0:
break
for j in itertools.combinations(S,i):
s=sum(j)
if s%10!=0:
ans=max(ans,s)
i-=1
print(ans) | import sys
N=int(eval(input()))
S=[int(eval(input())) for _ in range(N)]
S.sort()
ans=sum(S)
if ans%10!=0:
print(ans)
sys.exit()
else:
for i in range(N):
if S[i]%10!=0:
print((ans-S[i]))
sys.exit()
else:
print((0)) | p03699 |
N=int(eval(input()))
item = [int(eval(input())) for i in range(N)]
ans=0
for i in range(2 ** N):
out = 0
for j in range(N): # このループが一番のポイント
if (i >> j) & 1: # 順に右にシフトさせ最下位bitのチェックを行う
out+=item[j] # フラグが立っていたら 加算する
if str(out)[-1]=='0':
out = 0
ans=max(ans,out)
print(ans) | N=int(eval(input()))
items = [int(eval(input())) for i in range(N)]
tot=sum(items)
ans=0
if tot%10!=0:
ans=tot
else:
items.sort()
for i in range(N):
if items[i]%10!=0:
ans=tot-items[i]
break
print(ans) | p03699 |
_,*l=list(map(int,open(0).read().split()));s=sum(l)
print((0 if all(i%10<1 for i in l) else s-min(i for i in l if i%10)*(s%10<1))) | _,*l=list(map(int,open(0)));s=sum(l)
print((0 if all(i%10<1 for i in l) else s-min(i for i in l if i%10)*(s%10<1))) | p03699 |
n=int(eval(input()))
li=[]
for i in range(n):
li.append(int(eval(input())))
pl=[0]
for i in range(2**n):
point=0
for j in range(n):
if ((i>>j)&1):
point+=li[j]
if point%10!=0:
pl.append(point)
pl.sort(reverse=True)
for i in pl:
if i%10!=0:
print(i)
break
else:
print((0))
| n=int(eval(input()))
li=[]
for i in range(n):
li.append(int(eval(input())))
out=sum(li)
if out%10!=0:
print(out)
else:
li.sort()
for i in li:
if i%10!=0:
print((out-i))
break
else:
print((0)) | p03699 |
n = int(eval(input()))
s = [int(eval(input())) for _ in range(n)]
sum = [0]
for i in range(n):
temp = []
for x in sum:
temp.append(x)
temp.append(x+s[i])
sum = temp[::]
dp = [i for i in sum if i % 10 != 0]
print((max(dp) if dp != [] else '0')) | n = int(eval(input()))
s = sorted([int(eval(input())) for _ in range(n)])
if sum(s) % 10 != 0:
print((sum(s)))
quit()
else:
for i in s:
if i % 10 != 0:
s.remove(i)
print((sum(s)))
quit()
print('0') | p03699 |
N = int(eval(input()))
s = [int(eval(input())) for _ in range(N)]
ans = 0
for i in range(2**N):
correct = []
su = 0
for j in range(N):
if ((i >> j) & 1):
su += s[j]
if su % 10 == 0:
su = 0
ans = max(ans,su)
print(ans)
| N = int(eval(input()))
s = [int(eval(input())) for _ in range(N)]
s.sort()
ans = sum(s)
if ans % 10 != 0:
print(ans)
else:
for i in range(N):
if s[i] % 10 != 0:
print((ans - s[i]))
exit()
print((0))
| p03699 |
n = int(eval(input()))
s = [int(eval(input())) for _ in range(n)]
# bit全探索
s_max = 0
for bit in range(1<<n):
s_tmp = 0
for i in range(n):
if bit >> i & 1:
s_tmp += s[i]
if s_tmp % 10 == 0:
s_tmp = 0
s_max = max(s_max, s_tmp)
print(s_max) | n = int(eval(input()))
s = [int(eval(input())) for _ in range(n)]
s.sort()
s_max = sum(s)
if s_max % 10 != 0:
print(s_max)
exit()
else:
for i in s:
if i % 10 != 0:
print((s_max - i))
exit()
print((0)) | p03699 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.