input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
# def to_2(num):
# ret = []
# while (num != 0):
# if num % 2 == 1:
# ret.append(True)
# else:
# ret.append(False)
# num = num // 2
# return np.array(ret)
# def()
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# 全探索
from itertools import combinations
A_2 = [bin(a) for a in A]
kouho = [sum(A[idx:(idx2+1)]) for idx, idx2 in combinations(list(range(0, N)), 2)]
ma = 0
for A_sub in combinations(kouho, K):
bina = A_sub[0]
# print(bina)
for i in range(1, K):
bina = bina & A_sub[i]
if bina > ma:
ma = bina
print(ma) | # https://atcoder.jp/contests/dwacon5th-prelims/tasks/dwacon5th_prelims_b
# 解説見てしまった
# N≤1000の性質をうまく使う必要はない。O(N^2)で全部書き出せばいい。完全に引っ掛け。
# 答えの仮定、bitごとに見る、上位桁からのgreedyらへんがキーワード
from itertools import combinations
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = [sum(A[s:t]) for s, t in combinations(list(range(N + 1)), 2)]
l = max(B).bit_length() # 何桁扱えば十分か？
x = 0 # 初期値
for i in range(l, -1, -1): # 上位桁からgreedyに決定
# 候補のうち i bit目=1がK個以上あれば答えに計上できる
x_tmp = x + (1 << i)
if sum((x_tmp & b) == x_tmp for b in B) >= K: # 確定した桁+i桁を1としたときに答えになり得るか？
x = x_tmp
print(x)
| p03215 |
import itertools
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
b = [a[0]]
for i in range(n-1):
b.append(b[i]+a[i+1])
c1 = list(itertools.combinations(list(range(n)),2))
s = a
for i in c1:
s.append(b[i[1]]-b[i[0]]+a[i[0]])
c2 = list(itertools.combinations(list(range(len(s))),k))
max=0
for i in c2:
t = s[i[0]]
for j in i:
t = t&s[j]
if max < t:
max = t
print(max)
| import itertools
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
b = [a[0]]
for i in range(n-1):
b.append(b[i]+a[i+1])
c = list(itertools.combinations(list(range(n)),2))
s = a
for i in c:
s.append(b[i[1]]-b[i[0]]+a[i[0]])
s.sort(reverse=True)
l = len(bin(s[0]))-2
d = 1<<l-1
t = 0
while d>0:
s1 = []
if s[k-1] >= d:
t += d
for i in s:
if i >= d:
s1.append(i)
else:
s=s1
break
for i in range(len(s)):
if s[i] >= d:
s[i] -= d
else:
s.sort(reverse=True)
break
d //= 2
print(t) | p03215 |
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
b = [a[0]]
for i in range(n-1):
b.append(b[i]+a[i+1])
s = b
for i in range(n-1):
for j in range(i,n-1):
s.append(b[j+1]-b[i])
s.sort(reverse=True)
l = len(bin(s[0]))-2
d = 1<<l-1
t = 0
while d>0:
s1 = []
if s[k-1] >= d:
t += d
for i in s:
if i >= d:
s1.append(i)
else:
s=s1
break
for i in range(len(s)):
if s[i] >= d:
s[i] -= d
else:
s.sort(reverse=True)
break
d //= 2
print(t) | n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
b = [a[0]]
for i in range(n-1):
b.append(b[i]+a[i+1])
s = b
for i in range(n-1):
for j in range(i,n-1):
s.append(b[j+1]-b[i])
s.sort(reverse=True)
l = len(bin(s[0]))-2
d = 1<<l-1
t = 0
while d>0:
s1 = []
if s[k-1] >= d:
t += d
for i in s:
if i >= d:
s1.append(i)
else:
s=s1
break
for i in range(len(s)):
if s[i] >= d:
s[i] -= d
else:
s.sort(reverse=True)
break
d = d>>1
print(t) | p03215 |
N,K=list(map(int,input().split()))
alist=list(map(int,input().split()))
sum_list=[]
for i in range(N):
s=0
for j in range(i,N):
s+=alist[j]
sum_list.append(s)
sum_list.sort(reverse=True)
#print(sum_list)
answer=0
for i in reversed(list(range(41))):
x=2**i
cnt=0
for s in sum_list:
if (answer+x)&s==answer+x:
cnt+=1
if cnt>=K:
answer+=x
break
print(answer) | N,K=list(map(int,input().split()))
alist=list(map(int,input().split()))
sum_list=[]
for i in range(N):
s=0
for j in range(i,N):
s+=alist[j]
sum_list.append(s)
sum_list.sort(reverse=True)
#print(sum_list)
answer=0
for i in reversed(list(range(41))):
x=2**i
cnt=0
for s in sum_list:
if answer+x>s:
break
elif (answer+x)&s==answer+x:
cnt+=1
if cnt>=K:
answer+=x
break
print(answer) | p03215 |
from itertools import accumulate, combinations
n, k = list(map(int, input().split()))
a = [0] + list(accumulate(list(map(int, input().split()))))
btfl =[]
for i in range(0, n):
for j in range(i + 1, n + 1):
btfl.append(a[j] - a[i])
ans = 0
for l in combinations(btfl, k):
cnt = l[0]
for i in l:
cnt &= i
ans = max(ans, cnt)
print(ans)
| from itertools import accumulate
n, k = list(map(int, input().split()))
a = [0] + list(accumulate(list(map(int, input().split()))))
btfl = []
for i in range(0, n):
for j in range(i + 1, n + 1):
btfl.append(a[j] - a[i])
# 解説AC
ans = 0
for i in range(50)[::-1]:
num, cnt = ans + pow(2, i), 0
for b in btfl:
if num == num & b:
cnt += 1
if cnt >= k:
ans = num
print(ans)
| p03215 |
from itertools import accumulate
def main():
n, k = list(map(int, input().split()))
a = [0] + list(accumulate(list(map(int, input().split()))))
btfl = []
for i in range(0, n):
for j in range(i + 1, n + 1):
btfl.append(a[j] - a[i])
# 解説AC
ans = 0
for i in range(50)[::-1]:
num, cnt = ans + pow(2, i), 0
for b in btfl:
if num == num & b:
cnt += 1
if cnt >= k:
ans = num
print(ans)
if __name__ == '__main__':
main()
| from itertools import accumulate
n, k = list(map(int, input().split()))
a = [0] + list(accumulate(list(map(int, input().split()))))
btfl = []
for i in range(0, n):
for j in range(i + 1, n + 1):
btfl.append(a[j] - a[i])
# 解説AC
ans = 0
for i in range(50)[::-1]:
num, cnt = ans + pow(2, i), 0
for b in btfl:
if num == num & b:
cnt += 1
if cnt >= k:
ans = num
print(ans)
| p03215 |
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
b=[]
for i in range(n):
x=0
for j in range(i,n):
x+=a[j]
b.append(x)
ans=0
l=len(b)
for i in range(40,0,-1):
x=0
s=2**i
for j in range(l):
if b[j]&(ans+s)==ans+s:x+=1
if x>=k:ans+=s
print(ans) | n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
b=[]
for i in range(n):
x=0
for j in range(i,n):
x+=a[j]
b.append(x)
ans=0
l=len(b)
for i in range(40,-1,-1):
x=0
s=2**i
for j in range(l):
if b[j]&(ans+s)==ans+s:x+=1
if x>=k:ans+=s
print(ans) | p03215 |
def main():
N, K = list(map(int, input().split()))
A = [0] + list(map(int, input().split()))
for i in range(N):
A[i + 1] += A[i]
B = [A[j] - A[i] for i in range(N) for j in range(i + 1, N + 1)]
ans = 0
t = 40
tmp = pow(2, t)
while t:
count = 0
tmp //= 2
for b in B:
if ((b & (tmp + ans)) == (tmp + ans)):
count += 1
if count >= K:
ans += tmp
break
t -= 1
print (ans)
if __name__ == '__main__':
main() | def main():
N, K = list(map(int, input().split()))
A = [0] + list(map(int, input().split()))
for i in range(N):
A[i + 1] += A[i]
B = [A[j] - A[i] for i in range(N) for j in range(i + 1, N + 1)]
ans = 0
tmp = pow(2, 40)
for _ in range(40):
count = 0
tmp //= 2
tmp_ = ans + tmp
for b in B:
if ((b & (tmp_)) == (tmp_)):
count += 1
if count >= K:
ans += tmp
break
print (ans)
if __name__ == '__main__':
main() | p03215 |
#横にn個入力
n, k = list(map(int, input().split()))
a = input().split()
a = [int(m) for m in a]
nli = []
b = 0
for i in range(n):
for j in range(i, n):
b += a[j]
nli.append(b)
b = 0
nli.sort(reverse=True)
m = 40
x = 0
cnt = 0
candili = []
for i in range(m - 1, 0, -1):
if x == 0:
for j in range(len(nli)):
if nli[j] & (x + 2 ** i) == x + 2 ** i:
candili.append(nli[j])
cnt += 1
if cnt >= k:
x += 2 ** i
cnt = 0
else:
cnt = 0
candili = []
else:
for j in candili:
if j & (x + 2 ** i) == x + 2 ** i:
cnt += 1
if cnt >= k:
x += 2 ** i
cnt = 0
else:
cnt = 0
print(x) | #横にn個入力
n, k = list(map(int, input().split()))
a = input().split()
a = [int(m) for m in a]
nli = []
b = 0
for i in range(n):
for j in range(i, n):
b += a[j]
nli.append(b)
b = 0
nli.sort(reverse=True)
m = 41
x = 0
cnt = 0
candili = []
for i in range(m - 1, -1, -1):
if x == 0:
for j in range(len(nli)):
if nli[j] & (x + 2 ** i) == x + 2 ** i:
candili.append(nli[j])
cnt += 1
if cnt >= k:
x += 2 ** i
cnt = 0
else:
cnt = 0
candili = []
else:
for j in candili:
if j & (x + 2 ** i) == x + 2 ** i:
cnt += 1
if cnt >= k:
x += 2 ** i
cnt = 0
else:
cnt = 0
print(x) | p03215 |
import itertools as tool
N, K = list(map(int, input().split()))
a = [int(x) for x in input().split()]
beautifuls = []
for i in range(0, len(a)):
for j in range(i+1, len(a)+1):
beautiful = sum(a[i:j])
beautifuls.append(beautiful)
beau_K = list(tool.combinations(beautifuls, K))
ands = []
for combi in beau_K:
for i in range(K):
if i == 0:
tmp = combi[0]
else:
tmp = eval(str(bin(tmp & combi[i])))
ands.append(eval(str(tmp)))
print((max(ands)))
|
N, K = list(map(int, input().split()))
a = [int(x) for x in input().split()]
beautifuls = []
for i in range(0, len(a)):
for j in range(i+1, len(a)+1):
beautiful = sum(a[i:j])
beautifuls.append(beautiful)
x_ = 0
t = 1
count = 0
while 1:
for i in range(len(beautifuls)):
if eval(str(bin((x_ + 2**(t-1)) & beautifuls[i]))) == x_+ 2**(t-1):
count += 1
if count == K:
x_ += 2**(t-1)
t = 0
break
count = 0
t += 1
if t > 40:
break
print(x_)
| p03215 |
from itertools import accumulate
N, K = list(map(int, input().split()))
As = list(map(int, input().split()))
accAs = [0] + list(accumulate(As))
Bs = []
for L in range(N):
for R in range(L, N):
Bs.append(accAs[R + 1] - accAs[L])
ans = 0
for d in reversed(list(range(50))):
num = sum([(B >> d) & 1 for B in Bs])
if num >= K:
ans += 1 << d
Bs = [B if (B >> d) & 1 else 0 for B in Bs]
print(ans)
| from itertools import accumulate
N, K = list(map(int, input().split()))
As = list(map(int, input().split()))
accAs = [0] + list(accumulate(As))
Bs = []
for L in range(N):
for R in range(L, N):
Bs.append(accAs[R + 1] - accAs[L])
ans = 0
for d in reversed(list(range(40))):
num = sum([(B >> d) & 1 for B in Bs])
if num >= K:
ans += 1 << d
Bs = [B for B in Bs if (B >> d) & 1]
print(ans)
| p03215 |
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
n,k = ma()
A = lma()
bu = []
for i in range(n):
tmp=0
for j in range(i,n):
tmp+=A[j]
bu.append(tmp)
mb = bin(max(bu))
ls = [0]*(len(mb)-2)
for b in bu:
for i in range(len(bin(b))-2):
if (b>>i &1):
ls[i]+=1
ans = 0
tmp=bu
for i in range(len(mb)-3,-1,-1):
if ls[i]<k:
continue
tmp2=[]
for b in tmp:
if (b>>i &1):
tmp2.append(b)
if len(tmp2)>=k:
ans+=2**i
tmp=tmp2
else:
pass
print(ans)
| ma = lambda :list(map(int,input().split()))
lma = lambda :list(map(int,input().split()))
n,k = ma()
A = lma()
bu = []
for i in range(n):
tmp=0
for j in range(i,n):
tmp+=A[j]
bu.append(tmp)
mb = bin(max(bu))
ans = 0
for i in range(len(mb)-3,-1,-1):
tmp=[]
for b in bu:
if (b>>i &1):
tmp.append(b)
if len(tmp)>=k:
ans+=2**i
bu=tmp
else:
pass
print(ans)
| p03215 |
def cumsum(l):
c = [0] * len(l)
for i in range(len(l)):
c[i] = c[i-1] + l[i]
return c
N, K = list(map(int, input().split()))
a = [int(i) for i in input().split()]
c = [0] + cumsum(a)
s = [bin(c[j+i] - c[j]).replace('0b','').zfill(40) for i in range(1, N+1) for j in range(N-i+1)]
ans = [0] * 40
for i in range(40):
t = [j for j in s if j[i] == '1']
if len(t) >= K:
ans[i] = 1
s = t
print((sum([ans[i] * 2**(39-i) for i in range(40)]))) | def cumsum(l):
c = [0] * len(l)
for i in range(len(l)):
c[i] = c[i-1] + l[i]
return c
N, K = list(map(int, input().split()))
a = [int(i) for i in input().split()]
c = [0] + cumsum(a)
s = [bin(c[j+i] - c[j]).replace('0b','').zfill(40) for i in range(1, N+1) for j in range(N-i+1)]
ans = 0
for i in range(40):
t = [j for j in s if j[i] == '1']
if len(t) >= K:
ans += 2**(39-i)
s = t
print(ans) | p03215 |
import sys
from itertools import accumulate
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
R = [0] + list(accumulate(A))
subs = []
for left in range(n):
for right in range(left + 1, n + 1):
subs.append(R[right] - R[left])
res = 0
for mask in reversed(list(range(40))):
if len(subs) == 0:
break
tmp = []
for i in range(len(subs)):
if subs[i] & (1 << mask):
tmp.append(subs[i])
if len(tmp) >= k:
res += 1 << mask
subs = tmp
print(res)
if __name__ == '__main__':
resolve()
| import sys
from itertools import accumulate
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
R = [0] + list(accumulate(A))
subs = []
for left in range(n + 1):
for right in range(left + 1, n + 1):
num = R[right] - R[left]
subs.append(num)
for i in reversed(list(range(41))):
tmp = []
for num in subs:
if num & (1 << i):
tmp.append(num)
if len(tmp) >= k:
subs = tmp
res = subs[0]
for num in subs:
res &= num
print(res)
if __name__ == '__main__':
resolve()
| p03215 |
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
def ACC1(l):
N = len(l)
ret = [0]*(N+1)
for i in range(N):
ret[i+1] = ret[i]+l[i]
return ret
N,K = IL()
A = IL()
ACC = ACC1(A)
SUMS = []
for i in range(N+1):
for j in range(i+1,N+1):
SUMS.append(ACC[j]-ACC[i])
ans = 0
for k in range(40)[::-1]:
HERE = list([x for x in SUMS if (x>>k)&1])
if len(HERE)>=K:
ans += 1<<k
SUMS = HERE
print(ans) | # -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
def ACC1(l):
N = len(l)
ret = [0]*(N+1)
for i in range(N):
ret[i+1] = ret[i]+l[i]
return ret
N,K = IL()
A = IL()
ACC = ACC1(A)
SUMS = []
for i in range(N+1):
for j in range(i+1,N+1):
SUMS.append(ACC[j]-ACC[i])
ans = 0
for k in range(int_log(max(SUMS),2)+1)[::-1]:
HERE = list([x for x in SUMS if (x>>k)&1])
if len(HERE)>=K:
ans += 1<<k
SUMS = HERE
print(ans) | p03215 |
n, k = list(map(int, input().split()))
As = list(map(int, input().split()))
from itertools import accumulate
acc = [0]+list(accumulate(As))
dp = [0] * 50
mx = 0
sums = []
for i in range(n+1):
for j in range(i+1,n+1):
s = acc[j]-acc[i]
sums.append(s)
# 最大の桁数
for d in range(50):
if max(sums) & (1<<d):
mx = max(mx, d)
dp[d] += 1
mx = 0
for i in range(50):
if dp[i] >= k:
mx = max(mx,i)
ans = 0
now = 0
for d in range(50,-1,-1):
cnt = 0
for s in sums:
if s & (now+(1<<d)) == now+(1<<d):
cnt += 1
# print(d,cnt)
if cnt >= k:
now += 1<<d
print(now) | n, k = list(map(int, input().split()))
As = list(map(int, input().split()))
from itertools import accumulate
acc = [0]+list(accumulate(As))
dp = [0] * 50
mx = 0
sums = []
for i in range(n+1):
for j in range(i+1,n+1):
s = acc[j]-acc[i]
sums.append(s)
# 最大の桁数
for d in range(50):
if max(sums) & (1<<d):
mx = max(mx, d)
dp[d] += 1
mx = 0
for i in range(50):
if dp[i] >= k:
mx = max(mx,i)
# 計算
ans = 0
now = 0
for d in range(50,-1,-1):
cnt = 0
for s in sums:
if s & (now+(1<<d)) == now+(1<<d):
cnt += 1
# print(d,cnt)
if cnt >= k:
now += 1<<d
print(now) | p03215 |
def b_len(v):
return len(bin(v)[2:])
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cs = [0]
for aa in a:
cs.append(cs[-1] + aa)
ps = []
for i in range(1, n + 1):
for j in range(i):
ps.append(cs[i] - cs[j])
ps = sorted(ps, reverse=True)
pw = b_len(ps[k - 1])
MOD = 2 ** pw
nps = {i:set() for i in range(pw)}
for i in range(len(ps)):
t = ps[i] % MOD
for j in range(pw):
if 1 << j & t:
nps[j].add(i)
ans = 0
buf = set(range(len(ps)))
for j in range(pw)[::-1]:
if len(nps[j]) >= k:
x = buf & nps[j]
if len(x) >= k:
buf = x
ans += 2 ** j
print(ans) | from math import log, ceil
n, k = list(map(int, input().split()))
a = tuple(map(int, input().split()))
A_MAX = 10 ** 9
MAX_BIT_LENGTH = ceil(log(A_MAX * n, 2))
cs = [0]
t = 0
for aa in a:
t += aa
cs.append(t)
ps = []
for r in range(1, n + 1):
for l in range(r):
ps.append(cs[r] - cs[l])
ans = 0
for b in range(MAX_BIT_LENGTH)[::-1]:
cnt = 0
t = ans + (1 << b)
for p in ps:
if p & t == t:
cnt += 1
if cnt == k:
ans = t
break
print(ans) | p03215 |
import sys
import collections
import itertools
import math
import re
from collections import Counter
from collections import deque
from collections import defaultdict
MOD = 10 ** 9 + 7
N,K = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
C = []
s = 0
ma = 0
for i in range(0,N-1):
for j in range(i, N):
if j==i:
C.append(A[i])
else:
C.append(C[-1] + A[j])
ma = max(ma, max(C))
IDX = 0
while ((1 << IDX) < ma):
IDX += 1
def filterList(list, i):
retList = []
for l in list:
if l & (1 << i):
retList.append(l)
return retList
D = C
for i in range(IDX,-1,-1):
newD = filterList(D,i)
if len(newD) < K:
break
else:
D = newD
EE = list(itertools.combinations(D, K))
EE = list(set(EE))
ret = 0
for E in EE:
r = E[0]
for e in E:
r = r & e
ret = max(ret, r)
print(ret)
sys.exit(0)
| import sys
N,K = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
C = []
for i in range(0,N-1):
for j in range(i, N):
if j==i:
C.append(A[i])
else:
C.append(C[-1] + A[j])
D = C
ans = 0
for i in range(40,-1,-1):
yes = []
no = []
for l in D:
if l & (1 << i):
yes.append(l)
else:
no.append(l)
if len(yes) >= K:
ans += 1 << i
D = yes
print(ans)
sys.exit(0)
| p03215 |
import sys
import collections
from collections import Counter
# from collections import deque
# from collections import defaultdict
import itertools
# from itertools import accumulate
# from itertools import permutations
# from itertools import combinations
# from itertools import takewhile
from itertools import compress
# import functools
# from functools import reduce
import math
# from math import gcd
# from math import inf
# from math import ceil
# from math import floor
# from math import log10
# from math import log2
# from math import log
from math import factorial
# import re
N, K = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
S = set()
for i in range(N):
for j in range(i, N):
b = A[i:j + 1]
S.add(sum(b))
S = sorted(list(S))
ans = 0
for i in range(40, -1, -1):
A = [s & (1 << i) for s in S]
newS = list(compress(S, A))
if len(newS) >= K:
ans += (1 << i)
S = newS
print(ans)
| import sys
import collections
from collections import Counter
# from collections import deque
# from collections import defaultdict
import itertools
# from itertools import accumulate
# from itertools import permutations
# from itertools import combinations
# from itertools import takewhile
from itertools import compress
# import functools
# from functools import reduce
import math
# from math import gcd
# from math import inf
# from math import ceil
# from math import floor
# from math import log10
# from math import log2
# from math import log
from math import factorial
# import re
N, K = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
S = set()
for i in range(N):
for j in range(i, N):
b = A[i:j + 1]
S.add(sum(b))
S = list(S)
ans = 0
for i in range(40, -1, -1):
A = [s & (1 << i) for s in S]
newS = list(compress(S, A))
if len(newS) >= K:
ans += (1 << i)
S = newS
print(ans)
| p03215 |
from copy import deepcopy
from collections import deque
N, K = list(map(int, input().split()))
A = [int(a) for a in input().split()]
Sum = deque([0])
for i in range(N):
Sum.append(Sum[-1] + A[i])
Asum = deque([])
for i in range(N):
for j in range(i+1, N+1):
Asum.append(Sum[j] - Sum[i])
Search = deepcopy(Asum)
x = 0
for i in reversed(list(range(1, 41))):
new = deque([])
for s in Search:
if (x + 2 ** (i-1)) & s == x + 2 ** (i-1):
new.append(s)
if len(new) >= K:
Search = new
x += 2 ** (i-1)
print(x) | import sys
sys.setrecursionlimit(1000000)
def search(i, L, Lnum, K):
if i > 40: return 0
add = pow(2, 40 - i)
nextK = []
count = 0
for l in L:
if l & add == add:
nextK.append(l)
count += 1
#print(i, L)
if count >= K: return add + search(i+1, nextK, count, K)
else: return search(i+1, L, Lnum, K)
def solve():
input = sys.stdin.readline
N, K = list(map(int, input().split()))
A = [int(a) for a in input().split()]
sumA = [0] * (N + 1)
for i, a in enumerate(A): sumA[i+1] = sumA[i] + a
subA = []
for i in range(N):
for j in range(i+1, N+1): subA.append(sumA[j] - sumA[i])
print((search(0, subA, N * (N + 1) // 2, K)))
return 0
if __name__ == "__main__":
solve() | p03215 |
import copy
N, K = list(map(int,input().split()))
a = list(map(int,input().split()))
S = [0]*N
S[0] = a[0]
for k in range(1,N):
S[k] = S[k-1] + a[k]
S = [0] + S
T = []
for k in range(N):
for l in range(k+1,N+1):
T.append(S[l]-S[k])
ans = 0
for d in range(41,-1,-1):
c = 0
for e in T:
if (ans+2**d)&e == ans+2**d:
c += 1
if c >= K:
ans += 2**d
print(ans)
| N, K = list(map(int,input().split()))
a = list(map(int,input().split()))
S = [0]*N
S[0] = a[0]
for k in range(1,N):
S[k] = S[k-1] + a[k]
S = [0] + S
T = []
for k in range(N):
for l in range(k+1,N+1):
T.append(S[l]-S[k])
ans = 0
for d in range(41,-1,-1):
c = 0
for e in T:
if (ans+2**d)&e == ans+2**d:
c += 1
if c >= K:
ans += 2**d
print(ans)
| p03215 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from itertools import accumulate
n,k = li()
a = list(li())
acum = list(accumulate([0]+a))
cand = []
for i in range(n+1):
for j in range(i+1,n+1):
cand.append(acum[j] - acum[i])
ans = 0
for mask in range(40, -1, -1):
satis = sum([bool(ci&(1<<mask)) for ci in cand])
if satis >= k:
ans += (1<<mask)
nex = [ci for ci in cand if ci & (1<<mask)]
cand = nex
print(ans) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n, k = li()
a = list(li())
cum = [0]
for ai in a:
cum.append(cum[-1] + ai)
pool = []
for i in range(n+1):
for j in range(i+1, n+1):
pool.append(cum[j] - cum[i])
MAX_BIT = 41
ans = 0
for bit in range(MAX_BIT, -1, -1):
new_pool = []
for poli in pool:
if poli & (1<<bit):
new_pool.append(poli)
if len(new_pool) >= k:
ans += (1<<bit)
pool = new_pool
print(ans) | p03215 |
import sys
from collections import *
import heapq
import math
# from math import gcd
import bisect
import copy
from itertools import permutations,accumulate,combinations,product
# def input():
# return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
rlst=ruiseki(a)
# print(rlst)
lst=[]
for i in range(n+1):
for j in range(i+1,n+1):
# print(i,j)
lst.append(rlst[j]-rlst[i])
# print(lst)
tmp=math.log(rlst[-1],2)
now=int(tmp)
while now>=0:
anslst=[]
for i in range(len(lst)):
if 1&(lst[i]>>now)==1:
anslst.append(lst[i])
if len(anslst)>=k:
lst=anslst
now-=1
# print(lst)
ans=lst[0]
for i in range(k):
ans=ans&lst[i]
print(ans) | import sys
from collections import *
import heapq
import math
# from math import gcd
import bisect
import copy
from itertools import permutations,accumulate,combinations,product
def input():
return sys.stdin.readline()
def ruiseki(lst):
return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
rlst=ruiseki(a)
# print(rlst)
lst=[]
for i in range(n+1):
for j in range(i+1,n+1):
# print(i,j)
lst.append(rlst[j]-rlst[i])
# print(lst)
tmp=math.log(rlst[-1],2)
now=int(tmp)
while now>=0:
anslst=[]
for i in range(len(lst)):
if 1&(lst[i]>>now)==1:
anslst.append(lst[i])
if len(anslst)>=k:
lst=anslst
now-=1
# print(lst)
ans=lst[0]
for i in range(k):
ans=ans&lst[i]
print(ans) | p03215 |
from itertools import accumulate as ac
from functools import reduce
n,k=list(map(int,input().split()))
*ac,=ac([0]+list(map(int,input().split())))
l=[ac[j]-ac[i] for i in range(n+1) for j in range(i+1,n+1)]
count_bits=lambda n:sum([x&n==n for x in l])
ans=0
for i in range(41)[::-1]:
if count_bits(ans|1<<i)>=k:
ans|=1<<i
print(ans) | from itertools import accumulate as ac
n,k=list(map(int,input().split()))
*a,=ac([0]+list(map(int,input().split())))
l=[a[j]-a[i] for i in range(n+1) for j in range(i+1,n+1)]
f=lambda n:sum([x&n==n for x in l])
ans=0
for i in range(41)[::-1]:
if f(ans|1<<i)>=k:
ans|=1<<i
print(ans) | p03215 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
stand_bit = [set() for i in range(64)]
acc = [0 for i in range(n+1)]
acc[0] = 0
for i in range(1, n+1):
acc[i] += a[i-1] + acc[i-1]
set_ans = set()
for i in range(n):
for j in range(i, n):
set_ans.add(acc[j+1] - acc[i])
s = "{:b}".format(acc[j+1] - acc[i])
s = s.zfill(64)
for num, bit in enumerate(s):
if bit == "1":
stand_bit[num].add(acc[j+1] - acc[i])
for i in range(64):
if len(set_ans & stand_bit[i]) >= k:
set_ans &= stand_bit[i]
ans_list = list(set_ans)
ans = ans_list[0]
for i in ans_list:
ans &= i
print(ans)
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
stand_bit = [set() for i in range(64)]
acc = [0 for i in range(n+1)]
acc[0] = 0
for i in range(1, n+1):
acc[i] += a[i-1] + acc[i-1]
set_ans = set()
for i in range(n):
for j in range(i, n):
set_ans.add(acc[j+1] - acc[i])
s = acc[j+1] - acc[i]
index = 63
while s :
if s & 1:
stand_bit[index].add(acc[j+1] - acc[i])
s = s >> 1
index -= 1
for i in range(64):
if len(set_ans & stand_bit[i]) >= k:
set_ans &= stand_bit[i]
ans_list = list(set_ans)
ans = ans_list[0]
for i in ans_list:
ans &= i
print(ans)
| p03215 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
stand_bit = [set() for i in range(64)]
acc = [0 for i in range(n+1)]
acc[0] = 0
for i in range(1, n+1):
acc[i] += a[i-1] + acc[i-1]
set_ans = set()
for i in range(n):
for j in range(i, n):
set_ans.add(acc[j+1] - acc[i])
s = acc[j+1] - acc[i]
index = 63
while s :
if s & 1:
stand_bit[index].add(acc[j+1] - acc[i])
s = s >> 1
index -= 1
for i in range(64):
if len(set_ans & stand_bit[i]) >= k:
set_ans &= stand_bit[i]
ans_list = list(set_ans)
ans = ans_list[0]
for i in ans_list:
ans &= i
print(ans)
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
stand_bit = [set() for i in range(42)]
acc = [0 for i in range(n+1)]
acc[0] = 0
for i in range(1, n+1):
acc[i] += a[i-1] + acc[i-1]
set_ans = set()
for i in range(n):
for j in range(i, n):
set_ans.add(acc[j+1] - acc[i])
s = acc[j+1] - acc[i]
index = 41
while s :
if s & 1:
stand_bit[index].add(acc[j+1] - acc[i])
s = s >> 1
index -= 1
for i in range(42):
if len(set_ans & stand_bit[i]) >= k:
set_ans &= stand_bit[i]
ans_list = list(set_ans)
ans = ans_list[0]
for i in ans_list:
ans &= i
print(ans)
| p03215 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
stand_bit = [set() for i in range(42)]
acc = [0 for i in range(n+1)]
acc[0] = 0
for i in range(1, n+1):
acc[i] += a[i-1] + acc[i-1]
set_ans = set()
for i in range(n):
for j in range(i, n):
set_ans.add(acc[j+1] - acc[i])
s = acc[j+1] - acc[i]
index = 41
while s:
if s & 1:
stand_bit[index].add(acc[j+1] - acc[i])
s = s >> 1
index -= 1
for i in range(42):
if len(set_ans & stand_bit[i]) >= k:
set_ans &= stand_bit[i]
ans_list = list(set_ans)
ans = ans_list[0]
for i in ans_list:
ans &= i
print(ans)
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
stand_bit = [set() for i in range(42)]
acc = [0 for i in range(n+1)]
for i in range(1, n+1):
acc[i] += a[i-1] + acc[i-1]
set_ans = set()
for i in range(n):
for j in range(i, n):
tmp = acc[j+1] - acc[i]
set_ans.add(tmp)
s = tmp
index = 41
while s:
if s & 1:
stand_bit[index].add(tmp)
s = s >> 1
index -= 1
for i in range(42):
if len(set_ans & stand_bit[i]) >= k:
set_ans &= stand_bit[i]
ans_list = list(set_ans)
ans = ans_list[0]
for i in ans_list:
ans &= i
print(ans)
| p03215 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N,K = LI()
A = LI()
sa = list(itertools.accumulate([0]+A))
b = []
for i in range(N):
for j in range(i+1,N+1):
b.append(sa[j]-sa[i])
b.sort(reverse=True)
max_b = (max(b)).bit_length()
mask = 0
for i in range(max_b-1,-1,-1):
bit = 2**i
cnt = 0
for x in b:
if x & mask == mask:
cnt += (x & bit > 0)
if cnt >= K:
mask += bit
print (mask)
| import sys,queue,math,copy,itertools,bisect,collections,heapq
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
N,K = LI()
A = LI()
sa = list(itertools.accumulate([0]+A))
b = []
for i in range(N):
for j in range(i+1,N+1):
b.append(sa[j]-sa[i])
#b.sort(reverse=True)
max_b = max(b).bit_length()
mask = 0
for i in range(max_b-1,-1,-1):
bit = 2**i
cnt = 0
for x in b:
if x & mask == mask:
cnt += (x & bit > 0)
if cnt >= K:
mask += bit
print (mask) | p03215 |
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
cums = [0]
for a in A:
cums.append(cums[-1] + a)
vs = []
for l in range(N):
for r in range(l+1,N+1):
vs.append(cums[r] - cums[l])
vs.sort(reverse=True)
for i in range(100,-1,-1):
tmps = []
for v in vs:
if v&(1<<i):
tmps.append(v)
if len(tmps) >= K:
vs = tmps
if len(vs) < K:
print((0))
else:
ans = vs[0]
for v in vs[1:K]:
ans &= v
print(ans) | N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
B = []
for i,a in enumerate(A):
k = 0
for c in A[i:]:
k += c
B.append(k)
ans = 0
for i in range(40,-1,-1):
C = []
for b in B:
if b&(1<<i):
C.append(b)
if len(C) >= K:
B = C
ans += 2**i
print(ans) | p03215 |
from itertools import accumulate, combinations
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
sum_A = sum(A)
B = [0] + list(accumulate(A))
cand = []
for i in range(N+1):
for j in range(i+1,N+1):
cand.append(B[j] - B[i])
cand.sort(reverse=True)
length = len(bin(cand[K-1])[2:])
num = []
for c in cand:
if len(bin(c)[2:]) < length:
break
num.append(c)
ans = 0
for item in combinations(num,K):
n = 0
for i in range(len(item)):
if i == 0:
n = item[i]
n &= item[i]
ans = max(ans, n)
print(ans)
if __name__ == "__main__":
main() | from itertools import accumulate
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
sum_A = sum(A)
B = [0] + list(accumulate(A))
cand = []
for i in range(N+1):
for j in range(i+1,N+1):
cand.append(B[j] - B[i])
ans = 0
for i in range(40):
bit = 1 << (39 - i)
cnt = 0
new_cand = []
for c in cand:
if c & bit:
cnt += 1
new_cand.append(c)
if cnt >= K:
ans += 2 ** (39 - i)
cand = new_cand
print(ans)
if __name__ == "__main__":
main() | p03215 |
import itertools
nk = input().split()
seisuuretu = input().split()
for i in range(len(seisuuretu)):
seisuuretu[i] = int(seisuuretu[i])
all_seisuuretu = []
for start in range(len(seisuuretu) + 1):
for end in range(len(seisuuretu) + 1):
if start < end:
all_seisuuretu.append(seisuuretu[start:end])
beautiful_list = []
for pattern in all_seisuuretu:
beautiful_list.append(sum(pattern))
select_index = []
for index in itertools.permutations(list(range(len(beautiful_list))), r=int(nk[1])):
select_index.append(index)
result = []
for temp_index in select_index:
count = 0
for one_index in temp_index:
if count == 0:
temp_and = beautiful_list[one_index]
else:
temp_and = temp_and & beautiful_list[one_index]
count += 1
result.append(temp_and)
print((max(result)))
| nk = input().split()
seisuuretu = input().split()
for i in range(len(seisuuretu)):
seisuuretu[i] = int(seisuuretu[i])
all_seisuuretu = []
for start in range(len(seisuuretu) + 1):
for end in range(len(seisuuretu) + 1):
if start < end:
all_seisuuretu.append(seisuuretu[start:end])
beautiful_list = []
for pattern in all_seisuuretu:
beautiful_list.append(sum(pattern))
for i in range(len(beautiful_list)):
beautiful_list[i] = bin(beautiful_list[i])[2:]
list_max = []
for i in beautiful_list:
list_max.append(len(i))
list_max = max(list_max)
list_max = -list_max
status = True
while status == True:
temp = []
count = 0
for i in beautiful_list:
try:
if int(i[list_max]) == 1:
count += 1
temp.append(i)
except:
continue
if count > int(nk[1]):
list_max += 1
beautiful_list = temp
elif count == int(nk[1]):
beautiful_list = temp
for num in range(len(beautiful_list)):
if num == 0:
ronriseki = int(beautiful_list[num], 2)
else:
ronriseki = ronriseki & int(beautiful_list[num], 2)
print(ronriseki)
status = False
elif list_max == -1:
for num in range(len(beautiful_list)):
if num == 0:
ronriseki = int(beautiful_list[num], 2)
else:
ronriseki = ronriseki & int(beautiful_list[num], 2)
print(ronriseki)
status = False
else:
list_max += 1
| p03215 |
# -*- coding: utf-8 -*-
def inpl(): return list(map(int, input().split()))
N, K = inpl()
A = inpl()
tmp = 0
S = [0]*N
Q = []
for i in range(N):
tmp += A[i]
S[i] = tmp
Q.append(tmp)
tmp = 0
for i in range(1, N):
tmp = S[i-1]
for j in range(i, N):
#print(i, j)
v = S[j] -S[i-1]
Q.append(v)
res = 0
while True:
ok = 0
for i in range(40):
num = res + int("1" + "0"*i, 2)
tmp = 0
for j in range(len(Q)):
if num & Q[j] == num:
tmp += 1
if tmp >= K:
ok = num
if res < ok:
res = ok
else:
break
print(res) | # -*- coding: utf-8 -*-
def inpl(): return list(map(int, input().split()))
N, K = inpl()
A = inpl()
tmp = 0
S = [0]*N
Q = []
for i in range(N):
tmp += A[i]
S[i] = tmp
Q.append(tmp)
tmp = 0
for i in range(1, N):
tmp = S[i-1]
for j in range(i, N):
#print(i, j)
v = S[j] -S[i-1]
Q.append(v)
res = 0
L = len(Q)
I = len(bin(sum(A))) - 2
while True:
ok = 0
for i in range(I):
num = res + 2**i
tmp = 0
for j in range(L):
if num & Q[j] == num:
tmp += 1
if tmp >= K:
ok = num
I = len(bin(res - ok)) - 2
if res < ok & ok > 0:
res = ok
else:
break
print(res) | p03215 |
from collections import defaultdict
from itertools import accumulate
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
Acum = [0]
Acum.extend(accumulate(A))
cnt = defaultdict(int)
for i in range(n):
for j in range(i+1, n+1):
beauty = Acum[j]-Acum[i]
cnt[beauty] += 1
x = 0
for t in reversed(list(range(41))):
y = 1 << t
cnt_k = 0
for beauty, c in list(cnt.items()):
if (x+y) & beauty == (x+y):
cnt_k += c
if k <= cnt_k:
x += y
print(x)
| from collections import defaultdict
from itertools import accumulate
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
Acum = [0]
Acum.extend(accumulate(A))
cnt = defaultdict(int)
for i in range(n):
for j in range(i+1, n+1):
beauty = Acum[j]-Acum[i]
cnt[beauty] += 1
def check(x):
res = 0
for beauty, c in list(cnt.items()):
if x & beauty == x:
res += c
return k <= res
L = 0
R = 1 << 40
while L != R-1:
M = (L+R)//2
if check(M):
L = M
else:
R = M
print(L) | p03215 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
ruiseki = [0] * (n + 1)
for i in range(n):
ruiseki[i+1] = ruiseki[i] + a[i]
li = []
for i in range(n):
for j in range(i, n):
tmp = format(ruiseki[j + 1] - ruiseki[i], '040b')
li.append(tmp)
for i in range(40):
cnt = 0
new_li = []
for j in range(len(li)):
if li[j][i] == "1":
new_li.append(li[j])
cnt += 1
if cnt >= k:
li = new_li[0:]
ans = 2**41 -1
for i in range(k):
ans = ans & int(li[i], 2)
print(ans) | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
li = []
for i in range(n):
num = 0
for j in range(i, n):
num += a[j]
li.append(num)
ans = 0
for i in range(40)[::-1]:
bit = 2 ** i
new_li = [num for num in li if num&bit != 0]
if len(new_li) >= k:
li = new_li[0:]
ans += bit
print(ans) | p03215 |
from itertools import accumulate
from itertools import combinations
N, K = [int(x) for x in input().strip().split(" ")]
As = [0] + [int(x) for x in input().strip().split(" ")]
aAs = list(accumulate(As))
keta = 41
d = [set() for _ in range(41)]
for i, j in combinations(list(range(N)), 2):
rr = aAs[j + 1] - aAs[i]
rr = "{0:041d}".format(int(bin(rr)[2:]))
for k in range(keta):
if rr[k] == "1":
d[k].add((i, j))
for i in range(N):
j = i
rr = As[i+1]
rr = "{0:041d}".format(int(bin(rr)[2:]))
for k in range(keta):
if rr[k] == "1":
d[k].add((i, j))
candidates = None
rr = 0
for i, ss in enumerate(d):
if len(ss) < K:
continue
if candidates == None:
candidates = ss
rr += pow(2, 40-i)
else:
xx = ss & candidates
if len(xx) < K:
continue
candidates = xx
rr += pow(2, 40-i)
print(rr)
| N, K = list(map(int, input().split()))
from itertools import accumulate
As = [0] + list(map(int, input().split()))
As = list(accumulate(As))
L = len(bin(As[-1]))-2
xs = []
for i in range(N+1):
for j in range(i+1, N+1):
xs.append(As[j] - As[i])
xs.sort()
ts = set(range(N*(N+1)//2))
for j in range(L-1,-1,-1):
nts = set()
for i in ts:
if (xs[i]>>j)%2:
nts.add(i)
if len(nts) >= K:
ts = nts
c = 0
r = 0
for i in ts:
c += 1
if r == 0:
r = xs[i]
else:
r = r&xs[i]
if c == K:
break
print(r)
| p03215 |
p = int(eval(input()))
def div(a, b):
n = len(a)
m = len(b)
res = [0] * (n - m + 1)
tmp = pow(b[-1], p - 2, p)
for i in range(n - m, -1, -1):
t = a[i + m - 1] * tmp % p
res[i] = t
for j in range(m):
a[i + j] = (a[i + j] - t * b[j]) % p
return res
a = list(map(int, input().split()))
ans = [0] * p
f = [0] * (p + 1)
f[0] = 1
for i in range(p):
for j in range(p, 0, -1):
f[j] += f[j - 1]
f[j - 1] = -f[j - 1] * i
f[j] %= p
for i in range(p):
if a[i] == 1:
fm = div(f[:], [-i, 1])
t = 1
r = 0
for v in fm:
r += v * t
t = t * i % p
t = pow(r, p - 2, p)
for j in range(len(fm)):
ans[j] += fm[j] * t % p
for i in range(p):
ans[i] %= p
print((' '.join(map(str, ans))))
| p = int(eval(input()))
def div(a, b):
n = len(a)
m = len(b)
res = [0] * (n - m + 1)
tmp = pow(b[-1], p - 2, p)
for i in range(n - m, -1, -1):
t = a[i + m - 1] * tmp % p
res[i] = t
for j in range(m):
a[i + j] = (a[i + j] - t * b[j]) % p
return res
a = list(map(int, input().split()))
ans = [0] * p
f = [0] * (p + 1)
f[0] = 1
for i in range(p):
for j in range(p, 0, -1):
f[j] += f[j - 1]
f[j - 1] = -f[j - 1] * i
f[j] %= p
for i in range(p):
if a[i] == 1:
fm = div(f[:], [-i, 1])
t = 1
r = 0
for v in fm:
r += v * t
t = t * i % p
t = pow(r, p - 2, p)
for j in range(len(fm)):
ans[j] += fm[j] * t
for i in range(p):
ans[i] %= p
print((' '.join(map(str, ans))))
| p02950 |
p = eval(input())
a = list(map(int, input().strip().split()))
b = [0] * p
p2 = p * p
s = []
for i in range(p):
if a[i]: s.append(i)
ncr = [[0 for i in range(p)] for j in range(p)]
for i in range(p):
ncr[i][0] = ncr[i][i] = 1
ncr[i][1] = i
for n in range(2, p):
for r in range(2, n):
ncr[n][r] = ncr[n - 1][r] + ncr[n - 1][r - 1]
if (ncr[n][r] >= p): ncr[n][r] -= p
jpow = [[0 for i in range(p)] for j in range(p)]
jpow[0][0] = 1
for i in range(1, p):
val = 1
for j in range(p):
jpow[i][j] = val
val *= i
if (val >= p2): val %= p
for r in range(1, p):
for j in s:
x = ncr[p - 1][r]
x *= jpow[j][p - 1 - r]
if (x >= p2): x %= p
if (p - r) & 1: b[r] -= x
else: b[r] += x
if b[r] >= p or b[r] < 0: b[r] %= p
if a[0]: b[0] = 1
print(' '.join(map(str, b))) | p = eval(input())
a = list(map(int, input().strip().split()))
b = [0] * p
p2 = p * p
s = []
for i in range(p):
if a[i]: s.append(i)
ncr = [[0 for i in range(p)] for j in range(p)]
for i in range(p):
ncr[i][0] = ncr[i][i] = 1
ncr[i][1] = i
for n in range(2, p):
for r in range(2, n):
ncr[n][r] = ncr[n - 1][r] + ncr[n - 1][r - 1]
if (ncr[n][r] >= p): ncr[n][r] -= p
jpow = [[0 for i in range(p)] for j in range(p)]
jpow[0][0] = 1
for i in range(1, p):
val = 1
for j in range(p):
jpow[i][j] = val
val *= i
if (val >= p): val %= p
for r in range(1, p):
for j in s:
x = ncr[p - 1][r]
x *= jpow[j][p - 1 - r]
if (x >= p2): x %= p
if (p - r) & 1: b[r] -= x
else: b[r] += x
if b[r] >= p or b[r] < 0: b[r] %= p
if a[0]: b[0] = 1
print(' '.join(map(str, b))) | p02950 |
#import sys
#input = sys.stdin.readline
def getInv(N,Q):
inv = [0] * (N + 1)
inv[1] = 1
for i in range(2, N + 1):
inv[i] = (-(Q // i) * inv[Q % i]) % Q
return inv
def getCmb(N,Q):
inv = getInv(N,Q)
nCr = [1] * (N + 1)
for i in range(1, N + 1):
nCr[i] = (nCr[i - 1] * (N - i + 1) * inv[i]) % Q
return nCr
def main():
p = int( eval(input()))
A = list( map( int, input().split()))
ANS = [A[0]]
pm1Ck = getCmb(p-1,p)
for k in range(1,p):
now = 0
for i in range(p):
now -= A[i]*pow(p-i,p-1-k,p)*pm1Ck[k]
now %= p
ANS.append(now)
print(( " ".join( map( str, ANS))))
# for i in range(p):
# now = 0
# for k in range(p):
# now += ANS[k]*pow(i,k,p)
# now %= p
# print(A[i], now)
if __name__ == '__main__':
main()
| #import sys
#input = sys.stdin.readline
def getInv(N,Q):
inv = [0] * (N + 1)
inv[1] = 1
for i in range(2, N + 1):
inv[i] = (-(Q // i) * inv[Q % i]) % Q
return inv
def getCmb(N,Q):
inv = getInv(N,Q)
nCr = [1] * (N + 1)
for i in range(1, N + 1):
nCr[i] = (nCr[i - 1] * (N - i + 1) * inv[i]) % Q
return nCr
def main():
p = int( eval(input()))
A = list( map( int, input().split()))
ANS = [A[0]]
pm1Ck = getCmb(p-1,p)
Pow = [[0]*p for _ in range(p+1)]
for i in range(p+1):
Pow[i][0] = 1
for i in range(1,p):
for k in range(p-1):
Pow[i][k+1] = Pow[i][k]*i%p
for k in range(1,p):
now = 0
for i in range(p):
now -= A[i]*Pow[p-i][p-1-k]*pm1Ck[k]
# now -= A[i]*pow(p-i,p-1-k,p)*pm1Ck[k]
now %= p
ANS.append(now)
print(( " ".join( map( str, ANS))))
# for i in range(p):
# now = 0
# for k in range(p):
# now += ANS[k]*pow(i,k,p)
# now %= p
# print(A[i], now)
if __name__ == '__main__':
main()
| p02950 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
p = int(eval(input()))
a = [int(i) for i in input().split()]
ret = [0] * p
fac = [1]
inv = [1]
power = [0] * p
for i in range(1, p) :
fac.append(fac[-1] * i % p)
inv.append(pow(fac[-1], p - 2, p))
for i in range(p) :
if a[i] == 0 :
continue
ret[0] += 1
for j in range(p) :
ret[j] += -fac[p-1]*inv[p-1-j]*inv[j]*pow(-i, p-1-j, p)%p
ret[j] %= p
print((' '.join(map(str, ret)))) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
p = int(eval(input()))
a = [int(i) for i in input().split()]
ret = [0] * p
fac = [1]
inv = [1]
for i in range(1, p) :
fac.append(fac[-1] * i % p)
inv.append(pow(fac[-1], p - 2, p))
for i in range(p) :
if a[i] == 0 :
continue
ret[0] += 1
power = 1
for j in range(p-1, -1, -1) :
ret[j] += -fac[p-1]*inv[p-1-j]*inv[j]*power%p
ret[j] %= p
power *= -i
power %= p
print((' '.join(map(str, ret)))) | p02950 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
p = int(eval(input()))
a = list(map(int, input().split()))
### 素数の逆元とCombination
M = p
N = 10**4 # 必要なテーブルサイズ
g1 = [None] * (N+1) # 元テーブル
g2 = [None] * (N+1) #逆元テーブル
inverse = [None] * (N+1) #逆元テーブル計算用テーブル
g1[0] = g1[1] = g2[0] = g2[1] = 1
inverse[0], inverse[1] = [0, 1]
for i in range( 2, N + 1 ):
g1[i] = ( g1[i-1] * i ) % M
inverse[i] = ( -inverse[M % i] * (M//i) ) % M # ai+b==0 mod M <=> i==-b*a^(-1) <=> i^(-1)==-b^(-1)*aより
g2[i] = (g2[i-1] * inverse[i]) % M
def cmb(n, r, M):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return (g1[n] * g2[r] * g2[n-r]) % M
ans = [0]*p
for i,num in enumerate(a):
if num==0:
continue
for j in range(p):
ans[j] += -cmb(p-1,j,M) * pow(-i,p-1-j)
ans[0] += 1
for i in range(p):
ans[i] %= M
write(" ".join(map(str, ans))) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
p = int(eval(input()))
a = list(map(int, input().split()))
### 素数の逆元とCombination
M = p
N = 10**4 # 必要なテーブルサイズ
g1 = [None] * (N+1) # 元テーブル
g2 = [None] * (N+1) #逆元テーブル
inverse = [None] * (N+1) #逆元テーブル計算用テーブル
g1[0] = g1[1] = g2[0] = g2[1] = 1
inverse[0], inverse[1] = [0, 1]
for i in range( 2, N + 1 ):
g1[i] = ( g1[i-1] * i ) % M
inverse[i] = ( -inverse[M % i] * (M//i) ) % M # ai+b==0 mod M <=> i==-b*a^(-1) <=> i^(-1)==-b^(-1)*aより
g2[i] = (g2[i-1] * inverse[i]) % M
def cmb(n, r, M):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return (g1[n] * g2[r] * g2[n-r]) % M
ans = [0]*p
for i,num in enumerate(a):
if num==0:
continue
for j in range(p):
ans[j] += -cmb(p-1,j,M) * pow(-i,p-1-j,M)
ans[j] %= M
ans[0] += 1
for i in range(p):
ans[i] %= M
write(" ".join(map(str, ans))) | p02950 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
p = int(eval(input()))
a = list(map(int, input().split()))
### 素数の逆元とCombination
M = p
N = 10**4 # 必要なテーブルサイズ
g1 = [None] * (N+1) # 元テーブル
g2 = [None] * (N+1) #逆元テーブル
inverse = [None] * (N+1) #逆元テーブル計算用テーブル
g1[0] = g1[1] = g2[0] = g2[1] = 1
inverse[0], inverse[1] = [0, 1]
for i in range( 2, N + 1 ):
g1[i] = ( g1[i-1] * i ) % M
inverse[i] = ( -inverse[M % i] * (M//i) ) % M # ai+b==0 mod M <=> i==-b*a^(-1) <=> i^(-1)==-b^(-1)*aより
g2[i] = (g2[i-1] * inverse[i]) % M
def cmb(n, r, M):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return (g1[n] * g2[r] * g2[n-r]) % M
ans = [0]*p
for i,num in enumerate(a):
if num==0:
continue
for j in range(p):
ans[j] += -cmb(p-1,j,M) * pow(-i,p-1-j,M)
ans[j] %= M
ans[0] += 1
for i in range(p):
ans[i] %= M
write(" ".join(map(str, ans))) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
p = int(eval(input()))
a = list(map(int, input().split()))
### 素数の逆元とCombination
M = p
N = 10**4 # 必要なテーブルサイズ
g1 = [None] * (N+1) # 元テーブル
g2 = [None] * (N+1) #逆元テーブル
inverse = [None] * (N+1) #逆元テーブル計算用テーブル
g1[0] = g1[1] = g2[0] = g2[1] = 1
inverse[0], inverse[1] = [0, 1]
for i in range( 2, N + 1 ):
g1[i] = ( g1[i-1] * i ) % M
inverse[i] = ( -inverse[M % i] * (M//i) ) % M # ai+b==0 mod M <=> i==-b*a^(-1) <=> i^(-1)==-b^(-1)*aより
g2[i] = (g2[i-1] * inverse[i]) % M
def cmb(n, r, M):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return (g1[n] * g2[r] * g2[n-r]) % M
ans = [0]*p
for i,num in enumerate(a):
if num==0:
continue
val = 1
for j in reversed(list(range(p))):
ans[j] += -cmb(p-1,j,M) * val #pow(-i,p-1-j,M)
# ans[j] += -cmb(p-1,j,M) * pow(-i,p-1-j,M)
ans[j] %= M
val *= -i
val %= M
ans[0] += 1
for i in range(p):
ans[i] %= M
write(" ".join(map(str, ans))) | p02950 |
p = int(eval(input()))
a = list(map(int,input().split()))
lis = [0] * (p+1)
for i in range(p):
if i == 0:
lis[1] = 1
lis[0] = 0
else:
nlis = [0] * (p+1)
for j in range(p+1):
nlis[j] += lis[j] * (-1 * i)
if j != 0:
nlis[j] += lis[j-1]
lis = nlis
#print (lis) = (x-0)*(x-1)*…*(x-p+1)の各項の係数
#ラグランジュ補完を実際に計算していく
#参考 https://mathtrain.jp/hokan
ans = [0] * p
for i in range(p):
#fi(x)を計算 (x-i)でlisを割る
if a[i] == 0:
continue
nlis = [0] * p
for j in range(p-1,-1,-1):
if j == p-1:
nlis[j] = lis[j+1]
else:
nlis[j] = (lis[j+1] - nlis[j+1] * (-1 * i))
for j in range(p):
ans[j] += nlis[j]
for i in range(p):
ans[i] = (p - ans[i]) % p
print((" ".join(map(str,ans))))
|
p = int(eval(input()))
a = list(map(int,input().split()))
lis = [0] * (p+1)
for i in range(p):
if i == 0:
lis[1] = 1
lis[0] = 0
else:
nlis = [0] * (p+1)
for j in range(p+1):
nlis[j] += lis[j] * (-1 * i)
if j != 0:
nlis[j] += lis[j-1]
nlis[j] %= p
lis = nlis
#print (lis) = (x-0)*(x-1)*…*(x-p+1)の各項の係数
#ラグランジュ補完を実際に計算していく
#参考 https://mathtrain.jp/hokan
ans = [0] * p
for i in range(p):
#fi(x)を計算 (x-i)でlisを割る
if a[i] == 0:
continue
nlis = [0] * p
for j in range(p-1,-1,-1):
if j == p-1:
nlis[j] = lis[j+1]
else:
nlis[j] = (lis[j+1] - nlis[j+1] * (-1 * i)) % p
for j in range(p):
ans[j] += nlis[j]
for i in range(p):
ans[i] = (p - ans[i]) % p
print((" ".join(map(str,ans)))) | p02950 |
#!/usr/bin/env python3
import sys
import functools
INF = float("inf")
def solve(p: int, a: "List[int]"):
N = p
MOD = p
fac = [0]*N
finv = [0]*N
inv = [0]*N
def cmb_init():
fac[0] = 1
fac[1] = 1
finv[0] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, N):
fac[i] = fac[i-1]*i % MOD
inv[i] = -inv[MOD % i]*(MOD//i) % MOD
finv[i] = finv[i-1]*inv[i] % MOD
def cmb(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k]*finv[n-k] % MOD) % MOD
cmb_init()
b = [0]*p
for ai, av in enumerate(a):
if av == 1:
for i in range(p):
b[i] += -cmb(p-1, i) * pow(-ai, p-i-1)
b[i] %= p
b[0] += 1
b[0] %= p
print(*b, sep=" ")
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
p = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(p-1-0+1)] # type: "List[int]"
solve(p, a)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
import functools
INF = float("inf")
def solve(p: int, a: "List[int]"):
N = p+1
MOD = p
inv = [0]*N
inv[1] = 1
for i in range(2, N):
inv[i] = -inv[MOD % i]*(MOD//i) % MOD
b = [0]*p
for ai, av in enumerate(a):
if av == 0:
continue
c = 1
d = 1
for i in range(p-1, -1, -1):
b[i] += - c * d
b[i] %= p
c = c * i * inv[p-i] % p
d = -d*ai % p
b[0] += 1
b[0] %= p
print(*b, sep=" ")
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
p = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(p-1-0+1)] # type: "List[int]"
solve(p, a)
if __name__ == '__main__':
main()
| p02950 |
def f_polynomal_construction(P, A):
class Combination(object):
"""参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb"""
__slots__ = ["mod", "factorial", "inverse"]
def __init__(self, max_n: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_n + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], mod - 2, mod))
for i in range(max_n, 0, -1):
inv_append(inv[-1] * i % mod)
self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]
def combination(self, n, r):
if n < 0 or r < 0 or n < r:
return 0
return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod
combination = Combination(P - 1, P)
comb = [combination.combination(P - 1, i) for i in range(P)]
ans = [0] * P
for j, a in enumerate(A):
if a == 0:
continue
# 1-(x-j)^{p-1} = 1 - \sum_{k=0}^{p-1} comb(p-1, p-k-1) * x^{p-k-1} * (-j)^k
# なので、定数項に1を足し、x^k の係数から各々引く
# pow(-j, k, P) としたいが、時間がかかるので tmp に掛けていくことにする
ans[0] += 1
tmp = 1
for k in range(P):
index = P - k - 1
# if k > 0:
# tmp *= (-j)
# tmp %= P
# ans[index] -= comb[index] * tmp
ans[index] -= comb[index] * pow(-j, k, P)
ans[index] %= P
return ' '.join(map(str, ans))
P = int(eval(input()))
A = [int(i) for i in input().split()]
print((f_polynomal_construction(P, A))) | def f_polynomal_construction(P, A):
class Combination(object):
"""参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb"""
__slots__ = ["mod", "factorial", "inverse"]
def __init__(self, max_n: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_n + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], mod - 2, mod))
for i in range(max_n, 0, -1):
inv_append(inv[-1] * i % mod)
self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]
def combination(self, n, r):
if n < 0 or r < 0 or n < r:
return 0
return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod
combination = Combination(P - 1, P)
comb = [combination.combination(P - 1, i) for i in range(P)]
ans = [0] * P
for j, a in enumerate(A):
if a == 0:
continue
# 1-(x-j)^{p-1} = 1 - \sum_{k=0}^{p-1} comb(p-1, p-k-1) * x^{p-k-1} * (-j)^k
# なので、定数項に1を足し、x^k の係数から各々引く
# pow(-j, k, P) としたいが、時間がかかるので tmp に掛けていくことにする
ans[0] += 1
tmp = 1
for k in range(P):
index = P - k - 1
if k > 0:
tmp *= (-j)
tmp %= P
ans[index] -= comb[index] * tmp
ans[index] %= P
return ' '.join(map(str, ans))
P = int(eval(input()))
A = [int(i) for i in input().split()]
print((f_polynomal_construction(P, A))) | p02950 |
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return list(map(int,input().split()))
def lmp(): return list(map(int,input().split()))
l,r,d=mp()
ans=0
for i in range(l,r+1):
if i%d==0:
ans+=1
print(ans) | a,b,c=list(map(int,input().split()))
print((b//c-(a-1)//c)) | p02606 |
l, r, d = list(map(int, input().split()))
print((r // d - -(-l // d) + 1))
|
L, R, d = list(map(int, input().split()))
print((R // d - (L - 1) // d))
| p02606 |
import sys
read = sys.stdin.read
from itertools import accumulate
def main():
l, r, d = list(map(int, input().split()))
res = 0
for i1 in range(l, r + 1):
res += i1 % d == 0
print(res)
if __name__ == '__main__':
main() | def main():
l, r, d = list(map(int, input().split()))
res = r // d - (l-1) // d
print(res)
if __name__ == '__main__':
main()
| p02606 |
from math import gcd
from math import factorial as f
from math import ceil, floor, sqrt
import math
import bisect
import re
import heapq
from copy import deepcopy
import itertools
from itertools import permutations
from sys import exit
ii = lambda: int(eval(input()))
mi = lambda: list(map(int, input().split()))
li = lambda: list(map(int, input().split()))
yes = "Yes"
no = "No"
def main():
l, r, d = mi()
cnt = 0
tmp = d
while tmp <= r:
if tmp <= r and tmp >= l:
cnt += 1
tmp += d
print(cnt)
main()
| l, r, d = list(map(int, input().split()))
cnt = 0
tmp = d
while tmp <= r:
if tmp <= r and tmp >= l:
cnt += 1
tmp += d
print(cnt) | p02606 |
l, r, d = list(map(int, input().split()))
cnt = 0
for i in range(l, r+1):
# print(i)
if i % d == 0:
cnt += 1
print(cnt)
| l, r, d = list(map(int, input().split()))
cnt = 0
for i in range(l, r+1):
if i % d == 0:
cnt += 1
print(cnt) | p02606 |
#!/usr/bin/env python3
l, r, d = list(map(int, input().split()))
print((r//d - (l-1)//d))
| #!/usr/bin/env pypy
l, r, d = list(map(int, input().split()))
print((r//d - (l-1)//d))
| p02606 |
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
l,r,d = LI()
ans = 0
for i in range(l, r+1):
if i % d == 0:
ans += 1
print(ans) | #!/usr/bin/env python3
l, r, d = list(map(int, input().split()))
n = (l-1) // d + 1
m = r // d
print((m-n+1)) | p02606 |
L,R,d = list(map(int,input().split()))
print((len([i for i in range(L,R+1) if i % d == 0]))) | L,R,d=list(map(int,input().split()));print((R//d-(L-1)//d)) | p02606 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(L, R, D):
ans = 0
for i in range(L, R+1):
if i % D == 0:
ans += 1
return ans
def main():
L, R, D = read_int_n()
print(slv(L, R, D))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(L, R, D):
return R // D - (L-1) // D
def main():
L, R, D = read_int_n()
print(slv(L, R, D))
if __name__ == '__main__':
main()
| p02606 |
L, R, d = list(map(int, input().split()))
result = 0
for i in range(L, R + 1):
if i % d == 0:
result += 1
print(result)
| L, R, d = list(map(int, input().split()))
print((R // d - (L - 1) // d))
| p02606 |
import sys
input = sys.stdin.readline
def main():
ans = 0
l,r,d = list(map(int, input().split()))
ans = (r//d) - (l//d)
if l%d == 0:
ans += 1
print(ans)
if __name__ == '__main__':
main() | l, r, d = list(map(int, input().split()))
print((r//d-(l-1)//d)) | p02606 |
# -*- coding: utf-8 -*-
# 標準入力を取得
L, R, d = list(map(int, input().split()))
# 求解処理
ans = R // d - (L - 1) // d
# 結果出力
print(ans)
| # -*- coding: utf-8 -*-
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
L, R, d = list(map(int, input().split()))
return L, R, d
def main(L: int, R: int, d: int) -> None:
"""
メイン処理.
Args:\n
L (int): 整数（1 <= L <= R <= 100）
R (int): 整数（1 <= L <= R <= 100）
d (int): 整数（1 <= d <= 100）
"""
# 求解処理
ans = R // d - (L - 1) // d
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
L, R, d = get_input()
# メイン処理
main(L, R, d)
| p02606 |
l,r,d=list(map(int,input().split()))
cnt=0
for i in range(l,r+1):
for j in range(1,101):
if d*j==i:
cnt+=1
break
print(cnt)
| l, r, d = list(map(int, input().split()))
ans = r // d - (l - 1) // d
print(ans)
| p02606 |
l,r,d = list(map(int, input().split()))
ans = 0
while l <= r:
if l%d == 0:
ans += 1
l += 1
print(ans) | l,r,d = list(map(int, input().split()))
ans = r//d - (l-1)//d
print(ans) | p02606 |
import sys
input = sys.stdin.readline
l,r,d=list(map(int,input().split()))
ans = 0
for i in range(l,r+1):
if i%d==0:
ans+=1
print(ans)
| import sys
input = sys.stdin.readline
l,r,d=list(map(int,input().split()))
v1 = l//d
if l%d==0:
v1-=1
v2 = r//d
print((v2-v1))
| p02606 |
def main():
left, right, div = [int(x) for x in input().split()]
ans = sum(x % div == 0 for x in range(left, right + 1))
print(ans)
if __name__ == '__main__':
main()
| def main():
left, right, div = [int(x) for x in input().split()]
ans = right // div - (left - 1) // div
print(ans)
if __name__ == '__main__':
main()
| p02606 |
l, r, d = list(map(int, input().split()))
print((r//d - l//d + (l%d==0)))
| l, r, d = list(map(int, input().split()))
print((r//d - (l-1)//d))
| p02606 |
L,R,d=list(map(int, input().split()))
cnt=0
for i in range(L, R+1):
if i%d == 0: cnt+=1
print(cnt) | L,R,d=list(map(int, input().split()))
print((R//d-(L-1)//d)) | p02606 |
L, R, d = list(map(int, input().split()))
count = 0
for i in range(101):
if d * i >= L and d * i <= R:
count += 1
if d * i > R:
break
print(count) | l, r, d = list(map(int, input().split()))
print((r//d - (l-1)//d)) | p02606 |
L,R,d = list(map(int,input().split()))
k = L//d
n = R//d
if L%d==0:
print((n-k+1))
else:
print((n-k)) | L,R,d = list(map(int,input().split()))
print((R//d-(L-1)//d)) | p02606 |
L,R,d=list(map(int,input().split()))
ans=0
for i in range(L,R+1):
if i%d==0:
ans+=1
print(ans) | L,R,d=list(map(int,input().split()))
ans=0
for i in range(R-L+1):
if (L+i)%d==0:
ans+=1
print(ans) | p02606 |
l, r, d = list(map(int, input().split()))
print((r//d - (l-1)//d)) | L, R, d = list(map(int, input().split()))
diff = R - L + 1
ans = 0
l = [None for _ in range(diff)]
for i in range(diff):
l[i] = L + i
if l[i] % d == 0:
ans += 1
print(ans) | p02606 |
l, r, d = list(map(int, input().split()))
print((r//d - (l-1)//d)) | #!/usr/bin/env python3
l, r, d = list(map(int, input().split()))
print((r//d - (l-1)//d))
| p02606 |
l,r,d = list(map(int,input().split()))
print(( r//d -(l-1)//d )) | A = list(map(int, input().split()))
C = 0
for i in range(A[0], A[1]+1):
if i % A[2] == 0:
C += 1
print(C) | p02606 |
def main():
L, R, d = list(map(int, input().split(' ')))
total = 0
for i in range(L, R + 1):
if i % d == 0:
total += 1
print(total)
main() | def main():
L, R, d = list(map(int, input().split(' ')))
X = 0
if L % d == 0:
X = int(L / d) - 1
else:
X = int(L / d)
print((int(R / d) - X))
main() | p02606 |
L,R,d=list(map(int,input().split()))
ans=0
for i in range(L,R+1):
if i%d==0:
ans+=1
print(ans)
| L,R,d=list(map(int,input().split()))
ans=R//d-(L-1)//d
print(ans) | p02606 |
import sys
s = [x for x in sys.stdin.readline().rstrip()]
black = float("inf")
ans = 0
for i in range(len(s)):
if s[i] == "B" and black > i:
black = i
elif s[i] == "W" and black != float("inf"):
ans += i - black
black += 1
print(ans) | import sys
def main():
s = sys.stdin.readline().rstrip()
black = 0
ans = 0
for i in s:
if i == "B":
black = black + 1
else:
ans = ans + black
print(ans)
return
if __name__ == "__main__":
main() | p03200 |
#AGC029-A Irreversible operation
"""
問題：
一直線上にオセロがある
一回の操作で[黒白]を裏返す時[白黒]、最大何回の操作が行えるか
解法：
まずいちばん最初のBが出てくるところまでは無視できる
そこから、Bの数*Wの数が答え
"""
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
s = readline().rstrip().decode('utf-8')
flag = 0
black = 0
white = 0
ans = 0
for i in s:
if flag:
if i == "B":
black += 1
else:
ans += black
else:
if i == "B":
flag = 1
black += 1
print(ans) | #AGC029-A Irreversible operation
"""
問題：
一直線上にオセロがある
一回の操作で[黒白]を裏返す時[白黒]、最大何回の操作が行えるか
解法：
まずいちばん最初のBが出てくるところまでは無視できる
そこから、Wが出てくる度にそこまでに出現したBの数を足した合計が答え
"""
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
s = readline().rstrip().decode('utf-8')
flag = 0
black = 0
white = 0
ans = 0
for i in s:
if flag:
if i == "B":
black += 1
else:
ans += black
else:
if i == "B":
flag = 1
black += 1
print(ans) | p03200 |
from sys import stdin
N=(stdin.readline().rstrip())
def str_del(str,index):
str = str[:index]+str[index+1:]
return str
ans=0
for i in range(100000000000):
index=N.find("W")
if index==-1:
break
ans=ans+index
N=str_del(N,index)
print(ans) | from sys import stdin
N=(stdin.readline().rstrip())
N=list(N)
cnt=0
ans=0
for i in N:
if i=="B":
cnt+=1
else:
ans+=cnt
print(ans) | p03200 |
S = input().strip()
Sb = [c == "B" for c in S]
def reverse(Sb,i):
_list = Sb.copy()
_list[i] = not _list[i]
return _list
def operate_onestep(Sb):
_list = Sb.copy()
cnt = 0
flg = True
while flg:
flg = False
for i in range(len(_list)-1):
if _list[i] and not _list[i+1]:
cnt += 1
_list = reverse(_list,i)
_list = reverse(_list,i+1)
flg = True
return cnt
print((operate_onestep(Sb))) | S = input().strip()
w_total = 0
num_op = 0
for i,c in enumerate(S):
if c == "W":
w_total += 1
num_op += i + 1 - w_total
print(num_op) | p03200 |
S = list(input().rstrip())
count = 0
flag = True
while flag:
for i in range(len(S)-1):
if S[i] == 'B' and S[i+1] == 'W':
S[i], S[i+1] = S[i+1], S[i]
count += 1
break
if i == len(S)-2:
flag = False
print(count) | S = list(input().rstrip())
ans = 0
countw = 0
for i, c in enumerate(S):
if c == 'W':
ans += i - countw
countw += 1
print(ans) | p03200 |
import sys
def bubble_sort(arr):
counter = 0
change = True
for i in range(len(arr)):
for j in range(len(arr) - 1, i, -1):
if arr[j] < arr[j - 1]:
arr[j], arr[j - 1] = arr[j - 1], arr[j]
counter += 1
if change == 0: break
return arr, counter
def solve():
input = sys.stdin.readline
S = list(input().replace("B", "2").replace("W", "1"))[:-1]
S, counter = bubble_sort(S)
print(counter)
solve()
| import sys
def solve():
input = sys.stdin.readline
S = list(input().replace("B", "2").replace("W", "1"))[:-1]
N = len(S)
ans = N * (N - 1) // 2
data = [0] * (N + 1)
def add(k, v):
while k <= N:
data[k] += v
k += k & -k
def get(k):
s = 0
while k:
s += data[k]
k -= k & -k
return s
for a in map({a: i + 1 for i, a in enumerate(sorted(S))}.__getitem__, S):
ans -= get(a)
add(a, 1)
print(ans)
solve()
| p03200 |
import sys
def S(): return sys.stdin.readline().rstrip()
if __name__=='__main__':
sl = list(S())
flag = True
c = 0
while flag:
flag = False
for i in range(0,len(sl)-1):
if sl[i]=='B' and sl[i+1]=='W':
sl[i],sl[i+1] = 'W','B'
c += 1
flag = True
print(c)
exit() | import sys
def S(): return sys.stdin.readline().rstrip()
if __name__=='__main__':
sl = list(S())
ans = 0
c = 0
for i,item in enumerate(sl):
if item=='W':
ans += c
else:
c += 1
print(ans)
exit() | p03200 |
import collections
import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
s = rs()
counter = collections.Counter(s)
n = len(s)
res = 0
for i, c in enumerate(s):
if c == 'W':
counter['W'] -= 1
else:
res += counter['W']
print(res) | import collections
import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
s = rs()
counter = collections.Counter(s)
res = 0
for i, c in enumerate(s):
if c == 'W':
counter['W'] -= 1
else:
res += counter['W']
print(res) | p03200 |
from sys import stdin
def main():
A=stdin.readline().replace('B', '0').replace('W', '1')
#A=list(map(int,bw))
#A = list(map(int,stdin.readline().replace('B', '0').replace('W', '1')))
wc = A.count('1')
indices = [i for i, x in enumerate(A) if x == '1']
if wc > 0:
print((sum(indices) - 1*wc*(wc-1) //2 ))
else:
print((sum(indices)))
input = lambda: stdin.readline()
main()
| from sys import stdin
def main():
A=stdin.readline()
#A = list(map(int,stdin.readline().replace('B', '0').replace('W', '1')))
wc = A.count('W')
indices = [i for i, x in enumerate(A) if x == 'W']
if wc > 0:
print((sum(indices) - 1*wc*(wc-1) //2 ))
else:
print((sum(indices)))
input = lambda: stdin.readline()
main()
| p03200 |
#!/usr/bin/env python3
"""
https://atcoder.jp/contests/agc029/tasks/agc029_a
"""
import sys
import re
s = sys.stdin.readline().rstrip()
s2 = ''
cnt = 0
while True:
s = re.sub('^W+','',s)
s = re.sub('B+$','',s)
s2 = s.replace('BW', 'WB', 1)
if s2 == s:
break
cnt += 1
s = s2
print(cnt) | #!/usr/bin/env python3
"""
https://atcoder.jp/contests/agc029/tasks/agc029_a
"""
import sys
import re
s = sys.stdin.readline().rstrip()
e = 0
n = 0
for chr in s:
if chr == 'W':
e += n
if chr == 'B':
n += 1
print(e)
| p03200 |
from sys import stdin
s = stdin.readline().rstrip()
li = []
for i in range(len(s)):
if s[i] == "B":
li.append(0)
else:
li.append(1)
count = 0
while True:
flag = 0
for i in range(len(li)-1):
if li[i] == 0 and li[i+1] == 1:
li[i],li[i+1] = 1,0
flag = 1
count += 1
if flag == 0:
print(count)
exit() | from sys import stdin
s = stdin.readline().rstrip()
now = 0
count = 0
for i in range(len(s)):
if s[i] == "W":
count += (i-now)
now += 1
print(count) | p03200 |
import heapq
class MinCostFlow:
class Edge:
def __init__(self, to, cap, rev, cost):
self.to, self.cap, self.rev, self.cost = to, cap, rev, cost
def __init__(self, V):
self.V = V
self.E = [[] for _ in range(V)]
def add_edge(self, fr, to, cap, cost):
self.E[fr].append(self.Edge(to, cap, len(self.E[to]), cost))
self.E[to].append(self.Edge(fr, 0, len(self.E[fr])-1, -cost))
def run(self, source, sink, f, INF=10**5):
res = 0
h, prevv, preve = [0] * self.V, [0] * self.V, [0] * self.V
while (f > 0):
pque = []
dist = [INF] * self.V
dist[source] = 0
heapq.heappush(pque, (0, source))
while pque:
cost, v = heapq.heappop(pque)
cost = -cost
if dist[v] < cost:
continue
for i, e in enumerate(self.E[v]):
if e.cap > 0 and dist[v] - h[e.to] < dist[e.to] - e.cost - h[v]:
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to]
prevv[e.to], preve[e.to] = v, i
heapq.heappush(pque, (-dist[e.to], e.to))
if dist[sink] == INF:
return -1
for v in range(self.V):
h[v] += dist[v]
d, v = f, sink
while v != source:
d = min(d, self.E[prevv[v]][preve[v]].cap)
v = prevv[v]
f -= d
res += d * h[sink]
v = sink
while v != source:
self.E[prevv[v]][preve[v]].cap -= d
self.E[v][self.E[prevv[v]][preve[v]].rev].cap += d
v = prevv[v]
return res
while True:
N = int(eval(input()))
if not N:
break
V = 366
mcf = MinCostFlow(V)
for i in range(V - 1):
mcf.add_edge(i, i + 1, 2, 0)
for _ in range(N):
s, t, c = list(map(int, input().split()))
mcf.add_edge(s - 1, t, 1, -c)
print((-mcf.run(0, V - 1, 2, 10 ** 9))) | import heapq
import sys
if sys.version[0] == '2':
range, input = xrange, raw_input
class MinCostFlow:
class Edge:
def __init__(self, to, cap, rev, cost):
self.to, self.cap, self.rev, self.cost = to, cap, rev, cost
def __init__(self, V):
self.V = V
self.E = [[] for _ in range(V)]
def add_edge(self, fr, to, cap, cost):
self.E[fr].append(self.Edge(to, cap, len(self.E[to]), cost))
self.E[to].append(self.Edge(fr, 0, len(self.E[fr])-1, -cost))
def run(self, source, sink, f, INF=10**5):
res = 0
h, prevv, preve = [0] * self.V, [0] * self.V, [0] * self.V
while (f > 0):
pque = []
dist = [INF] * self.V
dist[source] = 0
heapq.heappush(pque, (0, source))
while pque:
cost, v = heapq.heappop(pque)
cost = -cost
if dist[v] < cost:
continue
for i, e in enumerate(self.E[v]):
if e.cap > 0 and dist[v] - h[e.to] < dist[e.to] - e.cost - h[v]:
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to]
prevv[e.to], preve[e.to] = v, i
heapq.heappush(pque, (-dist[e.to], e.to))
if dist[sink] == INF:
return -1
for v in range(self.V):
h[v] += dist[v]
d, v = f, sink
while v != source:
d = min(d, self.E[prevv[v]][preve[v]].cap)
v = prevv[v]
f -= d
res += d * h[sink]
v = sink
while v != source:
self.E[prevv[v]][preve[v]].cap -= d
self.E[v][self.E[prevv[v]][preve[v]].rev].cap += d
v = prevv[v]
return res
while True:
N = int(eval(input()))
if not N:
break
V = 366
mcf = MinCostFlow(V)
for i in range(V - 1):
mcf.add_edge(i, i + 1, 2, 0)
for _ in range(N):
s, t, c = list(map(int, input().split()))
mcf.add_edge(s - 1, t, 1, -c)
print((-mcf.run(0, V - 1, 2, 10 ** 9))) | p00825 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(S, T, ABCD):
def norm(s):
s_ = []
for c in s:
if len(s_) == 0:
s_.append(c)
elif s_[-1] == c:
s_.pop()
s_.append('A' if c != 'A' else 'B')
else:
s_.pop()
return ''.join(s_)
for a, b, c, d in ABCD:
s = S[a-1:b]
t = T[c-1:d]
if norm(s) == norm(t):
print('YES')
else:
print('NO')
def main():
S = read_str()
T = read_str()
q = read_int()
ABCD = [read_int_n() for _ in range(q)]
slv(S, T, ABCD)
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(S, T, ABCD):
S_ = [0]
for c in S:
S_.append((1 if c == 'A' else 2) + S_[-1])
T_ = [0]
for c in T:
T_.append((1 if c == 'A' else 2) + T_[-1])
for a, b, c, d in ABCD:
s = (S_[b]-S_[a-1]) % 3
t = (T_[d]-T_[c-1]) % 3
if s == t:
print('YES')
else:
print('NO')
def main():
S = read_str()
T = read_str()
q = read_int()
ABCD = [read_int_n() for _ in range(q)]
slv(S, T, ABCD)
if __name__ == '__main__':
main()
| p03765 |
# https://atcoder.jp/contests/arc071/submissions/6325840
from itertools import accumulate
S = tuple(map(lambda x: 1 if x == 'A' else 2, input()))
T = tuple(map(lambda x: 1 if x == 'A' else 2, input()))
# A=1,B=2
acc_s = (0,) + tuple(accumulate(S))
acc_t = (0,) + tuple(accumulate(T))
ans = []
Q = int(input())
for _ in range(Q):
sl, sr, tl, tr = map(int, input().split())
diff = (acc_t[tr] - acc_t[tl - 1]) - (acc_s[sr] - acc_s[sl - 1])
# 添え字-1は変数再代入しない方が20ms速い
ans.append('YES' if diff % 3 == 0 else 'NO')
print(*ans, sep='\n')
# 逐次printだと1000ms
# 一括だと500ms
| # https://atcoder.jp/contests/arc071/submissions/6325840
from itertools import accumulate
convert = {'A': 1, 'B': 2}
S = tuple(convert[x] for x in input())
T = tuple(convert[x] for x in input())
# maspyさんのやり方
acc_s = (0,) + tuple(accumulate(S))
acc_t = (0,) + tuple(accumulate(T))
ans = []
Q = int(input())
for _ in range(Q):
sl, sr, tl, tr = map(int, input().split())
diff = (acc_t[tr] - acc_t[tl - 1]) - (acc_s[sr] - acc_s[sl - 1])
# 添え字-1は変数再代入しない方が20ms速い
ans.append('YES' if diff % 3 == 0 else 'NO')
print(*ans, sep='\n')
# 逐次printだと1000ms
# 一括だと500ms
| p03765 |
S = input()
T = input()
Q = int(input())
qs = [tuple(map(lambda x:int(x)-1,input().split())) for i in range(Q)]
smem = [0]
for c in S:
if c == 'A':
smem.append(smem[-1] + 1)
else:
smem.append(smem[-1] - 1)
tmem = [0]
for c in T:
if c == 'A':
tmem.append(tmem[-1] + 1)
else:
tmem.append(tmem[-1] - 1)
anss = []
for s1,s2,t1,t2 in qs:
a = smem[s2+1] - smem[s1]
b = tmem[t2+1] - tmem[t1]
if a%3 == b%3:
anss.append('YES')
else:
anss.append('NO')
print(*anss, sep='\n')
| S = input()
T = input()
Q = int(input())
qs = [tuple(map(int,input().split())) for i in range(Q)]
sas = [0]
sbs = [0]
for c in S:
a = int(c=='A')
sas.append(sas[-1] + a)
sbs.append(sbs[-1] + (a^1))
tas = [0]
tbs = [0]
for c in T:
a = int(c=='A')
tas.append(tas[-1] + a)
tbs.append(tbs[-1] + (a^1))
ans = []
for a,b,c,d in qs:
sa = sas[b] - sas[a-1]
sb = sbs[b] - sbs[a-1]
ta = tas[d] - tas[c-1]
tb = tbs[d] - tbs[c-1]
s = (sb-sa)%3
t = (tb-ta)%3
ans.append('YES' if s==t else 'NO')
print(*ans, sep='\n')
| p03765 |
import sys
def input():
return sys.stdin.readline().strip()
def restore(s):
while len(s) > 1:
s = s.replace("AA", "B")
s = s.replace("BB", "A")
s = s.replace("AB", "")
s = s.replace("BA", "")
return s
S = input()
T = input()
q = int(input())
for _ in range(q):
a, b, c, d = map(int, input().split())
r_s = restore(S[a - 1 : b])
r_t = restore(T[c - 1 : d])
print("YES") if r_s == r_t else print("NO")
| import sys
from itertools import accumulate
def input():
return sys.stdin.readline().strip()
def acc(li, n):
res = [0] * (n + 1)
for i in range(n):
if li[i] == "A":
res[i + 1] = 1
elif li[i] == "B":
res[i + 1] = 2
return list(accumulate(res))
def restore(x, y, li):
return (li[y] - li[x - 1]) % 3
S = input()
T = input()
N = len(S)
M = len(T)
acc_S = acc(S, N)
acc_T = acc(T, M)
q = int(input())
for _ in range(q):
a, b, c, d = map(int, input().split())
v_S = restore(a, b, acc_S)
v_T = restore(c, d, acc_T)
print("YES") if v_S == v_T else print("NO")
| p03765 |
s = input()
t = input()
n = int(input())
q = []
for i in range(n):
abcd = list(map(int, input().split()))
q.append(abcd)
def shorten(s):
if s[0] != s[1]:
return s[2:]
elif s[1] != s[2]:
return s[0] + s[3:]
return s[3:]
def check(s):
sc = [s]
while len(s) >= 3:
if s in visited:
s = visited[s]
break
s = shorten(s)
sc.append(s)
if len(s) == 2:
if s == 'AA':
s = 'B'
elif s == 'BB':
s = 'A'
else:
s = ''
for sci in sc:
visited[sci] = s
return s
visited = {}
for a,b,c,d in q:
si = check(s[a-1:b])
ti = check(t[c-1:d])
if si == ti:
print('YES')
else:
print('NO')
| S = input()
T = input()
n = int(input())
q = []
for i in range(n):
abcd = list(map(int, input().split()))
q.append(abcd)
toi = lambda c: 1 if c == 'A' else 2
s = [0] * (len(S)+1)
for i in range(len(S)):
s[i+1] = s[i] + toi(S[i])
t = [0] * (len(T)+1)
for i in range(len(T)):
t[i+1] = t[i] + toi(T[i])
for a,b,c,d in q:
si = (s[b] - s[a-1]) % 3
ti = (t[d] - t[c-1]) % 3
if si == ti:
print('YES')
else:
print('NO')
| p03765 |
import collections
class MyList(list):
def __init__(self, x=[]):
list.__init__(self, x)
def __iadd__(self, A):
ret = MyList()
for a, b in zip(self, A):
ret.append(a + b)
return ret
def __isub__(self, A):
ret = MyList()
for a, b in zip(self, A):
ret.append(a - b)
return ret
def __gt__(self, A):
for a, b in zip(self, A):
if a != b:
return a > b
return False
class MaxFlow:
"""Dinic Algorithm: find max-flow
complexity: O(EV^2)
used in GRL6A(AOJ)
"""
class Edge:
def __init__(self, to, cap, rev):
self.to, self.cap, self.rev = to, cap, rev
def __init__(self, V, D):
""" V: the number of vertexes
E: adjacency list
source: start point
sink: goal point
"""
self.V = V
self.E = [[] for _ in range(V)]
self.D = D
def zero(self):
return MyList([0] * self.D)
def add_edge(self, fr, to, cap):
self.E[fr].append(self.Edge(to, cap, len(self.E[to])))
self.E[to].append(self.Edge(fr, self.zero(), len(self.E[fr])-1))
def dinic(self, source, sink):
"""find max-flow"""
INF = MyList([10**9] * self.D)
maxflow = self.zero()
while True:
self.bfs(source)
if self.level[sink] < 0:
return maxflow
self.itr = MyList([0] * self.V)
while True:
flow = self.dfs(source, sink, INF)
if flow > self.zero():
maxflow += flow
else:
break
def dfs(self, vertex, sink, flow):
"""find augmenting path"""
if vertex == sink:
return flow
for i in range(self.itr[vertex], len(self.E[vertex])):
self.itr[vertex] = i
e = self.E[vertex][i]
if e.cap > self.zero() and self.level[vertex] < self.level[e.to]:
if flow > e.cap:
d = self.dfs(e.to, sink, e.cap)
else:
d = self.dfs(e.to, sink, flow)
if d > self.zero():
e.cap -= d
self.E[e.to][e.rev].cap += d
return d
return self.zero()
def bfs(self, start):
"""find shortest path from start"""
que = collections.deque()
self.level = [-1] * self.V
que.append(start)
self.level[start] = 0
while que:
fr = que.popleft()
for e in self.E[fr]:
if e.cap > self.zero() and self.level[e.to] < 0:
self.level[e.to] = self.level[fr] + 1
que.append(e.to)
def to_poly(a, l):
if l == 0:
return str(a)
elif l == 1:
return "{}x".format('' if a == 1 else a)
else:
return "{}x^{}".format('' if a == 1 else a, l)
while True:
N, M = list(map(int, input().split()))
if N == M == 0:
break
mf = MaxFlow(N, 51)
for _ in range(M):
u, v, p = input().split()
u, v = int(u)-1, int(v)-1
poly = MyList([0] * 51)
for x in p.split('+'):
try:
num = int(x)
poly[-1] = num
except ValueError:
a, l = x.split('x')
if l:
poly[-int(l.strip("^"))-1] = int(a) if a else 1
else:
poly[-2] = int(a) if a else 1
mf.add_edge(u, v, poly)
mf.add_edge(v, u, poly)
maxflow = mf.dinic(0, N-1)
ans = '+'.join(to_poly(a, l) for a, l in zip(maxflow, reversed(list(range(51)))) if a)
print((ans if ans else 0)) | import collections
class MyList(list):
def __init__(self, x=[]):
list.__init__(self, x)
def __iadd__(self, A):
return MyList([a + b for a, b in zip(self, A)])
def __isub__(self, A):
return MyList([a - b for a, b in zip(self, A)])
def __gt__(self, A):
for a, b in zip(self, A):
if a != b:
return a > b
return False
class MaxFlow:
"""Dinic Algorithm: find max-flow
complexity: O(EV^2)
used in GRL6A(AOJ)
"""
class Edge:
def __init__(self, to, cap, rev):
self.to, self.cap, self.rev = to, cap, rev
def __init__(self, V, D):
""" V: the number of vertexes
E: adjacency list
source: start point
sink: goal point
"""
self.V = V
self.E = [[] for _ in range(V)]
self.D = D
def zero(self):
return MyList([0] * self.D)
def add_edge(self, fr, to, cap):
self.E[fr].append(self.Edge(to, cap, len(self.E[to])))
self.E[to].append(self.Edge(fr, self.zero(), len(self.E[fr])-1))
def dinic(self, source, sink):
"""find max-flow"""
INF = MyList([10**9] * self.D)
maxflow = self.zero()
while True:
self.bfs(source)
if self.level[sink] < 0:
return maxflow
self.itr = MyList([0] * self.V)
while True:
flow = self.dfs(source, sink, INF)
if flow > self.zero():
maxflow += flow
else:
break
def dfs(self, vertex, sink, flow):
"""find augmenting path"""
if vertex == sink:
return flow
for i in range(self.itr[vertex], len(self.E[vertex])):
self.itr[vertex] = i
e = self.E[vertex][i]
if e.cap > self.zero() and self.level[vertex] < self.level[e.to]:
if flow > e.cap:
d = self.dfs(e.to, sink, e.cap)
else:
d = self.dfs(e.to, sink, flow)
if d > self.zero():
e.cap -= d
self.E[e.to][e.rev].cap += d
return d
return self.zero()
def bfs(self, start):
"""find shortest path from start"""
que = collections.deque()
self.level = [-1] * self.V
que.append(start)
self.level[start] = 0
while que:
fr = que.popleft()
for e in self.E[fr]:
if e.cap > self.zero() and self.level[e.to] < 0:
self.level[e.to] = self.level[fr] + 1
que.append(e.to)
def to_poly(a, l):
if l == 0:
return str(a)
elif l == 1:
return "{}x".format('' if a == 1 else a)
else:
return "{}x^{}".format('' if a == 1 else a, l)
while True:
N, M = list(map(int, input().split()))
if N == M == 0:
break
mf = MaxFlow(N, 51)
for _ in range(M):
u, v, p = input().split()
u, v = int(u)-1, int(v)-1
poly = MyList([0] * 51)
for x in p.split('+'):
try:
num = int(x)
poly[-1] = num
except ValueError:
a, l = x.split('x')
if l:
poly[-int(l.strip("^"))-1] = int(a) if a else 1
else:
poly[-2] = int(a) if a else 1
mf.add_edge(u, v, poly)
mf.add_edge(v, u, poly)
maxflow = mf.dinic(0, N-1)
ans = '+'.join(to_poly(a, l) for a, l in zip(maxflow, reversed(list(range(51)))) if a)
print((ans if ans else 0)) | p01445 |
x = eval(input())
w = [int(i) for i in input().split()]
d = 0
for i in range(len(w) -2 ):
if (w[i] > w[i+1] > w[i+2]) or (w[i] < w[i+1] < w[i+2]):
d += 1
print(d)
| n=int(eval(input()))
v=[int(i) for i in input().split()]
ans=0
for i in range(1, len(v)-1):
if (v[i]>v[i-1] and v[i]<v[i+1]) or (v[i]<v[i-1] and v[i]>v[i+1]):
ans+=1
print(ans) | p02988 |
n = int(eval(input()))
p = list(map(int, input().split()))
a = 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]):
a += 1
print(a)
| # 少しひっかけ問題っぽいです。
n = int(eval(input()))
p = list(map(int, input().split()))
a = 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]):
a += 1
print(a)
| p02988 |
N=int(eval(input()))
temp=input().split()
p=[int(temp[i]) for i in range(N)]
counter=0
for i in range(1, N-1):
if (p[i]-p[i-1])*(p[i]-p[i+1])<0:
counter+=1
print(counter) | n=int(eval(input()))
p=list(map(int, input().split()))
counter=0
for i in range(1, n-1):
if (p[i]-p[i-1])*(p[i]-p[i+1])<0:
counter+=1
print((int(counter))) | p02988 |
n = int(eval(input()))
l = list(map(int, input().split()))
print((sum(l[i]<l[i+1]<l[i+2] or l[i]>l[i+1]>l[i+2] for i in range(n-2)))) | n=int(eval(input()))
l=list(map(int,input().split()))
a=0
for i in range(n-2):
p,q,r=l[i:i+3]
if p<q<r or r<q<p: a+=1
print(a) | p02988 |
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(1, n - 1):
if a[i - 1] < a[i] < a[i + 1] or a[i - 1] > a[i] > a[i + 1]:
ans += 1
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(n - 2):
if a[i] < a[i + 1] < a[i + 2]:
ans += 1
if a[i] > a[i + 1] > a[i + 2]:
ans += 1
print(ans) | p02988 |
n=int(eval(input()))
p=list(map(int,input().split()))
ans=0
for i in range(1,n-1):
if sorted([p[i-1],p[i],p[i+1]])[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):
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()))
ps = list(map(int, input().split()))
ans = 0
for i in range(1, N-1):
if ps[i-1] < ps[i] < ps[i+1] or ps[i-1] > ps[i] > ps[i+1]:
ans += 1
print(ans)
| N = int(eval(input()))
Ps = list(map(int, input().split()))
ans = 0
for i in range(1, N-1):
if Ps[i-1]<Ps[i]<Ps[i+1] or Ps[i-1]>Ps[i]>Ps[i+1]:
ans += 1
print(ans)
| p02988 |
n = int(eval(input()))
p = list(map(int, input().split()))
ans = 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]):
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] < p[i+1] or p[i+1] < p[i] < p[i-1]:
ans += 1
print(ans)
| p02988 |
n = int(eval(input()))
l = list(map(int, input().split()))
cnt = 0
for i in range(n-2):
if max(l[i], l[i+1], l[i+2]) != l[i+1] and min(l[i], l[i+1], l[i+2]) != l[i+1]:
cnt += 1
print(cnt) | n = int(eval(input()))
l = list(map(int, input().split()))
cnt = 0
for i in range(n-2):
if l[i]<l[i+1]<l[i+2] or l[i]>l[i+1]>l[i+2]:
cnt += 1
print(cnt) | p02988 |
#B
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]:
ans += 1
if p[i-1] > p[i] and p[i] > p[i+1]:
ans += 1
print(ans) | n = int(eval(input()))
p = list(map(int, input().split()))
count = 0
for i in range(1, n-1):
if p[i-1] < p[i] and p[i] < p[i+1]:
count += 1
elif p[i-1] > p[i] and p[i] > p[i+1]:
count += 1
else:
pass
print(count) | p02988 |
n = int(eval(input()))
p = [int(x) for x in input().split()]
cnt = 0
for i in range(1,n-1):
if p[i-1]<p[i] and p[i]<p[i+1]:
cnt +=1
elif p[i-1]>p[i] and p[i]>p[i+1]:
cnt +=1
print(cnt) | n = int(eval(input()))
p = [int(_) for _ in input().split()]
cnt =0
for i in range(2,n):
if p[i-2] < p[i-1] < p[i] or p[i]<p[i-1]<p[i-2]:
cnt +=1
print(cnt) | p02988 |
n = int(eval(input()))
ps = list(map(int, input().split()))
count = 0
for i in range(1, n-2+1):
if ps[i-1] < ps[i] < ps[i+1]:
count += 1
elif ps[i-1] > ps[i] > ps[i+1]:
count += 1
print(count) |
n = int(eval(input()))
ps = list(map(int, input().split()))
count = 0
for i in range(n-2):
a = [ps[i], ps[i+1], ps[i+2]]
b = ps[i+1]
a.sort()
if a[1] == b:
count += 1
print(count) | p02988 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.