input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N = int(eval(input()))
LP = list(map(int, input().split()))
cnt = 0
for i in range(N-2):
LA = []
LB = []
LA.append(LP[i])
LA.append(LP[i+1])
LA.append(LP[i+2])
LB = sorted(LA)
if LA[1] == LB[1]:
cnt += 1
print(cnt) | N = int(eval(input()))
LP = list(map(int, input().split()))
cnt = 0
for i in range(N-2):
LA = []
LB = []
LA = [LP[i],LP[i+1],LP[i+2]]
LB = sorted(LA)
if LA[1] == LB[1]:
cnt += 1
print(cnt) | p02988 |
import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
from itertools import permutations, combinations, accumulate
from functools import *
from collections import deque, defaultdict, Counter
from heapq import heapify, heappop, heappush, heappushpop
INF = float('inf')
NIL = - 1
""" Input
S = input().rstrip()
N, A, B = map(int, input().split())
A = np.array(input().split(), dtype=np.float64)
D = [int(input()) for _ in range(N)]
AB = [[int(x) for x in input().split()] for _ in range(N)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
"""
N = int(eval(input()))
P = list(map(int, input().split()))
counter = 0
for i in range(1, len(P) - 1):
if (P[i - 1] < P[i] and P[i] < P[i + 1]) or (P[i - 1] > P[i] and P[i] > P[i + 1]):
counter += 1
print(counter)
# def main():
# if __name__ == '__main__':
# main()
| import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
from itertools import permutations, combinations, accumulate
from functools import *
from collections import deque, defaultdict, Counter
from heapq import heapify, heappop, heappush, heappushpop
INF = float('inf')
NIL = - 1
N = int(eval(input()))
P = list(map(int, input().split()))
counter = 0
for i in range(1, len(P) - 1):
if (P[i - 1] < P[i] < P[i + 1]) or (P[i - 1] > P[i] > P[i + 1]):
counter += 1
print(counter)
| p02988 |
n = int(eval(input()))
p = list(map(int, input().split()))
ans = sum(p[i] == (p[i + 1] + p[i] + p[i - 1] - max(p[i + 1], p[i], p[i - 1]) - min(p[i + 1], p[i], p[i - 1])) for i in range(1, n - 1))
print(ans)
| n = int(eval(input()))
p = list(map(int, input().split()))
ans = sum(
p[i - 1] < p[i] < p[i + 1] or p[i - 1] > p[i] > p[i + 1]
for i in range(1, n - 1)
)
print(ans)
| p02988 |
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
s = S()
d = defaultdict(int)
for i in s:
d[i] += 1
for i in list(d.keys()):
if d[i] != 2:
print("No")
quit()
print("Yes")
return
#B
def B():
n = I()
p = LI()
ans = 0
for i in range(1,n-1):
k = p[i-1:i+2]
k.sort()
if k[1] == p[i]:
ans += 1
print(ans)
return
#C
def C():
n = I()
return
#D
def D():
n = I()
return
#E
def E():
n = I()
return
#F
def F():
n = I()
return
#Solve
if __name__ == "__main__":
B()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
p = LI()
a = [0]*(n+1)
a[p[0]] += 1
a[p[1]] += 1
a[p[2]] += 1
ans = 0
if sum(a[:p[1]]) == 1:
ans += 1
for i in range(2,n-1):
a[p[i-2]] -= 1
a[p[i+1]] += 1
if sum(a[:p[i]]) == 1:
ans += 1
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| p02988 |
n = int(eval(input()))
L = [int(i) for i in input().split()]
Answer = int(0)
for i in range(n-2):
if L[i]<L[i+1] and L[i+1]<L[i+2]:
Answer = Answer + 1
continue
if L[i+2]<L[i+1] and L[i+1]<L[i]:
Answer = Answer + 1
continue
print(Answer)
| n = int(eval(input()))
L = [int(i) for i in input().split()]
Answer = int(0)
for i in range(n-2):
if L[i]<L[i+1] and L[i+1]<L[i+2]:
Answer = Answer + 1
if L[i+2]<L[i+1] and L[i+1]<L[i]:
Answer = Answer + 1
print(Answer)
| p02988 |
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque
# import fractions
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
P = il()
ret = 0
for n in range(1, N - 1):
if P[n - 1] < P[n] < P[n + 1] or P[n - 1] > P[n] > P[n + 1]:
ret += 1
print(ret)
if __name__ == '__main__':
main()
| import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
P = il()
ret = 0
for n in range(1, N-1):
if P[n-1] < P[n] < P[n+1] or P[n-1] > P[n] > P[n+1]:
ret += 1
print(ret)
if __name__ == '__main__':
main()
| p02988 |
n = int(eval(input()))
p = list(map(int, input().split()))
count = 0
for i in range(1,len(p)-1,1):
if p[i+1] > p[i] > p[i-1]:
count = count +1
elif p[i+1] < p[i] < p[i-1]:
count = count +1
else:
pass
print(count) | n = int(eval(input()))
p = list(map(int, input().split()))
count = 0
for i in range(1,n-1,1):
if p[i+1] > p[i] > p[i-1]:
count = count +1
elif p[i+1] < p[i] < p[i-1]:
count = count +1
else:
pass
print(count) | p02988 |
cnt = 0
n = int(eval(input()))
lst = [int(i) for i in input().split()]
for i in range(n-2):
a,b,c = lst[i],lst[i+1],lst[i+2]
if (a<b and b<c) or (c<b and b<a):
cnt += 1
print(cnt) | n = int(eval(input()))
lst = list(map(int,input().split()))
cnt = 0
for i in range(1,n-1):
x,y,z = lst[i-1],lst[i],lst[i+1]
if x<=y<=z or z<=y<=x:
cnt += 1
print(cnt) | p02988 |
n = int(eval(input()))
l = list(map(int,input().split()))
cnt =0
for i in range(1,n-1):
if l[i-1]<l[i]<l[i+1] or l[i-1]>l[i]>l[i+1]:
cnt+=1
print(cnt) | def solve():
n = int(eval(input()))
p = list(map(int,input().split()))
cnt = 0
for i in range(1,n-1):
if p[i-1]<p[i]<p[i+1] or p[i-1]>p[i]>p[i+1]:
cnt+=1
print(cnt)
if __name__=='__main__':
solve() | p02988 |
n = int(eval(input()))
PPP = list(map(int, input().split()))
ans = 0
for i in range(1, n-1):
if (PPP[i] >= PPP[i-1] and PPP[i+1] > PPP[i]) or (PPP[i-1] > PPP[i] and PPP[i] >= PPP[i+1]):
ans += 1
print(ans)
| N = int(eval(input()))
PPP = list(map(int, input().split()))
ans = 0
for i in range(1, N-1):
if (PPP[i] >= PPP[i-1] and PPP[i+1] > PPP[i]) or (PPP[i] >= PPP[i+1] and PPP[i-1] > PPP[i]):
ans += 1
print(ans)
| p02988 |
n = int(eval(input()))
p = list(map(int, input().split()))
cnt = 0
for i in range(2, n):
if p[i-2] < p[i-1] < p[i] or p[i-2] > p[i-1] > p[i]:
cnt += 1
print(cnt)
| n = int(eval(input()))
p = list(map(int, input().split()))
cnt = 0
for i in range(2, n):
a = [p[i], p[i-1], p[i-2]]
a.sort()
if p[i-1] == a[1]:
cnt += 1
print(cnt)
| p02988 |
n = int(eval(input()))
P = list(map(int, input().split()))
ans = 0
for i in range(0,len(P)-2):
if P[i] < P[i+1] < P[i+2] or P[i+2] < P[i+1] < P[i]:
ans += 1
print(ans) | n = int(eval(input()))
P = list(map(int,input().split()))
ans = 0
for i in range(n-2):
if P[i]<P[i+1]<P[i+2] or P[i+2] < P[i+1] < P[i]:
ans += 1
else:
pass
print(ans) | p02988 |
n = int(eval(input()))
*p, = list(map(int, input().split()))
ans = 0
for i in range(n - 2):
if p[i] < p[i + 1] < p[i + 2] or p[i + 2] < p[i + 1]< p[i]:
ans += 1
print(ans)
| n = int(eval(input()))
p = list(map(int, input().split()))
ans = 0
for i in range(n - 2):
if p[i] < p[i + 1] < p[i + 2] or p[i + 2] < p[i + 1]< p[i]:
ans += 1
print(ans)
| p02988 |
N = int(eval(input()))
P = list(map(int, input().split()))
ans = 0
for i in range(N-2):
ans += P[i] < P[i+1] < P[i+2]
ans += P[i] > P[i+1] > P[i+2]
print(ans)
| n = int(eval(input()))
p = list(map(int, input().split()))
ans = 0
for i in range(1, n-1):
if p[i-1] < p[i]<p[i+1] or p[i+1] < p[i] < p[i-1]:
ans += 1
print(ans)
| p02988 |
n=int(eval(input()))
p=list(input().split())
p=[int(i) for i in p]
cnt=0
for i in range(1,n-1):
if p[i]!=max(p[i-1],max(p[i],p[i+1])) and p[i]!=min(p[i-1],min(p[i],p[i+1])):
cnt+=1
print(cnt)
| n=int(eval(input()))
p=list(input().split())
p=[int(i) for i in p]
cnt=0
for i in range(1,n-1):
if p[i]!=max(p[i-1],p[i],p[i+1]) and p[i]!=min(p[i-1],p[i],p[i+1]):
cnt+=1
print(cnt)
| p02988 |
n = int(eval(input()))
p = list(map(int,input().split()))
ans = 0
for i in range(1,n-1):
x = p[i-1:i+2]
x.sort()
if x[1] == p[i]:
ans+=1
print(ans) | n = int(eval(input()))
p = list(map(int,input().split()))
ans = 0
for i in range(1,n-1):
t = p[i-1:i+2]
if max(t)>t[1]>min(t):
ans+=1
print(ans) | p02988 |
n = int(eval(input()))
p = list(map(int , input().split()))
meet_condition = 0
for i in range(n-2):
X =[]
for j in range(3):
X.append(p[i+j])
if p[i+1] != max(X) and p[i+1] != min(X):
meet_condition += 1
print(meet_condition) | n = int(eval(input()))
p = list(map(int , input().split()))
meet_condition = 0
for i in range(1 , n-1):
if p[i-1] < p[i] < p[i+1] or p[i-1] > p[i] > p[i+1]:
meet_condition += 1
print(meet_condition) | p02988 |
n = int(eval(input()))
pn = list(map(int,input().split()))
count = 0
for i in range(1,n-1):
if (pn[i] > pn[i-1] and pn[i] < pn[i+1]) or (pn[i] < pn[i-1] and pn[i] > pn[i+1]):
count += 1
print(count) | count = 0
n = int(eval(input()))
p = list(map(int,input().split()))
for i in range(n-2):
if p[i] < p[i+1] < p[i+2]:
count += 1
elif p[i] > p[i+1] > p[i+2]:
count += 1
print(count) | p02988 |
N = int(eval(input()))
P = list(map(int,input().split()))
ans = 0
for i in range(1,N-1):
if P[i-1]<P[i]<P[i+1] or P[i-1]>P[i]>P[i+1]:
ans += 1
print(ans) | n=int(eval(input()))
p=list(map(int,input().split()))
ans=0
for i in range(1,n-1):
if (p[i-1]<p[i] and p[i]<p[i+1]) or (p[i+1]<p[i] and p[i]<p[i-1]):
ans+=1
print(ans)
| p02988 |
def solve(string):
n, c = string.split()
n, c = int(n), list(c)
wi, ri = 0, n - 1
while wi < n and c[wi] == "R":
wi += 1
while ri >= 0 and c[ri] == "W":
ri -= 1
ans = 0
while wi < n and ri >= 0 and wi < ri:
c[wi], c[ri], ans = c[ri], c[wi], ans + 1
wi, ri = wi + 1, ri - 1
while wi < n and c[wi] == "R":
wi += 1
while ri >= 0 and c[ri] == "W":
ri -= 1
return str(ans)
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| def solve(string):
_, c = string.split()
r = c.count("R")
return str(c[:r].count("W"))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| p02597 |
# 初期入力
from bisect import bisect_left
import sys
#input = sys.stdin.readline #文字列では使わない
N = int(eval(input()))
c =input().strip()
ans =0
w =[i for i, x in enumerate(c) if x == 'W']
r =[i for i, x in enumerate(c) if x == 'R']
w_num =len(w) #全体でWの数
r_num =len(r) #全体でRの数
ans =bisect_left(r,r_num)
print((r_num -ans)) |
# 初期入力
from bisect import bisect_left
import sys
#input = sys.stdin.readline #文字列では使わない
N = int(eval(input()))
c =input().strip()
ans =0
r =[i for i, x in enumerate(c) if x == 'R'] #全体の中でRのIndex
r_num =len(r) #全体でRの数
ans =bisect_left(r,r_num) #呪われないためのRとWの境界
print((r_num -ans)) #境界より右側のRの数 | p02597 |
import sys
input = sys.stdin.readline
n=int(eval(input()))
s=list(input().strip())
count = 0
for i in range(n):
if s[i]=='W':
for j in range(n-1,i,-1):
if s[j]=='R':
s[i],s[j]=s[j],s[i]
count+=1
break
else:
break
print(count)
| import sys
input = sys.stdin.readline
n=int(eval(input()))
s=list(input().strip())
count = 0
cw = s.count('W')
cr = n-cw
for i in range(cr):
if s[i]=='W':
count+=1
print(count)
| p02597 |
# -*- coding: utf-8 -*-
import sys
def main():
N = int( sys.stdin.readline() )
c_list = list(sys.stdin.readline().rstrip())
cnt = 0
L = 0
R = len(c_list) - 1
while L < R:
if (c_list[L] == "W") and (c_list[R] == "R"):
c_list[L], c_list[R] = c_list[R], c_list[L]
cnt += 1
L += 1
R -= 1
elif c_list[L] == "R":
L += 1
elif c_list[R] == "W":
R -= 1
print(cnt)
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
def main():
N = int( sys.stdin.readline() )
c_list = list(sys.stdin.readline().rstrip())
num_R = c_list.count("R")
cnt = 0
for i in range(num_R):
if c_list[i] == "W":
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| p02597 |
import re
N = int(input().strip())
# C = [c for c in input().strip()]
C = input().strip()
G = re.compile(r"^R*W*$")
cnt = 0
def rep(i, c, r, w):
if i == r:
return "W"
elif i == w:
return "R"
else:
return c
while not G.match(C):
cnt += 1
r = C.rfind("R")
w = C.find("W")
C = "".join([
rep(i, c, r, w)
for i, c in enumerate(C)
])
# break
print(cnt) | N = int(input().strip())
C = [c for c in input().strip()]
if "W" not in C or "R" not in C:
print((0))
import sys; sys.exit(0)
cnt = 0
i = 0
j = len(C) - 1
while i < j:
while C[i] == "R":
i += 1
while C[j] == "W":
j -= 1
if i > j:
break
cnt += 1
C[i] = "R"
C[j] = "W"
i += 1
j -= 1
print(cnt) | p02597 |
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))
n = ini()
s = list(ins())
t = sorted(s)
ans = 0
for i in range(n):
if t[i] != "R":
break
if s[i] != t[i]:
ans += 1
print(ans)
| import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))
n = ini()
s = list(ins())
n = s.count("R")
t = sorted(s)
ans = 0
for i in range(n):
if s[i] != t[i]:
ans += 1
print(ans)
| p02597 |
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))
n = ini()
s = list(ins())
n = s.count("R")
t = sorted(s)
ans = 0
for i in range(n):
if s[i] != t[i]:
ans += 1
print(ans)
| import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))
n = ini()
s = list(ins())
n = s.count("R")
ans = 0
for i in range(n):
if s[i] != "R":
ans += 1
print(ans)
| p02597 |
n,s,*w=open(0)
r=[-1]
n=int(n)
a=i=0
while i<n:
if'W'>s[i]:r+=i,
else:w+=i,
i+=1
for w in w:
if r.pop()>w:a+=1
else:break
print(a) | _,s=open(0)
print((s[:s.count('R')].count('W'))) | p02597 |
import sys
readline = sys.stdin.readline
from collections import deque
def solve():
N = int(readline())
C = readline().rstrip()
R, W = 'R', 'W'
reds = deque(i for i in range(len(C)) if C[i] == 'R')
whites = deque(i for i in range(len(C)) if C[i] == 'W')
count = 0
while len(whites) > 0 and len(reds) > 0 and whites[0] < reds[-1]:
reds.pop()
whites.popleft()
count += 1
print(count)
solve() | import sys
readline = sys.stdin.readline
def solve():
N = int(readline())
C = readline().rstrip()
reds = [i for i in range(len(C)) if C[i] == 'R']
whites = [i for i in range(len(C)) if C[i] == 'W']
i = 0
n = min(len(reds), len(whites))
while i < n and reds[-1-i] > whites[i]:
i += 1
print(i)
solve() | p02597 |
import sys
sys.setrecursionlimit(10**6)
def main(input, print):
N = int(input())
C = list(input().strip())
last = N
ans = 0
for i in range(N):
if C[i] == 'W':
for j in reversed(range(i+1, last)):
if C[j] == 'R':
ans += 1
last = j
break
print(ans)
if __name__ == '__main__':
main(sys.stdin.readline, print)
| import sys
sys.setrecursionlimit(10**6)
def main(input, print):
N = int(input())
C = list(input().strip())
last = N
ans = 0
for i in range(N):
if C[i] == 'W':
has_r = False
for j in reversed(range(i+1, last)):
if C[j] == 'R':
ans += 1
last = j
has_r = True
break
if not has_r:
break
print(ans)
if __name__ == '__main__':
main(sys.stdin.readline, print)
| p02597 |
from itertools import accumulate
from math import ceil
N = int(eval(input()))
A = list(map(int, input().split()))
class BinaryIndexedTree:
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += (i & -i)
def reset(self):
self.bit = [0] * (self.size + 1)
# BIT準備
BIT = BinaryIndexedTree(N)
# 答えをにぶたん
lo, hi = -1, max(A) + 1 # sample2などに対応するためにhiを設定
while hi - lo > 1:
m = (hi + lo) // 2
# m以上かどうかで分類
binary = [(1 if a >= m else -1) for a in A]
binary = list(accumulate(binary))
# BITの初期化
BIT.reset()
# 和が0以上となる連続部分列を数える
tmp = 0
# 転倒数っぽくやる
binary_sorted = {b: i for i, b in enumerate(sorted(binary), start=1)}
ans = 0
for j, b in enumerate(binary):
tmp += BIT.sum(binary_sorted[b]) + (binary_sorted[b] >= 0)
BIT.add(binary_sorted[b], 1)
# 連続する部分列の個数の半分以上和が0以上となる区間が存在するかで場合分け
if tmp >= ceil(((N * (N + 1)) / 2) / 2):
lo = m
else:
hi = m
print(lo)
| from itertools import accumulate
from math import ceil
N = int(eval(input()))
A = list(map(int, input().split()))
class BinaryIndexedTree:
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += (i & -i)
def reset(self):
self.bit = [0] * (self.size + 1)
# BIT準備
BIT = BinaryIndexedTree(N)
# 答えをにぶたん
lo, hi = -1, max(A) + 1 # sample2などに対応するためにhiを設定
while hi - lo > 1:
m = (hi + lo) // 2
# m以上かどうかで分類
binary = [(1 if a >= m else -1) for a in A]
binary = list(accumulate(binary))
# BITの初期化
BIT.reset()
# 和が0以上となる連続部分列を数える
tmp = 0
# 転倒数っぽくやる
binary_sorted = {b: i for i, b in enumerate(sorted(binary), start=1)}
ans = 0
for j, b in enumerate(binary):
tmp += BIT.sum(binary_sorted[b]) + (b >= 0)
BIT.add(binary_sorted[b], 1)
# 連続する部分列の個数の半分以上和が0以上となる区間が存在するかで場合分け
if tmp >= ceil(((N * (N + 1)) / 2) / 2):
lo = m
else:
hi = m
print(lo)
| p03275 |
import sys
from itertools import accumulate
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
class BIT:
def __init__(self,init_value):
self.n = len(init_value)
self.tree = [0]*(self.n+1)
for i in range(1,self.n+1):
x = init_value[i-1]
while i <= self.n:
self.tree[i] += x
i += i & (-i)
def update(self,i,x): # i(1-index)番目の値を+x
while i <= self.n:
self.tree[i] += x
i += i & (-i)
return
def query(self,i): # 1番目からi(1-index)番目までの和を返す
res = 0
while i > 0:
res += self.tree[i]
i -= i & (-i)
return res
N = I()
A = LI()
def f(x): # A[l:r+1] の中央値が x 以上になる (l,r) の個数が、全体の半分以上あるか
B = [0] + [1 if A[i] >= x else -1 for i in range(N)]
B = list(accumulate(B))
B = [b+N for b in B]
# Bi <= Bj たる (i,j) の個数を数える
bit = BIT([0]*(2*N+2))
count = 0
for i in range(N+1):
b = B[i]
count += bit.query(b+1)
bit.update(b+1,1)
return True if count >= (N*(N+1)+3)//4 else False
ok = 1
ng = 10**9+1
while ok+1 < ng:
mid = (ok+ng)//2
if f(mid):
ok = mid
else:
ng = mid
print(ok)
| import sys
from itertools import accumulate
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
class BIT:
def __init__(self,init_value):
self.n = len(init_value)
self.tree = [0]*(self.n+1)
for i in range(1,self.n+1):
x = init_value[i-1]
while i <= self.n:
self.tree[i] += x
i += i & (-i)
def update(self,i,x): # i(1-index)番目の値を+x
while i <= self.n:
self.tree[i] += x
i += i & (-i)
return
def query(self,i): # 1番目からi(1-index)番目までの和を返す
res = 0
while i > 0:
res += self.tree[i]
i -= i & (-i)
return res
N = I()
A = LI()
def f(x): # A[l:r+1] の中央値が x 以上になる (l,r) の個数が、全体の半分以上あるか
B = [0] + [1 if A[i] >= x else -1 for i in range(N)]
B = list(accumulate(B))
B = [b+N+1 for b in B] # 全て正になるように補正
# Bi <= Bj たる (i,j) の個数を数える
bit = BIT([0]*(2*N+2))
count = 0
for i in range(N+1):
b = B[i]
count += bit.query(b)
bit.update(b,1)
if count >= (N*(N+1)+3)//4:
return True
return False
ok = 1
ng = 10**9+1
while ok+1 < ng:
mid = (ok+ng)//2
if f(mid):
ok = mid
else:
ng = mid
print(ok)
| p03275 |
import sys
from itertools import accumulate
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
class BIT:
def __init__(self,init_value):
self.n = len(init_value)
self.tree = [0]*(self.n+1)
for i in range(1,self.n+1):
x = init_value[i-1]
while i <= self.n:
self.tree[i] += x
i += i & (-i)
def update(self,i,x): # i(1-index)番目の値を+x
while i <= self.n:
self.tree[i] += x
i += i & (-i)
return
def query(self,i): # 1番目からi(1-index)番目までの和を返す
res = 0
while i > 0:
res += self.tree[i]
i -= i & (-i)
return res
N = I()
A = LI()
def f(x): # A[l:r+1] の中央値が x 以上になる (l,r) の個数が、全体の半分以上あるか
B = [0] + [1 if A[i] >= x else -1 for i in range(N)]
B = list(accumulate(B))
B = [b+N+1 for b in B] # 全て正になるように補正
# Bi <= Bj たる (i,j) の個数を数える
bit = BIT([0]*(2*N+2))
count = 0
for i in range(N+1):
b = B[i]
count += bit.query(b)
bit.update(b,1)
if count >= (N*(N+1)+3)//4:
return True
return False
ok = 1
ng = 10**9+1
while ok+1 < ng:
mid = (ok+ng)//2
if f(mid):
ok = mid
else:
ng = mid
print(ok)
| # 座標圧縮した場合
import sys
from itertools import accumulate
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
class BIT:
def __init__(self,init_value):
self.n = len(init_value)
self.tree = [0]*(self.n+1)
for i in range(1,self.n+1):
x = init_value[i-1]
while i <= self.n:
self.tree[i] += x
i += i & (-i)
def update(self,i,x): # i(1-index)番目の値を+x
while i <= self.n:
self.tree[i] += x
i += i & (-i)
return
def query(self,i): # 1番目からi(1-index)番目までの和を返す
res = 0
while i > 0:
res += self.tree[i]
i -= i & (-i)
return res
N = I()
A = LI()
C = sorted(list(set(A)))
dict_A = {} # dict_A[a] = (a は A の中で何番目に小さい値か)
dict_C = {} # dict_C[i] = (A の中で i 番目に小さい値)
for i in range(1,len(C)+1):
dict_C[i] = C[i-1]
dict_A[C[i-1]] = i
A = [dict_A[a] for a in A]
def f(x): # A[l:r+1] の中央値が x 以上になる (l,r) の個数が、全体の半分以上あるか
B = [0] + [1 if A[i] >= x else -1 for i in range(N)]
B = list(accumulate(B))
B = [b+N+1 for b in B] # 全て正になるように補正
# Bi <= Bj たる (i,j) の個数を数える
bit = BIT([0]*(2*N+2))
count = 0
for i in range(N+1):
b = B[i]
count += bit.query(b)
bit.update(b,1)
if count >= (N*(N+1)+3)//4:
return True
return False
ok = 1
ng = 10**5+1
while ok+1 < ng:
mid = (ok+ng)//2
if f(mid):
ok = mid
else:
ng = mid
print((dict_C[ok]))
| p03275 |
from itertools import accumulate
from math import ceil
N = int(eval(input()))
A = list(map(int, input().split()))
if N == 1:
print((A[0]))
exit()
class BinaryIndexedTree:
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += (i & -i)
def reset(self):
self.bit = [0] * (self.size + 1)
BIT = BinaryIndexedTree(N) # Binaryの先頭の分
lo, hi = -1, 10 ** 9 + 1
while hi - lo > 1:
# Xは中央値候補
X = (hi + lo) // 2
# X以上なら1、X未満なら-1に変換
Binary = [(1 if a >= X else -1) for a in A]
# 累積和をとる
Binary = list(accumulate(Binary))
# BITを初期化
BIT.reset()
# 転倒数っぽいものを数える
inversion = 0
Binary_sorted = {b: i for i, b in enumerate(sorted(Binary), start=1)}
for j, b in enumerate(Binary):
inversion += BIT.sum(Binary_sorted[b]) + (b >= 0)
BIT.add(Binary_sorted[b], 1)
if inversion >= ceil((N * (N + 1) / 2) / 2):
lo = X
else:
hi = X
print(lo) | import math
n = int(input())
lst = list(map(int, input().split()))
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
def judge(x, lst, n):
length = len(lst)
all_pair = (length*(length-1) // 2) + length
lst_r = [-1 if i < x else 1 for i in lst]
lst_accum = []
a = 0
for i in lst_r:
a += i
lst_accum.append(a)
bit = Bit(n)
lst_accum_sorted = {b: i for i, b in enumerate(sorted(lst_accum), start=1)}
count = 0
for j, b in enumerate(lst_accum):
count += bit.sum(lst_accum_sorted[b]) + (b >= 0)
bit.add(lst_accum_sorted[b], 1)
if count >= math.ceil(all_pair/2):
return True
else:
return False
sorted_lst = sorted(lst)
low = 0
high = len(lst) - 1
while high - low >1:
t = (low+high) // 2
i = sorted_lst[t]
if judge(i, lst, n):
low = t
else:
high = t
print(sorted_lst[high]) if judge(sorted_lst[high], lst, n) else print(sorted_lst[low])
| p03275 |
from itertools import accumulate
def add(B,a,n):#リストに値を追加する関数
x = a
while x <= n:
B[x] += 1
x += x&(-x)
def sums(B,a):#a番目までの和
x = a
S = 0
while x != 0:
S += B[x]
x -= x&(-x)
return S
def invnumber(n, S):# #{(i,j)| i<j and S[i]<=S[j]}
B = [0]*(n*2 + 1)
invs = 0
for i in range(n):
s = S[i] + n
invs += sums(B, s)
add(B, s, n*2)
return invs
N = int( eval(input()))
A = list( map( int, input().split()))
R = max(A)+1
L = 0
c = (N*(N-1)//2 + 1)//2
while R - L > 1:
M = (R+L)//2
S = [0]*N
if A[0] >= M:
S[0] = 1
else:
S[0] = -1
for i in range(1,N):
if A[i] >= M:
S[i] = S[i-1] + 1
else:
S[i] = S[i-1] - 1
if invnumber(N,S) >= c:
L = M
else:
R = M
print(L)
| def add(B,a,n):#リストに値を追加する関数
x = a
while x <= n:
B[x] += 1
x += x&(-x)
def sums(B,a):#a番目までの和
x = a
S = 0
while x != 0:
S += B[x]
x -= x&(-x)
return S
def invnumber(n, S):# #{(i,j)| i<j and S[i]<=S[j]}
B = [0]*(n*2 + 1)
invs = 0
for i in range(n):
s = S[i] + n
invs += sums(B, s)
add(B, s, n*2)
return invs
N = int( eval(input()))
A = list( map( int, input().split()))
R = max(A)+1
L = 0
c = (N*(N+1)//2 + 1)//2
while R - L > 1:
M = (R+L)//2
S = [0]*(N+1)
for i in range(1,N+1):
if A[i-1] >= M:
S[i] = S[i-1] + 1
else:
S[i] = S[i-1] - 1
if invnumber(N+1,S) >= c:
L = M
else:
R = M
print(L)
| p03275 |
from bisect import bisect_left
from math import ceil
# >= 3.3
# from collections.abc import Sequence
# < 3.3
from collections import Sequence
class LazySequence(Sequence):
def __init__(self, f, n):
self.f = f
self.n = n
def __len__(self):
return self.n
def __getitem__(self, i):
if not (0 <= i < self.n):
raise IndexError
return self.f(i)
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def __len__(self):
return self.size
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, v):
while i <= self.size:
self.tree[i] += v
i += i & -i
N = int(eval(input()))
a = [0] + [int(s) for s in input().split()]
def count_lr(x):
s = [0] * (N + 1)
for i in range(1, N + 1):
s[i] = s[i - 1] + (1 if a[i] >= x else -1)
ss = sorted(s)
def f(v):
i = bisect_left(ss, v)
return i + 1
b = Bit(N + 10)
count = 0
for i in range(N + 1):
fi = f(s[i])
count += b.sum(fi)
b.add(fi, 1)
return count
# i: 0, 1, ..., 10 ** 9 + 10
# x: 10 ** 9 + 10, ..., 0
counts = LazySequence(lambda i: count_lr(10 ** 9 + 10 - i), 10 ** 9 + 10)
ans = 10 ** 9 + 10 - bisect_left(counts, ceil(N * (N + 1) / 4))
print(ans)
|
from bisect import bisect_left
from math import ceil
import sys
if sys.version_info[0:2] >= (3, 3):
from collections.abc import Sequence
else:
from collections import Sequence
class LazySequence(Sequence):
def __init__(self, f, n):
self.f = f
self.n = n
def __len__(self):
return self.n
def __getitem__(self, i):
if not (0 <= i < self.n):
raise IndexError
return self.f(i)
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def __len__(self):
return self.size
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, v):
while i <= self.size:
self.tree[i] += v
i += i & -i
N = int(eval(input()))
a = [0] + [int(s) for s in input().split()]
# a = [0] * (N + 1)
def count_lr(x):
s = [0] * (N + 1)
for i in range(1, N + 1):
s[i] = s[i - 1] + (1 if a[i] >= x else -1)
ss = sorted(set(s))
ind = {v: i + 1 for i, v in enumerate(ss)}
b = Bit(N + 10)
count = 0
for i in range(N + 1):
j = ind[s[i]]
count += b.sum(j)
b.add(j, 1)
return count
# i: 0, 1, ..., 10 ** 9
# x: 10 ** 9, ..., 0
counts = LazySequence(lambda i: count_lr(10 ** 9 - i), 10 ** 9 + 1)
ans = 10 ** 9 - bisect_left(counts, ceil(N * (N + 1) / 4))
print(ans)
| p03275 |
class BIT:
"""1-indexed BIT
"""
def __init__(self, size: int):
"""サイズを指定して BIT を初期化します。
"""
self.__size = size
self.__bit = [0] * (self.__size+1)
def add(self, idx: int, val: int):
"""位置 idx (1-indexed) に値 val をたす。
:param idx: 値を追加したいインデックス
:param val: 追加したい値
"""
while idx <= self.__size:
self.__bit[idx] += val
idx += idx & (-idx)
def sum(self, idx: int)->int:
s = 0
while idx > 0:
s += self.__bit[idx]
idx -= idx & (-idx)
return s
def median_of_medians(N: int, A: list) -> int:
def check(x: int)->int:
bit = BIT(2 * N + 1)
s = 0
a = 0
for i in range(N):
s += bit.sum(a + N)
bit.add(a + N, 1)
a = a + (1 if x <= A[i] else - 1)
s += bit.sum(a + N)
return s
alpha = sorted(A)
l, r = 0, N
while r - l > 1:
m = (r + l + 1) // 2
if 2*check(alpha[m]) >= (N * (N + 1)) // 2:
l = m
else:
r = m
return alpha[l]
if __name__ == "__main__":
N = int(eval(input()))
A = [int(s) for s in input().split()]
ans = median_of_medians(N, A)
print(ans)
|
def median_of_medians(N: int, A: list)->int:
def search(c):
bar = N
r = 0
res_nega = 0
dp_arr = [0]*(2*N+1)
for i in range(N):
dp_arr[bar] += 1
if A[i] < c:
r += dp_arr[bar]
bar += 1
else:
r -= (dp_arr[bar-1])
bar -= 1
res_nega += r
return res_nega
# binary search
a_sorted = sorted(A)
left = 0
right = N
mid = N // 2
C = N*(N+1) // 2
while True:
if search(a_sorted[mid]) <= C // 2:
if mid == N-1:
break
elif search(a_sorted[mid+1]) > C // 2:
break
else:
left = mid
mid = (mid + right) // 2
else:
right = mid + 1
mid = (mid + left) // 2
return a_sorted[mid]
if __name__ == "__main__":
N = int(eval(input()))
A = [int(s) for s in input().split()]
ans = median_of_medians(N, A)
print(ans)
| p03275 |
n = int(eval(input()))
A = list(map(int, input().split()))
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
le = -1
ri = max(A) + 1
mid = (le + ri) // 2
while ri - le > 1:
S = [0] * n
S[0] = -1 + 2 * int(A[0] >= mid)
for i in range(n-1):
S[i+1] = S[i] - 1 + 2 * int(A[i] >= mid)
bit = Bit(n+2)
ans = 0
Smin = min(S)
S = [S[i]-min(S)+1 for i in range(n)]
#print(S)
for i, p in enumerate(S):
bit.add(p, 1)
ans += bit.sum(p) - 1 # 「S[i] >= S[i]」をカウントしないように1を引く
#print(le, ri, mid, ans)
if ans >= (n*(n-1))//(2*2):
le = mid
else:
ri = mid
mid = (le + ri) // 2
print(le)
| n = int(eval(input()))
A = list(map(int, input().split()))
# n = 4
# A = [i+1 for i in range(n)]
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
#print((n*(n+1))//(2*2))
le = -1
ri = max(A) + 1
mid = (le + ri) // 2
while ri - le > 1:
S = [0] * n
S[0] = -1 + 2 * int(A[0] >= mid)
for i in range(n-1):
S[i+1] = S[i] - 1 + 2 * int(A[i+1] >= mid)
bit = Bit(n+2)
ans = 0
for i in range(n):
if S[i] >= 0:
ans += 1
#print("S OK")
Smin = min(S)
S = [S[i] - Smin + 1 for i in range(n)]
#print("S OK2")
#print(S)
for i, p in enumerate(S):
bit.add(p, 1)
ans += bit.sum(p) - 1 # 「S[i] >= S[i]」をカウントしないように1を引く
#print(i,ans)
#print(le, ri, mid, ans)
if ans >= (n*(n+1))//(2*2):
le = mid
else:
ri = mid
mid = (le + ri) // 2
print(le)
| p03275 |
n = int(eval(input()))
a = list(map(int, input().split()))
x = list(sorted(set(a)))
n_sub = n * (n + 1) // 2
Li = -1
Ri = len(x) - 1
while Ri > Li + 1:
i = (Li + Ri) // 2
xi = x[i]
UorD = [1 if ak >= xi else -1 for ak in a]
cnt_sum = [0] * (2 * n + 1)
cumsum = 0
cnt_sum[cumsum + n] = 1
tmp = 0
for uk in UorD:
cumsum += uk
cnt_sum[cumsum + n] += 1
tmp += sum(cnt_sum[:cumsum + n])
if tmp >= n_sub // 2:
Li = i
break
else:
Ri = i
print((x[Ri]))
| n = int(eval(input()))
a = list(map(int, input().split()))
x = list(sorted(set(a)))
n_sub = n * (n + 1) // 2
Li = 0
Ri = len(x)
while Ri > Li + 1:
i = (Li + Ri) // 2
xi = x[i]
UorD = [1 if ak >= xi else -1 for ak in a]
cnt_sum = [0] * (2 * n + 1)
cumsum = 0
cnt_sum[cumsum + n] = 1
judge = 0
s = 0
for uk in UorD:
cumsum += uk
if uk == 1:
s += cnt_sum[cumsum + n] + 1
else:
s -= cnt_sum[cumsum + n + 1] - 1
cnt_sum[cumsum + n] += 1
judge += s
if judge >= n_sub // 2:
Li = i
break
else:
Ri = i
print((x[Li]))
| p03275 |
n = int(eval(input()))
a = list(map(int, input().split()))
x = list(sorted(set(a)))
n_sub = n * (n + 1) // 2
Li = 0
Ri = len(x)
while Ri > Li + 1:
i = (Li + Ri) // 2
xi = x[i]
UorD = [1 if ak >= xi else -1 for ak in a]
cnt_sum = [0] * (2 * n + 1)
cumsum = 0
cnt_sum[cumsum + n] = 1
judge = 0
s = 0
for uk in UorD:
cumsum += uk
if uk == 1:
s += cnt_sum[cumsum + n] + 1
else:
s -= cnt_sum[cumsum + n + 1] - 1
cnt_sum[cumsum + n] += 1
judge += s
if judge >= n_sub // 2:
Li = i
break
else:
Ri = i
print((x[Li]))
| def f(n, a):
x = list(sorted(set(a)))
n_sub_half = n * (n + 1) // 2 // 2
n_plus_minus = n * 2 + 1
Li = 0
Ri = len(x)
while Ri > Li + 1:
i = (Li + Ri) // 2
xi = x[i]
cnt_sum = [0] * n_plus_minus
cumsum = 0
cnt_sum[cumsum] = 1
judge = 0
s = 0
for ak in a:
if ak >= xi:
cumsum += 1
s += cnt_sum[cumsum] + 1
else:
cumsum -= 1
s -= cnt_sum[cumsum + 1] - 1
cnt_sum[cumsum] += 1
judge += s
if judge >= n_sub_half:
Li = i
break
else:
Ri = i
print((x[Li]))
n = int(eval(input()))
a = list(map(int, input().split()))
f(n, a)
| p03275 |
def cumsum(li):
ret = []
sum = 0
for i in li:
sum += i
ret.append(sum)
return ret
class BinaryIndexedTree:
# http://hos.ac/slides/20140319_bit.pdf
def __init__(self, size):
"""
:param int size:
"""
self._bit = [0 for _ in range(size)]
self._size = size
def add(self, i, w):
"""
i 番目に w を加える
:param int i:
:param int w:
:return:
"""
x = i + 1
while x <= self._size:
self._bit[x - 1] += w
x += x & -x
def sum(self, i):
"""
0 番目から i 番目までの合計
:param int i:
:return:
"""
ret = 0
x = i + 1
while x > 0:
ret += self._bit[x - 1]
x -= x & -x
return ret
def __len__(self):
return self._size
def count_inversions(li, max=None):
"""
リストから転倒数 (li[i] > li[j] (i < j) となる (i, j) の組み合わせ数) を返す
バブルソートするときに反転する必要がある数。
:param numpy.ndarray | list of int li:
すべての要素が 0 以上の int である配列。
BIT を使うので、マイナスを含んだり最大値が大きい場合は np.argsort の結果を指定
ただしリストに重複を含む場合は np.argsort は unstable なので別の方法使うこと
https://docs.scipy.org/doc/numpy/reference/generated/numpy.sort.html
:param int max: li の最大値。わかる場合は指定
:rtype: int
"""
if not max:
max = __builtins__.max(li)
bit = BinaryIndexedTree(size=max + 1)
ret = 0
for i in range(len(li)):
ret += i - bit.sum(li[i])
bit.add(li[i], 1)
return ret
def bisect_left_callable(fn, x, lo, hi):
"""
lo から hi-1 のうち、fn の結果が x 以上となる、最も左の値
bisect.bisect_left と同じ
https://docs.python.org/ja/3/library/bisect.html
:param callable fn:
:param x:
:param int lo: 最小値
:param int hi: 最大値 + 1
:return: lo <= ret <= hi
"""
while lo < hi:
mid = (lo + hi) // 2
if fn(mid) < x:
lo = mid + 1
else:
hi = mid
return lo
N = int(eval(input()))
series = list(map(int, input().split()))
series_sorted = sorted(series)
# L と r の選び方の組み合わせ数。1 から N までの和に等しい
lr_size = (N + 1) * N / 2
# cumsum[L] <= cumsum[r] となる (L, r) の組み合わせ数を数える
# 転倒数を数えて lr_size から引けばいい
# それが (lr_size + 1) // 2 以上である一番大きい x を探す
def solve(i):
x = series_sorted[i]
# series を x 以上かどうかで 1 と 0 に置換し累積和を取る
cumsum_li = [0] + cumsum([1 if s >= x else -1 for s in series])
# 転倒数 (cumsum にマイナスを含むので最小でも 0 になるよう N を加算）
inversions = count_inversions([N + i for i in cumsum_li], max=N + N)
if lr_size - inversions >= (lr_size + 1) // 2:
return i
else:
return float('inf')
ans_i = bisect_left_callable(solve, float('inf'), lo=0, hi=N)
print((series_sorted[max(0, min(N - 1, ans_i - 1))]))
| def bisect_right_callable(fn, x, lo, hi):
"""
lo から hi-1 のうち、fn の結果が x 以下となる、最も右の値 + 1
bisect.bisect_right と同じ
https://docs.python.org/ja/3/library/bisect.html
:param callable fn:
:param x:
:param int lo: 最小値
:param int hi: 最大値 + 1
:return: lo <= ret <= hi
"""
while lo < hi:
mid = (lo + hi) // 2
if x < fn(mid):
hi = mid
else:
lo = mid + 1
return lo
N = int(eval(input()))
series = list(map(int, input().split()))
series_sorted = sorted(series)
# L と r の選び方の組み合わせ数。1 から N までの和に等しい
lr_size = (N + 1) * N / 2
def count_lr(x):
"""
x 以上の数を半分以上含む == 中央値が x 以上である、L と r の選び方の数
:param x:
:return:
"""
ret = 0
# series[i] が x 未満なら 1、x 以上なら -1 を i番目に持つ配列の、i=0 から i までの累積和。
cumsum = 0
# counts[i]: cumsum が i に何回なったか
counts = {i: 0 for i in range(-N, N + 1)}
counts[cumsum] = 1
diff = 0
for i in range(N):
if series[i] >= x:
cumsum += 1
counts[cumsum] += 1
diff += counts[cumsum]
else:
cumsum -= 1
counts[cumsum] += 1
diff -= counts[cumsum + 1] - 1
ret += diff
return ret
# count_lr(x) の結果が半分以上であれば、中央値は x 以上。
# count_lr(x) が半分以上のうち一番大きい x を探す。
def solve(i):
if count_lr(series_sorted[i]) >= (lr_size + 1) // 2:
return 0
else:
return float('inf')
ans_i = bisect_right_callable(solve, 0, lo=0, hi=N)
print((series_sorted[max(0, min(N - 1, ans_i - 1))]))
| p03275 |
#!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
n, i = LI()
print(n-i+1)
return
#B
def B():
h, w = LI()
a = SR(h)
dy = defaultdict(int)
dx = defaultdict(int)
for y in range(h):
for x in range(w):
if a[y][x] == "#":
dx[x] = 1
dy[y] = 1
dy = list(sorted(dy.items(), key=lambda x: x[0]))
dx = list(sorted(dx.items(), key=lambda x: x[0]))
for y,_ in dy:
for x,_ in dx:
print(a[y][x], end="")
print()
return
#C
def C():
n, k = LI()
x = LI()
ans = inf
for i in range(n - k + 1):
if x[i] * x[i + k - 1] > 0:
ans = min(ans, max(abs(x[i]), abs(x[i + k - 1])))
continue
ans = min(ans, min(abs(x[i]), abs(x[i + k - 1])) * 2 + max(abs(x[i]), abs(x[i + k - 1])))
print(ans)
return
# D
# 解説AC
def D():
class BinaBinaryIndexedTree:
# http://hos.ac/slides/20140319_bit.pdf
def __init__(self, size):
"""
:param int size:
"""
self.bit = [0 for _ in range(size)]
self.size = size
def add(self, i, w):
"""
i番目にwを加える
:param int i:
:param int w:
:return:
"""
x = i + 1
while x <= self.size:
self.bit[x - 1] += w
x += x & -x
return
def sum(self, i):
"""
[0,i]の合計
:param int i:
:return:
"""
res = 0
x = i + 1
while x > 0:
res += self.bit[x - 1]
x -= x & -x
return res
def __len__(self):
return self.size
def count_inversions(array, Max=None):
"""
リストから転倒数 (array[i] > array[j] (i < j) となる (i, j) の組み合わせ数) を返す
バブルソートするときに反転する必要がある数。
:param list of int array:
すべての要素が 0 以上の int である配列。
:param int max: array の最大値。指定はわかる場合
:rtype: int
"""
if not Max:
Max = max(array) + n
bit = BinaBinaryIndexedTree(Max + 1)
res = 0
for i in range(len(array)):
res += i - bit.sum(array[i])
bit.add(array[i], 1)
return res
def f(i):
x = a_sorted[i]
c = [n] + [1 if e >= x else - 1 for e in a]
for i in range(n):
c[i + 1] += c[i]
tmp = count_inversions(c, 2 * n)
if invmax - tmp >= (invmax + 1) // 2:
return True
else:
return False
n = II()
a = LI()
a_sorted = sorted(a)
invmax = (n + 1) * n // 2
ok = 0
ng = n
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
print(a_sorted[ok])
return
#Solve
if __name__ == '__main__':
D()
| #!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
n, i = LI()
print(n-i+1)
return
#B
def B():
h, w = LI()
a = SR(h)
dy = defaultdict(int)
dx = defaultdict(int)
for y in range(h):
for x in range(w):
if a[y][x] == "#":
dx[x] = 1
dy[y] = 1
dy = list(sorted(dy.items(), key=lambda x: x[0]))
dx = list(sorted(dx.items(), key=lambda x: x[0]))
for y,_ in dy:
for x,_ in dx:
print(a[y][x], end="")
print()
return
#C
def C():
n, k = LI()
x = LI()
ans = inf
for i in range(n - k + 1):
if x[i] * x[i + k - 1] > 0:
ans = min(ans, max(abs(x[i]), abs(x[i + k - 1])))
continue
ans = min(ans, min(abs(x[i]), abs(x[i + k - 1])) * 2 + max(abs(x[i]), abs(x[i + k - 1])))
print(ans)
return
# D
# 解説AC
# 転倒数を求める BIT(BinaryIndexedTree) は主な問題ではないので説明は省く
# 転倒数を求めるのに至るまでの考察がきもい
# 工夫したリストの転倒数を求めることで
# 各値が何個の範囲 [l,r] の中央値として存在するかを求められる
#
# 1) 工夫したリスト
# 今回必要なのはある番目において
# a[i] より小さい数が何個あって a[i] より大きい数が何個あるかという情報
# 特に a[i] より(大きい数-小さい数)の情報が欲しい
# 典型として覚えるなら、 a[k] < a[i] で 1 、 a[k] >= a[i] で-1
# として累積和とるとa[k]までの(大きい数-小さい数)が求められる
#
# 2) 中央値の性質
# 長さ M の整数列 b の中央値を x として
# • b 中に x 以上の要素が ⌈M/2⌉以上含まれる
# • x は，上の性質を満たす整数の中で最大である
# が中央値の性質になり、つまり2分探索で求められることがわかる
#
# 3) 問題の言いかえ
# つまり問題は
# a の連続部分列 a[l, r] (1 ≤ l ≤ r ≤ N) のうち
# x 以上の要素を ⌈r−l+1/2⌉ 個以上含むものは何通り(x通り)で、
# (n+1)*n//2 - x 通りが (n+1)*n//2 の半分より多い（要は全連続部分列において
# x以上の数がその連続列の半数以上である物の数が全連続部分文字列の半分より多い）
# ならそれは全中央値の中央値としてなりえて、この性質を満たす最大値が答えになる
# と言い換えることができる
# 各連続部分文字列の中央値をmとしてそれにおいて x 以上の要素がその連続列の半数以上である場合
# x は中央値以下であり中央値のリストを作った際 x はその部分列の中央値としてリストに入れられた
# もの以下になるため 中央値のリストの中央値を求める際の x が中央値のリストの中央値になるかの判定
# においてその部分の中央値の値は x よりも大きいため x 以上の要素数に 1 加えることができる
# この x 以上の要素がその連続列の半数以上である場合という部分において、工夫したリストは
# S[i] = i_∑_j=1 {ai}となっているため a[l, r] の要素の総和は S_r − S_{l−1}となっていて
# (l, r) (0 ≤ l < r ≤ N) のうち，Sl ≤ Sr を満たすものを数えると x 以上の要素が含まれる数
# がその列の半数を超えるものの数を数えていることと同じになり、つまりこれは転倒数を求めることで求められる
#
# 注意)
# なお転倒数は負の数があると難しいのでx以下の数はどう数えてもn以上にならないためnを足すことで-1*n
# を帳消ししている
def D():
class BinaryIndexedTree:
# http://hos.ac/slides/20140319_bit.pdf
def __init__(self, size):
"""
:param int size:
"""
self.bit = [0 for _ in range(size)]
self.size = size
def add(self, i, w):
"""
i番目にwを加える
:param int i:
:param int w:
:return:
"""
x = i + 1
while x <= self.size:
self.bit[x - 1] += w
x += x & -x
return
def sum(self, i):
"""
[0,i]の合計
:param int i:
:return:
"""
res = 0
x = i + 1
while x > 0:
res += self.bit[x - 1]
x -= x & -x
return res
def __len__(self):
return self.size
def count_inversions(array, Max=None):
"""
リストから転倒数 (array[i] > array[j] (i < j) となる (i, j) の組み合わせ数) を返す
バブルソートするときに反転する必要がある数。
:param list of int array:
すべての要素が 0 以上の int である配列。
:param int max: array の最大値。指定はわかる場合
:rtype: int
"""
if not Max:
Max = max(array) + n
bit = BinaryIndexedTree(Max + 1)
res = 0
for i in range(len(array)):
res += i - bit.sum(array[i])
bit.add(array[i], 1)
return res
def f(i):
x = a_sorted[i]
c = [n] + [1 if e >= x else - 1 for e in a]
for i in range(n):
c[i + 1] += c[i]
tmp = count_inversions(c, 2 * n)
if invmax - tmp >= (invmax + 1) // 2:
return True
else:
return False
n = II()
a = LI()
a_sorted = sorted(a)
invmax = (n + 1) * n // 2
ok = 0
ng = n
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
print(a_sorted[ok])
return
#Solve
if __name__ == '__main__':
D()
| p03275 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left, bisect_right
import random
from itertools import permutations, accumulate, combinations
import sys
import string
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
A = LI()
class BIT:
def __init__(self, size):
self.bit = [0] * size
self.size = size
def add(self, i, w):
x = i + 1
while x <= self.size:
self.bit[x - 1] += w
x += x & -x
return
def sum(self, i):
res = 0
x = i + 1
while x > 0:
res += self.bit[x - 1]
x -= x & -x
return res
def D(L):
n = len(L)
bit = BIT(2 * n + 1)
ans = 0
for i in range(n - 1, -1, -1):
bit.add(L[i] + n, 1)
ans += bit.sum(L[i] + n - 1)
return ans
ALL = (n + 1) * n // 2
A2 = sorted(A)
# 求めるのは、1より-1の方が多かった区間の数
ng, ok = n, 0
while ng > ok + 1:
mid = (ok + ng) // 2
L = [0] + list(accumulate([1 if i >= A2[mid] else -1 for i in A]))
if D(L) >= ALL // 2 + 1:
ng = mid
else:
ok = mid
print((A2[ok]))
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 18
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
class BIT:
def __init__(self, size):
self.bit = [0] * size
self.size = size
def add(self, i, w):
x = i + 1
while x <= self.size:
self.bit[x - 1] += w
x += x & -x
return
def sum(self, i):
res = 0
x = i + 1
while x:
res += self.bit[x - 1]
x -= x & -x
return res
n = I()
A = LI()
def D(L):
n = len(L)
bit = BIT(2 * n + 1)
ans = 0
for i in range(n - 1, -1, -1):
bit.add(L[i] + n, 1)
ans += bit.sum(L[i] + n - 1)
return ans
ALL = (n + 1) * n // 2
A2 = sorted(A)
# 求めるのは、1より-1の方が多かった区間の数
ng, ok = n, 0
while ng > ok + 1:
mid = (ok + ng) // 2
L = [0] + list(accumulate([1 if i >= A2[mid] else -1 for i in A]))
if D(L) >= ALL // 2 + 1:
ng = mid
else:
ok = mid
print((A2[ok])) | p03275 |
class BIT:
'''
0-indexed
'''
def __init__(self, N):
self.size = N
self.tree = [0] * (N + 1)
self.depth = n.bit_length()
def _bitsum(self, i):
ret = 0
while i:
ret += self.tree[i]
i ^= i & -i
return ret
def bitsum(self, l, r=None): # [l, r)
if r is None:
return self._bitsum(l)
else:
return self._bitsum(r) - self._bitsum(l)
def bitadd(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
return
n = int(eval(input()))
m = (n * (n - 1) // 2) // 2 + 1
a = list(map(int, input().split()))
d = dict()
_a = sorted(set(a))
for i, x in enumerate(_a):
d[x] = i
a = [d[x] for x in a]
def check(X):
b = [0] + [(y>=X)*2 - 1 for y in a]
for i in range(n):
b[i+1] += b[i]
c = min(b)
b = [x-c for x in b]
bit = BIT(n + 10)
ans = 0
for x in b:
ans += bit.bitsum(x+1)
bit.bitadd(x, 1)
return ans >= m
t = [len(_a) + 1, -1]
while t[0] - t[1] > 1:
mid = (t[0] + t[1]) // 2
t[check(mid)] = mid
print((_a[t[1]]))
| class BIT:
'''
0-indexed
'''
def __init__(self, N):
self.size = N
self.tree = [0] * (N + 1)
self.depth = n.bit_length()
def _bitsum(self, i):
ret = 0
while i:
ret += self.tree[i]
i ^= i & -i
return ret
def bitsum(self, l, r=None): # [l, r)
if r is None:
return self._bitsum(l)
else:
return self._bitsum(r) - self._bitsum(l)
def bitadd(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
return
n = int(eval(input()))
m = n * (n + 1) // 4
a = list(map(int, input().split()))
d = dict()
_a = sorted(set(a + [0]))
for i, x in enumerate(_a):
d[x] = i
a = [d[x] for x in a]
def check(X):
b = [0] + [(y>=X)*2 - 1 for y in a]
for i in range(n):
b[i+1] += b[i]
c = min(b)
b = [x-c for x in b]
bit = BIT(max(b) + 2)
ans = 0
for x in b:
ans += bit.bitsum(x + 1)
bit.bitadd(x, 1)
return ans >= m
t = [len(_a), 0]
while t[0] - t[1] > 1:
mid = (t[0] + t[1]) // 2
t[check(mid)] = mid
print((_a[t[1]]))
| p03275 |
N = int(eval(input()))
A = [int(_) for _ in input().split()]
class BIT:
# index 1~
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
M = N * (N + 1) // 2 # (N+1)C2
sorted_A = sorted(A)
inf = 0
sup = max(A) + 1
while sup - inf > 1:
x = (sup + inf) // 2
S = [0] * (N + 1)
for i in range(N):
if A[i] >= x:
S[i + 1] = S[i] + 1
else:
S[i + 1] = S[i] - 1
min_value = min(S)
for i in range(N + 1):
S[i] += abs(min_value) + 1
forward = 0
bit = BIT(max(S))
for s in S:
forward += bit.sum(s)
bit.add(s, 1)
if forward >= (M + 1) // 2:
inf = x
else:
sup = x
for a in reversed(sorted_A):
if inf >= a:
print(a)
break
| N = int(eval(input()))
A = [int(_) for _ in input().split()]
class BIT:
# index 1~
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def sub_problem(x):
S = [0] * (N + 1)
for i in range(N):
S[i + 1] = S[i] + 1 if A[i] >= x else S[i] - 1
geta = abs(min(S)) + 1
for i in range(N + 1):
S[i] += geta
forward = 0
bit = BIT(max(S))
for s in S:
forward += bit.sum(s)
bit.add(s, 1)
return forward >= (M + 1) // 2
M = N * (N + 1) // 2 # (N+1)C2
sorted_A = sorted(A)
inf = 0
sup = N
while sup - inf > 1:
mid = (sup + inf) // 2
x = sorted_A[mid]
if sub_problem(x):
inf = mid
else:
sup = mid
print((sorted_A[inf]))
| p03275 |
N = int(eval(input()))
A = [int(_) for _ in input().split()]
class BIT:
# index 1~
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def sub_problem(x):
S = [0] * (N + 1)
for i in range(N):
S[i + 1] = S[i] + 1 if A[i] >= x else S[i] - 1
geta = abs(min(S)) + 1
for i in range(N + 1):
S[i] += geta
forward = 0
bit = BIT(max(S))
for s in S:
forward += bit.sum(s)
bit.add(s, 1)
return forward >= M // 2 # TEST これだと通らないはず
M = N * (N + 1) // 2 # (N+1)C2
sorted_A = sorted(A)
inf = 0
sup = N
while sup - inf > 1:
mid = (sup + inf) // 2
x = sorted_A[mid]
if sub_problem(x):
inf = mid
else:
sup = mid
print((sorted_A[inf]))
| N = int(eval(input()))
A = [int(_) for _ in input().split()]
def sub_problem(x):
S = [0] * (N + 1)
for i in range(N):
S[i + 1] = S[i] + 1 if A[i] >= x else S[i] - 1
geta = abs(min(S)) + 1
for i in range(N + 1):
S[i] += geta
forward = 0
size = max(S)
bit = [0] * (size + 1)
for s in S:
i = s
while i > 0:
forward += bit[i]
i -= i & -i
i = s
while i <= size:
bit[i] += 1
i += i & -i
return forward >= (M + 1) // 2
M = N * (N + 1) // 2 # (N+1)C2
sorted_A = sorted(A)
inf = 0
sup = N
while sup - inf > 1:
mid = (sup + inf) // 2
x = sorted_A[mid]
if sub_problem(x):
inf = mid
else:
sup = mid
print((sorted_A[inf]))
| p03275 |
import itertools
n=int(eval(input()))
lst=list(map(int,input().split()))
ans=[]
for c in list(itertools.combinations(list(range(len(lst)+1)),2)):
ans.append(lst[c[0]:c[1]][(c[1]-c[0])//2])
print((sorted(ans)[len(ans)//2]))
| n=int(eval(input()))
lst=list(map(int,input().split()))
ans=[]
for i in range(1,n+1):
for e in range(0,n+1-i):
ans.append(sorted(lst[e:e+i])[i//2])
print((sorted(ans)[len(ans)//2])) | p03275 |
N=int(eval(input()))
A=list(map(int,input().split()))
A_sort=sorted(A)
ANSMIN=0
ANSMAX=N-1
cums=[None]*(N+1)
def midup(x):
cums[0]=0
for i in range(N):
if A[i]>=x:
cums[i+1]=cums[i]+1
else:
cums[i+1]=cums[i]-1
MINS=min(cums)
MAXS=max(cums)
#print(MINS,MAXS,cums)
bitlist=[0 for i in range(MAXS-MINS+2)]#出現個数をbit indexed treeの形でもっておく.
NUM=0#iまでで,s_k<=s_iとなるものの個数
for i in range(N+1):
bitobje=cums[i]-MINS+1
#print(i,bitobje)
x=bitobje
while x!=0:
NUM+=bitlist[x]
x-=(x&(-x))
while bitobje<=MAXS-MINS+1:
bitlist[bitobje]+=1
#print(i,bitobje,bitlist)
bitobje+=(bitobje &(-bitobje))
#print(i,bitlist,NUM)
#print(NUM,cums,bitlist)
if NUM>=(N+1)*N//2/2:
return 1
else:
return 0
while True:
candi=A_sort[(ANSMIN+ANSMAX)//2]
if midup(candi)==1:#中央値がx以上なら1を返す！
ANSMIN=(ANSMIN+ANSMAX)//2
else:
ANSMAX=(ANSMIN+ANSMAX)//2
if A_sort[ANSMIN]==A_sort[ANSMAX]:
print((A_sort[ANSMIN]))
break
if ANSMIN+1==ANSMAX:
if midup(A_sort[ANSMAX])==1:
print((A_sort[ANSMAX]))
break
else:
print((A_sort[ANSMIN]))
break
| N=int(eval(input()))
A=list(map(int,input().split()))
A_sort=sorted(A)
ANSMIN=0
ANSMAX=N-1
cums=[None]*(N+1)
def midup(x):
cums[0]=0
for i in range(N):
if A[i]>=x:
cums[i+1]=cums[i]+1
else:
cums[i+1]=cums[i]-1
MINS=min(cums)
MAXS=max(cums)
#print(MINS,MAXS,cums)
bitlist=[0 for i in range(MAXS-MINS+2)]#出現個数をbit indexed treeの形でもっておく.
NUM=0#iまでで,s_k<=s_iとなるものの個数
for i in range(N+1):
bitobje=cums[i]-MINS+1
#print(i,bitobje)
x=bitobje
while x!=0:
NUM+=bitlist[x]
x-=(x&(-x))
while bitobje<=MAXS-MINS+1:
bitlist[bitobje]+=1
bitobje+=(bitobje &(-bitobje))
if NUM>=(N+1)*N//2/2:
return 1
else:
return 0
while True:
candi=A_sort[(ANSMIN+ANSMAX)//2]
if midup(candi)==1:#中央値がx以上なら1を返す！
ANSMIN=(ANSMIN+ANSMAX)//2
else:
ANSMAX=(ANSMIN+ANSMAX)//2
if A_sort[ANSMIN]==A_sort[ANSMAX]:
print((A_sort[ANSMIN]))
break
if ANSMIN+1==ANSMAX:
if midup(A_sort[ANSMAX])==1:
print((A_sort[ANSMAX]))
break
else:
print((A_sort[ANSMIN]))
break | p03275 |
def main():
def add(i,x):
while i<=size:
tree[i]+=x
i+=i&-i
n,*a=list(map(int,open(0).read().split()))
size=n-~n
m=n*-~n//2+1>>1
ng=max(a)+1
ok=0
while ng-ok>1:
mid=(ok+ng)//2
tree=[0]*-~size
c=n+1
s=0
add(c,1)
for t in a:
c+=1if t>=mid else-1
i=c
while i:
s+=tree[i]
i-=i&-i
add(c,1)
if s>=m:ok=mid
else:ng=mid
print(ok)
main() | def main():
def add(i,x):
while i<=size:
tree[i]+=x
i+=i&-i
n,*a=list(map(int,open(0).read().split()))
size=n-~n
m=n*-~n//2+1>>1
ng=max(a)+1
ok=0
while ng-ok>1:
mid=ok+ng>>1
tree=[0]*-~size
c=n+1
s=0
add(c,1)
for t in a:
c+=1if t>=mid else-1
i=c
while i:
s+=tree[i]
i-=i&-i
add(c,1)
if s>=m:ok=mid
else:ng=mid
print(ok)
main() | p03275 |
from itertools import accumulate
N = int(eval(input()))
A = list(map(int, input().split()))
NN = ((N + 1) * N // 2 + 1) // 2
def ok(x):
S = list(accumulate(1 if a >= x else -1 for a in A))
ms = min(min(S), 0)
S = [1] + [s - ms + 1 for s in S]
L = max(S) + 1
B = [0] * L
c = 0
for s in S:
i = s
while i > 0:
c += B[i]
i -= i & -i
i = s
while i < L:
B[i] += 1
i += i & -i
return c >= NN
B = sorted(set(A))
l = 0
r = len(B)
while r - l > 1:
m = (l + r) // 2
if ok(B[m]):
l = m
else:
r = m
print((B[l])) | N = int(eval(input()))
A = list(map(int, input().split()))
NN = ((N + 1) * N // 2 + 1) // 2
def ok(x):
B = [0] * (2 * N + 1)
res, cum, cur = 0, 0, 0
B[0] += 1
for a in A:
if a >= x:
cum += 1
cur += B[cum]+1
else:
cur -= B[cum]-1
cum -= 1
B[cum] += 1
res += cur
return res >= NN
B = sorted(set(A))
l = 0
r = len(B)
while r - l > 1:
m = (l + r) // 2
if ok(B[m]):
l = m
else:
r = m
print((B[l])) | p03275 |
import math
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
def reset(self):
for i in range(len(self.tree)):
self.tree[i] = 0
get_ints = lambda: [int(st) for st in input().split()]
N=int(eval(input()))
inarr=get_ints()
sorted_in = sorted(inarr)
comb = N*(N+1) // 2
bit = Bit(2*N+1)
def binsearch(lft, rgt):
half = (lft + rgt) // 2
if lft >= half:
return half
summed = 0
res = 0
bit.reset()
bit.add(N, 1)
for x in inarr:
value = 1 if x >= sorted_in[half] else -1
summed += value
count = bit.sum(N + summed)
bit.add(N + summed, 1)
res += count
return binsearch(half, rgt) if res >= math.ceil(comb/2) else binsearch(lft, half)
res = binsearch(0, N)
print((sorted_in[res]))
| import math
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
def reset(self):
t = self.tree
for i in range(len(t)):
t[i] = 0
get_ints = lambda: [int(st) for st in input().split()]
N=int(eval(input()))
inarr=get_ints()
sorted_in = sorted(inarr)
comb = N*(N+1) // 2
bit = Bit(2*N+1)
def binsearch(lft, rgt):
half = (lft + rgt) // 2
if lft >= half:
return half
summed = 0
res = 0
bit.reset()
bit.add(N, 1)
for x in inarr:
value = 1 if x >= sorted_in[half] else -1
summed += value
count = bit.sum(N + summed)
bit.add(N + summed, 1)
res += count
return binsearch(half, rgt) if res >= math.ceil(comb/2) else binsearch(lft, half)
res = binsearch(0, N)
print((sorted_in[res]))
| p03275 |
import math
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
def reset(self):
t = self.tree
for i in range(len(t)):
t[i] = 0
get_ints = lambda: [int(st) for st in input().split()]
N=int(eval(input()))
inarr=get_ints()
sorted_in = sorted(inarr)
comb = N*(N+1) // 2
bit = Bit(2*N+1)
def binsearch(lft, rgt):
half = (lft + rgt) // 2
if lft >= half:
return half
summed = 0
res = 0
bit.reset()
bit.add(N, 1)
for x in inarr:
value = 1 if x >= sorted_in[half] else -1
summed += value
count = bit.sum(N + summed)
bit.add(N + summed, 1)
res += count
return binsearch(half, rgt) if res >= math.ceil(comb/2) else binsearch(lft, half)
res = binsearch(0, N)
print((sorted_in[res]))
| 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
def reset(self):
t = self.tree
for i in range(len(t)):
t[i] = 0
get_ints = lambda: [int(st) for st in input().split()]
N=int(eval(input()))
inarr=get_ints()
sorted_in = sorted(inarr)
comb = N*(N+1) // 2
bit = Bit(2*N+1)
def binsearch(lft, rgt):
half = (lft + rgt) // 2
if lft >= half:
return half
summed = 0
res = 0
bit.reset()
bit.add(N, 1)
for x in inarr:
value = 1 if x >= sorted_in[half] else -1
summed += value
count = bit.sum(N + summed)
bit.add(N + summed, 1)
res += count
return binsearch(half, rgt) if res >= comb // 2 else binsearch(lft, half)
res = binsearch(0, N)
print((sorted_in[res]))
| p03275 |
#!/usr/bin/env python3
import sys
import itertools
import collections
from itertools import accumulate
import math
INF = float("inf")
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
def inversion(a):
"転倒してない数を求める"
d = {av: i+1 for i, av in enumerate(sorted(a))}
b = Bit(len(a))
ans = 0
for i, av in enumerate(a):
b.add(d[av], 1)
ans += b.sum(d[av])
return ans
def solve(N: int, a: "List[int]"):
left = 0
right = max(a)+1
while right - left > 1:
mid = (right + left)//2
# acc = [0]*N
# for i in range(N):
# if a[i] >= mid:
# acc[i] = acc[i-1]+1
# else:
# acc[i] = acc[i-1]-1
acc = (1 if aa >= mid else -1 for aa in a)
acc = tuple(accumulate(acc))
invs = inversion(acc)
if invs < (N*(N+1)//4 + 1):
right = mid
else:
left = mid
print(left)
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
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, a)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
from itertools import accumulate
INF = float("inf")
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
def inversion(a):
"転倒していない組(l, r)の個数を求める"
d = {av: i+1 for i, av in enumerate(sorted(a))}
b = Bit(len(a))
ans = 0
for i, av in enumerate(a):
ans += b.sum(d[av])
b.add(d[av], 1)
return ans
def solve(N: int, a: "List[int]"):
def isOK(y):
acc = (1 if aa >= y else -1 for aa in a)
acc = tuple([0]) + tuple(accumulate(acc))
invs = inversion(acc)
if acc[0] == -1:
invs -= 1
return invs < (N*(N+1))//4
def binary_search(x):
ng = -1
ok = len(x)+1
while abs(ok - ng) > 1:
mid = (ok + ng)//2
if isOK(mid):
ok = mid
else:
ng = mid
return ng, ok
ng, ok = binary_search(list(range(max(a))))
print(ng)
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
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, a)
if __name__ == '__main__':
main()
| p03275 |
n = int(eval(input()))
l = []
for i in range(n):
x= list(map(int, input().split()))
l.append(x)
def find(ele, l):
cc = 0
ans = []
for i in l:
if i==ele:
ans.append(cc)
cc+=1
return ans
c = n-1
for i in l[::-1]:
if c==n-1:
m = max(i)
xxx = i.copy()
xxx.remove(m)
m2 = max(xxx)
if m==m2:
count = 0
count2 = 0
for aa in xxx:
if aa==m2 and count2==1:
ii = count
break
elif aa==m2:
count2+=1
count+=1
index = [i.index(m), ii]
else:
index = [i.index(m), i.index(m2)]
maxval = [m, m2]
c-=1
#print(index, maxval, "m")
continue
else:
m = max(i)
xxx = i.copy()
xxx.remove(m)
m2 = max(xxx)
count = 0
count2 = len(maxval)
#print(maxval)
found2 =find(m2,i)
found = find(m,i)
#print(found, found2, "Found")
for a in maxval:
#print(count, count2, i)
if count==count2:
break
if index[count] not in found2 or len(found2)!=1:
maxval.append(a+m2)
if index[count] not in found or len(found)!=1:
maxval[count]+=m
count+=1
if m==m2:
index =[found[0]]*(2*count2)
else:
index = [found[0]]*count2+[found2[0]]*count2
c-=1
#print(maxval, index, "i")
print((max(maxval))) | n = int(eval(input()))
ans = [[0]*3 for xxx in range(n)]
for i in range(n):
a,b,c = list(map(int, input().split()))
if i==0:
ans[0][0] = a
ans[0][1] = b
ans[0][2] = c
continue
ans[i][0] += max(ans[i-1][1], ans[i-1][2]) + a
ans[i][1] += max(ans[i-1][2], ans[i-1][0]) + b
ans[i][2] += max(ans[i-1][0], ans[i-1][1]) + c
ans = ans[-1]
print((max(ans))) | p03162 |
n = int(eval(input()))
table = []
for _ in range(n):
table.append([int(v) for v in input().split()])
dp = [0] * 3
for i in range(n):
dp_n = [0] * 3
a, b, c = table[i]
a0 = dp[0]
b0 = dp[1]
c0 = dp[2]
dp_n[0] = max(b0, c0) + a
dp_n[1] = max(c0, a0) + b
dp_n[2] = max(a0, b0) + c
dp = dp_n
print((max(dp)))
| def main():
N = int(eval(input()))
table = []
for _ in range(N):
a, b, c = list(map(int, input().split()))
table.append((a, b, c))
dp = [0] * 3
for i in range(N):
a, b, c = table[i]
a0 = dp[0]
b0 = dp[1]
c0 = dp[2]
dp[0] = max(b0, c0) + a
dp[1] = max(c0, a0) + b
dp[2] = max(a0, b0) + c
print((max(dp)))
main()
| p03162 |
N = int(eval(input()))
vacation = []
for i in range(N):
vacation.append(list(map(int, input().split())))
activities = 3
schedules = [[None for _ in range(activities)] for _ in range(N)]
schedules[0] = vacation[0]
for i in range(1, N):
for j in range(activities):
schedules[i][j] = max(schedules[i - 1][(j + 1) % 3], schedules[i - 1][(j + 2) % 3]) + vacation[i][j]
print((max(schedules[N - 1]))) | def main():
n = int(eval(input()))
matrix = []
tb = [[0] * 4 for _ in range(n + 1)]
for _ in range(n):
matrix.append([int(e) for e in input().split()])
for i in range(1, n + 1):
for j in range(1, 4):
for l in range(1, 4):
if j == l: continue
tb[i][j] = max(tb[i][j], tb[i - 1][l] + matrix[i - 1][j - 1])
print((max(tb[n])))
return 0
if __name__ == "__main__":
main() | p03162 |
n = int(eval(input()))
felicidade = []
for x in range(n):
felicidade.append(list(map(int,input().split())))
DP = [0,0,0]
if n == 1:
print((max(felicidade[0])))
else:
for x in range(3):
DP[x] = felicidade[0][x]
for dia in range(1,n):
m = [0] * 3
for x in range(3):#As duas possíveis escolhas são x e y
for y in range(3):
if x != y: #Se elas forem diferentes
m[x] = max(m[x], DP[y] + felicidade[dia][x])
DP = m
print((max(DP)))
| nDays = int(eval(input()))
today = [int(x) for x in input().split()]
for i in range(nDays - 1):
tomorrow = [int(x) for x in input().split()]
tomorrow[0] += max(today[1], today[2])
tomorrow[1] += max(today[0], today[2])
tomorrow[2] += max(today[0], today[1])
today = tomorrow
print((max(today))) | p03162 |
N = int(eval(input()))
abc = [tuple(map(int, input().split())) for _ in range(N)]
dp = [[0] * 3 for _ in range(N+1)] # どの行動を選んだか残しておくための３、
for i in range(N):
for j in range(3): # 昨日の行動
for k in range(3):
if j == k:
continue # 昨日と同じ行動はとれないので飛ばす
dp[i+1][k] = max(dp[i+1][k], dp[i][j] + abc[i][k])
print((max(dp[-1]))) | N = int(eval(input()))
dp = [[0 for _ in range(3)] for _ in range(N+1)]
#dp[i][j]:i日目に活動a~cを行ったときに得られる最高の累積幸福度
for i in range(1, N+1):
a,b,c = list(map(int, input().split()))
dp[i][0] = a + max(dp[i-1][1], dp[i-1][2])
dp[i][1] = b + max(dp[i-1][0], dp[i-1][2])
dp[i][2] = c + max(dp[i-1][0], dp[i-1][1])
print((max(dp[-1][0], dp[-1][1], dp[-1][2]))) | p03162 |
N = int(eval(input()))
A_B_C = []
for i in range(N):
A_B_C.append(tuple(map(int, input().split())))
DP = [[0]*3 for i in range(N)]
DP[0][0] = A_B_C[0][0]
DP[0][1] = A_B_C[0][1]
DP[0][2] = A_B_C[0][2]
for i in range(1, N):
for j in range(3):
j_a = (j + 1) % 3
j_b = (j + 2) % 3
DP[i][j] = max(DP[i-1][j_a], DP[i-1][j_b]) + A_B_C[i][j]
print((max(DP[N-1][0], DP[N-1][1], DP[N-1][2]))) | N = int(eval(input()))
F = [tuple(map(int, input().split())) for _ in range(N)]
DP = [0] * 3
for f in F:
D = [0] * 3
S = {0, 1, 2}
for i in range(3):
S.remove(i)
for s in S:
D[i] = max(D[i], f[i] + DP[s])
S.add(i)
DP = D
print((max(DP))) | p03162 |
N = int(eval(input()))
ABC = []
for _ in range(N):
a,b,c = list(map(int,input().split()))
ABC.append((a,b,c))
dpA = [ABC[0][0]]*N
dpB = [ABC[0][1]]*N
dpC = [ABC[0][2]]*N
for i in range(1, N):
dpA[i] = max(dpB[i-1] + ABC[i][0], dpC[i-1] + ABC[i][0])
dpB[i] = max(dpA[i-1] + ABC[i][1], dpC[i-1] + ABC[i][1])
dpC[i] = max(dpA[i-1] + ABC[i][2], dpB[i-1] + ABC[i][2])
print((max(dpA[N-1], dpB[N-1], dpC[N-1]))) | N = int(eval(input()))
for i in range(N):
a,b,c = list(map(int,input().split()))
if i == 0:
preA = a
preB = b
preC = c
else:
A = max(preB + a, preC + a)
B = max(preA + b, preC + b)
C = max(preA + c, preB + c)
preA = A
preB = B
preC = C
print((max(preA, preB, preC))) | p03162 |
n = int(eval(input()))
a = [0] * (n + 1)
b = [0] * (n + 1)
c = [0] * (n + 1)
for i in range(1, n + 1):
a[i], b[i], c[i] = list(map(int, input().split()))
a[i] = a[i] + max(b[i - 1], c[i - 1])
b[i] = b[i] + max(c[i - 1], a[i - 1])
c[i] = c[i] + max(a[i - 1], b[i - 1])
print((max(a[n], b[n], c[n]))) | n = int(eval(input()))
hya, hyb, hyc = 0, 0, 0
for _ in range(n):
a, b, c = list(map(int, input().split()))
ha = a + max(hyb, hyc)
hb = b + max(hyc, hya)
hc = c + max(hya, hyb)
hya =ha
hyb =hb
hyc =hc
print((max(ha, hb, hc))) | p03162 |
n=int(eval(input()))
a,b,c = list(map(int,input().split()))
d={'a':a,'b':b,'c':c}#初期化
for i in range(n-1):
a,b,c = list(map(int,input().split()))
da,db,dc=d['a'],d['b'],d['c']
d['a'] = a +max(db,dc)
d['b'] = b +max(da,dc)
d['c'] = c +max(da,db)
print((max(d.values()))) | N = int(eval(input()))
A,B,C=[],[],[]
for i in range(N):
a,b,c = list(map(int,input().split()))
A.append(a)
B.append(b)
C.append(c)
dpa,dpb,dpc = A[0],B[0],C[0]
for i in range(1,N):
a,b,c = dpa,dpb,dpc
dpa = max(c,b)+A[i]
dpb = max(c,a)+B[i]
dpc = max(a,b)+C[i]
print((max(dpa,dpb,dpc))) | p03162 |
n = int(eval(input()))
eff = [list(map(int, input().split())) for _ in range(n)]
dp = [[float('-inf')] * 3 for _ in range(n)]
from copy import deepcopy
dp[0] = deepcopy(eff[0])
for i in range(1, n):
for yi in range(3):
for ti in range(3):
if yi != ti:
dp[i][ti] = max(dp[i][ti], dp[i-1][yi] + eff[i][ti])
print((max(dp[-1]))) | from copy import deepcopy
n = int(eval(input()))
eff = [list(map(int, input().split())) for _ in range(n)]
dp = [[float('-inf')] * 3 for _ in range(n)]
dp[0] = deepcopy(eff[0])
for i in range(1, n):
for yi in range(3):
for ti in range(3):
if yi != ti:
dp[i][ti] = max(dp[i][ti], dp[i-1][yi] + eff[i][ti])
print((max(dp[-1]))) | p03162 |
from copy import deepcopy
n = int(eval(input()))
eff = [list(map(int, input().split())) for _ in range(n)]
dp = [[float('-inf')] * 3 for _ in range(n)]
dp[0] = deepcopy(eff[0])
for i in range(1, n):
for yi in range(3):
for ti in range(3):
if yi != ti:
dp[i][ti] = max(dp[i][ti], dp[i-1][yi] + eff[i][ti])
print((max(dp[-1]))) | n = int(eval(input()))
da = db = dc = 0
for i in range(n):
a, b, c = list(map(int, input().split()))
da, db, dc = max(db, dc) + a, max(da, dc) + b, max(da, db) + c
print((max(da, db, dc))) | p03162 |
# coding: utf-8
# import sys
# input = sys.stdin.readline
def dp_happiness(N):
yesterday_a, yesterday_b, yesterday_c = 0, 0, 0
for _ in range(N):
a, b, c = list(map(int, input().split()))
today_a = a + max(yesterday_b, yesterday_c)
today_b = b + max(yesterday_c, yesterday_a)
today_c = c + max(yesterday_a, yesterday_b)
yesterday_a = today_a
yesterday_b = today_b
yesterday_c = today_c
return max(today_a, today_b, today_c)
N = int(eval(input()))
print((dp_happiness(N))) | # coding: utf-8
import sys
input = sys.stdin.readline
def dp_happiness(N):
yesterday_a, yesterday_b, yesterday_c = 0, 0, 0
for _ in range(N):
a, b, c = list(map(int, input().split()))
today_a = a + max(yesterday_b, yesterday_c)
today_b = b + max(yesterday_c, yesterday_a)
today_c = c + max(yesterday_a, yesterday_b)
yesterday_a = today_a
yesterday_b = today_b
yesterday_c = today_c
return max(today_a, today_b, today_c)
N = int(eval(input()))
print((dp_happiness(N))) | p03162 |
n = int(eval(input()))
a = ([list(map(int, input().split())) for _ in range(n)])
a.insert(0,[0,0,0])
dp = [[0,0,0] for _ in range(n+1)]
for i, a in enumerate(a):
dp_1 = dp[i-1]
dp[i][0] = max(dp_1[1], dp_1[2]) + a[0]
dp[i][1] = max(dp_1[0], dp_1[2]) + a[1]
dp[i][2] = max(dp_1[0], dp_1[1]) + a[2]
print((max(dp[n])))
| def main():
n = int(eval(input()))
abc = []
for _ in range(n):
abc.append(tuple(map(int, input().split())))
dp = [[0,0,0] for _ in range(n)]
dp[0][0] = abc[0][0]
dp[0][1] = abc[0][1]
dp[0][2] = abc[0][2]
for i in range(1, n):
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + abc[i][0]
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + abc[i][1]
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + abc[i][2]
print((max(dp[n-1])))
if __name__ == '__main__':
main() | p03162 |
def main():
n = int(eval(input()))
abc = []
for _ in range(n):
abc.append(tuple(map(int, input().split())))
dp = [[0,0,0] for _ in range(n)]
dp[0][0] = abc[0][0]
dp[0][1] = abc[0][1]
dp[0][2] = abc[0][2]
for i in range(1, n):
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + abc[i][0]
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + abc[i][1]
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + abc[i][2]
print((max(dp[n-1])))
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
colA, colB, colC = list(map(int, input().split()))
for i1 in range(1, n):
a, b, c = list(map(int, input().split()))
colA, colB, colC = a + max(colB, colC), b + max(colA, colC), c + max(colA, colB)
print((max(colA, colB, colC)))
if __name__ == '__main__':
main()
| p03162 |
import sys
input=sys.stdin.readline
def main():
N = int(eval(input()))
a1,b1,c1 = 0,0,0
for _ in range(N):
a,b,c = list(map(int, input().split()))
a0,b0,c0 = a1,b1,c1
a1 = max(b0, c0) + a # b or c => a
b1 = max(a0, c0) + b # a or c => b
c1 = max(a0, b0) + c # a or b => c
print((max(a1,b1,c1)))
if __name__ == '__main__':
main()
| import sys
input=sys.stdin.readline
def main():
N = int(eval(input()))
a1,b1,c1 = 0,0,0
for _ in range(N):
a,b,c = list(map(int, input().split()))
a0,b0,c0 = a1,b1,c1
a1 = a + (b0 if b0 > c0 else c0)
b1 = b + (a0 if a0 > c0 else c0)
c1 = c + (a0 if a0 > b0 else b0)
print((max(a1,b1,c1)))
if __name__ == '__main__':
main()
| p03162 |
# EduDPC - Vacation
import sys
input = sys.stdin.readline
n = int(eval(input()))
arr = [list(map(int, input().rstrip().split())) for _ in range(n)]
dp = [[0, 0, 0] for i in range(n)]
dp[0] = arr[0]
for i in range(1, n):
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + arr[i][0]
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + arr[i][1]
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + arr[i][2]
print((max(dp[-1]))) | # dpC - Vacation
# 貰うDP
import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
A = tuple(tuple(map(int, input().rstrip().split())) for _ in range(n))
dp = [[0] * 3 for _ in range(n)]
dp[0] = A[0]
for i in range(1, n): # i-th day
for j in range(3): # yesterday
for k in range(3): # today
if j != k:
dp[i][k] = max(dp[i][k], dp[i - 1][j] + A[i][k])
print((max(dp[-1])))
if __name__ == "__main__":
main() | p03162 |
N = int(eval(input()))
dp = [[0] * 3 for _ in range(N)]
dp[0][0], dp[0][1], dp[0][2] = list(map(int, input().split()))
for i in range(1,N):
abc = list(map(int, input().split()))
for j,k,l in ((0,1,2), (1,0,2), (2, 0, 1)):
dp[i][j] = abc[j] + max(dp[i-1][k], dp[i-1][l])
print((max(dp[N-1]))) | N = int(eval(input()))
x, y, z = list(map(int, input().split()))
for _ in range(N-1):
a, b, c = list(map(int, input().split()))
x, y, z = a + max(y, z), b + max(x, z), c + max(x, y)
print((max(x,y,z))) | p03162 |
n=int(eval(input()))
a=[]
for i in range(n):
a.append([0,0,0])
a[i][0],a[i][1],a[i][2]=list(map(int,input().split()))
a.reverse()
b=[a[0][0],a[0][1],a[0][2]]
for i in range(1,n):
b1=b[:]
b[0]=max(a[i][0]+b1[1],a[i][0]+b1[2])
b[1]=max(a[i][1]+b1[0],a[i][1]+b1[2])
b[2]=max(a[i][2]+b1[1],a[i][2]+b1[0])
print((max(b)))
| n=int(eval(input()))
a=[]
for i in range(n):
a.append([0,0,0])
a[i][0],a[i][1],a[i][2]=list(map(int,input().split()))
b=[a[0][0],a[0][1],a[0][2]]
for i in range(1,n):
b1=b[:]
b[0]=max(a[i][0]+b1[1],a[i][0]+b1[2])
b[1]=max(a[i][1]+b1[0],a[i][1]+b1[2])
b[2]=max(a[i][2]+b1[1],a[i][2]+b1[0])
print((max(b)))
| p03162 |
N = int(eval(input()))
happy_list = [list(map(int, input().split())) for n in range(N)]
def chmax(a, b):
if a > b:
return a
else:
return b
dp_list = [[0, 0, 0]]
for n in range(1, N+1):
tmp = [0, 0, 0]
tmp[1] = chmax(tmp[1], dp_list[n-1][0] + happy_list[n-1][1])
tmp[2] = chmax(tmp[2], dp_list[n-1][0] + happy_list[n-1][2])
tmp[0] = chmax(tmp[0], dp_list[n-1][1] + happy_list[n-1][0])
tmp[2] = chmax(tmp[2], dp_list[n-1][1] + happy_list[n-1][2])
tmp[0] = chmax(tmp[0], dp_list[n-1][2] + happy_list[n-1][0])
tmp[1] = chmax(tmp[1], dp_list[n-1][2] + happy_list[n-1][1])
dp_list.append(tmp)
print((max(tmp))) | N = int(eval(input()))
abc_list = [list(map(int, input().split())) for _ in range(N)]
happy_list = [[0, 0, 0]] # n日目にa|b|cを選んだときの幸福のそこまでの最大値
# before_act = -1 # a: 0, b: 1, c: 2
for n in range(N):
before_happy_a, before_happy_b, before_happy_c = happy_list[-1]
a, b, c = abc_list[n]
tmp_happy_a = max(before_happy_b, before_happy_c) + a
tmp_happy_b = max(before_happy_c, before_happy_a) + b
tmp_happy_c = max(before_happy_a, before_happy_b) + c
happy_list.append([tmp_happy_a, tmp_happy_b, tmp_happy_c])
print((max(happy_list[-1]))) | p03162 |
N = int(eval(input()))
a, b, c = [0] * N, [0] * N, [0] * N
for i in range(N):
a[i], b[i], c[i] = list(map(int, input().split()))
dp = [[0] * 3 for _ in range(N)]
dp[0] = [a[0], b[0], c[0]]
for i in range(N - 1):
dp[i + 1][0] = max(dp[i][1] + a[i + 1], dp[i][2] + a[i + 1])
dp[i + 1][1] = max(dp[i][0] + b[i + 1], dp[i][2] + b[i + 1])
dp[i + 1][2] = max(dp[i][0] + c[i + 1], dp[i][1] + c[i + 1])
print((max(dp[N-1]))) | n= int(eval(input()))
a=[0]*n
b=[0]*n
c=[0]*n
for i in range(n):
a[i],b[i],c[i]=list(map(int, input().split()))
dp = [[0] * 3 for _ in range(n)]
dp[0] = [a[0], b[0], c[0]]
for i in range(1,n):
dp[i][0]=max(a[i]+dp[i-1][1],a[i]+dp[i-1][2])
dp[i][1]=max(b[i]+dp[i-1][0],b[i]+dp[i-1][2])
dp[i][2]=max(c[i]+dp[i-1][0],c[i]+dp[i-1][1])
print((max(dp[-1]))) | p03162 |
N = int(eval(input()))
l = [list(map(int, input().split())) for _ in range(N)]
dp = [[0 for i in range(3)] for j in range(N+1)]
for i in range(1, N+1):
for j in range(3):
for k in range(3):
if j != k:
dp[i][j] = max(dp[i][j], dp[i-1][k]+l[i-1][k])
print((max(dp[N][0], dp[N][1], dp[N][2])))
| N = int(eval(input()))
dp = [[0 for i in range(3)] for j in range(N+1)]
for i in range(1, N+1):
hapiness = list(map(int, input().split()))
for j in range(3):
for k in range(3):
if j != k:
dp[i][j] = max(dp[i][j], dp[i-1][k] + hapiness[k])
print((max(dp[N][0], dp[N][1], dp[N][2]))) | p03162 |
N = int(eval(input()))
dp = [[0]*3 for i in range(N+1)]
for i in range(1, N+1):
acitivities = list(map(int, input().split()))
for j in range(3):
for k in range(3):
if j == k :
continue
dp[i][j] = max(dp[i][j], dp[i-1][k]+acitivities[j])
print((max(dp[N]))) | N = int(eval(input()))
dp = [[0]*3 for i in range(N+1)]
A = [list(map(int, input().split())) for i in range(N)]
for i in range(N):
for j in range(3):
for k in range(3):
if j == k :
continue
dp[i][j] = max(dp[i][j], dp[i-1][k]+A[i][j])
print((max(dp[N-1]))) | p03162 |
n=int(eval(input()))
ma,mb,mc=0,0,0
for _ in range(n):
a,b,c=list(map(int,input().split()))
x,y,z=ma,mb,mc
ma=a+max([y,z])
mb=b+max([z,x])
mc=c+max([x,y])
print((max([ma,mb,mc]))) | def main():
n, *abc = list(map(int, open(0).read().split()))
dp = [[0, 0, 0] for _ in range(n + 1)]
for i, (a, b, c) in enumerate(zip(abc[::3], abc[1::3], abc[2::3]), 1):
x, y, z = dp[i - 1]
dp[i] = [a + max(y, z), b + max(z, x), c + max(x, y)]
ans = max(dp[-1])
print(ans)
if __name__ == '__main__':
main()
| p03162 |
n = int(eval(input()))
dp = [[0 for _ in range(3)] for _ in range(n+1)]
ls = [[1,2],[0,2],[0,1]]
for i in range(1,n+1):
day = list(map(int,input().split()))
dp[i][0] = day[0] + max(dp[i-1][1],dp[i-1][2])
dp[i][1] = day[1] + max(dp[i-1][0],dp[i-1][2])
dp[i][2] = day[2] + max(dp[i-1][0],dp[i-1][1])
print((max(dp[n])))
| N = int(eval(input()))
ls = [[0 for i in range(3)] for i in range(N)]
for i in range(N):
ls[i] = list(map(int,input().split()))
# dp[i][j] -> i-1日目にjの仕事をしたときの i 日目の幸福度の総和
dp = [ [0 for i in range(3)] for i in range(N)]
for i in range(3):
dp[0][i] = ls[0][i]
for i in range(1,N):
for j in range(3):
w = [0,1,2]
w.remove(j)
x,y = w[0],w[1]
dp[i][j] = max(dp[i-1][x],dp[i-1][y]) + ls[i][j]
print((max(dp[N-1])))
| p03162 |
N = int(eval(input()))
act = list(list(map(int, input().split())) for _ in range(N))
dp = [[0 for _ in range(3)] for _ in range(N + 1)]
for i in range(N):
dp[i + 1][0] = max(dp[i + 1][0], act[i][0] + max(dp[i][1], dp[i][2]))
dp[i + 1][1] = max(dp[i + 1][1], act[i][1] + max(dp[i][0], dp[i][2]))
dp[i + 1][2] = max(dp[i + 1][2], act[i][2] + max(dp[i][0], dp[i][1]))
print((max(dp[N]))) | import sys
input = sys.stdin.readline
N = int(eval(input()))
act = [tuple(map(int, input().split())) for _ in range(N)]
dp = [[0] * 3 for _ in range(N)]
dp[0][0] = act[0][0]
dp[0][1] = act[0][1]
dp[0][2] = act[0][2]
for i in range(N - 1):
for j in range(3):
dp[i + 1][j] = max(dp[i][(j + 1) % 3], dp[i][(j + 2) % 3]) + act[i + 1][j]
print((max(dp[-1]))) | p03162 |
n=int(eval(input()))
a=[[]]
for i in range(n):
a.append([int(i) for i in input().split()])
dp=[[0,0,0] for i in range(n+1)]
for i in range(1,n+1):
for j in range(3):
dp[i][j]=a[i][j]+max(dp[i-1][k] for k in range(3) if k!=j)
print((max(dp[n]))) | n=int(eval(input()))
lst=[]
for i in range(n):
lst.append([int(i) for i in input().split()])
dp=[[0,0,0] for i in range(n)]
dp[0]=lst[0]
for i in range(1,n):
for j in range(3):
dp[i][j]=lst[i][j]+max(dp[i-1][k] for k in range(3) if k!=j)
print((max(dp[n-1])))
| p03162 |
import sys
sys.setrecursionlimit(1000000)
N = int(eval(input()))
a = [[0]*3 for i in range(N)]
for i in range(N):
a[i] = [int(i) for i in input().split()]
def f(n, i):
if n ==0:
return a[0][i]
i1 = (i+1) % 3
i2 = (i+2) % 3
if F[n][i]:
return F[n][i]
F[n][i] = max(f(n-1, i1), f(n-1, i2)) + a[n][i]
return F[n][i]
F =[[None]*3 for _ in range(N)]
print((max(f(N-1, 0), f(N-1,1), f(N-1,2))))
| N = int(eval(input()))
a = [[0]*3 for i in range(N)]
for i in range(N):
a[i] = [int(i) for i in input().split()]
def summerVacation(n, i):
if n ==0:
dp[n][i] = a[n][i]
return
i1 = (i+1) % 3
i2 = (i+2) % 3
dp[n][i] = max( dp[n-1][i1], dp[n-1][i2] ) + a[n][i]
dp =[[None]*3 for _ in range(N)]
for n in range(N):
for i in range(3):
summerVacation(n, i)
print(( max( dp[N-1][0], dp[N-1][1], dp[N-1][2] )))
| p03162 |
n = int(eval(input()))
a = [0]
b = [0]
c = [0]
for i in range(n):
aa,bb,cc = list(map(int,input().split()))
a.append(max(b[i] + aa, c[i] + aa))
b.append(max(a[i] + bb, c[i] + bb))
c.append(max(a[i] + cc, b[i] + cc))
print((max(a[-1], b[-1], c[-1])))
| def main():
n = int(eval(input()))
a = [0]
b = [0]
c = [0]
for i in range(n):
aa,bb,cc = list(map(int,input().split()))
a.append(max(b[i] + aa, c[i] + aa))
b.append(max(a[i] + bb, c[i] + bb))
c.append(max(a[i] + cc, b[i] + cc))
print((max(a[-1], b[-1], c[-1])))
main() | p03162 |
import sys
from functools import lru_cache
sys.setrecursionlimit(10 ** 6)
N = int(eval(input()))
plans = []
for _ in range(N):
a, b, c = list(map(int, input().split()))
plans.append((a, b, c))
@lru_cache(maxsize=None)
def max_utility_at(day, i):
candidates = [
(1, 2),
(0, 2),
(0, 1)
]
if day == 0:
return plans[0][i]
else:
return max(max_utility_at(day - 1, x) + plans[day][i] for x in candidates[i])
print((max(max_utility_at(N - 1, x) for x in (0, 1, 2)))) | N = int(eval(input()))
plans = []
for _ in range(N):
a, b, c = list(map(int, input().split()))
plans.append((a, b, c))
memo = [[0] * (N + 1) for _ in range(3)]
for day, plan in enumerate(plans, 1):
memo[0][day] = max(memo[1][day - 1], memo[2][day - 1]) + plan[0]
memo[1][day] = max(memo[0][day - 1], memo[2][day - 1]) + plan[1]
memo[2][day] = max(memo[0][day - 1], memo[1][day - 1]) + plan[2]
print((max(memo[0][N], memo[1][N], memo[2][N])))
| p03162 |
#!/usr/bin/env python3
#dp3 #Vacation
n = int(eval(input()))
dpa = [0]*n
dpb = [0]*n
dpc = [0]*n
a,b,c = list(map(int,input().split()))
dpa[0] = a
dpb[0] = b
dpc[0] = c
for i in range(1,n):
a,b,c = list(map(int,input().split()))
dpa[i] = max(dpb[i-1] + a,dpc[i-1] + a)
dpb[i] = max(dpa[i-1] + b,dpc[i-1] + b)
dpc[i] = max(dpa[i-1] + c,dpb[i-1] + c)
print((max(dpa[-1],dpb[-1],dpc[-1])))
| #!/usr/bin/env python3
#dp3 #Vacation
def c():
n = int(eval(input()))
dpa = [0]*n
dpb = [0]*n
dpc = [0]*n
a,b,c = list(map(int,input().split()))
dpa[0] = a
dpb[0] = b
dpc[0] = c
for i in range(1,n):
a,b,c = list(map(int,input().split()))
dpa[i] = max(dpb[i-1] + a,dpc[i-1] + a)
dpb[i] = max(dpa[i-1] + b,dpc[i-1] + b)
dpc[i] = max(dpa[i-1] + c,dpb[i-1] + c)
print((max(dpa[-1],dpb[-1],dpc[-1])))
if __name__ == '__main__':
c()
| p03162 |
n = int(eval(input()))
a_ls = [0] * n
b_ls = [0] * n
c_ls = [0] * n
for i in range(n):
a,b,c = list(map(int,input().split()))
a_ls[i] = a
b_ls[i] = b
c_ls[i] = c
dp = [[0]*3 for _ in range(n+1)]
dp[1] = [a_ls[0], b_ls[0], c_ls[0]]
for i in range(1,n):
dp[i+1][0] = max(dp[i+1][0], dp[i][1] + a_ls[i], dp[i][2] + a_ls[i])
dp[i+1][1] = max(dp[i+1][1], dp[i][0] + b_ls[i], dp[i][2] + b_ls[i])
dp[i+1][2] = max(dp[i+1][2], dp[i][0] + c_ls[i], dp[i][1] + c_ls[i])
print((max(dp[-1]))) | n = int(eval(input()))
days_ls = [0] * n
for i in range(n):
days_ls[i] = list(map(int, input().split()))
dp = [[0]*3 for _ in range(n)]
dp[0] = days_ls[0]
for i in range(1,n):
dp[i][0] = max(dp[i-1][1],dp[i-1][2]) + days_ls[i][0]
dp[i][1] = max(dp[i-1][0],dp[i-1][2]) + days_ls[i][1]
dp[i][2] = max(dp[i-1][1],dp[i-1][0]) + days_ls[i][2]
print((max(dp[-1]))) | p03162 |
n = int(eval(input()))
abc = [list(map(int, input().split())) for _ in range(n)]
a, b, c = 0, 0, 0
for x, y, z in abc:
a, b, c = max(b, c) + x, max(a, c) + y, max(a, b) + z
print((max(a, b, c))) | n = int(eval(input()))
h = [list(map(int, input().split())) for _ in range(n)]
x, y, z = 0, 0, 0
for a, b, c in h:
x, y, z = max(y,z) + a, max(x,z) + b, max(x,y) + c
print((max(x, y, z))) | p03162 |
n = int(eval(input()))
abc = [list(map(int,input().split())) for _ in range(n)]
dp = [[0 for _ in range(3)] for _ in range(n+1)]
for i in range(1,n+1):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i][k] = max(dp[i][k],dp[i-1][j] + abc[i-1][k])
ans = 0
for i in range(3):
ans = max(ans,dp[n][i])
print(ans) | n = int(eval(input()))
abc = [list(map(int,input().split())) for _ in range(n)]
dp = [[0 for _ in range(3)] for _ in range(n+1)]
for i in range(1,n+1):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i][k] = max(dp[i][k],dp[i-1][j] + abc[i-1][k])
ans = max(dp[-1])
print(ans) | p03162 |
N = int(eval(input()))
Y = []
for _ in range(N):
Y.append(list(map(int, input().split()))) # Y = [[3, 9, 7], [10, 3, 2]]
dp = [[0] * 3 for _ in range(N)] # 初期化
dp[0] = Y[0] # 初期化
# A, B, C の3パターン以外にも対応
for i in range(N-1):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i+1][j] = max(dp[i+1][j], dp[i][k] + Y[i+1][j])
print((max(dp[N-1]))) | N = int(eval(input()))
A = [0] * N
B = [0] * N
C = [0] * N
for i in range(N):
A[i], B[i], C[i] = list(map(int, input().split()))
dp = [[0] * 3 for _ in range(N)] # 初期化 [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] for n = 4
dp[0] = [A[0], B[0], C[0]]
for i in range(N-1):
dp[i+1][0] = max(dp[i][1]+A[i+1], dp[i][2]+A[i+1])
dp[i+1][1] = max(dp[i][0]+B[i+1], dp[i][2]+B[i+1])
dp[i+1][2] = max(dp[i][0]+C[i+1], dp[i][1]+C[i+1])
print((max(dp[N-1]))) | p03162 |
def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
ABC = [list(map(int, input().split())) for i in range(N)]
dp = [[0]*3 for i in range(N)]
dp[0] = ABC[0]
ind = [[1, 2], [0, 2], [0, 1]]
for i in range(1, N):
a, b, c = ABC[i]
dp[i][0] = a + max(dp[i-1][1], dp[i-1][2])
dp[i][1] = b + max(dp[i-1][0], dp[i-1][2])
dp[i][2] = c + max(dp[i-1][0], dp[i-1][1])
print((max(dp[-1])))
if __name__ == "__main__":
main()
| def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
ABC = [list(map(int, input().split())) for i in range(N)]
dp = [[0]*3 for i in range(N)]
dp[0] = ABC[0]
for i in range(N-1):
a, b, c = ABC[i+1]
dp[i+1][0] = a + max(dp[i][1], dp[i][2])
dp[i+1][1] = b + max(dp[i][0], dp[i][2])
dp[i+1][2] = c + max(dp[i][0], dp[i][1])
print((max(dp[-1])))
if __name__ == "__main__":
main()
| p03162 |
import sys
#import unittest
#import collections
def plan_vacation(activity, n):
dp = [[0] * 3 for i in range(n)]
for i in range(3):
dp[0][i] = activity[0][i]
for i in range(1, n):
for j in range(3):
for k in range(3):
if j != k:
dp[i][j] = max(dp[i][j], dp[i-1][k] + activity[i][j])
return max(dp[n-1])
def read_input():
#Read the input N
n = int(sys.stdin.readline())
activity = [[0]* 3 for i in range(n)]
for i in range(n):
a = sys.stdin.readline().split()
for j in range(3):
activity[i][j] = int(a[j])
result = plan_vacation(activity, n)
print(result)
if __name__ == '__main__':
read_input()
| import sys
#import unittest
#import collections
def plan_vacation(activity, n):
dp = [0] * 3
for i in range(3):
dp[i] = activity[0][i]
for i in range(1, n):
new_dp = [0] * 3
for j in range(3):
for k in range(3):
if j != k:
new_dp[j] = max(new_dp[j], dp[k] + activity[i][j])
dp = new_dp
return max(dp)
def read_input():
#Read the input N
n = int(sys.stdin.readline())
activity = [[0]* 3 for i in range(n)]
for i in range(n):
a = sys.stdin.readline().split()
for j in range(3):
activity[i][j] = int(a[j])
result = plan_vacation(activity, n)
print(result)
if __name__ == '__main__':
read_input()
| p03162 |
s = list(map(int, input().split()))
n=s[0]
dp=[[0]*3 for i in range(n)]
s = list(map(int, input().split()))
dp[0][0]=s[0]
dp[0][1] = s[1]
dp[0][2] = s[2]
for i in range(1,n):
s = list(map(int, input().split()))
dp[i][0] = max(dp[i-1][1]+s[0], dp[i-1][2]+s[0])
dp[i][1] = max(dp[i-1][0]+s[1], dp[i-1][2]+s[1])
dp[i][2] = max(dp[i-1][0]+s[2], dp[i-1][1]+s[2])
print((max(dp[n-1]))) |
n=list(map(int,input().split()))[0]
dp=[[0]*3 for _ in range(n+1)]
for i in range(1,n+1):
a,b,c=list(map(int,input().split()))
dp[i][0]=max(dp[i-1][1]+a,dp[i-1][2]+a)
dp[i][1]=max(dp[i-1][0]+b,dp[i-1][2]+b)
dp[i][2]=max(dp[i-1][1]+c,dp[i-1][0]+c)
print((max(dp[-1]))) | p03162 |
n=int(eval(input()))
l1=[]
l2=[]
l3=[]
for i in range(n):
l=input().split()
u=int(l[0])
v=int(l[1])
w=int(l[2])
l1.append(u)
l2.append(v)
l3.append(w)
dpu=[0 for i in range(n)]
dpv=[0 for i in range(n)]
dpw=[0 for i in range(n)]
dpu[0]=l1[0]
dpv[0]=l2[0]
dpw[0]=l3[0]
for i in range(1,n):
dpu[i]=max(dpv[i-1],dpw[i-1])+l1[i]
dpv[i]=max(dpu[i-1],dpw[i-1])+l2[i]
dpw[i]=max(dpu[i-1],dpv[i-1])+l3[i]
print((max(dpu[-1],dpv[-1],dpw[-1])))
| n=int(eval(input()))
l=[]
for i in range(n):
lo=input().split()
l.append((int(lo[0]),int(lo[1]),int(lo[2])))
dp=[[0 for i in range(3)]for i in range(n)]
dp[0][0]=l[0][0]
dp[0][1]=l[0][1]
dp[0][2]=l[0][2]
for i in range(1,n):
dp[i][0]=max(dp[i-1][1],dp[i-1][2])+l[i][0]
dp[i][1]=max(dp[i-1][2],dp[i-1][0])+l[i][1]
dp[i][2]=max(dp[i-1][0],dp[i-1][1])+l[i][2]
print((max(dp[n-1][0],dp[n-1][1],dp[n-1][2])))
| p03162 |
import sys
sys.setrecursionlimit(int(1e6))
n=int(eval(input()))
l=[[0,0,0]]
for _ in range(n):
l.append(list(map(int,input().split())))
memo=[[-1,-1,-1] for _ in range(n+1)]
memo[0][0]=0
memo[0][1]=0
memo[0][2]=0
def dp(i,j):
if memo[i][j]!=-1:
return memo[i][j]
else:
memo[i][j]=max(dp(i-1,(j+1)%3)+l[i][j],dp(i-1,(j+2)%3)+l[i][j])
return memo[i][j]
print((max(dp(n,0),dp(n,1),dp(n,2)))) | import sys
sys.setrecursionlimit(int(1e6))
n=int(eval(input()))
l=[[0,0,0]]
for _ in range(n):
l.append(list(map(int,input().split())))
memo=[[-1,-1,-1] for _ in range(n+1)]
memo[0][0]=0
memo[0][1]=0
memo[0][2]=0
def dp(i,j):
if memo[i][j]!=-1:
return memo[i][j]
else:
memo[i][j]=max(dp(i-1,(j+1)%3)+l[i][j],dp(i-1,(j+2)%3)+l[i][j])
return memo[i][j]
s1=dp(n,0)
s2=dp(n,1)
s3=dp(n,2)
print((max(s1,s2,s3))) | p03162 |
def main():
n = int(eval(input()))
x = []
for _ in range(n):
a, b, c = list(map(int, input().split()))
x.append([a, b, c])
dp = [[0] * 3 for _ in range(n)]
# i日目の幸福度dp[i-1]
# まず1日目の幸福度を設定
dp[0] = [x[0][l] for l in range(3)]
for i in range(1,n):
for j in range(3):
dp[i][j] = max([dp[i-1][k]+x[i][j] for k in range(3) if k != j]+[dp[i][j]])
print((max(dp[n-1])))
if __name__ == "__main__":
main() | def main():
n = int(eval(input()))
x = []
for _ in range(n):
a, b, c = list(map(int, input().split()))
x.append((a, b, c))
dp0 = [0]*(n+1)
dp1 = [0]*(n+1)
dp2 = [0]*(n+1)
for i in range(1,n+1):
a, b, c = x[i-1]
dp0[i] = max(dp1[i-1]+a, dp2[i-1]+a)
dp1[i] = max(dp0[i-1]+b, dp2[i-1]+b)
dp2[i] = max(dp0[i-1]+c, dp1[i-1]+c)
print((max(dp0[n], dp1[n], dp2[n])))
if __name__ == "__main__":
main() | p03162 |
n = int(eval(input()))
a,b,c = list(map(int,input().split()))
dp = [0,0,0] * n
dp[0] = [a,b,c]
for i in range(1,n):
a,b,c = list(map(int,input().split()))
dp[i] = [max(dp[i-1][1],dp[i-1][2])+a,max(dp[i-1][0],dp[i-1][2])+b,max(dp[i-1][0],dp[i-1][1])+c]
print((max(dp[n-1]))) | import sys
input = sys.stdin.readline
n = int(eval(input()))
a = [0]*n
b = [0]*n
c = [0]*n
for i in range(n):
a[i],b[i],c[i] = list(map(int,input().split()))
dpa = [a[0]]+[0]*(n-1)
dpb = [b[0]]+[0]*(n-1)
dpc = [c[0]]+[0]*(n-1)
for i in range(1,n):
dpa[i] = max(dpb[i-1],dpc[i-1]) + a[i]
dpb[i] = max(dpc[i-1],dpa[i-1]) + b[i]
dpc[i] = max(dpa[i-1],dpb[i-1]) + c[i]
print((max(dpa[-1],dpb[-1],dpc[-1])))
| p03162 |
N=int(eval(input()))
dp=[[0]*3 for i in range(N+1)]
for i in range(1,N+1):
a=list(map(int,input().split()))
for j in range(3):
tmp=[]
for k in range(3):
if j!=k:
dp[i][k]=max(dp[i][k],dp[i-1][j]+a[k])
print((max(dp[-1]))) | N = int(eval(input()))
A = [list(map(int, input().split())) for i in range(N)]
dp = [[0]*3 for i in range(N+1)]
for i in range(1,N+1):
for j in range(3):
for k in range(3):
if j != k:
dp[i][k] = max(dp[i][k],dp[i-1][j]+A[i-1][k])
print((max(dp[-1]))) | p03162 |
N = int(eval(input()))
A = [list(map(int, input().split())) for i in range(N)]
dp = [[0]*3 for i in range(N+1)]
for i in range(1,N+1):
for j in range(3):
for k in range(3):
if j != k:
dp[i][k] = max(dp[i][k],dp[i-1][j]+A[i-1][k])
print((max(dp[-1]))) | import sys
input = sys.stdin.readline
N = int(eval(input()))
table = []
dp = [[0]*3 for i in range(N)]
for i in range(N):
a,b,c = list(map(int, input().split()))
table.append((a,b,c))
dp[0] = table[0]
for i in range(1,N):
for j in range(3):
for k in range(3):
if j==k:
continue
dp[i][j] = max(dp[i][j],dp[i-1][k]+table[i][j])
print((max(dp[-1]))) | p03162 |
n= int(eval(input()))
active = [[0, 0, 0]] * n
for i in range(n):
a, b, c = list(map(int, input().split(' ')))
active[i] = [a, b, c]
dp = [[]] * (n + 1)
for i in range(n+1):
dp[i] = [0, 0, 0]
#print(n, active, dp)
def chmin(arr, index_a, val):
if arr[index_a] > val:
arr[index_a] = val
return True
return False
def chmax(arr, index_a, val):
if arr[index_a] < val:
arr[index_a] = val
return True
return False
ans = 0
pre_active = None
for i in range(n):
a, b, c = active[i]
dp_i = i + 1 # dpの添字はi日目なので、i = 0 = 初期状態, この場合 i が前日になる
# i日目に a を選ぶ
dp[dp_i][0] = max(dp[i][1] + a, dp[i][2] + a)
# i日目に b を選ぶ
dp[dp_i][1] = max(dp[i][0] + b, dp[i][2] + b)
# i日目に a を選ぶ
dp[dp_i][2] = max(dp[i][0] + c, dp[i][1] + c)
#print(dp)
print((max(dp[n]))) | n = int(eval(input()))
a = [0] * n
b = [0] * n
c = [0] * n
for i in range(n):
a[i], b[i], c[i] = list(map(int, input().split()))
dp = [[]] * (n+1)
for i in range(n+1):
dp[i] = [0, 0, 0]
for i in range(n):
dp[i+1][0] = max(dp[i][1] + a[i], dp[i][2] + a[i])
dp[i+1][1] = max(dp[i][0] + b[i], dp[i][2] + b[i])
dp[i+1][2] = max(dp[i][0] + c[i], dp[i][1] + c[i])
print((max(dp[n]))) | p03162 |
import sys
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()
def maxim(i, char):
if i < 0:
return 0
if li[i][char] != -1:
##print('hi')
##print(i,char)
return li[i][char]
if char == 2:
li[i][2] = max(c[i] + maxim(i - 1, 1), c[i] + maxim(i - 1, 0))
return li[i][2]
if char == 1:
li[i][1] = max(b[i] + maxim(i - 1, 0), b[i] + maxim(i - 1, 2))
return li[i][1]
if char == 0:
li[i][0] = max(a[i] + maxim(i - 1, 1), a[i] + maxim(i - 1, 2))
return li[i][0]
if char == 3:
li[i][3] = (max(maxim(i - 1, 2), maxim(i - 1, 1), maxim(i - 1, 0)))
return li[i][3]
n = int(eval(input()))
a, b, c = [], [], []
for _ in range(n):
x, y, z = get_ints()
li = [[-1 for i in range(4)] for j in range(n+1)]
a.append(x)
b.append(y)
c.append(z)
li = [[-1 for i in range(4)] for j in range(n+1)]
print((maxim(n , 3))) | import sys
def get_array(): return list(map(int , sys.stdin.readline().strip().split()))
def get_ints(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()
n=int(eval(input()))
a, b, c = [], [], []
for _ in range(n):
x,y,z=get_ints()
##li=[[-1 for i in range(4)]for j in range(n)]
a.append(x)
b.append(y)
c.append(z)
li=[[-1 for i in range(4)]for j in range(n)]
for i in range(n):
for j in range(4):
if i==0:
if j==0:
li[i][j]=a[i]
if j==1:
li[i][j]=b[i]
if j==2:
li[i][j]=c[i]
if j==3:
li[i][j] = 0
continue
if j==0:
li[i][j] = max(a[i] + li[i-1][1] ,a[i] + li[i - 1][2])
if j==1:
li[i][j] = max(b[i] + li[i - 1][0], b[i] +li[i - 1][2])
if j==2:
li[i][j] = max(c[i] + li[i - 1][1], c[i] + li[i - 1][0])
if j==3:
li[i][3] = (max(li[i - 1][2],li[i - 1][1], li[i - 1][0]))
print((max(li[n-1])))
| p03162 |
n = int(eval(input()))
dp = [[0 for i in range(3)]]
for i in range(1,n+1):
a,b,c = list(map(int, input().split()))
x = max(dp[i-1][1] + a, dp[i-1][2] + a)
y = max(dp[i-1][2] + b, dp[i-1][0] + b)
z = max(dp[i-1][0] + c, dp[i-1][1] + c)
dp.append([x,y,z])
print((max(dp[n])))
| n = int(eval(input()))
dp = [0 for i in range(3)]
for i in range(1,n+1):
a,b,c = list(map(int, input().split()))
x = max(dp[1] + a, dp[2] + a)
y = max(dp[2] + b, dp[0] + b)
z = max(dp[0] + c, dp[1] + c)
dp = [x,y,z]
print((max(dp)))
| p03162 |
def main():
N = int(eval(input()))
A = [0]
B = [0]
C = [0]
for i in range(N):
a, b, c = (int(i) for i in input().split())
A.append(a)
B.append(b)
C.append(c)
dp = [[0 for _ in range(N+1)] for _ in range(3)]
dp[0][1] = A[1]
dp[1][1] = B[1]
dp[2][1] = C[1]
for i in range(1, N):
dp[2][i+1] = max(dp[0][i] + C[i+1], dp[1][i] + C[i+1])
dp[1][i+1] = max(dp[0][i] + B[i+1], dp[2][i] + B[i+1])
dp[0][i+1] = max(dp[1][i] + A[i+1], dp[2][i] + A[i+1])
print((max(dp[0][-1], dp[1][-1], dp[2][-1])))
if __name__ == '__main__':
main()
| def main():
N = int(eval(input()))
ABC = [[int(i) for i in input().split()] for j in range(N)]
dp = [[0]*3 for _ in range(N+1)]
for i in range(N):
for j in range(3):
dp[i+1][j] = max(dp[i][(j+1) % 3], dp[i][(j+2) % 3]) + ABC[i][j]
print((max(dp[N])))
if __name__ == '__main__':
main()
| p03162 |
# coding: utf-8
import sys
input = sys.stdin.readline
def f(n, abc):
dp = [0] * 3
for i in range(1, n + 1):
a, b, c = abc[i - 1]
dp = [ max(dp[1] + a, dp[2] + a), \
max(dp[0] + b, dp[2] + b), \
max(dp[0] + c, dp[1] + c) ]
return(max(dp))
n = int(eval(input())) # 1 <= n <= 10^5
abc = [list(map(int, input().rstrip().split())) for _ in range(n)]
print((f(n, abc)))
| # coding: utf-8
import sys
input = sys.stdin.readline
def f(n, abc):
dp = [0] * 3
for i in range(n):
a, b, c = abc[i]
dp0, dp1, dp2 = dp
dp = [ max(dp1 + a, dp2 + a), \
max(dp0 + b, dp2 + b), \
max(dp0 + c, dp1 + c) ]
return(max(dp))
n = int(eval(input())) # 1 <= n <= 10^5
abc = [list(map(int, input().rstrip().split())) for _ in range(n)]
print((f(n, abc)))
| p03162 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.