input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
def main():
n=int(eval(input()))
a=list(map(int,input().split()))
class segtree():
def __init__(self,base,monoid,ini):#self,モノイド,元の配列
#ini：上限（下限）,base：元の配列,monoid：モノイド,tree：セグ木,depth：treeの深さ,
#basesize：baseの要素数,treesize：treeの要素数,num：treesize-basesize
# 初期値（上限とか下限）を決定
self.ini=ini
#セグ木の要素数（num）および深さ（depth）を計算
self.basesize=len(base)
self.num,self.depth=1,1
while self.num<self.basesize:
self.num*=2
self.depth+=1
self.num-=1
#関数（モノイド、今回はmin）を設定
self.monoid=monoid
#セグ木を構築
self.treesize=self.num*2+1
self.tree=[None]*self.treesize
#segtree[m]以降に代入したい配列を入力していく
for i in range(self.num, self.num+self.basesize):self.tree[i]=base[i-self.num]
for i in range(self.num+self.basesize, self.treesize):self.tree[i]=ini
#segtree[m]以降の情報を使って、0に向かってセグ木を構築していく
for i in range(self.num-1,-1,-1):
self.tree[i]=monoid(self.tree[2*i+1],self.tree[2*i+2])
#条件を満たす(サンプルの条件はs以下になること)最大のインデックスを返す関数
def max_index(self,index_func):
#探していく
i=0
while i<self.num:
k=2*i+1
if index_func(self.tree[k+1]):
i=k+1
continue
if index_func(self.tree[k]):
i=k
continue
return -1
return i-self.num
#条件を満たす(サンプルの条件はs以下になること)最小のインデックスを返す関数
def min_index(self,index_func):
#探していく
i=0
while i<self.num:
k=2*i+1
if index_func(self.tree[k]):
i=k
continue
if index_func(self.tree[k+1]):
i=k+1
continue
return -1
return i-self.num
#半開区間[lower,upper)の最小値（とか）を探す関数
def search(self,lower,upper):
#返り値を初期化
ret=self.ini
l=lower+self.num
r=upper+self.num
while l<r:
if r%2==0:
r-=1
ret=self.monoid(ret,self.tree[r])
if l%2==0:
ret=self.monoid(ret,self.tree[l])
l+=1
l//=2
r//=2
return ret
#base[i]をsに更新したときにセグ木全体を更新する関数
def update(self,index,new_value):
i=index+self.num
self.tree[i]=new_value
while i!=0:
i=(i-1)//2
temp=self.monoid(self.tree[2*i+1],self.tree[2*i+2])
if self.tree[i]!=temp:
self.tree[i]=temp
continue
break
#s=segtree([1,2,3],max,0)
#print(s.tree)
s=segtree([10**6,10**6]+a+[10**6,10**6],max,0)
def b_search_u(a,b,border):
ini=a
while True:
med=(a+b)//2
if a==b:return a
if a+1==b:
if s.search(ini,a+1)>border:return a
else:return b
elif s.search(ini,med+1)>border:b=med
else:a=med+1
def b_search_d(a,b,border):
ini=b
while True:
med=(a+b)//2
if a==b:return a
elif a+1==b:
if s.search(b,ini+1)>border:return b
else:return a
elif s.search(med,ini+1)>border:a=med
else:b=med-1
d=[0]*n
for i in range(n):
d[a[i]-1]=i
ans=0
for i in range(n-1):
k1=b_search_u(d[i]+3,n+3,i+1)
cnt1=min(b_search_u(k1+1,n+4,i+1),n+2)
k2=b_search_d(1,d[i]+1,i+1)
cnt2=max(b_search_d(0,k2-1,i+1),1)
ans+=((k2-cnt2)*(k1-d[i]-2)+(cnt1-k1)*(d[i]-k2+2))*(i+1)
print(ans)
main()
| def main():
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
n=int(eval(input()))
a=list(map(int,input().split()))
d=[0]*n
for i,j in enumerate(a):
d[j-1]=i+2
vis=[False]*(n+4)
u_r=unionfind(n+4)
u_l=unionfind(n+4)
ans=0
#print(d)
for j,i in enumerate(d[:-1]):
vis[i]=True
if vis[i+1]==True:
u_r.unite_r(i,i+1)
u_l.unite_l(i,i+1)
k1=u_r.root(i+1)+1
else:
k1=i+1
if vis[k1+1]==True:
cnt1=u_r.root(k1+1)+1
else:
cnt1=k1+1
cnt1=min(cnt1,n+2)
if vis[i-1]==True:
u_r.unite_r(i,i-1)
u_l.unite_l(i,i-1)
k2=u_l.root(i-1)-1
else:
k2=i-1
if vis[k2-1]==True:
cnt2=u_l.root(k2-1)-1
else:
cnt2=k2-1
cnt2=max(cnt2,1)
ans+=((k2-cnt2)*(k1-i)+(cnt1-k1)*(i-k2))*(j+1)
#print(cnt2,k2,i-2,k1,cnt1)
print(ans)
main()
| p02919 |
def main():
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
n=int(eval(input()))
a=list(map(int,input().split()))
d=[0]*n
for i,j in enumerate(a):
d[j-1]=i+2
vis=[False]*(n+4)
u_r=unionfind(n+4)
u_l=unionfind(n+4)
ans=0
#print(d)
for j,i in enumerate(d[:-1]):
vis[i]=True
if vis[i+1]==True:
u_r.unite_r(i,i+1)
u_l.unite_l(i,i+1)
k1=u_r.root(i+1)+1
else:
k1=i+1
if vis[k1+1]==True:
cnt1=u_r.root(k1+1)+1
else:
cnt1=k1+1
cnt1=min(cnt1,n+2)
if vis[i-1]==True:
u_r.unite_r(i,i-1)
u_l.unite_l(i,i-1)
k2=u_l.root(i-1)-1
else:
k2=i-1
if vis[k2-1]==True:
cnt2=u_l.root(k2-1)-1
else:
cnt2=k2-1
cnt2=max(cnt2,1)
ans+=((k2-cnt2)*(k1-i)+(cnt1-k1)*(i-k2))*(j+1)
#print(cnt2,k2,i-2,k1,cnt1)
print(ans)
main()
| def main():
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
n=int(eval(input()))
a=list(map(int,input().split()))
d=[0]*n
for i,j in enumerate(a):
d[j-1]=i+2
vis=[False]*(n+4)
u_r=unionfind(n+4)
u_l=unionfind(n+4)
ans=0
for j,i in enumerate(d[:-1]):
vis[i]=True
if vis[i+1]==True:
u_r.unite_r(i,i+1)
u_l.unite_l(i,i+1)
k1=u_r.root(i+1)+1
else:
k1=i+1
if vis[k1+1]==True:
cnt1=u_r.root(k1+1)+1
else:
cnt1=k1+1
cnt1=min(cnt1,n+2)
if vis[i-1]==True:
u_r.unite_r(i,i-1)
u_l.unite_l(i,i-1)
k2=u_l.root(i-1)-1
else:
k2=i-1
if vis[k2-1]==True:
cnt2=u_l.root(k2-1)-1
else:
cnt2=k2-1
cnt2=max(cnt2,1)
ans+=((k2-cnt2)*(k1-i)+(cnt1-k1)*(i-k2))*(j+1)
print(ans)
main() | p02919 |
def main():
#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
########################################################
##初期化（要素は一つ入れておく）
#avl_key:値,avl_left:左の子のindex,avl_right:右の子のindex
#balance[i]: {"Even":0,"Left":-1,"Right":1}
#avl_keyには初めに何か加えておく
n = int(eval(input()))
p = list(map(int,input().split()))
q = [0]*(n+1)
for i in range(n):
q[p[i]] = i+1
avl_key = [q[n]]
avl_left = [None]*(n+1)
avl_right = [None]*(n+1)
balance = [0]*n
ans = 0
for i in range(n-1,0,-1):
cnt = 0
v = q[i]
lo = search_lower(0,v,None)
hi = search_higher(0,v,None)
#print(lo,hi)
if lo:
lo2 = search_lower(0,lo,0)
t = lo-lo2
if hi:
t *= hi - v
else:
t *= n+1 - v
cnt += t
if hi:
hi2 = search_higher(0,hi,n+1)
t = hi2 - hi
if lo:
t *= v - lo
else:
t *= v
cnt += t
#print(cnt)
ans += i*cnt
insert(0,v)
print(ans)
if __name__ == "__main__":
main() | import sys
stdin = sys.stdin
ni = lambda: int(ns())
nl = lambda: list(map(int, stdin.readline().split()))
nm = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
n = ni()
p = nl()
q = [0]*(n+1)
for i in range(n):
q[p[i]] = i+1
ans = 0
l = [0] + [i for i in range(n+1)]
r = [i+1 for i in range(n+1)] + [n+1]
for i in range(1,n+1):
v = q[i]
l1,r1 = l[v],r[v]
l2,r2 = l[l1],r[r1]
ans += i*((v-l1)*(r2-r1) + (r1-v)*(l1-l2))
l[r1] = l1
r[l1] = r1
print(ans)
| p02919 |
N = int(eval(input()))
P = [int(i) for i in input().split(" ")]
ans = 0
for L in range(N-1):
for R in range(L+1, N):
if 2 <= len(P[L:R+1]) <= 3:
seq = sorted(P[L:R+1], reverse=True)
else:
if seq[0] > P[R] > seq[1]:
seq = [seq[0], P[R], seq[1]]
elif P[R] > seq[0]:
seq = [P[R], seq[0], seq[1]]
elif seq[1] > P[R] > seq[2]:
seq = [seq[0], seq[1], P[R]]
ans += seq[1]
print(ans) | N = int(eval(input()))
P = [int(i) for i in input().split(" ")]
# 各数字が何番目に入っているかを保存する
pos = [0] * (N + 1)
for i in range(N):
pos[P[i]] = i + 1
l = [0]+[i for i in range(N + 1)]
r = [i + 1 for i in range(N + 1)] + [N + 1]
# 1から順番に見ていく
ans = 0
for i in range(1, N + 1):
idx = pos[i]
l1, r1 = l[idx], r[idx]
l2, r2 = l[l1], r[r1]
ans += i * ((l1 - l2) * (r1 - idx) + (idx - l1) * (r2 - r1))
l[r1], r[l1] = l1, r1
print(ans) | p02919 |
from bisect import bisect_left
import sys
input = sys.stdin.readline
n = int(eval(input()))
p = tuple(map(int, input().split()))
pos = [[] for _ in range(n + 1)]
for ind, pp in enumerate(p):
for j in range(pp + 1):
pos[j].append(ind)
ans = 0
for i, pp in enumerate(p):
ind = bisect_left(pos[pp], i)
left = 1
if ind - 1 >= 0:
left = i - pos[pp][ind - 1]
else:
left = i + 1
right = 0
if ind + 1 < len(pos[pp]):
i_right = pos[pp][ind + 1]
right = 1
if ind + 2 < len(pos[pp]):
right = pos[pp][ind + 2] - i_right
else:
right = n - i_right
# print(i, pp, left * right, left, right)
ans += left * right * pp
left = 0
if ind - 1 >= 0:
i_left = pos[pp][ind - 1]
left = 1
if ind - 2 >= 0:
left = i_left - pos[pp][ind - 2]
else:
left = i_left + 1
right = 1
if ind + 1 < len(pos[pp]):
right = pos[pp][ind + 1] - i
else:
right = n - i
# print(i, pp, left * right, left, right)
ans += left * right * pp
print(ans)
| # https://atcoder.jp/contests/abc140/submissions/7411285
# 写経
def main():
N = int(eval(input()))
*p, = list(map(int, input().split()))
xtoi = [-1] * (N + 1)
for i, x in enumerate(p):
xtoi[x] = i
L = [-1] * (N + 2)
R = [N] * (N + 2)
for i in range(N):
L[i] = i - 1
R[i] = i + 1
iter_inds = iter(xtoi)
next(iter_inds)
ans = 0
for x, ind in enumerate(iter_inds, start=1):
# l2, ..., l1, ..., x, ..., r1, ..., r2
# (l2,r1) or (l1,r2)
l1 = L[ind]
l2 = L[l1]
r1 = R[ind]
r2 = R[r1]
ans += x * ((l1 - l2) * (r1 - ind) + (r2 - r1) * (ind - l1))
L[r1] = l1
R[l1] = r1
print(ans)
if __name__ == '__main__':
main()
| p02919 |
class SparseTable:
def __init__(self, a, func=max, one=-10**18):
self.table = [a[:]]
self.n = len(a)
self.logn = self.n.bit_length()
self.func = func
self.one = one
for i in [1 << x for x in range(self.logn - 1)]:
self.table.append([])
for j in range(self.n - i * 2 + 1):
self.table[-1].append(self.func(self.table[-2][j],
self.table[-2][j + i]))
def get_section(self, i, j):
length = j - i
log = length.bit_length() - 1
if length <= 0:
return self.one
return self.func(self.table[log][i], self.table[log][j - length])
def low(m, x):
mi = 0
ma = m
if ma < 0 or sp.get_section(0, ma) <= x:
return - 1
while mi != ma:
mm = (mi + ma) // 2 + 1
if sp.get_section(mm, m) > x:
mi = mm
else:
ma = mm - 1
return mi
def high(m, x):
mi = m + 1
ma = n - 1
if m >= n or sp.get_section(m+1, n) <= x:
return n
while mi != ma:
mm = (mi + ma) // 2
if sp.get_section(m, mm+1) > x:
ma = mm
else:
m1 = mm + 1
return mi
n = int(eval(input()))
p = [int(i) for i in input().split()]
sp = SparseTable(p)
ans = 0
for i in range(n):
j = low(i, p[i])
k = low(j, p[i])
l = high(i, p[i])
m = high(l, p[i])
ans += p[i] * ((i-j) * (m-l) + (j-k) * (l-i))
print(ans)
| class SparseTable:
def __init__(self, a, func=max, one=-10**18):
self.table = [a[:]]
self.n = len(a)
self.logn = self.n.bit_length()
self.func = func
self.one = one
for i in [1 << x for x in range(self.logn - 1)]:
self.table.append([])
for j in range(self.n - i * 2 + 1):
self.table[-1].append(self.func(self.table[-2][j],
self.table[-2][j + i]))
def get_section(self, i, j):
length = j - i
log = length.bit_length() - 1
if length <= 0:
return self.one
a = self.func(self.table[log][i], self.table[log][j - (1<<log)])
return a
def low(m, x):
mi = 0
ma = m - 1
if ma < 0 or sp.get_section(0, m) <= x:
return - 1
while mi != ma:
mm = (mi + ma) // 2 + 1
if sp.get_section(mm, m) > x:
mi = mm
else:
ma = mm - 1
return mi
def high(m, x):
mi = m
ma = n - 1
if m >= n or sp.get_section(m, n) <= x:
return n
while mi != ma:
mm = (mi + ma) // 2
if sp.get_section(m, mm+1) > x:
ma = mm
else:
mi = mm + 1
return mi
n = int(eval(input()))
p = [int(i) for i in input().split()]
sp = SparseTable(p)
ans = 0
for i in range(n):
j = low(i, p[i])
k = low(j, p[i])
l = high(i, p[i])
m = high(l+1, p[i])
ans += p[i] * ((i-j) * (m-l) + (j-k) * (l-i))
print(ans)
| p02919 |
from bisect import bisect_left, bisect_right
class OrderedSet:
def __init__(self, a):
self.c = {}
self.a_sort = sorted(list(set(a)))
for i, a in enumerate(self.a_sort):
self.c[a] = i + 1
self.r = {v: k for k, v in list(self.c.items())}
self.size = len(self.c)
self.tree = [0] * (self.size + 1)
self.num = [0] * self.size
self.all_count = 0 # 全要素数
# BITのsum関数
def _sum(self, index):
s = 0
while index:
s += self.tree[index]
index -= index & (-index)
return s
# xをk個挿入する
def insert(self, x, k=1):
index = self.c[x]
self.num[index - 1] += k
while index <= self.size:
self.tree[index] += k
index += index & (-index)
self.all_count += k
# xをk個削除する
def erase(self, x, k=1):
self.insert(x, k=-k)
# 格納しているxの数を返す
def count(self, x):
return self.num[self.c[x] - 1]
# 下から数えてk番目の要素を返す（要素がk個未満のときNoneを返す）
def get_kth_bottom(self, k):
if k <= 0:
return None
elif self.all_count < k:
return None
else:
i = 0
s = 0
step = 1 << (self.size.bit_length() - 1)
while step:
if i + step <= self.size and s + self.tree[i + step] < k:
i += step
s += self.tree[i]
step >>= 1
return self.r[i + 1]
# 上から数えてk番目の要素を返す（要素がk個未満のときNoneを返す）
def get_kth_top(self, k):
return self.get_kth_bottom(self.all_count - k + 1)
# x以上の最小要素を返す
def lower_bound(self, x):
p = bisect_left(self.a_sort, x)
if p == 0:
k = 1
else:
k = self._sum(p) + 1
return self.get_kth_bottom(k)
# x以下の最大要素を返す
def upper_bound(self, x):
p = bisect_right(self.a_sort, x)
if p == 0:
return None
else:
k = self._sum(p)
return self.get_kth_bottom(k)
def resolve():
N = int(eval(input()))
A = list(map(int, input().split()))
P = [0] * (N + 1)
for i in range(N):
P[A[i]] = i + 1
OS = OrderedSet(P)
ans = 0
for i in range(N, 0, -1):
p = P[i]
c = OS.lower_bound(p)
d = None if c is None else OS.lower_bound(c + 1)
b = OS.upper_bound(p)
a = None if b is None else OS.upper_bound(b - 1)
a = a if a is not None else 0
d = d if d is not None else N + 1
if b is None:
if c is not None:
ans += i * p * (d - c)
elif c is None:
ans += i * (b - a) * (N - p + 1)
else:
ans += i * ((b - a) * (c - p) + (p - b) * (d - c))
OS.insert(p)
print(ans)
if __name__ == "__main__":
resolve()
|
def resolve():
N = int(eval(input()))
A = list(map(int, input().split()))
P = [0] * (N + 1)
for i, a in enumerate(A):
P[a] = i
l_idx = list(range(-1, N - 1)) + [-1, -1]
r_idx = list(range(1, N + 1)) + [N, N] # 番兵
ans = 0
for p in range(1, N + 1):
x = P[p]
l1 = l_idx[x]
l2 = l_idx[l1]
r1 = r_idx[x]
r2 = r_idx[r1]
cmb = (x - l1) * (r2 - r1) + (l1 - l2) * (r1 - x)
ans += p * cmb
l_idx[r1] = l1
r_idx[l1] = r1
print(ans)
if __name__ == "__main__":
resolve() | p02919 |
# -*- 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
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 = lend - bit.sum(m-1)
return cnt == 0
# m~idxの間に出現済が1つ以下(この範囲の中で自分が最大値か2番目)かどうか
def calc2(m):
cnt = lend - bit.sum(m-1)
return cnt <= 1
# idx~mの間に出現済がない(この範囲の中で自分が最大値)かどうか
def calc3(m):
cnt = bit.sum(m) - rstart
return cnt == 0
# idx~mの間に出現済が1つ以下(この範囲の中で自分が最大値か2番目)かどうか
def calc4(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, 2)
bit.add(N+1, 2)
ans = [0] * (N+1)
# 大きいaから見ていく
for a in range(N, 0, -1):
# a(N~1)が格納されているindex
idx = idxs[a]
# 左の終点と右の始点は各回固定なので先に取っておく
lend = bit.sum(idx)
rstart = bit.sum(idx-1)
# 自分より小さいindexで2回目に自分より大きい値がある直前の場所
p = bisearch_min(0, idx+1, calc2)
# 自分より小さいindexで最初に自分より大きい値がある直前の場所
q = bisearch_min(0, idx+1, calc1)
# 自分より大きいindexで最初に自分より大きい値がある直前の場所
r = bisearch_max(idx, N+1, calc3)
# 自分より大きいindexで2回目に自分より大きい値がある直前の場所
s = bisearch_max(idx, N+1, calc4)
# aを使う回数 * a = (左に自分より大きい値がある時の通り数 + 右に自分より大きい値がある時の通り数) * a
ans[a] = ((q-p)*(r-idx+1) + (idx-q+1)*(s-r)) * 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, 2)
bit.add(N+1, 2)
ans = [0] * (N+1)
# 大きいaから見ていく
for a in range(N, 0, -1):
# a(N~1)が格納されているindex
idx = idxs[a]
# 自分より小さいindexで2回目に自分より大きい値がある直前の場所
p = bit.bisearch_right(-1, idx, 2) + 1
# 自分より小さいindexで最初に自分より大きい値がある直前の場所
q = bit.bisearch_right(-1, idx, 1) + 1
# 自分より大きいindexで最初に自分より大きい値がある直前の場所
r = bit.bisearch_left(idx, N+1, 1) - 1
# 自分より大きいindexで2回目に自分より大きい値がある直前の場所
s = bit.bisearch_left(idx, N+1, 2) - 1
# aを使う回数 * a = (左に自分より大きい値がある時の通り数 + 右に自分より大きい値がある時の通り数) * a
ans[a] = ((q-p)*(r-idx+1) + (idx-q+1)*(s-r)) * a
# aを出現済とする
bit.add(idx, 1)
# 全てのaについての合計
print((sum(ans)))
| p02919 |
import bisect
n = int(eval(input()))
p = list(map(int, input().split()))
index = [0] * (n+1)
for i in range(n):
index[p[i]] = i
poss = []
result = 0
for i in range(1, n+1)[::-1]:
x = index[i]
if len(poss) == 0:
poss.append(x)
continue
dx = bisect.bisect_left(poss, x)
# 左に１番目の数がある
if dx > 0:
lbl = 0
if dx > 1:
lbl = poss[dx-2]+1
lbr = poss[dx-1]
rbl = n-1
if len(poss) != dx:
rbl = poss[dx] -1
result += (lbr-lbl+1) * (rbl-x+1) * i
# 右に1番目の数がある
if dx < len(poss):
rbr = n-1
if dx < len(poss) -1:
rbr = poss[dx+1]-1
rbl = poss[dx]
lbr = 0
if dx > 0:
lbr = poss[dx-1] +1
result += (rbr-rbl+1) * (x-lbr+1) * i
poss.insert(dx, x)
print(result) | class BIT:
def __init__(self, n):
self.n = n
self.N = 1 << n.bit_length()
self.data = [0] * (self.N +1)
def add(self, i, x):
while i <= self.N:
self.data[i] += x
i += i & -i
def sum(self, i):
total = 0
while i > 0:
total += self.data[i]
i -= i&-i
return total
def search(self, w):
if w <= 0:
return 0
x = 0
k = self.N >> 1
while k > 0:
if x+k <= self.N and self.data[x+k] < w:
w -= self.data[x+k]
x += k
k = k >> 1
return x+1
def len(self):
return self.data[self.N]
n = int(eval(input()))
p = list(map(int, input().split()))
index = [0] * (n+1)
for i in range(n):
index[p[i]] = i+1
used = BIT(n)
result = 0
for i in range(1, n+1)[::-1]:
x = index[i]
if used.len() == 0:
used.add(x, 1)
continue
dx = used.sum(x)
# 左に１番目の数がある
if dx > 0:
lbl = 1
if dx > 1:
lbl = used.search(dx-1)+1
lbr = used.search(dx)
rbl = n
if used.len() != dx:
rbl = used.search(dx+1) -1
result += (lbr-lbl+1) * (rbl-x+1) * i
# 右に1番目の数がある
if dx < used.len():
rbr = n
if dx < used.len() -1:
rbr = used.search(dx+2)-1
rbl = used.search(dx+1)
lbr = 1
if dx > 0:
lbr = used.search(dx) +1
result += (rbr-rbl+1) * (x-lbr+1) * i
used.add(x, 1)
print(result) | p02919 |
import sys
from bisect import bisect
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, leastValue, largestValue):
t = self.root
lb, hb = leastValue, largestValue
while t:
if key < t.key:
hb = t.key
t = t.left
else:
lb = t.key
t = t.right
return lb, hb
def solve():
input = sys.stdin.readline
N = int(eval(input()))
P = [int(p) for p in input().split()]
pindex = dict()
for i, p in enumerate(P): pindex[p - 1] = i
L, R = dict(), dict()
L[pindex[N-1]] = -1
R[pindex[N-1]] = N
L[-1] = L[N] = -1
R[-1] = R[N] = N
Ans = 0
if N == 10 ** 5:
appeared = []
appeared.append(-1)
appeared.append(pindex[N - 1])
appeared.append(N)
for i in reversed(list(range(N - 1))):
pid = pindex[i]
mid = bisect(appeared, pindex[i])
L[pid], R[pid] = appeared[mid - 1], appeared[mid]
Ans += (i + 1) * ((pid - L[pid]) * (R[R[pid]] - R[pid]) + (R[pid] - pid) * (L[pid] - L[L[pid]]))
appeared.insert(mid, pindex[i])
R[L[pid]] = L[R[pid]] = pid
else:
Ans = 0
T = AVLTree()
T.insert(pindex[N-1])
for i in reversed(list(range(N-1))):
pid = pindex[i]
L[pid], R[pid] = T.search(pid, -1, N)
Ans += (i + 1) * ((pid - L[pid]) * (R[R[pid]] - R[pid]) + (R[pid] - pid) * (L[pid] - L[L[pid]]))
T.insert(pid)
R[L[pid]] = L[R[pid]] = pid
print(Ans)
return 0
if __name__ == "__main__":
solve()
| import sys
from bisect import bisect
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, leastValue, largestValue):
t = self.root
lb, hb = leastValue, largestValue
while t:
if key < t.key:
hb = t.key
t = t.left
else:
lb = t.key
t = t.right
return lb, hb
def solve():
input = sys.stdin.readline
N = int(eval(input()))
P = [int(p) for p in input().split()]
pindex = dict()
for i, p in enumerate(P): pindex[p - 1] = i
L, R = dict(), dict()
L[pindex[N-1]] = -1
R[pindex[N-1]] = N
L[-1] = L[N] = -1
R[-1] = R[N] = N
Ans = 0
if N == 10 ** 5:
appeared = []
appeared.append(-1)
appeared.append(pindex[N - 1])
appeared.append(N)
for i in reversed(list(range(N - 1))):
pid = pindex[i]
mid = bisect(appeared, pindex[i])
left, right = appeared[mid - 1], appeared[mid]
Ans += (i + 1) * ((pid - left) * (R[right] - right) + (right - pid) * (left - L[left]))
appeared.insert(mid, pindex[i])
L[pid], R[pid] = left, right
R[left] = L[right] = pid
else:
Ans = 0
T = AVLTree()
T.insert(pindex[N-1])
for i in reversed(list(range(N-1))):
pid = pindex[i]
L[pid], R[pid] = T.search(pid, -1, N)
Ans += (i + 1) * ((pid - L[pid]) * (R[R[pid]] - R[pid]) + (R[pid] - pid) * (L[pid] - L[L[pid]]))
T.insert(pid)
R[L[pid]] = L[R[pid]] = pid
print(Ans)
return 0
if __name__ == "__main__":
solve()
| p02919 |
import sys
from bisect import bisect
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, leastValue, largestValue):
t = self.root
lb, hb = leastValue, largestValue
while t:
if key < t.key:
hb = t.key
t = t.left
else:
lb = t.key
t = t.right
return lb, hb
def solve():
input = sys.stdin.readline
N = int(eval(input()))
P = [int(p) for p in input().split()]
pindex = dict()
L, R = dict(), dict()
for i, p in enumerate(P):
pindex[p - 1] = i
L[i] = -1
R[i] = N
L[-1] = L[N] = -1
R[-1] = R[N] = N
Ans = 0
Ans = 0
T = AVLTree()
T.insert(pindex[N-1])
for i in reversed(list(range(N-1))):
pid = pindex[i]
L[pid], R[pid] = l, r = T.search(pid, -1, N)
Ans += (i + 1) * ((pid - l) * (R[r] - r) + (r - pid) * (l - L[l]))
T.insert(pid)
R[l] = L[r] = pid
print(Ans)
return 0
if __name__ == "__main__":
solve()
| import sys
from bisect import bisect
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, leastValue, largestValue):
t = self.root
lb, hb = leastValue, largestValue
while t:
if key < t.key:
hb = t.key
t = t.left
else:
lb = t.key
t = t.right
return lb, hb
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():
input = sys.stdin.readline
N = int(eval(input()))
P = [int(p) for p in input().split()]
pindex = dict()
L, R = dict(), dict()
for i, p in enumerate(P): pindex[p - 1] = i
Ans = 0
T = AVLTree()
T.insert(pindex[N-1])
if N == 10 ** 5:
for i in range(N-2, 0, -1):
pid = pindex[i]
left, right = T.lower_bound(pid, -1), T.upper_bound(pid, N)
if left == -1: l2 = -1
else: l2 = T.lower_bound(left, -1)
if right == N: r2 = N
else: r2 = T.upper_bound(right, N)
Ans += (i + 1) * ((pid - left) * (r2 - right) + (right - pid) * (left - l2))
T.insert(pid)
Ans += (2 if 0 < pindex[0] < N - 1 else 1)
else:
L[pindex[N-1]] = -1
R[pindex[N-1]] = N
L[-1] = L[N] = -1
R[-1] = R[N] = N
for i in reversed(list(range(N-1))):
pid = pindex[i]
L[pid], R[pid] = l, r = T.search(pid, -1, N)
Ans += (i + 1) * ((pid - l) * (R[r] - r) + (r - pid) * (l - L[l]))
T.insert(pid)
R[l] = L[r] = pid
print(Ans)
return 0
if __name__ == "__main__":
solve()
| p02919 |
N = int(eval(input()))
ls = [int(i) for i in input().split()]
#N = 5
#ls = [1,2,3,4,5]
dic = {}
result = []
def get_second_large(ls):
if len(ls) < 2:
return ls[0]
else:
return sorted(ls)[-2]
for l in range(N):
for r in range(l+1,N):
tup = tuple(ls[l:r+1])
if tup not in dic:
second = get_second_large(ls[l:r+1])
dic[tup] = second
result.append(dic[tup])
print((sum(result))) | N = int(eval(input()))
ls = [int(i) for i in input().split()]
result = []
for l in range(N-1):
if ls[l] > ls[l+1]:
sec_big, biggist = ls[l+1], ls[l]
else:
sec_big, biggist = ls[l], ls[l+1]
result.append(sec_big)
for r in range(l+2, N):
if ls[r] > biggist:
result.append(biggist)
sec_big = biggist
biggist = ls[r]
elif biggist > ls[r] > sec_big:
result.append(ls[r])
sec_big = ls[r]
else:
result.append(sec_big)
print((sum(result)))
| p02919 |
# 点更新，区間クエリ
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 + 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+2
A = [N+1]*2 + A + [N+1]*2
#%%
ans = 0
seg = SegTree(N+4,[1]*2+[0]*N+[1]*2,segfunc,0)
def judge(l,r,key):
if l>r:
l,r = r,l
res = seg.query(l,r+1)
if res>key:
return False
else:
return True
def bsearch(idx,ng,key):
ok = idx
while abs(ok-ng)>1:
mid = (ok+ng)//2
if judge(idx,mid,key):
ok = mid
else:
ng = mid
return ng
for idx in reversed(idxlist):
if A[idx]==N:
seg.update(idx,1)
continue
ng_l = 0
ng_r = N+3
L1 = bsearch(idx,ng_l,0)
L2 = bsearch(idx,ng_l,1)
R1 = bsearch(idx,ng_r,0)
R2 = bsearch(idx,ng_r,1)
coef = 0
if A[L1]!=N+1:
coef += (L1-L2)*(R1-idx)
if A[R1]!=N+1:
coef += (R2-R1)*(idx-L1)
ans += A[idx]*coef
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+2
A = [N+1]*2 + A + [N+1]*2
#%%
ans = 0
seg = BIT(N+4,[1]*2+[0]*N+[1]*2)
def judge(l,r,key):
if l>r:
l,r = r,l
res = seg.query(l,r+1)
if res>key:
return False
else:
return True
def bsearch(idx,ng,key):
ok = idx
while abs(ok-ng)>1:
mid = (ok+ng)//2
if judge(idx,mid,key):
ok = mid
else:
ng = mid
return ng
for idx in reversed(idxlist):
if A[idx]==N:
seg.update(idx,1)
continue
ng_l = 0
ng_r = N+3
L1 = bsearch(idx,ng_l,0)
L2 = bsearch(idx,ng_l,1)
R1 = bsearch(idx,ng_r,0)
R2 = bsearch(idx,ng_r,1)
coef = 0
if A[L1]!=N+1:
coef += (L1-L2)*(R1-idx)
if A[R1]!=N+1:
coef += (R2-R1)*(idx-L1)
ans += A[idx]*coef
seg.update(idx,1)
print(ans)
| p02919 |
import bisect
class SqrtSet:
def __init__(self, block_limit=300):
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:])
block = block[:sep]
def main():
n = int(eval(input()))
p = list(map(int, input().split()))
idx = [0] * n
for i in range(0, n):
idx[i] = i
idx.sort(key=lambda i: - p[i])
t = SqrtSet()
t.insert(-1)
t.insert(n)
ans = 0
for i in idx:
nex = t.search_higher(i)
nexnex = t.search_higher(nex)
pre = t.search_lower(i)
prepre = t.search_lower(pre)
if prepre != None:
ans += p[i] * (pre - prepre) * (nex - i)
if nexnex != None:
ans += p[i] * (i - pre) * (nexnex - nex)
t.insert(i)
print(ans)
main()
| import bisect
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 dump(self):
for b in self.child:
print(len(b), end=" ")
print("")
def main():
n = int(input())
p = list(map(int, input().split()))
idx = [0] * n
for i in range(0, n):
idx[i] = i
idx.sort(key=lambda i: - p[i])
t = SqrtSet()
t.insert(-1)
t.insert(n)
ans = 0
for i in idx:
nex = t.search_higher(i)
nexnex = t.search_higher(nex)
pre = t.search_lower(i)
prepre = t.search_lower(pre)
if prepre != None:
ans += p[i] * (pre - prepre) * (nex - i)
if nexnex != None:
ans += p[i] * (i - pre) * (nexnex - nex)
t.insert(i)
print(ans)
main()
| p02919 |
from time import time
from statistics import median
from bisect import bisect_left, bisect_right
from random import random, sample
class TwoLayerSet:
def __init__(self, p):
self.top = []
self.bottom = [[]]
self.p = p
def insert(self, key):
(top, bottom) = (self.top, self.bottom)
top_i = bisect_left(top, key)
if top_i != len(top) and key == top[top_i]:
return False
block = bottom[top_i]
block_i = bisect_left(block, key)
if block_i != len(block) and key == block[block_i]:
return False
if random() < self.p:
top.insert(top_i, key)
bottom[top_i] = block[block_i:]
bottom.insert(top_i, block[:block_i])
else:
block.insert(block_i, key)
return True
def erase(self, key):
(top, bottom) = (self.top, self.bottom)
top_i = bisect_left(top, key)
if top_i != len(top) and key == top[top_i]:
top.pop(top_i)
bottom[top_i].extend(bottom.pop(top_i+1))
return True
block = bottom[top_i]
block_i = bisect_left(block, key)
if block_i != len(block) and key == block[block_i]:
block.pop(block_i)
return True
return False
def less(self, key):
if key is None:
return None
top = self.top
top_i = bisect_left(top, key)
block = self.bottom[top_i]
block_i = bisect_left(block, key)
if block_i != 0:
return block[block_i - 1]
if top_i != 0:
return top[top_i - 1]
return None
def less_equal(self, key):
top = self.top
top_i = bisect_right(top, key)
block = self.bottom[top_i]
block_i = bisect_right(block, key)
if block_i != 0:
return block[block_i - 1]
if top_i != 0:
return top[top_i - 1]
return None
def greater(self, key):
if key is None:
return None
top = self.top
top_i = bisect_right(top, key)
block = self.bottom[top_i]
block_i = bisect_right(block, key)
if block_i != len(block):
return block[block_i]
if top_i != len(top):
return top[top_i]
return None
def greater_equal(self, key):
top = self.top
top_i = bisect_left(top, key)
block = self.bottom[top_i]
block_i = bisect_left(block, key)
if block_i != len(block):
return block[block_i]
if top_i != len(top):
return top[top_i]
return None
def main():
n = int(eval(input()))
p = list(map(int, input().split()))
idx = [0] * n
for i in range(0, n):
idx[i] = i
idx.sort(key=lambda i: - p[i])
t = TwoLayerSet(1/1000)
t.insert(-1)
t.insert(n)
ans = 0
for i in idx:
nex = t.greater(i)
nexnex = t.greater(nex)
pre = t.less(i)
prepre = t.less(pre)
if prepre != None:
ans += p[i] * (pre - prepre) * (nex - i)
if nexnex != None:
ans += p[i] * (i - pre) * (nexnex - nex)
t.insert(i)
print(ans)
main()
| from time import time
from statistics import median
from bisect import bisect_left, bisect_right
from random import random, sample
class TwoLayerSet:
def __init__(self, p):
self.top = []
self.bottom = [[]]
self.p = p
def insert(self, key):
(top, bottom) = (self.top, self.bottom)
top_i = bisect_left(top, key)
if top_i != len(top) and key == top[top_i]:
return False
block = bottom[top_i]
block_i = bisect_left(block, key)
if block_i != len(block) and key == block[block_i]:
return False
if random() < self.p:
top.insert(top_i, key)
bottom[top_i] = block[block_i:]
bottom.insert(top_i, block[:block_i])
else:
block.insert(block_i, key)
return True
def erase(self, key):
(top, bottom) = (self.top, self.bottom)
top_i = bisect_left(top, key)
if top_i != len(top) and key == top[top_i]:
top.pop(top_i)
bottom[top_i].extend(bottom.pop(top_i+1))
return True
block = bottom[top_i]
block_i = bisect_left(block, key)
if block_i != len(block) and key == block[block_i]:
block.pop(block_i)
return True
return False
def less(self, key):
if key is None:
return None
top = self.top
top_i = bisect_left(top, key)
block = self.bottom[top_i]
block_i = bisect_left(block, key)
if block_i != 0:
return block[block_i - 1]
if top_i != 0:
return top[top_i - 1]
return None
def less_equal(self, key):
top = self.top
top_i = bisect_right(top, key)
block = self.bottom[top_i]
block_i = bisect_right(block, key)
if block_i != 0:
return block[block_i - 1]
if top_i != 0:
return top[top_i - 1]
return None
def greater(self, key):
if key is None:
return None
top = self.top
top_i = bisect_right(top, key)
block = self.bottom[top_i]
block_i = bisect_right(block, key)
if block_i != len(block):
return block[block_i]
if top_i != len(top):
return top[top_i]
return None
def greater_equal(self, key):
top = self.top
top_i = bisect_left(top, key)
block = self.bottom[top_i]
block_i = bisect_left(block, key)
if block_i != len(block):
return block[block_i]
if top_i != len(top):
return top[top_i]
return None
def main():
n = int(eval(input()))
p = list(map(int, input().split()))
idx = [0] * n
for i in range(0, n):
idx[i] = i
idx.sort(key=lambda i: - p[i])
t = TwoLayerSet(1/50)
t.insert(-1)
t.insert(n)
ans = 0
for i in idx:
nex = t.greater(i)
nexnex = t.greater(nex)
pre = t.less(i)
prepre = t.less(pre)
if prepre != None:
ans += p[i] * (pre - prepre) * (nex - i)
if nexnex != None:
ans += p[i] * (i - pre) * (nexnex - nex)
t.insert(i)
print(ans)
main()
| p02919 |
from bisect import bisect_left, bisect_right
from random import random, sample
class TwoLayerSet:
def __init__(self, p):
self.top = []
self.bottom = [[]]
self.p = p
def insert(self, key):
(top, bottom) = (self.top, self.bottom)
top_i = bisect_left(top, key)
if top_i != len(top) and key == top[top_i]:
return False
block = bottom[top_i]
block_i = bisect_left(block, key)
if block_i != len(block) and key == block[block_i]:
return False
if random() < self.p:
top.insert(top_i, key)
bottom[top_i] = block[block_i:]
bottom.insert(top_i, block[:block_i])
else:
block.insert(block_i, key)
return True
def erase(self, key):
(top, bottom) = (self.top, self.bottom)
top_i = bisect_left(top, key)
if top_i != len(top) and key == top[top_i]:
top.pop(top_i)
bottom[top_i].extend(bottom.pop(top_i+1))
return True
block = bottom[top_i]
block_i = bisect_left(block, key)
if block_i != len(block) and key == block[block_i]:
block.pop(block_i)
return True
return False
def less(self, key):
if key is None:
return None
top = self.top
top_i = bisect_left(top, key)
block = self.bottom[top_i]
block_i = bisect_left(block, key)
if block_i != 0:
return block[block_i - 1]
if top_i != 0:
return top[top_i - 1]
return None
def less_equal(self, key):
top = self.top
top_i = bisect_right(top, key)
block = self.bottom[top_i]
block_i = bisect_right(block, key)
if block_i != 0:
return block[block_i - 1]
if top_i != 0:
return top[top_i - 1]
return None
def greater(self, key):
if key is None:
return None
top = self.top
top_i = bisect_right(top, key)
block = self.bottom[top_i]
block_i = bisect_right(block, key)
if block_i != len(block):
return block[block_i]
if top_i != len(top):
return top[top_i]
return None
def greater_equal(self, key):
top = self.top
top_i = bisect_left(top, key)
block = self.bottom[top_i]
block_i = bisect_left(block, key)
if block_i != len(block):
return block[block_i]
if top_i != len(top):
return top[top_i]
return None
def main():
n = int(eval(input()))
p = list(map(int, input().split()))
idx = [0] * n
for i in range(0, n):
idx[i] = i
idx.sort(key=lambda i: - p[i])
t = TwoLayerSet(1/100)
t.insert(-1)
t.insert(n)
ans = 0
for i in idx:
nex = t.greater(i)
nexnex = t.greater(nex)
pre = t.less(i)
prepre = t.less(pre)
if prepre != None:
ans += p[i] * (pre - prepre) * (nex - i)
if nexnex != None:
ans += p[i] * (i - pre) * (nexnex - nex)
t.insert(i)
print(ans)
main()
| from random import random, sample
def bis_l(a, k):
l = 0
r = len(a)
while l != r:
m = (l + r) >> 1
if a[m] < k:
l = m + 1
else:
r = m
return l
def bis_r(a, k):
l = 0
r = len(a)
while l != r:
m = (l + r) >> 1
if a[m] <= k:
l = m + 1
else:
r = m
return l
class TwoLayerSet:
def __init__(self, p):
self.top = []
self.bottom = [[]]
self.p = p
def insert(self, key):
(top, bottom) = (self.top, self.bottom)
top_i = bis_l(top, key)
if top_i != len(top) and key == top[top_i]:
return False
block = bottom[top_i]
block_i = bis_l(block, key)
if block_i != len(block) and key == block[block_i]:
return False
if random() < self.p:
top.insert(top_i, key)
bottom[top_i] = block[block_i:]
bottom.insert(top_i, block[:block_i])
else:
block.insert(block_i, key)
return True
def erase(self, key):
(top, bottom) = (self.top, self.bottom)
top_i = bis_l(top, key)
if top_i != len(top) and key == top[top_i]:
top.pop(top_i)
bottom[top_i].extend(bottom.pop(top_i+1))
return True
block = bottom[top_i]
block_i = bis_l(block, key)
if block_i != len(block) and key == block[block_i]:
block.pop(block_i)
return True
return False
def less(self, key):
if key is None:
return None
top = self.top
top_i = bis_l(top, key)
block = self.bottom[top_i]
block_i = bis_l(block, key)
if block_i != 0:
return block[block_i - 1]
if top_i != 0:
return top[top_i - 1]
return None
def less_equal(self, key):
top = self.top
top_i = bis_r(top, key)
block = self.bottom[top_i]
block_i = bis_r(block, key)
if block_i != 0:
return block[block_i - 1]
if top_i != 0:
return top[top_i - 1]
return None
def greater(self, key):
if key is None:
return None
top = self.top
top_i = bis_r(top, key)
block = self.bottom[top_i]
block_i = bis_r(block, key)
if block_i != len(block):
return block[block_i]
if top_i != len(top):
return top[top_i]
return None
def greater_equal(self, key):
top = self.top
top_i = bis_l(top, key)
block = self.bottom[top_i]
block_i = bis_l(block, key)
if block_i != len(block):
return block[block_i]
if top_i != len(top):
return top[top_i]
return None
def main():
n = int(eval(input()))
p = list(map(int, input().split()))
idx = [0] * n
for i in range(0, n):
idx[i] = i
idx.sort(key=lambda i: - p[i])
t = TwoLayerSet(1/100)
t.insert(-1)
t.insert(n)
ans = 0
for i in idx:
nex = t.greater(i)
nexnex = t.greater(nex)
pre = t.less(i)
prepre = t.less(pre)
if prepre != None:
ans += p[i] * (pre - prepre) * (nex - i)
if nexnex != None:
ans += p[i] * (i - pre) * (nexnex - nex)
t.insert(i)
print(ans)
main()
| p02919 |
#!/usr/bin/env python3
N=int(eval(input()))
p=list(map(int,input().split()))
LL = [0] + [i for i in range(N+1)]
RR = [i+1 for i in range(N+1)] + [N+1]
E = [(v, i+1) for i, v in enumerate(p)]
E.sort()
ans=0
for v, i in E:
r0 = RR[i]
r1 = RR[r0]
l0 = LL[i]
l1 = LL[l0]
RR[l0] = r0
LL[r0] = l0
ans += ((r1 - r0)*(i-l0)+(r0-i)*(l0 - l1))*v
print(ans)
| #!/usr/bin/env python3
ans=0
n=int(eval(input()))
p=list(map(int,input().split()))
b=[0]*(n+1)
for i in range(n):
b[p[i]]=i+1
LL=[0]+[i for i in range(n+1)]
RR=[i for i in range(1,n+2)]+[n+1]
for i in range(1,n+1):
l1=LL[b[i]]
l0=LL[l1]
r0=RR[b[i]]
r1=RR[r0]
ans+=((l1-l0)*(r0-b[i])+(r1-r0)*(b[i]-l1))*i
LL[r0]=l1
RR[l1]=r0
print(ans)
| p02919 |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from bisect import bisect_left
import sys
N = int(eval(input()))
Pn = [[i,j] for i,j in enumerate(list(map(int, sys.stdin.readline().rstrip().split())))]
Pn = sorted(Pn,key=lambda x:-x[1])
In = [Pn[0][0]]
ans = 0
for i,p in Pn[1:]:
cnt = 0
c = bisect_left(In,i)
In.insert(c,i)
# Choose leftside bigger
if c > 0:
l,r = 0,0
if c == 1:
l = In[c-1]+1
elif c > 1:
l = In[c-1]-In[c-2]
if c == len(In)-1:
r = N-In[c]
elif c < len(In)-1:
r = In[c+1]-In[c]
cnt += l*r
# Choose rightside bigger
if c < len(In)-1:
l,r = 0,0
if c == len(In)-2:
r = N-In[c+1]
elif c < len(In)-2:
r = In[c+2]-In[c+1]
if c == 0:
l = In[c]+1
elif c > 0:
l = In[c]-In[c-1]
cnt += l*r
ans += cnt*p
print(ans) | #!/usr/bin/python3
# -*- coding: utf-8 -*-
N = int(eval(input()))
Pn = list(map(int, input().split()))
In = [0] * (N+1)
for i in range(N):
In[Pn[i]] = i+1
cnt = 0
l = [0] + [i for i in range(N+1)]
r = [i+1 for i in range((N+1))] + [N+1]
for v in range(1, N+1):
i = In[v]
l1 = l[i]
l2 = l[l1]
r1 = r[i]
r2 = r[r1]
cnt += ((l1-l2) * (r1-i) + (i-l1) * (r2-r1)) * v
l[r1] = l1
r[l1] = r1
print(cnt)
| p02919 |
def resolve():
n = int(eval(input()))
p = list(map(int, input().split()))
second = sorted(p)[-2]
dp = [[[0, 0] for _ in range(n)] for __ in range(n)]
ans = 0
for i in range(n - 1):
dp[i][i + 1][1], dp[i][i + 1][0] = sorted([p[i], p[i + 1]])
ans += dp[i][i + 1][1]
for j in range(i + 2, n):
_, dp[i][j][1], dp[i][j][0] = sorted(
[dp[i][j - 1][0], dp[i][j - 1][1], p[j]])
ans += dp[i][j][1]
if dp[i][j][1] == second:
ans += dp[i][j][1] * (n - j - 1)
break
print(ans)
if __name__ == '__main__':
resolve()
| def resolve():
n = int(eval(input()))
p = list(map(int, input().split()))
second = sorted(p)[-2]
# dp = [[[0, 0] for _ in range(n)] for __ in range(n)]
ans = 0
for i in range(n - 1):
b, a = sorted([p[i], p[i + 1]])
ans += b
for j in range(i + 2, n):
x = p[j]
if x > a:
a, b = x, a
elif x > b:
a, b = a, x
else:
a, b = a, b
ans += b
if b == second:
ans += b * (n - j - 1)
break
print(ans)
if __name__ == '__main__':
resolve()
| p02919 |
# -*- coding: utf-8 -*-
N = int(eval(input()))
P_list = list(map(int, input().split()))
# rev_P_list = []
# for P in (reversed(P_list)):
# rev_P_list.append(P)
x_list_list = [[0 for i in range(N)] for i in range(N)]
ans = 0
for i in range(N - 1):
for j in range(i + 1, N):
if j == i + 1:
x_list_list[i][j] = sorted([P_list[i], P_list[j]], reverse=True)
ans += x_list_list[i][j][1]
else:
tmp_list = [t for t in x_list_list[i][j - 1]]
tmp_list.append(P_list[j])
tmp_list = sorted(tmp_list, reverse=True)
x_list_list[i][j] = [tmp_list[0], tmp_list[1]]
ans += x_list_list[i][j][1]
print(ans) | # -*- coding: utf-8 -*-
N = int(eval(input()))
P_list = list(map(int, input().split()))
# rev_P_list = []
# for P in (reversed(P_list)):
# rev_P_list.append(P)
x_dic = {}
ans = 0
for i in range(N - 1):
for j in range(i + 1, N):
if j == i + 1:
x_dic["{}_{}".format(i, j)] = sorted([P_list[i], P_list[j]], reverse=True)
ans += x_dic["{}_{}".format(i, j)][1]
else:
tmp_list = [t for t in x_dic["{}_{}".format(i, j - 1)]]
tmp_list.append(P_list[j])
tmp_list = sorted(tmp_list, reverse=True)
x_dic["{}_{}".format(i, j)] = [tmp_list[0], tmp_list[1]]
ans += x_dic["{}_{}".format(i, j)][1]
print(ans) | p02919 |
n = int(eval(input()))
ListP =[int(i) for i in input().split()]
#n = 10000
#ListP = [i for i in range(n)]
points = 0
ListPos2 = [0] * (n + 1)
for i, a in enumerate(ListP):
ListPos2[a] = i + 1
ListPos = [0, 0] + [ListPos2[n]] + [n+1, n+1]
#ListTPos = [0] * (n+2) + [n+1, n+1]
ListTPos = [0] * (n + 1) + [n+1]
ListTPos[ListPos2[n]] = ListPos2[n]
pos = 0
for i in reversed(list(range(1,n))):
posi = ListPos2[i]
ListTPos[posi] = posi
for j in ListTPos[posi+1:]:
if (j > 0):
pos = ListPos.index(j)
ListPos.insert(pos, posi)
#pos = ListTPos[j]
break
l1 = ListPos[pos-1]
l2 = ListPos[pos-2]
h1 = ListPos[pos+1]
h2 = ListPos[pos+2]
points += i * ((posi-l1)*(h2-h1) + (h1-posi)*(l1-l2))
#low1 = ListPos[pos] - ListPos[pos-1]
#low2 = ListPos[pos-1] - ListPos[pos-2]
#high1 = ListPos[pos+1] - ListPos[pos]
#high2 = ListPos[pos+2] - ListPos[pos+1]
#points += i * (low1 * high2 + high1 * low2)
#print(i, ListPos)
#print(points, low1, high2, high1, low2)
print(points) | n = int(eval(input()))
p = [int(i) for i in input().split()]
pos_list = [0] * n
for ind, i in enumerate(p):
pos_list[i-1] = ind
left_nextInd = list(range(-1, n-1)) + [-1, -1]
right_nextInd = list(range(1, n+1)) + [n, n]
answer = 0
for i in range(1, n):
ind = pos_list[i-1]
l1 = left_nextInd[ind]
l2 = left_nextInd[l1]
r1 = right_nextInd[ind]
r2 = right_nextInd[r1]
answer += i * ((ind-l1) * (r2-r1) + (r1-ind) * (l1-l2))
left_nextInd[r1] = l1
right_nextInd[l1] = r1
print(answer) | p02919 |
import bisect
n = int(eval(input()))
p = list(map(int, input().split()))
pi = sorted(zip(p, list(range(n))))
index = [-1, -1, pi[n - 1][1], n, n]
ret = 0
for pos in range(n - 2, -1, -1):
p, i = pi[pos]
ii = bisect.bisect_left(index, i)
ret += p * (index[ii - 1] - index[ii - 2]) * (index[ii] - i)
ret += p * (i - index[ii - 1]) * (index[ii + 1] - index[ii])
bisect.insort_left(index, i)
print(ret) | n = int(eval(input()))
p = list(map(int, input().split()))
pi = sorted(zip(p, list(range(n))))
left = {i: i - 1 for i in range(n)}
right = {i: i + 1 for i in range(n)}
left[-1] = -1
right[n] = n
ret = 0
for p, i in pi:
ret += p * (left[i] - left[left[i]]) * (right[i] - i)
ret += p * (i - left[i]) * (right[right[i]] - right[i])
l, r = left[i], right[i]
right[l] = r
left[r] = l
print(ret) | p02919 |
def main():
import sys
input=sys.stdin.readline
from bisect import bisect,insort
n=int(eval(input()))
p=list(map(int,input().split()))
p=[0]+p
q=[0]*(n+1)
for i in range(1,n+1):
q[p[i]]=i
lst=[0,q[n],n+1]
ans=0
for i in range(1,n):
k=i
i=n-i
num=q[i]
a=bisect(lst,num)
if a==1:
ans+=i*num*(lst[2]-lst[1])
insort(lst,num)
elif a==1+k:
ans+=i*(n+1-num)*(lst[k]-lst[k-1])
insort(lst,num)
else:
b=lst[a-2]
c=lst[a-1]
d=lst[a]
e=lst[a+1]
ans+=i*(d-num)*(c-b)+i*(num-c)*(e-d)
insort(lst,num)
print(ans)
if __name__=="__main__":
main() | n=int(eval(input()))
p=list(map(int,input().split()))
f=[0]*(n+1)
for i in range(n):
f[p[i]]=i+1
l=[0]+[i for i in range(n+1)]
r=[i+1 for i in range(n+1)]+[n+1]
ans=0
for i in range(1,n+1):
x=f[i]
l1,r1=l[x],r[x]
l2,r2=l[l1],r[r1]
ans+=i*((l1-l2)*(r1-x)+(x-l1)*(r2-r1))
l[r1],r[l1]=l1,r1
print(ans) | p02919 |
import bisect
N = int(eval(input()))
P = list(map(int, input().split()))
place = [-1] * (N + 1)
for i in range(N):
p = P[i]
place[p] = i
ans = 0
big_place = [place[N]]
for i in range(N - 1, 0, -1):
pos = bisect.bisect_left(big_place, place[i])
if pos < len(big_place):
right = big_place[pos]
else:
right = N
if pos + 1 < len(big_place):
right2 = big_place[pos + 1]
else:
right2 = N
if pos - 1 >= 0:
left = big_place[pos - 1]
else:
left = -1
if pos - 2 >= 0:
left2 = big_place[pos - 2]
else:
left2 = -1
if left >= 0:
left_cand = left - left2
else:
left_cand = 0
right_cand = right - place[i]
ans += i * left_cand * right_cand
if right < N:
right_cand = right2 - right
else:
right_cand = 0
left_cand = place[i] - left
ans += i * left_cand * right_cand
big_place1 = big_place[:pos]
big_place2 = big_place[pos:]
big_place = big_place1 + [place[i]] + big_place2
print(ans)
| class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
# i+1番目からR番目まで足すとt以上となるような最小のRを返す
def bisect_plus(self, i, t):
L = i
R = self.size
R_prev = R
sum_i = self.sum(i)
while True:
range_sum = self.sum(R) - sum_i
if range_sum < t:
if R == self.size:
return self.size + 1
L, R = R, R_prev
else:
R_prev = R
R = (L + R + 1) // 2
if R == R_prev:
return R
# L番目からi-1番目まで足すとt以上となるような最小のRを返す
def bisect_minus(self, i, t):
L = 1
R = i
L_prev = L
sum_i = self.sum(i - 1)
while True:
range_sum = sum_i - self.sum(L - 1)
if range_sum < t:
if L == 1:
return 0
L, R = L_prev, L
else:
L_prev = L
L = (L + R) // 2
if L == L_prev:
return L
N = int(eval(input()))
P = list(map(int, input().split()))
place = [-1] * (N + 1)
for i in range(N):
p = P[i]
place[p] = i
ans = 0
big_place = Bit(N)
big_place.add(place[N] + 1, 1)
for i in range(N - 1, 0, -1):
pos = place[i] + 1
right = big_place.bisect_plus(pos, 1)
right2 = big_place.bisect_plus(pos, 2)
left = big_place.bisect_minus(pos, 1)
left2 = big_place.bisect_minus(pos, 2)
if left > 0:
left_cand = left - left2
else:
left_cand = 0
right_cand = right - pos
ans += i * left_cand * right_cand
if right < N + 1:
right_cand = right2 - right
else:
right_cand = 0
left_cand = pos - left
ans += i * left_cand * right_cand
big_place.add(pos, 1)
print(ans)
| p02919 |
class SegmentTree:
def __init__(self, a):
self.padding = 0
self.n = len(a)
self.N = 2 ** (self.n-1).bit_length()
self.data = [self.padding]*(self.N-1) + a + [self.padding]*(self.N-self.n)
for i in range(2*self.N-2, 0, -2):
self.data[(i-1)//2] = sum([self.data[i], self.data[i-1]])
def __len__(self):
return self.n
def update(self, i, x):
idx = self.N - 1 + i
self.data[idx] = x
while idx:
idx = (idx-1) // 2
self.data[idx] = sum([self.data[2*idx+1], self.data[2*idx+2]])
def query(self, i, j):
# [i, j)
if i == j:
return self.data[self.N - 1 + i]
else:
idx1 = self.N - 1 + i
idx2 = self.N - 2 + j # 閉区間にする
result = self.padding
while idx1 + 1 < idx2:
if idx1&1 == 0: # idx1が偶数
result = sum([result, self.data[idx1]])
if idx2&1 == 1: # idx2が奇数
result = sum([result, self.data[idx2]])
idx2 -= 1
idx1 //= 2
idx2 = (idx2 - 1)//2
if idx1 == idx2:
result = sum([result, self.data[idx1]])
else: # idx1 + 1 == idx2
result = sum([result, self.data[idx1], self.data[idx2]])
return result
def find_next(st, idx):
n = len(st)
idx_v = st.query(idx, idx)
right_sum = st.query(idx, n) - idx_v
if right_sum:
left = idx
right = n
while left + 1 < right:
mid = (left + right) // 2
right_sum = st.query(idx, mid) - idx_v
if right_sum >= 1:
right = mid
else:
left = mid
return left
else:
return n
def find_before(st, idx):
if idx == 0:
return -1
left_sum = st.query(0, idx)
if left_sum:
left = 0
right = idx
while left + 1 < right:
mid = (left + right) // 2
left_sum = st.query(mid, idx)
if left_sum:
left = mid
else:
right = mid
return left
else:
return -1
N = int(eval(input()))
P = list(enumerate(list(map(int, input().split()))))
P = sorted(P, key=lambda x:x[1], reverse=True)
a = [0]*N
st = SegmentTree(a)
ans = 0
for i, p in P:
ir1 = find_next(st, i)
ir2 = N if ir1==N else find_next(st, ir1)
il1 = find_before(st, i)
il2 = -1 if il1==-1 else find_before(st, il1)
ans += ((ir1-i)*(il1-il2) + (ir2-ir1)*(i-il1)) * p
st.update(i, 1)
print(ans) | N = int(eval(input()))
P = list(enumerate(list(map(int, input().split()))))
P = sorted(P, key=lambda x:x[1])
before_idx = list(range(-1, N-1)) + [-1, -1]
next_idx = list(range(1, N+1)) + [N, N]
ans = 0
for i, p in P:
il1 = before_idx[i]
il2 = before_idx[il1]
ir1 = next_idx[i]
ir2 = next_idx[ir1]
ans += p * ((i-il1)*(ir2-ir1) + (ir1-i)*(il1 -il2))
before_idx[ir1] = il1
next_idx[il1] = ir1
print (ans) | p02919 |
N = int(eval(input()))
P = [int(x) - 1 for x in input().split()]
idx = [0] * N
for i in range(N):
idx[P[i]] = i
ans = 0
for i in range(N - 2, -1, -1):
find = False
l1 = idx[i] + 1
l2 = 0
for j in range(idx[i] - 1, -1, -1):
if i < P[j]:
if not find:
l1 = idx[i] - j
l2 = j + 1
find = True
else:
l2 = idx[i] - l1 - j
break
find = False
r1 = N - idx[i]
r2 = 0
for j in range(idx[i] + 1, N):
if i < P[j]:
if not find:
r1 = j - idx[i]
r2 = N - j
find = True
else:
r2 = j - r1 - idx[i]
break
ans += (i + 1) * (l1 * r2 + l2 * r1)
print(ans) | N = int(eval(input()))
P = [int(x) for x in input().split()]
PIdx = sorted([(i + 1, v) for i, v in enumerate(P)], key = lambda x: x[1])
L = [0]
for i in range(N + 1):
L.append(i)
R = [i + 1 for i in range(N + 1)]
R.append(N + 1)
ans = 0
for i, v in PIdx:
l1 = L[i]
l2 = L[l1]
r1 = R[i]
r2 = R[r1]
ans += v * ((i - l1) * (r2 - r1) + (l1 - l2) * (r1 - i))
L[r1] = l1
R[l1] = r1
print(ans) | p02919 |
n = int(eval(input()))
xs = list(map(int, input().split()))
x2i = {}
for i, x in enumerate(xs):
x2i[x] = i+1
ll = [0] * (n+2)
rr = [n+1] * (n+2)
def find_l(l, r, default):
m, m2 = 0, 0
mi=mi2=default
for i in range(r-l):
i = i + l
if ll[i] > m:
mi, m = i, ll[i]
for i in range(r-l):
i = i + l
if i == mi:
continue
if ll[i] > m2:
mi2, m2 = i, ll[i]
return max(mi, mi2), min(mi, mi2)
def find_r(l, r, default):
m, m2 = n+1, n+1
mi=mi2=default
for i in range(r-l):
i = i + l
if rr[i] < m:
mi, m = i, rr[i]
for i in range(r-l):
i = i + l
if i == mi:
continue
if rr[i] < m2:
mi2, m2 = i, rr[i]
return max(mi, mi2), min(mi, mi2)
class ss_min:
def __init__(self, init_val, n, ide_ele):
self.segfunc = min
self.num = 2**(n-1).bit_length()
self.ide_ele = ide_ele
self.seg=[self.ide_ele]*2*self.num
for i in range(n):
self.seg[i+self.num-1]=init_val[i]
for i in range(self.num-2,-1,-1) :
self.seg[i]=self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k+1:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1],self.seg[k*2+2])
def query(self, p, q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res,self.seg[p])
if q&1 == 1:
res = self.segfunc(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res,self.seg[p])
else:
res = self.segfunc(self.segfunc(res,self.seg[p]),self.seg[q])
return res
class ss_max:
def __init__(self, init_val, n, ide_ele):
self.segfunc = max
self.num = 2**(n-1).bit_length()
self.ide_ele = ide_ele
self.seg=[self.ide_ele]*2*self.num
for i in range(n):
self.seg[i+self.num-1]=init_val[i]
for i in range(self.num-2,-1,-1) :
self.seg[i]=self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k+1:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1],self.seg[k*2+2])
def query(self, p, q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res,self.seg[p])
if q&1 == 1:
res = self.segfunc(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res,self.seg[p])
else:
res = self.segfunc(self.segfunc(res,self.seg[p]),self.seg[q])
return res
ssmm = ss_min(rr, n+2, n+1)
ssmm2 = ss_max(ll, n+2, 0)
r = 0
for x in range(n):
x = n - x
# lmi, lmi2 = find_l(0, x2i[x], 0)
rmi2 = ssmm.query(x2i[x]+1, n+1)
ssmm.update(rmi2, n+1)
rmi = ssmm.query(x2i[x]+1, n+1)
ssmm.update(rmi2, rmi2)
lmi = ssmm2.query(0, x2i[x])
ssmm2.update(lmi, 0)
lmi2 = ssmm2.query(0, x2i[x])
ssmm2.update(lmi, lmi)
a,b,c,d =(x2i[x] - lmi), (lmi - lmi2), (rmi - rmi2), (rmi2 - x2i[x])
r += (a*c + b*d) * x
# print(x, r)
# print(rmi, rmi2, lmi, lmi2)
ll[x2i[x]] = x2i[x]
ssmm.update(x2i[x], x2i[x])
ssmm2.update(x2i[x], x2i[x])
print(r)
|
class SegTree:
def __init__(self, init_val, n, ide_ele, seg_func):
self.segfunc = seg_func
self.num = 2**(n-1).bit_length()
self.ide_ele = ide_ele
self.seg=[self.ide_ele]*2*self.num
for i in range(n):
self.seg[i+self.num-1]=init_val[i]
for i in range(self.num-2,-1,-1) :
self.seg[i]=self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k+1:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1],self.seg[k*2+2])
def query(self, p, q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res,self.seg[p])
if q&1 == 1:
res = self.segfunc(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res,self.seg[p])
else:
res = self.segfunc(self.segfunc(res,self.seg[p]),self.seg[q])
return res
n = int(eval(input()))
xs = list(map(int, input().split()))
x2i = {}
for i, x in enumerate(xs):
x2i[x] = i
ss1 = SegTree([n] * n, n, n, min)
ss2 = SegTree([-1] * n, n, -1, max)
r = 0
for x in range(n):
x = n - x
rmi2 = ss1.query(x2i[x]+1, n)
if rmi2 != n:
ss1.update(rmi2, n)
rmi = ss1.query(x2i[x]+1, n)
if rmi2 != n:
ss1.update(rmi2, rmi2)
lmi = ss2.query(0, x2i[x])
if lmi != -1:
ss2.update(lmi, -1)
lmi2 = ss2.query(0, x2i[x])
if lmi != -1:
ss2.update(lmi, lmi)
a,b,c,d =(x2i[x] - lmi), (lmi - lmi2), (rmi - rmi2), (rmi2 - x2i[x])
r += (a*c + b*d) * x
# print(x, r)
# print(rmi, rmi2, lmi, lmi2)
ss1.update(x2i[x], x2i[x])
ss2.update(x2i[x], x2i[x])
print(r)
| p02919 |
#!/usr/bin/env python3
import sys
from bisect import bisect_left, insort_left
INF = float("inf")
def solve(N: int, P: "List[int]"):
# 番号pは何番目か 0-index
rev = [0]*(N+1)
for i, p in enumerate(P):
rev[p] = i
ans = 0
seq = [rev[N]]
for i in range(N-1, 0, -1):
j = bisect_left(seq, rev[i])
seq.insert(j, rev[i])
# print(seq, j)
if j != 0:
L, R = seq[j-1], seq[j]
LL = seq[j-1]-seq[j-2] if j-2 >= 0 else seq[j-1]+1
RR = seq[j+1]-seq[j] if j+1 <= N-i else N-seq[j]
ans += i*(LL*RR)
# print("addA", i*(LL*RR), LL, RR)
if j != N-i:
L, R = seq[j], seq[j+1]
LL = seq[j]-seq[j-1] if j-1 >= 0 else seq[j]+1
RR = seq[j+2]-seq[j+1] if j+2 <= N-i else N-seq[j+1]
ans += i*(LL*RR)
# print("addB", i*(LL*RR), LL, RR)
# print("ans", ans)
# if i == 5:
# break
print(ans)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
P = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, P)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
# from collections import Counter
INF = float("inf")
class MaxBit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s = max(s, self.tree[i])
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] = max(self.tree[i], x)
i += i & -i
class MinBit:
def __init__(self, n):
self.size = n
self.tree = [n-1] * (n + 1)
def sum(self, i):
s = self.size-1
while i > 0:
s = min(s, self.tree[i])
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] = min(self.tree[i], x)
i += i & -i
def solve(N: int, P: "List[int]"):
prev = MaxBit(N+2)
foll = MinBit(N+2)
seq = [0]*(N+2)
inv = {p: i for i, p in enumerate(P)}
# print(inv)
# c = Counter()
ans = 0
for i in range(N, 0, -1):
prev.add(inv[i]+2, inv[i]+1)
foll.add(N-inv[i]+1, inv[i]+1)
seq[inv[i]+1] = i
# print("")
# print("{}番目に{}を追加".format(inv[i]+1, i))
# print("seq : ", seq)
# print("prev: ", [prev.sum(j) for j in range(N+2)])
# print("foll: ", [foll.sum(j) for j in range(N+2)][::-1])
p = prev.sum(inv[i]+1)
pp = prev.sum(p)
f = foll.sum(N-inv[i])
ff = foll.sum(N-f+1)
# 前の数字との組み合わせ
if p > 0:
# (前、今) 前に伸ばす * 後ろに伸ばす
ans += i*(p-pp)*(f-(inv[i]+1))
# print("+ (A): ", i*(p-pp)*(f-(inv[i]+1)))
# c[i] += (p - pp) * (f - (inv[i]+1))
# 後ろの数字との組み合わせ
if f < N+1:
# (今、後) 前に伸ばす * 後に伸ばす
ans += i*(inv[i]+1 - p) * (ff - f)
# print("+ (B): ", i*(inv[i]+1 - p)*(ff-f))
# c[i] += (ff - f) * ((inv[i]+1) - p)
print(ans)
# print([(i+1, c[i+1]) for i in range(N)])
# guchoku = Counter()
# for i in range(N):
# for j in range(i+1, N):
# guchoku[sorted(P[i:j+1])[-2]] += 1
# print(sorted(P[i:j+1])[-2], P[i:j+1])
# print([(i+1, guchoku[i+1]) for i in range(N)])
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
P = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, P)
if __name__ == '__main__':
main()
| p02919 |
#!/usr/bin/env python3
import sys
# from collections import Counter
INF = float("inf")
class MaxBit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s = max(s, self.tree[i])
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] = max(self.tree[i], x)
i += i & -i
class MinBit:
def __init__(self, n):
self.size = n
self.tree = [n-1] * (n + 1)
def sum(self, i):
s = self.size-1
while i > 0:
s = min(s, self.tree[i])
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] = min(self.tree[i], x)
i += i & -i
def solve(N: int, P: "List[int]"):
prev = MaxBit(N+2)
foll = MinBit(N+2)
seq = [0]*(N+2)
inv = {p: i for i, p in enumerate(P)}
# print(inv)
# c = Counter()
ans = 0
for i in range(N, 0, -1):
prev.add(inv[i]+2, inv[i]+1)
foll.add(N-inv[i]+1, inv[i]+1)
seq[inv[i]+1] = i
# print("")
# print("{}番目に{}を追加".format(inv[i]+1, i))
# print("seq : ", seq)
# print("prev: ", [prev.sum(j) for j in range(N+2)])
# print("foll: ", [foll.sum(j) for j in range(N+2)][::-1])
p = prev.sum(inv[i]+1)
pp = prev.sum(p)
f = foll.sum(N-inv[i])
ff = foll.sum(N-f+1)
# 前の数字との組み合わせ
if p > 0:
# (前、今) 前に伸ばす * 後ろに伸ばす
ans += i*(p-pp)*(f-(inv[i]+1))
# print("+ (A): ", i*(p-pp)*(f-(inv[i]+1)))
# c[i] += (p - pp) * (f - (inv[i]+1))
# 後ろの数字との組み合わせ
if f < N+1:
# (今、後) 前に伸ばす * 後に伸ばす
ans += i*(inv[i]+1 - p) * (ff - f)
# print("+ (B): ", i*(inv[i]+1 - p)*(ff-f))
# c[i] += (ff - f) * ((inv[i]+1) - p)
print(ans)
# print([(i+1, c[i+1]) for i in range(N)])
# guchoku = Counter()
# for i in range(N):
# for j in range(i+1, N):
# guchoku[sorted(P[i:j+1])[-2]] += 1
# print(sorted(P[i:j+1])[-2], P[i:j+1])
# print([(i+1, guchoku[i+1]) for i in range(N)])
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
P = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, P)
if __name__ == '__main__':
main()
| N = int(eval(input()))
P = list(map(int, input().split()))
pos = {}
for i, p in enumerate(P):
pos[p] = i+1
foll = [i+1 for i in range(N+1)]+[N+1]
prev = [0]+[i for i in range(N+1)]
ans = 0
for i in range(1, N+1):
curr = pos[i]
r = foll[curr]
rr = foll[r]
l = prev[curr]
ll = prev[l]
ans += (l-ll)*(r-curr)*i
ans += (rr-r)*(curr-l)*i
foll[l] = foll[curr]
prev[r] = prev[curr]
# print(*foll)
# print(*prev)
print(ans)
| p02919 |
import sys
from heapq import heappush, heappop
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
self.depth = pow(2, n.bit_length())
def add(self, i, x=1):
i += 1
while i <= self.n:
self.data[i] += x
i += i & -i
def get_sum(self, i):
i += 1
x = 0
while i > 0:
x += self.data[i]
i -= i & -i
return x
# Return sum for [l, r)
def get_sum_range(self, l, r):
return self.get_sum(r - 1) - self.get_sum(l - 1)
# Return the minimum i that satisfies a_0 + a_1 + ... + a_i >= x
def lower_bound(self, x):
if x <= 0:
return 0
i = 0
k = pow(2, self.depth)
while k:
if i + k < self.n and self.data[i + k] < x:
x -= self.data[i + k]
i += k
k >>= 1
return i
def main():
N, *P = list(map(int, read().split()))
index = [0] * (N + 1)
for i, p in enumerate(P):
index[p] = i
bit = BIT(N)
ans = 0
for n in range(N, 0, -1):
i = index[n]
bit.add(i)
x = bit.get_sum(i)
left1 = left2 = -1
right1 = right2 = N
if x - 2 > 0:
left2 = bit.lower_bound(x - 2)
if x - 1 > 0:
left1 = bit.lower_bound(x - 1)
if x + 1 <= N - n + 1:
right1 = bit.lower_bound(x + 1)
if x + 2 <= N - n + 1:
right2 = bit.lower_bound(x + 2)
ans += ((left1 - left2) * (right1 - i) + (right2 - right1) * (i - left1)) * n
print(ans)
return
if __name__ == '__main__':
main()
| import sys
from heapq import heappush, heappop
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *P = list(map(int, read().split()))
idx = [0] * (N + 1)
for i, p in enumerate(P):
idx[p] = i
left = list(range(-1, N)) + [-1]
right = list(range(1, N + 1)) + [N, N]
ans = 0
for n in range(1, N + 1):
i = idx[n]
l1 = left[i]
l2 = left[l1]
r1 = right[i]
r2 = right[r1]
ans += n * ((l1 - l2) * (r1 - i) + (r2 - r1) * (i - l1))
left[r1] = l1
right[l1] = r1
print(ans)
return
if __name__ == '__main__':
main()
| p02919 |
import sys
from heapq import heappush, heappop
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
self.depth = pow(2, n.bit_length())
def add(self, i, x=1):
i += 1
while i <= self.n:
self.data[i] += x
i += i & -i
def get_sum(self, i):
i += 1
x = 0
while i > 0:
x += self.data[i]
i -= i & -i
return x
# Return sum for [l, r)
def get_sum_range(self, l, r):
return self.get_sum(r - 1) - self.get_sum(l - 1)
# Return the minimum i that satisfies a_0 + a_1 + ... + a_i >= x
def lower_bound(self, x):
if x <= 0:
return 0
i = 0
s = 0
k = 1 << (self.depth - 1)
while k:
if i + k <= self.n and s + self.data[i + k] < x:
i += k
s += self.data[i]
k >>= 1
return i
def main():
N, *P = list(map(int, read().split()))
index = [0] * (N + 1)
for i, p in enumerate(P):
index[p] = i
bit = BIT(N)
ans = 0
for n in range(N, 0, -1):
i = index[n]
bit.add(i)
x = bit.get_sum(i)
left1 = left2 = -1
right1 = right2 = N
if x - 2 > 0:
left2 = bit.lower_bound(x - 2)
if x - 1 > 0:
left1 = bit.lower_bound(x - 1)
if x + 1 <= N - n + 1:
right1 = bit.lower_bound(x + 1)
if x + 2 <= N - n + 1:
right2 = bit.lower_bound(x + 2)
ans += ((left1 - left2) * (right1 - i) + (right2 - right1) * (i - left1)) * n
print(ans)
return
if __name__ == '__main__':
main()
| import sys
from heapq import heappush, heappop
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
self.step = pow(2, n.bit_length() - 1)
def add(self, i, x=1):
i += 1
while i <= self.n:
self.data[i] += x
i += i & -i
def get_sum(self, i):
i += 1
x = 0
while i > 0:
x += self.data[i]
i -= i & -i
return x
# Return sum for [l, r)
def get_sum_range(self, l, r):
return self.get_sum(r - 1) - self.get_sum(l - 1)
# Return the minimum i that satisfies a_0 + a_1 + ... + a_i >= x
def lower_bound(self, x):
if x <= 0:
return 0
i = 0
k = self.step
while k:
if i + k < self.n and self.data[i + k] < x:
x -= self.data[i + k]
i += k
k >>= 1
return i
def main():
N, *P = list(map(int, read().split()))
index = [0] * (N + 1)
for i, p in enumerate(P):
index[p] = i
bit = BIT(N)
ans = 0
for n in range(N, 0, -1):
i = index[n]
bit.add(i)
x = bit.get_sum(i)
left1 = left2 = -1
right1 = right2 = N
if x - 2 > 0:
left2 = bit.lower_bound(x - 2)
if x - 1 > 0:
left1 = bit.lower_bound(x - 1)
if x + 1 <= N - n + 1:
right1 = bit.lower_bound(x + 1)
if x + 2 <= N - n + 1:
right2 = bit.lower_bound(x + 2)
ans += ((left1 - left2) * (right1 - i) + (right2 - right1) * (i - left1)) * n
print(ans)
return
if __name__ == '__main__':
main()
| p02919 |
def slove():
import sys
input = sys.stdin.readline
s = list(str(input().rstrip('\n')))
w = int(input().rstrip('\n'))
print(("".join(s[::w])))
if __name__ == '__main__':
slove()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
s = str(readline().rstrip().decode('utf-8'))
w = int(readline())
ans = []
for i in range(0, len(s), w):
ans.append(s[i])
print(("".join(ans)))
if __name__ == '__main__':
solve()
| p03303 |
n = int(eval(input()))
a = list(map(int, input().split()))
safe = set()
for i in range(n - 1):
for j in range(i + 1, n):
pro = a[i] * a[j]
digit = [pro % (10 ** k) // (10 ** (k - 1)) for k in range(1, 10)]
while digit[-1] == 0:
digit = digit[:-1]
if len(digit) == 1:
safe.add(pro)
continue
flag = True
for k in range(len(digit) - 1):
if digit[k + 1] - digit[k] != -1:
flag = False
break
if flag:
safe.add(pro)
if safe:
print((max(safe)))
else:
print((-1))
| n = int(eval(input()))
a = list(map(int, input().split()))
ma = -1
for i in range(n - 1):
for j in range(i + 1, n):
pro = a[i] * a[j]
digit = [pro % (10 ** k) // (10 ** (k - 1)) for k in range(1, 10)]
while digit[-1] == 0:
digit = digit[:-1]
if len(digit) == 1:
ma = max(ma, pro)
continue
flag = True
for k in range(len(digit) - 1):
if digit[k + 1] - digit[k] != -1:
flag = False
break
if flag:
ma = max(ma, pro)
print(ma)
| p01880 |
n = int(eval(input()))
a = list(map(int, input().split()))
ma = -1
for i in range(n - 1):
for j in range(i + 1, n):
pro = a[i] * a[j]
digit = [pro % (10 ** k) // (10 ** (k - 1)) for k in range(1, 10)]
while digit[-1] == 0:
digit = digit[:-1]
if len(digit) == 1:
ma = max(ma, pro)
continue
flag = True
for k in range(len(digit) - 1):
if digit[k + 1] - digit[k] != -1:
flag = False
break
if flag:
ma = max(ma, pro)
print(ma)
| n = int(eval(input()))
a = list(map(int, input().split()))
ma = -1
for i in range(n - 1):
for j in range(i + 1, n):
pro = a[i] * a[j]
pre = pro % 10
pro //= 10
while pro:
if pre - pro % 10 == 1:
pre = pro % 10
pro //= 10
else:
break
if not pro:
ma = max(ma, a[i] * a[j])
print(ma)
| p01880 |
from collections import deque
N=int(eval(input()))
A=list(map(int,input().split()))
edge=[[] for i in range(N)]
for _ in range(N-1):
u,v=list(map(int,input().split()))
edge[u-1].append(v-1)
edge[v-1].append(u-1)
ans=[0]
parent=[-1]*N
que=deque([(0,-1)])
while que:
v,pv=que.popleft()
for nv in edge[v]:
if nv!=pv:
parent[nv]=v
ans.append(nv)
que.append((nv,v))
ans=ans[::-1]
dpc=[[] for i in range(N)]
dpn=[[] for i in range(N)]
sz=[0]*N
for v in ans:
sz[v]=1
if A[v]<0:
dpc[v]=[float("inf"),A[v]]
for nv in edge[v]:
if nv!=parent[v]:
merged=[float("inf")]*(sz[v]+sz[nv]+1)
for i in range(1,1+sz[v]):
for j in range(1,1+sz[nv]):
merged[i+j-1]=min(merged[i+j-1],dpc[v][i]+dpc[nv][j])
if dpn[nv][j]!=float("inf"):
merged[i+j]=min(merged[i+j],dpc[v][i])
merged[i+j-1]=min(merged[i+j-1],dpc[v][i]+dpn[nv][j])
dpc[v]=merged
sz[v]+=sz[nv]
dpn[v]=[float("inf")]*(sz[v]+1)
else:
dpn[v]=[float("inf"),A[v]]
for nv in edge[v]:
if nv!=parent[v]:
merged=[float("inf")]*(sz[v]+sz[nv]+1)
for i in range(1,1+sz[v]):
for j in range(1,1+sz[nv]):
if dpc[nv][j]<0:
merged[i+j]=min(merged[i+j],dpn[v][i])
merged[i+j-1]=min(merged[i+j-1],dpn[v][i]+dpn[nv][j])
if dpn[nv][j]!=float("inf"):
merged[i+j]=min(merged[i+j],dpn[v][i])
dpn[v]=merged
sz[v]+=sz[nv]
sz[v]=1
dpc[v]=[float("inf"),A[v]]
for nv in edge[v]:
if nv!=parent[v]:
merged=[float("inf")]*(sz[v]+sz[nv]+1)
for i in range(1+sz[v]):
for j in range(1+sz[nv]):
merged[i+j-1]=min(merged[i+j-1],dpc[v][i]+dpc[nv][j])
if dpn[nv][j]!=float("inf"):
merged[i+j]=min(merged[i+j],dpc[v][i])
merged[i+j-1]=min(merged[i+j-1],dpc[v][i]+dpn[nv][j])
dpc[v]=merged
sz[v]+=sz[nv]
ans=N
for i in range(1,N+1):
if dpc[0][i]<0 or dpn[0][i]!=float("inf"):
ans=i
break
print((ans-1))
| from collections import deque
N=int(eval(input()))
A=list(map(int,input().split()))
edge=[[] for i in range(N)]
for _ in range(N-1):
u,v=list(map(int,input().split()))
edge[u-1].append(v-1)
edge[v-1].append(u-1)
ans=[0]
parent=[-1]*N
que=deque([(0,-1)])
while que:
v,pv=que.popleft()
for nv in edge[v]:
if nv!=pv:
parent[nv]=v
ans.append(nv)
que.append((nv,v))
ans=ans[::-1]
for v in range(N):
edge[v]=[nv for nv in edge[v] if nv!=parent[v]]
dpc=[[] for i in range(N)]
dpn=[[] for i in range(N)]
sz=[0]*N
for v in ans:
sz[v]=1
sz[v]=1
dpc[v]=[10**18,A[v]]
for nv in edge[v]:
merged=[10**18]*(sz[v]+sz[nv]+1)
for i in range(1+sz[v]):
for j in range(1+sz[nv]):
merged[i+j-1]=min(merged[i+j-1],dpc[v][i]+min(dpc[nv][j],dpn[nv][j]))
if dpn[nv][j]<=10**15:
merged[i+j]=min(merged[i+j],dpc[v][i])
dpc[v]=merged
sz[v]+=sz[nv]
sz[v]=1
if A[v]<0:
dpn[v]=[10**18]*2
else:
dpn[v]=[10**18,A[v]]
for nv in edge[v]:
merged=[10**18]*(sz[v]+sz[nv]+1)
for i in range(1,1+sz[v]):
for j in range(1,1+sz[nv]):
if dpc[nv][j]<0:
merged[i+j]=min(merged[i+j],dpn[v][i])
merged[i+j-1]=min(merged[i+j-1],dpn[v][i]+dpn[nv][j])
if dpn[nv][j]<=10**15:
merged[i+j]=min(merged[i+j],dpn[v][i])
dpn[v]=merged
sz[v]+=sz[nv]
ans=N
for i in range(1,N+1):
if dpc[0][i]<0 or dpn[0][i]<=10**15:
ans=i
break
print((ans-1))
| p03159 |
N, M = list(map(int, input().split()))
LL, MM = list(map(int, input().split()))
gate = [LL + i for i in range(MM-LL+1)]
for _ in range(M-1):
LL, MM = list(map(int, input().split()))
tmp = [LL + i for i in range(MM-LL+1)]
gate = list(set(gate) & set(tmp))
print((len(gate)))
| N, M = list(map(int, input().split()))
min_, max_ = list(map(int, input().split()))
for _ in range(M-1):
LL, MM = list(map(int, input().split()))
min_ = max(min_, LL)
max_ = min(max_, MM)
if min_ <= max_:
print((max_ - min_ + 1))
else:
print((0)) | p03037 |
N, M = list(map(int,input().split()))
def main():
Ls = []
Rs = []
for i in range(M):
inputs = list(map(int,input().split()))
Ls.append(inputs[0])
Rs.append(inputs[1])
result = set()
for i in range(1, M + 1):
Li = Ls[i - 1]
LiPlus = { j for j in range(Li + 1, Rs[i - 1] + 1) }
LiPlus.add(Li)
if len(result) == 0:
result = LiPlus
continue
result = result & LiPlus
print((len(result)))
if __name__ == '__main__':
main() | N, M = list(map(int,input().split()))
def main():
Ls = []
Rs = []
for i in range(M):
inputs = list(map(int,input().split()))
Ls.append(inputs[0])
Rs.append(inputs[1])
maxL = max(Ls)
minR = min(Rs)
if maxL > minR:
print((0))
else:
print((minR - maxL + 1))
if __name__ == '__main__':
main() | p03037 |
from collections import Counter
N, M = list(map(int, input().split()))
cnt = Counter()
for i in range(M):
l, r = list(map(int, input().split()))
for i in range(l, r + 1):
cnt[i] += 1
ans = 0
for v in list(cnt.values()):
if v == M:
ans += 1
print(ans) | from collections import Counter
N, M = list(map(int, input().split()))
L = []
R = []
for i in range(M):
l, r = list(map(int, input().split()))
L.append(l)
R.append(r)
maxL = max(L)
minR = min(R)
ans = max(0, minR - maxL + 1)
print(ans) | p03037 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
def main():
n, m = list(map(int, input().split()))
ans = set([i for i in range(1 , n + 1)])
for _ in range(m):
l, r = list(map(int, input().split()))
card = set([i for i in range(l, r + 1)])
ans = ans & card
print((len(ans)))
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
def solve(l1, r1, l2, r2):
if r1 < l2 or r2 < l1:
return None
elif l1 < l2 and r1 < r2:
return [l2, r1]
elif l1 >= l2 and r1 <= r2:
return [l1, r1]
elif l1 <= l2 and r2 <= r1:
return [l2, r2]
else:
return [l1, r2]
def main():
n, m = list(map(int, input().split()))
ans = [1, n]
for _ in range(m):
l, r = list(map(int, input().split()))
# print(l, r)
ans = solve(ans[0], ans[1], l, r)
# print(ans)
if ans is None:
print((0))
exit(0)
print((ans[1] - ans[0] + 1))
if __name__ == '__main__':
main()
| p03037 |
# coding: UTF-8
# sample code
v = list(map(int, input().split()))
n, m = v[0], v[1]
l, r = [], []
for i in range(m):
v = list(map(int, input().split()))
l.append(v[0])
r.append(v[1])
num = 0
for i in range(n):
flag = 0
for j in range(m):
if not((l[j]<=i+1) and (i+1<=r[j])):
flag += 1
if flag == 0:
num += 1
print(num) | # coding: UTF-8
# sample code
v = list(map(int, input().split()))
n, m = v[0], v[1]
l, r = [], []
for i in range(m):
v = list(map(int, input().split()))
l.append(v[0])
r.append(v[1])
min = 1
max = n
for i in range(m):
if l[i] > min:
min = l[i]
if max > r[i]:
max = r[i]
num = max-min+1
if num < 0:
print((0))
else:
print(num) | p03037 |
n , m=list(map(int,input().split()))
l1 , r1 =list(map(int,input().split()))
A =set(range(l1,r1+1))
for i in range(m-1):
l , r =list(map(int,input().split()))
B = set(range(l,r+1))
A = A.intersection(B)
print((len(A))) | n , m = list(map(int,input().split()))
L = []
R = []
for i in range(m):
l , r = list(map(int,input().split()))
L.append(l)
R.append(r)
Lmax = max(L)
Rmin = min(R)
s = list(range(Lmax,Rmin+1))
print((len(s))) | p03037 |
li = input().split()
n = int(li[0])
m = int(li[1])
# IDカードn枚， ゲートm個
l_r = []
# i番目のゲートはl~rのIDカードを持っていれば通過できる
l_r = [input().split() for i in range(m)]
answer = 0
for i in range(n):
for lr in l_r:
l = int(lr[0])
r = int(lr[1])
if l <= i + 1 and i + 1 <= r:
continue
else:
break
else:
answer += 1
print(answer) | li = input().split()
n = int(li[0])
m = int(li[1])
# IDカードn枚， ゲートm個
# i番目のゲートはl~rのIDカードを持っていれば通過できる
l_r = [input().split() for i in range(m)]
l_r.sort(key=lambda x:int(x[0]))
l_max = int(l_r[-1][0])
l_r.sort(key=lambda x:int(x[1]))
r_min = int(l_r[0][1])
answer = 0
# for i in range(n):
# if l_max <= i + 1 and i + 1 <= r_min:
# answer += 1
diff = r_min - l_max + 1
if diff > 0:
print(diff)
else:
print((0)) | p03037 |
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def _I(): return int(sys.stdin.readline())
def _F(): return float(sys.stdin.readline())
def _pf(s): return print(s, flush=True)
N, M = LI()
LR = []
for i in range(M):
LR.append(LI())
#低い方と高い方を求める
lower = None
found = False
for i in range(1,N+1):
if found:
break
for lr in LR:
if not (lr[0] <= i <= lr[1]):
break
else:
lower = i
found = True
if lower == None:
print(0)
exit()
# print('lower', lower)
if lower == N:
print(1)
exit()
upper = None
found = False
for i in reversed(range(lower+1, N+1)):
if found:
break
for lr in LR:
if not (lr[0] <= i <= lr[1]):
break
else:
upper = i
found = True
if upper == None:
upper = lower
# print('upper', upper)
print(upper - lower + 1)
| import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def _I(): return int(sys.stdin.readline())
def _F(): return float(sys.stdin.readline())
def _pf(s): return print(s, flush=True)
N, M = LI()
LR = []
for i in range(M):
LR.append(LI())
left, right = 0, inf
for lr in LR:
left = max(left, lr[0])
right = min(right, lr[1])
# print(left, right)
if left > right:
print(0)
else:
print(right - left + 1)
| p03037 |
N, M = list(map(int, input().split()))
L = [None] * M
R = [None] * M
ans = [0] * (N + 1)
for i in range(M):
L[i], R[i] = list(map(int, input().split()))
for i in range(M):
for j in range(L[i], R[i] + 1):
ans[j] += 1
print((ans.count(M)))
| N, M = list(map(int, input().split()))
L = [None] * M
R = [None] * M
for i in range(M):
L[i], R[i] = list(map(int, input().split()))
ans = list(range(max(L), min(R) + 1))
print((len(ans))) | p03037 |
N,M=list(map(int,input().split()))
LR=list(range(N+1))
for i in range(M):
L,R=list(map(int,input().split()))
LR=list(set(list(range(L,R+1))) & set(LR))
print((len(LR))) | N,M=list(map(int,input().split()))
LR=set(range(N+1))
l=[]
r=[]
for i in range(M):
L,R=list(map(int,input().split()))
l.append(L)
r.append(R)
ans=min(r)-max(l)+1
if ans<0:
ans=0
print(ans) | p03037 |
inputted = list(map(int, input().split()))
N = inputted[0]
M = inputted[1]
LR = [list(map(int, input().split())) for i in range(M)]
left = 0
right = N
for LRi in LR:
left = max(left, LRi[0])
right = min(right, LRi[1])
if left > right: break
answer = max(0, right - left + 1)
print(answer)
| inputted = list(map(int, input().split()))
N = inputted[0]
M = inputted[1]
LR = [list(map(int, input().split())) for i in range(M)]
left = 1
right = N
for LRi in LR:
left = max(left, LRi[0])
right = min(right, LRi[1])
if left > right: break
answer = max(0, right - left + 1)
print(answer)
| p03037 |
import sys
def fastio():
from io import StringIO
from atexit import register
global input
sys.stdin = StringIO(sys.stdin.read())
input = lambda : sys.stdin.readline().rstrip('\r\n')
sys.stdout = StringIO()
register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
def debug(*var, sep = ' ', end = '\n'):
print(*var, file=sys.stderr, end = end, sep = sep)
INF = 10**20
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))
# from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
n, m = I()
a = [0] * (n + 10)
for i in range(m):
x, y = I()
a[x] += 1
a[y + 1] -= 1
ans = 0
for i in range(1, n + 10):
a[i] = a[i] + a[i - 1]
if a[i] == m:
ans += 1
print(ans)
| def mi():
return list(map(int, input().split()))
'''
3 4
*G*S
G**S
*G*S
'''
n,m = mi()
l = -1
r = 1e10
for i in range(m):
a,b=mi()
if l>b or b<a:
print((0))
exit()
l = max(l,a)
r = min(r,b)
if r<l:
print((0))
else:
print((r-l+1)) | p03037 |
n, m = list(map(int, input().split()))
ans_set = {x for x in range(1, n+1)}
for _ in range(m):
a, b = list(map(int, input().split()))
sub_set = {x for x in range(a, b+1)}
ans_set = ans_set & sub_set
ans = len(ans_set)
print(ans) | n, m = list(map(int, input().split()))
l = [0]*m
r = [0]*m
for i in range(m):
l[i], r[i] = list(map(int, input().split()))
ans = min(r) - max(l)
if ans >= 0 :
print((ans+1))
else:
print((0)) | p03037 |
N,M = list(map(int,input().split()))
#list_aaa = []
#
#for i in range(M):
# L,R = map(int,input().split())
# aaa = set(range(L,R+1))
# list_aaa.append(aaa)
#print(list_aaa)
#and_set = list_aaa[0]
for i in range(M):
L,R = list(map(int,input().split()))
aaa = set(range(L,R+1))
if i == 0:
and_set = aaa
else:
and_set = and_set.intersection(aaa)
print((len(and_set)))
| N,M = list(map(int,input().split()))
L_list = []
R_list = []
for i in range(M):
L,R = list(map(int,input().split()))
L_list.append(L)
R_list.append(R)
L_max = max(L_list)
R_min = min(R_list)
#print(range(L_max,R_min+1))
print((len(list(range(L_max,R_min+1))))) | p03037 |
N, M = list(map(int, input().split()))
card = False
for _ in range(M):
L, R = list(map(int, input().split()))
if card is not False:
card = card & set([i for i in range(L, R + 1)])
else:
card = set([i for i in range(L, R + 1)])
print((len(card))) | N, M = list(map(int, input().split()))
left = 1
right = N
for _ in range(M):
L, R = list(map(int, input().split()))
if left < L:
left = L
if R < right:
right = R
if left > right:
print((0))
exit()
print((right - left + 1)) | p03037 |
n,m=input().split()
n=int(n)
m=int(m)
i=1
x=list()
y=list()
ans=0
g=0
i=i+1
l,r=input().split()
l=int(l)
r=int(r)
while l != r + 1:
x.append(l)
l = l + 1
i=1
while m!=i:
i=i+1
l,r=input().split()
l=int(l)
r=int(r)
while l != r + 1:
y.append(l)
l = l + 1
while g!=len(x):
v=x[g] in y
if v==False:
x.remove(x[g])
else:
g=g+1
g=0
y=[]
print((len(x))) | n,m=input().split()
n=int(n)
m=int(m)
i=0
x=list()
y=list()
ans=0
g=0
ll=[]
rr=[]
while i!=m:
i=i+1
l,r=input().split()
l=int(l)
r=int(r)
ll.append(l)
rr.append(r)
l=max(ll)
r=min(rr)
ans=r-l+1
if l>r:
ans=0
print(ans)
| p03037 |
n, m = list(map(int, input().split()))
x = list()
for i in range(m):
temp = list(map(int, input().split()))
tempall = set()
for j in range(temp[0],temp[1]+1):
tempall.add(j)
x.append(tempall)
ans = set(x[0])
for i in range(m):
ans = ans & x[i]
print((len(ans))) | n, m = list(map(int, input().split()))
l = [1,n]
for i in range(m):
temp = list(map(int, input().split()))
l[0] = max(l[0],temp[0])
l[1] = min(l[1],temp[1])
print((int(max(l[1]-l[0]+1, 0)))) | p03037 |
n, m = list(map(int, input().split()))
l, r = list(map(int, input().split()))
ID = list(range(l, r + 1))
for _ in range(m - 1):
l, r = list(map(int, input().split()))
if r < min(ID):
print((0))
exit()
elif max(ID) < l:
print((0))
exit()
elif min(ID) >= l and max(ID) >= r:
l = min(ID)
ID.clear()
ID.extend(list(range(l, r + 1)))
elif min(ID) < l and max(ID) >= r:
ID.clear()
ID.extend(list(range(l, r + 1)))
elif min(ID) < l and max(ID) < r:
r = max(ID)
ID.clear()
ID.extend(list(range(l, r + 1)))
print((len(ID)))
| n, m = list(map(int, input().split()))
l, r = list(map(int, input().split()))
for _ in range(m - 1):
li, ri = list(map(int, input().split()))
if ri < l:
print((0))
exit()
elif r < li:
print((0))
exit()
elif l >= li and r >= ri:
r = ri
elif l < li and r >= ri:
l, r = li, ri
elif l < li and r < ri:
l = li
print((r - l + 1))
| p03037 |
n,m=list(map(int,input().split()))
zahyo=[0]*m
for i in range(m):
zahyo[i]=list(map(int,input().split()))
collec_lis=[]
for i in range(m):
collec_lis.extend(list(range(int(zahyo[i][0]),int(zahyo[i][1])+1)))
import collections
c = collections.Counter(collec_lis)
kyotu=[int(i) for i in list(c.values()) if i==m]
print((len(kyotu))) |
# 左右の範囲を絞っていくことで共通要素のみを炙り出す
n,m = list(map(int,input().split()))
l = -1
r = n+1
for i in range(m):
l_i,r_i = list(map(int,input().split()))
l = max(l,l_i)
r = min(r,r_i)
print((max(0,r-l+1))) | p03037 |
n,m=list(map(int,input().split()))
memo=[]
l,r=list(map(int,input().split()))
for i in range(r-l+1):
memo.append(l+i)
for v in range(m-1):
memo1=[]
l,r=list(map(int,input().split()))
for k in range(len(memo)):
if l<=memo[k]<=r:
memo1.append(memo[k])
memo=memo1
print((len(memo))) | n,m=list(map(int,input().split()))
l=[]
r=[]
for i in range(m):
l1,r1=list(map(int,input().split()))
l.append(l1)
r.append(r1)
print((0 if min(r)-max(l)+1<0 else min(r)-max(l)+1)) | p03037 |
N, M = [int(n) for n in input().split()]
A = [1 for _ in range(N)]
for _ in range(M):
L, R = [int(n) for n in input().split()]
for i in range(0, L-1, 1):
A[i] = 0
for i in range(R, N, 1):
A[i] = 0
cnt = 0
for i in range(N):
if A[i] == 1:
cnt += 1
print(cnt)
| N, M = [int(n) for n in input().split()]
left, right = 1, N
for _ in range(M):
L, R = [int(n) for n in input().split()]
if left < L:
left = L
if R < right:
right = R
if left <= right:
print((right - left + 1))
else:
print((0))
| p03037 |
import copy
N,M=list(map(int,input().split()))
D=[]
for _ in range(M):
if _==0:
LR=list(map(int,input().split()))
for u in range(LR[0],LR[1]+1):
D.append(u)
else:
LR=list(map(int,input().split()))
DD=copy.deepcopy(D)
for v in DD:
if v not in list(range(LR[0],LR[1]+1)):
D.remove(v)
print((len(D))) | N,M=list(map(int,input().split()))
LR=list(list(map(int,input().split())) for _ in range(M))
L=1
R=N
for i in range(M):
L=max(L,LR[i][0])
R=min(R,LR[i][1])
print((R-L+1 if L<=R else 0)) | p03037 |
n, m = list(map(int, input().split()))
l, r = list(map(int, input().split()))
ans = set(range(l, r + 1))
for _ in range(m - 1):
l, r = list(map(int, input().split()))
ans &= set(range(l, r + 1))
print((len(ans))) | n, m = list(map(int, input().split()))
l, r = list(map(int, input().split()))
for _ in range(m - 1):
a, b = list(map(int, input().split()))
l = max(l, a)
r = min(r, b)
print((max(0, r - l + 1)))
| p03037 |
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
l_first, r_first = list(map(int, input().split()))
answer_set = {value for value in range(l_first, r_first + 1)}
for _ in range(m - 1):
l_current, r_current = list(map(int, input().split()))
current_set = {value for value in range(l_current, r_current + 1)}
answer_set.intersection_update(current_set)
print((len(answer_set)))
| import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
l_list = []
r_list = []
for _ in range(m):
l, r = list(map(int, input().split()))
l_list.append(l)
r_list.append(r)
l_maybe_answer = max(l_list)
r_maybe_answer = min(r_list)
if l_maybe_answer <= r_maybe_answer:
print((min(r_list) - max(l_list) + 1))
else:
print((0))
| p03037 |
def main():
N, M = list(map(int, input().split()))
box = []
for i in range(M):
LR = [j for j in map(int, input().split())]
box += LR
# for i in range(M):
# L, R = map(int, input().split())
# box.append(L)
# box.append(R)
# print(box)
num = 0
for j in range(1, N+1):
plus = 1
# print(j)
if plus == 1:
for i in range(0, len(box), 2):
# print(box[i], box[i+1])
if j < box[i] or box[i+1] < j:
plus = 0
break
num += plus
print(num)
if __name__ == "__main__":
main()
| def main():
N, M = list(map(int, input().split()))
L = []
R = []
for i in range(M):
l, r = list(map(int, input().split()))
L.append(l)
R.append(r)
Lout = max(L)
Rout = min(R)
ans = Rout - Lout+1
if ans < 0:
print((0))
else:
print(ans)
if __name__ == "__main__":
main()
| p03037 |
def doqueri(S,N,L,R):
s = S[L-1:R]
l = [0] * (L-1)
r = [0] * (N-R)
return l+s+r
if __name__ == '__main__':
N, M = list(map(int, input().split()))
S = [1] * N
for _ in range(M):
L,R = list(map(int, input().split()))
S = doqueri(S[:],N,L,R)
print((S.count(1))) | if __name__ == '__main__':
N, M = list(map(int, input().split()))
lmax = 0
rmin = N
for _ in range(M):
L,R = list(map(int, input().split()))
if L > lmax:
lmax = L
if R < rmin:
rmin = R
ans = rmin - lmax + 1
if ans < 0:
ans = 0
print(ans) | p03037 |
N, M = list(map(int, input().split()))
stepper = 0
gate = []
for j in range(M):
gate_1, gate_2 = list(map(int, input().split()))
gate.append([gate_1, gate_2])
def numJudge(arr, num):
if arr[0] <= num <= arr[1]:
return 1
else:
return 0
def judge(num):
num += 1
ctr = 0
for k in range(M):
if gate[k][0] <= num <= gate[k][1]:
ctr += 1
if ctr == M:
return 1
else:
return 0
ans = list(map(judge, list(range(N))))
print((sum(list(ans))))
| N, M = list(map(int, input().split()))
stepper = 0
gate = []
for j in range(M):
gate_1, gate_2 = list(map(int, input().split()))
gate.append([gate_1, gate_2])
gate_min = 0
gate_max = N
for m in range(M):
if gate[m][0] > gate_min:
gate_min = gate[m][0]
if gate[m][1] < gate_max:
gate_max = gate[m][1]
#print(gate_min, gate_max)
for k in range(N):
k = k+1
if gate_min <= k <= gate_max:
stepper += 1
print(stepper)
| p03037 |
n, m = list(map(int, input().split()))
l, r = [0]*m, [0]*m
for i in range(m):
l[i], r[i] = list(map(int, input().split()))
ans = [0]*n
for i in range(m):
memo = [0]*n
for j in range(l[i]-1, r[i]):
memo[j] = 1
for k in range(n):
ans[k] += memo[k]
print((ans.count(m))) | n, m = list(map(int, input().split()))
l, r = [0]*m, [0]*m
for i in range(m):
l[i], r[i] = list(map(int, input().split()))
ll = max(l)
rr = min(r)
if rr-ll >= 0:
print((rr-ll+1))
else:
print((0)) | p03037 |
import sys
import math
from collections import defaultdict
from collections import deque
def load(vtype=int):
return vtype(input().strip())
def load_list(seplator=" ", vtype=int):
return [vtype(v) for v in input().strip().split(seplator)]
def exit():
import sys
sys.exit(0)
def perm_sub(li, used):
if len(li) == len(used):
return [deque()]
k = []
for i in range(len(li)):
if i in used:
continue
used.add(i)
sub_list = perm_sub(li, used)
for sub in sub_list:
sub.appendleft(li[i])
k.extend(sub_list)
used.discard(i)
return k
def perm_li(li):
return perm_sub(li, set())
def perm_n(n):
return perm_sub(list(range(n)), set())
def join_i(li, sep=""):
return sep.join([str(e) for e in li])
def li2n(li):
n, base = 0, 1
for i in range(len(li)-1, -1, -1):
n += li[i] * base
base *= 10
return n
def sli2ili(li):
return [int(s) for s in li]
def prime_list(n):
li = [i for i in range(2, n+1)]
for i in range(len(li)):
if li[i] >= int(math.sqrt(n)):
break
if li[i] == -1:
continue
for j in range(i+1, len(li)):
if li[j] % li[i] == 0:
li[j] = -1
return [n for n in li if n != -1]
def gcd(a, b):
a, b = max(a, b), min(a, b)
while True:
r = a % b
if r == 0: return b
a, b = b, r
def lcm(a, b):
return int(a * b / gcd(a,b))
def all_subset(li):
s = []
n = len(li)
for bit in range(0, (1<<(n+1))):
ss = set()
for i in range(0, n):
if (bit & (1 << i)):
ss.add(li[i])
s.append(ss)
return s
def factorial(n):
if n == 1:
return 1
return n * factorial(n-1)
def mCn(m, n):
def factorial_ntimes(m, n):
r = 1
while n:
r *= m
m -= 1
n -= 1
return r
return int(factorial_ntimes(m, n) / factorial(n))
n,m = load_list()
lr = []
for _ in range(m):
l, r = load_list()
lr.append(set(range(l, r+1)))
passed = set.intersection(*lr)
print((len(passed)))
| import sys
import math
from collections import defaultdict
from collections import deque
def load(vtype=int):
return vtype(input().strip())
def load_list(seplator=" ", vtype=int):
return [vtype(v) for v in input().strip().split(seplator)]
def exit():
import sys
sys.exit(0)
def perm_sub(li, used):
if len(li) == len(used):
return [deque()]
k = []
for i in range(len(li)):
if i in used:
continue
used.add(i)
sub_list = perm_sub(li, used)
for sub in sub_list:
sub.appendleft(li[i])
k.extend(sub_list)
used.discard(i)
return k
def perm_li(li):
return perm_sub(li, set())
def perm_n(n):
return perm_sub(list(range(n)), set())
def join_i(li, sep=""):
return sep.join([str(e) for e in li])
def li2n(li):
n, base = 0, 1
for i in range(len(li)-1, -1, -1):
n += li[i] * base
base *= 10
return n
def sli2ili(li):
return [int(s) for s in li]
def prime_list(n):
li = [i for i in range(2, n+1)]
for i in range(len(li)):
if li[i] >= int(math.sqrt(n)):
break
if li[i] == -1:
continue
for j in range(i+1, len(li)):
if li[j] % li[i] == 0:
li[j] = -1
return [n for n in li if n != -1]
def gcd(a, b):
a, b = max(a, b), min(a, b)
while True:
r = a % b
if r == 0: return b
a, b = b, r
def lcm(a, b):
return int(a * b / gcd(a,b))
def all_subset(li):
s = []
n = len(li)
for bit in range(0, (1<<(n+1))):
ss = set()
for i in range(0, n):
if (bit & (1 << i)):
ss.add(li[i])
s.append(ss)
return s
def factorial(n):
if n == 1:
return 1
return n * factorial(n-1)
def mCn(m, n):
def factorial_ntimes(m, n):
r = 1
while n:
r *= m
m -= 1
n -= 1
return r
return int(factorial_ntimes(m, n) / factorial(n))
n,m = load_list()
lr = []
lmax = 0
rmin = 10**6
for _ in range(m):
l, r = load_list()
lmax = max(lmax, l)
rmin = min(rmin, r)
print((len(list(range(lmax, rmin+1)))))
| p03037 |
n, m = list(map(int, input().split()))
array = [list(map(int, input().split())) for i in range(m)]
result = set([i for i in range(1, n+1)])
for el in array:
L, R = el[0], el[1]
work = set([i for i in range(L, R+1)])
result = work & result
print((len(result))) | n, m = list(map(int, input().split()))
array = [list(map(int, input().split())) for i in range(m)]
result = [1, n]
for el in array:
if el[0] > result[1] or result[0] > el[1]:
result = [1, 0]
break
else:
work = sorted(result + el)
result = [work[1], work[2]]
print((result[1]-result[0]+1)) | p03037 |
n,m=list(map(int,input().split()))
l,r=list(map(int,input().split()))
a=set(range(l,r+1))
for i in range(m-1):
l,r=list(map(int,input().split()))
a.intersection_update(list(range(l,r+1)))
print((len(a)))
| n,m=list(map(int,input().split()))
ll,rr=0,n
for i in range(m):
l,r=list(map(int,input().split()))
ll=max(l,ll)
rr=min(r,rr)
print((max(rr-ll+1,0))) | p03037 |
N,M = list(map(int,input().split()))
listA=[]
while True:
try:
listA.append(list(map(int,input().split())))
except:
break;
count = 0
for i in range(1,N+1):
for j in range(M):
if i < listA[j][0] or listA[j][1] < i:
break;
if j == M-1:
count += 1
print(count) | N,M = list(map(int,input().split()))
listA=[]
while True:
try:
listA.append(list(map(int,input().split())))
except:
break;
L=[]
R=[]
for i in listA:
L.append(i[0])
R.append(i[1])
maxL = max(L)
minR = min(R)
count = 0
for i in range(1,N+1):
if maxL <= i <= minR:
count+=1
print(count) | p03037 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n, m = list(map(int, readline().split()))
lr = [list(map(int, readline().split())) for _ in range(m)]
id_list = [i for i in range(lr[0][0], lr[0][1] + 1)]
for i in range(1, m):
x = 1
id_list = [j for j in id_list if lr[i][0] <= j <= lr[i][1]]
print((len(id_list))) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n, m = list(map(int, readline().split()))
lr = [list(map(int, readline().split())) for _ in range(m)]
left = 0
right = n
for i in range(m):
left = max(left, lr[i][0])
right = min(right,lr[i][1])
print((max(0,right-left+1))) | p03037 |
N, M = list(map(int, input().split()))
K = set(range(1, N + 1))
for i in range(M):
l, r = list(map(int, input().split()))
K = K & set(range(l, r + 1))
print((len(K))) | N, M = list(map(int, input().split()))
L = 1
R = N
for i in range(M):
l, r = list(map(int, input().split()))
if l > L:
L = l
# print('L ' + str(L))
if r < R:
R = r
# print('R ' + str(R))
if L > R:
print((0))
else:
print((R - L + 1))
| p03037 |
N, M = list(map(int, input().split()))
LR = []
for _ in range(M):
l, r = list(map(int, input().split()))
LR.append((l, r))
cards = LR[:]
master_ids = set(range(cards[0][0], cards[0][1]+1))
for l, r in cards:
ids = set(range(l, r+1))
master_ids = master_ids & ids
if not master_ids:
break
ans = len(master_ids)
print(ans)
| N, M = list(map(int, input().split()))
LR = []
for _ in range(M):
l, r = list(map(int, input().split()))
LR.append((l, r))
cards = LR[:]
import sys
INT_MAX = sys.maxsize
left_id = 0
right_id = INT_MAX
for l, r in cards:
left_id = max(left_id, l)
right_id = min(right_id, r)
if left_id <= right_id:
ans = right_id + 1 - left_id
else:
ans = 0
print(ans) | p03037 |
n, m = list(map(int, input().split()))
Authority = [list(map(int, input().split())) for _ in range(m)]
cards = set(range(1, n + 1))
for i in range(m):
gate = set(range(Authority[i][0], Authority[i][1] + 1))
cards &= gate
print((len(cards)))
| n, m = list(map(int, input().split()))
Authority = [list(map(int, input().split())) for _ in range(m)]
cards = list(range(1, n + 2))
l_list = []
r_list = []
for i in range(m):
l_list.append(Authority[i][0])
r_list.append(Authority[i][1])
print((len(cards[max(l_list):min(r_list) + 1])))
| p03037 |
N,M=(int(i) for i in input().split())
gate=[]
for i in range(M):
gate.append([int(i) for i in input().split()])
gate[i].append(gate[i][1]-gate[i][0])
gate=sorted(gate,key=lambda x:x[2])
answer=0
for i in range(N+1):
ok=1
for l,r,p in gate:
if l<=i and i<=r:
pass
else:
ok=0
break
if ok==1:
answer+=1
print(answer) | N,M=(int(i) for i in input().split())
gate=[]
for i in range(M):
gate.append([int(i) for i in input().split()])
maxl=max(gate,key=lambda x:x[0])[0]
minr=min(gate,key=lambda x:x[1])[1]
if maxl<=minr:
print((minr-maxl+1))
else:
print((0)) | p03037 |
n, m = [int(i) for i in input().split()]
x = [[0 for _ in range(m)] for i in range(n)]
for i in range(m):
l, r = [int(i) for i in input().split()]
for j in range(l-1, r):
x[j][i] = 1
counter = 0
for i in range(n):
if sum(x[i]) == m:
counter += 1
print(counter) | n, m = [int(i) for i in input().split()]
ll = []
rr = []
for i in range(m):
l, r = [int(i) for i in input().split()]
ll.append(l)
rr.append(r)
ans = min(rr) - max(ll) + 1
if ans < 0:
ans = 0
print(ans) | p03037 |
n,m = list(map(int,input().split()))
a = {}
for i in range(m):
l,r = list(map(int,input().split()))
for j in range(l,r+1):
if not j in a:
a[j] = 1
else:
a[j] += 1
count = 0
for key in list(a.keys()):
if a[key] == m:
count +=1
print(count) | n,m = list(map(int,input().split()))
min,max = list(map(int,input().split()))
for i in range(m-1):
l,r = list(map(int,input().split()))
if l > max:
print((0))
exit(0)
if r < min:
print((0))
exit(0)
if l > min:
min = l
if r < max:
max = r
print((max-min+1)) | p03037 |
n, m = list(map(int, input().split()))
l, r = list(map(int, input().split()))
ans = [x for x in range(l, r+1)]
if m > 1:
for i in range(m-1):
l, r = list(map(int, input().split()))
ans = [x for x in range(l, r+1) if x in ans]
print((len(ans)))
| n, m = list(map(int, input().split()))
l, r = list(map(int, input().split()))
ans = -1
if m > 1:
for i in range(m-1):
_l, _r = list(map(int, input().split()))
if (l < _l <= r):
l = _l
if (l <= _r < r):
r = _r
if _r < l or r < _l:
ans = 0
print(ans)
break
if ans == -1:
print((r-l+1))
| p03037 |
card_num, gate_num = list(map(int, input().split()))
table = [0] * card_num
count = 0
for i in range(gate_num):
start_num, end_num = list(map(int, input().split()))
for j in range(start_num-1, end_num):
table[j] += 1
for l in range(card_num):
if table[l] == gate_num:
count += 1
print(count) | # 先頭の最大と最後尾の最小を求める
card_num, gate_num = list(map(int, input().split()))
lmax, rmin = list(map(int, input().split())) # 最初の入力がlの最大とrの最小
for i in range(1, gate_num):
l, r = list(map(int, input().split()))
lmax = max(lmax, l) # lmaxにlmaxとlの大きい方
rmin = min(rmin, r) # rminにrminとrの小さい方
print((max(0, rmin-lmax+1))) # 0かrmin-lmax+1の大きい方を出力 | p03037 |
n,m=list(map(int,input().split()))
D=[list(map(int,input().split())) for i in range(m)]
I=set(i for i in range(1,n+1))
for i in range(m):
I &= set(i for i in range(D[i][0],D[i][1]+1))
print((len(I))) | n,m=list(map(int,input().split()))
D=[list(map(int,input().split())) for i in range(m)]
maxI=n
minI=1
for i in range(m):
maxI=min(maxI,D[i][1])
minI=max(minI,D[i][0])
print((max(maxI-minI+1,0))) | p03037 |
def set_range(x, y):
return {t+x for t in range(y-x)}
N, M = list(map(int, input().split()))
L = [0]*M
R = [0]*M
for m in range(M):
L[m], R[m] = list(map(int, input().split()))
S = set_range(1, N+1)
for m in range(M):
S = S.intersection(set_range(L[m], R[m]+1))
print((len(S))) | N, M = list(map(int, input().split()))
L = [0]*M
R = [0]*M
for m in range(M):
L[m], R[m] = list(map(int, input().split()))
print((max(0,min(R)-max(L)+1))) | p03037 |
import sys
input=sys.stdin.readline
N,M = list(map(int, input().split()))
g = set(i for i in range(1,N+1))
for i in range(M):
l,r = list(map(int, input().split()))
t = set(i for i in range(l,r+1))
g = g & t
print((len(g)))
| import sys
input=sys.stdin.readline
N,M = list(map(int, input().split()))
l,r = 1,N
for i in range(M):
l1,r1 = list(map(int, input().split()))
if l1>l:
l = l1
if r1<r:
r = r1
if r-l<0:
print((0))
else:
print((r-l+1))
| p03037 |
# ABC127C - Prison
n, m = list(map(int, input().rstrip().split()))
lst = [list(map(int, input().rstrip().split())) for _ in range(m)]
gates = [{j for j in range(i[0], i[1] + 1)} for i in lst]
ans = gates[0]
for i in gates[1:]:
ans = ans & i
print((len(ans))) | # ABC127C - Prison
n, m = list(map(int, input().rstrip().split()))
a, b = list(map(int, input().rstrip().split()))
ans = {i for i in range(a, b + 1)}
for _ in range(m - 1):
a, b = list(map(int, input().rstrip().split()))
ans = ans & {i for i in range(a, b + 1)}
print((len(ans))) | p03037 |
# ABC127C - Prison
n, m = list(map(int, input().rstrip().split()))
lst = [list(map(int, input().rstrip().split())) for _ in range(m)]
ans = 0
l, r = lst[0][0], lst[0][1]
for i in lst[1:]:
l = max(l, i[0])
r = min(r, i[1])
for i in range(1, n + 1):
if l <= i <= r:
ans += 1
print(ans) | # ABC127C - Prison
# l-max < i < r-min -> count i
n, m = list(map(int, input().rstrip().split()))
lst = [list(map(int, input().rstrip().split())) for _ in range(m)]
l, r = lst[0][0], lst[0][1]
for i in lst[1:]:
l = max(l, i[0])
r = min(r, i[1])
print((max(0, r - l + 1))) | p03037 |
tmp = input().split()
N = int(tmp[0])
M = int(tmp[1])
cardlist = []
for i in range(M):
cardlist.append(list(map(int, input().split())))
count = 0
for i in range(1, N+1):
flag = True
for j in range(M):
if (cardlist[j][0] > i or cardlist[j][1] < i):
flag = False
break
if (flag):
count += 1
print(count) | tmp = input().split()
N = int(tmp[0])
M = int(tmp[1])
max = N
min = 0
for i in range(M):
inputcard = list(map(int, input().split()))
if min < inputcard[0]:
min = inputcard[0]
if max > inputcard[1]:
max = inputcard[1]
if (max - min + 1 < 0):
print((0))
else:
print((max - min + 1)) | p03037 |
N, M = list(map(int, input().split()))
master = set(range(1, N+1))
for _ in range(M):
L, R = list(map(int, input().split()))
master = master & set(range(L, R+1))
print((len(master))) | N, M = list(map(int, input().split()))
lb = 1
rb = N
for _ in range(M):
L, R = list(map(int, input().split()))
lb = max(lb, L)
rb = min(rb, R)
print((rb-lb+1 if lb <= rb else 0)) | p03037 |
n,m = list(map(int,input().split()))
card = [0]*n
for i in range(m):
l,r = list(map(int,input().split()))
l -= 1
card[l:r] = list([x+1 for x in card[l:r]])
print((card.count(m))) | n,m = list(map(int,input().split()))
card = [0]*n
l,r = 1,n
for i in range(m):
tmp_l,tmp_r = list(map(int,input().split()))
if l < tmp_l:
l=tmp_l
if r > tmp_r:
r = tmp_r
ans = 0
if r-l>=0:
ans = r-l+1
print(ans) | p03037 |
n,m = list(map(int, input().split()))
for m_i in range(m):
l,r = list(map(int, input().split()))
if m_i==0:
ans = set(range(l, r+1))
else:
ans &= set(range(l, r+1))
print((len(ans))) | n,m = list(map(int, input().split()))
L = []
R = []
for _ in range(m):
l,r = list(map(int, input().split()))
L.append(l)
R.append(r)
print((min(R)-max(L)+1 if min(R)-max(L)>=0 else 0)) | p03037 |
#n: id card
#m: gate
n, m = list(map(int, input().split()))
data = [0 for i in range(n+1)]
ans = 0
for i in range(m):
l, r = list(map(int, input().split()))
for j in range(l, r+1):
data[j] += 1
if data[j] == m:
ans += 1
print(ans) | #n: id card
#m: gate
n, m = list(map(int, input().split()))
data = [0 for i in range(n+1)]
for i in range(m):
l, r = list(map(int, input().split()))
data[l-1] += 1
data[r] -= 1
for i in range(n):
data[i+1] += data[i]
print((data.count(m))) | p03037 |
N, M = [int(x) for x in input().split()]
LR = [[int(x) for x in input().split()] for i in range(M)]
LR = [list(range(x,y+1)) for (x,y) in LR]
res = set(LR[0])
for x in LR[1:]:
# print(res)
# print(x)
res = res.intersection(set(x))
# print(res)
print((len(res))) | N, M = [int(x) for x in input().split()]
L = 1
R = N
for i in range(M):
L_,R_ = [int(x) for x in input().split()]
L = max(L, L_)
R = min(R, R_)
print((max((R-L + 1), 0))) | p03037 |
n, m = input().split()
N = int(n)
M = int(m)
s = set([])
card = N
for i in range(M):
l, r = input().split()
L = int(l)
R = int(r)
for j in range(N):
if L <= j+1 and j+1 <= R:
pass
else:
s.add(j+1)
print((N - len(list(s))))
| n, m = input().split()
N = int(n)
M = int(m)
listL = []
listR = []
card = N
for i in range(M):
l, r = input().split()
L = int(l)
R = int(r)
listL.append(L)
listR.append(R)
maxL = max(listL)
minR = min(listR)
if minR < maxL:
result = 0
else:
result = minR - maxL + 1
print(result)
| p03037 |
N, M = list(map(int, input().split()))
L = []
R = []
for i in range(M):
L_in, R_in = list(map(int, input().split()))
L.append(L_in)
R.append(R_in)
cnt = 0
for n in range(N):
counter = 0
for m in range(M):
if (n + 1) == R[m] or (L[m] <= (n + 1) and (n + 1) <= R[m]):
counter += 1
if counter == M:
cnt += 1
else:
break
print(cnt)
| N, M = list(map(int, input().split()))
L = []
R = []
for m in range(M):
L_in, R_in = list(map(int, input().split()))
L.append(L_in)
R.append(R_in)
if min(R) >= max(L):
print((min(R) - max(L) + 1))
else:
print((0))
| p03037 |
N,M=list(map(int,input().split()))
all=[]
for i in range(M):
L,R=list(map(int,input().split()))
ids=[b for b in range(L,R+1)]
all.append(ids)
for a in range(M):
ans=set(all[a])&set(all[0])
print((len(ans))) | N,M=list(map(int,input().split()))
all=[]
for i in range(M):
L,R=list(map(int,input().split()))
if i==0:
ans=[b for b in range(L,R+1)]
else:
ids=[b for b in range(L,R+1)]
ans=set(ans)&set(ids)
print((len(ans))) | p03037 |
N,M=list(map(int,input().split()))
all=[]
for i in range(M):
L,R=list(map(int,input().split()))
if i==0:
ans=[b for b in range(L,R+1)]
else:
ids=[b for b in range(L,R+1)]
ans=set(ans)&set(ids)
print((len(ans))) | N,M=list(map(int,input().split()))
L,R=[],[]
for i in range(M):
l,r=list(map(int,input().split()))
L.append(l)
R.append(r)
ans=min(R)-max(L)+1
if ans<=0:
ans=0
print(ans) | p03037 |
import sys
input = sys.stdin.readline
def main():
N, M = [int(x) for x in input().split()]
answer = set()
for i in range(M):
L, R = [int(x) for x in input().split()]
if i == 0:
answer = {x for x in range(L, R + 1)}
else:
s = {x for x in range(L, R + 1)}
answer &= s
print((len(answer)))
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
def main():
N, M = [int(x) for x in input().split()]
A = []
for i in range(M):
A.append([int(x) for x in input().split()])
answer = A[0]
for i in range(1, M):
if max(answer) < min(A[i]) or max(A[i]) < min(answer):
print((0))
exit()
total = []
total.extend(answer)
total.extend(A[i])
s_total = sorted(total)
answer = s_total[1:3]
print((answer[1] - answer[0] + 1))
if __name__ == '__main__':
main()
| p03037 |
n, m = list(map(int, input().split()))
buf = set(range(1, n+1))
for i in range(m):
l, r = list(map(int, input().split()))
buf = buf & set(range(l, r+1))
print((len(buf)))
| a = 1
n, m = list(map(int, input().split()))
ans_r = 10 ** 5
l_list = []
r_list = []
for i in range(m):
l, r = list(map(int, input().split()))
l_list.append(int(l))
r_list.append(int(r))
for r in r_list:
if ans_r > r:
ans_r = r
for l in l_list:
if a < l:
a = l
if ans_r >= a:
print((ans_r - a + 1))
else:
print((0))
| p03037 |
N, M = list(map(int, input().split()))
B = set()
for i in range(M):
L, R = list(map(int, input().split()))
A = set(j for j in range(L, R+1))
if i == 0:
B = A
B = A & B
print((len(B)))
| N, M = list(map(int, input().split()))
maxL = 1
minR = N
for i in range(M):
L, R = list(map(int, input().split()))
maxL = max(maxL, L)
minR = min(minR, R)
print((max(minR - maxL +1, 0))) | p03037 |
n, m = list(map(int, input().split()))
left, right = list(map(int, input().split()))
ans = set(range(left, right+1))
for i in range(m-1):
left, right = list(map(int, input().split()))
set_temp = set(range(left, right+1))
ans = ans & set_temp
print((len(ans))) | n, m = list(map(int, input().split()))
min_num = 0
max_num = 10**5
for i in range(m):
min_temp, max_temp = list(map(int, input().split()))
if min_temp > min_num:
min_num = min_temp
if max_temp < max_num:
max_num = max_temp
print((max(max_num - min_num + 1, 0)))
| p03037 |
def resolve():
N,M = list(map(int,input().split()))
# LL,RR = [],[]
# for i in range(M):
# L,R = map(int,input().split())
# LL.append(L)
# RR.append(R)
ans = 0
# print()
# print(N,M)
# print(LL,RR)
bool_id = [1]*N
# print(bool_id)
for i in range(M): #Gate num
# print(LL[i],RR[i])
# l,r = LL[i]-1,RR[i]
l,r = list(map(int,input().split()))
#bool_id[l:r] = [True]*(r-l)
bool_id[:l-1] = [0]*(l-1)
bool_id[r:] = [0]*(N-r)
# print(bool_id)
print((sum(bool_id)))
resolve() | def resolve():
N,M = list(map(int,input().split()))
LL,RR = [],[]
for i in range(M):
L,R = list(map(int,input().split()))
LL.append(L)
RR.append(R)
bool_id = [1]*N
lmin = -1
rmax = 10**10
for i in range(M):
lmin = max(lmin,LL[i])
rmax = min(rmax,RR[i])
print((max(rmax-lmin+1,0)))
resolve() | p03037 |
N, M = list(map(int,input().split()))
ID = list(i+1 for i in range(N))
for i in range(M):
L,R = list(map(int,input().split()))
ID_new = [j for j in range(L,R+1)]
ID = set(ID) & set(ID_new)
print((len(ID))) | N, M = list(map(int,input().split()))
l=1
r=N
for i in range(M):
L,R = list(map(int,input().split()))
l = max(l,L)
r = min(r,R)
ans = r-l+1
if ans >= 0:
print(ans)
else:
print((0))
| p03037 |
# -*- coding: utf-8 -*-
# abc127/abc127_c
import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
def main():
N, M = i2nn()
R, L = i2nn()
ss = set(range(R, L + 1))
for i in range(1, M):
R, L = i2nn()
ss = ss & set(range(R, L + 1))
print((len(ss)))
return
main()
| # -*- coding: utf-8 -*-
# abc127/abc127_c
import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
def main():
N, M = i2nn()
L, R = (0, N)
for i in range(M):
Li, Ri = i2nn()
if L < Li:
L = Li
if Ri < R:
R = Ri
if L > R:
print((0))
else:
print((R - L + 1))
return
main()
| p03037 |
def resolve():
(n, m) = list(map(int, input().split(" ")))
results = [0] * n
for i in range(m):
o = list(map(int, input().split(" ")))
if i == 0:
results[o[0]:o[1]+1] = [1] * (o[1]+1-o[0])
continue
for j in range(n):
if not results[j]:
continue
if not (o[0] <= j and j <= o[1]):
results[j] = 0
if o[1] < j:
break
if results.count(1) == 0:
print((0))
return
print((results.count(1)))
if '__main__' == __name__:
resolve() | def resolve():
(n, m) = list(map(int, input().split(" ")))
for i in range(m):
o = list(map(int, input().split(" ")))
if i == 0:
lmax = o[0]
rmin = o[1]
else:
lmax = max(lmax, o[0])
rmin = min(rmin, o[1])
print((rmin-lmax+1 if lmax <= rmin else 0))
if '__main__' == __name__:
resolve() | p03037 |
n, m = [int(i) for i in input().split()]
table = [[int(i) for i in input().split()] for m in range(m)]
a = list(range(table[0][0],table[0][1]+1))
ans = a
for i,t in enumerate(table[1:]):
if i == 0:
b = list(range(t[0], t[1]+1))
ans = set(a) & set(b)
else:
b = list(range(t[0], t[1]+1))
ans = ans & set(b)
print((len(ans))) | n,m=list(map(int,input().split()))
low=1
high=n
for i in range(m):
l,r=list(map(int,input().split()))
low = max(low,l)
high=min(high,r)
ans=high-low+1
print((ans if ans>=0 else 0)) | p03037 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.