input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
import math
import functools
import copy
N=int(eval(input()))
a=list(map(int,input().split()))
b=copy.copy(a)
ans=list()
for i in range(N):
del b[i]
gcd=functools.reduce(math.gcd,b)
ans.append(gcd)
b.insert(i,a[i])
print((max(ans)))
|
import math
from itertools import accumulate
n = int(eval(input()))
a = list(map(int, input().split()))
fromleft = list(accumulate(a, math.gcd))
fromright = list(accumulate(a[::-1], math.gcd))[::-1]
gcd = []
gcd.append(fromright[1])
for i in range(1, n-1):
gcd.append(math.gcd(fromleft[i-1], fromright[i+1]))
gcd.append(fromleft[n-2])
print((max(gcd)))
|
p03061
|
from functools import reduce
import copy
def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x % y) #再帰定義
def gcd_list(numbers):
return reduce(gcd, numbers)
n=int(eval(input()))
a_o=list(map(int,input().split()))
g=[1]*n
for i in range(n):
a=copy.copy(a_o)
a.pop(i)
g[i]=gcd_list(a)
print((max(g)))
|
def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x % y) #再帰定義
n=int(eval(input()))
a=list(map(int,input().split()))
l=[0]*n
r=[0]*n
for i in range(1,n):
if i==1:
l[1]=a[0]
r[-2]=a[-1]
else:
l[i]=gcd(l[i-1],a[i-1])
r[-i-1]=gcd(r[-i],a[-i])
g=[0]*n
for i in range(n):
if l[i]==0 or r[i]==0:
g[i]=l[i]+r[i]
else:
g[i]=gcd(l[i],r[i])
print((max(g)))
|
p03061
|
def gcd(a,b):
if a % b == 0:
return b
else:
return gcd(b,a%b)
N = int(eval(input()))
A = [i for i in map(int,input().split())]
g = []
for i in range(N):
ans = 0
for j in range(N):
if ans == 0 and i != j:
ans = A[j]
continue
if i != j:
ans = gcd(A[j],ans)
g.append(ans)
print((max(g)))
|
def gcd(a,b):
if b == 0:
return a
if a % b == 0:
return b
else:
return gcd(b,a%b)
N = int(eval(input()))
A = [i for i in map(int,input().split())]
L = [0]
R = [0]
for i in range(N):
L.append(gcd(L[-1],A[i]))
for i in range(N-1,-1,-1):
R.append(gcd(R[-1],A[i]))
R.reverse()
g = []
for i in range(N):
g.append(gcd(L[i],R[i+1]))
print((max(g)))
|
p03061
|
n = int(eval(input()))
a = list(map(int,input().split()))
if n == 2:
print((max(a)))
else:
l = [-1]
r = []
def gcd(x,y):
while y != 0:
x, y = y, x%y
# print(x,y)
return(x)
for i in range(n-1):
m = a[i+1:][0]
if len(a[i+1:]) == 1:
m = a[i+1:][0]
elif len(a[i+1:]) > 1:
for j in a[i+1:]:
m = gcd(m,j)
r.append(m)
m2 = a[:i+1][0]
if len(a[:i+1]) == 1:
m2 = a[:i+1][0]
elif len(a[:i+1]) > 1:
for j in a[:i+1]:
m2 = gcd(m2,j)
l.append(m2)
r.append(-1)
# print(r)
# print(l)
ans = 0
for i in range(n):
if l[i] == -1:
ans = max(ans,r[i])
elif r[i] == -1:
ans = max(ans,l[i])
else:
ans = max(ans,gcd(l[i],r[i]))
print(ans)
|
n = int(eval(input()))
a = list(map(int,input().split()))
if n == 2:
print((max(a)))
else:
l = [0 for i in range(n)]
r = [0 for i in range(n)]
def gcd(x,y):
while y != 0:
x, y = y, x%y
# print(x,y)
return(x)
for i in range(1,n):
l[i] = gcd(l[i-1],a[i-1])
r[n-i-1] = gcd(r[n-i],a[n-i])
# print(l)
# print(r)
ans = 0
for i in range(n):
if l[i] == -1:
ans = max(ans,r[i])
elif r[i] == -1:
ans = max(ans,l[i])
else:
ans = max(ans,gcd(l[i],r[i]))
print(ans)
|
p03061
|
N=int(eval(input()))
LA=list(map(int,input().split()))
ans=[]
def gcd(m,n):
while n:
m,n=n,m%n
return m
from functools import reduce
def multigcd(item):
return reduce(gcd, item)
for n in range(N):
L=LA[:n]+LA[n+1:]
ans.append(multigcd(L))
print((max(ans)))
|
N=int(eval(input()))
LA=list(map(int,input().split()))
ans=[]
def gcd(m,n):
if m==0 or n==0:
return m+n
while n:
m,n=n,m%n
return m
La=[0]
Lb=[0]
for n in range(N-1):
La.append(gcd(La[n],LA[n]))
Lb.append(gcd(Lb[n],LA[-(n+1)]))
for n in range(N):
ans.append(gcd(La[n],Lb[-(n+1)]))
print((max(ans)))
|
p03061
|
#import math
from functools import reduce
def gcd(a,b):
r = 1
while r > 0:
r = a % b
a = b
b = r
return a
n = int(eval(input()))
a = [int(i) for i in input().split()]
L = [0] * n
for i in range(n):
aa = a[:]
aa.pop(i)
L[i] = reduce(gcd, aa)
print((max(L)))
|
def gcd(a,b):
if a == 0:
return b
if b == 0:
return a
r = 1
while r > 0:
r = a % b
a = b
b = r
return a
n = int(eval(input()))
A = [int(i) for i in input().split()]
L = [0] * n
L[0] = 0
L[1] = A[0]
for i in range(2,n):
L[i] = gcd(L[i-1], A[i-1])
R = [0] * n
R[-1] = 0
R[-2] = A[-1]
for i in range(3,n+1):
R[-i] = gcd(R[-i+1], A[-i+1])
M = [gcd(L[i],R[i]) for i in range(n)]
print((max(M)))
|
p03061
|
import sys
from collections import deque
def gcd(a, b):
while b:
a, b = b, a % b
return a
input = sys.stdin.readline
n = int(eval(input()))
a_que = deque(list(map(int, input().split())))
ans = 1
for _ in range(n):
out = a_que.popleft()
m = 0
for a in a_que:
m = gcd(m, a)
ans = max(ans, m)
a_que.append(out)
print(ans)
|
import sys
def gcd(a, b):
while b:
a, b = b, a % b
return a
input = sys.stdin.readline
n = int(eval(input()))
a_list = list(map(int, input().split()))
l_list = [0]
r_list = [0]
l_gcd, r_gcd = 0, 0
for i in range(n-1):
l_gcd = gcd(l_gcd, a_list[i])
l_list.append(l_gcd)
r_gcd = gcd(r_gcd, a_list[-i-1])
r_list.append(r_gcd)
ans = 1
for i in range(n):
ans = max(ans, gcd(l_list[i], r_list[-i-1]))
print(ans)
|
p03061
|
n = int(eval(input()))
a = list(map(int, input().split()))
a.sort(reverse=True)
from functools import lru_cache
import sys
if n == 2:
print((max(a)))
sys.exit()
@lru_cache(maxsize=100000)
def gcd(x, y):
while y:
x, y = y, x % y
return x
def gcd_list(li):
if len(li) == 1:
return li[0]
g = gcd(li[0], li[1])
for i in range(2, len(li)):
g = gcd(g, li[i])
return g
def gcd_list_2(li):
g = gcd(li[0], li[1])
if g == 1:
return max(gcd_list([li[0]] + li[2:]), gcd_list(li[1:]))
for i in range(2, n):
if gcd(g, li[i]) == 1:
if i == n - 1:
return gcd_list(li[:i])
gg = gcd_list(li[i+1:])
bb = [gcd(li[x], gg) for x in range(i+1)]
bb.sort()
return bb[1]
else:
g = gcd(g, li[i])
return g
def max_gcd(a):
g = gcd_list(a)
a = [a[i]//g for i in range(n)]
m = gcd_list_2(a)
print((g * m))
max_gcd(a)
|
n = int(eval(input()))
a = list(map(int, input().split()))
import sys
if n == 2:
print((max(a)))
sys.exit()
def gcd(x, y):
while y:
x, y = y, x % y
return x
g = a[0]
gcd_left = [g]
for i in range(n-1):
g = gcd(g, a[i+1])
gcd_left.append(g)
g = a[n-1]
gcd_right = [g]
for i in range(n-1):
g = gcd(g, a[n-2-i])
gcd_right.append(g)
max_gcd = gcd_right[n-2]
for i in range(1, n-1):
max_gcd = max(max_gcd, gcd(gcd_left[i-1], gcd_right[n - 2 - i]))
max_gcd = max(max_gcd, gcd_left[n-2])
print(max_gcd)
|
p03061
|
import math
N = int(eval(input()))
A = [int(_) for _ in input().split()]
def gcd(x, y):
if x < y:
return gcd(y, x)
elif y == 0:
return x
else:
return gcd(y, x % y)
class SegmentTree():
def m(self, v1, v2): # ***monoid***
return gcd(v1, v2)
def __init__(self, array):
m = self.m
e = self.e = 0 # ***identity element***
size = self.size = 10**6 # ***limit for array size***
n = self.n = len(array)
dat = self.dat = [e] * n + array + [e] * (2 * size - 2 * n)
for i in range(n - 1, 0, -1): # build
dat[i] = m(dat[i << 1], dat[i << 1 | 1])
def modify(self, p, v): # set value at position p (0-indexed)
m, n, dat = self.m, self.n, self.dat
p += n
dat[p] = v
while p > 1:
dat[p >> 1] = m(dat[p], dat[p ^ 1])
p >>= 1
def query(self, l, r): # result on interval [l, r) (0-indexed)
m, e, n, dat = self.m, self.e, self.n, self.dat
res = e
l += n
r += n
while l < r:
if l & 1:
res = m(res, dat[l])
l += 1
if r & 1:
r -= 1
res = m(res, dat[r])
l >>= 1
r >>= 1
return res
ST = SegmentTree(A)
ans = 0
for i, a in enumerate(A):
ST.modify(i, ST.e)
ans = max(ans, ST.query(0, N))
ST.modify(i, a)
print(ans)
|
import math
N = int(eval(input()))
A = [int(_) for _ in input().split()]
def gcd(x, y):
if x < y:
return gcd(y, x)
elif y == 0:
return x
else:
return gcd(y, x % y)
class SegmentTree():
def m(self, v1, v2): # ***monoid***
return gcd(v1, v2)
def __init__(self, array):
m = self.m
e = self.e = 0 # ***identity element***
size = self.size = 10**5 # ***limit for array size***
n = self.n = len(array)
dat = self.dat = [e] * n + array + [e] * (2 * size - 2 * n)
for i in range(n - 1, 0, -1): # build
dat[i] = m(dat[i << 1], dat[i << 1 | 1])
def modify(self, p, v): # set value at position p (0-indexed)
m, n, dat = self.m, self.n, self.dat
p += n
dat[p] = v
while p > 1:
dat[p >> 1] = m(dat[p], dat[p ^ 1])
p >>= 1
def query(self, l, r): # result on interval [l, r) (0-indexed)
m, e, n, dat = self.m, self.e, self.n, self.dat
res = e
l += n
r += n
while l < r:
if l & 1:
res = m(res, dat[l])
l += 1
if r & 1:
r -= 1
res = m(res, dat[r])
l >>= 1
r >>= 1
return res
ST = SegmentTree(A)
ans = 0
for i, a in enumerate(A):
ST.modify(i, ST.e)
ans = max(ans, ST.query(0, N))
ST.modify(i, a)
print(ans)
|
p03061
|
N = int(eval(input()))
A = [int(_) for _ in input().split()]
class SegmentTree():
def __init__(self, array, m, e, size):
self.m = m # monoid
self.e = e # identity element
self.size = size # limit for array size
self.n = n = len(array) # array size
self.dat = dat = [e] * n + array + [e] * (2 * size - 2 * n)
for i in range(n - 1, 0, -1): # build
dat[i] = m(dat[i << 1], dat[i << 1 | 1])
def modify(self, p, v): # set value at position p (0-indexed)
m, n, dat = self.m, self.n, self.dat
p += n
dat[p] = v
while p > 1:
dat[p >> 1] = m(dat[p], dat[p ^ 1])
p >>= 1
def query(self, l, r): # result on interval [l, r) (0-indexed)
m, e, n, dat = self.m, self.e, self.n, self.dat
res = e
l += n
r += n
while l < r:
if l & 1:
res = m(res, dat[l])
l += 1
if r & 1:
r -= 1
res = m(res, dat[r])
l >>= 1
r >>= 1
return res
gcd = lambda x, y: gcd(y, x) if x < y else x if y == 0 else gcd(y, x % y)
e = 0
size = 10**6
ST = SegmentTree(A, m=gcd, e=e, size=size)
ans = 1
for i, a in enumerate(A):
ST.modify(i, 0)
ans = max(ans, ST.query(0, N))
ST.modify(i, a)
print(ans)
|
N = int(eval(input()))
A = [int(_) for _ in input().split()]
class SegmentTree():
def __init__(self, array, m, e, size):
"""
Parameters
----------
array : list
to construct segment tree from
m : func
binary operation of the monoid
e :
identity element of the monoid
size : int
limit for array size
"""
self.m = m
self.e = e
self.size = size
self.n = n = len(array)
self.dat = dat = [e] * n + array + [e] * (2 * size - 2 * n)
for i in range(n - 1, 0, -1): # build
dat[i] = m(dat[i << 1], dat[i << 1 | 1])
def modify(self, p, v): # set value at position p (0-indexed)
m, n, dat = self.m, self.n, self.dat
p += n
dat[p] = v
while p > 1:
dat[p >> 1] = m(dat[p], dat[p ^ 1])
p >>= 1
def query(self, l, r): # result on interval [l, r) (0-indexed)
m, e, n, dat = self.m, self.e, self.n, self.dat
res = e
l += n
r += n
while l < r:
if l & 1:
res = m(res, dat[l])
l += 1
if r & 1:
r -= 1
res = m(res, dat[r])
l >>= 1
r >>= 1
return res
gcd = lambda x, y: gcd(y, x) if x < y else x if y == 0 else gcd(y, x % y)
e = 0
size = N
ST = SegmentTree(A, m=gcd, e=e, size=size)
ans = 1
for i, a in enumerate(A):
ST.modify(i, 0)
ans = max(ans, ST.query(0, N))
ST.modify(i, a)
print(ans)
|
p03061
|
N = int(eval(input()))
A = list(map(int, input().split()))
def gcd(a, b):
while b:
a, b = b, a%b
return a
def gcd_of_arr(arr):
cd = arr[0]
for i in range(1,len(arr)):
if cd==1:
return cd
cd = gcd(arr[i], cd)
return cd
ans = 0
for i in range(N):
tmp = gcd_of_arr(A[0:i] + A[i+1:N])
ans = max(ans, tmp)
print(ans)
|
N = int(eval(input()))
A = list(map(int, input().split()))
def gcd(a, b):
while b:
a, b = b, a%b
return a
L, R = [0]*(N+1), [0]*(N+1)
for i in range(1,N+1):
L[i] = gcd(L[i-1], A[i-1])
R[N-i] = gcd(R[N+1-i], A[N-i])
ans = 0
for i in range(N):
ans = max(ans, gcd(L[i], R[i+1]))
print(ans)
|
p03061
|
#どっちで出すか注意, rstrip注意
#提出前に見返すこと！
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate
#from itertools import product
from bisect import bisect_left,bisect_right
import heapq
from math import floor, ceil
#from operator import itemgetter
from functools import lru_cache
#inf = 10**17
#mod = 10**9 + 7
N = int(eval(input()))
A = list(map(int, input().split()))
@lru_cache(maxsize=None)
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
def gcd_group(arr):
g = gcd(arr[0], arr[1])
for i in range(2, len(arr)):
g = gcd(g, arr[i])
return g
def lcm(a, b):
g = gcd(a, b)
return (a*b)//g
def lcm_group(arr):
l = lcm(arr[0], arr[1])
for i in range(2, len(arr)):
l = lcm(l, arr[i])
return l
if len(A) == 2:
print((max(A)))
exit()
res = 0
for i in range(N):
arr = A[:i] + A[i+1:]
res = max(res, gcd_group(arr))
print(res)
if __name__ == '__main__':
main()
|
#どっちで出すか注意, rstrip注意
#提出前に見返すこと！
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate
#from itertools import product
from bisect import bisect_left,bisect_right
import heapq
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
N = int(eval(input()))
A = list(map(int, input().split()))
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
def gcd_group(arr):
g = gcd(arr[0], arr[1])
for i in range(2, len(arr)):
g = gcd(g, arr[i])
return g
def lcm(a, b):
g = gcd(a, b)
return (a*b)//g
def lcm_group(arr):
l = lcm(arr[0], arr[1])
for i in range(2, len(arr)):
l = lcm(l, arr[i])
return l
l = [0]
for i in range(N-1):
l.append(gcd(l[-1], A[i]))
r = [0]
for i in range(N-1, 0, -1):
r.append(gcd(r[-1], A[i]))
res = 0
for i in range(N):
res = max(res, gcd(l[i], r[-(i+1)]))
print(res)
if __name__ == '__main__':
main()
|
p03061
|
import math
import itertools
n = int(eval(input()))
a = list(map(int, input().split()))
pf = [0]*(n+1)
pb = [0]*(n+1)
p = a[0]
for i in range(n):
p = math.gcd(p, a[i])
pf[i+1] = p
p = a[-1]
for i in range(-1, -n-1, -1):
p = math.gcd(p, a[i])
pb[i-1] = p
ans = [0]*n
for i in range(n):
ans[i] = math.gcd(pf[i], pb[i+1])
print((max(ans)))
|
import math
import itertools
n = int(eval(input()))
a = list(map(int, input().split()))
pf = [0] + list(itertools.accumulate(a, math.gcd))
pb = [0] + list(itertools.accumulate(reversed(a), math.gcd))
pb.reverse()
ans = [0]*n
for i in range(n):
ans[i] = math.gcd(pf[i], pb[i+1])
print((max(ans)))
|
p03061
|
import collections
from functools import reduce
def gcd(u,v):
if v:
return gcd(v, u % v)
else:
return u
n = int(input())
elems = list(map(int , input().split(' ')))
dpp = [ None ] * len(elems)
dps = [ None ] * len(elems)
for i in range(len(elems)): dpp[i] = reduce(gcd, elems[:i+1])
for i in range(len(elems)): dps[len(elems) - 1 - i] = reduce(gcd, elems[- i - 1:])
r = 0
for i in range(len(elems)):
u,v = dpp[i-1] if i-1 >= 0 else -1, dps[i+1] if i+1 < len(elems) else -1
r = max(r, gcd(u,v) if u != -1 and v != -1 else max(u,v))
print(r)
|
import collections
def gcd(u,v):
if v:
return gcd(v, u % v)
else:
return u
n = int(input())
elems = list(map(int , input().split(' ')))
dpp = [ None ] * len(elems)
dps = [ None ] * len(elems)
dpp[0] = elems[0]
for i in range(1,len(elems)):
dpp[i] = gcd(elems[i], dpp[i-1])
dps[len(elems) -1] = elems[-1]
for i in range(len(elems) - 2, -1, -1):
dps[i] = gcd(elems[i], dps[i+1])
r = 0
for i in range(len(elems)):
u,v = dpp[i-1] if i-1 >= 0 else -1, dps[i+1] if i+1 < len(elems) else -1
r = max(r, gcd(u,v) if u != -1 and v != -1 else max(u,v))
print(r)
|
p03061
|
def gcd(m,n):
x=max(m,n)
y=min(m,n)
if x==0:
return 0
while y!=0:
x,y=y,x%y
return x
n = int(eval(input()))
a = list(map(int, input().split()))
b = [0]
for i in range(n):
a[i],a[n-1]=a[n-1],a[i]
temp = a[0]
for j in range(n-1):
temp=gcd(temp,a[j])
if temp == 1:
break
if temp < max(b):
break
b.append(temp)
a[i],a[n-1]=a[n-1],a[i]
print((max(b)))
|
def gcd(m,n):
x=max(m,n)
y=min(m,n)
while y!=0:
x,y=y,x%y
return x
n = int(eval(input()))
a = list(map(int, input().split()))
b = []
l = [0]
r = [0]
for i in range(n):
l.append(gcd(a[i],l[i]))
r.append(gcd(a[n-1-i],r[i]))
for i in range(n):
b.append(gcd(l[i],r[n-1-i]))
print((max(b)))
|
p03061
|
from math import gcd
N, *A = list(map(int, open(0).read().split()))
acc_l = [0] * (N + 1)
acc_r = [0] * (N + 1)
for i in range(1, N + 1):
acc_l[i] = gcd(acc_l[i - 1], A[i - 1])
acc_r[i] = gcd(acc_r[i - 1], A[-i])
ans = 0
for i in range(N + 1):
ans = max(ans, gcd(acc_l[i], acc_r[N - i - 1]))
print(ans)
|
from math import gcd
N, *A = list(map(int, open(0).read().split()))
acc_l = [0]
acc_r = [0]
for i in range(N):
acc_l.append(gcd(acc_l[-1], A[i]))
acc_r.append(gcd(acc_r[-1], A[N - i - 1]))
ans = 0
for i in range(N):
ans = max(ans, gcd(acc_l[i], acc_r[N - i - 1]))
print(ans)
|
p03061
|
def gcd(a, b):
while True:
a, b = b, a % b
if b == 0:
break
return a
def compute_gcd(ns):
a = gcd(ns[0], ns[1])
for i in range(2, len(ns)):
a = gcd(a, ns[i])
return a
n = int(eval(input()))
nums = list(map(int, input().split()))
if n == 2:
print((max(nums)))
else:
gcds = []
for i in range(n):
ns = [nums[j] for j in range(n) if j != i]
a = compute_gcd(ns)
gcds.append(a)
print((max(gcds)))
|
def gcd(a, b):
while True:
a, b = b, a % b
if b == 0:
break
return a
n = int(eval(input()))
nums = list(map(int, input().split()))
if n == 2:
print((max(nums)))
else:
l_gcds = [nums[0]]
r_gcds = [nums[-1]]
for i in range(1, n - 1):
l = gcd(l_gcds[-1], nums[i])
r = gcd(r_gcds[-1], nums[n - i - 1])
l_gcds.append(l)
r_gcds.append(r)
r_gcds = r_gcds[::-1]
gcds = [l_gcds[-1], r_gcds[0]]
for i in range(1, n - 1):
gcds.append(gcd(l_gcds[i - 1], r_gcds[i]))
print((max(gcds)))
|
p03061
|
N=int(eval(input()))
nums = [int(i) for i in input().split()]
def gcd(x, y):
if x < y:
x = x ^ y
y = x ^ y
x = x ^ y
div = x % y
while div != 0:
x = y
y = div
div = x % y
return y
memo = {}
memo[(0, 1)] = nums[0]
memo[(N-1, N)] = nums[N-1]
for i in range(2, N+1):
memo[(0, i)] = gcd(memo[(0, i - 1)], nums[i-1])
# print("{} {} memo:{}".format(0, i, memo[(0,i)]))
for i in reversed(list(range(0, N-1))):
memo[(i, N)] = gcd(memo[(i + 1, N)], nums[i])
# print("{} {} memo:{}".format(i, N, memo[(i,N)]))
res = 1
for i in range(1, N-1):
res = max(res, gcd(memo[(0, i)], memo[(i+1, N)]))
# print("gcd:{}".format(gcd(memo[(0, i)], memo[(i+1, N)])))
res = max(res, memo[(0, N-1)])
res = max(res, memo[(1, N)])
print(res)
|
N=int(eval(input()))
nums = [int(i) for i in input().split()]
def gcd(x, y):
if x < y:
x = x ^ y
y = x ^ y
x = x ^ y
div = x % y
while div != 0:
x = y
y = div
div = x % y
return y
memo = {}
memo[(0, 1)] = nums[0]
memo[(N-1, N)] = nums[N-1]
for i in range(2, N+1):
memo[(0, i)] = gcd(memo[(0, i - 1)], nums[i-1])
for i in reversed(list(range(0, N-1))):
memo[(i, N)] = gcd(memo[(i + 1, N)], nums[i])
res = 1
for i in range(1, N-1):
res = max(res, gcd(memo[(0, i)], memo[(i+1, N)]))
res = max(res, memo[(0, N-1)])
res = max(res, memo[(1, N)])
print(res)
|
p03061
|
N = int(eval(input()))
A = [int(n) for n in input().split()]
import math, copy
def all_gcd(l):
a = l[0]
for i in range(1,len(l)):
b = l[i]
a = math.gcd(a, b)
return a
max_gcd = 0
for n in A:
copied_A = copy.copy(A)
copied_A.remove(n)
max_gcd = max(max_gcd, all_gcd(copied_A))
print(max_gcd)
|
import math
N = int(eval(input()))
A = [int(n) for n in input().split()]
gcd_l = [0]
gcd_r = [0]
for i in range(N):
gcd_l.append(math.gcd(gcd_l[i], A[i]))
gcd_r.append(math.gcd(gcd_r[i], A[-(i+1)]))
gcd_r = gcd_r[::-1]
max_gcd = 0
for i in range(N):
max_gcd = max(max_gcd, math.gcd(gcd_l[i], gcd_r[i+1]))
print(max_gcd)
|
p03061
|
import math
import copy
def gcd(a,b):
if b==0:return a
return gcd(b,a%b)
N=int(eval(input()))
A=list(map(int,input().split()))
if N==2:
print((max(A)))
exit()
else:
max=0
for i in range(N):
x = copy.deepcopy(A)
del x[i]
element = gcd(x[0], x[1])
if N==2:
c = element
else:
for i in range(2,N-1):
element=gcd(element,x[i])
c = element
if c >= max:
max = c
print(max)
|
def gcd(a,b):
if b==0:
return a
return gcd(b,a%b)
N=int(eval(input()))
A=list(map(int,input().split()))
AL=[0]*N
AR=[0]*N
for i in range(N):
if i == 0:
AL[0] = A[0]
AR[0] = A[N-1]
else:
AL[i] = gcd(AL[i-1],A[i])
AR[i] = gcd(AR[i-1],A[N-i-1])
max=0
for i in range(N):
if i == 0:
n_ex_gcd = AR[N-2]
elif i == N-1:
n_ex_gcd = AL[N-2]
else:
n_ex_gcd = gcd(AL[i-1],AR[N-i-2])
if n_ex_gcd > max:
max = n_ex_gcd
print(max)
|
p03061
|
def gcd(a, b):
if b == 0:
return a
elif a == 0:
return b
else:
return gcd(b, a % b)
def solve(n, a):
l, r = [], []
l = [0 for i in range(n + 1)]
r = [0 for i in range(n + 1)]
r[n] = 0
for i in range(0, n):
if i == 0:
l[0] = 0
else:
l[i] = gcd(l[i - 1], a[i - 1])
for i in range(n, 0, -1):
if i == n:
r[i] = 0
else:
r[i] = gcd(r[i+1], a[i])
m = 0
for i in range(n):
# print('m', m)
m = max(m, gcd(l[i], r[i + 1]))
return m
def input_from_console():
n = int(eval(input()))
a = list(map(int, input().split()))
return n, a
def main():
n, a_list = input_from_console()
print((solve(n, a_list)))
if __name__ == "__main__":
main()
|
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def solve(n, a):
l = [0] * n
r = [0] * (n + 1)
for i in range(1, n):
l[i] = gcd(l[i - 1], a[i - 1])
for i in range(n - 1, 0, -1):
r[i] = gcd(r[i + 1], a[i])
m = 0
for i in range(n):
m = max(m, gcd(l[i], r[i + 1]))
return m
def input_from_console():
n = int(eval(input()))
a = list(map(int, input().split()))
return n, a
def main():
n, a_list = input_from_console()
print((solve(n, a_list)))
if __name__ == "__main__":
main()
|
p03061
|
import math
from functools import reduce
N = int(eval(input()))
A = list(map(int,input().split()))
ans = 1
for i in range(N):
g = reduce(math.gcd,A[:i]+A[i+1:])
ans = max(ans,g)
print(ans)
|
import math
from collections import deque
N = int(eval(input()))
A = list(map(int,input().split()))
M = 0
L = deque([0])
R = deque([0])
for i in range(1,N+1):
L.append(math.gcd(L[-1],A[i-1]))
R.appendleft(math.gcd(R[0],A[N-i]))
for j in range(N):
m = math.gcd(L[j],R[j+1])
M = max(M,m)
print(M)
|
p03061
|
N = int(eval(input()))
A = [int(i) for i in input().split()]
def gcd(x, y):
if x < y:
x, y = y, x
if y == 0:
return x
return gcd(x%y, y)
L = [0]
R = [0]
for i in range(N):
L.append(gcd(A[i], L[i]))
R.append(gcd(A[-i-1], R[i]))
R.reverse()
M = []
for i in range(0, N):
M.append(gcd(L[i], R[i+1]))
print((max(M)))
|
N = int(eval(input()))
A = [int(i) for i in input().split()]
def gcd(x, y):
if x < y:
x, y = y, x
while y != 0:
x, y = y, x%y
return x
L = [0]
R = [0]
for i in range(N):
L.append(gcd(A[i], L[i]))
R.append(gcd(A[-i-1], R[i]))
R.reverse()
M = []
for i in range(0, N):
M.append(gcd(L[i], R[i+1]))
print((max(M)))
|
p03061
|
"""
最大公約数をもっとも落としている数Xを削る（＝見ないことにする）、という発想に置き換える。
方針１：
Xを特定する。
どうやって特定する？
各Aを素因数分解する。このとき、他の
方針２：
約数をカウントする。すべてのAの約数をカウントして総和する。
このとき、カウントがN個になる約数は初期状態での公約数である。
一方で、カウントがN-1個の約数は、その約数をもたない数が一つだけ存在するということなので、
そのような数Aを削ったときに、公約数になる。
したがって、カウントがN-1個以上の約数のうち最大のものが、数Xを削ったときの最大公約数である。
問題はどうやって約数をカウントするかだ。愚直にやるとO(N√max(A))かかるため間に合わない。
ただ、約数の数自体はせいぜい1000個くらいのはず。いったん素因数分解してから、各素因数を何個累乗させるかで考えればよいか。
"""
def main():
from collections import Counter
N = int(eval(input()))
A = list(map(int,input().split()))
count = {}
for a in A:
tmp = []
d = 2
while d*d <= a:
while a%d == 0:
tmp.append(d)
a //= d
d += 1
if a != 1:
tmp.append(a)
divides = [1]
for k,v in list(Counter(tmp).items()):
M = len(divides)
for i in range(1,v+1):
for j in range(M):
divides.append(divides[j]*pow(k,i))
for d in divides:
if d not in count:
count[d] = 0
count[d] += 1
ans = 0
for k,v in list(count.items()):
if v >= N-1:
ans = max(ans,k)
print(ans)
main()
|
def gcd(a,b):
if a == 0 or b == 0:
return max(a,b)
return a if b==0 else gcd(b,a%b)
N = int(eval(input()))
A = list(map(int,input().split()))
rA = A[::-1]
LEFT = [0]
g = A[0]
for i in range(N):
g = gcd(g,A[i])
LEFT.append(g)
RIGHT = [0]
g = rA[0]
for i in range(N):
g = gcd(g,rA[i])
RIGHT.append(g)
ans = 0
for i in range(1,N+1):
ans = max(ans,gcd(LEFT[i-1],RIGHT[N-i]))
print(ans)
|
p03061
|
import math
import copy
import sys
import bisect
input = sys.stdin.readline
def divide(x): #約数配列
div=[1]
check=2
for check in range(1,int(x**0.5)+1):
if(x%check==0):
div.append(check)
div.append(x//check)
return div
def main():
n=int(eval(input()))
a = list(map(int,input().split()))
ans={}
for i in range(n):
div=divide(a[i])
for c in div:
if c not in ans:
ans[c]=1
else:
ans[c]+=1
M=1
for c in ans:
if ans[c]>=n-1:
M=max(M,c)
print(M)
if __name__ == "__main__":
main()
|
def gcd(a, b): #最大公約数
if b == 0:
return a
else:
return gcd(b, a%b)
def main():
n=int(eval(input()))
a = list(map(int,input().split()))
L=[a[0] for _ in range(n)]
R=[a[n-1] for _ in range(n)]
for i in range(1,n):
L[i]=gcd(L[i-1],a[i])
for i in range(1,n):
R[i]=gcd(R[i-1],a[n-1-i])
R.reverse()
LR=[]
for i in range(1,n-1):
LR.append( gcd(L[i-1],R[i+1]) )
if LR==[]:
print((max(L[n-2],R[1] )))
else:
print((max(max(LR),L[n-2],R[1] )))
if __name__ == "__main__":
main()
|
p03061
|
n = int(input())
a = input().split()
cnt = 0
for i in a:
a[cnt] = int(i)
cnt += 1
chk = {}
chk2 = {}
def make_divisors(k):
divisors = []
for i in range(1, int(k**0.5)+1):
if k % i == 0:
if i in chk:
chk[i] += 1
else:
chk[i] = 1
if i != k // i:
key = int(k//i)
if key in chk:
chk[key] += 1
else:
chk[key] = 1
return divisors
for i in range(2):
make_divisors(a[i])
cnt = 1
for i in range(2,len(a)):
k = a[i]
if k in chk:
make_divisors(k)
cnt += 1
continue
del_list = []
for j in chk:
if k % j == 0:
chk[j] += 1
if chk[j] < cnt+1:
del_list.append(j)
for j in del_list:
del chk[j]
cnt += 1
answer = 0
for i in chk:
if int(chk[i]) >= chk[1] - 1 and i > answer:
answer = i
print(answer)
|
n = int(input())
a = input().split()
cnt = 0
for i in a:
a[cnt] = int(i)
cnt += 1
chk = {}
chk2 = {}
def make_divisors(k):
divisors = []
for i in range(1, int(k**0.5)+1):
if k % i == 0:
if i in chk:
chk[i] += 1
else:
chk[i] = 1
if i != k // i:
key = int(k//i)
if key in chk:
chk[key] += 1
else:
chk[key] = 1
return divisors
for i in range(2):
make_divisors(a[i])
cnt = 1
for i in range(2,len(a)):
k = a[i]
if k not in chk2:
chk2[k] = 1
else:
if chk2[k] == 1:
chk2[k] += 1
elif chk2[k] > 1:
continue
del_list = []
for j in chk:
if k % j == 0:
chk[j] += 1
if chk[j] < cnt+1:
del_list.append(j)
for j in del_list:
del chk[j]
cnt += 1
answer = 0
for i in chk:
if int(chk[i]) >= chk[1] - 1 and i > answer:
answer = i
print(answer)
|
p03061
|
memo = {}
def gcd(a, b):
if (a, b) in list(memo.keys()):
return memo[(a, b)]
if b == 0:
return a
g = gcd(b, a % b)
memo[(a, b)] = g
return g
n = eval(input())
a_list = list(map(int, input().split()))
max_g = 0
for exclude in range(n):
g = a_list[0] if exclude > 0 else a_list[1]
for i, a in enumerate(a_list):
if i == 0 or i == exclude:
continue
g_new = gcd(g, a)
if (g, a) not in memo:
memo[(g, a)] = g_new
g = g_new
if g <= max_g:
break
if g > max_g:
max_g = g
print(max_g)
|
def gcd(a, b):
if b == 0:
return a
g = gcd(b, a % b)
return g
n = eval(input())
a_list = list(map(int, input().split()))
gs1 = [None] * n
gs1[0] = a_list[0]
for i in range(1, n):
gs1[i] = gcd(gs1[i - 1], a_list[i])
gs2 = [None] * n
gs2[n - 1] = a_list[n - 1]
for i in reversed(range(n - 1)):
gs2[i] = gcd(gs2[i + 1], a_list[i])
max_g = 0
for exclude in range(n):
if exclude == 0:
g = gs2[1]
elif exclude == n - 1:
g = gs1[n - 2]
else:
g = gcd(gs1[exclude - 1], gs2[exclude + 1])
if g > max_g:
max_g = g
print(max_g)
|
p03061
|
import functools
# import math
def solve():
N = int(eval(input()))
A = [int(i) for i in input().split()]
# gcd = functools.reduce(math.gcd, A)
max_gcd = 1
for i in range(N):
A_ = A.copy()
A_.remove(A[i])
max_gcd = max(max_gcd, functools.reduce(gcd, A_))
print(max_gcd)
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
if __name__ == '__main__':
solve()
|
# 解説を参考に作成
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
def gcd(a, b):
"""最大公約数"""
a, b = (a, b) if a >= b else (b, a)
if b == 0:
return a
return gcd(b, a % b)
# from decorator import stop_watch
#
#
# @stop_watch
def solve(N, A):
L = [0] * N
L[0] = A[0]
for i in range(1, N):
L[i] = gcd(A[i], L[i - 1])
R = [0] * N
R[-1] = A[-1]
for i in range(1, N):
R[-(i + 1)] = gcd(A[-(i + 1)], R[-i])
ans = 0
for i in range(N):
if i == 0:
ans = max(ans, R[i + 1])
elif i == N - 1:
ans = max(ans, L[i - 1])
else:
ans = max(ans, gcd(L[i - 1], R[i + 1]))
print(ans)
if __name__ == '__main__':
# S = input()
N = int(eval(input()))
# N, M = map(int, input().split())
A = [int(i) for i in input().split()]
# B = [int(i) for i in input().split()]
# AB = [[int(i) for i in input().split()] for _ in range(N)]
solve(N, A)
# # test
# from random import randint
# from func import random_str
# solve()
|
p03061
|
mod = 10 ** 9 + 7
mod2 = 2**61+1
from collections import deque
import heapq
from bisect import bisect_left, insort_left, bisect_right
def iip(listed=True):
ret = [int(i) for i in input().split()]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iip_ord():
return [ord(i) - ord("a") for i in eval(input())]
def main():
ans = solve()
if ans is not None:
print(ans)
def solve():
N = iip(False)
A = iip()
A.sort()
A1 = [i for i in A]
A2 = [i for i in A]
ss1 = soinsuu_bunkai(A[0])
ss2 = soinsuu_bunkai(A[1])
ah1 = [1 for _ in A]
ah2 = [1 for _ in A]
#print(A)
ak1 = 1
for i in ss1:
out = 0
ahk = None
for j, a in enumerate(A1):
if a % i != 0:
out += 1
if out == 2: #2回アウトなら終了。
break
else:
ahk = j
else:
A1[j] //= i
if out == 2:
continue
elif out == 1:
ah1[ahk] *= i
else:
ak1 *= i
ak2 = 1
for i in ss2:
out = 0
ahk = None
for j, a in enumerate(A2):
if a % i != 0:
out += 1
if out == 2: #2回アウトなら終了。
break
else:
ahk = j
else:
A2[j] //= i
if out == 2:
continue
elif out == 1:
ah2[ahk] *= i
else:
ak2 *= i
#print(ak1)
#print(ah1)
#print(ak2)
#print(ah2)
print((max(ak1*max(ah1), ak2*max(ah2))))
#####################################################ライブラリ集ここから
def fprint(s):
for i in s:
print(i)
def split_print_space(s):
print((" ".join([str(i) for i in s])))
def split_print_enter(s):
print(("\n".join([str(i) for i in s])))
def koenai_saidai_x_index(sorted_list, n):
l = 0
r = len(sorted_list)
if len(sorted_list) == 0:
return False
if sorted_list[0] > n:
return False
while r - l > 1:
x = (l + r) // 2
if sorted_list[x] == n:
return x
elif sorted_list[x] > n:
r = x
else:
l = x
return l
def searchsorted(sorted_list, n, side):
if side not in ["right", "left"]:
raise Exception("sideはrightかleftで指定してください")
l = 0
r = len(sorted_list)
if n > sorted_list[-1]:
# print(sorted_list)
return len(sorted_list)
if n < sorted_list[0]:
return 0
while r - l > 1:
x = (l + r) // 2
if sorted_list[x] > n:
r = x
elif sorted_list[x] < n:
l = x
else:
if side == "left":
r = x
elif side == "right":
l = x
if side == "left":
if sorted_list[l] == n:
return r - 1
else:
return r
if side == "right":
if sorted_list[l] == n:
return l + 1
else:
return l
def soinsuu_bunkai(n):
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False):
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod):
return power(n, mod - 2)
def power(n, p, mod_= mod):
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
if __name__ == "__main__":
main()
|
mod = 10 ** 9 + 7
mod2 = 2**61+1
from collections import deque
import heapq
from bisect import bisect_left, insort_left, bisect_right
def iip(listed=True):
ret = [int(i) for i in input().split()]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iip_ord():
return [ord(i) - ord("a") for i in eval(input())]
def main():
ans = solve()
if ans is not None:
print(ans)
def solve():
N = iip(False)
A = iip()
A.sort()
A1 = [i for i in A]
A2 = [i for i in A]
ss1 = soinsuu_bunkai(A[0])
ss2 = soinsuu_bunkai(A[1])
ah1 = [1 for _ in A]
ss1.extend(ss2)
#print(A)
ak1 = 1
for i in ss1:
out = 0
ahk = None
for j, a in enumerate(A1):
if a % i != 0:
out += 1
if out == 2: #2回アウトなら終了。
break
else:
ahk = j
else:
A1[j] //= i
if out == 2:
continue
elif out == 1:
ah1[ahk] *= i
else:
ak1 *= i
#print(ak1)
#print(ah1)
#print(ak2)
#print(ah2)
print((ak1*max(ah1)))
#####################################################ライブラリ集ここから
def fprint(s):
for i in s:
print(i)
def split_print_space(s):
print((" ".join([str(i) for i in s])))
def split_print_enter(s):
print(("\n".join([str(i) for i in s])))
def koenai_saidai_x_index(sorted_list, n):
l = 0
r = len(sorted_list)
if len(sorted_list) == 0:
return False
if sorted_list[0] > n:
return False
while r - l > 1:
x = (l + r) // 2
if sorted_list[x] == n:
return x
elif sorted_list[x] > n:
r = x
else:
l = x
return l
def searchsorted(sorted_list, n, side):
if side not in ["right", "left"]:
raise Exception("sideはrightかleftで指定してください")
l = 0
r = len(sorted_list)
if n > sorted_list[-1]:
# print(sorted_list)
return len(sorted_list)
if n < sorted_list[0]:
return 0
while r - l > 1:
x = (l + r) // 2
if sorted_list[x] > n:
r = x
elif sorted_list[x] < n:
l = x
else:
if side == "left":
r = x
elif side == "right":
l = x
if side == "left":
if sorted_list[l] == n:
return r - 1
else:
return r
if side == "right":
if sorted_list[l] == n:
return l + 1
else:
return l
def soinsuu_bunkai(n):
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False):
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod):
return power(n, mod - 2)
def power(n, p, mod_= mod):
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
if __name__ == "__main__":
main()
|
p03061
|
#!/usr/bin/env python3
import sys
import math
from collections import Counter
import collections
INF = float("inf")
def factorial(n):
# 試し割りによる素因数分解
prime_count = collections.Counter()
for i in range(2, int(math.sqrt(n)) + 2):
while n % i == 0:
n /= i
prime_count[i] += 1
if n > 1:
prime_count[int(n)] += 1
return prime_count
def GCD(a, b):
if a == 0:
return b
else:
return GCD(b % a, a)
def GCDs(*a):
# リストで入力しないよう注意。
if len(a) == 0:
return -1 # エラー
if len(a) == 1:
return a[0]
res = a[0]
for i in range(1, len(a)):
res = GCD(res, a[i])
return res
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)
# divisors.sort()
return divisors
def solve(N: int, A: "List[int]"):
c1 = make_divisors(A[0])
c2 = make_divisors(A[1])
c = sorted(list(set(c1 + c2)))
OKs = []
for cv in c:
if sum([1 if a % cv == 0 else 0 for a in A]) >= N-1:
OKs.append(cv)
print((max(OKs)))
# b = A[0]
# m = INF
# mi = -1
# for i in range(N):
# g = GCD(A[i], b)
# print(g)
# if m > g:
# m = g
# mi = i
# buf = None
# for i in range(N):
# if mi == i:
# continue
# if buf is None:
# buf = A[i]
# else:
# buf = GCD(buf, A[i])
# print([buf, GCDs(*A[1:])])
# print("回答: ", max([buf, GCDs(*A[1:])]))
# # print(g)
# s = SegmentTree(N)
# for i in range(N):
# s.update(i, A[i])
# # print("tree ", s.tree)
# g = []
# for i in range(N):
# # iを覗いたGCDをとる
# if i == 0:
# g.append(s.query(1, N))
# elif i == N-1:
# g.append(s.query(0, N-1))
# else:
# # print(s.query(0, i), s.query(i+1, N))
# g.append(GCD(s.query(0, i), s.query(i+1, N)))
# # print(g)
# # print("回答2: ", max(g))
# print(max(g))
# g = []
# for i in range(N):
# buf = None
# for j in range(N):
# if i == j:
# continue
# if buf is None:
# buf = A[j]
# else:
# buf = GCD(buf, A[j])
# g.append(buf)
# # print(g)
# print("正解：", max(g))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
import math
from collections import Counter
import collections
INF = float("inf")
def factorial(n):
# 試し割りによる素因数分解
prime_count = collections.Counter()
for i in range(2, int(math.sqrt(n)) + 2):
while n % i == 0:
n /= i
prime_count[i] += 1
if n > 1:
prime_count[int(n)] += 1
return prime_count
def GCD(a, b):
if a == 0:
return b
else:
return GCD(b % a, a)
def GCDs(*a):
# リストで入力しないよう注意。
if len(a) == 0:
return -1 # エラー
if len(a) == 1:
return a[0]
res = a[0]
for i in range(1, len(a)):
res = GCD(res, a[i])
return res
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)
# divisors.sort()
return divisors
def solve(N: int, A: "List[int]"):
asc = [0]
for i in range(N):
asc.append(GCD(asc[-1], A[i]))
desc = [0]
for i in range(N):
desc.append(GCD(desc[-1], A[N-i-1]))
buf = []
for i in range(N):
buf.append(GCD(asc[i], desc[N-i-1]))
print((max(buf)))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
|
p03061
|
from functools import reduce
def gcd_base(x, y):
if x >= y:
while y != 0:
x, y = y, x % y
return x
else:
while x != 0:
y, x = x, y % x
return y
def gcd(numbers):
return reduce(gcd_base, numbers)
N = int(eval(input()))
A = list(map(int, input().split()))
GCD = []
for i in range(N):
a = A.pop(0)
GCD.append(gcd(A))
A.append(a)
print((max(GCD)))
|
def gcd(x, y):
if x >= y:
while y != 0:
x, y = y, x % y
return x
else:
while x != 0:
y, x = x, y % x
return y
N = int(eval(input()))
A = list(map(int, input().split()))
L = [0, 0]
for ai in A:
L.append(gcd(L[-1], ai))
R = [0, 0]
for ai in A[::-1]:
R.append(gcd(R[-1], ai))
print((max(gcd(l, r) for l, r in zip(L, reversed(R)))))
|
p03061
|
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
input = sys.stdin.readline
# bisect_left(lists, 3)
# bisect_right(lists, 3)
def main():
N = int(eval(input()))
A = input().split()
A = [int(s) for s in A]
ans = -1
Lis = [[-1 for _ in range(N)] for _ in range(N)]
for i, val in enumerate(A):
tmp = -1
for j, vol in enumerate(A):
if i == j:
continue
if tmp == -1:
tmp = vol
continue
if Lis[i][j] != -1:
tmp = Lis[i][j]
else:
tmp = gcd(vol, tmp)
Lis[i][j] = tmp
if ans == -1 or tmp > ans:
ans = tmp
print(ans)
def gcd(a, b):
if a > b:
a, b = b, a
while a > 0:
a, b = b % a, a
return b
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
input = sys.stdin.readline
# bisect_left(lists, 3)
# bisect_right(lists, 3)
def main():
N = int(eval(input()))
A = input().split()
A = [int(s) for s in A]
base = -1
for i, val in enumerate(A):
if i == 0:
base == val
continue
base = gcd(val, base)
ans = base
for i, val in enumerate(A):
tmp = -1
for j, vol in enumerate(A):
if i == j:
continue
if tmp == -1:
tmp = vol
continue
tmp = gcd(vol, tmp)
if tmp <= base:
break
if tmp > ans:
ans = tmp
print(ans)
def gcd(a, b):
if a > b:
a, b = b, a
while a > 0:
a, b = b % a, a
return b
if __name__ == "__main__":
main()
|
p03061
|
class SegmentTree:
def __init__(self, seq, func="min"):
if func=="min":
self.f = min
self.e = float('inf')
if func=="max":
self.f = max
self.e = -float('inf')
if func=="gcd":
self.f = gcd
self.e = 0
self._n = len(seq)
self.n_seg = 2**(self._n-1).bit_length()
self.seg = [self.e]*2*self.n_seg
for i in range(self._n):
self.seg[self.n_seg+i-1] = seq[i]
for i in range(self.n_seg-2, -1, -1):
self.seg[i] = self.f(self.seg[2*i+1], self.seg[2*i+2])
def update(k, val):
k += self.n_seg -1
self.seg[k] = val
while k+1:
k = (k-1)//2
self.seg[k] = self.f(self.seg[k*2+1], self.seg[k*2+2])
def query(self, a, b):
if b<=a:
return self.e
a += self.n_seg-1
b += self.n_seg-2
res = self.e
while b-a>1:
if a&1==0:
res = self.f(res, self.seg[a])
if b&1==1:
res = self.f(res, self.seg[b])
b -= 1
a = a//2
b = (b-1)//2
if a==b:
res = self.f(res, self.seg[a])
else:
res = self.f(self.f(res, self.seg[a]), self.seg[b])
return res
def __repr__(self):
ret = str(self.seg[self._n-1:])
return ret
def gcd(a, b):
if b>a:
a, b = b, a
while b:
a, b = b, a%b
return a
if __name__=="__main__":
N = int(eval(input()))
A = list(map(int, input().split()))
A_seg = SegmentTree(A, func="gcd")
ans = -1
for i in range(N):
ans = max(ans, gcd(A_seg.query(0, i), A_seg.query(i+1, N)))
print(ans)
|
def gcd(a, b):
if b==0:
return a
while b>0:
a, b = b, a%b
return a
N = int(eval(input()))
A = list(map(int, input().split()))
S_left = [0 for _ in range(N+1)]
S_right = [0 for _ in range(N+1)]
for i in range(N):
S_left[i+1] = gcd(S_left[i], A[i])
S_right[i+1] = gcd(S_right[i], A[-i-1])
S_right = S_right[::-1]
S_left = S_left + [0]
S_right = [0] + S_right
ans = 0
for i in range(1, N+1):
ans = max(ans, gcd(S_left[i-1], S_right[i+1]))
print(ans)
|
p03061
|
n=int(eval(input()))
l=list(map(int,input().split()))
gcds=[]
def gcd(a,b):
if b==0:
return a
return gcd(b,a%b)
for i in range(len(l)):
omitlist=list(l)
omitlist.pop(i)
n=len(omitlist)
if n==1:
gcds.append(omitlist[0])
else:
element = gcd(omitlist[0], omitlist[1])
if n==2:
gcds.append(element)
else:
for i in range(2,n):
element=gcd(element,omitlist[i])
gcds.append(element)
print((max(gcds)))
|
n=int(eval(input()))
left=list(map(int,input().split()))
right=list(left)
right.reverse()
gcds=[]
gcdleft=[]
gcdright=[]
gcdleft.append(left[0])
gcdright.append(right[0])
def gcd(a,b):
if b==0:
return a
return gcd(b,a%b)
if n==2:
gcds.append(gcdleft[0])
gcds.append(gcdright[0])
else:
for i in range(1,n-1):
gcdleft.append(gcd(gcdleft[i-1],left[i]))
gcdright.append(gcd(gcdright[i-1],right[i]))
gcds.append(gcdright[-1])
for i in range(0,n-2):
gcds.append(gcd(gcdleft[i],gcdright[n-3-i]))
gcds.append(gcdleft[-1])
print((max(gcds)))
|
p03061
|
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
def gcd_arr(arr, N):
if N == 2:
return gcd(arr[0], arr[1])
elif N == 1:
return arr[0]
else:
mid = N // 2
return gcd(gcd_arr(arr[:mid], mid), gcd_arr(arr[mid:], N-mid))
def gcd_arr_with_rm(arr, N, remove = 0):
return gcd_arr(arr[0:remove] + arr[(remove+1):], N - 1)
def solve():
N = int(input())
arr = [int(_) for _ in input().split()]
max_gcd = 1
for j in range(N):
tmp = gcd_arr_with_rm(arr, N, remove = j)
if tmp > max_gcd:
max_gcd = tmp
print(str(max_gcd))
if __name__ == '__main__':
solve()
|
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
def solve():
N = int(input())
arr = [int(_) for _ in input().split()]
left = [0] * (N + 1)
right = [0] * (N + 1)
left[0] = 0
right[N] = 0
for i in range(1, N+1):
left[i] = gcd(left[i - 1], arr[i - 1])
for i in range(N - 1, 0, -1):
right[i] = gcd(right[i + 1], arr[i])
max_gcd = 0
for i in range(N):
max_gcd = max(max_gcd, gcd(left[i], right[i+1]))
print(str(max_gcd))
if __name__ == '__main__':
solve()
|
p03061
|
import copy
n = int(eval(input()))
l = sorted(list(map(int, input().split())))
b = []
def gcd(a,b):
while b:
a, b = b, a % b
return a
if n == 2:
print((max(l[0],l[1])))
elif n == 3:
print((max(gcd(l[0],l[1]),gcd(l[0],l[2]),gcd(l[2],l[1]))))
else:
for i in range(n):
tmp = copy.copy(l)
tmp.pop(i)
x = gcd(tmp[0],tmp[1])
for j in list(range(2, n-1)):
x = gcd(x,tmp[j])
b.append(x)
print((max(b)))
|
def gcd(a,b):
while b:a,b=b,a%b
return a
n,a,b=int(eval(input())),list(map(int,input().split())),[]
if n==2:print((max(a[0],a[1])))
elif n==3:print((max(gcd(a[0],a[1]),gcd(a[0],a[2]),gcd(a[1],a[2]))))
else:
no,mi=a[0],a[0]
for i in range(1,n):
s=gcd(no,a[i])
if s!=no:
no=max(s,mi)
mi=gcd(s,mi)
print(no)
|
p03061
|
n=int(eval(input()))
A=list(map(int,input().split()))
divsors=[]
for i in range(n):
for j in range(1,int(A[i]**(1/2)+1)):
if A[i]%j==0:
divsors.append(j)
if j!=A[i]//j:
divsors.append(A[i]//j)
set_divsors=sorted(list(set(divsors)))[::-1]
for i in range(len(set_divsors)):
a=divsors.count(set_divsors[i])
if a==n or a==n-1:
print((set_divsors[i]))
break
|
n=int(eval(input()))
A=[]*n
A[:]=list(map(int,input().split()))
def gcd(a,b):
while b:
a,b=b,a%b
return a
left=[0]*n
right=[0]*n
for i in range(1,n):
left[i]=gcd(left[i-1],A[i-1])
right[n-1-i]=gcd(right[n-i],A[n-i])
ans=0
for i,j in zip(left,right):
ans=max(ans,gcd(i,j))
print(ans)
|
p03061
|
from functools import reduce
def gcd(a,b):
while b!=0:
a,b=b,a%b
return a
def gcd_list(numbers):
return reduce(gcd, numbers)
N = int(eval(input()))
A = list(map(int, input().split()))
max_ans = 0
for i in range(len(A)):
tmp = A[:i] + A[1+i:]
ans = gcd_list(tmp)
if max_ans < ans:
max_ans = ans
print(max_ans)
|
def gcd(a,b):
while b!=0:
a,b=b,a%b
return a
N = int(eval(input()))
A = list(map(int, input().split()))
# 累積最大公約数的な
head = []
tail = []
head.append(A[0])
tail.append(A[-1])
for i, j in zip(A[1:], A[N-2::-1]):
head.append(gcd(head[-1], i))
tail.append(gcd(tail[-1], j))
ans = 0
for i in range(len(head)-2):
tmp = gcd(head[i], tail[len(tail)-1-2-i])
if ans < tmp:
ans = tmp
print((max(head[-1], head[-2], tail[-2], ans)))
|
p03061
|
def gcd(a, b):
while b:
a, b = b, a % b
return a
N = int(eval(input()))
A = list(map(int, input().split()))
d = {}
m = []
if len(A) == 2:
print((max(A)))
exit()
for i in range(N):
_A = []
_A.extend(A[0:i])
_A.extend(A[i+1:N])
for j in range(1, len(_A)):
if j == 1:
tmp = gcd(_A[j], _A[j-1])
else:
tmp = gcd(_A[j], tmp)
m.append(tmp)
print((max(m)))
|
def gcd(a, b):
while b:
a, b = b, a % b
return a
N = int(eval(input()))
A = list(map(int, input().split()))
L = [0] * N
R = [0] * N
L[0] = A[0]
R[N-1] = A[-1]
for n in range(1, N):
L[n] = gcd(L[n - 1], A[n])
for n in reversed(list(range(N-1))):
R[n] = gcd(R[n + 1], A[n])
ans = 0
for n in range(N):
if n == 0:
ans = max(ans, R[n+1])
elif n == N - 1:
ans = max(ans, L[n-1])
else:
ans = max(ans, gcd(L[n-1], R[n+1]))
print(ans)
|
p03061
|
from collections import deque
def gcm(a, b):
if a < b:
a = a+b
b=a-b
a = a-b
if b == 0:
return a
else:
r = a%b
return b if r == 0 else gcm(b, r)
N = int(eval(input()))
A = list(map(int, input().split()))
L = deque([0])
for i in range(1, N):
L.append(gcm(L[-1],A[i-1]))
R = deque([0])
for i in reversed(list(range(N-1))):
R.appendleft(gcm(R[0],A[i+1]))
ans = 0
for i in range(N):
ans = max(ans, gcm(L[i],R[i]))
print(ans)
|
import sys
sys.setrecursionlimit(10**5)
def GCM(a, b):
if a < b:
a += b
b = a-b
a -= b
if a % b == 0:
return b
else:
return GCM(b, a%b)
N = int(eval(input()))
A = list(map(int, input().split()))
l2r =[]
r2l = []
g = A[0]
for a in A:
g = GCM(g, a)
l2r.append(g)
g = A[-1]
for a in reversed(A):
g = GCM(g, a)
r2l.append(g)
r2l = list(reversed(r2l))
ans = r2l[1]
for i in range(1, N-1):
ans = max(ans, GCM(l2r[i-1], r2l[i+1]))
ans = max(ans, l2r[N-2])
print(ans)
|
p03061
|
def gcd(x, y):
if y == 0:
return x
return gcd(y, x % y)
class SEGMENT_TREE:
def __init__(self, N):
self.N = N
self.tree = [0] * (2 * N) # 問題により修正
def init(self, arr):
N = self.N
for i in range(N):
self.tree[N + i] = arr[i]
for i in range(N - 1, 0, -1):
self.tree[i] = gcd(
self.tree[i * 2], self.tree[i * 2 + 1]) # 問題により修正
def update(self, p, value):
i = p + self.N
self.tree[i] = value
while i > 1:
self.tree[i >> 1] = gcd(self.tree[i], self.tree[i ^ 1]) # 問題により修正
i >>= 1
def query(self, l, r):
N = self.N
res = 0 # 問題により修正
l += N
r += N
while l < r:
if (l & 1):
res = gcd(res, self.tree[l]) # 問題により修正
l += 1
if (r & 1):
r -= 1
res = gcd(res, self.tree[r]) # 問題により修正
l >>= 1
r >>= 1
return res
if __name__ == "__main__":
N = int(eval(input()))
A = list(map(int, input().split()))
seg = SEGMENT_TREE(N)
seg.init(A)
ans = 0
for i, a in enumerate(A):
seg.update(i, 0)
ans = max(ans, seg.query(0, N))
seg.update(i, a)
print(ans)
|
def gcd(x, y):
if y == 0:
return x
return gcd(y, x % y)
class SEGMENT_TREE:
def __init__(self, N):
self.N = N
self.tree = [0] * (2 * N) # 問題により修正
def init(self, arr):
N = self.N
for i in range(N):
self.tree[N + i] = arr[i]
for i in range(N - 1, 0, -1):
self.tree[i] = gcd(
self.tree[i * 2], self.tree[i * 2 + 1]) # 問題により修正
def update(self, p, value):
i = p + self.N
self.tree[i] = value
while i > 1:
self.tree[i // 2] = gcd(self.tree[i], self.tree[i ^ 1]) # 問題により修正
i //= 2
def query(self, l, r):
N = self.N
res = 0 # 問題により修正
l += N
r += N
while l < r:
if (l & 1):
res = gcd(res, self.tree[l]) # 問題により修正
l += 1
if (r & 1):
r -= 1
res = gcd(res, self.tree[r]) # 問題により修正
l //= 2
r //= 2
return res
if __name__ == "__main__":
N = int(eval(input()))
A = list(map(int, input().split()))
seg = SEGMENT_TREE(N)
seg.init(A)
ans = 0
for i in range(N):
tmp = gcd(seg.query(0, i), seg.query(i + 1, N))
ans = max(ans, tmp)
print(ans)
|
p03061
|
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)
divisors.sort(reverse=True)
return divisors
N = int(eval(input()))
A = sorted([int(x) for x in input().split()])
ans = 1
for i in range(2):
divisors = make_divisors(A[i])
for divisor in divisors:
indivisible_count = 0
for j in range(N):
if A[j] % divisor != 0:
indivisible_count += 1
if indivisible_count <= 1 and divisor > ans:
ans = divisor
print(ans)
|
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
N = int(eval(input()))
A = sorted([int(x) for x in input().split()])
ans = 1
divisors = make_divisors(A[0]) + make_divisors(A[1])
divisors = sorted(set(divisors), reverse=True)
for divisor in divisors:
indivisible_count = 0
for i in range(N):
if A[i] % divisor != 0:
indivisible_count += 1
if indivisible_count <= 1:
ans = divisor
break
print(ans)
|
p03061
|
# 2019-11-18 00:38:19(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# import re
# import heapq
# import array
# from scipy.misc import comb # (default: exact=False)
# import numpy as np
def main():
n, k = [int(x) for x in sys.stdin.readline().split()]
s = sys.stdin.readline().rstrip()
happy_count = 0
happy_count += sum(1 for i in range(n-1) if s[i] == s[i+1])
happy_count += 2 * k
ans = min(happy_count, n - 1)
print(ans)
if __name__ == "__main__":
main()
|
# 2019-11-18 00:38:19(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# import re
# import heapq
# import array
# from scipy.misc import comb # (default: exact=False)
# import numpy as np
def main():
n, k = [int(x) for x in sys.stdin.readline().split()]
s = sys.stdin.readline().rstrip()
happy_count = sum([0] + [1 for i in range(n-1) if s[i] == s[i+1]])
happy_count += 2 * k
ans = min(happy_count, n - 1)
print(ans)
if __name__ == "__main__":
main()
|
p02918
|
N,K=list(map(int, input().split()))
S=list(input())
L=[]
now=None
for i,s in enumerate(S):
if i==0:
now=s
cnt=1
elif now==s:
cnt+=1
elif now!=s:
L.append([now,cnt])
cnt=1
now=s
else:
L.append([now,cnt])
l=len(L)
for i in range(1,min(K*2,l),2):
s=L[i][0]
if s=="L": L[i][0]="R"
elif s=="R": L[i][0]="L"
ans=0
prev=None
for t in L:
s=t[0]
cnt=t[1]
if prev is None:
prev=s
lcnt=cnt
else:
if prev==s:
lcnt+=cnt
elif prev!=s:
ans+=(lcnt-1)
lcnt=cnt
prev=s
else:
ans+=(lcnt-1)
print(ans)
|
# -*- coding: utf-8 -*-
import sys
N,K=list(map(int, sys.stdin.readline().split()))
S=sys.stdin.readline().strip()
L=[]
cnt=0
for i,x in enumerate(S):
if i==0:
cnt+=1
prev=x
else:
if prev==x: #前の文字と今の文字が同じ
cnt+=1
else: #前の文字と今の文字が異なる
L.append(cnt)
cnt=1
prev=x
else:
L.append(cnt)
print(sum(L)-max(1,len(L)-2*K))
|
p02918
|
import sys,math,collections,itertools
input = sys.stdin.readline
N,K=list(map(int,input().split()))
S=input().rstrip()
ori_num=0
turn_num=0
for i in range(N):
if i>0:
if S[i-1] =='L' and S[i] =='L':
ori_num += 1
if S[i-1] != S[i]:
turn_num +=1
if i<N-1:
if S[i] =='R' and S[i+1] =='R':
ori_num += 1
while K:
if turn_num >1:
turn_num -= 2
K -= 1
ori_num += 2
elif turn_num ==1:
ori_num +=1
K=0
print(ori_num)
|
import sys,math,collections,itertools
input = sys.stdin.readline
N,K=list(map(int,input().split()))
S=input().rstrip()
ori_num=0
turn_num=0
for i in range(N):
if i>0:
if S[i-1] =='L' and S[i] =='L':
ori_num += 1
if S[i-1] != S[i]:
turn_num +=1
if i<N-1:
if S[i] =='R' and S[i+1] =='R':
ori_num += 1
if turn_num >=2*K:
ori_num += 2*K
else:
num = turn_num//2
num2 = turn_num%2
ori_num += 2*num+num2
print(ori_num)
|
p02918
|
import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, k = list(map(int, input().rstrip('\n').split()))
s = str(input().rstrip('\n'))
cnt = 0
for i in range(1, n):
if s[i-1] == s[i]:
cnt += 1
print((min(n - 1, cnt + k * 2)))
if __name__ == '__main__':
solve()
|
import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, k = list(map(int, input().rstrip('\n').split()))
s = str(input().rstrip('\n'))
cnt = 0
for i in range(1, n):
if s[i] == s[i-1]:
cnt += 1
print((min(n - 1, cnt + k * 2)))
if __name__ == '__main__':
solve()
|
p02918
|
# -*- coding: utf-8 -*-
# https://atcoder.jp/contests/abc140/tasks/abc140_d
N, K = list(map(int, input().split()))
S = input().strip()
happiness = 0
for idx in range(1, N):
if S[idx] == S[idx - 1]:
happiness += 1
# 一人しか幸せにできないときがあるか?
#
# あっ...これは不要なのでは...
# 単に後述の幸せの最大値で丸めればよいのでは
# always_two_happiness = S[0] == S[-1]
# 幸せの最大値
max_happiness = N - 1
for i in range(K):
happiness += 2
print((min(happiness, max_happiness)))
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
N, K = list(map(int, input().split()))
S = input().strip()
# 初期の幸せ度を調べる
happiness = 0
previous_face = S[0]
for i in range(1, N):
if S[i] == previous_face:
happiness += 1
else:
previous_face = S[i]
# 並べ替え後の幸せ度
happiness = happiness + 2 * K
if N - 1 < happiness:
happiness = N - 1
# 出力
print(happiness)
|
p02918
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, k = list(map(int, input().split()))
s = input().rstrip()
def split(s):
new = [s[0]]
for i in range(n-1):
if s[i] != s[i+1]:
new.append(s[i+1])
else:
new[-1] += s[i+1]
return new
def transform(s, k):
for _ in range(k):
s = split(s)
if len(s) == 1:
s = ''.join(s)
break
idx = 1
s[idx] = s[idx].replace('L', 'X').replace('R', 'L').replace('X', 'R')
s = ''.join(s)
return s
s = transform(s, k)
def count(s):
cnt = 0
for i in range(n):
if i+1 < len(s) and s[i] == 'R' and s[i+1] == 'R':
cnt += 1
elif i-1 >= 0 and s[i] == 'L' and s[i-1] == 'L':
cnt += 1
return cnt
print((count(s)))
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, k = list(map(int, input().split()))
s = input().rstrip()
def count(s):
cnt = 0
for i in range(n):
if i+1 < len(s) and s[i] == 'R' and s[i+1] == 'R':
cnt += 1
elif i-1 >= 0 and s[i] == 'L' and s[i-1] == 'L':
cnt += 1
return cnt
print((min(count(s)+2*k, n-1)))
|
p02918
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
from collections import deque
def getN():
return int(eval(input()))
def getList():
return list(map(int, input().split()))
import math
n, k = getList()
s = input().strip()
s = s
state = "X"
cur_seq = 0
seq_nums = []
n_separate = 0
for c in s:
# print(c, state == c)
if state == c:
cur_seq += 1
else:
state = c
seq_nums.append(cur_seq)
cur_seq = 1
n_separate += 1
# print(n_separate)
print((min(n - n_separate + 2 * k, n - 1)))
|
import sys
from collections import defaultdict, deque, Counter
import math
# import copy
from bisect import bisect_left, bisect_right
# import heapq
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(eval(input()))
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def getmoji(k):
return chr(ord("a") + k)
def main():
n, k = getList()
s = getS()
ko, fuko = 0, 0
for i, j in zip(s, s[1:]):
if i == j:
ko += 1
else:
fuko += 1
print((ko + min(k*2, fuko)))
if __name__ == "__main__":
main()
|
p02918
|
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)]
def rle(s):
import itertools
return list([(x[0], len(list(x[1]))) for x in itertools.groupby(s)])
n, k = ril()
s = rs()
s = rle(s)
m = len(s)
if m <= 2 * k:
print((n - 1))
else:
print((n - m + 2 * k))
|
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)]
n, k = ril()
s = rs()
m = 1
for c0, c1 in zip(s, s[1:]):
if c0 != c1:
m += 1
if m <= 2 * k:
print((n - 1))
else:
print((n - m + 2 * k))
|
p02918
|
import sys
from itertools import groupby
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, K = list(map(int, readline().split()))
S = readline().strip()
ans = groups = 0
for k, g in groupby(S):
ans += len(list(g)) - 1
groups += 1
ans += 2 * K
if ans > N - 1:
ans = N - 1
print(ans)
return
if __name__ == '__main__':
main()
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, K = list(map(int, readline().split()))
S = readline().strip()
ans = 0
for i in range(N-1):
if S[i] == S[i+1]:
ans += 1
ans += 2 * K
if ans > N - 1:
ans = N - 1
print(ans)
return
if __name__ == '__main__':
main()
|
p02918
|
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def pf(s): return print(s, flush=True)
N = I()
b = LI()
result = []
while True:
# print(b)
for i in range(1, len(b)+1):
# print(i)
if b[-i] == len(b)-i+1:
# print('break')
result.append(b[-i])
del b[-i]
break
else:
if not b:
break
print(-1)
exit()
for i in result[::-1]:
print(i)
|
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def pf(s): return print(s, flush=True)
N = I()
b = LI()
result = []
while True:
# print(b)
for i in range(1, len(b)+1):
# print(i)
if b[-i] == len(b)-i+1:
# print('break')
result.append(b[-i])
b.pop(-i)
break
else:
if not b:
break
print(-1)
exit()
for i in result[::-1]:
print(i)
|
p03089
|
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def pf(s): return print(s, flush=True)
N = I()
b = LI()
result = []
while True:
# print(b)
for i in range(1, len(b)+1):
# print(i)
if b[-i] == len(b)-i+1:
# print('break')
result.append(b[-i])
b.pop(-i)
break
else:
if not b:
break
print(-1)
exit()
for i in result[::-1]:
print(i)
|
N = int(input())
B = [int(x) - 1 for x in input().split()]
# print('b', B)
ans = []
while B:
popped = -1
for i in reversed(range(len(B))):
if B[i] == i:
ans.append(i + 1)
popped = B.pop(i)
break
if popped == -1:
print(-1)
quit()
print(*ans[::-1], sep="\n")
|
p03089
|
n=int(eval(input()))
l=list(map(int,input().split()))
ansL=[]
c=0
f=0
for j in range(n):
for i in range(len(l)-1,-1,-1):
if l[i]==i+1:
ansL.append(l.pop(i))
c+=1
break
if c!=n:
print((-1))
else:
for k in range(len(ansL)-1,-1,-1):
print((ansL[k]))
|
n=int(eval(input()))
l=list(map(int,input().split()))
L=[]
c=0
for j in range(n):
for i in range(len(l)-1,-1,-1):
if l[i]==i+1:
L.insert(0,l.pop(i))
c+=1
break
if c!=n:
print((-1))
else:
for k in range(len(L)):
print((L[k]))
|
p03089
|
n=int(eval(input()))
a=[]
b=list(map(int,input().split()))
for i in range(n):
for j in range(n-i-1,-1,-1):
if b[j]==j+1:
a.append(b.pop(j))
break
if len(a)<n:
print((-1))
exit()
a.reverse()
for i in a:
print(i)
|
n=int(eval(input()))
a=[]
b=list(map(int,input().split()))
for i in range(n):
for j in range(n)[n-i-1::-1]:
if b[j]==j+1:
a.append(b.pop(j))
break
if len(a)<n:
print((-1))
exit()
a.reverse()
for i in a:
print(i)
|
p03089
|
def main():
n = int(eval(input()))
b = list(map(int, input().split()))
f = True
ans = []
while len(b) > 0:
sf = True
for i in reversed(list(range(len(b)))):
if b[i] == i+1:
b.pop(i)
ans.append(i+1)
sf = False
break
if sf:
f = False
break
if f:
for v in reversed(ans):
print(v)
else:
print("-1")
if __name__ == "__main__":
main()
|
def main():
n = int(eval(input()))
b = list(map(int, input().split()))
ans = []
f = True
for i in reversed(list(range(n))):
F = True
for j in reversed(list(range(i+1))):
if b[j] == j+1:
ans.append(b.pop(j))
F = False
break
if F:
f = False
break
if f:
for v in reversed(ans):
print(v)
else:
print((-1))
if __name__ == "__main__":
main()
|
p03089
|
N = int(eval(input()))
b = list(map(int, input().split()))
a = [1, 2, 3, 4, 5]
def f(a, ans):
if len(a) == 0:
for i in range(len(ans)):
print((ans[len(ans) - i - 1]))
exit()
for i in range(len(a)):
if i + 1 == a[i]:
f(a[0:i] + a[i + 1:len(a)], ans + [i + 1])
f(b, [])
print((-1))
|
N = int(eval(input()))
b = list(map(int, input().split()))
a = [1, 2, 3, 4, 5]
def f(a, ans):
if len(a) == 0:
for i in range(len(ans)):
print((ans[len(ans) - i - 1]))
exit()
for i in range(len(a) - 1, -1, -1):
if i + 1 == a[i]:
f(a[0:i] + a[i + 1:len(a)], ans + [i + 1])
break
f(b, [])
print((-1))
|
p03089
|
def main():
n, *b = list(map(int, open(0).read().split()))
m = []
for k in range(1, n+1):
for i in range(n - k, -1, -1):
if b[i] == i + 1:
b.pop(i)
m.append(i+1)
break
if len(b) > 0:
print((-1))
else:
print(('\n'.join(map(str, m[::-1]))))
if __name__ == '__main__':
main()
|
def main():
n, *b = list(map(int, open(0).read().split()))
m = []
for k in range(1, n + 1):
for i in range(n - k, -1, -1):
if b[i] == i + 1:
b.pop(i)
m.append(i + 1)
break
else:
print((-1))
exit()
print(('\n'.join(map(str, m[::-1]))))
if __name__ == '__main__':
main()
|
p03089
|
def BFS(Bs,del_idx,result):
if Bs==[1]:
return result
if del_idx!=None:
del Bs[del_idx]
for i,b in enumerate(Bs):
if i+1==b:
DBs=Bs.copy()
result.append(i+1)
out=BFS(DBs,i,result)
if out:
return out
else:
del result[-1]
return None
def Solve():
output=[]
N=int(eval(input()))
Bs=[int(x) for x in input().split()]
return BFS(Bs,None,[])
result=Solve()
if result:
result.reverse()
for r in result:
print(r)
else:
print((-1))
|
def BFS(Bs,del_idx,result):
if Bs==[1]:
return result
if del_idx!=None:
del Bs[del_idx]
for i,b in enumerate(Bs):
if b>i+1:
return None
for i,b in enumerate(Bs):
if i+1==b:
DBs=Bs.copy()
result.append(i+1)
out=BFS(DBs,i,result)
if out:
return out
else:
del result[-1]
return None
def Solve():
output=[]
N=int(eval(input()))
Bs=[int(x) for x in input().split()]
return BFS(Bs,None,[])
result=Solve()
if result:
result.reverse()
for r in result:
print(r)
else:
print((-1))
|
p03089
|
def main():
N = int(eval(input()))
B = list(map(int, input().split()))
Bs = [B]
Rs = [[]]
for i in range(N):
Bs_new = []
Rs_new = []
for b,r in zip(Bs,Rs):
for j in range(N-i):
if (b[j] == j+1):
tmp = list(b)
tmp2 = list(r)
tmp2.insert(0,tmp.pop(j))
Bs_new.append(tmp)
Rs_new.append(tmp2)
Bs = Bs_new
Rs = Rs_new
if (0 < len(Rs)):
R = Rs[0]
print(("\n".join([str(i) for i in R])))
else:
print((-1))
main()
|
def check(b, n):
if (1 == n):
if (1 == b[0]):
return [1]
else:
return []
else:
for (i,b_) in enumerate(b):
if ((i+1) == b_):
tmp = list(b)
del tmp[i]
res = check(tmp, n-1)
#print(res, n-1)
if (0 < len(res)):
#print(res, b_)
res.append(b_)
return res
return []
def main():
N = int(eval(input()))
B = list(map(int, input().split()))
res = check(B, N)
if (0 < len(res)):
print(("\n".join([str(i) for i in res])))
else:
print((-1))
main()
|
p03089
|
n = int(eval(input()))
b = list(map(int, input().split()))
for i in range(n):
if b[i] > i+1:
print((-1))
break
else:
ans = []
while len(b) > 1:
# print(ans,b)
c = len(ans)
f = b[0]
for i in range(1, len(b))[::-1]:
if b[i] == i + 1:
# print("check", b[i:])
ans.append(b.pop(i))
break
else:
for i in range(1, len(b)):
# print(f, i, b, n - c, ans)
if f >= b[i]:
ans.append(b.pop(i-1))
break
elif n - c == b[i]:
ans.append(b.pop(i))
break
elif i == len(b) - 1:
ans.append(b.pop(-1))
break
else:
f = b[i]
ans.append(1)
for i in range(n)[::-1]:
print((ans[i]))
|
n = int(eval(input()))
b = list(map(int, input().split()))
for i in range(n):
if b[i] > i+1:
print((-1))
break
else:
ans = []
while len(b) > 0:
f = b[0]
for i in range(len(b))[::-1]:
if b[i] == i + 1:
ans.append(b.pop(i))
break
for i in range(n)[::-1]:
print((ans[i]))
|
p03089
|
N = int(eval(input()))
B = list(map(int, input().split()))
def dfs(stack, B):
if len(B)==1:
if B[0]==1:
stack.append(1)
return stack
else: return None
else:
tmp = []
flag = False
for i, b in enumerate(B):
stack_ = stack + [b]
B_ = B[:i] + B[i+1:]
if b==i+1: tmp.append(dfs(stack_, B_))
for tp in tmp:
if tp is not None:
flag = True
ans = tp
if flag:
return ans
else:
return None
ans = dfs([], B)
if ans is None:
print('-1')
else:
ans = ans[::-1]
for i in range(N):
print((ans[i]))
|
N = int(eval(input()))
B = list(map(int, input().split()))
stack = []
for i in range(N):
tmp = []
flag = True
for j in range(len(B)):
if B[j]==j+1:
tmp.append(j)
if tmp:
tmp.sort(reverse=True)
ans = tmp[0]
B = B[:ans] + B[ans+1:]
stack.append(ans+1)
else:
flag = False
break
if flag:
stack = stack[::-1]
for i in stack:
print(i)
else:
print((-1))
|
p03089
|
import sys
import time
import copy
N = int(eval(input()))
b = [int(b) for b in input().split()]
h = {}
t1 = time.time()
def f(b):
t2 = time.time()
if t2 - t1 > 1.9:
print((-1))
sys.exit()
key = "".join([str(x) for x in b])
if key in h:
return copy.copy(h[key])
if len(b) == 1:
h[key] = b if b[0] == 1 else []
return copy.copy(h[key])
for i in range(len(b)):
i = len(b) - 1 - i
if b[i] == i + 1:
b_sub = copy.copy(b)
b_i = b_sub.pop(i)
a = f(b_sub)
if len(a) != 0:
a.append(b_i)
h[key] = a
return copy.copy(h[key])
h[key] = []
return copy.copy(h[key])
a = f(b)
if len(a) == 0:
print((-1))
else:
for i in range(N):
print((a[i]))
|
import sys
import time
import copy
N = int(eval(input()))
b = [int(b) for b in input().split()]
h = {}
t1 = time.time()
def f(b):
t2 = time.time()
if t2 - t1 > 1.5:
print((-1))
sys.exit()
key = "".join([str(x) for x in b])
if key in h:
return copy.copy(h[key])
if len(b) == 1:
h[key] = b if b[0] == 1 else []
return copy.copy(h[key])
for i in range(len(b)):
i = len(b) - 1 - i
if b[i] == i + 1:
b_sub = copy.copy(b)
b_i = b_sub.pop(i)
a = f(b_sub)
if len(a) != 0:
a.append(b_i)
h[key] = a
return copy.copy(h[key])
h[key] = []
return copy.copy(h[key])
a = f(b)
if len(a) == 0:
print((-1))
else:
for i in range(N):
print((a[i]))
|
p03089
|
LIST=""
LIST=list(LIST)
c=0
def func(S):
global LIST
global c
if(len(S)==0):
c=1
if(c==1):
for i in range(len(LIST)-1,-1,-1):
print((LIST[i]))
exit()
So=S[::]
for i in range(len(S)):
S=So[::]
if(S[i]==(i+1)):
LIST.append(S.pop(i))
func(S)
if(len(LIST)==0):
print("-1")
exit()
LIST.pop(-1)
N=int(eval(input()))
S=list(map(int,input().split()))
for i in range(N):
if((S[i] - i)>1):
print("-1")
exit()
func(S)
print("-1")
|
N=int(eval(input()))
S=list(map(int,input().split()))
LIST=list("")
for i in range(N):
if((S[i] - i)>1):
print("-1")
exit()
while(len(S)>0):
c=10**10
for i in range (len(S)):
if(S[i]==i+1):
c=i
if(c==(10**10)):
print("-1")
exit()
LIST.append(S.pop(c))
for i in range(len(LIST)-1,-1,-1):
print((LIST[i]))
|
p03089
|
n = int(eval(input()))
a = list(map(int,input().split()))
def solve(l, ans):
if l == []:
return ans
cnd = []
for i in range(len(l)):
if l[i] == i+1:
cnd.append(i)
if cnd == []:
return 0
for ind in cnd:
ans.append(ind+1)
cond = solve(l[0:ind] + l[(ind+1):(len(l)+1)], ans)
if cond == 0:
ans.pop()
continue
else:
return cond
return 0
ans = solve(a,[])
if ans == 0:
print((-1))
else:
for A in ans[::-1]:
print(A)
|
n = int(eval(input()))
a = list(map(int,input().split()))
def solve(l,ans):
if l == []:
return ans
for i in range(len(l)-1,-1,-1):
if l[i] == i+1:
ans.append(i+1)
return solve(l[:i]+l[i+1:], ans)
return 0
A = solve(a,[])
if A == 0:
print((-1))
else:
for a in A[::-1]:
print(a)
|
p03089
|
def limited_insertion(N: int, B: list)->list:
# print(N, B)
if N == 1:
return [1] if B[0] == 1 else []
# 後ろからみていって、インデックス(1-indexed)と
# その位置の配列(B)の値が等しい最初のペアを探す。
# なければ失敗
for i in range(N, 0, -1):
if i == B[i-1]:
# 見つけたら、それを除いた配列に関して
# 再帰的に同じことを行う。
# print('>>>pair', i, B[i-1])
rec = limited_insertion(N-1, B[:i-1] + B[i:])
if len(rec) > 0:
return rec + [i]
else:
return []
return []
if __name__ == "__main__":
N = int(eval(input()))
B = [int(s) for s in input().split()]
A = limited_insertion(N, B)
if len(A) == 0:
print((-1))
else:
for a in A:
print(a)
|
def limited_insertion(N: int, B: list) -> list:
op = []
for i in range(N-1, -1, -1):
for j in range(i, -1, -1):
b = B[j]
if i+1 < b:
# invalid number
return []
if j+1 == b:
# remove b[j]
B = B[:j] + B[j+1:]
op.append(b)
break
else:
# not found
return []
return reversed(op)
if __name__ == "__main__":
N = int(eval(input()))
B = [int(s) for s in input().split()]
ans = limited_insertion(N, B)
if ans:
for a in ans:
print(a)
else:
print((-1))
|
p03089
|
import copy
def dfs(i, operations, rest_bs):
if i == 0 and len(rest_bs) == 0:
return operations
for k, b in enumerate(rest_bs):
j = k + 1
if j <= i and j == b:
copied_operations = copy.deepcopy(operations)
copied_operations.append(j)
res = dfs(i-1, copied_operations, rest_bs[:k] + rest_bs[k+1:])
if res != -1:
return res
return -1
if __name__ == "__main__":
N = int(eval(input()))
bs = list(map(int, input().split()))
res = dfs(N, [], bs)
if res == -1:
print((-1))
else:
for n in reversed(res):
print(n)
|
if __name__ == "__main__":
N = int(eval(input()))
bs = list(map(int, input().split()))
operations = []
for i in range(N):
j_remove = -1
for j in range(N-i):
if bs[j] == j+1:
j_remove = j
if j_remove == -1:
print("-1")
exit()
operations.append(bs.pop(j_remove))
for n in reversed(operations):
print(n)
|
p03089
|
N = int(eval(input()))
b = list(map(int, input().split()))
def dfs(c):
if len(c) == 0:
return []
for i in range(1, len(c)+1):
if c[i-1] > i:
return False
if c[i-1] == i:
cc = c.copy()
del cc[i-1]
res = dfs(cc)
if res is not False:
res.append(i)
return res
return False
res = dfs(b)
if res is False:
print((-1))
else:
for i in res:
print(i)
|
N = int(eval(input()))
b = list(map(int, input().split()))
def dfs(c):
if len(c) == 0:
return []
for i in range(len(c), 0, -1):
if c[i-1] > i:
return False
if c[i-1] == i:
cc = c.copy()
del cc[i-1]
res = dfs(cc)
if res is not False:
res.append(i)
return res
return False
res = dfs(b)
if res is False:
print((-1))
else:
for i in res:
print(i)
|
p03089
|
import sys
from collections import Counter
def input():
return sys.stdin.readline().strip()
# sys.setrecursionlimit(100000)
def helper(cur: list, B, candi, ans, rest):
if rest == 0:
if cur == B:
for i in ans:
print(i)
sys.exit()
else:
return
for k, v in list(candi.items()):
if v > 0 and len(cur) + 1 >= k:
cur.insert(k - 1, k)
candi[k] -= 1
helper(cur, B, candi, ans + [k], rest - 1)
cur.pop(k - 1)
candi[k] += 1
def main():
n = int(input().strip())
B = [int(i) for i in input().strip().split()]
counter = Counter(B)
helper([], B, counter, [], n)
print((-1))
return
if __name__ == "__main__":
main()
|
import sys
def input():
return sys.stdin.readline().strip()
# sys.setrecursionlimit(100000)
def main():
n = int(input().strip())
B = [int(i) for i in input().strip().split()]
ans = []
ptr = len(B)
while ptr > 0:
if B[ptr - 1] == ptr:
ans.append(B.pop(ptr - 1))
ptr = len(B)
else:
ptr -= 1
if len(ans) == n:
for i in ans[::-1]:
print(i)
else:
print((-1))
return
if __name__ == "__main__":
main()
|
p03089
|
n=int(eval(input()))
ball = list(map(int,input().split()))
ans = []
count = 0
while len(ball)>0:
count += 1
for i in range(len(ball)-1,-1,-1):
#print(ball,i)
if i+1 ==ball[i]:
move = ball.pop(i)
ans.insert(0,move)
break
if count ==100000:
break
if len(ans) == n:
for i in ans:
print(i)
else:
print((-1))
|
n = int(eval(input()))
b = list(map(int,input().split()))
Flag = True
memo = []
while Flag:
Flag = False
index = -1
for i, v in enumerate(b):
if i == v-1:
Flag = True
index = i
if index != -1:
m = b.pop(index)
memo.append(m)
if len(b):
print((-1))
else:
memo.reverse()
for aa in memo:
print(aa)
|
p03089
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import sys
from itertools import chain
from functools import reduce
from collections import OrderedDict, Counter, deque
import operator
def IA(): return [int(x) for x in input().split()]
def IM(N): return [IA() for _ in range(N)]
N = int(input())
B = IA()
sys.setrecursionlimit(500)
def f(b, n):
if n == 0:
return []
for i, x in enumerate(b, 1):
if i < x or n < x:
return None
for i, x in enumerate(b, 1):
if i == x:
ret = f(tuple(b[:i-1] + b[i:]), n-1)
if ret is not None:
return ret + [i]
return None
ans = f(B, N)
if ans:
print(*ans, sep="\n")
else:
print(-1)
|
#!/bin/env python3
IS = lambda: int(input())
IA = lambda: [int(x) for x in input().split()]
N = IS()
B = IA()
def f(b, n):
ans = []
while b:
for i in range(len(b), 0, -1):
j = i - 1
if i == b[j]:
ans.append(i)
b = b[:j] + b[j+1:]
break
else:
return None
return list(reversed(ans))
ans = f(B, N)
if ans:
print(*ans, sep="\n")
else:
print(-1)
|
p03089
|
N=int(eval(input()))
b=list(map(int,input().split()))
tmp=-1
idx=0
count=1
flag=True
ans=[]
while(len(b)):
#print(idx)
if idx<len(b):
if b[idx]==count:
tmp=idx
idx+=1
count+=1
else:
idx+=1
count+=1
if idx>(len(b)-1):
if tmp==-1:
flag=False
break
else:
#print(tmp)
ans.append(b[tmp])
del b[tmp]
tmp=-1
idx=0
count=1
#print(ans)
if flag:
for i in range(len(ans)):
print((ans[len(ans)-1-i]))
else:
print((-1))
|
N = int(eval(input()))
b = list(map(int,input().split()))
ans = []
for i in range(N):
for j in range(len(b)-1,-1,-1):
if b[j]==(j+1):
ans += [b[j]]
del b[j]
break
if len(b)!=0:
print((-1))
exit()
for i in range(N):
print((ans[N-1-i]))
|
p03089
|
def main():
if 'get_ipython' not in globals():
# For Subsession
N = int(eval(input()))
# b = list(map(int, input().split()))
b = [int(i) for i in input().split()]
else:
# b = [1,2,1]
# b = [2,2]
b = [1,1,1,2,2,1,2,3,2]
N = len(b)
if check(b,N) != True:
print((-1))
def check(B,lenB):
# if 'get_ipython' in globals(): print(B)
if lenB == 0 :
return True
#for i in reversed(range(lenB)):
for i in range(lenB-1,-1,-1):
if B[i] == i+1:
if check(B[:i]+B[(i+1):],lenB -1 ) == True:
print((B[i]))
return True
break
return False
main()
|
import sys
def main():
if 'get_ipython' not in globals():
# For Subsession
N = int(eval(input()))
b = [int(i) for i in input().split()]
else:
# b = [1,2,1]
# b = [2,2]
b = [1,1,1,2,2,1,2,3,2]
N = len(b)
ans = []
while True:
for i in range(N-1,-1,-1):
if b[i] == i+1:
ans.append(i+1)
del b[i]
N = N -1
break
if i == 0:
print((-1))
sys.exit()
if N == 0:
break
for i in reversed(ans):
print(i)
main()
|
p03089
|
N=int(eval(input()))
B=list(map(int,input().split(' ')))
def dfs(n,B,ans):
if n==0:
return ans[::-1]
else:
for num,i in enumerate(B):
if num+1==i:
res = dfs(n-1,B[:num]+B[num+1:],ans+[i])
if res:
return res
return False
ans = dfs(N,B,[])
if not ans:
print((-1))
else:
for i in ans:
print(i)
|
N=int(eval(input()))
B=list(map(int,input().split(' ')))
ans = []
for i in range(N):
for n,j in enumerate(B[::-1]):
if N-i-n==j:
ans.append(B.pop(N-i-n-1))
break
if len(ans)==N:
for i in ans[::-1]:
print(i)
else:
print((-1))
|
p03089
|
N = int(eval(input()))
b_list = list(map(int, input().split()))
generate_seq = []
def is_ok(b):
len_b = len(b)
if len_b == 1 and b[0] == 1:
generate_seq.append(1)
return True
processing = []
for idx in range(len_b):
if b[idx] != idx + 1:
processing.append(False)
else:
b_tmp = b[:]
del b_tmp[idx]
tmp = is_ok(b_tmp)
if tmp:
generate_seq.append(idx + 1)
return True
return False
result = is_ok(b_list)
if result:
print(('\n'.join(list(map(str, generate_seq)))))
else:
print((-1))
|
N = int(eval(input()))
b_list = list(map(int, input().split()))
generate_seq = []
def is_ok(b):
len_b = len(b)
if len_b == 1 and b[0] == 1:
generate_seq.append(1)
return True
for idx, val in enumerate(b):
if idx + 1 < val:
return False
processing = []
for idx in range(len_b):
if b[idx] != idx + 1:
processing.append(False)
else:
b_tmp = b[:]
del b_tmp[idx]
tmp = is_ok(b_tmp)
if tmp:
generate_seq.append(idx + 1)
return True
return False
result = is_ok(b_list)
if result:
print(('\n'.join(list(map(str, generate_seq)))))
else:
print((-1))
|
p03089
|
import sys
sys.setrecursionlimit(10**6)
n = int(eval(input()))
b = list(map(int , input().split()))
def dfs(s, ans):
#print(s, ans)
if len(s) == 0:
print(('\n'.join(map(str, reversed(ans)))))
exit()
return
for i in range(len(s)):
if s[i] == i+1:
s1 = s[:i] + s[i+1:]
ans.append(s[i])
dfs(s1, ans)
if len(ans) > 0:
ans.pop()
dfs(b, [])
print('-1')
|
import sys
sys.setrecursionlimit(10**6)
n = int(eval(input()))
b = list(map(int , input().split()))
def dfs(s, ans):
if len(s) == 0:
print(('\n'.join(map(str, reversed(ans)))))
exit()
return
for i in range(len(s)):
#if s[i] == i+1:
#if s[i] == i+1 and max(s[:i] + [0]) >= i:
if s[i] == i+1:
s1 = s[:i] + s[i+1:]
allok = True
for j in range(len(s1)):
if s1[j] > j+1:
allok = False
break
#print(s[:i], s[i+1:],i)
if allok:
ans.append(s[i])
dfs(s1, ans)
if len(ans) > 0:
ans.pop()
dfs(b, [])
print('-1')
|
p03089
|
import sys
sys.setrecursionlimit(10**6)
n = int(eval(input()))
b = list(map(int , input().split()))
def dfs(s, ans):
if len(s) == 0:
print(('\n'.join(map(str, reversed(ans)))))
exit()
return
for i in range(len(s)):
#if s[i] == i+1:
#if s[i] == i+1 and max(s[:i] + [0]) >= i:
if s[i] == i+1:
s1 = s[:i] + s[i+1:]
allok = True
for j in range(len(s1)):
if s1[j] > j+1:
allok = False
break
#print(s[:i], s[i+1:],i)
if allok:
ans.append(s[i])
dfs(s1, ans)
if len(ans) > 0:
ans.pop()
dfs(b, [])
print('-1')
|
n = int(eval(input()))
b = list(map(int , input().split()))
def f(c):
for i in reversed(list(range(len(c)))):
if c[i] == i+1:
return (c[i], c[:i] + c[i+1:])
return (-1, c)
ans = []
for i in range(n):
(a, b) = f(b)
if a == -1:
print((-1))
exit()
ans.append(a)
#print(ans, b)
print(('\n'.join(map(str, reversed(ans)))))
|
p03089
|
import sys
sys.setrecursionlimit(2147483647)
INF=float('inf')
MOD=10**9+7
input=sys.stdin.readline
n=int(eval(input()))
s=list(map(int,input().split()))
import copy
def DEF(ary,ary2):
#print(ary,ary2)
global n,s
if len(ary2)==n:
#print(ary)
if ary==s:
for item in ary2:
print(item)
exit()
else:
for i in range(len(ary)+1):
tmp = copy.deepcopy(ary)
tmp.insert(i,i+1)
DEF(tmp,ary2+[i+1])
DEF([],[])
print((-1))
|
n=int(eval(input()))
s=list(map(int,input().split()))
result=[]
for i in range(n):
posi=-1
for index,ss in enumerate(s):
if ss==index+1:
posi=index
if posi==-1:
print((-1))
exit()
else:
result.append(s[posi])
s.pop(posi)
for item in result[::-1]:
print(item)
|
p03089
|
n=int(eval(input()))
b=list(map(int,input().split()))
a=[0]*(n+1)
a[0]=0
for i in b:a.insert(int(i)-1,i)
if sum(a[:n])==sum(b):
for i in range(n):
print((a[i]))
else:print((-1))
|
n=int(eval(input()))
B=list(map(int,input().split()))
a=[0]
for b in B:a.insert(b-1,b)
if sum(a[:n])==sum(B):
for i in range(n):print((a[i]))
else:print((-1))
|
p03089
|
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from functools import lru_cache, reduce
from math import ceil, floor
from sys import setrecursionlimit
import heapq
import itertools
import operator
inf = float('inf')
def get_int():
return int(eval(input()))
def get_float():
return float(eval(input()))
def get_str():
return input().strip()
def get_list_of_int():
return [int(i) for i in input().split()]
def get_list_of_float():
return [float(f) for f in input().split()]
def get_list_of_char():
return list(input().strip())
def get_data(n, order=None, **kwargs):
if not order:
order = list(range(len(kwargs)))
it = iter(order)
var, fn = list(zip(*sorted(sorted(kwargs.items()), key=lambda _: next(it))))
rows = []
for _ in range(n):
rows.append(input().split())
columns = list(zip(*rows))
exec("global "+", ".join(var)+"\n"+"\n".join(
v+"=list(map(fn[{}], data[{}]))".format(i, i)
for i, v in enumerate(var)),
globals(),
{"fn": list(fn), "data": list(columns)}
)
return
# inputs
N = 0
B = []
def set_inputs():
global N, B
N = get_int()
B = get_list_of_int()
return
memo = dict()
# n: int, b: List[int]
def solve(b):
if len(b) == 0:
return []
s = str(b)
if memo.get(s, None):
return memo[s]
possible_indices = []
for i, v in enumerate(b):
if i + 1 == v:
possible_indices.append(i)
if len(possible_indices) == 0:
memo[s] = [-1]
return [-1]
for i in possible_indices:
ans = solve(b[:i] + b[i+1:])
if len(ans) == 1 and ans[0] == -1:
continue
memo[s] = ans + [i+1]
return ans + [i+1]
memo[s] = [-1]
return [-1]
def main():
setrecursionlimit(100000)
set_inputs()
for i in solve(B):
print(i)
return
if __name__ == '__main__':
main()
|
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from functools import lru_cache, reduce
from math import ceil, floor
from sys import setrecursionlimit
import heapq
import itertools
import operator
inf = float('inf')
def get_int():
return int(eval(input()))
def get_float():
return float(eval(input()))
def get_str():
return input().strip()
def get_list_of_int():
return [int(i) for i in input().split()]
def get_list_of_float():
return [float(f) for f in input().split()]
def get_list_of_char():
return list(input().strip())
def get_data(n, order=None, **kwargs):
if not order:
order = list(range(len(kwargs)))
it = iter(order)
var, fn = list(zip(*sorted(sorted(kwargs.items()), key=lambda _: next(it))))
rows = []
for _ in range(n):
rows.append(input().split())
columns = list(zip(*rows))
exec("global "+", ".join(var)+"\n"+"\n".join(
v+"=list(map(fn[{}], data[{}]))".format(i, i)
for i, v in enumerate(var)),
globals(),
{"fn": list(fn), "data": list(columns)}
)
return
# inputs
N = 0
B = []
def set_inputs():
global N, B
N = get_int()
B = get_list_of_int()
return
# n: int, b: List[int]
def solve(b):
if len(b) == 0:
return []
if sum(b) > len(b) * (len(b) + 1) // 2:
return [-1]
for i, v in enumerate(b):
if v > i + 1:
return [-1]
possible_indices = []
for i, v in enumerate(b):
if i + 1 == v:
possible_indices.append(i)
if len(possible_indices) == 0:
return [-1]
for i in possible_indices:
ans = solve(b[:i] + b[i+1:])
if len(ans) == 1 and ans[0] == -1:
continue
return ans + [i+1]
return [-1]
def main():
setrecursionlimit(100000)
set_inputs()
for i in solve(B):
print(i)
return
if __name__ == '__main__':
main()
|
p03089
|
N = int(eval(input()))
b = [int(_) for _ in input().split()]
def delitable(numbers):
return [v for i, v in enumerate(numbers) if v == i + 1]
b_searched = set()
b_unsearched = []
b_searched.add(tuple(b))
delit = delitable(b)
if delit == []:
print("-1")
for delit_num in delit:
b_unsearched.append([b[:delit_num - 1] + b[delit_num:], [delit_num]])
while b_unsearched:
b, log = b_unsearched.pop()
if b and max(b) > N - len(log):
continue
b_tuple = tuple(b)
b_searched.add(b_tuple)
delit = delitable(b)
if not delit:
if not b:
log.reverse()
print(("\n".join(map(str, log))))
break
else:
continue
for delit_num in delit:
b_temp = b[:delit_num - 1] + b[delit_num:]
if not tuple(b_temp) in b_searched:
b_unsearched.append([b_temp, log + [delit_num]])
else:
print("-1")
|
N = int(eval(input()))
b = [int(_) for _ in input().split()]
def delitable(numbers):
return [v for i, v in enumerate(numbers) if v == i + 1]
log = []
while b:
delit = delitable(b)
if not delit:
print((-1))
break
del b[delit[-1] - 1]
log.append(delit[-1])
else:
log.reverse()
print(("\n".join(map(str, log))))
|
p03089
|
def solve(remains, nums):
if (len(remains)) == 0:
[print(num) for num in nums[::-1]]
exit()
n_remains = []
n_nums = []
for i, num in enumerate(remains):
if i + 1 == num:
n_remains.append(remains[:i] + remains[i + 1:])
n_nums.append(nums + [i + 1])
if len(n_remains) == 0:
return False
for n_remain, n_num in zip(n_remains, n_nums):
solve(n_remain, n_num)
n = int(input())
B = [int(x) for x in input().split()]
solve(B, [])
print(-1)
|
def solve(remains, nums):
if (len(remains)) == 0:
[print(num) for num in nums[::-1]]
exit()
n_remain = None
n_num = None
for i, num in enumerate(remains):
if i + 1 == num:
n_remain = remains[:i] + remains[i + 1:]
n_num = nums + [i + 1]
if n_remain is None:
return False
solve(n_remain, n_num)
n = int(input())
B = [int(x) for x in input().split()]
solve(B, [])
print(-1)
|
p03089
|
import sys
input = sys.stdin.readline
N=int(eval(input()))
B=list(map(int,input().split()))
def dfs(B,LEN,ANS):
#print(B,LEN,ANS)
if LEN==0:
for a in ANS[::-1]:
print(a)
sys.exit()
for i in range(LEN):
if B[i]==i+1:
C=B[:i]+B[i+1:]
dfs(C,LEN-1,ANS+[i+1])
dfs(B,N,[])
print((-1))
|
import sys
input = sys.stdin.readline
N=int(eval(input()))
B=list(map(int,input().split()))
for i in range(N):
if B[i]>i+1:
print((-1))
sys.exit()
def dfs(B,LEN,ANS):
#print(B,LEN,ANS)
if LEN==0:
for a in ANS[::-1]:
print(a)
sys.exit()
for i in range(LEN-1,-1,-1):
if B[i]==i+1:
C=B[:i]+B[i+1:]
dfs(C,LEN-1,ANS+[i+1])
dfs(B,N,[])
print((-1))
|
p03089
|
# coding: utf-8
eval(input())
B_ = [int(i) for i in input().split()]
def f (B, ans):
if len(B) == 0:
return ans
for i in range(len(B)):
if B[i] <= len(B) and B[i] == i+1 :
B2 = B[:]
ans2 = ans[:]
ans2.append(B2.pop(B[i]-1))
result = f(B2, ans2)
if result is not None:
return result
result = f(B_, [])
if result is None:
result = [-1]
for s in result[::-1]:
print(s)
|
# coding: utf-8
N = int(eval(input()))
B = [int(i) for i in input().split()]
ans = []
while (len(B) > 0):
for _ in range(len(B)):
for i in list(range(len(B)))[::-1]:
if B[i] == i+1:
ans.append(i+1)
B.pop(i)
break
break
if len(ans) != N:
print((-1))
else:
for i in ans[::-1]:
print(i)
|
p03089
|
n = int(eval(input()))
bs = list(map(int, input().split()))
ans = []
def check(bs, pre):
tmp = pre[:]
if len(bs) == 0:
ans.append(tmp)
return
cand = []
for i, b in enumerate(bs):
if i + 1 == b:
cand.append(i)
if len(cand) == 0:
return
for i in cand:
check(bs[:i] + bs[i+1:], [i + 1] + tmp)
check(bs, [])
if len(ans):
for ai in ans[0]:
print(ai)
else:
print((-1))
|
n = int(eval(input()))
bs = list(map(int, input().split()))
ans = []
def check(bs, pre):
tmp = pre[:]
if len(bs) == 0:
ans.append(tmp)
return
cand = []
for i, b in enumerate(bs):
if i + 1 == b:
cand.append(i)
if len(cand) == 0:
return
i = cand[-1]
check(bs[:i] + bs[i+1:], [i + 1] + tmp)
check(bs, [])
if len(ans):
for ai in ans[0]:
print(ai)
else:
print((-1))
|
p03089
|
def check_val(ind):
if ind > len(b): return False
if b[ind-1] == ind:
ans.append(ind)
del b[ind-1]
return True
else:
return False
N,*b = map(int,open(0).read().split())
if b[0] != 1:
print(-1)
exit()
set_b = sorted(set(b),reverse=True)
ans = []
while len(b) != 0:
flg = False
for i in set_b:
flg = check_val(i)
if flg: break
if set_b[-1] not in b: del set_b[-1]
else: #消せるものがなくなった
if len(b) == 0:
print(*ans[::-1],sep="\n")
else:
print(-1)
|
def check_val(ind):
if ind > len(b): return False
if b[ind-1] == ind:
ans.append(ind)
del b[ind-1]
if ind not in b: set_b.remove(ind)
return True
else:
return False
N,*b = map(int,open(0).read().split())
if b[0] != 1:
print(-1)
exit()
set_b = sorted(set(b),reverse=True)
ans = []
while len(b) != 0:
flg = False
for i in set_b:
flg = check_val(i)
if flg: break
if flg == False:
print(-1)
exit()
else: #消せるものがなくなった
print(*ans[::-1],sep="\n")
|
p03089
|
N = int(eval(input()))
list_b = list(map(int, input().split()))
aaa = [[1, 1], [1, 2]]
ans = [[1, 1], [1, 2]]
for i in range(2,N):
j = []
f = []
for d in range(len(aaa)):
s = []
t = []
for k in range(i+1):
a = aaa[d].copy()
b = ans[d].copy()
a.insert(k, k+1)
b.append(k+1)
s.append(a)
t.append(b)
j += s
f += t
aaa = j
ans = f
if list_b in aaa:
index = aaa.index(list_b)
anser = ans[index]
for i in range(N):
print((anser[i]))
else:
print('-1')
|
N = int(eval(input()))
list_b = list(map(int, input().split()))
ans = [0 for i in range(N)]
finish = False
for i in range(N-1, -1, -1):
mx = -1
for k in range(i+1):
if list_b[k] == k+1:
mx = max(mx, k+1)
if mx == -1:
finish = True
break
else:
ans[i] = mx
for j in range(mx-1, i):
list_b[j] = list_b[j+1]
if not finish:
for i in range(N):
print((ans[i]))
else:
print((-1))
|
p03089
|
import collections
N = int(eval(input()))
B = list(map(int, input().split()))
for i, b in enumerate(B, start=1):
if b > i:
print((-1))
exit()
bnn = collections.defaultdict(
lambda: collections.defaultdict(dict)
)
def inv_sousa(B, N, now=tuple()):
if N == 0:
yield now
else:
if now in bnn[B][N] or max(B) > N:
return
bnn[B][N][now] = False
for i in set(B):
idx = i - 1
if B[idx] == i:
yield from inv_sousa(B[:idx] + B[i:], N - 1, now=now + (B[idx],))
for x in inv_sousa(tuple(B), N):
if x:
for i in x[::-1]:
print(i)
break
else:
print((-1))
|
N = int(eval(input()))
B = list(map(int, input().split()))
inv_output = list()
for i in range(N, 0, -1):
for j in range(i, 0, -1):
if B[j - 1] == j:
inv_output.append(B.pop(j - 1))
break
else:
print((-1))
break
else:
for i in inv_output[::-1]:
print(i)
|
p03089
|
from collections import Counter
import sys
sys.setrecursionlimit(10**7)
n = int(input())
B = list(map(int, input().split()))
c = Counter(B)
A = []
history = []
def dfs(i):
if i == n+1:
if A == B:
print(*history, sep='\n')
exit()
return 0
for j in reversed(range(1, i+1)):
if not c[j]:
continue
c[j] -= 1
history.append(j)
A.insert(j-1, j)
dfs(i+1)
A.pop(j-1)
history.pop()
c[j] += 1
dfs(1)
print(-1)
|
n = int(input())
B = list(map(int, input().split()))
A = []
for b in B:
A.insert(b-1, b)
if all(A[i] <= i+1 for i in range(n)):
C = []
for a in A:
C.insert(a-1, a)
if B == C:
print(*A, sep='\n')
else:
print(-1)
else:
print(-1)
|
p03089
|
from collections import deque
def main():
n = int(eval(input()))
b = list(map(int, input().split()))
s = set()
q = deque()
q.append([tuple(b), [0]*n, 0])
ans = None
while q:
now, history, depth = q.popleft()
if now in s:
continue
s.add(now)
if len(now) == 0:
ans = history
break
for i, j in enumerate(now):
if i+1 == j:
tmp = history[::]
tmp[depth] = i+1
q.appendleft([tuple(now[:i] + now[i+1:]), tmp, depth+1])
if ans is None:
print((-1))
else:
for i in ans[::-1]:
if i == 0:
break
print(i)
if __name__ == "__main__":
main()
|
n = int(eval(input()))
b = list(map(int, input().split()))
def check(b):
for i in range(len(b))[::-1]:
if i+1 == b[i]:
return i
return -1
ans = []
for i in range(n):
ind = check(b)
if ind >= 0:
ans.append(ind+1)
b = b[:ind] + b[ind+1:]
else:
print((-1))
exit()
for i in ans[::-1]:
print(i)
|
p03089
|
import copy
n = int(eval(input()))
goal = list(map(int, input().split(" ")))
output = -1
def searchAns(goal, temp, left, proc):
#print(temp, left, proc)
if len(left) == 0:
if temp == goal:
return proc
else:
return -1
for num in left:
#print(num, temp, left, proc)
if num <= len(temp) + 1:
copyTemp = copy.copy(temp)
copyTemp.insert(num-1, num)
copyLeft = copy.copy(left)
copyLeft.remove(num)
copyProc = copy.copy(proc)
copyProc.append(num)
result = searchAns(goal, copyTemp, copyLeft, copyProc)
if result != -1:
return result
else:
return -1
proc = searchAns(goal, [], goal, [])
if proc == -1:
print((-1))
else:
for num in proc:
print(num)
|
import copy
n = int(eval(input()))
goal = list(map(int, input().split(" ")))
output = -1
procReverse = []
temp_goal = copy.copy(goal)
for _ in range(n):
index = list(range(1,len(temp_goal)+1))
for i in range(len(temp_goal)-1, -1, -1):
#print(i, index, temp_goal)
if index[i] == temp_goal[i]:
procReverse.append(temp_goal[i])
temp_goal.pop(i)
break
else:
print((-1))
break
else:
for i in range(n-1, -1, -1):
print((procReverse[i]))
|
p03089
|
import sys
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int,input().split()))
for i in range(n):
if i+1 < a[i]:
print((-1))
exit()
def dfs(x,ans,so):
if x == n:
if ans == a:
so = so[::-1]
for i in so:
print(i)
exit()
return 0
for i in range(len(ans)):
if ans[i] == i+1:
ans.pop(i)
so.append(i+1)
dfs(x+1,ans,so)
ans.insert(i,i+1)
so.pop()
return -1
print((dfs(0,a,[])))
|
import sys
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int,input().split()))
for i in range(n):
if i+1 < a[i]:
print((-1))
exit()
def dfs(x,ans,so):
if x == n:
if ans == a:
so = so[::-1]
for i in so:
print(i)
exit()
return 0
for i in range(len(ans)-1,-1,-1):
if ans[i] == i+1:
ans.pop(i)
so.append(i+1)
dfs(x+1,ans,so)
ans.insert(i,i+1)
so.pop()
return -1
print((dfs(0,a,[])))
|
p03089
|
class Node:
def __init__(self, prev, val, next):
self.prev = prev
self.val = val
self.next = next
NIL = 0
START = -1
END = -2
class List:
def __init__(self, li):
li.append(END)
self.li = [Node(NIL, START, NIL)]
for e in li:
node = Node(self.li[-1], e, NIL)
self.li[-1].next = node
self.li.append(node)
self.l = len(self.li) - 1
self.ans = []
def step(self):
i = self.l
u = self.li[-1]
while u.val != START:
if u.val == i:
u.prev.next = u.next
u.next.prev = u.prev
self.ans.append(u.val)
self.l -= 1
return True
else:
u = u.prev
i -= 1
self.ans = [-1]
return False
def solve(self):
for _ in range(self.l - 1):
if not self.step():
break
print(*self.ans[::-1], sep="\n")
def main():
n = int(input())
b = list(map(int, input().split()))
l = List(b)
l.solve()
if __name__ == "__main__":
main()
|
def main():
n = int(input())
b = list(map(int, input().split()))
ans = []
while b:
l = len(b)
for i in range(l)[::-1]:
if b[i] == i + 1:
pp = b.pop(i)
ans.append(pp)
break
else:
ans = [-1]
break
print(*ans[::-1], sep="\n")
if __name__ == "__main__":
main()
|
p03089
|
import copy
def insertion(n, x):
if not x:
return True
for i in range(n - 1, -1, -1):
y = copy.copy(x)
if y[i] == i + 1:
y.pop(i)
ope.insert(0, i + 1)
if insertion(n - 1, y):
return True
else:
ope.pop(0)
return False
n = int(eval(input()))
b = list(map(int, input().split()))
ope = []
if insertion(n, b):
for i in ope:
print(i)
else:
print((-1))
|
import sys
n = int(eval(input()))
b = list(map(int, input().split()))
ope = []
i = n
while i > 0:
flag = 0
j = i
while j > 0:
if b[j - 1] == j:
b.pop(j - 1)
i -= 1
ope.insert(0, j)
flag = 1
break
j -= 1
if flag == 0:
print((-1))
sys.exit()
for i in ope:
print(i)
|
p03089
|
import itertools
n = eval(input())
num_list = [int(i) for i in input().split()]
is_possible = False
for order_list in list(itertools.permutations(num_list)):
output_list = []
if order_list[0] != 1:
continue
for x in order_list:
output_list.insert(x - 1, x)
if output_list == num_list:
is_possible = True
break
if is_possible:
for out in order_list:
print(out)
else:
print((-1))
|
import itertools
n = eval(input())
num_list = [int(i) for i in input().split()]
is_possible = False
permutations = list(set(itertools.permutations(num_list)))
for order_list in permutations:
output_list = []
if order_list[0] != 1:
continue
for x in order_list:
output_list.insert(x - 1, x)
if output_list == num_list:
is_possible = True
break
if is_possible:
for out in order_list:
print(out)
else:
print((-1))
|
p03089
|
n = int(eval(input()))
b = list(map(int,input().split()))
ans = []
def solve(b,i):
if i == 0:
return True
for j in range(i-1,-1,-1):
if b[j] == j+1:
p = b[:j] + b[j+1:]
if solve(p,i-1):
ans.append(j+1)
return True
return False
solve(b,n)
if len(ans) == n:
for i in range(n):
print((ans[i]))
else:
print((-1))
|
n = int(eval(input()))
b = list(map(int,input().split()))
ans = []
def solve(b,i):
if i == 0:
return True
for j in range(i-1,-1,-1):
if b[j] > j+1:
return False
if b[j] == j+1:
p = b[:j] + b[j+1:]
if solve(p,i-1):
ans.append(j+1)
return True
return False
solve(b,n)
if len(ans) == n:
for i in range(n):
print((ans[i]))
else:
print((-1))
|
p03089
|
def remove(data):
global result
pos = min(len(data), max(data))
for n in range(pos-1, -1, -1):
if data[n] == n + 1:
result.append(n + 1)
if len(data) == 1:
#print('OK')
return True
else:
#print('remove {0} '.format(n + 1), end='')
#print(data[:n] + data[n+1:])
if remove(data[:n] + data[n+1:]):
return True
else:
#print('try again')
if len(result) > 0:
result.pop(-1)
return False
_ = eval(input())
B = list(map(int, input().split()))
result = []
if remove(B):
result.reverse()
for res in result:
print(res)
else:
print((-1))
|
_ = eval(input())
data = list(map(int, input().split()))
result = []
pos = min(len(data), max(data)) - 1
while pos >= 0:
if data[pos] == pos + 1:
x = data.pop(pos)
#print('remove {0} {1}'.format(x, data))
result.append(x)
if len(data) == 0:
break
pos = min(len(data), max(data)) - 1
else:
pos -= 1
if len(data) == 0:
result.reverse()
for res in result:
print(res)
else:
print((-1))
|
p03089
|
import sys
input = sys.stdin.readline # NOQA
sys.setrecursionlimit(10 ** 7) # NOQA
def dfs(N, a, i, b, procedure):
if i == 0:
return procedure
for j in range(1, i+1):
if a[j-1] == j:
l = a[:]
del l[j-1]
p = procedure[:]
p.append(j)
ret = dfs(N, l, i-1, b, p)
if ret is not None:
return ret
def main():
N = int(input())
b = list(map(int, input().split()))
res = dfs(N, b, N, b, [])
if res is None:
print(-1)
else:
print(*res[::-1], sep="\n")
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.readline # NOQA
sys.setrecursionlimit(10 ** 7) # NOQA
def dfs(N, a, i, procedure):
if i == 0:
return procedure
for j in reversed(range(1, i+1)):
if a[j-1] == j:
l = a[:]
del l[j-1]
p = procedure[:]
p.append(j)
ret = dfs(N, l, i-1, p)
if ret is not None:
return ret
break
def main():
N = int(input())
b = list(map(int, input().split()))
res = dfs(N, b, N, [])
if res is None:
print(-1)
else:
print(*res[::-1], sep="\n")
if __name__ == "__main__":
main()
|
p03089
|
n = int(eval(input()))
b = list(map(int, input().split()))
ans = []
def dfs(x):
if x == []:
return True
ret = False
for i, a in enumerate(x):
if i + 1 == a:
ret = dfs(x[:i] + x[i+1:])
if ret:
ans.append(a)
break
return ret
if dfs(b):
for a in ans:
print(a)
else:
print((-1))
|
n = int(eval(input()))
b = list(map(int, input().split()))
ans = []
for k in range(n):
for i in reversed(list(range(n - k))):
a = b[i]
if i + 1 == a:
ans.append(b.pop(i))
break
if b != []:
print((-1))
else:
for a in reversed(ans):
print(a)
|
p03089
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
N = int(readline())
B = list(map(int, readline().split()))
def main():
def dfs(vec):
i = 0
zero_only = True
for j in range(len(vec)):
if vec[j] > 0:
zero_only = False
i += 1
if vec[j] == i:
vec[j] = 0
ret = dfs(vec)
vec[j] = i
if ret != False:
ret.append(i)
return ret
if zero_only:
return []
else:
return False
ans = dfs(B)
if ans == False:
print(-1)
else:
print(*ans, sep='\n')
if __name__ == '__main__':
main()
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
N = int(readline())
B = list(map(int, readline().split()))
def main():
ans = []
while B:
found = False
for i in range(len(B), 0, -1):
if i == B[i - 1]:
ans.append(i)
del B[i - 1]
found = True
break
if not found:
print(-1)
return
print(*reversed(ans), sep='\n')
if __name__ == '__main__':
main()
|
p03089
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.