input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
a = []
for _ in range(5):
x = int(eval(input()))
a.append(x if x>= 40 else 40)
print((sum(a)//5)) | scores = [int(eval(input())) for _ in range(5)]
print((sum([(score < 40) * 40 + (score >= 40) * score for score in scores]) // 5)) | p00515 |
from collections import defaultdict as ddic, deque
from itertools import combinations, permutations, product
import sys
sys.setrecursionlimit(10**6)
stdout = sys.stdout
rr = lambda: input().strip()
rri = lambda: int(input())
rrm = lambda: list(map(int, input().strip().split()))
def solve(N, A):
memo = {}
def dp(i, color):
if i == N: return 0
if (i, color) in memo:
return memo[i, color]
if color == 1: # black
# no white
ans = dp(i+1, 1) + (A[i] != color)
else:
ans = min(dp(i+1, 0), dp(i+1, 1)) + (A[i] != color)
memo[i, color] = ans
return ans
return min(dp(0, 0), dp(0, 1))
###
N = rri()
S = rr()
A = [1 if c == '#' else 0 for c in S]
print(solve(N, A))
| from collections import defaultdict as ddic, deque
from itertools import combinations, permutations, product
import sys
sys.setrecursionlimit(10**6)
stdout = sys.stdout
rr = lambda: input().strip()
rri = lambda: int(input())
rrm = lambda: list(map(int, input().strip().split()))
def solve(N, A):
dp0 = [0] * (N+1)
dp1 = [0] * (N+1)
for i in range(N-1, -1, -1):
for color in (0, 1):
if color == 1:
ans = dp1[i+1] + (A[i] != color)
else:
ans = min(dp0[i+1], dp1[i+1]) + (A[i] != color)
if color == 0:
dp0[i] = ans
else:
dp1[i] = ans
return min(dp0[0], dp1[0])
###
N = rri()
S = rr()
A = [1 if c == '#' else 0 for c in S]
print(solve(N, A))
| p03063 |
N, M = list(map(int, input().split()))
a = [sorted(list(map(int, input().split()))[1:]) for _ in range(N)]
b = [i for i in range(1, M + 1)]
c = [i for i in range(1, M + 1)]
for i in range(N):
for j in range(len(b)):
if (not b[j] in a[i]) and b[j] in c:
c.remove(b[j])
print((len(c)))
| N, M = list(map(int, input().split()))
a = [list(map(int, input().split()))[1:] for _ in range(N)]
b = [i for i in range(1, M + 1)]
c = [i for i in range(1, M + 1)]
for i in range(N):
for j in range(M):
if b[j] in c and (not b[j] in a[i]):
c.remove(b[j])
print((len(c)))
| p03126 |
n, m = list(map(int,input().split()))
a = []
for i in range(n):
a += list(i for i in (list(map(int,input().split() ))))[::-1]
a.pop(-1)
print((sum([1 if a.count(i) == n else 0 for i in range(m+1)]))) | n, m = list(map(int,input().split()))
s = set(range(1,m+1))
for i in range(n):
_,*a = list(map(int,input().split()))
s &= set(a) # 集合の積
print((len(s))) | p03126 |
N, M = list(map(int, input().split()))
all_dish = []
for n in range(N):
K_n_list = list(map(int, input().split()))
del K_n_list[0]
for K_n_list_num in K_n_list:
all_dish.append(K_n_list_num)
prefer_dish = []
dish_kind = list(set(all_dish))
prefer_dish = [dish_kind_num for dish_kind_num in dish_kind if all_dish.count(dish_kind_num) == N]
print((len(prefer_dish))) | ii=lambda:int(eval(input()))
miis=lambda:list(map(int,input().split()))
lmiis=lambda:list(map(int,input().split()))
n,m=miis()
k=lmiis()
st=set(k[1:])
for i in range(n-1):
ki=lmiis()
st=st&set(ki[1:])
print((len(st))) | p03126 |
# coding: utf-8
import sys
# import bisect
# import math
# import itertools
# import numpy as np
"""Template"""
class IP:
"""
入力を取得するクラス
"""
def __init__(self):
self.input = sys.stdin.readline
def I(self):
"""
1文字の取得に使います
:return: int
"""
return int(self.input())
def S(self):
"""
1文字の取得(str
:return: str
"""
return self.input()
def IL(self):
"""
1行を空白で区切りリストにします(int
:return: リスト
"""
return list(map(int, self.input().split()))
def SL(self):
"""
1行の文字列を空白区切りでリストにします
:return: リスト
"""
return list(map(str, self.input().split()))
def ILS(self, n):
"""
1列丸々取得します(int
:param n: 行数
:return: リスト
"""
return [int(self.input()) for _ in range(n)]
def SLS(self, n):
"""
1列丸々取得します（str
:param n: 行数
:return: リスト
"""
return [self.input() for _ in range(n)]
def SILS(self, n):
"""
Some Int LineS
横に複数、縦にも複数
:param n: 行数
:return: list
"""
return [self.IL() for _ in range(n)]
def SSLS(self, n):
"""
Some String LineS
:param n: 行数
:return: list
"""
return [self.SL() for _ in range(n)]
class Idea:
def __init__(self):
pass
def HF(self, p):
"""
Half enumeration
半分全列挙です
pの要素の和の組み合わせを作ります。
ソート、重複削除行います
:param p: list : 元となるリスト
:return: list : 組み合わせられた和のリスト
"""
return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))
def Bfs2(self, a):
"""
bit_full_search2
bit全探索の改良版
全探索させたら2進数のリストと10進数のリストを返す
:return: list２つ : １個目 2進数(16桁) 2個目 10進数
"""
# 参考
# https://blog.rossywhite.com/2018/08/06/bit-search/
# https://atcoder.jp/contests/abc105/submissions/4088632
value = []
for i in range(1 << len(a)):
output = []
for j in range(len(a)):
if self.bit_o(i, j):
"""右からj+1番目のiが1かどうか判定"""
# output.append(a[j])
output.append(a[j])
value.append([format(i, 'b').zfill(16), sum(output)])
value.sort(key=lambda x: x[1])
bin = [value[k][0] for k in range(len(value))]
val = [value[k][1] for k in range(len(value))]
return bin, val
def S(self, s, r=0, m=-1):
"""
ソート関係行います。色々な設定あります。
:param s: 元となるリスト
:param r: reversするかどうか 0=False 1=True
:param m: （2次元配列）何番目のインデックスのソートなのか
:return: None
"""
r = bool(r)
if m == -1:
s.sort(reverse=r)
else:
s.sort(reverse=r, key=lambda x: x[m])
def bit_n(self, a, b):
"""
bit探索で使います。0以上のときにTrue出します
自然数だからn
:param a: int
:param b: int
:return: bool
"""
return bool((a >> b & 1) > 0)
def bit_o(self, a, b):
"""
bit探索で使います。1のときにTrue出すよ
oneで1
:param a: int
:param b: int
:return: bool
"""
return bool(((a >> b) & 1) == 1)
def ceil(self, x, y):
"""
Round up
小数点切り上げ割り算
:param x: int
:param y: int
:return: int
"""
return -(-x // y)
def ave(self, a):
"""
平均を求めます
:param a: list
:return: int
"""
return sum(a) / len(a)
def gcd(self, x, y):
if y == 0:
return x
else:
return self.gcd(y, x % y)
"""ここからメインコード"""
def main():
# 1文字に省略
r, e = range, enumerate
ip = IP()
id = Idea()
"""この下から書いてね"""
n, m = ip.IL()
res = [[False for _ in r(m)] for _ in r(n)]
for i in r(n):
o = ip.IL()
for j, x in e(o):
if j != 0:
res[i][x - 1] = True
ans = 0
for i in r(m):
rr = 0
for j in r(n):
if res[j][i]:
rr += 1
if rr == n:
ans += 1
print(ans)
main()
| n, m = list(map(int, input().split()))
res = [[False for _ in range(m)] for _ in range(n)]
for i in range(n):
o = list(map(int, input().split()))
for j, x in enumerate(o):
if j != 0:
res[i][x - 1] = True
ans = 0
res = list(zip(*res))
for i, x in enumerate(res):
if all(x):
ans += 1
print(ans)
| p03126 |
n, m = list(map(int, input().split()))
res = [[False for _ in range(m)] for _ in range(n)]
for i in range(n):
o = list(map(int, input().split()))
for j, x in enumerate(o):
if j != 0:
res[i][x - 1] = True
res = list(zip(*res))
ans = sum(1 for x in res if all(x))
print(ans)
| n, m = list(map(int, input().split()))
res = [0] * m
for i in range(n):
o = list(map(int, input().split()))
for j, x in enumerate(o):
if j != 0:
res[x - 1] += 1
ans = sum(1 for x in res if x == n)
print(ans)
| p03126 |
n,m=list(map(int,input().split()));d=[i+1 for i in range(m)]
def listdup(a,b):
x=[]
for i in a:
if i in b:x.append(i)
return sorted(x)
for i in range(n):
a=list(map(int,input().split()));a=a[1:];a.sort()
d=listdup(a,d)
print((len(d))) | n,m=list(map(int,input().split()))
s=set(list(map(int,input().split()))[1:])
for i in range(n-1):
s&=set(list(map(int,input().split()))[1:])
print((len(s))) | p03126 |
N, M = list(map(int, input().split()))
cnt = [0] * M
for _ in range(N):
K, *A = list(map(int, input().split()))
for a in A:
cnt[a - 1] += 1
print((sum(c == N for c in cnt))) | n, m = list(map(int, input().split()))
cnt = [0] * m
for _ in range(n):
k, *A, = list(map(int, input().split()))
for a in A:
cnt[a - 1] += 1
print((sum(c == n for c in cnt))) | p03126 |
N,M = list(map(int, input().split()))
A = [0 for i in range(M+1)]
for i in range(N):
tmp = input().split()
for j in tmp[1:]:
A[int(j)] += 1
ans = len([0 for i in A if i == N])
print(ans)
| n,m = list(map(int, input().split()))
d = {}
for _ in range(n):
k = input().split()
for j in k[1:]:
if j not in d:
d[j] = 0
d[j] += 1
print((len([v for v in list(d.values()) if v == n]))) | p03126 |
n, m = list(map(int, input().split()))
count = 0
kind = [0 for i in range(m)]
for i in range(n):
anketo = list(map(int, input().split()))
for j in range(1, len(anketo)):
kind[anketo[j]-1] += 1
for i in kind:
if i == n:
count += 1
print(count)
| n, m = list(map(int, input().split()))
c = list(map(int, input().split()))
A = set(c[1:])
for i in range(n-1):
t = list(map(int, input().split()))
A &= set((t[1:]))
print((len(A))) | p03126 |
N, M = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]
A = [flatten for inner in A for flatten in inner[1:]]
#print(A)
import collections
A_cnt = collections.Counter(A)
print((sum([l[1]==N for l in A_cnt.most_common()])))
| N,M = list(map(int,input().split()))
_, *A = list(map(int,input().split()))
s = set(A)
for i in range(N-1):
_, *B = list(map(int,input().split()))
s &= set(B)
print((len(s))) | p03126 |
n,m=list(map(int,input().split()))
a=[0]*m
b=[list(map(int,input().split())) for _ in range(n) ]
for i in range(n):
c=b[i][0]
for j in range(1,c+1):
a[b[i][j]-1]+=1
print((a.count(n))) | n,m=list(map(int,input().split()))
c=set(range(1,m+1))
for i in range(n):
a=list(map(int,input().split()))
b=set(a[1:])
c=b&c
print((len(c))) | p03126 |
q=set(map(str,list(range(31))))
for s in open(0).readlines()[1:]:
t=set(s.split()[1:])
q&=t
print((len(q))) | a,b=list(map(int,input().split()))
for i in range(a):
n,*a=list(map(int,input().split()))
if i==0:
l=a
else:
l=set(a)&set(l)
print((len(l))) | p03126 |
a,b=list(map(int,input().split()))
for i in range(a):
n,*a=list(map(int,input().split()))
if i==0:
l=a
else:
l=set(a)&set(l)
print((len(l))) | a,b=list(map(int,input().split()))
for i in range(a):
if i==0:
x=set(input().split()[1:])
else:
x=x&set(input().split()[1:])
print((len(x))) | p03126 |
def read():
return int(eval(input()))
def reads():
return list(map(int, input().split()))
n,m = reads()
a = []
r = []
for i in range(n):
a.append(reads())
for i in range(n):
for j in range(1,a[i][0]+1):
r.append(a[i][j])
ans = 0
for i in set(r):
if r.count(i) == n:
ans += 1
print(ans) | def read():
return int(eval(input()))
def reads():
return list(map(int, input().split()))
n, m = reads()
a = set(input().split()[1:])
for _ in range(n - 1):
a &= set(input().split()[1:])
print((len(a))) | p03126 |
n, m = list(map(int, input().split()))
k = [list(map(int, input().split())) for i in range(n)]
ans = 0
for i in range(1, m+1):
cnt = 0
for p in k:
if i in p[1:]:
cnt += 1
if cnt == n:
ans += 1
print(ans) | n,m = list(map(int,input().split()))
cnt = [0]*(m+1)
for i in range(n):
x = list(map(int, input().split()))
for p in x[1:]:
cnt[p] += 1
print((cnt.count(n))) | p03126 |
import sys
import collections as c
input = sys.stdin.readline
def main():
ans = 0
N, M = list(map(int, input().split()))
a = []
for _ in range(N):
a += list(map(int, input().split()))[1:]
co = c.Counter(a)
for k, v in list(co.items()):
if v == N:
ans += 1
print(ans)
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
def main():
ans = 0
N, M = list(map(int, input().split()))
f = set(range(1,M+1))
for _ in range(N):
a = set(list(map(int, input().split()))[1:])
f.intersection_update(a)
print((len(f)))
if __name__ == '__main__':
main() | p03126 |
N,M=list(map(int,input().split()))
C = set(list(range(1,M+1)))
for _ in range(N):
L=list(map(int,input().split()))
A=L[1:]
C=C&set(A)
print((len(C))) | N,M=list(map(int,input().split()))
K=[0]*M
a=0
for i in range(N):
A=list(map(int,input().split()))
for j in A[1:]:
K[j-1]+=1
for i in K:
if i==N:
a+=1
print(a) | p03126 |
a,b=list(map(int,input().split()))
c=list(map(int,input().split()))[1:]
#print(c)
for _ in range(a-1):
#print(range(a))
d=list(map(int,input().split()))[1:]
#print(d)
c=set(c)&set(d)
#print(c)
print((len(c))) | a,b=list(map(int,input().split()))
c=list(map(int,input().split()))[1:]
for _ in range(a-1):c=set(c)&set(list(map(int,input().split()))[1:])
print((len(c))) | p03126 |
import collections
N, M = list(map(int, input().split()))
likes = []
for i in range(N):
x = list(map(int, input().split()))
_ = x.pop(0)
likes += x
col = collections.Counter(likes)
count = 0
for k, v in list(col.items()):
if v == N:
count += 1
print(count) |
n, m = list(map(int, input().split()))
likes = [0] * m
for i in range(n):
k, *a = list(map(int, input().split()))
for j in a:
likes[j-1] += 1
count = 0
for i in likes:
if i == n:
count += 1
print(count) | p03126 |
N,M = list(map(int,input().split()))
nes = []
count = 0
for i in range(N) :
li = list(map(int,input().split()))
nes.append(li)
favorite = [0] * M
for i in range(N) :
for j in range(1,nes[i][0]+1) :
favorite[nes[i][j]-1] += 1
for i in range(M) :
if favorite[i] == N :
count+=1
print(count) | #template
def inputlist(): return [int(k) for k in input().split()]
#template
N,M = inputlist()
ans = [0]*(M+1)
c =0
for i in range(N):
A = inputlist()
K = A[0]
Aa = A[1:]
for j in range(K):
ans[Aa[j]] +=1
for i in range(1,M+1):
if ans[i] == N:
c+=1
print(c) | p03126 |
from collections import Counter
n, m = list(map(int, input().split()))
L = []
cnt = 0
for _ in range(n):
tmp = input().split()
a = tmp[1:]
L.extend(a)
c = Counter(L)
for k, v in list(c.items()):
if v==n:
cnt += 1
print(cnt) | n, m = list(map(int, input().split()))
foods = [0] * m
for _ in range(n):
k, *a = input().split()
for food in a:
foods[int(food)-1] += 1
print((foods.count(n)))
| p03126 |
import functools
print((len(functools.reduce(lambda x, y: x&y,[set(input().split()[1:]) for _ in [0]*int(input().split()[0])])))) | print((len(set.intersection(*[set(input().split()[1:]) for _ in [0]*int(input().split()[0])])))) | p03126 |
from functools import reduce
N, M = list(map(int, input().split()))
prod = set(range(1, M + 1))
for _ in range(N):
prod &= set(list(map(int, input().split()))[1:])
ans = len(prod)
print(ans) | # 入力
N, M = list(map(int, input().split()))
K, A = list(zip(*(
(int(t[0]), list(map(int, t[1].split())))
for t in (input().split(maxsplit=1) for _ in range(N))
)))
# 素直にカウント
ans = sum(
all(k in a for a in A)
for k in range(1, M + 1)
)
# 出力
print(ans)
| p03126 |
from functools import reduce
n, m = list(map(int, input().split()))
k = [list(map(int, input().split()))[1:] for _ in range(n)]
print((len(reduce(lambda a,b: a&b, [set(kk) for kk in k]))))
| n, m = list(map(int, input().split()))
s = [0] * m
for i in range(n):
a = list(map(int, input().split()))[1:]
for x in a:
s[x-1] += 1
ans = 0
for x in s:
if x == n:
ans += 1
print(ans)
| p03126 |
Tmp = []
Tmp = input().rstrip().split(' ')
nN = int(Tmp[0])
nM = int(Tmp[1])
nData = [[ 0 for i in range(2)] for j in range(nM)]
for i in range(nM):
nData[i][0]=i+1
for i in range(nN):
Tmp = input().rstrip().split(' ')
nK = int(Tmp[0])
nTmp =[ 0 for j in range(nK)]
for j in range(nK):
nTmp[j] = int(Tmp[j+1])
# print(nTmp)
for j in range(nM):
if nData[j][0] in nTmp:
nData[j][1] += 1
nAns=0
for i in range(nM):
if nData[i][1]==nN:
nAns += 1
print(nAns)
| mp = []
Tmp = input().rstrip().split(' ')
nN = int(Tmp[0])
nM = int(Tmp[1])
nF = [ 0 for i in range(nM)]
for i in range(nN):
Tmp = input().rstrip().split(' ')
nTmpN = int(Tmp[0])
for j in range(nTmpN):
nCnt = int(Tmp[j+1]) - 1
nF[nCnt] += 1
nAns = 0
for i in range(nM):
nTmpN = nF[i]
if nTmpN == nN:
nAns += 1
print(nAns)
| p03126 |
from collections import Counter
n, m = list(map(int, input().split()))
food_arr = []
total = 0
for i in range(n):
food_arr += list(map(int, input().split()[1:]))
counter = Counter(food_arr)
for key, value in list(counter.items()):
if value == n:
total += 1
print(total) | N, M = list(map(int, input().split()))
se = set(range(1,M+1))
for _ in range(N):
k, *A = list(map(int, input().split()))
se &= set(A)
print((len(se))) | p03126 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
a,b = LI()
if a%b == 0:
print((a+b))
else:
print((b-a))
return
#B
def B():
n,m = LI()
d = defaultdict(int)
for i in range(n):
l = LI()
for j in range(1,len(l)):
d[l[j]] += 1
ans = 0
for i in list(d.values()):
if i == n:
ans += 1
print(ans)
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
B()
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,m = LI()
ans = [1]*m
for i in range(n):
q = LI()
for j in q[1:]:
ans[j-1] += 1
for j in range(m):
ans[j] -= 1
res = 0
for i in ans:
if i == 1:
res += 1
print(res)
return
#Solve
if __name__ == "__main__":
solve()
| p03126 |
N,M=list(map(int,input().split()))
A=[list(map(int,input().split()[1:])) for i in range(N)]
food=set(range(1,M+1))
for i in range(N):
food&=set(A[i])
print((len(food))) | N,M=list(map(int,input().split()))
food=set(range(1,M+1))
for i in range(N):
K,*A=list(map(int,input().split()))
food&=set(A)
print((len(food))) | p03126 |
n,m = list(map(int,input().split()))
a = [list(map(int,input().split())) for i in range(n)]
ans = 0
cnt = 0
for i in range(1,m+1):
for j in range(n):
for k in range(1,a[j][0]+1):
if a[j][k] == i:
cnt += 1
break
if cnt == n:
ans += 1
cnt = 0
print(ans) | n,m = list(map(int,input().split()))
a = [list(map(int,input().split())) for i in range(n)]
ans = 0
cnt = 0
for i in range(1,m+1):
for j in a:
if i in j[1:]:
cnt += 1
if cnt == n:
ans += 1
cnt = 0
print(ans) | p03126 |
n,m = list(map(int, input().split()))
l = []
for i in range(n): #Kを除く好きな食べ物を取得
a = [int(_) for _ in input().split()]
l.append(a[1:a[0]+1])
y = [] #全部好きな人を要素’1’として格納
for j in range(1,m+1):
x = 0
for k in range(n):
if j in l[k]:
x += 1
if x == n:
y.append(1)
print((len(y)))
| n,m = list(map(int, input().split()))
l = []
for i in range(n): #Kを除く好きな食べ物を取得
a = [int(_) for _ in input().split()]
l.append(a[1:a[0]+1])
y = [] #全部好きな人を要素’1’として格納
for j in range(1,m+1):
x = 0
for k in range(n):
if j in l[k]:
x += 1
if x == n: #これが全部好きの条件
y.append(1)
print((len(y)))
| p03126 |
n,m=list(map(int,input().split()));a=[]
for _ in[0]*n:a.extend(list(map(int,input().split()))[1:])
print((sum(n==a.count(i+1)for i in range(m)))) | I=lambda:list(map(int,input().split()))
n,m=I()
a=[]
for _ in[0]*n:a.extend(I()[1:])
print((sum(n==a.count(i+1)for i in range(m)))) | p03126 |
N,M = list(map(int,input().split()))
list_list = [list(map(int,input().split())) for i in range(N)]
count = 0
for i in range(1,M+1):
flg = True
for list in list_list:
if i in list[1:]:
continue
else:
flg = False
break
if flg == True:
count += 1
print(count)
| N, M = list(map(int, input().split()))
a = set(list(map(int, input().split()))[1:])
for i in range(N - 1):
a &= set(list(map(int, input().split()))[1:])
print((len(a)))
| p03126 |
N, M = list(map(int, input().split()))
K = [0] * N
A = [[0 for j in range(M)] for i in range(N)]
for i in range(N):
inpt = list(map(int, input().split()))
K[i] = inpt[0]
for j in range(1, K[i]+1, 1):
A[i][j-1] = inpt[j]
count = 0
for j in range(1, M+1, 1):
likecount = 0
for i in range(N):
for k in range(K[i]):
if A[i][k] == j:
likecount += 1
if likecount == N:
count += 1
print(count)
| N, M = list(map(int, input().split()))
K = [0] * N
A = [list(map(int, input().split())) for i in range(N)]
count = 0
for i in range(1, M+1, 1):
likecount = 0
for j in range(N):
for k in range(1, A[j][0]+1, 1):
if A[j][k] == i:
likecount += 1
if likecount == N:
count += 1
print(count)
| p03126 |
N, M = list(map(int, input().split()))
K = [0] * N
A = [list(map(int, input().split())) for i in range(N)]
count = 0
for i in range(1, M+1, 1):
likecount = 0
for j in range(N):
for k in range(1, A[j][0]+1, 1):
if A[j][k] == i:
likecount += 1
if likecount == N:
count += 1
print(count)
| N, M = list(map(int, input().split()))
likeset = set(range(1, M+1))
for _ in range(N):
a, *b = list(map(int, input().split()))
likeset &= set(b)
print((len(likeset)))
| p03126 |
from collections import defaultdict
n, m = list(map(int, input().split()))
s = []
for _ in range(n):
k, *a = list(map(int, input().split()))
s.append(a)
dd = defaultdict(int)
for l in s:
for k in l:
dd[k] += 1
print((sum(1 if v == n else 0 for k, v in list(dd.items()))))
| n, m = list(map(int, input().split()))
s = set(range(1, m+1))
for _ in range(n):
k, *a = list(map(int, input().split()))
s &= set(a)
print((len(s))) | p03126 |
n, m = list(map(int, input().split()))
S = set(range(1, m+1))
for i in range(n):
k, *a = list(map(int, input().split()))
S &= set(a)
print((len(S)))
| n, m = list(map(int, input().split()))
s = set(range(1, m+1))
for i in range(n):
k, *a = list(map(int, input().split()))
s &= set(a)
print((len(s)))
| p03126 |
n, m = list(map(int, input().split()))
ans = [0] * m
for _ in range(n):
k, *a = [int(x) for x in input().split()]
for i in a:
ans[i-1] += 1
tmp = 0
for a in ans:
if a == n:
tmp += 1
print(tmp)
| n, m = list(map(int, input().split()))
ans = set(map(str, list(range(1, m+1))))
for _ in range(n):
ans = ans & set(input().split()[1:])
print((len(ans)))
| p03126 |
a = list(map(int,input().split()))
cnt = [0,] *(a[1]+1)
for i in range(a[0]):
suki = list(map(int,input().split()))
for j in range(1, len(suki)):
cnt[suki[j]]+=1
ans = 0
for i in range(1, a[1]+1):
if cnt[i] == a[0]:
ans+=1
print((str(ans))) | import sys
readline = sys.stdin.readline
a = list(map(int,input().split()))
N = a[0]
M = a[1]
cnt = [0,]*(M+1)
ans = 0
for i in range(N):
K, *like, = readline().split()
K = int(K)
like = [int(s) for s in like]
for j in range(K):
cnt[like[j]] += 1
for i in range(1, M+1):
if cnt[i] == N:
ans += 1
print((str(ans)))
| p03126 |
N, M = list(map(int,input().split()))
A = [list(map(int,input().split())) for _ in range(N)]
ans = 0
for i in range(1,M+1):
cnt = 0
for a in A:
if(i in a[1:]):
cnt += 1
if(cnt == N):
ans += 1
print(ans) | N, M = list(map(int,input().split()))
A = [list(map(int,input().split())) for _ in range(N)]
tmp = [0]*(M+1)
for a in A:
for aa in a[1:]:
tmp[aa] += 1
ans = 0
for t in tmp:
if t == N:
ans += 1
print(ans) | p03126 |
from collections import Counter
n,m = list(map(int,input().split()))
many =[]
for i in range(n):
a = list(map(int,input().split()))
for j in range(1,a[0]+1):
many.append(a[j])
ans = Counter(many).most_common()
count = 0
for i in range(len(ans)):
if ans[i][1] == n:
count += 1
print(count) | n,m = list(map(int,input().split()))
data = [0 for i in range(m)]
for i in range(n):
k,*a = list(map(int,input().split()))
for x in a:
data[x-1] += 1
ans = 0
for i in range(m):
if data[i] == n:
ans += 1
print(ans) | p03126 |
N, M = list(map(int,input().split()))
foods = [0 for m in range(M)]
for n in range(N):
A = list(map(int, input().split()))
for a in A[1:]:
foods[a-1]+=1
foods_ans = [f for f in foods if f == N]
#print(foods)
#print(foods_ans)
print((len(foods_ans)))
| N, M = list(map(int,input().split()))
foods = [0 for m in range(M)]
for n in range(N):
A = list(map(int, input().split()))
for a in A[1:]:
foods[a-1]+=1
print((len([f for f in foods if f == N])))
| p03126 |
N,M = list(map(int, input().split()))
KA = []
a = []
ans = 0
for i in range(N):
KA = list(map(int, input().split()))
A = KA[1:]
a += A
for j in range(1,M+1):
if a.count(j) == N:
ans += 1
print(ans)
| Ans_list = []
Ans = 0
N,M = list(map(int, input().split()))
for i in range(N):
KA = list(map(int, input().split()))
Mylist = KA[1:]
for j in range(len(Mylist)):
Ans_list.append(Mylist[j])
for i in range(M+1):
if Ans_list.count(i)==N:
Ans += 1
print(Ans)
| p03126 |
N,M = list(map(int,input().split()))
list = [list(map(int,input().split())) for x in range(N)]
#一列目削除
for i in range(0,N):
list[i].pop(0)
stock = []
#解答が全リストにあるか探索
for i in range(0,N):
for j in range(0,len(list[i])):
cnt = 0
for k in range(0,N):
if list[i][j] in list[k]:
cnt += 1
if cnt == N:
stock.append(list[i][j])
if N == 1:
stock = list[i]
print((len(set(stock)))) | N,M = list(map(int,input().split()))
M_kinds = set(range(1,M+1))
for i in range(N):
a,*b = list(map(int,input().split()))
M_kinds &= set(b)
print((len(M_kinds))) | p03126 |
n, m = list(map(int, input().split()))
ref = {}
a = list(map(int, input().split()))
del a[0]
a = set(a)
ref = a
for i in range (n - 1):
a = list(map(int, input().split()))
del a[0]
a = set(a)
ref = ref & a
print((len(ref))) | n, m = list(map(int, input().split()))
cnt = [0]*m
ans = 0
for i in range(n):
k, *a = list(map(int, input().split()))
for j in a:
cnt[j - 1] += 1
for i in cnt:
if i == n:
ans += 1
print(ans) | p03126 |
n, m = list(map(int, input().split()))
ka = [list(map(int, input().split())) for i in range(n)]
ans = [0] * m
for i in range(n):
for j in range(1, len(ka[i])):
for k in range(1, m+1):
if ka[i][j] == k:
ans[k-1] += 1
break
print((ans.count(n))) | n, m = list(map(int, input().split()))
ka = [list(map(int, input().split())) for i in range(n)]
ans = [0] * m
for i in range(n):
for j in ka[i][1:]:
ans[j-1] += 1
print((ans.count(n))) | p03126 |
class Avltree:
def __init__(self, key=None):
self.key = key
self.left = None
self.right = None
self.balance = "Even"
def search(self, key):
node = self
while node is not None:
if node.key == key:
return node
if node.key > key:
node = node.left
elif node.key < key:
node = node.right
return None
def search_lower(self, key, key_lower):
node = self
if node.key is None:
return key_lower
ans = key_lower
while node is not None:
if node.key < key:
if ans < node.key:
ans = node.key
node = node.right
elif node.key >= key:
node = node.left
return ans
def search_higher(self, key, key_higher):
node = self
if node.key is None:
return key_higher
ans = key_higher
while node is not None:
if node.key > key:
if ans > node.key:
ans = node.key
node = node.left
elif node.key <= key:
node = node.right
return ans
def end_lower(self, end_lower_key):
node = self
while node.left is not None:
node = node.left
return node.key
def end_higher(self, end_higher_key):
node = self
while node.right is not None:
node = node.right
return node.key
def DoubleRightRotation(self):
tl = self.left
self.left = tl.right.right
tl.right.right = self
tlr = tl.right
tl.right = tlr.left
tlr.left = tl
if tlr.balance == "Left":
tlr.right.balance = "Right"
tlr.left.balance = "Even"
elif tlr.balance == "Right":
tlr.right.balance = "Even"
tlr.left.balance = "Left"
elif tlr.balance == "Even":
tlr.right.balance = "Even"
tlr.left.balance = "Even"
tlr.balance = "Even"
return tlr
def DoubleLeftRotation(self):
tr = self.right
self.right = tr.left.left
tr.left.left = self
trl = tr.left
tr.left = trl.right
trl.right = tr
if trl.balance == "Right":
trl.left.balance = "Left"
trl.right.balance = "Even"
elif trl.balance == "Left":
trl.left.balance = "Even"
trl.right.balance = "Right"
elif trl.balance == "Even":
trl.left.balance = "Even"
trl.right.balance = "Even"
trl.balance = "Even"
return trl
def SingleLeftRotation(self):
tr = self.right
tr.balance = "Even"
self.balance = "Even"
self.right = tr.left
tr.left = self
return tr
def SingleRightRotation(self):
tl = self.left
tl.balance = "Even"
self.balance = "Even"
self.left = tl.right
tl.right = self
return tl
def replace(self, p, v):
if p.left == self:
p.left = v
else:
p.right = v
def insert(self, key):
if self.key is None:
self.key = key
return self
if key < self.key:
if self.left is None:
self.left = Avltree(key)
else:
self.left.insertx(self, key)
elif key > self.key:
if self.right is None:
self.right = Avltree(key)
else:
self.right.insertx(self, key)
else: # key == self.key:
pass # do not overwrite
def insertx(self, p, key):
node = self
s = []
while True:
if node.key > key:
s.append((node, -1))
if node.left is None:
node.left = Avltree(key)
node = node.left
break
else:
node = node.left
elif node.key < key:
s.append((node, 1))
if node.right is None:
node.right = Avltree(key)
node = node.right
break
else:
node = node.right
while len(s) != 0:
node, direct = s.pop()
if len(s) != 0:
par = s[-1][0]
else:
par = p
if direct == -1:
if node.balance == "Right":
node.balance = "Even"
break
elif node.balance == "Even":
node.balance = "Left"
elif node.balance == "Left":
if node.left.balance == "Right":
node.replace(par, node.DoubleRightRotation())
elif node.left.balance == "Left":
node.replace(par, node.SingleRightRotation())
break
elif direct == 1:
if node.balance == "Left":
node.balance = "Even"
break
elif node.balance == "Even":
node.balance = "Right"
elif node.balance == "Right":
if node.right.balance == "Left":
node.replace(par, node.DoubleLeftRotation())
elif node.right.balance == "Right":
node.replace(par, node.SingleLeftRotation())
break
def to_s(self):
return self.key
def left_s(self):
if self.left is None:
return None
return (self.left).key
def right_s(self):
if self.right is None:
return None
return (self.right).key
n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
l=[0]*n
for i in range(n):
l[a[i]-1]=i
root=Avltree()
for i in range(n):
root.insert(l[i])
ans+=(i+1)*(l[i]-root.search_lower(l[i],-1))*(root.search_higher(l[i],n)-l[i])
print(ans) | class Avltree:
def __init__(self, key=None):
self.key = key
self.left = None
self.right = None
self.balance = "Even"
def search(self, key):
node = self
while node is not None:
if node.key == key:
return node
if node.key > key:
node = node.left
elif node.key < key:
node = node.right
return None
def search_lower(self, key, key_lower):
node = self
if node.key is None:
return key_lower
ans = key_lower
while node is not None:
if node.key < key:
if ans < node.key:
ans = node.key
node = node.right
elif node.key >= key:
node = node.left
return ans
def search_higher(self, key, key_higher):
node = self
if node.key is None:
return key_higher
ans = key_higher
while node is not None:
if node.key > key:
if ans > node.key:
ans = node.key
node = node.left
elif node.key <= key:
node = node.right
return ans
def end_lower(self, end_lower_key):
node = self
while node.left is not None:
node = node.left
return node.key
def end_higher(self, end_higher_key):
node = self
while node.right is not None:
node = node.right
return node.key
def DoubleRightRotation(self):
tl = self.left
self.left = tl.right.right
tl.right.right = self
tlr = tl.right
tl.right = tlr.left
tlr.left = tl
if tlr.balance == "Left":
tlr.right.balance = "Right"
tlr.left.balance = "Even"
elif tlr.balance == "Right":
tlr.right.balance = "Even"
tlr.left.balance = "Left"
elif tlr.balance == "Even":
tlr.right.balance = "Even"
tlr.left.balance = "Even"
tlr.balance = "Even"
return tlr
def DoubleLeftRotation(self):
tr = self.right
self.right = tr.left.left
tr.left.left = self
trl = tr.left
tr.left = trl.right
trl.right = tr
if trl.balance == "Right":
trl.left.balance = "Left"
trl.right.balance = "Even"
elif trl.balance == "Left":
trl.left.balance = "Even"
trl.right.balance = "Right"
elif trl.balance == "Even":
trl.left.balance = "Even"
trl.right.balance = "Even"
trl.balance = "Even"
return trl
def SingleLeftRotation(self):
tr = self.right
tr.balance = "Even"
self.balance = "Even"
self.right = tr.left
tr.left = self
return tr
def SingleRightRotation(self):
tl = self.left
tl.balance = "Even"
self.balance = "Even"
self.left = tl.right
tl.right = self
return tl
def replace(self, p, v):
if p.left == self:
p.left = v
else:
p.right = v
def insert(self, key):
if self.key is None:
self.key = key
return self
if key < self.key:
if self.left is None:
self.left = Avltree(key)
else:
self.left.insertx(self, key)
elif key > self.key:
if self.right is None:
self.right = Avltree(key)
else:
self.right.insertx(self, key)
else:
pass
def insertx(self, p, key):
node = self
s = []
while True:
if node.key > key:
s.append((node, -1))
if node.left is None:
node.left = Avltree(key)
node = node.left
break
else:
node = node.left
elif node.key < key:
s.append((node, 1))
if node.right is None:
node.right = Avltree(key)
node = node.right
break
else:
node = node.right
while len(s) != 0:
node, direct = s.pop()
if len(s) != 0:
par = s[-1][0]
else:
par = p
if direct == -1:
if node.balance == "Right":
node.balance = "Even"
break
elif node.balance == "Even":
node.balance = "Left"
elif node.balance == "Left":
if node.left.balance == "Right":
node.replace(par, node.DoubleRightRotation())
elif node.left.balance == "Left":
node.replace(par, node.SingleRightRotation())
break
elif direct == 1:
if node.balance == "Left":
node.balance = "Even"
break
elif node.balance == "Even":
node.balance = "Right"
elif node.balance == "Right":
if node.right.balance == "Left":
node.replace(par, node.DoubleLeftRotation())
elif node.right.balance == "Right":
node.replace(par, node.SingleLeftRotation())
break
def to_s(self):
return self.key
def left_s(self):
if self.left is None:
return None
return (self.left).key
def right_s(self):
if self.right is None:
return None
return (self.right).key
n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
l=[0]*n
for i in range(n):
l[a[i]-1]=i
root=Avltree()
for i in range(n):
root.insert(l[i])
ans+=(i+1)*(l[i]-root.search_lower(l[i],-1))*(root.search_higher(l[i],n)-l[i])
print(ans) | p03987 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
# 大きい数字から追加していく。そのときの連結成分の大きさだけ足される。
# union findっぽく。各成分の左端を根として持つ
N = int(eval(input()))
A = [int(x) for x in input().split()]
x_to_i = {x:i for i,x in enumerate(A)}
V = set()
root = dict()
size = dict()
def find_root(x):
y = root[x]
if x == y:
return y
ry = find_root(y)
root[x] = ry
return ry
def merge(x,y):
rx = find_root(x)
ry = find_root(y)
sx = size[rx]
sy = size[ry]
if sx > sy:
rx,ry = ry,rx
sx,sy = sy,sx
root[rx] = ry
size[ry] += sx
answer = 0
for x in range(N,0,-1):
i = x_to_i[x]
V.add(i)
size[i] = 1
root[i] = i
left = 0
right = 0
if i-1 in V:
left = size[find_root(i-1)]
merge(i-1,i)
if i+1 in V:
right = size[find_root(i+1)]
merge(i+1,i)
cnt = (left+1) * (right+1)
answer += x * cnt
print(answer) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
"""
・大きい数から挿入していく
・連結成分の両端を管理する
"""
N,*A = list(map(int,read().split()))
A = [0] + A + [0]
ind = [0] * (N+1)
for i,x in enumerate(A):
ind[x] = i
left = list(range(1,len(A)+1))
right = list(range(-1,len(A)-1))
answer = 0
for i in ind[:0:-1]:
# i番目に数を挿入
l = left[i-1]; r = right[i+1]
left[r] = l; right[l] = r
x = i - l + 1; y = r - i + 1
answer += A[i] * (x * y)
print(answer) | p03987 |
import bisect
n=int(input())
a=list(map(int,input().split()))
b=sorted([(a[i],i+1) for i in range(n)])
s=[0,n+1]
ans=0
for c,j in b:
k=bisect.bisect(s,j)
ans+=c*(s[k]-j)*(j-s[k-1])
s.insert(k,j)
print(ans)
| n=int(input())
a=list(map(int,input().split()))
def f():
s=[(0,-1)]
x=[0]*(n+1)
for i,j in enumerate(a):
while s[-1][0]>j:s.pop()
x[j]=i-s[-1][1]
s.append((j,i))
return x
l=f()
a.reverse()
r=f()
print(sum([i*l[i]*r[i] for i in a]))
| p03987 |
'''
研究室PCでの解答
'''
import math
#import numpy as np
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
mod = 10**9+7
dir = [(-1,0),(1,0),(0,-1),(0,1)]
alp = "abcdefghijklmnopqrstuvwxyz"
def main():
n = int(ipt())
ans = 0
a = [int(i) for i in ipt().split()]
pl = [-1]*(n+1)
for i,ai in enumerate(a):
pl[ai] = i+1
#Bit_Indexed_Tree
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(n+1)
#A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= n:
BIT[idx] += x
idx += idx&(-idx)
return
for i in range(1,n+1):
pi = pl[i]
ll = 0
lr = pi
bi = BIT_query(pl[i])
while ll != lr:
mid = ll+(lr-ll)//2
if BIT_query(mid) == bi:
lr = mid
else:
ll = mid+1
rl = pi
rr = n
while rl != rr:
mid = rl+(rr-rl+1)//2
if BIT_query(mid) == bi:
rl = mid
else:
rr = mid-1
# print("a",rl,lr)
ans += (pi-lr)*(rl-pi+1)*i
BIT_update(pi,1)
print(ans)
return None
if __name__ == '__main__':
main()
| '''
研究室PCでの解答
'''
import math
#import numpy as np
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
mod = 10**9+7
dir = [(-1,0),(1,0),(0,-1),(0,1)]
alp = "abcdefghijklmnopqrstuvwxyz"
class Binary_Indexed_Tree:
#Binary_Indexed_Tree
#A1 ... AnのBIT(1-indexed)
def __init__(self,n):
self.N = n
self.BIT = [0]*(n+1)
self.l2 = 2**(len(format(n,'b'))-1)
#A1 ~ Aiまでの和 O(logN)
def query(self,idx):
res_sum = 0
while idx > 0:
res_sum += self.BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
while idx <= self.N:
self.BIT[idx] += x
idx += idx&(-idx)
return
def lower_bound(self,w):
if w <= 0:
return 0
x = 0
k = self.l2
while k > 0:
if x+k <= self.N and self.BIT[x+k] < w:
w -= self.BIT[x+k]
x += k
k //= 2
return x+1
def upper_bound(self,w):
x = 0
k = self.l2
while k > 0:
if x+k <= self.N and self.BIT[x+k] <= w:
w -= self.BIT[x+k]
x += k
k //= 2
return x
def main():
n = int(ipt())
ans = 0
a = [int(i) for i in ipt().split()]
pl = [-1]*(n+1)
for i,ai in enumerate(a):
pl[ai] = i+1
bt = Binary_Indexed_Tree(n)
for i in range(1,n+1):
pi = pl[i]
bi = bt.query(pl[i])
lb = bt.lower_bound(bi)
ub = bt.upper_bound(bi)
ans += (pi-lb)*(ub-pi+1)*i
bt.update(pi,1)
print(ans)
return None
if __name__ == '__main__':
main()
| p03987 |
n = int(eval(input()))
A = list(map(int, input().split()))
P = [0]*n
for i, a in enumerate(A):
P[a-1] = i
import heapq
q = []
heapq.heapify(q)
R = [n-1]*n
for i, a in enumerate(A):
while q and q[0]*(-1) > a:
v = heapq.heappop(q)*(-1)
R[v-1] = i-1
heapq.heappush(q, a*(-1))
q = []
L = [0]*n
for j in range(n):
i = n-1-j
a = A[i]
while q and q[0]*(-1) > a:
v = heapq.heappop(q)*(-1)
L[v-1] = i+1
heapq.heappush(q, a*(-1))
#print(L)
#print(R)
ans = 0
for i in range(n):
a = i+1
l, r, p = L[i], R[i], P[i]
ans += (p-l+1)*(r-p+1)*a
print(ans) | n = int(eval(input()))
A = list(map(int, input().split()))
A = [a-1 for a in A]
P = [-1]*n
for i, a in enumerate(A):
P[a] = i
R = [n]*n
q = []
import heapq
heapq.heapify(q)
for i in range(n):
while q:
if -q[0] > A[i]:
v = -heapq.heappop(q)
R[v] = i
else:
break
heapq.heappush(q, -A[i])
L = [-1]*n
q = []
heapq.heapify(q)
for i in reversed(list(range(n))):
while q:
if -q[0] > A[i]:
v = -heapq.heappop(q)
L[v] = i
else:
break
heapq.heappush(q, -A[i])
#print(P)
#print(R)
#print(L)
ans = 0
for i in range(n):
ans += (P[i]-L[i])*(R[i]-P[i])*(i+1)
print(ans)
| p03987 |
#!/usr/bin/env python3
#AGC5 B
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = LI()
lst = [0 for i in range(n+1)]
for i in range(n):
lst[a[i]] = i
l = [0]*n
r = [0]*n
ans = 0
for i in range(1,n+1)[::-1]:
x = lst[i]
if x + 1 < n and a[x+1] > i:
R = r[x+1]
else:
R = x
if x - 1 >= 0 and a[x-1] > i:
L = l[x-1]
else:
L = x
l[R] = L
r[L] = R
ans += (x - L + 1)*(R - x + 1)*i
print(ans) | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
"""
すべてのiに対して
「a_iが最小値となる区間はいくつあるか?」を考える.
a_iより左側でa_iより小さいもののうち最もa_iに近いものをa_l
a_iより右側でa_iより小さいもののうち最もa_iに近いものをa_rとする.
最小値がa_iとなる区間は左側がl+1,l+2,...,i
右側がi,i+1,...,r-1となる区間
⇒(i-l+1)x(r-i+1)個の区間でa_iが最小値をとる
すべてのiに対してこの個数を求める.
"""
n = I()
a = LI()
lst = [0]*(n+1)
for i in range(n):
lst[a[i]] = i
l = [0]*n #各iに対して,a_iより左側でa_iより小さいもののうち最もa_iに近いもののindex
r = [0]*n #各iに対して,a_iより右側でa_iより小さいもののうち最もa_iに近いもののindex
ans = 0
#大きい値から見ていく
for x in range(1,n+1)[::-1]:
#調べている数 := x
#xの位置 := i
i = lst[x]
#iが右端でないかつ,iの右隣が自分(x)より大きい場合
if i+1 < n and a[i+1] > x:
#r[i+1] := iより右側でxより小さいもののうち最もiに近いもののindex
# ⇒ i <= j < r[i+1] に関してa[j]はx以上である.
R = r[i+1]
else:
#右隣がいないまたは右隣が自分(x)より小さい場合
R = i
#iが左端でないかつ,iの左隣が自分(x)より大きい場合
if i-1 >= 0 and a[i-1] > x:
#l[i-1] := iより左側でxより小さいもののうち最もiに近いもののindex
# ⇒ l[i-1] < j <= i に関してa[j]はx以上である.
L = l[i-1]
else:
#左隣がいないまたは左隣が自分(x)より小さい場合
L = i
# L < j < Rに関してa[j]はx以上であることが分かっている.
# ⇒Rの位置から見て左側の区間はLまで
# ⇒Lの位置から見て右側の区間はRまで
l[R] = L
r[L] = R
ans += (i-L+1)*(R-i+1)*x
print(ans)
| p03987 |
import bisect
N = int(eval(input()))
A = list(map(int,input().split()))
ans = 0
for i in range(N):
l = 1
for j in range(i-1,-1,-1):
if A[i] <= A[j]:
l += 1
else:
break
r = 1
for j in range(i+1,N):
if A[i] <= A[j]:
r += 1
else:
break
ans += l*r*A[i]
print(ans) | N = int(eval(input()))
a = list(map(int,input().split()))
l = [i for i in range(N)]
r = [i for i in range(N)]
b = [0] * N
for i in range(N):
b[a[i]-1] = i
ans = 0
for i in range(N-1,-1,-1):
m = b[i]
x,y = l[m],r[m]
ans += (i+1)*(m-x+1)*(y-m+1)
l[min(y+1,N-1)] = x
r[max(x-1,0)] = y
print(ans) | p03987 |
class Node:
def __init__(self, key):
self.key = key
self.lch = None
self.rch = None
self.bias = 0
self.size = 1
class AVLTree:
def __init__(self):
self.root = None
def rotate_left(self, v):
u = v.rch
u.size = v.size
v.size -= u.rch.size + 1 if u.rch is not None else 1
v.rch = u.lch
u.lch = v
if u.bias == -1:
u.bias = v.bias = 0
else:
u.bias = 1
v.bias = -1
return u
def rotate_right(self, v):
u = v.lch
u.size = v.size
v.size -= u.lch.size + 1 if u.lch is not None else 1
v.lch = u.rch
u.rch = v
if u.bias == 1:
u.bias = v.bias = 0
else:
u.bias = -1
v.bias = 1
return u
def rotateLR(self, v):
u = v.lch
t = u.rch
t.size = v.size
v.size -= u.size - (t.rch.size if t.rch is not None else 0)
u.size -= t.rch.size + 1 if t.rch is not None else 1
u.rch = t.lch
t.lch = u
v.lch = t.rch
t.rch = v
self.update_bias_double(t)
return t
def rotateRL(self, v):
u = v.rch
t = u.lch
t.size = v.size
v.size -= u.size - (t.lch.size if t.lch is not None else 0)
u.size -= t.lch.size + 1 if t.lch is not None else 1
u.lch = t.rch
t.rch = u
v.rch = t.lch
t.lch = v
self.update_bias_double(t)
return t
def update_bias_double(self, v):
if v.bias == 1:
v.rch.bias = -1
v.lch.bias = 0
elif v.bias == -1:
v.rch.bias = 0
v.lch.bias = 1
else:
v.rch.bias = 0
v.lch.bias = 0
v.bias = 0
def add(self, key):
if self.root is None:
self.root = Node(key)
return
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lch
elif v.key < key:
history.append((v, -1))
v = v.rch
else:
return
p, pdir = history[-1]
if pdir == 1:
p.lch = Node(key)
else:
p.rch = Node(key)
while history:
v, direction = history.pop()
v.bias += direction
v.size += 1
new_v = None
b = v.bias
if b == 0:
break
if b == 2:
u = v.lch
if u.bias == -1:
new_v = self.rotateLR(v)
else:
new_v = self.rotate_right(v)
break
if b == -2:
u = v.rch
if u.bias == 1:
new_v = self.rotateRL(v)
else:
new_v = self.rotate_left(v)
break
if new_v is not None:
if len(history) == 0:
self.root = new_v
return
p, pdir = history.pop()
p.size += 1
if pdir == 1:
p.lch = new_v
else:
p.rch = new_v
while history:
p, pdir = history.pop()
p.size += 1
def remove(self, key):
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lch
elif v.key < key:
history.append((v, -1))
v = v.rch
else:
break
else:
return False
if v.lch is not None:
history.append((v, 1))
lmax = v.lch
while lmax.rch is not None:
history.append((lmax, -1))
lmax = lmax.rch
v.key = lmax.key
v = lmax
c = v.rch if v.lch is None else v.lch
if history:
p, pdir = history[-1]
if pdir == 1:
p.lch = c
else:
p.rch = c
else:
self.root = c
return True
while history:
new_p = None
p, pdir = history.pop()
p.bias -= pdir
p.size -= 1
b = p.bias
if b == 2:
if p.lch.bias == -1:
new_p = self.rotateLR(p)
else:
new_p = self.rotate_right(p)
elif b == -2:
if p.rch.bias == 1:
new_p = self.rotateRL(p)
else:
new_p = self.rotate_left(p)
elif b != 0:
break
if new_p is not None:
if len(history) == 0:
self.root = new_p
return True
gp, gpdir = history[-1]
if gpdir == 1:
gp.lch = new_p
else:
gp.rch = new_p
if new_p.bias != 0:
break
while history:
p, pdir = history.pop()
p.size -= 1
return True
def member(self, key):
v = self.root
while v is not None:
if key < v.key:
v = v.lch
elif v.key < key:
v = v.rch
else:
return True
return False
def lower_bound(self, key):
ret = None
v = self.root
while v is not None:
if v.key >= key:
if ret is None or ret > v.key:
ret = v.key
v = v.lch
else:
v = v.rch
return ret
def upper_bound(self, key):
ret = None
v = self.root
while v is not None:
if v.key <= key:
if ret is None or ret < v.key:
ret = v.key
v = v.rch
else:
v = v.lch
return ret
def find_kth_element(self, k):
v = self.root
s = 0
while v is not None:
t = s+v.lch.size if v.lch is not None else s
if t == k:
return v.key
elif t < k:
s = t+1
v = v.rch
else:
v = v.lch
return None
def __contains__(self, key): return self.member(key)
def __delitem__(self, key): return self.remove(key)
def __bool__(self): return self.root is not None
def __len__(self): return self.root.size if self.root is not None else 0
if __name__ == '__main__':
N = int(eval(input()))
A = [(a, i) for i, a in enumerate(map(int, input().split()))]
A.sort(reverse=True)
T = AVLTree()
T.add(-1)
T.add(N)
ans = 0
while A:
a, i = A.pop()
l = T.upper_bound(i)
r = T.lower_bound(i)
ans += a*(r-i)*(i-l)
T.add(i)
print(ans)
| class Node:
def __init__(self, key):
self.key = key
self.lch = None
self.rch = None
self.bias = 0
class AVLTree:
def __init__(self):
self.root = None
def rotate_left(self, v):
u = v.rch
v.rch = u.lch
u.lch = v
if u.bias == -1:
u.bias = v.bias = 0
else:
u.bias = 1
v.bias = -1
return u
def rotate_right(self, v):
u = v.lch
v.lch = u.rch
u.rch = v
if u.bias == 1:
u.bias = v.bias = 0
else:
u.bias = -1
v.bias = 1
return u
def rotateLR(self, v):
u = v.lch
t = u.rch
u.rch = t.lch
t.lch = u
v.lch = t.rch
t.rch = v
self.update_bias_double(t)
return t
def rotateRL(self, v):
u = v.rch
t = u.lch
u.lch = t.rch
t.rch = u
v.rch = t.lch
t.lch = v
self.update_bias_double(t)
return t
def update_bias_double(self, v):
if v.bias == 1:
v.rch.bias = -1
v.lch.bias = 0
elif v.bias == -1:
v.rch.bias = 0
v.lch.bias = 1
else:
v.rch.bias = 0
v.lch.bias = 0
v.bias = 0
def add(self, key):
if self.root is None:
self.root = Node(key)
return
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lch
elif v.key < key:
history.append((v, -1))
v = v.rch
else:
return
p, pdir = history[-1]
if pdir == 1:
p.lch = Node(key)
else:
p.rch = Node(key)
while history:
v, direction = history.pop()
v.bias += direction
new_v = None
b = v.bias
if b == 0:
break
if b == 2:
u = v.lch
if u.bias == -1:
new_v = self.rotateLR(v)
else:
new_v = self.rotate_right(v)
break
if b == -2:
u = v.rch
if u.bias == 1:
new_v = self.rotateRL(v)
else:
new_v = self.rotate_left(v)
break
if new_v is not None:
if len(history) == 0:
self.root = new_v
return
p, pdir = history.pop()
if pdir == 1:
p.lch = new_v
else:
p.rch = new_v
def lower_bound(self, key):
ret = 1<<30
v = self.root
while v is not None:
if v.key >= key:
if ret > v.key:
ret = v.key
v = v.lch
else:
v = v.rch
return ret
def upper_bound(self, key):
ret = -1
v = self.root
while v is not None:
if v.key <= key:
if ret < v.key:
ret = v.key
v = v.rch
else:
v = v.lch
return ret
if __name__ == '__main__':
N = int(eval(input()))
A = [(a, i) for i, a in enumerate(map(int, input().split()))]
A.sort(reverse=True)
T = AVLTree()
T.add(-1)
T.add(N)
ans = 0
while A:
a, i = A.pop()
l = T.upper_bound(i)
r = T.lower_bound(i)
ans += a*(r-i)*(i-l)
T.add(i)
print(ans)
| p03987 |
n=int(eval(input()))
a=list(map(int,input().split()))
b=[0]*n
for i in range(n):b[a[i]-1]=i
ans=0
l,r=[i for i in range(n+1)],[i for i in range(n+1)]
for i in range(n-1,-1,-1):
ans+=(i+1)*(b[i]-l[b[i]]+1)*(r[b[i]]-b[i]+1)
l[r[b[i]]+1],r[l[b[i]]-1]=l[b[i]],r[b[i]]
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
l=[i-1 for i in range(n+1)]+[n]
r=[i+1 for i in range(n+1)]+[n+2]
ans=0
p=[0]*n
for i in range(n):p[a[i]-1]=i
for i in range(n-1,-1,-1):
j=p[i]
ans+=(i+1)*(j-l[j])*(r[j]-j)
l[r[j]],r[l[j]]=l[j],r[j]
print(ans) | p03987 |
class Avltree:
def __init__(self,key=None):
self.key = key
self.left = None
self.right = None
self.balance = "Even"
def search_lower(self,key,key_lower):
if self.key == None:
return key_lower
if self.key > key:
if self.left == None:
return key_lower
else:
return self.left.search_lower(key,key_lower)
if self.key < key:
key_lower = self.key
if self.right == None:
return key_lower
else:
return self.right.search_lower(key,key_lower)
if self.left == None:
return key_lower
else:
if key_lower == None:
return self.left.end_higher(self.left.key)
else:
return max(key_lower,self.left.end_higher(self.left.key))
def search_higher(self,key,key_higher):
if self.key == None:
return key_higher
if self.key > key:
key_higher = self.key
if self.left == None:
return key_higher
else:
return self.left.search_higher(key,key_higher)
if self.key < key:
if self.right == None:
return key_higher
else:
return self.right.search_higher(key,key_higher)
if self.right == None:
return key_higher
else:
if key_higher == None:
return self.right.end_lower(self.right.key)
else:
return min(key_higher,self.right.end_lower(self.right.key))
def end_lower(self,end_lower_key):
if self.left == None:
return end_lower_key
else:
end_lower_key = self.left.key
return self.left.end_lower(end_lower_key)
def end_higher(self,end_higher_key):
if self.right == None:
return end_higher_key
else:
end_higher_key = self.right.key
return self.right.end_higher(end_higher_key)
def DoubleRightRotation(self):
tl = self.left
self.left = tl.right.right
tl.right.right = self
tlr = tl.right
tl.right = tlr.left
tlr.left = tl
if tlr.balance == "Left":
tlr.right.balance = "Right"
tlr.left.balance = "Even"
elif tlr.balance == "Right":
tlr.right.balance = "Even"
tlr.left.balance = "Left"
elif tlr.balance == "Even":
tlr.right.balance = "Even"
tlr.left.balance = "Even"
tlr.balance = "Even"
return tlr
def DoubleLeftRotation(self):
tr = self.right
self.right = tr.left.left
tr.left.left = self
trl = tr.left
tr.left = trl.right
trl.right = tr
if trl.balance == "Right":
trl.left.balance = "Left"
trl.right.balance = "Even"
elif trl.balance == "Left":
trl.left.balance = "Even"
trl.right.balance = "Right"
elif trl.balance == "Even":
trl.left.balance = "Even"
trl.right.balance = "Even"
trl.balance = "Even"
return trl
def SingleLeftRotation(self):
tr = self.right
tr.balance = "Even"
self.balance = "Even"
self.right = tr.left
tr.left = self
return tr
def SingleRightRotation(self):
tl = self.left
tl.balance = "Even"
self.balance = "Even"
self.left = tl.right
tl.right = self
return tl
def replace(self,p,v):
if p.left == self:
p.left = v
else :
p.right = v
def insert(self,key):
if self.key == None:
self.key = key
return self
if key < self.key:
if self.left == None:
self.left = Avltree(key)
else:
self.left.insertx(self,key)
elif key > self.key:
if self.right == None:
self.right = Avltree(key)
else:
self.right.insertx(self,key)
else:
pass
def insertx(self,p,key):
if self.key > key:
if self.left == None:
self.left = Avltree(key)
else:
if not self.left.insertx(self, key):
return False
if self.balance == "Right":
self.balance = "Even"
return False
elif self.balance == "Even":
self.balance = "Left"
return True
elif self.balance == "Left":
if self.left.balance == "Right":
self.replace(p,self.DoubleRightRotation())
elif self.left.balance == "Left":
self.replace(p,self.SingleRightRotation())
return False
if self.key < key:
if self.right == None:
self.right = Avltree(key)
else:
if not self.right.insertx(self, key):
return False
if self.balance == "Left":
self.balance = "Even"
return False
elif self.balance == "Even":
self.balance = "Right"
return True
elif self.balance == "Right":
if self.right.balance == "Left":
self.replace(p,self.DoubleLeftRotation())
elif self.right.balance == "Right":
self.replace(p,self.SingleLeftRotation())
return False
return False
n = int(eval(input()))
a = list(map(int,input().split()))
b = [0]*(n+1)
for i in range(n):
b[a[i]] = i
root = Avltree()
ass = 0
for i in range(1,n+1):
l = root.search_lower(b[i],-1)
r = root.search_higher(b[i],n)
ass += (b[i]-l)*(r-b[i])*i
root.insert(b[i])
print(ass)
| #木の根を求める
def find(x,par):
if par[x] == x:
return x
else:
return find(par[x],par)
#xとyの属する集合の併合
def unite(x,y,par,rank,size):
x = find(x,par)
y = find(y,par)
if x != y:
#xとyの属している集合が異なる時
if rank[x] < rank[y]:
par[x] = y
size[y] += size[x]
else:
par[y] = x
size[x] += size[y]
if rank[x]==rank[y]:
rank[x] += 1
#xとyが同じ集合に属するかの判定
def same(x,y,par):
return find(x,par) == find(y,par)
########################################
n = int(eval(input()))
a = list(map(int,input().split()))
par = [0]*n #親
for i in range(n):
par[i] = i
rank = [1]*n #深さ
size = [1]*n #size[i]:iを根とするグループのサイズ
b = [0]*(n+1) #b[i]:iがaにおいて何番目か
for i in range(n):
b[a[i]]=i
ans = 0
for i in range(n,0,-1):
k = b[i]
left = 0
right = 0
if k-1>=0 and a[k-1]>a[k]:
left = size[find(k-1,par)]
unite(k-1,k,par,rank,size)
if k+1<=n-1 and a[k+1]>a[k]:
right = size[find(k+1,par)]
unite(k+1,k,par,rank,size)
ans += (left+1)*(right+1)*a[k]
print(ans)
| p03987 |
#木の根を求める
def find(x,par):
if par[x] == x:
return x
else:
return find(par[x],par)
#xとyの属する集合の併合
def unite(x,y,par,rank,size):
x = find(x,par)
y = find(y,par)
if x != y:
#xとyの属している集合が異なる時
if rank[x] < rank[y]:
par[x] = y
size[y] += size[x]
else:
par[y] = x
size[x] += size[y]
if rank[x]==rank[y]:
rank[x] += 1
#xとyが同じ集合に属するかの判定
def same(x,y,par):
return find(x,par) == find(y,par)
########################################
n = int(eval(input()))
a = list(map(int,input().split()))
par = [0]*n #親
for i in range(n):
par[i] = i
rank = [1]*n #深さ
size = [1]*n #size[i]:iを根とするグループのサイズ
b = [0]*(n+1) #b[i]:iがaにおいて何番目か
for i in range(n):
b[a[i]]=i
ans = 0
for i in range(n,0,-1):
k = b[i]
left = 0
right = 0
if k-1>=0 and a[k-1]>a[k]:
left = size[find(k-1,par)]
unite(k-1,k,par,rank,size)
if k+1<=n-1 and a[k+1]>a[k]:
right = size[find(k+1,par)]
unite(k+1,k,par,rank,size)
ans += (left+1)*(right+1)*a[k]
print(ans)
| #木の根を求める
def find(x):
if par[x] == x:
return x
else:
return find(par[x])
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x != y:
#xとyの属している集合が異なる時
if rank[x] < rank[y]:
par[x] = y
size[y] += size[x]
else:
par[y] = x
size[x] += size[y]
if rank[x]==rank[y]:
rank[x] += 1
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
########################################
n = int(eval(input()))
a = list(map(int,input().split()))
par = [0]*n #親
for i in range(n):
par[i] = i
rank = [1]*n #深さ
size = [1]*n #size[i]:iを根とするグループのサイズ
b = [0]*(n+1) #b[i]:iがaにおいて何番目か
for i in range(n):
b[a[i]]=i
ans = 0
for i in range(n,0,-1):
k = b[i]
left = 0
right = 0
if k-1>=0 and a[k-1]>a[k]:
left = size[find(k-1)]
unite(k-1,k)
if k+1<=n-1 and a[k+1]>a[k]:
right = size[find(k+1)]
unite(k+1,k)
ans += (left+1)*(right+1)*a[k]
print(ans)
| p03987 |
import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
A = list(map(int, input().split()))
left = [0] * N
tmp = []
for i, a in enumerate(A):
cnt = 1
while tmp:
aa, c = tmp.pop()
if aa < a:
tmp.append((aa, c))
break
else:
cnt += c
tmp.append((a, cnt))
left[i] = cnt
A =A [::-1]
right = [0] * N
tmp = []
for i, a in enumerate(A):
cnt = 1
while tmp:
aa, c = tmp.pop()
if aa < a:
tmp.append((aa, c))
break
else:
cnt += c
tmp.append((a, cnt))
right[i] = cnt
right = right[::-1]
A = A[::-1]
answer = 0
for i in range(N):
answer += left[i] * right[i] * A[i]
print(answer) | import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
A = list(map(int, input().split()))
def while_pop(arr):
res = [0] * N
tmp = []
for i, a in enumerate(arr):
cnt = 1
while tmp:
aa, c = tmp.pop()
if aa < a:
tmp.append((aa, c))
break
else:
cnt += c
tmp.append((a, cnt))
res[i] = cnt
return res
left = while_pop(A)
right = while_pop(A[::-1])[::-1]
answer = 0
for i in range(N):
answer += left[i] * right[i] * A[i]
print(answer) | p03987 |
class BIT_index:
def __init__(self, n):
self.BIT_prev = [n] * (n + 1)
self.BIT_next = [n] * (n + 1)
self.n = n
def __addElement(self, BIT, idx):
value = idx
idx += 1
while idx > 0:
BIT[idx] = min(BIT[idx], value)
idx -= idx & -idx
def addElement(self, idx):
self.__addElement(self.BIT_prev, self.n - 1 - idx)
self.__addElement(self.BIT_next, idx)
def __getIndex(self, BIT, idx):
idx += 1
ans = self.n
while idx <= self.n:
ans = min(ans, BIT[idx])
idx += idx & -idx
return ans
def getIndexPrev(self, idx):
return self.__getIndex(self.BIT_prev, self.n - 1 - idx)
def getIndexNext(self, idx):
return self.__getIndex(self.BIT_next, idx)
N = int(eval(input()))
As = list(map(int, input().split()))
Bs = [i for A, i in sorted([(As[i], i) for i in range(N)])]
BIT = BIT_index(N)
ans = 0
for i, B in enumerate(Bs):
iN = BIT.getIndexNext(B)
iP = BIT.getIndexPrev(B)
BIT.addElement(B)
ans += (i + 1) * (iN - B) * (B - (N - 1 - iP))
print(ans)
| N = int(eval(input()))
As = list(map(int, input().split()))
iAs = [0] * (N + 1)
for i, A in enumerate(As):
iAs[A] = i
ans = 0
iLs = list(range(N + 1))
iRs = list(range(N + 1))
for A in reversed(list(range(1, N + 1))):
iA = iAs[A]
iL, iR = iLs[iA], iRs[iA]
ans += A * (iA - iL + 1) * (iR - iA + 1)
iLs[iR + 1] = iL
iRs[iL - 1] = iR
print(ans)
| p03987 |
N = int(eval(input()))
As = list(map(int, input().split()))
iAs = [0] * (N + 1)
for i, A in enumerate(As):
iAs[A] = i
ans = 0
iLs = list(range(N + 1))
iRs = list(range(N + 1))
for A in reversed(list(range(1, N + 1))):
iA = iAs[A]
iL, iR = iLs[iA], iRs[iA]
ans += A * (iA - iL + 1) * (iR - iA + 1)
iLs[iR + 1] = iL
iRs[iL - 1] = iR
print(ans)
| def getNums(As):
nums = [0] * N
stack = [(-1, 0)]
for iA, A in enumerate(As):
while stack[-1][1] > A:
stack.pop()
nums[iA] = iA - stack[-1][0]
stack.append((iA, A))
return nums
N = int(eval(input()))
As = list(map(int, input().split()))
numLs = getNums(As)
numRs = getNums(reversed(As))
print((sum([A * numL * numR for A, numL, numR in zip(As, numLs, reversed(numRs))])))
| p03987 |
import sys
from operator import itemgetter
class BinaryIndexedTreeCustom:
def __init__(self, n, init, func):
self.size = n
self.tree = [init] * (n + 1)
self.depth = n.bit_length()
self.init = init
self.func = func
def get(self, i):
s = self.init
tr = self.tree
f = self.func
while i > 0:
s = f(s, tr[i])
i -= i & -i
return s
def put(self, i, x):
n = self.size
tr = self.tree
f = self.func
while i <= n:
y = tr[i]
tr[i] = f(tr[i], x)
if y == tr[i]:
break
i += i & -i
n, *aaa = list(map(int, sys.stdin.buffer.read().split()))
bit1 = BinaryIndexedTreeCustom(n, 0, max)
bit2 = BinaryIndexedTreeCustom(n, n + 1, min)
aaa_with_index = list(enumerate(aaa, start=1))
aaa_with_index.sort(key=itemgetter(1))
ans = 0
for i, a in aaa_with_index:
li = bit1.get(i)
ri = bit2.get(n - i)
ans += a * (i - li) * (ri - i)
bit1.put(i, i)
bit2.put(n + 1 - i, i)
print(ans)
| import sys
from operator import itemgetter
n, *aaa = list(map(int, sys.stdin.buffer.read().split()))
aaa_with_index = list(enumerate(aaa, start=1))
aaa_with_index.sort(key=itemgetter(1), reverse=True)
left = list(range(-1, n + 1))
right = list(range(1, n + 3))
ans = 0
for i, a in aaa_with_index:
li = left[i]
ri = right[i]
ans += a * (i - li) * (ri - i)
left[ri] = li
right[li] = ri
print(ans)
| p03987 |
import bisect
def inpl(): return [int(i) for i in input().split()]
N = int(eval(input()))
a = inpl()
b = [0 for _ in range(N)]
for i in range(N):
b[a[i]-1] = i+1
rng = [0, N+1]
ans = 0
for i, v in enumerate(b):
x = bisect.bisect_left(rng, v)
st = rng[x-1]
en = rng[x]
ans += (i+1)*(v-st)*(en-v)
bisect.insort_left(rng, v)
print(ans) | def inpl(): return [int(i) for i in input().split()]
N = int(eval(input()))
a = inpl()
b = {a[i]: i for i in range(N)}
left = list(range(N+2))
right = list(range(N+2))
ans = 0
for i in range(N,0,-1):
x = b[i]
ans += i*(right[x]-x +1)*(x-left[x] +1)
right[left[x] - 1] = right[x]
left[right[x] + 1] = left[x]
print(ans) | p03987 |
n = int(eval(input()))
A = [[int(a),i] for i,a in enumerate(input().split())]
A.sort()
bit = [0]*(n+1)
def sum(i):
# [0, i) の要素の総和を返す
s = 0
while i>0:
s += bit[i]
i -= i & -i
return s
# 0 index を 1 index に変更 転倒数を求めるなら1を足していく
def add(i, x):
i += 1
while i <= n:
bit[i] += x
i += i & -i
# 総和がx以上になる位置のindex をbinary search
def bsearch(x):
le = 0
ri = 1<<(n.bit_length()-1)
while ri > 0:
if le+ri <= n and bit[le+ri]<x:
x -= bit[le+ri]
le += ri
ri >>= 1
return le+1
ans = 0
for i in range(n):
x,ind = A[i]
s = sum(ind)
if s == 0:
l = 0
else:
l = bsearch(s)
s2 = s+1
if s2 > i:
r = n
else:
r = bsearch(s2)-1
ans += x*(r-ind)*(ind-l+1)
add(ind,1)
print(ans) | n = int(eval(input()))
A = list(map(int,input().split()))
l = [i-1 for i in range(n+2)]
r = [i+1 for i in range(n+2)]
ind = [0]*n
for i,a in enumerate(A):
ind[a-1] = i
ans = 0
for i in range(n-1,-1,-1):
x = ind[i]
ans += (i+1)*(r[x]-x)*(x-l[x])
l[r[x]],r[l[x]], = l[x],r[x]
print(ans) | p03987 |
from bisect import bisect_left
N = int(eval(input()))
*A, = list(map(int, input().split()))
indices = {a: i for i, a in enumerate(A)}
seen_idx = [-1, N]
ans = 0
for a in range(1, N+1):
idx = indices[a]
t = bisect_left(seen_idx, idx)
seen_idx = seen_idx[:t] + [idx] + seen_idx[t:]
left = idx - seen_idx[t-1]
right = seen_idx[t+1] - idx
ans += left * right * a
print(ans) | N = int(eval(input()))
*A, = list(map(int, input().split()))
indices = {a: i for i, a in enumerate(A)}
left = {i: i for i in range(N)} # "left[i] = l" is equivalent to "A[l], ..., A[i-1] > A[i]"
right = {i: i for i in range(N)} # "right[i] = r" is equivalent to "A[i] < A[i+1], ..., A[r]"
ans = 0
for a in range(N, 0, -1):
idx = indices[a]
l, r = left[idx], right[idx]
ans += (idx - l + 1) * (r - idx + 1) * a
left[r+1], right[l-1] = l, r # A[l-1] < A[l], ..., A[r] > A[r+1]
print(ans) | p03987 |
N=int(eval(input()))
A=list(map(int,input().split()))
p=[None]*N
for i,a in enumerate(A):
p[a-1]=i
ans=0
b={-1:1,N:1}
from bisect import bisect
for i in range(N):
bs=sorted(b.keys())
s=bisect(bs,p[i])
ans+=(i+1)*(p[i]-bs[s-1])*(bs[s]-p[i])
b[p[i]]=1
print(ans) | N=int(eval(input()))
A=list(map(int,input().split()))
p=[None]*N
for i,a in enumerate(A):
p[a-1]=i
ans=0
l,r=[i for i in range(N)],[i for i in range(N)]
for i in range(N-1,-1,-1):
left,right=l[p[i]],r[p[i]]
ans+=(i+1)*(p[i]-left+1)*(right-p[i]+1)
if left>0:
r[left-1]=right
if right<N-1:
l[right+1]=left
print(ans) | p03987 |
n=int(eval(input()))
a=list(map(int,input().split()))
a=sorted(list(enumerate(a)),key=lambda x:x[1])
l=1
while l<2*(n+2)-1:
l*=2
l-=1
seg=[True]*l
seg[0]=False
def update(i):
if seg[i]:
seg[i]=False
update((i-1)//2)
update((l-1)//2)
update((l-1)//2+n+1)
def search_left(i,j):
if j==1:
if i%2==1:
return search_left((i-1)//2,1)
else:
if seg[i-1]:
return search_left((i-1)//2,1)
else:
return search_left(i-1,0)
else:
if i<l//2:
return search_left(2*i+2-seg[2*i+2],0)
else:
return i
def search_right(i,j):
if j==1:
if i%2==0:
return search_right((i-1)//2,1)
else:
if seg[i+1]:
return search_right((i-1)//2,1)
else:
return search_right(i+1,0)
else:
if i<l//2:
return search_right(2*i+1+seg[2*i+1],0)
else:
return i
ans=0
for i,j in a:
s=(l//2+1+i)
p=search_left(s,1)
q=search_right(s,1)
ans+=(s-p)*(q-s)*j
update(s)
print(ans) | def main():
n = int(eval(input()))
a = list(map(int, input().split()))
a = sorted(list(enumerate(a)), key=lambda x: -x[1])
class unionfind():
# size:要素数,tree：unionfind木
def __init__(self, size): # self,要素数
self.size = size
self.tree = [i for i in range(self.size)] # root,depth
# rootを探す
def root(self, index):
temp_list = []
temp = self.tree[index]
while index != temp:
temp_list.append(index)
index = temp
temp = self.tree[index]
for i in temp_list:
self.tree[i] = index
return index
# 結合
def unite_r(self, index1, index2):
r1 = self.root(index1)
r2 = self.root(index2)
if r1 < r2:
self.tree[r1] = r2
else:
self.tree[r2] = r1
def unite_l(self, index1, index2):
r1 = self.root(index1)
r2 = self.root(index2)
if r1 > r2:
self.tree[r1] = r2
else:
self.tree[r2] = r1
# 同じか判定
def same(self, index1, index2):
r1 = self.root(index1)
r2 = self.root(index2)
return r1 == r2
ur = unionfind(n+2)
ul = unionfind(n+2)
vis = [False]*(n+2)
ans = 0
for i, j in a:
vis[i+1] = True
if vis[i+2]:
ur.unite_r(i+1, i+2)
ul.unite_l(i+1, i+2)
if vis[i]:
ur.unite_r(i, i+1)
ul.unite_l(i, i+1)
ans += j*(ur.root(i+1)-i)*(i+2-ul.root(i+1))
print(ans)
main()
| p03987 |
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
a = sorted(list(enumerate(a)), key=lambda x: -x[1])
class unionfind():
# size:要素数,tree：unionfind木
def __init__(self, size): # self,要素数
self.size = size
self.tree = [i for i in range(self.size)] # root,depth
# rootを探す
def root(self, index):
temp_list = []
temp = self.tree[index]
while index != temp:
temp_list.append(index)
index = temp
temp = self.tree[index]
for i in temp_list:
self.tree[i] = index
return index
# 結合
def unite_r(self, index1, index2):
r1 = self.root(index1)
r2 = self.root(index2)
if r1 < r2:
self.tree[r1] = r2
else:
self.tree[r2] = r1
def unite_l(self, index1, index2):
r1 = self.root(index1)
r2 = self.root(index2)
if r1 > r2:
self.tree[r1] = r2
else:
self.tree[r2] = r1
# 同じか判定
def same(self, index1, index2):
r1 = self.root(index1)
r2 = self.root(index2)
return r1 == r2
ur = unionfind(n+2)
ul = unionfind(n+2)
vis = [False]*(n+2)
ans = 0
for i, j in a:
vis[i+1] = True
if vis[i+2]:
ur.unite_r(i+1, i+2)
ul.unite_l(i+1, i+2)
if vis[i]:
ur.unite_r(i, i+1)
ul.unite_l(i, i+1)
ans += j*(ur.root(i+1)-i)*(i+2-ul.root(i+1))
print(ans)
main()
| def main():
n = int(eval(input()))
a = list(map(int, input().split()))
a = sorted(list(enumerate(a)), key=lambda x: -x[1])
L = [i for i in range(n+2)] # 連結成分のうち一番左のindex
R = [i for i in range(n+2)] # 連結成分のうち一番右のindex
ans = 0
for i, j in a: # 1-indexなので1ずれる
M = R[i+1] # 連結成分の最大値
m = L[i+1] # 連結成分の最小値
ans += j*(M-i)*(i+2-m) # 計算
R[m-1] = M # 連結成分の左端の更新
L[M+1] = m # 連結成分の右端の更新
print(ans)
main() | p03987 |
n = int(eval(input()))
a = list(map(int,input().split()))
p = [0]*(n+1)
ans = 0
for i in range(n):
p[a[i]] = i+1
l = [i-1 for i in range(n+2)]
l[0] = 0
r = [i+1 for i in range(n+2)]
r[-1] = n+1
for i in range(n,0,-1):
ans += (p[i]-l[p[i]])*(r[p[i]]-p[i])*i
l[r[p[i]]] = l[p[i]]
r[l[p[i]]] = r[p[i]]
print(ans) | N = int(eval(input()))
a = list(map(int, input().split()))
# indexをソート
b = [0] * N
for i in range(N):
b[a[i] - 1] = i
# 初期化 端っこ対策としてひとつ余計に取っている
left = [0] * (N + 1)
right = [0] * (N + 1)
for i in range(N + 1):
left[i] = i-1
right[i] = i+1
# 更新
for idx in reversed(b):
left[right[idx]] = left[idx]
right[left[idx]] = right[idx]
ans = 0
for i in range(N):
ans += a[i] * (i - left[i]) * (right[i] - i)
print(ans) | p03987 |
import bisect
N = int(eval(input()))
a = list(zip(list(map(int, input().split())), list(range(1, N + 1))))
b = [0, N + 1]
a.sort()
ans = 0
for j, i in a:
x = bisect.bisect(b, i)
y = b[x - 1]
z = b[x]
ans += (((z - y) * (z - y - 1) - (i - y) * (i - y - 1) - (z - i) * (z - i - 1)) // 2) * j
bisect.insort(b, i)
print(ans) | N = int(eval(input()))
a = list(map(int, input().split()))
b = [0] * (N + 1)
for i in range(N):
b[a[i]] = i + 1
l = [i for i in range(N + 2)]
r = [i for i in range(N + 2)]
ans = 0
for i in range(N, 0, -1):
m = b[i]
x = l[m]
y = r[m]
ans += (m - x + 1) * (y - m + 1) * i
r[x - 1] = y
l[y + 1] = x
print(ans) | p03987 |
from collections import defaultdict
#AVL
##search(0,x):O(logN)
# xがある場合indexを、ない場合Noneを返す
def search(root,key):
if avl_key[root] > key:
if avl_left[root] == None:
return None
else:
return search(avl_left[root],key)
if avl_key[root] < key:
if avl_right[root] == None:
return None
else:
return search(avl_right[root],key)
return root
##end_lower/higher:search_lower/higherで使用
def end_lower(root):
if avl_left[root] == None:
return avl_key[root]
else:
return end_lower(avl_left[root])
def end_higher(root):
if avl_right[root] == None:
return avl_key[root]
else:
return end_higher(avl_right[root])
##search_lower(0,x,None):O(logN)
# xより小さいものの中で最も大きいものを出力。ない場合はNoneを出力
def search_lower(root,key,lower_key):
if avl_key[root] > key:
if avl_left[root] == None:
return lower_key
else:
return search_lower(avl_left[root],key,lower_key)
if avl_key[root] < key:
lower_key = avl_key[root]
if avl_right[root] == None:
return lower_key
else:
return search_lower(avl_right[root],key,lower_key)
# ==
if avl_left[root] == None:
return lower_key
else:
if lower_key == None:
return end_higher(avl_left[root])
else:
return max(lower_key,end_higher(avl_left[root]))
##search_higher(0,x,None):O(logN)
# xより大きいものの中で最も小さいものを出力。ない場合はNoneを出力
def search_higher(root,key,higher_key):
if avl_key[root] > key:
higher_key = avl_key[root]
if avl_left[root] == None:
return higher_key
else:
return search_higher(avl_left[root],key,higher_key)
if avl_key[root] < key:
if avl_right[root] == None:
return higher_key
else:
return search_higher(avl_right[root],key,higher_key)
# ==
if avl_right[root] == None:
return higher_key
else:
if higher_key == None:
return end_lower(avl_right[root])
else:
return min(higher_key,end_lower(avl_right[root]))
##Rotation,replace,insertx:insertで使用
def DoubleRightRotation(x):
tl = avl_left[x]
avl_left[x] = avl_right[avl_right[tl]]
avl_right[avl_right[tl]] = x
tlr = avl_right[tl]
avl_right[tl] = avl_left[tlr]
avl_left[tlr] = tl
if balance[tlr] == -1:
balance[avl_right[tlr]] = 1
balance[avl_left[tlr]] = 0
elif balance[tlr] == 1:
balance[avl_right[tlr]] = 0
balance[avl_left[tlr]] = -1
else:
balance[avl_right[tlr]] = 0
balance[avl_left[tlr]] = 0
balance[tlr] = 0
return tlr
def DoubleLeftRotation(x):
tr = avl_right[x]
avl_right[x] = avl_left[avl_left[tr]]
avl_left[avl_left[tr]] = x
trl = avl_left[tr]
avl_left[tr] = avl_right[trl]
avl_right[trl] = tr
if balance[trl] == 1:
balance[avl_right[trl]] = 0
balance[avl_left[trl]] = -1
elif balance[trl] == -1:
balance[avl_left[trl]] = 0
balance[avl_right[trl]] = 1
else:
balance[avl_right[trl]] = 0
balance[avl_left[trl]] = 0
balance[trl] = 0
return trl
def SingleLeftRotation(x):
tr = avl_right[x]
balance[tr] = 0
balance[x] = 0
avl_right[x] = avl_left[tr]
avl_left[tr] = x
return tr
def SingleRightRotation(x):
tl = avl_left[x]
balance[tl] = 0
balance[x] = 0
avl_left[x] = avl_right[tl]
avl_right[tl] = x
return tl
def replace(x,p,v):
if avl_left[p] == x:
avl_left[p] = v
else:
avl_right[p] = v
def insertx(root,p,key):
if avl_key[root] > key:
if avl_left[root] == None:
avl_key.append(key)
avl_left[root] = len(avl_key)-1
else:
if not insertx(avl_left[root],root,key):
return False
if balance[root] == 1:
balance[root] = 0
return False
elif balance[root] == 0:
balance[root] = -1
return True
else:
if balance[avl_left[root]] == 1:
replace(root,p,DoubleRightRotation(root))
elif balance[avl_left[root]] == -1:
replace(root,p,SingleRightRotation(root))
return False
if avl_key[root] < key:
if avl_right[root] == None:
avl_key.append(key)
avl_right[root] = len(avl_key)-1
else:
if not insertx(avl_right[root],root,key):
return False
if balance[root] == -1:
balance[root] = 0
return False
elif balance[root] == 0:
balance[root] = 1
return True
else:
if balance[avl_right[root]] == -1:
replace(root,p,DoubleLeftRotation(root))
elif balance[avl_right[root]] == 1:
replace(root,p,SingleLeftRotation(root))
return False
return False
##insert(0,x):O(logN)
#x追加
def insert(root,key):
if key < avl_key[root]:
if avl_left[root] == None:
avl_key.append(key)
avl_left[root] = len(avl_key)-1
else:
insertx(avl_left[root],root,key)
elif key > avl_key[root]:
if avl_right[root] == None:
avl_key.append(key)
avl_right[root] = len(avl_key)-1
else:
insertx(avl_right[root],root,key)
else:
pass
#########################################
N = int(eval(input()))
A = [int(i) for i in input().split()]
IDX = defaultdict(int)
for idx,a in enumerate(A):
IDX[a] = idx + 1
# AVL木の初期化
avl_key = [0]
avl_left = [None] * (N + 2)
avl_right = [None] * (N + 2)
balance = [0] * (N + 2)
insert(0, N + 1)
ans = 0
for n in range(1, N + 1):
insert(0, IDX[n])
H = search_higher(0, IDX[n], None)
L = search_lower(0, IDX[n], None)
ans += (IDX[n] - L) * (H - IDX[n]) * n
print(ans) | import bisect
from collections import defaultdict
class SqrtSet:
def __init__(self, block_limit=201):
self.key = []
self.child = [[]]
self.block_limit = block_limit
def search_lower(self, key):
if key is None:
return None
ret = None
i = bisect.bisect_left(self.key, key)
if i != 0:
ret = self.key[i - 1]
block = self.child[i]
i = bisect.bisect_left(block, key)
if i != 0:
ret = block[i - 1]
return ret
def search_higher(self, key):
if key is None:
return None
ret = None
i = bisect.bisect_right(self.key, key)
if i != len(self.key):
ret = self.key[i]
block = self.child[i]
i = bisect.bisect_right(block, key)
if i != len(block):
ret = block[i]
return ret
def insert(self, key):
i = bisect.bisect(self.key, key)
block = self.child[i]
bisect.insort(block, key)
if len(block) == self.block_limit:
sep = self.block_limit // 2
self.key.insert(i, block[sep])
self.child.insert(i + 1, block[sep + 1:])
self.child[i] = block[:sep]
def main():
N = int(eval(input()))
A = [int(i) for i in input().split()]
# IDX[n] <-> A.index(n)
IDX = defaultdict(int)
for idx,a in enumerate(A):
IDX[a] = idx
SS = SqrtSet()
SS.insert(-1)
SS.insert(N)
ans = 0
for n in range(1, N + 1):
H = SS.search_higher(IDX[n])
L = SS.search_lower(IDX[n])
ans += (IDX[n] - L) * (H - IDX[n]) * n
SS.insert(IDX[n])
print(ans)
if __name__ == "__main__":
main() | p03987 |
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15
class SegmentTree():
def __init__(self,N,f,unit):
self.f = f
self.unit = unit
self.N = N
self.tree = [self.unit] * (2*self.N)
#self._build(array)
def _build(self,array):
for i,x in enumerate(array,self.N):
self.tree[i] = x
for i in range(self.N - 1,0,-1):
self.tree[i] = self.f(self.tree[i << 1],self.tree[i << 1|1])
def update(self,k,x):
k += self.N
self.tree[k] = x
while k > 1:
k >>= 1
self.tree[k] = self.f(self.tree[k << 1],self.tree[k << 1|1])
def query(self,l,r):
l += self.N
r += self.N
vl = self.unit
vr = self.unit
while l < r:
if l&1:
vl = self.f(vl,self.tree[l])
l += 1
if r&1:
r -= 1
vr = self.f(self.tree[r],vr)
l >>= 1
r >>= 1
return self.f(vl,vr)
def debug(self):
print((self.tree))
def main():
N = int(eval(input()))
A = list(map(int,input().split()))
st = SegmentTree(N,max,-1)
L = [-1] * N
for i,a in enumerate(A):
L[i] = st.query(0,a - 1)
st.update(a - 1,i)
st = SegmentTree(N,min,N)
R = [N] * N
for i in range(N - 1,-1,-1):
R[i] = st.query(0,A[i] - 1)
st.update(A[i] - 1,i)
ans = sum((R[i] - i)*(i - L[i])*A[i] for i in range(N))
print(ans)
if __name__ == '__main__':
main() | import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15
def main():
N = int(eval(input()))
A = list(enumerate(map(int,input().split())))
A.sort(key = lambda x:-x[1])
left = list(range(-1,N + 2))
right = list(range(1,N + 4))
ans = 0
for i,a in A:
L = left[i]
R = right[i]
ans += a*(i - L)*(R - i)
left[R] = L
right[L] = R
print(ans)
if __name__ == '__main__':
main() | p03987 |
# -*- coding: utf-8 -*-
import sys
from operator import add
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
class SegTree:
"""
セグメント木
1.update: i番目の値をxに更新する
2.query: 区間[l, r)の値を得る
"""
def __init__(self, n, func, intv, A=[]):
"""
:param n: 要素数(0-indexed)
:param func: 値の操作に使う関数(min, max, add, gcdなど)
:param intv: 要素の初期値(単位元)
:param A: 初期化に使うリスト(オプション)
"""
self.n = n
self.func = func
self.intv = intv
# nより大きい2の冪数
n2 = 1
while n2 < n:
n2 <<= 1
self.n2 = n2
self.tree = [self.intv] * (n2 << 1)
# 初期化の値が決まっている場合
if A:
# 1段目(最下段)の初期化
for i in range(n):
self.tree[n2+i] = A[i]
# 2段目以降の初期化
for i in range(n2-1, -1, -1):
self.tree[i] = self.func(self.tree[i*2], self.tree[i*2+1])
def update(self, i, x):
"""
i番目の値をxに更新
:param i: index(0-indexed)
:param x: update value
"""
i += self.n2
self.tree[i] = x
while i > 0:
i >>= 1
self.tree[i] = self.func(self.tree[i*2], self.tree[i*2+1])
def query(self, a, b):
"""
[a, b)の値を得る
:param a: index(0-indexed)
:param b: index(0-indexed)
"""
l = a + self.n2
r = b + self.n2
s = self.intv
while l < r:
if r & 1:
r -= 1
s = self.func(s, self.tree[r])
if l & 1:
s = self.func(s, self.tree[l])
l += 1
l >>= 1
r >>= 1
return s
def get(self, i):
""" 一点取得 """
return self.tree[i+self.n2]
def all(self):
""" 全区間[0, n)の取得 """
return self.tree[1]
def bisearch_min(mn, mx, func):
""" 条件を満たす最小値を見つける二分探索 """
ok = mx
ng = mn
while ng+1 < ok:
mid = (ok+ng) // 2
if func(mid):
# 下を探しに行く
ok = mid
else:
# 上を探しに行く
ng = mid
return ok
def bisearch_max(mn, mx, func):
""" 条件を満たす最大値を見つける二分探索 """
ok = mn
ng = mx
while ok+1 < ng:
mid = (ok+ng) // 2
if func(mid):
# 上を探しに行く
ok = mid
else:
# 下を探しに行く
ng = mid
return ok
# m~idxの間に出現済がない(この範囲の中で自分が最小値)かどうか
def calc1(m):
cnt = st.query(m, idx+1)
return cnt == 0
# idx~mの間に出現済がない(この範囲の中で自分が最小値)かどうか
def calc2(m):
cnt = st.query(idx, m+1)
return cnt == 0
N = INT()
A = LIST()
# aの昇順に処理できるようにindexで並べておく
idxs = [0] * (N+1)
for i, a in enumerate(A):
idxs[a] = i + 1
st = SegTree(N+2, add, 0)
# 先頭と末尾に番兵を仕込む
st.update(0, 1)
st.update(N+1, 1)
ans = [0] * (N+1)
for a in range(1, N+1):
# a(1~N)が格納されているindex
idx = idxs[a]
# 自分より小さいindexで最初に自分より小さい値がある直前の場所
l = bisearch_min(0, idx+1, calc1)
# 自分より大きいindexで最初に自分より小さい値がある直前の場所
r = bisearch_max(idx, N+1, calc2)
# aを使う回数 * a = 左端として使える範囲 * 右端として使える範囲 * a
ans[a] = (idx-l+1) * (r-idx+1) * a
# aを出現済とする
st.update(idx, 1)
# 全てのaについての合計
print((sum(ans)))
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
class BIT:
def __init__(self, n):
# 0-indexed
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
""" [0, i]を合計する """
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
""" 値の追加：添字i, 値x """
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def get(self, l, r=None):
""" 区間和の取得 [l, r) """
# 引数が1つなら一点の値を取得
if r is None: r = l + 1
res = 0
if r: res += self.sum(r-1)
if l: res -= self.sum(l-1)
return res
def bisearch_min(mn, mx, func):
""" 条件を満たす最小値を見つける二分探索 """
ok = mx
ng = mn
while ng+1 < ok:
mid = (ok+ng) // 2
if func(mid):
# 下を探しに行く
ok = mid
else:
# 上を探しに行く
ng = mid
return ok
# 右から1番目の値の位置
def calc1(m):
cnt = lend - bit.sum(m)
return cnt < 1
# 左から1番目の値の位置
def calc2(m):
cnt = bit.sum(m) - rstart
return cnt >= 1
N = INT()
A = LIST()
# aの昇順に処理できるようにindexで並べておく
idxs = [0] * (N+1)
for i, a in enumerate(A):
idxs[a] = i + 1
bit = BIT(N+2)
# 先頭と末尾に番兵を仕込む
bit.add(0, 1)
bit.add(N+1, 1)
ans = [0] * (N+1)
for a in range(1, N+1):
# a(1~N)が格納されているindex
idx = idxs[a]
# 左の終点と右の始点は各回固定なので先に取っておく
lend = bit.sum(idx)
rstart = bit.sum(idx)
# 自分より小さいindexで最初に自分より小さい値がある直前の場所
l = bisearch_min(-1, idx, calc1) + 1
# 自分より大きいindexで最初に自分より小さい値がある直前の場所
r = bisearch_min(idx, N+1, calc2) - 1
# aを使う回数 * a = 左端として使える範囲 * 右端として使える範囲 * a
ans[a] = (idx-l+1) * (r-idx+1) * a
# aを出現済とする
bit.add(idx, 1)
# 全てのaについての合計
print((sum(ans)))
| p03987 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
class BIT:
def __init__(self, n):
# 0-indexed
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
""" [0, i]を合計する """
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
""" 値の追加：添字i, 値x """
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def get(self, l, r=None):
""" 区間和の取得 [l, r) """
# 引数が1つなら一点の値を取得
if r is None: r = l + 1
res = 0
if r: res += self.sum(r-1)
if l: res -= self.sum(l-1)
return res
def bisearch_min(mn, mx, func):
""" 条件を満たす最小値を見つける二分探索 """
ok = mx
ng = mn
while ng+1 < ok:
mid = (ok+ng) // 2
if func(mid):
# 下を探しに行く
ok = mid
else:
# 上を探しに行く
ng = mid
return ok
# 右から1番目の値の位置
def calc1(m):
cnt = lend - bit.sum(m)
return cnt < 1
# 左から1番目の値の位置
def calc2(m):
cnt = bit.sum(m) - rstart
return cnt >= 1
N = INT()
A = LIST()
# aの昇順に処理できるようにindexで並べておく
idxs = [0] * (N+1)
for i, a in enumerate(A):
idxs[a] = i + 1
bit = BIT(N+2)
# 先頭と末尾に番兵を仕込む
bit.add(0, 1)
bit.add(N+1, 1)
ans = [0] * (N+1)
for a in range(1, N+1):
# a(1~N)が格納されているindex
idx = idxs[a]
# 左の終点と右の始点は各回固定なので先に取っておく
lend = bit.sum(idx)
rstart = bit.sum(idx)
# 自分より小さいindexで最初に自分より小さい値がある直前の場所
l = bisearch_min(-1, idx, calc1) + 1
# 自分より大きいindexで最初に自分より小さい値がある直前の場所
r = bisearch_min(idx, N+1, calc2) - 1
# aを使う回数 * a = 左端として使える範囲 * 右端として使える範囲 * a
ans[a] = (idx-l+1) * (r-idx+1) * a
# aを出現済とする
bit.add(idx, 1)
# 全てのaについての合計
print((sum(ans)))
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
class BIT:
def __init__(self, n):
# 0-indexed
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
""" [0, i]を合計する """
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
""" 値の追加：添字i, 値x """
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def get(self, l, r=None):
""" 区間和の取得 [l, r) """
# 引数が1つなら一点の値を取得
if r is None: r = l + 1
res = 0
if r: res += self.sum(r-1)
if l: res -= self.sum(l-1)
return res
def bisearch_left(self, l, r, x):
""" 区間l,rで左からx番目の値がある位置 """
l_val = self.sum(l)
ok = r
ng = l
while ng+1 < ok:
mid = (ok+ng) // 2
if self.sum(mid) - l_val >= x:
ok = mid
else:
ng = mid
return ok
def bisearch_right(self, l, r, x):
""" 区間l,rで右からx番目の値がある位置 """
r_val = self.sum(r)
ok = r
ng = l
while ng+1 < ok:
mid = (ok+ng) // 2
if r_val - self.sum(mid) < x:
ok = mid
else:
ng = mid
return ok
N = INT()
A = LIST()
# aの昇順に処理できるようにindexで並べておく
idxs = [0] * (N+1)
for i, a in enumerate(A):
idxs[a] = i + 1
bit = BIT(N+2)
# 先頭と末尾に番兵を仕込む
bit.add(0, 1)
bit.add(N+1, 1)
ans = [0] * (N+1)
for a in range(1, N+1):
# a(1~N)が格納されているindex
idx = idxs[a]
# 自分より小さいindexで最初に自分より小さい値がある直前の場所
l = bit.bisearch_right(-1, idx, 1) + 1
# 自分より大きいindexで最初に自分より小さい値がある直前の場所
r = bit.bisearch_left(idx, N+1, 1) - 1
# aを使う回数 * a = 左端として使える範囲 * 右端として使える範囲 * a
ans[a] = (idx-l+1) * (r-idx+1) * a
# aを出現済とする
bit.add(idx, 1)
# 全てのaについての合計
print((sum(ans)))
| p03987 |
import sys
class Node:
def __init__(self, key, value, height):
self.key = key #ノードの木
self.height = height #このノードを根とする部分木の高さ
self.value = value #ノードの値
self.left = None
self.right = None
def size(self, n): return 0 if n is None else n.height
def bias(self): #左の方が高いと正、右が高いと負の値を返す
return self.size(self.left) - self.size(self.right)
#木の高さの計算
def calcSize(self):
self.height = 1 + max(self.size(self.left), self.size(self.right))
class AVLTree:
def __init__(self):
self.root = None #根
self.change = False #修正フラグ
self.lmax = None #左部分木のキーの最大値
self.value = None #lmaxの値
###############
#回転操作, 修正操作
###############
def rotateL(self, n): #ノードnの左回転
r = n.right; rl = r.left
r.left = n; n.right = rl
r.left.calcSize()
r.calcSize()
return r
def rotateR(self, n):
l = n.left; lr = l.right
l.right = n; n.left = lr
l.right.calcSize()
l.calcSize()
return l
def rotateLR(self, n): #二重回転;左回転→右回転
n.left = self.rotateL(n.left)
return self.rotateR(n)
def rotateRL(self, n):
n.right = self.rotateR(n.right)
return self.rotateL(n)
def balanceL(self, n):
if not self.change: return n
h = n.height
if n.bias() == 2:
if n.left.bias() >= 0: n = self.rotateR(n)
else: n = self.rotateLR(n)
else: n.calcSize()
self.change = (h != n.height)
return n
def balanceR(self, n):
if not self.change: return n
h = n.height
if n.bias() == -2:
if n.right.bias() <= 0: n = self.rotateL(n)
else: n = self.rotateRL(n)
else: n.calcSize()
self.change = (h != n.height)
return n
###############
#Nodeの追加
###############
def insert(self, key, value): self.root = self.insert_sub(self.root, key, value)
def insert_sub(self, t, key, value): #新たなノードの挿入。初期位置は根。
if t is None:
self.change = True
return Node(key, value, 1)
if key < t.key:
t.left = self.insert_sub(t.left, key, value)
return self.balanceL(t)
elif key > t.key:
t.right = self.insert_sub(t.right, key, value)
return self.balanceR(t)
else:
self.change = False
t.value = value
return t
###############
#Nodeの削除
###############
def delete(self, key): self.root = self.delete_sub(self.root, key)
def delete_sub(self, t, key):
if t is None:
self.change = False
return None
if key < t.key:
t.left = self.delete_sub(t.left, key)
return self.balanceR(t)
elif key > t.key:
t.right - self.delete_sub(t.right, key)
return self.balanceL(t)
else:
if t.left is None:
self.change = True
return t.right
else:
t.left = self.delete_max(t.left)
t.key = self.lmax
t.value = self.value
return self.balanceR(t)
def delete_max(self, n):
if n.right is None: #nの右部分木が存在しない場合は左部分木を昇格させる
self.change = True
self.lmax = n.key
self.value = n.value
return n.left
else:
n.right = self.delete_max(n.right)
return self.balanceL(n)
###############
#Nodeの探索
###############
def search(self, key):
t = self.root
while t:
if key < t.key: t = t.left
elif key > t.key: t = t.right
else: return True
return False
def getValue(self, key):
t = self.root
while t:
if key < t.key: t = t.left
elif key > t.key: t = t.right
else: return t.value
return None
def lower_bound(self, key, leastValue):
t = self.root
bound = leastValue
while t:
if key <= t.key: t = t.left
else:
bound = t.key
t = t.right
return bound
def upper_bound(self, key, largestValue):
t = self.root
bound = largestValue
while t:
if key < t.key:
bound = t.key
t = t.left
else: t = t.right
return bound
def solve(): #デバッグ用コード
N = int(eval(input()))
A = [int(a) for a in input().split()]
Ai = dict()
for i in range(N): Ai[A[i]] = i
Tree = AVLTree()
ini = Ai[1]
Ans = 1 * (ini + 1) * (N - ini)
Tree.insert(ini, 1)
for i in range(2, N + 1):
ai = Ai[i]
Ans += i * (ai - Tree.lower_bound(ai, -1)) * (Tree.upper_bound(ai, N) - ai)
Tree.insert(ai, i)
print(Ans)
return 0
if __name__ == "__main__":
solve()
| import sys
class Node:
def __init__(self, key, height):
self.key = key #ノードの木
self.height = height #このノードを根とする部分木の高さ
self.left = None
self.right = None
def size(self, n): return 0 if n is None else n.height
def bias(self): #左の方が高いと正、右が高いと負の値を返す
return self.size(self.left) - self.size(self.right)
#木の高さの計算
def calcSize(self):
self.height = 1 + max(self.size(self.left), self.size(self.right))
class AVLTree:
def __init__(self):
self.root = None #根
self.change = False #修正フラグ
self.lmax = None #左部分木のキーの最大値
###############
#回転操作, 修正操作
###############
def rotateL(self, n): #ノードnの左回転
r = n.right; rl = r.left
r.left = n; n.right = rl
r.left.calcSize()
r.calcSize()
return r
def rotateR(self, n):
l = n.left; lr = l.right
l.right = n; n.left = lr
l.right.calcSize()
l.calcSize()
return l
def rotateLR(self, n): #二重回転;左回転→右回転
n.left = self.rotateL(n.left)
return self.rotateR(n)
def rotateRL(self, n):
n.right = self.rotateR(n.right)
return self.rotateL(n)
def balanceL(self, n):
if not self.change: return n
h = n.height
if n.bias() == 2:
if n.left.bias() >= 0: n = self.rotateR(n)
else: n = self.rotateLR(n)
else: n.calcSize()
self.change = (h != n.height)
return n
def balanceR(self, n):
if not self.change: return n
h = n.height
if n.bias() == -2:
if n.right.bias() <= 0: n = self.rotateL(n)
else: n = self.rotateRL(n)
else: n.calcSize()
self.change = (h != n.height)
return n
###############
#Nodeの追加
###############
def insert(self, key): self.root = self.insert_sub(self.root, key)
def insert_sub(self, t, key): #新たなノードの挿入。初期位置は根。
if t is None:
self.change = True
return Node(key, 1)
if key < t.key:
t.left = self.insert_sub(t.left, key)
return self.balanceL(t)
elif key > t.key:
t.right = self.insert_sub(t.right, key)
return self.balanceR(t)
else:
self.change = False
t.value = value
return t
###############
#Nodeの削除
###############
def delete(self, key): self.root = self.delete_sub(self.root, key)
def delete_sub(self, t, key):
if t is None:
self.change = False
return None
if key < t.key:
t.left = self.delete_sub(t.left, key)
return self.balanceR(t)
elif key > t.key:
t.right - self.delete_sub(t.right, key)
return self.balanceL(t)
else:
if t.left is None:
self.change = True
return t.right
else:
t.left = self.delete_max(t.left)
t.key = self.lmax
t.value = self.value
return self.balanceR(t)
def delete_max(self, n):
if n.right is None: #nの右部分木が存在しない場合は左部分木を昇格させる
self.change = True
self.lmax = n.key
self.value = n.value
return n.left
else:
n.right = self.delete_max(n.right)
return self.balanceL(n)
###############
#Nodeの探索
###############
def search(self, key, lower, higher):
t = self.root
lb, hb = lower, higher
while t:
if key < t.key:
hb = t.key
t = t.left
else:
lb = t.key
t = t.right
return lb, hb
def solve(): #デバッグ用コード
N = int(eval(input()))
A = [int(a) for a in input().split()]
Ai = dict()
for i, a in enumerate(A): Ai[a] = i
Tree = AVLTree()
ini = Ai[1]
Ans = 1 * (ini + 1) * (N - ini)
Tree.insert(ini)
for i in range(2, N + 1):
ai = Ai[i]
l, r = Tree.search(ai, -1, N)
Ans += i * (ai - l) * (r - ai)
Tree.insert(ai)
print(Ans)
return 0
if __name__ == "__main__":
solve()
| p03987 |
import bisect
N=int(eval(input()))
A=list(map(int,input().split()))
B=[i+1 for i in range(N)]
C=[]
for i in range(N):
C.append([A[i],B[i]])
C.sort()
L=[0,N+1]
ans=0
#print(C)
for i in range(N):
ans+=C[i][0]*(L[bisect.bisect_right(L,C[i][1])]-C[i][1])*(C[i][1]-L[bisect.bisect_left(L,C[i][1])-1])
L.insert(bisect.bisect_left(L,C[i][1]),C[i][1])
#print(ans,L)
#print(L)
print(ans) | import sys
sys.setrecursionlimit(1000000)
N=int(eval(input()))
a=list(map(int,input().split()))
b=[i for i in range(1,N+1)]
A=[]
for i in range(N):
A.append([a[i],b[i]])
A.sort(reverse=True)
#print(A)
PL=[i for i in range(N+1)]+[N+1]
PR=[i for i in range(N+1)]+[N+1]
def findL(x):
if x==PL[x]:
return x
else:
return findL(PL[x])
def findR(x):
if x==PR[x]:
return x
else:
return findR(PR[x])
#print(PR)
ans=0
for i in range(N):
ans+=A[i][0]*(A[i][1]-findL(A[i][1]-1))*(findR(A[i][1]+1)-A[i][1])
#print(ans,A[i][1],(A[i][1]-findL(A[i][1])+1),findR(A[i][1])-A[i][1]+1)
#print(PR)
PL[A[i][1]]=findL(A[i][1]-1)
PR[A[i][1]]=findR(A[i][1]+1)
print(ans) | p03987 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**10
mod = 10**9 + 7
def f():
n = int(eval(input()))
a = list(map(int, input().split()))
b = [0]*n
for _ in range(n):
b[a[_]-1] = _
r = (b[0]+1) * (n-b[0])
c = [b[0]]
m = 2
for i in b[1:]:
ri = bisect.bisect(c, i)
if ri == 0:
r += (i+1) * (c[ri]-i) * m
elif ri == m-1:
r += (i-c[ri-1]) * (n-i) * m
else:
r += (i-c[ri-1]) * (c[ri]-i) * m
m += 1
c = c[:ri] + [i] + c[ri:]
return r
print((f()))
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**10
mod = 10**9 + 7
def f():
n = int(eval(input()))
a = list(map(int, input().split()))
l = list(range(n+2))
r = list(range(n+2))
b = [0]*(n+2)
for i, x in enumerate(a, 1):
b[x] = i
c = 0
for i in range(n,0,-1):
bi = b[i]
c += i * (r[bi] - bi + 1) * (bi - l[bi] + 1)
r[l[bi]-1] = r[bi]
l[r[bi]+1] = l[bi]
return c
print((f()))
| p03987 |
def examA():
X = SI()
d = defaultdict(int)
for s in X:
if s=="T" and d["S"]>=1:
d["S"] -=1
else:
d[s] += 1
ans = d["S"] + d["T"]
print(ans)
return
def examB():
# じゅっぴーさんの
# https://juppy.hatenablog.com/entry/2019/02/11/%E8%9F%BB%E6%9C%AC_python_AVL%E6%9C%A8_%E6%A4%9C%E7%B4%A2%E6%8B%A1%E5%BC%B5_%E7%AB%B6%E6%8A%80%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0
###############################################################################
# root.search(x): ◯.data == x のものが存在するある場合それを出力、ない場合Noneを出力
# root.insert(x): ◯.data == xが存在する場合Falseを出力、ない場合◯.data == x なる頂点を作る
# y.to_s(): 頂点yのdataを出力
# y.left_s(): 頂点yのleftを出力(ない場合はNone)
# root.search_lower(x,None): ○.dataがxより小さいものの中で最も大きいものを出力、ない場合Noneを出力
# root.search_higher(x,None): xより大きいものの中で最も小さいものを出力、ない場合Noneを出力
################################################################################
class Avltree:
def __init__(self, key=None):
self.key = key
self.left = None
self.right = None
self.balance = "Even"
def search(self, key):
if self.key == None:
return None
if self.key > key:
if self.left == None:
return None
else:
return self.left.search(key)
if self.key < key:
if self.right == None:
return None
else:
return self.right.search(key)
return self # self.key == keyの場合
def search_lower(self, key, key_lower):
if self.key == None:
return key_lower
if self.key > key:
if self.left == None:
return key_lower
else:
return self.left.search_lower(key, key_lower)
if self.key < key:
key_lower = self.key
if self.right == None:
return key_lower
else:
return self.right.search_lower(key, key_lower)
# self.key == keyの場合
if self.left == None:
return key_lower
else:
if key_lower == None:
return self.left.end_higher(self.left.key)
else:
return max(key_lower, self.left.end_higher(self.left.key))
def search_higher(self, key, key_higher):
if self.key == None:
return key_higher
if self.key > key:
key_higher = self.key
if self.left == None:
return key_higher
else:
return self.left.search_higher(key, key_higher)
if self.key < key:
if self.right == None:
return key_higher
else:
return self.right.search_higher(key, key_higher)
# self.key == keyの場合
if self.right == None:
return key_higher
else:
if key_higher == None:
return self.right.end_lower(self.right.key)
else:
return min(key_higher, self.right.end_lower(self.right.key))
def end_lower(self, end_lower_key):
if self.left == None:
return end_lower_key
else:
end_lower_key = self.left.key
return self.left.end_lower(end_lower_key)
def end_higher(self, end_higher_key):
if self.right == None:
return end_higher_key
else:
end_higher_key = self.right.key
return self.right.end_higher(end_higher_key)
def DoubleRightRotation(self):
tl = self.left
self.left = tl.right.right
tl.right.right = self # selfはそのノード
tlr = tl.right
tl.right = tlr.left
tlr.left = tl
if tlr.balance == "Left":
tlr.right.balance = "Right"
tlr.left.balance = "Even"
elif tlr.balance == "Right":
tlr.right.balance = "Even"
tlr.left.balance = "Left"
elif tlr.balance == "Even":
tlr.right.balance = "Even"
tlr.left.balance = "Even"
tlr.balance = "Even"
return tlr
def DoubleLeftRotation(self):
tr = self.right
self.right = tr.left.left
tr.left.left = self
trl = tr.left
tr.left = trl.right
trl.right = tr
if trl.balance == "Right":
trl.left.balance = "Left"
trl.right.balance = "Even"
elif trl.balance == "Left":
trl.left.balance = "Even"
trl.right.balance = "Right"
elif trl.balance == "Even":
trl.left.balance = "Even"
trl.right.balance = "Even"
trl.balance = "Even"
return trl
def SingleLeftRotation(self):
tr = self.right
tr.balance = "Even"
self.balance = "Even"
self.right = tr.left
tr.left = self
return tr
def SingleRightRotation(self):
tl = self.left
tl.balance = "Even"
self.balance = "Even"
self.left = tl.right
tl.right = self
return tl
def replace(self, p, v): # 親ノードpの下にある自分(self)をvに置き換える。
if p.left == self:
p.left = v
else:
p.right = v
def insert(self, key): # rootでのみ呼ばれる挿入
if self.key == None: # rootを含むrotationはしないことにする。
self.key = key
return self
if key < self.key:
if self.left == None:
self.left = Avltree(key)
else:
self.left.insertx(self, key)
elif key > self.key:
if self.right == None:
self.right = Avltree(key)
else:
self.right.insertx(self, key)
else: # key == self.key:
pass # do not overwrite
def insertx(self, p, key): # replaceを呼ぶために一つ上の親を持っているinsert
if self.key > key:
if self.left == None:
self.left = Avltree(key)
else:
if not self.left.insertx(self, key): # 左の木が生長しなければ、
return False # 成長しない
if self.balance == "Right":
self.balance = "Even"
return False
elif self.balance == "Even":
self.balance = "Left"
return True # 成長した
elif self.balance == "Left":
if self.left.balance == "Right":
self.replace(p, self.DoubleRightRotation())
elif self.left.balance == "Left":
self.replace(p, self.SingleRightRotation())
return False # rotationを行うと成長しない
if self.key < key:
if self.right == None:
self.right = Avltree(key)
else:
if not self.right.insertx(self, key):
return False
if self.balance == "Left":
self.balance = "Even"
return False
elif self.balance == "Even":
self.balance = "Right"
return True
elif self.balance == "Right":
if self.right.balance == "Left":
self.replace(p, self.DoubleLeftRotation())
elif self.right.balance == "Right":
self.replace(p, self.SingleLeftRotation())
return False
return False # self.key == keyの時は何もしないので成長もしない
def to_s(self):
return self.key
def left_s(self):
if self.left == None:
return None
return (self.left).key
def right_s(self):
if self.right == None:
return None
return (self.right).key
################################################################
N = I()
A = LI()
lst = [0] * N
for i in range(N):
lst[A[i]-1] = i
AVL = Avltree()
ans = 0
for a in range(1,N+1):
i = lst[a-1]
l = AVL.search_lower(i,None)
r = AVL.search_higher(i,None)
AVL.insert(i)
#print(l,r)
if l==None:
l = -1
if r==None:
r = N
ans += (i-l)*(r-i)*a
#print(l,r,i,ans)
print(ans)
return
def examC():
ans = 0
print(ans)
return
def examD():
ans = 0
print(ans)
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
import sys,copy,bisect,itertools,heapq,math,random
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
if __name__ == '__main__':
examB()
"""
""" | def examA():
X = SI()
d = defaultdict(int)
for s in X:
if s=="T" and d["S"]>=1:
d["S"] -=1
else:
d[s] += 1
ans = d["S"] + d["T"]
print(ans)
return
def examB():
# 参考 earlgrey_yh
class Node:
def __init__(self, key, height):
self.key = key # ノードの木
self.height = height # このノードを根とする部分木の高さ
self.left = None
self.right = None
def size(self, n): return 0 if n is None else n.height
def bias(self): # 左の方が高いと正、右が高いと負の値を返す
return self.size(self.left) - self.size(self.right)
# 木の高さの計算
def calcSize(self):
self.height = 1 + max(self.size(self.left), self.size(self.right))
class AVLTree:
def __init__(self):
self.root = None # 根
self.change = False # 修正フラグ
###############
# 回転操作, 修正操作
###############
def rotateL(self, n): # ノードnの左回転
r = n.right;
rl = r.left
r.left = n;
n.right = rl
r.left.calcSize()
r.calcSize()
return r
def rotateR(self, n):
l = n.left;
lr = l.right
l.right = n;
n.left = lr
l.right.calcSize()
l.calcSize()
return l
def rotateLR(self, n): # 二重回転;左回転→右回転
n.left = self.rotateL(n.left)
return self.rotateR(n)
def rotateRL(self, n):
n.right = self.rotateR(n.right)
return self.rotateL(n)
def balanceL(self, n):
if not self.change: return n
h = n.height
if n.bias() == 2:
if n.left.bias() >= 0:
n = self.rotateR(n)
else:
n = self.rotateLR(n)
else:
n.calcSize()
self.change = (h != n.height)
return n
def balanceR(self, n):
if not self.change: return n
h = n.height
if n.bias() == -2:
if n.right.bias() <= 0:
n = self.rotateL(n)
else:
n = self.rotateRL(n)
else:
n.calcSize()
self.change = (h != n.height)
return n
###############
# Nodeの追加
###############
def insert(self, key):
self.root = self.insert_sub(self.root, key)
def insert_sub(self, t, key): # 新たなノードの挿入。初期位置は根。
if t is None:
self.change = True
return Node(key, 1)
if key < t.key:
t.left = self.insert_sub(t.left, key)
return self.balanceL(t)
elif key > t.key:
t.right = self.insert_sub(t.right, key)
return self.balanceR(t)
else:
self.change = False
return t
###############
# Nodeの探索
###############
def search(self, key, lower, higher):
t = self.root
lb, hb = lower, higher
while t:
if key < t.key:
hb = t.key
t = t.left
else:
lb = t.key
t = t.right
return lb, hb
N = I()
A = LI()
lst = [0] * N
for i in range(N):
lst[A[i]-1] = i
AVL = AVLTree()
ans = 0
for a in range(1,N+1):
i = lst[a-1]
l, r = AVL.search(i,-1,N)
AVL.insert(i)
#print(l,r)
ans += (i-l)*(r-i)*a
#print(l,r,i,ans)
print(ans)
return
def examC():
ans = 0
print(ans)
return
def examD():
ans = 0
print(ans)
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
import sys,copy,bisect,itertools,heapq,math,random
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
if __name__ == '__main__':
examB()
"""
""" | p03987 |
# 点更新，区間クエリ
class SegTree:
# n : 元の配列の長さ
# init_list: 元の配列
# segfunc : 載せる関数（演算）
# ide_ele : segfuncの単位元
def __init__(self, n, init_list ,segfunc, ide_ele):
# num : 2**num >= n となる最小の整数 （葉の数）
# seg : segtreeのリスト
self.num = 2**((n-1).bit_length())
self.seg = [ide_ele]*(2*self.num)
self.segfunc = segfunc
self.ide_ele = ide_ele
# 葉の要素をセット
for i in range(n):
self.seg[i+self.num-1] = init_list[i]
# segtreeの構築
for i in range(self.num-2, -1, -1):
self.seg[i] = segfunc(self.seg[2*i+1],self.seg[2*i+2])
#memo: 要素iの子ノードは要素2*i+1, 2*i+2
# : 要素iの親ノードは要素(i-1)//2
# 要素の更新 (init_list[k]=x)
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])
# 区間クエリ （区間[l,r)に対する演算結果）
def query(self, l,r):
if r<=l:
return self.ide_ele
l += self.num-1 #葉のノードのインデックス
r += self.num-2 #半開区間から閉区間へ
ret = self.ide_ele
while r-l>1:
if l&1 == 0:
ret = self.segfunc(ret,self.seg[l])
if r&1 == 1:
ret = self.segfunc(ret,self.seg[r])
r -= 1
# 親ノードへ遷移
l = l//2
r = (r-1)//2
if r==l:
ret = self.segfunc(ret, self.seg[r])
else:
ret = self.segfunc(ret, self.seg[l])
ret = self.segfunc(ret, self.seg[r])
return ret
def segfunc(x,y):
return x or y
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int,input().split()))
#%%
idxlist = [0]*N
for i,a in enumerate(A):
idxlist[a-1] = i
ans = 0
seg = SegTree(N,[0]*N,segfunc,0)
def judge(l,r):
if l>r:
l,r = r,l
res = seg.query(l,r+1)
if res:
return False
else:
return True
for idx in idxlist:
ng_l = -1
ng_r = N
left = idx
while abs(left-ng_l)>1:
mid = (left+ng_l)//2
if judge(idx,mid):
left = mid
else:
ng_l = mid
right = idx
while abs(ng_r-right)>1:
mid = (right+ng_r)//2
if judge(idx,mid):
right = mid
else:
ng_r = mid
ans += A[idx]*(idx-left+1)*(right-idx+1)
seg.update(idx,1)
print(ans)
|
# 1-indexed Binary Indexed Tree
class BIT:
def __init__(self, n, init_list):
self.num = n+1
self.tree = [0]*self.num
for i,e in enumerate(init_list):
self.update(i,e)
def update(self,k,x):
k = k+1
while k < self.num:
self.tree[k] += x
k += (k&(-k))
return
# sum([l,r))
def query(self, l,r):
ret = 0
while r>0:
ret += self.tree[r]
r -= r&(-r)
while l>0:
ret -= self.tree[l]
l -= l&(-l)
return ret
N = int(eval(input()))
A = list(map(int,input().split()))
#%%
idxlist = [0]*N
for i,a in enumerate(A):
idxlist[a-1] = i
ans = 0
seg = BIT(N,[0]*N)
def judge(l,r):
if l>r:
l,r = r,l
res = seg.query(l,r+1)
if res:
return False
else:
return True
for idx in idxlist:
ng_l = -1
ng_r = N
left = idx
while abs(left-ng_l)>1:
mid = (left+ng_l)//2
if judge(idx,mid):
left = mid
else:
ng_l = mid
right = idx
while abs(ng_r-right)>1:
mid = (right+ng_r)//2
if judge(idx,mid):
right = mid
else:
ng_r = mid
ans += A[idx]*(idx-left+1)*(right-idx+1)
seg.update(idx,1)
print(ans)
| p03987 |
def main():
n=int(eval(input()))
a=list(map(int,input().split()))
def func(l,i):
ret=l*(l+1)//2
ret-=i*(i+1)//2
ret-=(l-i-1)*(l-i)//2
return ret
dn={a[i]:i+1 for i in range(n)}
from bisect import bisect_left,insort
space=[0,n+1]
ans=0
for i in range(1,n+1):
t=dn[i]
tl=bisect_left(space,t)
l=space[tl-1]
r=space[tl]
lg=r-l-1
ans+=func(lg,t-l-1)*i
insort(space,t)
print(ans)
if __name__=='__main__':
main() | n=int(eval(input()))
p=list(map(int,input().split()))
dn={x:i for i,x in enumerate(p)}
#####segfunc#####
def segfunc(x, y):
return x+y
#################
#####ide_ele#####
ide_ele = 0
#################
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc=segfunc, ide_ele=ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
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番目の値をxに更新
k: index(0-index)
x: update value
"""
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):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
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
st=SegTree([0]*n)
ans=0
for k in range(1,n+1):
i=dn[k]
# idx=iを含み、区間和が0になる最長の区間を調べる。
l,r=0,i
while r-l>1:
x=(l+r)//2
if st.query(x,i+1)>0:
l,r=x,r
else:
l,r=l,x
l0=l if st.query(l,i+1)==0 else r
l,r=i,n-1
while r-l>1:
x=(l+r)//2
if st.query(i,x+1)>0:
l,r=l,x
else:
l,r=x,r
r0=r if st.query(i,r+1)==0 else l
ans+=k*(i-l0+1)*(r0-i+1)
st.update(i,1)
print(ans) | p03987 |
#!/usr/bin/env python3
class UnionFind:
__slots__ = ['id','sz']
def __init__(self, n):
self.id = [-1] * n
def root(self, x):
if self.id[x] < 0:
return x
else:
self.id[x] = self.root(self.id[x])
return self.id[x]
def find(self, x, y):
return uf.root(x) == uf.root(y)
def union(self, x, y):
s1, s2 = self.root(x), self.root(y)
if s1 != s2:
if self.id[s1] <= self.id[s2]:
self.id[s1] += self.id[s2]
self.id[s2] = s1
else:
self.id[s2] += self.id[s1]
self.id[s1] = s2
return True
return False
n = int(eval(input()))
a = list(map(int,input().split()))
uf = UnionFind(n)
ans=0
data=[0]*n
b=[0]*(n+1)
for i in range(n):
b[a[i]]=i
for i in range(n,0,-1):
r,l=0,0
data[b[i]]=i
if b[i]+1 <= n-1:
if data[b[i]+1]>0:
uf.union(b[i],b[i]+1)
r=-uf.id[uf.root(b[i])]
if b[i]-1>=0 and data[b[i]-1]>0:
uf.union(b[i],b[i]-1)
l=1-uf.id[uf.root(b[i])]-r
ans+=(r*l)*i
print(ans)
| #!/usr/bin/env python3
ans=0
n=int(eval(input()))
A=list(map(int,input().split()))
B=[0]*(n+1)
for i in range(n):
B[A[i]]=i+1
LL=[int(i) for i in range(n+2)]
RR=[int(i) for i in range(n+2)]
for i in range(n,0,-1):
l=LL[B[i]]
r=RR[B[i]]
ans+=(B[i]-l+1)*(r-B[i]+1)*i
LL[r+1]=l
RR[l-1]=r
print(ans)
| p03987 |
import bisect
class BTreeNode:
def __init__(self):
self.key = []
self.child = []
class BTree:
def __init__(self):
self.root = BTreeNode()
def search_higher(self, key):
ptr = self.root
ret = None
while ptr.child:
i = bisect.bisect_right(ptr.key, key)
if i != len(ptr.key):
ret = ptr.key[i]
ptr = ptr.child[i]
i = bisect.bisect_right(ptr.key, key)
if i != len(ptr.key):
ret = ptr.key[i]
return ret
def search_lower(self, key):
ptr = self.root
ret = None
while ptr.child:
i = bisect.bisect_left(ptr.key, key)
if i != 0:
ret = ptr.key[i - 1]
ptr = ptr.child[i]
i = bisect.bisect_left(ptr.key, key)
if i != 0:
ret = ptr.key[i - 1]
return ret
def insert(self, key):
def insert_rec(ptr):
b_size = 512
if not ptr.child:
bisect.insort(ptr.key, key)
if len(ptr.key) == b_size * 2 - 1:
ret = BTreeNode()
ret.key = ptr.key[:b_size]
ptr.key = ptr.key[b_size:]
return ret
else:
i = bisect.bisect(ptr.key, key)
temp = insert_rec(ptr.child[i])
if temp is not None:
ptr.key.insert(i, temp.key.pop(-1))
ptr.child.insert(i, temp)
if len(ptr.child) == b_size * 2:
ret = BTreeNode()
ret.child = ptr.child[:b_size]
ptr.child = ptr.child[b_size:]
ret.key = ptr.key[:b_size]
ptr.key = ptr.key[b_size:]
return ret
return None
temp = insert_rec(self.root)
if temp is not None:
root = BTreeNode()
root.key = [temp.key.pop(-1)]
root.child = [temp, self.root]
self.root = root
def dump(self):
def dump_rec(ptr, dep):
for _ in range(0, dep):
print(" ", end="")
print(ptr.key)
for c in ptr.child:
dump_rec(c, dep + 1)
dump_rec(self.root, 0)
print("")
def main():
n,*a=map(int,open(0).read().split())
l=[0]*n
for i,v in enumerate(a,1):l[v-1]=i
t=BTree()
t.insert(0)
t.insert(n+1)
c=0
for i,v in enumerate(l,1):
c+=(t.search_higher(v)-v)*(v-t.search_lower(v))*i
t.insert(v)
print(c)
main()
| from bisect import*
class BTreeNode:
def __init__(self):self.key,self.child=[],[]
class BTree:
def __init__(self):self.root=BTreeNode()
def search_higher(self,key):
ptr=self.root
ret=None
while ptr.child:
i=bisect(ptr.key,key)
if i!=len(ptr.key):ret=ptr.key[i]
ptr=ptr.child[i]
i=bisect(ptr.key,key)
if i!=len(ptr.key):ret=ptr.key[i]
return ret
def search_lower(self,key):
ptr=self.root
ret=None
while ptr.child:
i=bisect_left(ptr.key,key)
if i:ret=ptr.key[i-1]
ptr=ptr.child[i]
i=bisect_left(ptr.key,key)
if i:ret=ptr.key[i-1]
return ret
def insert(self,key):
def insert_rec(ptr,key):
b_size=512
if not ptr.child:
insort(ptr.key,key)
if len(ptr.key)==b_size*2-1:
ret=BTreeNode()
ret.key=ptr.key[:b_size]
ptr.key=ptr.key[b_size:]
return ret
else:
i=bisect(ptr.key,key)
tmp=insert_rec(ptr.child[i],key)
if tmp:
ptr.key.insert(i,tmp.key.pop())
ptr.child.insert(i,tmp)
if len(ptr.child)==b_size*2:
ret=BTreeNode()
ret.child=ptr.child[:b_size]
ptr.child=ptr.child[b_size:]
ret.key=ptr.key[:b_size]
ptr.key=ptr.key[b_size:]
return ret
return None
tmp=insert_rec(self.root,key)
if tmp:
root=BTreeNode()
root.key=[tmp.key.pop()]
root.child=[tmp,self.root]
self.root=root
def main():
n,*a=list(map(int,open(0).read().split()))
l=[0]*n
for i,v in enumerate(a,1):l[v-1]=i
t=BTree()
t.insert(0)
t.insert(n+1)
c=0
for i,v in enumerate(l,1):
c+=(t.search_higher(v)-v)*(v-t.search_lower(v))*i
t.insert(v)
print(c)
main() | p03987 |
from bisect import*
class BTreeNode:
def __init__(self):self.key,self.child=[],[]
class BTree:
def __init__(self):self.root=BTreeNode()
def search_higher(self,key):
ptr=self.root
ret=None
while ptr.child:
i=bisect(ptr.key,key)
if i!=len(ptr.key):ret=ptr.key[i]
ptr=ptr.child[i]
i=bisect(ptr.key,key)
if i!=len(ptr.key):ret=ptr.key[i]
return ret
def search_lower(self,key):
ptr=self.root
ret=None
while ptr.child:
i=bisect_left(ptr.key,key)
if i:ret=ptr.key[i-1]
ptr=ptr.child[i]
i=bisect_left(ptr.key,key)
if i:ret=ptr.key[i-1]
return ret
def insert(self,key):
def insert_rec(ptr):
b_size=512
if not ptr.child:
insort(ptr.key,key)
if len(ptr.key)==b_size*2-1:
ret=BTreeNode()
ret.key=ptr.key[:b_size]
ptr.key=ptr.key[b_size:]
return ret
else:
i=bisect(ptr.key,key)
tmp=insert_rec(ptr.child[i])
if tmp:
ptr.key.insert(i,tmp.key.pop())
ptr.child.insert(i,tmp)
if len(ptr.child)==b_size*2:
ret=BTreeNode()
ret.child=ptr.child[:b_size]
ptr.child=ptr.child[b_size:]
ret.key=ptr.key[:b_size]
ptr.key=ptr.key[b_size:]
return ret
tmp=insert_rec(self.root)
if tmp:
root=BTreeNode()
root.key=[tmp.key.pop()]
root.child=[tmp,self.root]
self.root=root
def main():
n,*a=list(map(int,open(0).read().split()))
l=[0]*n
for i,v in enumerate(a,1):l[v-1]=i
t=BTree()
t.insert(0)
t.insert(n+1)
c=0
for i,v in enumerate(l,1):
c+=(t.search_higher(v)-v)*(v-t.search_lower(v))*i
t.insert(v)
print(c)
main() | from bisect import*
class BTreeNode:
def __init__(self):self.key,self.child=[],[]
root=BTreeNode()
def main():
def search_higher(key):
ptr=root
ret=None
while ptr.child:
i=bisect(ptr.key,key)
if i!=len(ptr.key):ret=ptr.key[i]
ptr=ptr.child[i]
i=bisect(ptr.key,key)
if i!=len(ptr.key):ret=ptr.key[i]
return ret
def search_lower(key):
ptr=root
ret=None
while ptr.child:
i=bisect_left(ptr.key,key)
if i:ret=ptr.key[i-1]
ptr=ptr.child[i]
i=bisect_left(ptr.key,key)
if i:ret=ptr.key[i-1]
return ret
def insert_rec(ptr,key):
b_size=512
if not ptr.child:
insort(ptr.key,key)
if len(ptr.key)==b_size*2-1:
ret=BTreeNode()
ret.key=ptr.key[:b_size]
ptr.key=ptr.key[b_size:]
return ret
else:
i=bisect(ptr.key,key)
tmp=insert_rec(ptr.child[i],key)
if tmp:
ptr.key.insert(i,tmp.key.pop())
ptr.child.insert(i,tmp)
if len(ptr.child)==b_size*2:
ret=BTreeNode()
ret.child=ptr.child[:b_size]
ptr.child=ptr.child[b_size:]
ret.key=ptr.key[:b_size]
ptr.key=ptr.key[b_size:]
return ret
def insert(key):
global root
tmp=insert_rec(root,key)
if tmp:
p=BTreeNode()
p.key=[tmp.key.pop()]
p.child=[tmp,root]
root=p
n,*a=list(map(int,open(0).read().split()))
l=[0]*n
for i,v in enumerate(a,1):l[v-1]=i
insert(0)
insert(n+1)
c=0
for i,v in enumerate(l,1):
c+=(search_higher(v)-v)*(v-search_lower(v))*i
insert(v)
print(c)
main() | p03987 |
from bisect import*
class BTreeNode:
def __init__(self):self.key,self.child=[],[]
def main():
root=BTreeNode()
def search_higher(key):
ptr=root
ret=None
while ptr.child:
i=bisect(ptr.key,key)
if i!=len(ptr.key):ret=ptr.key[i]
ptr=ptr.child[i]
i=bisect(ptr.key,key)
if i!=len(ptr.key):ret=ptr.key[i]
return ret
def search_lower(key):
ptr=root
ret=None
while ptr.child:
i=bisect_left(ptr.key,key)
if i:ret=ptr.key[i-1]
ptr=ptr.child[i]
i=bisect_left(ptr.key,key)
if i:ret=ptr.key[i-1]
return ret
def insert_rec(ptr,key):
b_size=512
if not ptr.child:
insort(ptr.key,key)
if len(ptr.key)==b_size*2-1:
ret=BTreeNode()
ret.key=ptr.key[:b_size]
ptr.key=ptr.key[b_size:]
return ret
else:
i=bisect(ptr.key,key)
tmp=insert_rec(ptr.child[i],key)
if tmp:
ptr.key.insert(i,tmp.key.pop())
ptr.child.insert(i,tmp)
if len(ptr.child)==b_size*2:
ret=BTreeNode()
ret.child=ptr.child[:b_size]
ptr.child=ptr.child[b_size:]
ret.key=ptr.key[:b_size]
ptr.key=ptr.key[b_size:]
return ret
def insert(key):
tmp=insert_rec(root,key)
if tmp:root.key,root.child=[tmp.key.pop()],[tmp,root]
n,*a=list(map(int,open(0).read().split()))
l=[0]*n
for i,v in enumerate(a,1):l[v-1]=i
insert(0)
insert(n+1)
c=0
for i,v in enumerate(l,1):
c+=(search_higher(v)-v)*(v-search_lower(v))*i
insert(v)
print(c)
main() | from bisect import*
class BTreeNode:
def __init__(self):self.key,self.child=[],[]
class BTree:
def __init__(self):self.root=BTreeNode()
def search_higher(self,key):
ptr=self.root
ret=None
while ptr.child:
i=bisect(ptr.key,key)
if i!=len(ptr.key):ret=ptr.key[i]
ptr=ptr.child[i]
i=bisect(ptr.key,key)
if i!=len(ptr.key):ret=ptr.key[i]
return ret
def search_lower(self,key):
ptr=self.root
ret=None
while ptr.child:
i=bisect_left(ptr.key,key)
if i:ret=ptr.key[i-1]
ptr=ptr.child[i]
i=bisect_left(ptr.key,key)
if i:ret=ptr.key[i-1]
return ret
def insert(self,key):
def insert_rec(ptr):
b_size=256
if not ptr.child:
insort(ptr.key,key)
if len(ptr.key)==b_size*2-1:
ret=BTreeNode()
ret.key=ptr.key[:b_size]
ptr.key=ptr.key[b_size:]
return ret
else:
i=bisect(ptr.key,key)
tmp=insert_rec(ptr.child[i])
if tmp:
ptr.key.insert(i,tmp.key.pop())
ptr.child.insert(i,tmp)
if len(ptr.child)==b_size*2:
ret=BTreeNode()
ret.child=ptr.child[:b_size]
ptr.child=ptr.child[b_size:]
ret.key=ptr.key[:b_size]
ptr.key=ptr.key[b_size:]
return ret
tmp=insert_rec(self.root)
if tmp:
root=BTreeNode()
root.key=[tmp.key.pop()]
root.child=[tmp,self.root]
self.root=root
def main():
n,*a=list(map(int,open(0).read().split()))
l=[0]*n
for i,v in enumerate(a,1):l[v-1]=i
t=BTree()
t.insert(0)
t.insert(n+1)
c=0
for i,v in enumerate(l,1):
c+=(t.search_higher(v)-v)*(v-t.search_lower(v))*i
t.insert(v)
print(c)
main() | p03987 |
from bisect import*
class BTreeNode:
def __init__(self):self.key,self.child=[],[]
class BTree:
def __init__(self):self.root=BTreeNode()
def search_higher(self,key):
ptr=self.root
ret=None
while ptr.child:
i=bisect(ptr.key,key)
if i!=len(ptr.key):ret=ptr.key[i]
ptr=ptr.child[i]
i=bisect(ptr.key,key)
if i!=len(ptr.key):ret=ptr.key[i]
return ret
def search_lower(self,key):
ptr=self.root
ret=None
while ptr.child:
i=bisect_left(ptr.key,key)
if i:ret=ptr.key[i-1]
ptr=ptr.child[i]
i=bisect_left(ptr.key,key)
if i:ret=ptr.key[i-1]
return ret
def insert(self,key):
def insert_rec(ptr):
b_size=256
if not ptr.child:
insort(ptr.key,key)
if len(ptr.key)==b_size*2-1:
ret=BTreeNode()
ret.key=ptr.key[:b_size]
ptr.key=ptr.key[b_size:]
return ret
else:
i=bisect(ptr.key,key)
tmp=insert_rec(ptr.child[i])
if tmp:
ptr.key.insert(i,tmp.key.pop())
ptr.child.insert(i,tmp)
if len(ptr.child)==b_size*2:
ret=BTreeNode()
ret.child=ptr.child[:b_size]
ptr.child=ptr.child[b_size:]
ret.key=ptr.key[:b_size]
ptr.key=ptr.key[b_size:]
return ret
tmp=insert_rec(self.root)
if tmp:
root=BTreeNode()
root.key=[tmp.key.pop()]
root.child=[tmp,self.root]
self.root=root
def main():
n,*a=list(map(int,open(0).read().split()))
l=[0]*n
for i,v in enumerate(a,1):l[v-1]=i
t=BTree()
insert,search_higher,search_lower=t.insert,t.search_higher,t.search_lower
insert(0)
insert(n+1)
c=0
for i,v in enumerate(l,1):
c+=(search_higher(v)-v)*(v-search_lower(v))*i
insert(v)
print(c)
main() | from bisect import*
class SqrtSet:
def __init__(self,block_limit=201):
self.key=[]
self.child=[[]]
self.block_limit=block_limit
def search_lower(self,key):
if not key:return None
ret=None
i=bisect_left(self.key,key)
if i:ret=self.key[i-1]
block=self.child[i]
i=bisect_left(block,key)
if i:ret=block[i-1]
return ret
def search_higher(self,key):
if not key:return None
ret=None
i=bisect(self.key,key)
if i<len(self.key):ret=self.key[i]
block=self.child[i]
i=bisect(block,key)
if i<len(block):ret=block[i]
return ret
def insert(self,key):
i=bisect(self.key,key)
block=self.child[i]
insort(block,key)
if len(block)==self.block_limit:
sep=self.block_limit//2
self.key.insert(i,block[sep])
self.child.insert(i+1,block[sep+1:])
self.child[i]=block[:sep]
def main():
n,*a=list(map(int,open(0).read().split()))
l=[0]*n
for i,v in enumerate(a,1):l[v-1]=i
t=SqrtSet()
t.insert(0)
t.insert(n+1)
c=0
for i,v in enumerate(l,1):
c+=(t.search_higher(v)-v)*(v-t.search_lower(v))*i
t.insert(v)
print(c)
main() | p03987 |
from bisect import*
class SqrtSet:
def __init__(self,block_limit=201):
self.key=[]
self.child=[[]]
self.block_limit=block_limit
def search_lower(self,key):
if not key:return None
ret=None
i=bisect_left(self.key,key)
if i:ret=self.key[i-1]
block=self.child[i]
i=bisect_left(block,key)
if i:ret=block[i-1]
return ret
def search_higher(self,key):
if not key:return None
ret=None
i=bisect(self.key,key)
if i<len(self.key):ret=self.key[i]
block=self.child[i]
i=bisect(block,key)
if i<len(block):ret=block[i]
return ret
def insert(self,key):
i=bisect(self.key,key)
block=self.child[i]
insort(block,key)
if len(block)==self.block_limit:
sep=self.block_limit//2
self.key.insert(i,block[sep])
self.child.insert(i+1,block[sep+1:])
self.child[i]=block[:sep]
def main():
n,*a=list(map(int,open(0).read().split()))
l=[0]*n
for i,v in enumerate(a,1):l[v-1]=i
t=SqrtSet()
t.insert(0)
t.insert(n+1)
c=0
for i,v in enumerate(l,1):
c+=(t.search_higher(v)-v)*(v-t.search_lower(v))*i
t.insert(v)
print(c)
main() | class UnionFind():
def __init__(self,size):
self.table=[-1]*size
def root(self,x):
while self.table[x]>=0:
x=self.table[x]
return x
def unite(self,x,y):
s1=self.root(x)
s2=self.root(y)
if s1!=s2:
if self.table[s1]>self.table[s2]:
s1,s2=s2,s1
self.table[s1]+=self.table[s2]
self.table[s2]=s1
return
def same(self,x,y):
return self.root(x)==self.root(y)
def size(self,x):
return -self.table[self.root(x)]
n,*a=list(map(int,open(0).read().split()))
u=UnionFind(n)
b=[0]*n
for i,t in enumerate(a):b[t-1]=i
c=0
for k in b[::-1]:
l=r=1
if k>0 and a[k-1]>a[k]:
l+=u.size(k-1)
u.unite(k-1,k)
if k+1<n and a[k+1]>a[k]:
r+=u.size(k+1)
u.unite(k+1,k)
c+=l*r*a[k]
print(c) | p03987 |
import bisect
n = int(eval(input()))
a = [int(i) for i in input().split()]
b = [0 for i in range(n)]
for i in range(n): b[a[i]-1] = i
ans,c = (b[0]+1)*(n-b[0]),[b[0]]
for i in range(1,n):
x = bisect.bisect_left(c,b[i])
if 0<x<len(c): ans += (c[x]-b[i])*(b[i]-c[x-1])*(i+1)
elif x==0: ans += (c[0]-b[i])*(b[i]+1)*(i+1)
elif x==len(c): ans += (b[i]-c[-1])*(n-b[i])*(i+1)
bisect.insort_left(c,b[i])
print(ans) | n = int(eval(input()))
a = [int(i) for i in input().split()]
b,l,r,ans = [0]*(n+1),[i for i in range(n+2)],[i for i in range(n+2)],0
for i in range(n): b[a[i]]=i
for i in range(n,0,-1):
m = b[i]
x,y = l[m],r[m]
ans+=i*(m-x+1)*(y-m+1)
l[y+1],r[x-1] = x,y
print(ans) | p03987 |
import sys
sys.setrecursionlimit(2*10**5)
n = int(eval(input()))
a = list(map(int, input().split()))
# aのindexを前計算
d = {}
for i,j in enumerate(a):
d[j] = i
# segtree
data = [float("inf")]*(2*n)
# a_k の値を x に更新
def update(k, x):
k += n-1
data[k] = x
while k >= 0:
k = (k - 1) // 2
data[k] = min(data[2*k+1], data[2*k+2])
# 区間[l, r)の最小値
def query(l, r):
L = l + n; R = r + n
s = float("inf")
while L < R:
if R & 1:
R -= 1
s = min(s, data[R-1])
if L & 1:
s = min(s, data[L-1])
L += 1
L >>= 1; R >>= 1
return s
# initialize
for i, j in enumerate(a):
update(i,j)
# 区間[left, right)が与えられた場合の和を求める再帰
def rec(left=0, right=n):
if left==right:
return 0
# O(logN)
min_ = query(left, right)
ind = d[min_]
res = min_*(right-ind)*(ind+1-left)
res += rec(left, ind)
res += rec(ind+1,right)
return res
print((rec())) | n = int(eval(input()))
a = list(map(int, input().split()))
d = {}
for i,j in enumerate(a):
d[j] = i
uf = [-1]*n
def root(a):
if uf[a] < 0:
return a
uf[a] = root(uf[a])
return uf[a]
def unite(a,b):
ra,rb = root(a),root(b)
if ra==rb:
return False
if uf[ra] > uf[rb]:
ra,rb = rb,ra
uf[ra] += uf[rb]
uf[rb] = ra
return True
ans = 0
for i in range(n,0,-1):
left=right=0
ind = d[i]
if ind<n-1 and a[ind] < a[ind+1]:
right -= uf[root(ind+1)]
unite(ind, ind+1)
if ind>0 and a[ind] < a[ind-1]:
left -= uf[root(ind-1)]
unite(ind, ind-1)
ans += i*(left+1)*(right+1)
print(ans) | p03987 |
N = int(eval(input()))
A = [int(_) for _ in input().split()]
dp = [-1] * (N + 1)
count = [0] * N
for i in range(N):
count[i] = i - dp[A[i]]
dp = dp[:A[i]] + [i] * (N - A[i] + 1)
dp_r = [N] * (N + 1)
ans = 0
for i in range(N - 1, -1, -1):
ans += A[i] * (dp_r[A[i]] - i) * count[i]
dp_r = dp_r[:A[i]] + [i] * (N - A[i] + 1)
print(ans)
| N = int(eval(input()))
A = [int(_) for _ in input().split()]
left = list(range(N + 2))
right = list(range(N + 2))
index = {A[i - 1]: i for i in range(1, N + 1)}
ans = 0
for a in range(N, 0, -1):
i = index[a]
l = left[i]
r = right[i]
ans += a * (i - l + 1) * (r - i + 1)
left[r + 1] = l
right[l - 1] = r
print(ans)
| p03987 |
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
def main(N, A):
ans = 0
Ai = [(a, i + 1) for i, a in enumerate(A)]
Ai.sort(key=lambda x: x[0])
st = SegmentTree(n=N + 2, f=lambda x, y: x + y)
st.set_val(0, 1)
st.set_val(N + 1, 1)
for a, i in Ai:
lc = st.query(0, i)
l = st.bisect_left(lambda x: x < lc)
r = st.bisect_left(lambda x: x < lc + 1)
ans += a * (i - l) * (r - i)
st.set_val(i, 1)
print(ans)
class SegmentTree:
def __init__(self, n=None, f=max, identity_factory=int, initial_values=None):
assert(n or initial_values)
size = n if n else len(initial_values)
d = [identity_factory() for _ in range(2 * size + 1)]
self.__n, self.__d, self.__f, self.__e = size, d, f, identity_factory
if initial_values:
for i, v in enumerate(initial_values): d[size + i] = v
for i in range(size - 1, 0, -1): d[i] = f(d[i << 1], d[i << 1 | 1])
def get_val(self, index):
return self.__d[index + self.__n]
def set_val(self, index, new_value):
i, d, f = index + self.__n, self.__d, self.__f
if d[i] == new_value: return
d[i] = new_value
i = i >> 1
while i:
d[i] = f(d[i << 1], d[i << 1 | 1])
i = i >> 1
def modify(self, index, value):
self.set_val(index, self.__f(self.__d[index + self.__n], value))
def query(self, from_inclusive, to_exclusive):
ans = self.__e()
if to_exclusive <= from_inclusive: return ans
l, r, d, f = from_inclusive + self.__n, to_exclusive + self.__n, self.__d, self.__f
while l < r:
if l & 1: ans, l = f(ans, d[l]), l + 1
if r & 1: ans, r = f(d[r - 1], ans), r - 1
l, r = l >> 1, r >> 1
return ans
def bisect_left(self, func):
'''func()がFalseになるもっとも左のindexを探す
'''
i, n, f, d, v = 1, self.__n, self.__f, self.__d, self.__e()
i = n
j = n + n
while i < j:
if i & 1:
nv = f(v, d[i])
if not func(nv):
break
v = nv
i += 1
i >>= 1
j >>= 1
while i < n:
nv = f(v, d[i << 1])
if func(nv):
v, i = nv, i << 1 | 1
else:
i = i << 1
return i - n
if __name__ == '__main__':
input = sys.stdin.readline
N = int(eval(input()))
*A, = list(map(int, input().split()))
main(N, A)
| # でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
def main(N, A):
ans = 0
Ai = [(a, i + 1) for i, a in enumerate(A)]
Ai.sort(key=lambda x: x[0])
st = SegmentTree(n=N + 2, f=lambda x, y: x + y)
st.set_val(0, 1)
st.set_val(N + 1, 1)
for a, i in Ai:
lc = st.query(0, i)
l = st.bisect_left(lambda x: x < lc)
r = st.bisect_left(lambda x: x < lc + 1)
ans += a * (i - l) * (r - i)
st.set_val(i, 1)
print(ans)
class SegmentTree:
def __init__(self, n=None, f=max, identity_factory=int, initial_values=None):
assert(n or initial_values)
size = n if n else len(initial_values)
d = [identity_factory() for _ in range(2 * size + 1)]
self.__n, self.__d, self.__f, self.__e = size, d, f, identity_factory
if initial_values:
for i, v in enumerate(initial_values): d[size + i] = v
for i in range(size - 1, 0, -1): d[i] = f(d[i << 1], d[i << 1 | 1])
def get_val(self, index):
return self.__d[index + self.__n]
def set_val(self, index, new_value):
i, d, f = index + self.__n, self.__d, self.__f
if d[i] == new_value: return
d[i], i = new_value, i >> 1
while i:
d[i], i = f(d[i << 1], d[i << 1 | 1]), i >> 1
def modify(self, index, value):
self.set_val(index, self.__f(self.__d[index + self.__n], value))
def query(self, from_inclusive, to_exclusive):
ans = self.__e()
if to_exclusive <= from_inclusive: return ans
l, r, d, f = from_inclusive + self.__n, to_exclusive + self.__n, self.__d, self.__f
while l < r:
if l & 1: ans, l = f(ans, d[l]), l + 1
if r & 1: ans, r = f(d[r - 1], ans), r - 1
l, r = l >> 1, r >> 1
return ans
def bisect_left(self, func):
'''func()がFalseになるもっとも左のindexを探す
'''
i, j, n, f, d, v = self.__n, self.__n + self.__n, self.__n, self.__f, self.__d, self.__e()
while i < j:
if i & 1:
nv = f(v, d[i])
if not func(nv): break
v, i = nv, i + 1
i, j = i >> 1, j >> 1
while i < n:
nv = f(v, d[i << 1])
if func(nv): v, i = nv, i << 1 | 1
else: i = i << 1
return i - n
if __name__ == '__main__':
input = sys.stdin.readline
N = int(eval(input()))
*A, = list(map(int, input().split()))
main(N, A)
| p03987 |
#!/usr/bin/env python3
import sys
import random
class Node(object):
__slots__ = ['value', 'cnt', 'pri', 'lch', 'rch']
def __init__(self, value):
self.value = value
self.cnt = 1
self.pri = random.randint(1, 1 << 64)
self.lch = None
self.rch = None
def __iter__(self):
if self.lch is not None:
for x in self.lch.__iter__():
yield x
yield self.value
if self.rch is not None:
for x in self.rch.__iter__():
yield x
def __repr__(self):
return '{}'.format(self.value)
class Treap(object):
def __init__(self):
self.root = None
def __iter__(self):
if self.root is None:
pass
else:
for v in self.root:
yield v
def __repr__(self):
return "[{}]".format(", ".join(map(str, self)))
def count(self, node):
if node is None:
return 0
return node.cnt
def total(self, node):
if node is None:
return 0
return node.ttl
def update(self, node):
node.cnt = self.count(node.lch) + self.count(node.rch) + 1
def merge(self, l, r):
if l is None:
return r
if r is None:
return l
if l.pri > r.pri:
l.rch = self.merge(l.rch, r)
self.update(l)
return l
else:
r.lch = self.merge(l, r.lch)
self.update(r)
return r
def split(self, node, k):
# print("split:", node, k)
if node is None:
return (None, None)
if k <= self.count(node.lch):
s = self.split(node.lch, k)
node.lch = s[1]
self.update(node)
return (s[0], node)
else:
s = self.split(node.rch, k - self.count(node.lch) - 1)
node.rch = s[0]
self.update(node)
return (node, s[1])
def insert(self, k, v):
node = Node(v)
l, r = self.split(self.root, k)
self.root = self.merge(l, node)
self.root = self.merge(self.root, r)
def erase(self, k):
e, r = self.split(self.root, k)
l, e = self.split(e, k-1)
self.root = self.merge(l, r)
def add(self, v):
k = self.floor_index(v) + 1
self.insert(k, v)
def remove(self, v):
k = self.index(v) + 1
self.erase(k)
def index(self, value):
def sub_index(node, k):
if node is None:
raise ValueError("{} is not in tree".format(value))
nv = node.value
if nv == value:
return k + self.count(node.lch)
if nv > value:
return sub_index(node.lch, k)
return sub_index(node.rch, k + self.count(node.lch) + 1)
return sub_index(self.root, 0)
def __getitem__(self, i):
def sub_getitem(node, k):
if node is None:
raise IndexError("tree index out of range")
lc = self.count(node.lch)
if k + lc == i:
return node.value
if k + lc > i:
return sub_getitem(node.lch, k)
return sub_getitem(node.rch, k + lc + 1)
return sub_getitem(self.root, 0)
def floor_node(self, node, value, k):
if node is None:
return (None, None)
nv = node.value
if nv == value:
return (nv, k + self.count(node.lch))
if nv > value:
return self.floor_node(node.lch, value, k)
rf = self.floor_node(node.rch, value, k + self.count(node.lch) + 1)
if rf[0] is None:
return (nv, k + self.count(node.lch))
return rf
def ceil_node(self, node, value, k):
if node is None:
return (None, None)
nv = node.value
if nv == value:
return (nv, k + self.count(node.lch))
if nv < value:
return self.ceil_node(node.rch, value, k + self.count(node.lch))
lc = self.ceil_node(node.lch, value, k)
if lc[0] is None:
return (nv, k + self.count(node.lch))
return lc
def floor_value(self, node, value):
if node is None:
return None
nv = node.value
if nv == value:
return nv
if nv > value:
return self.floor_value(node.lch, value)
rf = self.floor_value(node.rch, value)
if rf is None:
return nv
return rf
def ceil_value(self, node, value):
if node is None:
return None
nv = node.value
if nv == value:
return nv
if nv < value:
return self.ceil_value(node.rch, value)
lc = self.ceil_value(node.lch, value)
if lc is None:
return nv
return lc
def floor(self, value):
return self.floor_value(self.root, value)
def ceil(self, value):
return self.ceil_value(self.root, value)
def floor_index(self, value):
res = self.floor_node(self.root, value, 0)[1]
if res is None:
return -1
return res
def ceil_index(self, value):
res = self.ceil_node(self.root, value, 0)[1]
if res is None:
return self.count(self.root)
return res
def solve(N: int, a: "List[int]"):
sep = Treap()
sep.add(-1)
sep.add(N)
idx = {aa: i for i, aa in enumerate(a)}
res = 0
for n in range(1, N+1):
i = idx[n]
j = sep.floor(i)
k = sep.ceil(i)
res += n * (i - j) * (k - i)
sep.add(i)
print(res)
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [ int(next(tokens)) for _ in range(N) ] # type: "List[int]"
solve(N, a)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, a: "List[int]"):
idx = {aa: i for i, aa in enumerate(a)}
left = [i for i in range(N+2)]
right = [i for i in range(N+2)]
res = 0
for n in range(N, 0, -1):
i = idx[n]
l = left[i]
r = right[i]
res += n * (i - l + 1) * (r - i + 1)
left[r+1] = l
right[l-1] = r
print(res)
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [ int(next(tokens)) for _ in range(N) ] # type: "List[int]"
solve(N, a)
if __name__ == '__main__':
main()
| p03987 |
n=int(eval(input()))
ide_ele=n
num=2**(n-1).bit_length()
seg=[ide_ele]*2*num
segfunc=min
def init(init_val):
for i in range(n):
seg[i+num-1]=init_val[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]=x
while k+1:
k=(k-1)//2
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
init_val=[int(i) for i in input().split()]
init(init_val)
ans=0
for i in range(n):
for j in range(i,n):
ans+=query(i,j+1)
print(ans)
| n=int(eval(input()))
A=[int(i) for i in input().split()]
Ans=[0]*n
Ans[0]=1
Stack=[[A[0],1]]
for i in range(1,n):
a=A[i]
b,ct_b=Stack.pop()
ct=1
while b>a and Stack:
ct+=ct_b
b,ct_b=Stack.pop()
if b<a:
Stack.append([b,ct_b])
Stack.append([a,ct])
else:
Stack.append([a,ct+ct_b])
ct+=ct_b
Ans[i]=ct
RA=A[::-1]
Ans_R=[0]*n
Ans_R[0]=1
Stack=[[RA[0],1]]
for i in range(1,n):
a=RA[i]
b,ct_b=Stack.pop()
ct=1
while b>a and Stack:
ct+=ct_b
b,ct_b=Stack.pop()
if b<a:
Stack.append([b,ct_b])
Stack.append([a,ct])
else:
Stack.append([a,ct+ct_b])
ct+=ct_b
Ans_R[i]=ct
Ans_R=Ans_R[::-1]
ans=0
for i in range(n):
ans+=(A[i]*Ans[i]*Ans_R[i])
print(ans) | p03987 |
class BinaryIndexTree: # 1-indexed
def __init__(self, N):
"""
INPUT
N [int] -> 全部0で初期化
N [list] -> そのまま初期化
"""
if isinstance(N, int):
self.N = N
self.depth = N.bit_length()
self.tree = [0] * (N + 1)
self.elem = [0] * (N + 1)
elif isinstance(N, list):
self.N = len(N)
self.depth = self.N.bit_length()
self.tree = [0] + N
self.elem = [0] + N
self._init()
else:
raise "INVALID INPUT: input must be int or list"
def _init(self):
size = self.N + 1
for i in range(1, self.N):
if i + (i & -i) > size:
continue
self.tree[i + (i & -i)] += self.tree[i]
def add(self, i, x):
self.elem[i] += x
while i <= self.N:
self.tree[i] += x
i += i & -i
def sum(self, i):
res = 0
while i > 0:
res += self.tree[i]
i -= i & -i
return res
def lower_bound(self, val):
if val <= 0:
return 0
i = 0
k = 1 << self.depth
while k:
if i + k <= self.N and self.tree[i + k] < val:
val -= self.tree[i + k]
i += k
k >>= 1
return i + 1
if __name__ == "__main__":
N = int(eval(input()))
P = list(map(int, input().split()))
idx = {a: i for i, a in enumerate(P, start=1)}
bit = BinaryIndexTree(N)
ans = 0
for i in range(1, N + 1):
bit.add(idx[i], 1)
s = bit.sum(idx[i])
l = bit.lower_bound(s)-bit.lower_bound(s-1)
r = bit.lower_bound(s+1) - idx[i]
ans += i*l*r
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
a_to_i = {a: i for i, a in enumerate(A, start=1)}
L = [i - 1 for i in range(N + 2)]
R = [i + 1 for i in range(N + 2)]
ans = 0
for a in range(N, 0, -1):
i = a_to_i[a]
ans += a * (R[i] - i) * (i - L[i])
L[R[i]] = L[i]
R[L[i]] = R[i]
print(ans) | p03987 |
A, B = list(map(int, input().split()))
if B % A == 0: print(str(A+B))
else: print(str(B-A))
| A, B = list(map(int, input().split()))
if B % A == 0: print((A+B))
else: print((B-A)) | p03125 |
a,b=list(map(int,input().split()))
if b%a==0:
print((a+b))
else:
print((b-a)) | a,b=list(map(int,input().split()))
print((b-a+2*a*(b%a==0))) | p03125 |
A, B = list(map(int, input().split()))
if B % A == 0:
print((A+B))
else:
print((B-A)) | A, B = list(map(int, input().split()))
print((B+A if B%A == 0 else B-A)) | p03125 |
def read():
return int(eval(input()))
def reads():
return list(map(int, input().split()))
a,b =reads()
if b%a == 0:
print((a+b))
else:
print((b-a)) | a,b = list(map(int,input().split()))
print((a+b if b%a == 0 else b-a)) | p03125 |
A, B = list(map(int,input().split()))
if B % A == 0:
print((A + B))
else:
print((B - A)) | a,b=list(map(int,input().split()))
if b%a== 0:
print((a+b))
else:
print((b-a)) | p03125 |
a, b = list(map(int, input().split()))
print(((a + b) if b % a == 0 else (b - a)))
| a,b=list(map(int,input().split()));print(([b+a,b-a][b%a>0])) | p03125 |
a,b=list(map(int,input().split()));print(((b-a)*(b%a>0)or a+b)) | a,b=list(map(int,input().split()))
print((a+b-2*a*(b%a>0))) | p03125 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.