index
int64 0
5.16k
| difficulty
int64 7
12
| question
stringlengths 126
7.12k
| solution
stringlengths 30
18.6k
| test_cases
dict |
|---|---|---|---|---|
400 | 10 | You are given a connected undirected graph with n vertices and m edges. The vertices are enumerated from 1 to n.
You are given n integers c1, c2, ..., cn, each of them is between - n and n, inclusive. It is also guaranteed that the parity of cv equals the parity of degree of vertex v. The degree of a vertex is the number of edges connected to it.
You are to write a weight between - 2Β·n2 and 2Β·n2 (inclusive) on each edge in such a way, that for each vertex v the sum of weights on edges connected to this vertex is equal to cv, or determine that this is impossible.
Input
The first line contains two integers n and m (2 β€ n β€ 105, n - 1 β€ m β€ 105) β the number of vertices and the number of edges.
The next line contains n integers c1, c2, ..., cn ( - n β€ ci β€ n), where ci is the required sum of weights of edges connected to vertex i. It is guaranteed that the parity of ci equals the parity of degree of vertex i.
The next m lines describe edges of the graph. The i-th of these lines contains two integers ai and bi (1 β€ ai, bi β€ n; ai β bi), meaning that the i-th edge connects vertices ai and bi.
It is guaranteed that the given graph is connected and does not contain loops and multiple edges.
Output
If there is no solution, print "NO".
Otherwise print "YES" and then m lines, the i-th of them is the weight of the i-th edge wi ( - 2Β·n2 β€ wi β€ 2Β·n2).
Examples
Input
3 3
2 2 2
1 2
2 3
1 3
Output
YES
1
1
1
Input
4 3
-1 0 2 1
1 2
2 3
3 4
Output
YES
-1
1
1
Input
6 6
3 5 5 5 1 5
1 4
3 2
4 3
4 5
3 5
5 6
Output
YES
3
5
3
-1
-3
5
Input
4 4
4 4 2 4
1 2
2 3
3 4
4 1
Output
NO |
def divisors(M):
d=[]
i=1
while M>=i**2:
if M%i==0:
d.append(i)
if i**2!=M:
d.append(M//i)
i=i+1
return d
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def eratosthenes(n):
res=[0 for i in range(n+1)]
prime=set([])
for i in range(2,n+1):
if not res[i]:
prime.add(i)
for j in range(1,n//i+1):
res[i*j]=1
return prime
def factorization(n):
res=[]
for p in prime:
if n%p==0:
while n%p==0:
n//=p
res.append(p)
if n!=1:
res.append(n)
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def ind(b,n):
res=0
while n%b==0:
res+=1
n//=b
return res
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 3, 5, 7, 11, 13, 17]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
from math import gcd
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(n):
res = [1]
prime = primeFactor(n)
for p in prime:
newres = []
for d in res:
for j in range(prime[p]+1):
newres.append(d*p**j)
res = newres
res.sort()
return res
def xorfactorial(num):
if num==0:
return 0
elif num==1:
return 1
elif num==2:
return 3
elif num==3:
return 0
else:
x=baseorder(num)
return (2**x)*((num-2**x+1)%2)+function(num-2**x)
def xorconv(n,X,Y):
if n==0:
res=[(X[0]*Y[0])%mod]
return res
x=[X[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
z=[X[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
res1=xorconv(n-1,x,y)
res2=xorconv(n-1,z,w)
former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
former=list(map(lambda x:x%mod,former))
latter=list(map(lambda x:x%mod,latter))
return former+latter
def merge_sort(A,B):
pos_A,pos_B = 0,0
n,m = len(A),len(B)
res = []
while pos_A < n and pos_B < m:
a,b = A[pos_A],B[pos_B]
if a < b:
res.append(a)
pos_A += 1
else:
res.append(b)
pos_B += 1
res += A[pos_A:]
res += B[pos_B:]
return res
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self.group = N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
stack = [x]
while self._parent[stack[-1]]!=stack[-1]:
stack.append(self._parent[stack[-1]])
for v in stack:
self._parent[v] = stack[-1]
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
self.group -= 1
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
class WeightedUnionFind():
def __init__(self,N):
self.parent = [i for i in range(N)]
self.size = [1 for i in range(N)]
self.val = [0 for i in range(N)]
self.flag = True
self.edge = [[] for i in range(N)]
def dfs(self,v,pv):
stack = [(v,pv)]
new_parent = self.parent[pv]
while stack:
v,pv = stack.pop()
self.parent[v] = new_parent
for nv,w in self.edge[v]:
if nv!=pv:
self.val[nv] = self.val[v] + w
stack.append((nv,v))
def unite(self,x,y,w):
if not self.flag:
return
if self.parent[x]==self.parent[y]:
self.flag = (self.val[x] - self.val[y] == w)
return
if self.size[self.parent[x]]>self.size[self.parent[y]]:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[x] += self.size[y]
self.val[y] = self.val[x] - w
self.dfs(y,x)
else:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[y] += self.size[x]
self.val[x] = self.val[y] + w
self.dfs(x,y)
class Dijkstra():
class Edge():
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
self.G = [[] for i in range(V)]
self._E = 0
self._V = V
@property
def E(self):
return self._E
@property
def V(self):
return self._V
def add_edge(self, _from, _to, _cost):
self.G[_from].append(self.Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
import heapq
que = []
d = [10**15] * self.V
d[s] = 0
heapq.heappush(que, (0, s))
while len(que) != 0:
cost, v = heapq.heappop(que)
if d[v] < cost: continue
for i in range(len(self.G[v])):
e = self.G[v][i]
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
#Z[i]:length of the longest list starting from S[i] which is also a prefix of S
#O(|S|)
def Z_algorithm(s):
N = len(s)
Z_alg = [0]*N
Z_alg[0] = N
i = 1
j = 0
while i < N:
while i+j < N and s[j] == s[i+j]:
j += 1
Z_alg[i] = j
if j == 0:
i += 1
continue
k = 1
while i+k < N and k + Z_alg[k]<j:
Z_alg[i+k] = Z_alg[k]
k += 1
i += k
j -= k
return Z_alg
class BIT():
def __init__(self,n,mod=0):
self.BIT = [0]*(n+1)
self.num = n
self.mod = mod
def query(self,idx):
res_sum = 0
mod = self.mod
while idx > 0:
res_sum += self.BIT[idx]
if mod:
res_sum %= mod
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
mod = self.mod
while idx <= self.num:
self.BIT[idx] += x
if mod:
self.BIT[idx] %= mod
idx += idx&(-idx)
return
class dancinglink():
def __init__(self,n,debug=False):
self.n = n
self.debug = debug
self._left = [i-1 for i in range(n)]
self._right = [i+1 for i in range(n)]
self.exist = [True for i in range(n)]
def pop(self,k):
if self.debug:
assert self.exist[k]
L = self._left[k]
R = self._right[k]
if L!=-1:
if R!=self.n:
self._right[L],self._left[R] = R,L
else:
self._right[L] = self.n
elif R!=self.n:
self._left[R] = -1
self.exist[k] = False
def left(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._left[res]
if res==-1:
break
k -= 1
return res
def right(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._right[res]
if res==self.n:
break
k -= 1
return res
class SparseTable():
def __init__(self,A,merge_func,ide_ele):
N=len(A)
n=N.bit_length()
self.table=[[ide_ele for i in range(n)] for i in range(N)]
self.merge_func=merge_func
for i in range(N):
self.table[i][0]=A[i]
for j in range(1,n):
for i in range(0,N-2**j+1):
f=self.table[i][j-1]
s=self.table[i+2**(j-1)][j-1]
self.table[i][j]=self.merge_func(f,s)
def query(self,s,t):
b=t-s+1
m=b.bit_length()-1
return self.merge_func(self.table[s][m],self.table[t-2**m+1][m])
class BinaryTrie:
class node:
def __init__(self,val):
self.left = None
self.right = None
self.max = val
def __init__(self):
self.root = self.node(-10**15)
def append(self,key,val):
pos = self.root
for i in range(29,-1,-1):
pos.max = max(pos.max,val)
if key>>i & 1:
if pos.right is None:
pos.right = self.node(val)
pos = pos.right
else:
pos = pos.right
else:
if pos.left is None:
pos.left = self.node(val)
pos = pos.left
else:
pos = pos.left
pos.max = max(pos.max,val)
def search(self,M,xor):
res = -10**15
pos = self.root
for i in range(29,-1,-1):
if pos is None:
break
if M>>i & 1:
if xor>>i & 1:
if pos.right:
res = max(res,pos.right.max)
pos = pos.left
else:
if pos.left:
res = max(res,pos.left.max)
pos = pos.right
else:
if xor>>i & 1:
pos = pos.right
else:
pos = pos.left
if pos:
res = max(res,pos.max)
return res
def solveequation(edge,ans,n,m):
#edge=[[to,dire,id]...]
x=[0]*m
used=[False]*n
for v in range(n):
if used[v]:
continue
y = dfs(v)
if y!=0:
return False
return x
def dfs(v):
used[v]=True
r=ans[v]
for to,dire,id in edge[v]:
if used[to]:
continue
y=dfs(to)
if dire==-1:
x[id]=y
else:
x[id]=-y
r+=y
return r
class SegmentTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
self.size = n
for i in range(n):
self.tree[self.num + i] = init_val[i]
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
if r==self.size:
r = self.num
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def bisect_l(self,l,r,x):
l += self.num
r += self.num
Lmin = -1
Rmin = -1
while l<r:
if l & 1:
if self.tree[l] <= x and Lmin==-1:
Lmin = l
l += 1
if r & 1:
if self.tree[r-1] <=x:
Rmin = r-1
l >>= 1
r >>= 1
if Lmin != -1:
pos = Lmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
elif Rmin != -1:
pos = Rmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
else:
return -1
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log
input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())
n,m = mi()
c = li()
edge = [[] for i in range(n)]
for i in range(m):
u,v = mi()
edge[u-1].append((v-1,i))
edge[v-1].append((u-1,i))
parent = [(-1,-1) for v in range(n)]
tree_edge = [[] for v in range(n)]
depth = [0 for v in range(n)]
special = None
stack = [0]
cnt = [0 for v in range(n)]
while stack:
v = stack[-1]
if cnt[v]==len(edge[v]):
stack.pop()
else:
nv,idx = edge[v][cnt[v]]
cnt[v] += 1
if nv==0 or parent[nv]!=(-1,-1):
if depth[nv] < depth[v] and (depth[v]-depth[nv])%2==0 and not special:
special = (v,nv,idx)
else:
parent[nv] = (v,idx)
depth[nv] = depth[v] + 1
tree_edge[v].append((nv,idx))
stack.append(nv)
if not special:
even = 0
odd = 0
for v in range(n):
if depth[v]&1:
odd += c[v]
else:
even += c[v]
if odd!=even:
print("NO")
else:
print("YES")
deq = deque([0])
topo = []
while deq:
v = deq.popleft()
topo.append(v)
for nv,idx in tree_edge[v]:
deq.append(nv)
ans = [0 for i in range(m)]
for v in topo[::-1]:
if v==0:
continue
_,i = parent[v]
ans[i] = c[v]
for nv,idx in tree_edge[v] :
ans[i] -= ans[idx]
print(*ans,sep="\n")
else:
print("YES")
even = 0
odd = 0
for v in range(n):
if depth[v]&1:
odd += c[v]
else:
even += c[v]
ans = [0 for i in range(m)]
v,nv,idx = special
if depth[v]&1:
ans[idx] -= (even-odd)//2
c[v] += (even-odd)//2
c[nv] += (even-odd)//2
else:
ans[idx] -= (odd-even)//2
c[v] += (odd-even)//2
c[nv] += (odd-even)//2
#print(ans)
deq = deque([0])
topo = []
while deq:
v = deq.popleft()
topo.append(v)
for nv,idx in tree_edge[v]:
deq.append(nv)
for v in topo[::-1]:
if v==0:
continue
_,i = parent[v]
ans[i] = c[v]
for nv,idx in tree_edge[v] :
ans[i] -= ans[idx]
print(*ans,sep="\n")
| {
"input": [
"6 6\n3 5 5 5 1 5\n1 4\n3 2\n4 3\n4 5\n3 5\n5 6\n",
"4 4\n4 4 2 4\n1 2\n2 3\n3 4\n4 1\n",
"3 3\n2 2 2\n1 2\n2 3\n1 3\n",
"4 3\n-1 0 2 1\n1 2\n2 3\n3 4\n"
],
"output": [
"YES\n 3\n 5\n 3\n -1\n -3\n 5\n",
"NO\n",
"YES\n 1\n 1\n 1\n",
"YES\n -1\n 1\n 1\n"
]
} |
401 | 7 | There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column. | import sys
def p(s):
print(s)
sys.exit(0)
n,m = list(map(int, input().split()))
t = [input() for _ in range(n)]
sts = []
for i in range(n):
founds = set()
for j in range(m):
if t[i][j] == '#':
founds.add(j)
sts.append(founds)
for i in range(n):
for j in range(i+1, n):
if len(sts[i]&sts[j]) != 0 and sts[i]!=sts[j]:
p('No')
p('Yes')
| {
"input": [
"5 9\n........#\n#........\n..##.#...\n.......#.\n....#.#.#\n",
"5 5\n..#..\n..#..\n#####\n..#..\n..#..\n",
"5 8\n.#.#..#.\n.....#..\n.#.#..#.\n#.#....#\n.....#..\n"
],
"output": [
"No\n",
"No\n",
"Yes\n"
]
} |
402 | 9 | Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 β€ n β€ 10) β the size of the array.
The second line of input contains n space-separated integers ai (1 β€ ai β€ 100) β the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}. | def mp():
return map(int, input().split())
n = int(input())
a = list(mp())
r = [abs(a[i] - a[i + 1]) for i in range(n - 1)]
if n != 1 and max(r) >= 2:
print('NO')
else:
print('YES') | {
"input": [
"3\n3 1 2\n",
"3\n1 2 3\n"
],
"output": [
"NO",
"YES"
]
} |
403 | 12 | There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k β
n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 β€ n β€ 500, 1 β€ k β€ 10) β the number of players and the number of cards each player will get.
The second line contains k β
n integers c_1, c_2, ..., c_{k β
n} (1 β€ c_i β€ 10^5) β the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 β€ f_j β€ 10^5) β the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 β€ h_t β€ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t β [2..k].
Output
Print one integer β the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0. | import math
from collections import defaultdict
def main():
n, k = map(int, input().split())
cards = list(map(int, input().split()))
fav = list(map(int, input().split()))
h = [0] + list(map(int, input().split()))
cards_cnt = defaultdict(int)
for val in cards:
cards_cnt[val] += 1
players_fav_cnt = defaultdict(int)
for val in fav:
players_fav_cnt[val] += 1
# dp[a][b] - a players, b favourite cards (in total)
dp = [[0 for _ in range(k*n+k+1)] for _ in range(n+1)]
for p in range(n):
for c in range(k*n+1):
for hand in range(k+1):
dp[p+1][c+hand] = max(dp[p+1][c+hand], dp[p][c] + h[hand])
res = 0
for f in players_fav_cnt:
res += dp[players_fav_cnt[f]][cards_cnt[f]]
print(res)
if __name__ == '__main__':
main()
| {
"input": [
"4 3\n1 3 2 8 5 5 8 2 2 8 5 2\n1 2 2 5\n2 6 7\n",
"3 3\n9 9 9 9 9 9 9 9 9\n1 2 3\n1 2 3\n"
],
"output": [
"21\n",
"0\n"
]
} |
404 | 11 | You are given three integers n, d and k.
Your task is to construct an undirected tree on n vertices with diameter d and degree of each vertex at most k, or say that it is impossible.
An undirected tree is a connected undirected graph with n - 1 edges.
Diameter of a tree is the maximum length of a simple path (a path in which each vertex appears at most once) between all pairs of vertices of this tree.
Degree of a vertex is the number of edges incident to this vertex (i.e. for a vertex u it is the number of edges (u, v) that belong to the tree, where v is any other vertex of a tree).
Input
The first line of the input contains three integers n, d and k (1 β€ n, d, k β€ 4 β
10^5).
Output
If there is no tree satisfying the conditions above, print only one word "NO" (without quotes).
Otherwise in the first line print "YES" (without quotes), and then print n - 1 lines describing edges of a tree satisfying the conditions above. Vertices of the tree must be numbered from 1 to n. You can print edges and vertices connected by an edge in any order. If there are multiple answers, print any of them.1
Examples
Input
6 3 3
Output
YES
3 1
4 1
1 2
5 2
2 6
Input
6 2 3
Output
NO
Input
10 4 3
Output
YES
2 9
2 10
10 3
3 1
6 10
8 2
4 3
5 6
6 7
Input
8 5 3
Output
YES
2 5
7 2
3 7
3 1
1 6
8 7
4 3 | n,d,k=map(int,input().split())
if n==1:
print("NO")
exit()
if k==1:
if n==2 and d==1:
print("YES")
print(1,2)
else:
print("NO")
exit()
if n<d+1:
print("NO")
exit()
co=1
ans=[]
for i in range(1,d+1):
ans.append((i,i+1))
co+=1
def dfs(r,dist,co):
if 2<=r<=d:
t=k-2
else:
t=k-1
if co==n:
return co
for _ in range(t):
if dist==d:
return co
if co==n:
return co
co+=1
ans.append((r,co))
co=dfs(co,dist+1,co)
return co
for i in range(2,d+1):
co=dfs(i,max(i-1,d-i+1),co)
if co==n:
print("YES")
for j in ans:
print(*j)
else:
print("NO") | {
"input": [
"8 5 3\n",
"6 3 3\n",
"10 4 3\n",
"6 2 3\n"
],
"output": [
"YES\n1 2\n2 3\n3 4\n4 5\n5 6\n2 7\n3 8\n",
"YES\n1 2\n2 3\n3 4\n2 5\n3 6\n",
"YES\n1 2\n2 3\n3 4\n4 5\n2 6\n3 7\n7 8\n7 9\n4 10\n",
"NO\n"
]
} |
405 | 10 | Enough is enough. Too many times it happened that Vasya forgot to dispose of garbage and his apartment stank afterwards. Now he wants to create a garbage disposal plan and stick to it.
For each of next n days Vasya knows a_i β number of units of garbage he will produce on the i-th day. Each unit of garbage must be disposed of either on the day it was produced or on the next day. Vasya disposes of garbage by putting it inside a bag and dropping the bag into a garbage container. Each bag can contain up to k units of garbage. It is allowed to compose and drop multiple bags into a garbage container in a single day.
Being economical, Vasya wants to use as few bags as possible. You are to compute the minimum number of bags Vasya needs to dispose of all of his garbage for the given n days. No garbage should be left after the n-th day.
Input
The first line of the input contains two integers n and k (1 β€ n β€ 2β
10^5, 1 β€ k β€ 10^9) β number of days to consider and bag's capacity. The second line contains n space separated integers a_i (0 β€ a_i β€ 10^9) β the number of units of garbage produced on the i-th day.
Output
Output a single integer β the minimum number of bags Vasya needs to dispose of all garbage. Each unit of garbage should be disposed on the day it was produced or on the next day. No garbage can be left after the n-th day. In a day it is allowed to compose and drop multiple bags.
Examples
Input
3 2
3 2 1
Output
3
Input
5 1
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
3 2
1 0 1
Output
2
Input
4 4
2 8 4 1
Output
4 | def read():
return list(map(int, input().split()))
def solve(n, k, A):
ans, prev = 0, 0
for a in A:
total = prev + a
if prev and total < k:
ans += 1
total = 0
elif total >= k:
ans += total // k
total %= k
prev = total
ans += prev // k
ans += 1 if prev % k > 0 else 0
return ans
n, k = read()
A = read()
print(solve(n, k, A)) | {
"input": [
"3 2\n1 0 1\n",
"4 4\n2 8 4 1\n",
"3 2\n3 2 1\n",
"5 1\n1000000000 1000000000 1000000000 1000000000 1000000000\n"
],
"output": [
"2\n",
"4\n",
"3\n",
"5000000000\n"
]
} |
406 | 9 | You have a playlist consisting of n songs. The i-th song is characterized by two numbers t_i and b_i β its length and beauty respectively. The pleasure of listening to set of songs is equal to the total length of the songs in the set multiplied by the minimum beauty among them. For example, the pleasure of listening to a set of 3 songs having lengths [5, 7, 4] and beauty values [11, 14, 6] is equal to (5 + 7 + 4) β
6 = 96.
You need to choose at most k songs from your playlist, so the pleasure of listening to the set of these songs them is maximum possible.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 3 β
10^5) β the number of songs in the playlist and the maximum number of songs you can choose, respectively.
Each of the next n lines contains two integers t_i and b_i (1 β€ t_i, b_i β€ 10^6) β the length and beauty of i-th song.
Output
Print one integer β the maximum pleasure you can get.
Examples
Input
4 3
4 7
15 1
3 6
6 8
Output
78
Input
5 3
12 31
112 4
100 100
13 55
55 50
Output
10000
Note
In the first test case we can choose songs {1, 3, 4}, so the total pleasure is (4 + 3 + 6) β
6 = 78.
In the second test case we can choose song 3. The total pleasure will be equal to 100 β
100 = 10000. | from sys import stdin
import heapq
input=stdin.readline
def f(a,k):
h=[]
ans=-222222222
a=sorted(a,key=lambda s:s[1],reverse=True)
s=0
for ad,p in a:
heapq.heappush(h,ad)
s+=ad
if len(h)>k:
s-=heapq.heappop(h)
ans=max(ans,s*p)
return ans
n,m=map(int,input().strip().split())
blanck=[]
for i in range(n):
x,y=map(int,input().strip().split())
blanck.append((x,y))
print(f(blanck,m)) | {
"input": [
"5 3\n12 31\n112 4\n100 100\n13 55\n55 50\n",
"4 3\n4 7\n15 1\n3 6\n6 8\n"
],
"output": [
"10000",
"78"
]
} |
407 | 7 | Vasya has a pile, that consists of some number of stones. n times he either took one stone from the pile or added one stone to the pile. The pile was non-empty before each operation of taking one stone from the pile.
You are given n operations which Vasya has made. Find the minimal possible number of stones that can be in the pile after making these operations.
Input
The first line contains one positive integer n β the number of operations, that have been made by Vasya (1 β€ n β€ 100).
The next line contains the string s, consisting of n symbols, equal to "-" (without quotes) or "+" (without quotes). If Vasya took the stone on i-th operation, s_i is equal to "-" (without quotes), if added, s_i is equal to "+" (without quotes).
Output
Print one integer β the minimal possible number of stones that can be in the pile after these n operations.
Examples
Input
3
---
Output
0
Input
4
++++
Output
4
Input
2
-+
Output
1
Input
5
++-++
Output
3
Note
In the first test, if Vasya had 3 stones in the pile at the beginning, after making operations the number of stones will be equal to 0. It is impossible to have less number of piles, so the answer is 0. Please notice, that the number of stones at the beginning can't be less, than 3, because in this case, Vasya won't be able to take a stone on some operation (the pile will be empty).
In the second test, if Vasya had 0 stones in the pile at the beginning, after making operations the number of stones will be equal to 4. It is impossible to have less number of piles because after making 4 operations the number of stones in the pile increases on 4 stones. So, the answer is 4.
In the third test, if Vasya had 1 stone in the pile at the beginning, after making operations the number of stones will be equal to 1. It can be proved, that it is impossible to have less number of stones after making the operations.
In the fourth test, if Vasya had 0 stones in the pile at the beginning, after making operations the number of stones will be equal to 3. | def main():
n = int(input())
ans = 0
for i in input():
if i == '-':
ans = max(0, ans-1)
else:
ans += 1
return ans
if __name__ == '__main__':
print(main()) | {
"input": [
"2\n-+\n",
"3\n---\n",
"5\n++-++\n",
"4\n++++\n"
],
"output": [
"1\n",
"0\n",
"3\n",
"4\n"
]
} |
408 | 7 | Soon after the Chunga-Changa island was discovered, it started to acquire some forms of civilization and even market economy. A new currency arose, colloquially called "chizhik". One has to pay in chizhiks to buy a coconut now.
Sasha and Masha are about to buy some coconuts which are sold at price z chizhiks per coconut. Sasha has x chizhiks, Masha has y chizhiks. Each girl will buy as many coconuts as she can using only her money. This way each girl will buy an integer non-negative number of coconuts.
The girls discussed their plans and found that the total number of coconuts they buy can increase (or decrease) if one of them gives several chizhiks to the other girl. The chizhiks can't be split in parts, so the girls can only exchange with integer number of chizhiks.
Consider the following example. Suppose Sasha has 5 chizhiks, Masha has 4 chizhiks, and the price for one coconut be 3 chizhiks. If the girls don't exchange with chizhiks, they will buy 1 + 1 = 2 coconuts. However, if, for example, Masha gives Sasha one chizhik, then Sasha will have 6 chizhiks, Masha will have 3 chizhiks, and the girls will buy 2 + 1 = 3 coconuts.
It is not that easy to live on the island now, so Sasha and Mash want to exchange with chizhiks in such a way that they will buy the maximum possible number of coconuts. Nobody wants to have a debt, so among all possible ways to buy the maximum possible number of coconuts find such a way that minimizes the number of chizhiks one girl gives to the other (it is not important who will be the person giving the chizhiks).
Input
The first line contains three integers x, y and z (0 β€ x, y β€ 10^{18}, 1 β€ z β€ 10^{18}) β the number of chizhics Sasha has, the number of chizhics Masha has and the price of a coconut.
Output
Print two integers: the maximum possible number of coconuts the girls can buy and the minimum number of chizhiks one girl has to give to the other.
Examples
Input
5 4 3
Output
3 1
Input
6 8 2
Output
7 0
Note
The first example is described in the statement. In the second example the optimal solution is to dot exchange any chizhiks. The girls will buy 3 + 4 = 7 coconuts. | def main():
x, y, z = map(int, input().split())
print((x + y) // z, max(min(x % z - (x + y) % z, y % z - (x + y) % z), 0))
main()
| {
"input": [
"6 8 2\n",
"5 4 3\n"
],
"output": [
"7 0\n",
"3 1\n"
]
} |
409 | 11 | The only difference between the easy and the hard versions is the maximum value of k.
You are given an infinite sequence of form "112123123412345..." which consist of blocks of all consecutive positive integers written one after another. The first block consists of all numbers from 1 to 1, the second one β from 1 to 2, the third one β from 1 to 3, ..., the i-th block consists of all numbers from 1 to i.
So the first 56 elements of the sequence are "11212312341234512345612345671234567812345678912345678910". Elements of the sequence are numbered from one. For example, the 1-st element of the sequence is 1, the 3-rd element of the sequence is 2, the 20-th element of the sequence is 5, the 38-th element is 2, the 56-th element of the sequence is 0.
Your task is to answer q independent queries. In the i-th query you are given one integer k_i. Calculate the digit at the position k_i of the sequence.
Input
The first line of the input contains one integer q (1 β€ q β€ 500) β the number of queries.
The i-th of the following q lines contains one integer k_i (1 β€ k_i β€ 10^9) β the description of the corresponding query.
Output
Print q lines. In the i-th line print one digit x_i (0 β€ x_i β€ 9) β the answer to the query i, i.e. x_i should be equal to the element at the position k_i of the sequence.
Examples
Input
5
1
3
20
38
56
Output
1
2
5
2
0
Input
4
2132
506
999999999
1000000000
Output
8
2
9
8
Note
Answers on queries from the first example are described in the problem statement. | word = ''
arr = [0]
for i in range(1,22000):
word = word + str(i)
arr.append(arr[-1] + len(word))
def sol(k):
d = 0
for i in range(1,22000):
if arr[i] > k:
d = i - 1
break
k = k - arr[d]
if k == 0:
return str(d)[-1]
else:
return word[k - 1]
for i in range(int(input())):
print(sol(int(input()))) | {
"input": [
"4\n2132\n506\n999999999\n1000000000\n",
"5\n1\n3\n20\n38\n56\n"
],
"output": [
"8\n2\n9\n8\n",
"1\n2\n5\n2\n0\n"
]
} |
410 | 7 | Lengths are measures in Baden in inches and feet. To a length from centimeters it is enough to know that an inch equals three centimeters in Baden and one foot contains 12 inches.
You are given a length equal to n centimeters. Your task is to convert it to feet and inches so that the number of feet was maximum. The result should be an integer rounded to the closest value containing an integral number of inches.
Note that when you round up, 1 cm rounds up to 0 inches and 2 cm round up to 1 inch.
Input
The only line contains an integer n (1 β€ n β€ 10000).
Output
Print two non-negative space-separated integers a and b, where a is the numbers of feet and b is the number of inches.
Examples
Input
42
Output
1 2
Input
5
Output
0 2 | def dliny(number):
return ((number + 1) // 3) // 12, ((number + 1) // 3) % 12
print(*dliny(int(input())))
| {
"input": [
"42\n",
"5\n"
],
"output": [
"1 2\n",
"0 2\n"
]
} |
411 | 9 | We start with a string s consisting only of the digits 1, 2, or 3. The length of s is denoted by |s|. For each i from 1 to |s|, the i-th character of s is denoted by s_i.
There is one cursor. The cursor's location β is denoted by an integer in \{0, β¦, |s|\}, with the following meaning:
* If β = 0, then the cursor is located before the first character of s.
* If β = |s|, then the cursor is located right after the last character of s.
* If 0 < β < |s|, then the cursor is located between s_β and s_{β+1}.
We denote by s_left the string to the left of the cursor and s_right the string to the right of the cursor.
We also have a string c, which we call our clipboard, which starts out as empty. There are three types of actions:
* The Move action. Move the cursor one step to the right. This increments β once.
* The Cut action. Set c β s_right, then set s β s_left.
* The Paste action. Append the value of c to the end of the string s. Note that this doesn't modify c.
The cursor initially starts at β = 0. Then, we perform the following procedure:
1. Perform the Move action once.
2. Perform the Cut action once.
3. Perform the Paste action s_β times.
4. If β = x, stop. Otherwise, return to step 1.
You're given the initial string s and the integer x. What is the length of s when the procedure stops? Since this value may be very large, only find it modulo 10^9 + 7.
It is guaranteed that β β€ |s| at any time.
Input
The first line of input contains a single integer t (1 β€ t β€ 1000) denoting the number of test cases. The next lines contain descriptions of the test cases.
The first line of each test case contains a single integer x (1 β€ x β€ 10^6). The second line of each test case consists of the initial string s (1 β€ |s| β€ 500). It is guaranteed, that s consists of the characters "1", "2", "3".
It is guaranteed that the sum of x in a single file is at most 10^6. It is guaranteed that in each test case before the procedure will stop it will be true that β β€ |s| at any time.
Output
For each test case, output a single line containing a single integer denoting the answer for that test case modulo 10^9 + 7.
Example
Input
4
5
231
7
2323
6
333
24
133321333
Output
25
1438
1101
686531475
Note
Let's illustrate what happens with the first test case. Initially, we have s = 231. Initially, β = 0 and c = \varepsilon (the empty string). The following things happen if we follow the procedure above:
* Step 1, Move once: we get β = 1.
* Step 2, Cut once: we get s = 2 and c = 31.
* Step 3, Paste s_β = 2 times: we get s = 23131.
* Step 4: β = 1 not= x = 5, so we return to step 1.
* Step 1, Move once: we get β = 2.
* Step 2, Cut once: we get s = 23 and c = 131.
* Step 3, Paste s_β = 3 times: we get s = 23131131131.
* Step 4: β = 2 not= x = 5, so we return to step 1.
* Step 1, Move once: we get β = 3.
* Step 2, Cut once: we get s = 231 and c = 31131131.
* Step 3, Paste s_β = 1 time: we get s = 23131131131.
* Step 4: β = 3 not= x = 5, so we return to step 1.
* Step 1, Move once: we get β = 4.
* Step 2, Cut once: we get s = 2313 and c = 1131131.
* Step 3, Paste s_β = 3 times: we get s = 2313113113111311311131131.
* Step 4: β = 4 not= x = 5, so we return to step 1.
* Step 1, Move once: we get β = 5.
* Step 2, Cut once: we get s = 23131 and c = 13113111311311131131.
* Step 3, Paste s_β = 1 times: we get s = 2313113113111311311131131.
* Step 4: β = 5 = x, so we stop.
At the end of the procedure, s has length 25. | def solve(l,s):
n = len(s)
for i in range(l):
n += (n-i-1)*(int(s[i])-1)
n %= 7 + 10**9
if len(s) < l:
s += s[i+1:]*(int(s[i])-1)
return n
for _ in range(int(input())):
l = int(input())
s = input()
print(solve(l,s)) | {
"input": [
"4\n5\n231\n7\n2323\n6\n333\n24\n133321333\n"
],
"output": [
"25\n1438\n1101\n686531475\n"
]
} |
412 | 9 | Ayoub thinks that he is a very smart person, so he created a function f(s), where s is a binary string (a string which contains only symbols "0" and "1"). The function f(s) is equal to the number of substrings in the string s that contains at least one symbol, that is equal to "1".
More formally, f(s) is equal to the number of pairs of integers (l, r), such that 1 β€ l β€ r β€ |s| (where |s| is equal to the length of string s), such that at least one of the symbols s_l, s_{l+1}, β¦, s_r is equal to "1".
For example, if s = "01010" then f(s) = 12, because there are 12 such pairs (l, r): (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 4), (4, 5).
Ayoub also thinks that he is smarter than Mahmoud so he gave him two integers n and m and asked him this problem. For all binary strings s of length n which contains exactly m symbols equal to "1", find the maximum value of f(s).
Mahmoud couldn't solve the problem so he asked you for help. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 β€ t β€ 10^5) β the number of test cases. The description of the test cases follows.
The only line for each test case contains two integers n, m (1 β€ n β€ 10^{9}, 0 β€ m β€ n) β the length of the string and the number of symbols equal to "1" in it.
Output
For every test case print one integer number β the maximum value of f(s) over all strings s of length n, which has exactly m symbols, equal to "1".
Example
Input
5
3 1
3 2
3 3
4 0
5 2
Output
4
5
6
0
12
Note
In the first test case, there exists only 3 strings of length 3, which has exactly 1 symbol, equal to "1". These strings are: s_1 = "100", s_2 = "010", s_3 = "001". The values of f for them are: f(s_1) = 3, f(s_2) = 4, f(s_3) = 3, so the maximum value is 4 and the answer is 4.
In the second test case, the string s with the maximum value is "101".
In the third test case, the string s with the maximum value is "111".
In the fourth test case, the only string s of length 4, which has exactly 0 symbols, equal to "1" is "0000" and the value of f for that string is 0, so the answer is 0.
In the fifth test case, the string s with the maximum value is "01010" and it is described as an example in the problem statement. | import sys
input = sys.stdin.readline
t=int(input())
def calc(x):
return x*(x+1)//2
for test in range(t):
n,m=map(int,input().split())
ANS=calc(n)
k=n-m
q,mod=divmod(k,m+1)
ANS-=calc(q+1)*mod+calc(q)*(m+1-mod)
print(ANS)
| {
"input": [
"5\n3 1\n3 2\n3 3\n4 0\n5 2\n"
],
"output": [
"4\n5\n6\n0\n12\n"
]
} |
413 | 9 | You are given a tree consisting of n nodes. You want to write some labels on the tree's edges such that the following conditions hold:
* Every label is an integer between 0 and n-2 inclusive.
* All the written labels are distinct.
* The largest value among MEX(u,v) over all pairs of nodes (u,v) is as small as possible.
Here, MEX(u,v) denotes the smallest non-negative integer that isn't written on any edge on the unique simple path from node u to node v.
Input
The first line contains the integer n (2 β€ n β€ 10^5) β the number of nodes in the tree.
Each of the next n-1 lines contains two space-separated integers u and v (1 β€ u,v β€ n) that mean there's an edge between nodes u and v. It's guaranteed that the given graph is a tree.
Output
Output n-1 integers. The i^{th} of them will be the number written on the i^{th} edge (in the input order).
Examples
Input
3
1 2
1 3
Output
0
1
Input
6
1 2
1 3
2 4
2 5
5 6
Output
0
3
2
4
1
Note
The tree from the second sample:
<image> |
def main():
n = int(input())
lst = [0] * (n+1)
s = []
for i in range(n-1):
a, b = map(int, input().split())
s.append((a,b))
lst[a]+=1
lst[b] +=1
sol = []
left = 0
right = n-2
for a, b in s:
if lst[a] == 1 or lst[b] == 1:
print(left)
left +=1
else:
print(right)
right -=1
if __name__ == "__main__":
main()
| {
"input": [
"6\n1 2\n1 3\n2 4\n2 5\n5 6\n",
"3\n1 2\n1 3\n"
],
"output": [
"0\n3\n1\n2\n4\n",
"0\n1\n"
]
} |
414 | 8 | A monopole magnet is a magnet that only has one pole, either north or south. They don't actually exist since real magnets have two poles, but this is a programming contest problem, so we don't care.
There is an nΓ m grid. Initially, you may place some north magnets and some south magnets into the cells. You are allowed to place as many magnets as you like, even multiple in the same cell.
An operation is performed as follows. Choose a north magnet and a south magnet to activate. If they are in the same row or the same column and they occupy different cells, then the north magnet moves one unit closer to the south magnet. Otherwise, if they occupy the same cell or do not share a row or column, then nothing changes. Note that the south magnets are immovable.
Each cell of the grid is colored black or white. Let's consider ways to place magnets in the cells so that the following conditions are met.
1. There is at least one south magnet in every row and every column.
2. If a cell is colored black, then it is possible for a north magnet to occupy this cell after some sequence of operations from the initial placement.
3. If a cell is colored white, then it is impossible for a north magnet to occupy this cell after some sequence of operations from the initial placement.
Determine if it is possible to place magnets such that these conditions are met. If it is possible, find the minimum number of north magnets required (there are no requirements on the number of south magnets).
Input
The first line contains two integers n and m (1β€ n,mβ€ 1000) β the number of rows and the number of columns, respectively.
The next n lines describe the coloring. The i-th of these lines contains a string of length m, where the j-th character denotes the color of the cell in row i and column j. The characters "#" and "." represent black and white, respectively. It is guaranteed, that the string will not contain any other characters.
Output
Output a single integer, the minimum possible number of north magnets required.
If there is no placement of magnets that satisfies all conditions, print a single integer -1.
Examples
Input
3 3
.#.
###
##.
Output
1
Input
4 2
##
.#
.#
##
Output
-1
Input
4 5
....#
####.
.###.
.#...
Output
2
Input
2 1
.
#
Output
-1
Input
3 5
.....
.....
.....
Output
0
Note
In the first test, here is an example placement of magnets:
<image>
In the second test, we can show that no required placement of magnets exists. Here are three example placements that fail to meet the requirements. The first example violates rule 3 since we can move the north magnet down onto a white square. The second example violates rule 2 since we cannot move the north magnet to the bottom-left black square by any sequence of operations. The third example violates rule 1 since there is no south magnet in the first column.
<image>
In the third test, here is an example placement of magnets. We can show that there is no required placement of magnets with fewer north magnets.
<image>
In the fourth test, we can show that no required placement of magnets exists. Here are two example placements that fail to meet the requirements. The first example violates rule 1 since there is no south magnet in the first row. The second example violates rules 1 and 3 since there is no south magnet in the second row and we can move the north magnet up one unit onto a white square.
<image>
In the fifth test, we can put the south magnet in each cell and no north magnets. Because there are no black cells, it will be a correct placement. | import sys
import math
def readStr():
return sys.stdin.readline().rstrip()
def readInts():
return list(map(int, readStr().split(' ')))
def main(n, m, a):
x = 0
empty = False
for i in range(n):
boundary = 0
dx = True
for j in range(m):
if a[i][j] == '#':
if j == 0 or a[i][j-1] == '.':
boundary += 1
if i > 0 and a[i-1][j] == '#':
dx = False
if boundary > 1:
return (-1, None)
if boundary == 0:
empty = True
elif dx:
x += 1
return (x, empty)
if __name__ == '__main__':
(n, m) = readInts()
a = list()
for i in range(n):
ai = readStr()
a.append(list(ai))
(x1, empty1) = main(n, m, a)
b = list(map(list, zip(*a)))
(x2, empty2) = main(m, n, b)
if x1 == -1 or x2 == -1:
print(-1)
elif empty1 != empty2:
print(-1)
else:
print(x1)
| {
"input": [
"3 3\n.#.\n###\n##.\n",
"4 5\n....#\n####.\n.###.\n.#...\n",
"4 2\n##\n.#\n.#\n##\n",
"3 5\n.....\n.....\n.....\n",
"2 1\n.\n#\n"
],
"output": [
"1\n",
"2\n",
"-1\n",
"0\n",
"-1\n"
]
} |
415 | 8 | You are given an array consisting of n integers a_1, a_2, ..., a_n. Initially a_x = 1, all other elements are equal to 0.
You have to perform m operations. During the i-th operation, you choose two indices c and d such that l_i β€ c, d β€ r_i, and swap a_c and a_d.
Calculate the number of indices k such that it is possible to choose the operations so that a_k = 1 in the end.
Input
The first line contains a single integer t (1 β€ t β€ 100) β the number of test cases. Then the description of t testcases follow.
The first line of each test case contains three integers n, x and m (1 β€ n β€ 10^9; 1 β€ m β€ 100; 1 β€ x β€ n).
Each of next m lines contains the descriptions of the operations; the i-th line contains two integers l_i and r_i (1 β€ l_i β€ r_i β€ n).
Output
For each test case print one integer β the number of indices k such that it is possible to choose the operations so that a_k = 1 in the end.
Example
Input
3
6 4 3
1 6
2 3
5 5
4 1 2
2 4
1 2
3 3 2
2 3
1 2
Output
6
2
3
Note
In the first test case, it is possible to achieve a_k = 1 for every k. To do so, you may use the following operations:
1. swap a_k and a_4;
2. swap a_2 and a_2;
3. swap a_5 and a_5.
In the second test case, only k = 1 and k = 2 are possible answers. To achieve a_1 = 1, you have to swap a_1 and a_1 during the second operation. To achieve a_2 = 1, you have to swap a_1 and a_2 during the second operation. | def f():
return list(map(int,input().split()))
for _ in range(int(input())):
n,k,m=f()
p=q=k
for _ in range(m):
a,b=f()
if a<=p<=b or a<=q<=b:
p=min(p,a)
q=max(q,b)
print(q-p+1) | {
"input": [
"3\n6 4 3\n1 6\n2 3\n5 5\n4 1 2\n2 4\n1 2\n3 3 2\n2 3\n1 2\n"
],
"output": [
"6\n2\n3\n"
]
} |
416 | 8 | You are given a non-decreasing array of non-negative integers a_1, a_2, β¦, a_n. Also you are given a positive integer k.
You want to find m non-decreasing arrays of non-negative integers b_1, b_2, β¦, b_m, such that:
* The size of b_i is equal to n for all 1 β€ i β€ m.
* For all 1 β€ j β€ n, a_j = b_{1, j} + b_{2, j} + β¦ + b_{m, j}. In the other word, array a is the sum of arrays b_i.
* The number of different elements in the array b_i is at most k for all 1 β€ i β€ m.
Find the minimum possible value of m, or report that there is no possible m.
Input
The first line contains one integer t (1 β€ t β€ 100): the number of test cases.
The first line of each test case contains two integers n, k (1 β€ n β€ 100, 1 β€ k β€ n).
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_1 β€ a_2 β€ β¦ β€ a_n β€ 100, a_n > 0).
Output
For each test case print a single integer: the minimum possible value of m. If there is no such m, print -1.
Example
Input
6
4 1
0 0 0 1
3 1
3 3 3
11 3
0 1 2 2 3 3 3 4 4 4 4
5 3
1 2 3 4 5
9 4
2 2 3 5 7 11 13 13 17
10 7
0 1 1 2 3 3 4 5 5 6
Output
-1
1
2
2
2
1
Note
In the first test case, there is no possible m, because all elements of all arrays should be equal to 0. But in this case, it is impossible to get a_4 = 1 as the sum of zeros.
In the second test case, we can take b_1 = [3, 3, 3]. 1 is the smallest possible value of m.
In the third test case, we can take b_1 = [0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2] and b_2 = [0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2]. It's easy to see, that a_i = b_{1, i} + b_{2, i} for all i and the number of different elements in b_1 and in b_2 is equal to 3 (so it is at most 3). It can be proven that 2 is the smallest possible value of m. | from math import ceil
def main(n, k, a):
a = set(a)
n = len(a)
if n > k == 1:
return -1
if n <= k:
return 1
return 1 + ceil((n-k)/(k-1))
for i in range(int(input())):
n, k = map(int, input().split())
a = list(map(int, input().split()))
print(main(n, k, a))
| {
"input": [
"6\n4 1\n0 0 0 1\n3 1\n3 3 3\n11 3\n0 1 2 2 3 3 3 4 4 4 4\n5 3\n1 2 3 4 5\n9 4\n2 2 3 5 7 11 13 13 17\n10 7\n0 1 1 2 3 3 4 5 5 6\n"
],
"output": [
"-1\n1\n2\n2\n2\n1\n"
]
} |
417 | 11 | There are some rabbits in Singapore Zoo. To feed them, Zookeeper bought n carrots with lengths a_1, a_2, a_3, β¦, a_n. However, rabbits are very fertile and multiply very quickly. Zookeeper now has k rabbits and does not have enough carrots to feed all of them. To solve this problem, Zookeeper decided to cut the carrots into k pieces. For some reason, all resulting carrot lengths must be positive integers.
Big carrots are very difficult for rabbits to handle and eat, so the time needed to eat a carrot of size x is x^2.
Help Zookeeper split his carrots while minimizing the sum of time taken for rabbits to eat the carrots.
Input
The first line contains two integers n and k (1 β€ n β€ k β€ 10^5): the initial number of carrots and the number of rabbits.
The next line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^6): lengths of carrots.
It is guaranteed that the sum of a_i is at least k.
Output
Output one integer: the minimum sum of time taken for rabbits to eat carrots.
Examples
Input
3 6
5 3 1
Output
15
Input
1 4
19
Output
91
Note
For the first test, the optimal sizes of carrots are \{1,1,1,2,2,2\}. The time taken is 1^2+1^2+1^2+2^2+2^2+2^2=15
For the second test, the optimal sizes of carrots are \{4,5,5,5\}. The time taken is 4^2+5^2+5^2+5^2=91. | import heapq
n, k = map(int, input().split())
A = list(map(int, input().split()))
def cal(x, m):
k, r = divmod(x, m)
return r * (k + 1) ** 2 + (m - r) * k ** 2
hp = [(cal(a, 2) - cal(a, 1), a, 2) for a in A]
heapq.heapify(hp)
ans = sum(a ** 2 for a in A)
for _ in range(k - n):
d, x, m = heapq.heappop(hp)
ans += d
heapq.heappush(hp, (cal(x, m + 1) - cal(x, m), x, m + 1))
print(ans) | {
"input": [
"1 4\n19\n",
"3 6\n5 3 1\n"
],
"output": [
"91\n",
"15\n"
]
} |
418 | 12 | Jeel and Ashish play a game on an n Γ m matrix. The rows are numbered 1 to n from top to bottom and the columns are numbered 1 to m from left to right. They play turn by turn. Ashish goes first.
Initially, each cell of the matrix contains a non-negative integer. Each turn, a player must perform all of the following actions in order.
* Choose a starting cell (r_1, c_1) with non-zero value.
* Choose a finishing cell (r_2, c_2) such that r_1 β€ r_2 and c_1 β€ c_2.
* Decrease the value of the starting cell by some positive non-zero integer.
* Pick any of the shortest paths between the two cells and either increase, decrease or leave the values of cells on this path unchanged. Note that:
* a shortest path is one that passes through the least number of cells;
* all cells on this path excluding the starting cell, but the finishing cell may be modified;
* the resulting value of each cell must be a non-negative integer;
* the cells are modified independently and not necessarily by the same value.
If the starting and ending cells are the same, then as per the rules, the value of the cell is decreased. No other operations are performed.
The game ends when all the values become zero. The player who is unable to make a move loses. It can be shown that the game will end in a finite number of moves if both players play optimally.
Given the initial matrix, if both players play optimally, can you predict who will win?
Input
The first line contains a single integer t (1 β€ t β€ 10) β the number of test cases. The description of each test case is as follows.
The first line of each test case contains two integers n and m (1 β€ n, m β€ 100) β the dimensions of the matrix.
The next n lines contain m space separated integers a_{i,j} (0 β€ a_{i,j} β€ 10^6) β the values of each cell of the matrix.
Output
For each test case, if Ashish wins the game, print "Ashish", otherwise print "Jeel" (without the quotes).
Example
Input
4
1 1
0
1 3
0 0 5
2 2
0 1
1 0
3 3
1 2 3
4 5 6
7 8 9
Output
Jeel
Ashish
Jeel
Ashish
Note
In the first test case, the only cell of the matrix is 0. There are no moves Ashish can make. Jeel is the winner.
In the second test case, Ashish can choose (r_1, c_1) = (r_2, c_2) = (1,3) and reduce the cell to 0, leaving [0, 0, 0]. Jeel cannot perform any moves. Ashish wins. | def solve_case():
n, m = [int(x) for x in input().split()];a = [[int(x) for x in input().split()] for x in range(n)];xr = [0] * (n + m)
for i in range(n):
for j in range(m):xr[i + j] ^= a[i][j]
return sum(xr) > 0
for _ in range(int(input())):print(['Jeel', 'Ashish'][solve_case()]) | {
"input": [
"4\n1 1\n0\n1 3\n0 0 5\n2 2\n0 1\n1 0\n3 3\n1 2 3\n4 5 6\n7 8 9\n"
],
"output": [
"\nJeel\nAshish\nJeel\nAshish\n"
]
} |
419 | 11 | Masha works in an advertising agency. In order to promote the new brand, she wants to conclude contracts with some bloggers. In total, Masha has connections of n different bloggers. Blogger numbered i has a_i followers.
Since Masha has a limited budget, she can only sign a contract with k different bloggers. Of course, Masha wants her ad to be seen by as many people as possible. Therefore, she must hire bloggers with the maximum total number of followers.
Help her, find the number of ways to select k bloggers so that the total number of their followers is maximum possible. Two ways are considered different if there is at least one blogger in the first way, which is not in the second way. Masha believes that all bloggers have different followers (that is, there is no follower who would follow two different bloggers).
For example, if n=4, k=3, a=[1, 3, 1, 2], then Masha has two ways to select 3 bloggers with the maximum total number of followers:
* conclude contracts with bloggers with numbers 1, 2 and 4. In this case, the number of followers will be equal to a_1 + a_2 + a_4 = 6.
* conclude contracts with bloggers with numbers 2, 3 and 4. In this case, the number of followers will be equal to a_2 + a_3 + a_4 = 6.
Since the answer can be quite large, output it modulo 10^9+7.
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 1000) β the number of bloggers and how many of them you can sign a contract with.
The second line of each test case contains n integers a_1, a_2, β¦ a_n (1 β€ a_i β€ n) β the number of followers of each blogger.
It is guaranteed that the sum of n over all test cases does not exceed 1000.
Output
For each test case, on a separate line output one integer β the number of ways to select k bloggers so that the total number of their followers is maximum possible.
Example
Input
3
4 3
1 3 1 2
4 2
1 1 1 1
2 1
1 2
Output
2
6
1
Note
The test case is explained in the statements.
In the second test case, the following ways are valid:
* conclude contracts with bloggers with numbers 1 and 2. In this case, the number of followers will be equal to a_1 + a_2 = 2;
* conclude contracts with bloggers with numbers 1 and 3. In this case, the number of followers will be equal to a_1 + a_3 = 2;
* conclude contracts with bloggers with numbers 1 and 4. In this case, the number of followers will be equal to a_1 + a_4 = 2;
* conclude contracts with bloggers with numbers 2 and 3. In this case, the number of followers will be equal to a_2 + a_3 = 2;
* conclude contracts with bloggers with numbers 2 and 4. In this case, the number of followers will be equal to a_2 + a_4 = 2;
* conclude contracts with bloggers with numbers 3 and 4. In this case, the number of followers will be equal to a_3 + a_4 = 2.
In the third test case, the following ways are valid:
* concludes a contract with a blogger with the number 2. In this case, the number of followers will be equal to a_2 = 2. | import math
def nCr(n,r):
f = math.factorial
return f(n) // (f(r)*f(n-r))
for iii in range(int(input())):
n,k=map(int,input().split())
arr=list(map(int,input().split()))
arr.sort(reverse=True)
xx=arr.count(arr[k-1])
c=0
for item in arr[:k]:
if(item==arr[k-1]):
c+=1
ans=nCr(xx,c)
print(ans%(10**9+7)) | {
"input": [
"3\n4 3\n1 3 1 2\n4 2\n1 1 1 1\n2 1\n1 2\n"
],
"output": [
"\n2\n6\n1\n"
]
} |
420 | 11 | Monocarp is playing a game "Assimilation IV". In this game he manages a great empire: builds cities and conquers new lands.
Monocarp's empire has n cities. In order to conquer new lands he plans to build one Monument in each city. The game is turn-based and, since Monocarp is still amateur, he builds exactly one Monument per turn.
Monocarp has m points on the map he'd like to control using the constructed Monuments. For each point he knows the distance between it and each city. Monuments work in the following way: when built in some city, a Monument controls all points at distance at most 1 to this city. Next turn, the Monument controls all points at distance at most 2, the turn after β at distance at most 3, and so on. Monocarp will build n Monuments in n turns and his empire will conquer all points that are controlled by at least one Monument.
Monocarp can't figure out any strategy, so during each turn he will choose a city for a Monument randomly among all remaining cities (cities without Monuments). Monocarp wants to know how many points (among m of them) he will conquer at the end of turn number n. Help him to calculate the expected number of conquered points!
Input
The first line contains two integers n and m (1 β€ n β€ 20; 1 β€ m β€ 5 β
10^4) β the number of cities and the number of points.
Next n lines contains m integers each: the j-th integer of the i-th line d_{i, j} (1 β€ d_{i, j} β€ n + 1) is the distance between the i-th city and the j-th point.
Output
It can be shown that the expected number of points Monocarp conquers at the end of the n-th turn can be represented as an irreducible fraction x/y. Print this fraction modulo 998 244 353, i. e. value x β
y^{-1} mod 998244353 where y^{-1} is such number that y β
y^{-1} mod 998244353 = 1.
Example
Input
3 5
1 4 4 3 4
1 4 1 4 2
1 4 4 4 3
Output
166374062
Note
Let's look at all possible orders of cities Monuments will be build in:
* [1, 2, 3]:
* the first city controls all points at distance at most 3, in other words, points 1 and 4;
* the second city controls all points at distance at most 2, or points 1, 3 and 5;
* the third city controls all points at distance at most 1, or point 1.
In total, 4 points are controlled.
* [1, 3, 2]: the first city controls points 1 and 4; the second city β points 1 and 3; the third city β point 1. In total, 3 points.
* [2, 1, 3]: the first city controls point 1; the second city β points 1, 3 and 5; the third city β point 1. In total, 3 points.
* [2, 3, 1]: the first city controls point 1; the second city β points 1, 3 and 5; the third city β point 1. In total, 3 points.
* [3, 1, 2]: the first city controls point 1; the second city β points 1 and 3; the third city β points 1 and 5. In total, 3 points.
* [3, 2, 1]: the first city controls point 1; the second city β points 1, 3 and 5; the third city β points 1 and 5. In total, 3 points.
The expected number of controlled points is (4 + 3 + 3 + 3 + 3 + 3)/(6) = 19/6 or 19 β
6^{-1} β‘ 19 β
166374059 β‘ 166374062 \pmod{998244353} | p=998244353
def f(x,y):
r=1
x=x%p
if x==0:
return 0
while y>0:
if y%2==1:
r=(r*x)%p
y=y>>1
x=(x*x)%p
return r
n,m=map(int,input().split())
l=[]
for _ in range(n):
l.append(list(map(int,input().split())))
a=1
for i in range(1,n+1):
a=(a*i)%p
q=0
for i in range(m):
v=[0]*n
for j in range(n):
v[j]=l[j][i]
v.sort()
x=1
for j in range(n):
x=(x*(min(v[j]-1,n)-j))%p
q=(q+a-x)%p
print((q*f(a,p-2))%p) | {
"input": [
"3 5\n1 4 4 3 4\n1 4 1 4 2\n1 4 4 4 3\n"
],
"output": [
"\n166374062\n"
]
} |
421 | 8 | One day, as Sherlock Holmes was tracking down one very important criminal, he found a wonderful painting on the wall. This wall could be represented as a plane. The painting had several concentric circles that divided the wall into several parts. Some parts were painted red and all the other were painted blue. Besides, any two neighboring parts were painted different colors, that is, the red and the blue color were alternating, i. e. followed one after the other. The outer area of the wall (the area that lied outside all circles) was painted blue. Help Sherlock Holmes determine the total area of red parts of the wall.
Let us remind you that two circles are called concentric if their centers coincide. Several circles are called concentric if any two of them are concentric.
Input
The first line contains the single integer n (1 β€ n β€ 100). The second line contains n space-separated integers ri (1 β€ ri β€ 1000) β the circles' radii. It is guaranteed that all circles are different.
Output
Print the single real number β total area of the part of the wall that is painted red. The answer is accepted if absolute or relative error doesn't exceed 10 - 4.
Examples
Input
1
1
Output
3.1415926536
Input
3
1 4 2
Output
40.8407044967
Note
In the first sample the picture is just one circle of radius 1. Inner part of the circle is painted red. The area of the red part equals Ο Γ 12 = Ο.
In the second sample there are three circles of radii 1, 4 and 2. Outside part of the second circle is painted blue. Part between the second and the third circles is painted red. Part between the first and the third is painted blue. And, finally, the inner part of the first circle is painted red. Overall there are two red parts: the ring between the second and the third circles and the inner part of the first circle. Total area of the red parts is equal (Ο Γ 42 - Ο Γ 22) + Ο Γ 12 = Ο Γ 12 + Ο = 13Ο | def mi():
return map(int, input().split())
n = int(input())
a = list(mi())
a.sort(reverse=True)
ans = 0
s = -1
from math import pi
for r in a:
s*=-1
ans+=pi*r*r*s
print (ans) | {
"input": [
"1\n1\n",
"3\n1 4 2\n"
],
"output": [
"3.141592653589793\n",
"40.840704496667314\n"
]
} |
422 | 7 | The Smart Beaver from ABBYY began to develop a new educational game for children. The rules of the game are fairly simple and are described below.
The playing field is a sequence of n non-negative integers ai numbered from 1 to n. The goal of the game is to make numbers a1, a2, ..., ak (i.e. some prefix of the sequence) equal to zero for some fixed k (k < n), and this should be done in the smallest possible number of moves.
One move is choosing an integer i (1 β€ i β€ n) such that ai > 0 and an integer t (t β₯ 0) such that i + 2t β€ n. After the values of i and t have been selected, the value of ai is decreased by 1, and the value of ai + 2t is increased by 1. For example, let n = 4 and a = (1, 0, 1, 2), then it is possible to make move i = 3, t = 0 and get a = (1, 0, 0, 3) or to make move i = 1, t = 1 and get a = (0, 0, 2, 2) (the only possible other move is i = 1, t = 0).
You are given n and the initial sequence ai. The task is to calculate the minimum number of moves needed to make the first k elements of the original sequence equal to zero for each possible k (1 β€ k < n).
Input
The first input line contains a single integer n. The second line contains n integers ai (0 β€ ai β€ 104), separated by single spaces.
The input limitations for getting 20 points are:
* 1 β€ n β€ 300
The input limitations for getting 50 points are:
* 1 β€ n β€ 2000
The input limitations for getting 100 points are:
* 1 β€ n β€ 105
Output
Print exactly n - 1 lines: the k-th output line must contain the minimum number of moves needed to make the first k elements of the original sequence ai equal to zero.
Please do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams, or the %I64d specifier.
Examples
Input
4
1 0 1 2
Output
1
1
3
Input
8
1 2 3 4 5 6 7 8
Output
1
3
6
10
16
24
40 | n=int(input())
a=list(map(int, input().split(" ")))
def check(n):
while n>1:
n/=2
if n==1:
return True
else:
return False
s=0
for j in range(n-1):
s+=a[j]
for i in range(n-1, -1, -1):
if check(i-j):
print(s)
a[i]+=a[j]
break
| {
"input": [
"8\n1 2 3 4 5 6 7 8\n",
"4\n1 0 1 2\n"
],
"output": [
"1\n3\n6\n10\n16\n24\n40\n",
"1\n1\n3\n"
]
} |
423 | 9 | Once Bob saw a string. It contained so many different letters, that the letters were marked by numbers, but at the same time each letter could be met in the string at most 10 times. Bob didn't like that string, because it contained repeats: a repeat of length x is such a substring of length 2x, that its first half coincides character by character with its second half. Bob started deleting all the repeats from the string. He does it as follows: while it's possible, Bob takes the shortest repeat, if it is not unique, he takes the leftmost one, and deletes its left half and everything that is to the left of this repeat.
You're given the string seen by Bob. Find out, what it will look like after Bob deletes all the repeats in the way described above.
Input
The first input line contains integer n (1 β€ n β€ 105) β length of the string. The following line contains n space-separated integer numbers from 0 to 109 inclusive β numbers that stand for the letters of the string. It's guaranteed that each letter can be met in the string at most 10 times.
Output
In the first line output the length of the string's part, left after Bob's deletions. In the second line output all the letters (separated by a space) of the string, left after Bob deleted all the repeats in the described way.
Examples
Input
6
1 2 3 1 2 3
Output
3
1 2 3
Input
7
4 5 6 5 6 7 7
Output
1
7 | def pow(x, exp, mod):
res = 1
while exp:
if exp & 1:
res = (res * x) % mod
x = (x * x) % mod
exp >>= 1
return res
MOD = 2 ** 121 - 1
M = int(1e9) + 1
n = int(input())
vals = list(map(int, input().split()))
groups = dict()
for i in range(n):
groups.setdefault(vals[i], []).append(i)
powsA = [1]
for i in range(n):
powsA.append((powsA[-1] * M) % MOD)
hashes = [0] * (n + 1)
for i in range(n):
hashes[i + 1] = (hashes[i] * M + vals[i]) % MOD
def get_hash(p, l):
res = hashes[p + l] - (hashes[p] * powsA[l]) % MOD
if res < 0:
res += MOD
elif res > MOD:
res -= MOD
return res
best = 0
i = 0
while i < n:
val = vals[i]
for j in groups[val]:
if j <= i:
continue
l = j - i
if j + l <= n and get_hash(i, l) == get_hash(j, l):
best = max(best, j)
i = j - 1
break
i += 1
res = vals[best:]
print(len(res))
print(" ".join(map(str, res))) | {
"input": [
"6\n1 2 3 1 2 3\n",
"7\n4 5 6 5 6 7 7\n"
],
"output": [
"3\n1 2 3 ",
"1\n7 "
]
} |
424 | 8 | Chilly Willy loves playing with numbers. He only knows prime numbers that are digits yet. These numbers are 2, 3, 5 and 7. But Willy grew rather bored of such numbers, so he came up with a few games that were connected with them.
Chilly Willy wants to find the minimum number of length n, such that it is simultaneously divisible by all numbers Willy already knows (2, 3, 5 and 7). Help him with that.
A number's length is the number of digits in its decimal representation without leading zeros.
Input
A single input line contains a single integer n (1 β€ n β€ 105).
Output
Print a single integer β the answer to the problem without leading zeroes, or "-1" (without the quotes), if the number that meet the problem condition does not exist.
Examples
Input
1
Output
-1
Input
5
Output
10080 | def cat(n):
if n < 3:
return -1
return 210 * (10 ** (n - 1) // 210 + 1)
print(cat(int(input())))
| {
"input": [
"5\n",
"1\n"
],
"output": [
"10080\n",
"-1\n"
]
} |
425 | 9 | Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image> | def main():
n, res = int(input()), []
l = list(map(int, input().split()))
for _ in range(int(input())):
w, h = map(int, input().split())
m = max(l[0], l[w - 1])
res.append(m)
l[0] = m + h
print('\n'.join(map(str, res)))
if __name__ == '__main__':
main()
| {
"input": [
"1\n1\n5\n1 2\n1 10\n1 10\n1 10\n1 10\n",
"3\n1 2 3\n2\n1 1\n3 1\n",
"5\n1 2 3 6 6\n4\n1 1\n3 1\n1 1\n4 3\n"
],
"output": [
"1\n3\n13\n23\n33\n",
"1\n3\n",
"1\n3\n4\n6\n"
]
} |
426 | 9 | Kalila and Dimna are two jackals living in a huge jungle. One day they decided to join a logging factory in order to make money.
The manager of logging factory wants them to go to the jungle and cut n trees with heights a1, a2, ..., an. They bought a chain saw from a shop. Each time they use the chain saw on the tree number i, they can decrease the height of this tree by one unit. Each time that Kalila and Dimna use the chain saw, they need to recharge it. Cost of charging depends on the id of the trees which have been cut completely (a tree is cut completely if its height equal to 0). If the maximum id of a tree which has been cut completely is i (the tree that have height ai in the beginning), then the cost of charging the chain saw would be bi. If no tree is cut completely, Kalila and Dimna cannot charge the chain saw. The chainsaw is charged in the beginning. We know that for each i < j, ai < aj and bi > bj and also bn = 0 and a1 = 1. Kalila and Dimna want to cut all the trees completely, with minimum cost.
They want you to help them! Will you?
Input
The first line of input contains an integer n (1 β€ n β€ 105). The second line of input contains n integers a1, a2, ..., an (1 β€ ai β€ 109). The third line of input contains n integers b1, b2, ..., bn (0 β€ bi β€ 109).
It's guaranteed that a1 = 1, bn = 0, a1 < a2 < ... < an and b1 > b2 > ... > bn.
Output
The only line of output must contain the minimum cost of cutting all the trees completely.
Please, do not write the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 4 5
5 4 3 2 0
Output
25
Input
6
1 2 3 10 20 30
6 5 4 3 2 0
Output
138 | read = lambda: map(int, input().split())
n = int(input())
a = list(read())
b = list(read())
dp = [0] * n
st = [0]
def f1():
i0, i1 = st[0], st[1]
b1 = dp[i1] - dp[i0]
k1 = b[i0] - b[i1]
return b1 <= a[i] * k1
def f2():
i1, i2 = st[-1], st[-2]
k1, k2 = b[i1] - b[i], b[i2] - b[i1]
b1, b2 = dp[i] - dp[i1], dp[i1] - dp[i2]
return b2 * k1 > b1 * k2
for i in range(1, n):
while len(st) > 1 and f1(): st.pop(0)
dp[i] = dp[st[0]] + a[i] * b[st[0]]
while len(st) > 1 and f2(): st.pop()
st.append(i)
print(dp[n - 1]) | {
"input": [
"5\n1 2 3 4 5\n5 4 3 2 0\n",
"6\n1 2 3 10 20 30\n6 5 4 3 2 0\n"
],
"output": [
"25\n",
"138\n"
]
} |
427 | 9 | Mad scientist Mike does not use slow hard disks. His modification of a hard drive has not one, but n different heads that can read data in parallel.
When viewed from the side, Mike's hard drive is an endless array of tracks. The tracks of the array are numbered from left to right with integers, starting with 1. In the initial state the i-th reading head is above the track number hi. For each of the reading heads, the hard drive's firmware can move the head exactly one track to the right or to the left, or leave it on the current track. During the operation each head's movement does not affect the movement of the other heads: the heads can change their relative order; there can be multiple reading heads above any of the tracks. A track is considered read if at least one head has visited this track. In particular, all of the tracks numbered h1, h2, ..., hn have been read at the beginning of the operation.
<image>
Mike needs to read the data on m distinct tracks with numbers p1, p2, ..., pm. Determine the minimum time the hard drive firmware needs to move the heads and read all the given tracks. Note that an arbitrary number of other tracks can also be read.
Input
The first line of the input contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of disk heads and the number of tracks to read, accordingly. The second line contains n distinct integers hi in ascending order (1 β€ hi β€ 1010, hi < hi + 1) β the initial positions of the heads. The third line contains m distinct integers pi in ascending order (1 β€ pi β€ 1010, pi < pi + 1) - the numbers of tracks to read.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is recommended to use the cin, cout streams or the %I64d specifier.
Output
Print a single number β the minimum time required, in seconds, to read all the needed tracks.
Examples
Input
3 4
2 5 6
1 3 6 8
Output
2
Input
3 3
1 2 3
1 2 3
Output
0
Input
1 2
165
142 200
Output
81
Note
The first test coincides with the figure. In this case the given tracks can be read in 2 seconds in the following way:
1. during the first second move the 1-st head to the left and let it stay there;
2. move the second head to the left twice;
3. move the third head to the right twice (note that the 6-th track has already been read at the beginning).
One cannot read the tracks in 1 second as the 3-rd head is at distance 2 from the 8-th track. | import sys
def input():
return sys.stdin.buffer.readline()[:-1]
for T in range(1):
n, m = map(int, input().split())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
ok, ng = 10**11, -1
while ok-ng > 1:
x = (ok+ng)//2
flg = True
j = 0
for i in range(n):
l = max(p[i] - q[j], 0)
if l > x:
flg = False
break
while j < m and q[j] < p[i]:
j += 1
if j == m:
break
while j < m:
r = q[j] - p[i]
if min(l, r)*2 + max(l, r) <= x:
j += 1
continue
else:
break
if j == m:
break
if flg == False or j < m:
ng = x
else:
ok = x
print(ok) | {
"input": [
"3 4\n2 5 6\n1 3 6 8\n",
"3 3\n1 2 3\n1 2 3\n",
"1 2\n165\n142 200\n"
],
"output": [
"2\n",
"0\n",
"81\n"
]
} |
428 | 11 | Dima loves Inna very much. He decided to write a song for her. Dima has a magic guitar with n strings and m frets. Dima makes the guitar produce sounds like that: to play a note, he needs to hold one of the strings on one of the frets and then pull the string. When Dima pulls the i-th string holding it on the j-th fret the guitar produces a note, let's denote it as aij. We know that Dima's guitar can produce k distinct notes. It is possible that some notes can be produced in multiple ways. In other words, it is possible that aij = apq at (i, j) β (p, q).
Dima has already written a song β a sequence of s notes. In order to play the song, you need to consecutively produce the notes from the song on the guitar. You can produce each note in any available way. Dima understood that there are many ways to play a song and he wants to play it so as to make the song look as complicated as possible (try to act like Cobein).
We'll represent a way to play a song as a sequence of pairs (xi, yi) (1 β€ i β€ s), such that the xi-th string on the yi-th fret produces the i-th note from the song. The complexity of moving between pairs (x1, y1) and (x2, y2) equals <image> + <image>. The complexity of a way to play a song is the maximum of complexities of moving between adjacent pairs.
Help Dima determine the maximum complexity of the way to play his song! The guy's gotta look cool!
Input
The first line of the input contains four integers n, m, k and s (1 β€ n, m β€ 2000, 1 β€ k β€ 9, 2 β€ s β€ 105).
Then follow n lines, each containing m integers aij (1 β€ aij β€ k). The number in the i-th row and the j-th column (aij) means a note that the guitar produces on the i-th string and the j-th fret.
The last line of the input contains s integers qi (1 β€ qi β€ k) β the sequence of notes of the song.
Output
In a single line print a single number β the maximum possible complexity of the song.
Examples
Input
4 6 5 7
3 1 2 2 3 1
3 2 2 2 5 5
4 2 2 2 5 3
3 2 2 1 4 3
2 3 1 4 1 5 1
Output
8
Input
4 4 9 5
4 7 9 5
1 2 1 7
8 3 4 9
5 7 7 2
7 1 9 2 5
Output
4 | def solution() : # ζ倧ηθ·η¦»ζ₯θͺδΊθ§θ½ιθΏηηΉ
n,m,k,s = map(int, input().split())
dis = lambda a,b : abs(a[0] - b[0]) + abs(a[1] - b[1])
corner = [(0,0), (0,m-1), (n-1,0), (n-1,m-1)]
vertex = [[(n,m), (n,-1), (-1,m), (-1,-1)] for _ in range(k+1)]
for i in range(n) :
for j,note in enumerate(map(int, input().split())) :
vertex[note] = [
(i,j) if dis((i,j), c) < dis(v, c) else v
for v,c in zip(vertex[note], corner)]
maxdis = [[-1] * (k+1) for _ in range(k+1)]
pairs = [(0,3),(3,0),(1,2),(2,1)]
for i in range(1, k+1) :
for j in range(i, k+1) :
vi,vj = vertex[i],vertex[j]
maxdis[i][j] = max(dis(vi[a], vj[b]) for a,b in pairs)
maxdis[j][i] = maxdis[i][j]
s = list(map(int, input().split()))
print(max(maxdis[s[i]][s[i+1]] for i in range(len(s) - 1)))
solution() | {
"input": [
"4 6 5 7\n3 1 2 2 3 1\n3 2 2 2 5 5\n4 2 2 2 5 3\n3 2 2 1 4 3\n2 3 1 4 1 5 1\n",
"4 4 9 5\n4 7 9 5\n1 2 1 7\n8 3 4 9\n5 7 7 2\n7 1 9 2 5\n"
],
"output": [
"8\n",
"4\n"
]
} |
429 | 9 | Last year the world's largest square was built in Berland. It is known that the square can be represented as an infinite plane with an introduced Cartesian system of coordinates. On that square two sets of concentric circles were painted. Let's call the set of concentric circles with radii 1, 2, ..., K and the center in the point (z, 0) a (K, z)-set. Thus, on the square were painted a (N, x)-set and a (M, y)-set. You have to find out how many parts those sets divided the square into.
Input
The first line contains integers N, x, M, y. (1 β€ N, M β€ 100000, - 100000 β€ x, y β€ 100000, x β y).
Output
Print the sought number of parts.
Examples
Input
1 0 1 1
Output
4
Input
1 0 1 2
Output
3
Input
3 3 4 7
Output
17
Note
Picture for the third sample:
<image> | def readGen(trans):
while 1:
for x in input().split():
yield(trans(x))
readint=readGen(int)
[N,x,M,y]=(next(readint) for i in range(4))
d=abs(y-x)
def interval(a,b): return range(a,b+1)
def case1(N,M,d): # d>=N
ans=0
for r in interval(1, min(M,d-N)):
ans+=1
if (M<=d-N):
return ans
for r in interval(d-N+1, min(M,d)):
ans+=2*(N+r-d)
if (M<=d):
return ans
for r in interval(d+1,min(M,d+N)):
ans+=2*(d+N-r+1)
if (M<=d+N):
return ans
for r in interval(d+N+1,M):
ans+=1
return ans
def partA(N,M,d):
ans=0
for r in interval(1,min(M,d)):
ans+=2*r-1
if (M<d+1):
return ans
for r in interval(d+1,min(M,2*d)):
ans+=2*(2*d-r)+1
return ans
def partB(N,M,d):
ans=0
bound1=min(2*d,N-d)
for r in interval(1,min(M,bound1)):
ans+=2*(r-1)+1
if (M<=bound1):
return ans
if (2*d<=N-d):
for r in interval(bound1+1,min(M,N-d)):
ans+=4*d
if (M<=N-d):
return ans
if (2*d>N-d):
for r in interval(bound1+1,min(M,2*d)):
ans+=2*(N-d)+1
if (M<=2*d):
return ans
bound2=max(2*d,N-d)
for r in interval(bound2+1,min(M,d+N)):
ans+=2*(d+N-r)+2
if (M<=d+N):
return ans
for r in interval(d+N+1,M):
ans+=1
return ans
def case2(N,M,d): # d<N
return partA(N,M,d)+partB(N,M,d)
def remain(N,M,d):
if (M>=d+N):
return 1
if (M>d):
return d+N-M+1
if (M<=d):
return N+1
def calc(N,M,d):
if (N<=d): return remain(N,M,d)+case1(N,M,d)
else: return remain(N,M,d)+case2(N,M,d)
print(calc(N,M,d))
| {
"input": [
"3 3 4 7\n",
"1 0 1 2\n",
"1 0 1 1\n"
],
"output": [
" 17\n",
" 3\n",
" 4\n"
]
} |
430 | 8 | Of course our child likes walking in a zoo. The zoo has n areas, that are numbered from 1 to n. The i-th area contains ai animals in it. Also there are m roads in the zoo, and each road connects two distinct areas. Naturally the zoo is connected, so you can reach any area of the zoo from any other area using the roads.
Our child is very smart. Imagine the child want to go from area p to area q. Firstly he considers all the simple routes from p to q. For each route the child writes down the number, that is equal to the minimum number of animals among the route areas. Let's denote the largest of the written numbers as f(p, q). Finally, the child chooses one of the routes for which he writes down the value f(p, q).
After the child has visited the zoo, he thinks about the question: what is the average value of f(p, q) for all pairs p, q (p β q)? Can you answer his question?
Input
The first line contains two integers n and m (2 β€ n β€ 105; 0 β€ m β€ 105). The second line contains n integers: a1, a2, ..., an (0 β€ ai β€ 105). Then follow m lines, each line contains two integers xi and yi (1 β€ xi, yi β€ n; xi β yi), denoting the road between areas xi and yi.
All roads are bidirectional, each pair of areas is connected by at most one road.
Output
Output a real number β the value of <image>.
The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
4 3
10 20 30 40
1 3
2 3
4 3
Output
16.666667
Input
3 3
10 20 30
1 2
2 3
3 1
Output
13.333333
Input
7 8
40 20 10 30 20 50 40
1 2
2 3
3 4
4 5
5 6
6 7
1 4
5 7
Output
18.571429
Note
Consider the first sample. There are 12 possible situations:
* p = 1, q = 3, f(p, q) = 10.
* p = 2, q = 3, f(p, q) = 20.
* p = 4, q = 3, f(p, q) = 30.
* p = 1, q = 2, f(p, q) = 10.
* p = 2, q = 4, f(p, q) = 20.
* p = 4, q = 1, f(p, q) = 10.
Another 6 cases are symmetrical to the above. The average is <image>.
Consider the second sample. There are 6 possible situations:
* p = 1, q = 2, f(p, q) = 10.
* p = 2, q = 3, f(p, q) = 20.
* p = 1, q = 3, f(p, q) = 10.
Another 3 cases are symmetrical to the above. The average is <image>. | R = lambda:map(int, input().split())
n, m = R()
a = list(R())
p, f, sz =[], [], []
e = [[] for i in range(n)]
vis = [0] * n
ans = 0
def find(u):
if f[u] != u:
f[u] = find(f[u])
return f[u]
for i in range(n):
p.append([a[i], i])
f.append(i)
sz.append(1)
p.sort()
p.reverse()
for i in range(m):
u, v = R()
e[u - 1].append(v - 1)
e[v - 1].append(u - 1)
for i in range(n):
u = p[i][1]
for v in e[u]:
if (vis[v] and find(u) != find(v)):
pu, pv = u, v
if (sz[f[u]] > sz[f[v]]):
pu, pv = pv, pu
ans += p[i][0] * sz[f[pu]] * sz[f[pv]]
sz[f[pv]] += sz[f[pu]]
f[f[pu]] = f[pv]
vis[u] = 1
print("%.6f" %(2. * ans / n / (n - 1))) | {
"input": [
"7 8\n40 20 10 30 20 50 40\n1 2\n2 3\n3 4\n4 5\n5 6\n6 7\n1 4\n5 7\n",
"3 3\n10 20 30\n1 2\n2 3\n3 1\n",
"4 3\n10 20 30 40\n1 3\n2 3\n4 3\n"
],
"output": [
"18.5714285714\n",
"13.3333333333\n",
"16.6666666667\n"
]
} |
431 | 9 | Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers not larger than n. We'll denote as n the length of permutation p1, p2, ..., pn.
Your task is to find such permutation p of length n, that the group of numbers |p1 - p2|, |p2 - p3|, ..., |pn - 1 - pn| has exactly k distinct elements.
Input
The single line of the input contains two space-separated positive integers n, k (1 β€ k < n β€ 105).
Output
Print n integers forming the permutation. If there are multiple answers, print any of them.
Examples
Input
3 2
Output
1 3 2
Input
3 1
Output
1 2 3
Input
5 2
Output
1 3 2 4 5
Note
By |x| we denote the absolute value of number x. | def getLine():
return list(map(int,input().split()))
n,k = getLine()
l = [0]*n
for i in range(n):
if i%2 == 0:l[i] = i//2+1
else : l[i] = n - l[i-1]+1
ans=l
for i in range(k,n):
if k%2 == 0:l[i] = l[i-1]-1
else : l[i] = l[i-1]+1
for i in ans:
print(i,end=" ") | {
"input": [
"5 2\n",
"3 1\n",
"3 2\n"
],
"output": [
"1 3 2 4 5 ",
"1 2 3 \n",
"1 3 2 "
]
} |
432 | 9 | Amr bought a new video game "Guess Your Way Out!". The goal of the game is to find an exit from the maze that looks like a perfect binary tree of height h. The player is initially standing at the root of the tree and the exit from the tree is located at some leaf node.
Let's index all the leaf nodes from the left to the right from 1 to 2h. The exit is located at some node n where 1 β€ n β€ 2h, the player doesn't know where the exit is so he has to guess his way out!
Amr follows simple algorithm to choose the path. Let's consider infinite command string "LRLRLRLRL..." (consisting of alternating characters 'L' and 'R'). Amr sequentially executes the characters of the string using following rules:
* Character 'L' means "go to the left child of the current node";
* Character 'R' means "go to the right child of the current node";
* If the destination node is already visited, Amr skips current command, otherwise he moves to the destination node;
* If Amr skipped two consecutive commands, he goes back to the parent of the current node before executing next command;
* If he reached a leaf node that is not the exit, he returns to the parent of the current node;
* If he reaches an exit, the game is finished.
Now Amr wonders, if he follows this algorithm, how many nodes he is going to visit before reaching the exit?
Input
Input consists of two integers h, n (1 β€ h β€ 50, 1 β€ n β€ 2h).
Output
Output a single integer representing the number of nodes (excluding the exit node) Amr is going to visit before reaching the exit by following this algorithm.
Examples
Input
1 2
Output
2
Input
2 3
Output
5
Input
3 6
Output
10
Input
10 1024
Output
2046
Note
A perfect binary tree of height h is a binary tree consisting of h + 1 levels. Level 0 consists of a single node called root, level h consists of 2h nodes called leaves. Each node that is not a leaf has exactly two children, left and right one.
Following picture illustrates the sample test number 3. Nodes are labeled according to the order of visit.
<image> | def main():
h, n = (map(int, input().split()))
c, m = 0, 2 ** h
r = 0
while m > 1:
if c == 0:
if n > (m//2):
r += m - 1
n -= m//2
c = 1 - c
else:
if n > m//2:
n -= m//2
else:
r += m - 1
c = 1 - c
c = 1 - c
r += 1
m //= 2
print(r)
if __name__ == '__main__':
main()
| {
"input": [
"1 2\n",
"10 1024\n",
"3 6\n",
"2 3\n"
],
"output": [
"2\n",
"2046\n",
"10\n",
"5\n"
]
} |
433 | 10 | Andrewid the Android is a galaxy-famous detective. He is now chasing a criminal hiding on the planet Oxa-5, the planet almost fully covered with water.
The only dry land there is an archipelago of n narrow islands located in a row. For more comfort let's represent them as non-intersecting segments on a straight line: island i has coordinates [li, ri], besides, ri < li + 1 for 1 β€ i β€ n - 1.
To reach the goal, Andrewid needs to place a bridge between each pair of adjacent islands. A bridge of length a can be placed between the i-th and the (i + 1)-th islads, if there are such coordinates of x and y, that li β€ x β€ ri, li + 1 β€ y β€ ri + 1 and y - x = a.
The detective was supplied with m bridges, each bridge can be used at most once. Help him determine whether the bridges he got are enough to connect each pair of adjacent islands.
Input
The first line contains integers n (2 β€ n β€ 2Β·105) and m (1 β€ m β€ 2Β·105) β the number of islands and bridges.
Next n lines each contain two integers li and ri (1 β€ li β€ ri β€ 1018) β the coordinates of the island endpoints.
The last line contains m integer numbers a1, a2, ..., am (1 β€ ai β€ 1018) β the lengths of the bridges that Andrewid got.
Output
If it is impossible to place a bridge between each pair of adjacent islands in the required manner, print on a single line "No" (without the quotes), otherwise print in the first line "Yes" (without the quotes), and in the second line print n - 1 numbers b1, b2, ..., bn - 1, which mean that between islands i and i + 1 there must be used a bridge number bi.
If there are multiple correct answers, print any of them. Note that in this problem it is necessary to print "Yes" and "No" in correct case.
Examples
Input
4 4
1 4
7 8
9 10
12 14
4 5 3 8
Output
Yes
2 3 1
Input
2 2
11 14
17 18
2 9
Output
No
Input
2 1
1 1
1000000000000000000 1000000000000000000
999999999999999999
Output
Yes
1
Note
In the first sample test you can, for example, place the second bridge between points 3 and 8, place the third bridge between points 7 and 10 and place the first bridge between points 10 and 14.
In the second sample test the first bridge is too short and the second bridge is too long, so the solution doesn't exist. | #!/usr/bin/env python
# 556D_fug.py - Codeforces.com 556D Fug quiz
#
# Copyright (C) 2015 Sergey
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Input
The first line contains integers n and m - the number of islands and bridges.
Next n lines each contain two integers li and ri - the coordinates of the
island endpoints.
The last line contains m integer numbers a1..am - the lengths of the bridges
that Andrewid got.
Output
If it is impossible to place a bridge between each pair of adjacent islands
in the required manner, print on a single line "No" (without the quotes)
, otherwise print in the first line "Yes" (without the quotes), and in the
second line print n-1 numbers b1, bn-1, which mean that between islands
i and i+1 there must be used a bridge number bi.
If there are multiple correct answers, print any of them. Note that in this
problem it is necessary to print "Yes" and "No" in correct case
"""
# Standard libraries
import unittest
import sys
import re
# Additional libraries
import heapq
###############################################################################
# Fug Class
###############################################################################
class Fug:
""" Fug representation """
def __init__(self, args):
""" Default constructor """
self.list = args[0]
self.alist = args[1]
self.gn = len(self.list) - 1
# Sorted list of bridges
self.asrt = sorted((n, i) for i, n in enumerate(self.alist))
# List of gaps between islands
self.gaps = []
prevli = self.list[0]
for i in range(self.gn):
li = self.list[i+1]
min = li[0] - prevli[1]
max = li[1] - prevli[0]
self.gaps.append((min, max, i))
prevli = li
# Sorted list of gaps between islands
self.gsrt = sorted(self.gaps)
self.gmin = [n[0] for n in self.gsrt]
self.result = [None]*self.gn
self.heap = []
def iterate(self):
j = 0
for (b, i) in self.asrt:
# Traverse gmin array
while j < self.gn and self.gmin[j] <= b:
it = self.gsrt[j]
heapq.heappush(self.heap, (it[1], it[0], it[2]))
j += 1
# Update result and remove the element from lists
if self.heap:
(mmax, mmin, mi) = self.heap[0]
if mmin <= b and mmax >= b:
self.result[mi] = str(i + 1)
heapq.heappop(self.heap)
yield
def calculate(self):
""" Main calcualtion function of the class """
for it in self.iterate():
pass
for n in self.result:
if n is None:
return "No"
answer = "Yes\n"
answer += " ".join(self.result)
return answer
###############################################################################
# Executable code
###############################################################################
def get_inputs(test_inputs=None):
it = iter(test_inputs.split("\n")) if test_inputs else None
def uinput():
""" Unit-testable input function wrapper """
if it:
return next(it)
else:
return sys.stdin.readline()
# Getting string inputs. Place all uinput() calls here
num = [int(s) for s in uinput().split()]
list = [[int(s) for s in uinput().split()] for i in range(num[0])]
alist = [int(s) for s in uinput().split()]
# Decoding inputs into a list
inputs = [list, alist]
return inputs
def calculate(test_inputs=None):
""" Base class calculate method wrapper """
return Fug(get_inputs(test_inputs)).calculate()
###############################################################################
# Unit Tests
###############################################################################
class unitTests(unittest.TestCase):
def test_sample_tests(self):
""" Quiz sample tests. Add \n to separate lines """
# Sample test 1
test = "4 4\n1 4\n7 8\n9 10\n12 14\n4 5 3 8"
self.assertEqual(calculate(test), "Yes\n2 3 1")
self.assertEqual(
get_inputs(test),
[[[1, 4], [7, 8], [9, 10], [12, 14]], [4, 5, 3, 8]])
# My tests
test = "5 5\n1 1\n2 7\n8 8\n10 10\n16 16\n1 1 5 6 2"
self.assertEqual(calculate(test), "Yes\n1 2 5 4")
# Other tests
test = "2 2\n11 14\n17 18\n2 9"
self.assertEqual(calculate(test), "No")
# Other tests
test = (
"2 1\n1 1\n1000000000000000000 1000000000000000000" +
"\n999999999999999999")
self.assertEqual(calculate(test), "Yes\n1")
test = ("5 9\n1 2\n3 3\n5 7\n11 13\n14 20\n2 3 4 10 6 2 6 9 5")
self.assertEqual(calculate(test), "Yes\n1 6 3 2")
size = 10000
test = str(size) + " " + str(size) + "\n"
x = size*1000
for i in range(size):
x += 2
test += str(x) + " " + str(x+1) + "\n"
for i in range(size):
test += str(2) + " "
self.assertEqual(calculate(test)[0], "Y")
def test_Fug_class__basic_functions(self):
""" Fug class basic functions testing """
# Constructor test
d = Fug([[[1, 5], [7, 8], [9, 10], [12, 14]], [4, 5, 3, 8]])
self.assertEqual(d.list[0][0], 1)
self.assertEqual(d.alist[0], 4)
# Sort bridges
self.assertEqual(d.asrt[0], (3, 2))
# Sort Gaps
self.assertEqual(d.gaps[0], (2, 7, 0))
self.assertEqual(d.gsrt[0], (1, 3, 1))
iter = d.iterate()
next(iter)
self.assertEqual(d.gmin, [1, 2, 2])
self.assertEqual(d.heap, [(5, 2, 2), (7, 2, 0)])
if __name__ == "__main__":
# Avoiding recursion limitaions
sys.setrecursionlimit(100000)
if sys.argv[-1] == "-ut":
unittest.main(argv=[" "])
# Print the result string
sys.stdout.write(calculate())
| {
"input": [
"4 4\n1 4\n7 8\n9 10\n12 14\n4 5 3 8\n",
"2 2\n11 14\n17 18\n2 9\n",
"2 1\n1 1\n1000000000000000000 1000000000000000000\n999999999999999999\n"
],
"output": [
"Yes\n2 3 1 ",
"No",
"Yes\n1 "
]
} |
434 | 8 | You are given an array of positive integers a1, a2, ..., an Γ T of length n Γ T. We know that for any i > n it is true that ai = ai - n. Find the length of the longest non-decreasing sequence of the given array.
Input
The first line contains two space-separated integers: n, T (1 β€ n β€ 100, 1 β€ T β€ 107). The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 300).
Output
Print a single number β the length of a sought sequence.
Examples
Input
4 3
3 1 4 2
Output
5
Note
The array given in the sample looks like that: 3, 1, 4, 2, 3, 1, 4, 2, 3, 1, 4, 2. The elements in bold form the largest non-decreasing subsequence. | mul=lambda A,B,r:[[max([A[i][k]+B[k][j] for k in r if A[i][k] and B[k][j]],default=0) for j in r] for i in r]
def binpower(A,n,e):
r = range(n)
B = A #A^0 is invalid, thus start from A^1
e -= 1
while True:
if e &1: B = mul(B,A,r)
e =e>>1
if e==0: return B
A =mul(A,A,r)
def f(l,n,T):
# Part 1: cal M
h = max(l)+1
N = [[0]*h for _ in range(h)]
Q = [[0]*h for _ in range(h)]
M = [[0]*n for _ in range(n)]
for j in range(n):
# update Mij based on Quv,(j-1)
for i in range(n):
M[i][j]=Q[l[i]][l[j]]+1 if l[i]<=l[j] else 0
# update Nuv,(j) and Quv,(j)
v = l[j]
for u in range(1,v+1):
N[u][v] = Q[u][v]+1
for vv in range(v,h):
Q[u][vv] = max(Q[u][vv],N[u][v])
return max(max(binpower(M,n,T)))
n,T = list(map(int,input().split()))
l = list(map(int,input().split()))
print(f(l,n,T))
| {
"input": [
"4 3\n3 1 4 2\n"
],
"output": [
"5\n"
]
} |
435 | 8 | Kevin Sun wants to move his precious collection of n cowbells from Naperthrill to Exeter, where there is actually grass instead of corn. Before moving, he must pack his cowbells into k boxes of a fixed size. In order to keep his collection safe during transportation, he won't place more than two cowbells into a single box. Since Kevin wishes to minimize expenses, he is curious about the smallest size box he can use to pack his entire collection.
Kevin is a meticulous cowbell collector and knows that the size of his i-th (1 β€ i β€ n) cowbell is an integer si. In fact, he keeps his cowbells sorted by size, so si - 1 β€ si for any i > 1. Also an expert packer, Kevin can fit one or two cowbells into a box of size s if and only if the sum of their sizes does not exceed s. Given this information, help Kevin determine the smallest s for which it is possible to put all of his cowbells into k boxes of size s.
Input
The first line of the input contains two space-separated integers n and k (1 β€ n β€ 2Β·k β€ 100 000), denoting the number of cowbells and the number of boxes, respectively.
The next line contains n space-separated integers s1, s2, ..., sn (1 β€ s1 β€ s2 β€ ... β€ sn β€ 1 000 000), the sizes of Kevin's cowbells. It is guaranteed that the sizes si are given in non-decreasing order.
Output
Print a single integer, the smallest s for which it is possible for Kevin to put all of his cowbells into k boxes of size s.
Examples
Input
2 1
2 5
Output
7
Input
4 3
2 3 5 9
Output
9
Input
3 2
3 5 7
Output
8
Note
In the first sample, Kevin must pack his two cowbells into the same box.
In the second sample, Kevin can pack together the following sets of cowbells: {2, 3}, {5} and {9}.
In the third sample, the optimal solution is {3, 5} and {7}. | def main():
n, k = map(int, input().split())
l = list(map(int, input().split()))
for i, x in zip(range((n - k) * 2 - 1, n - k - 1, -1), l):
l[i] += x
print(max(l))
if __name__ == '__main__':
main()
| {
"input": [
"4 3\n2 3 5 9\n",
"2 1\n2 5\n",
"3 2\n3 5 7\n"
],
"output": [
"9\n",
"7\n",
"8\n"
]
} |
436 | 11 | Define the simple skewness of a collection of numbers to be the collection's mean minus its median. You are given a list of n (not necessarily distinct) integers. Find the non-empty subset (with repetition) with the maximum simple skewness.
The mean of a collection is the average of its elements. The median of a collection is its middle element when all of its elements are sorted, or the average of its two middle elements if it has even size.
Input
The first line of the input contains a single integer n (1 β€ n β€ 200 000) β the number of elements in the list.
The second line contains n integers xi (0 β€ xi β€ 1 000 000) β the ith element of the list.
Output
In the first line, print a single integer k β the size of the subset.
In the second line, print k integers β the elements of the subset in any order.
If there are multiple optimal subsets, print any.
Examples
Input
4
1 2 3 12
Output
3
1 2 12
Input
4
1 1 2 2
Output
3
1 1 2
Input
2
1 2
Output
2
1 2
Note
In the first case, the optimal subset is <image>, which has mean 5, median 2, and simple skewness of 5 - 2 = 3.
In the second case, the optimal subset is <image>. Note that repetition is allowed.
In the last case, any subset has the same median and mean, so all have simple skewness of 0. | from itertools import accumulate
from fractions import Fraction
n = int(input())
A = [int(x) for x in input().split()]
A.sort()
B = list(accumulate([0] + A))
def condition(i, z):
return (2*z - 1)*(A[i-z] + A[-z]) > 2*(B[i+1] - B[i-z+1] + B[-1] - B[-z])
def average(i, z):
return Fraction((B[i+1] - B[i-z] + B[-1] - B[-z-1]) , 2*z + 1)
maxans = 0
argmax = (0, 0)
for i in range(1, n-1):
x, y = 0, min(i, n-1-i)
while y - x > 1:
z = (x + y)//2
if condition(i, z):
x = z
else:
y = z
if condition(i, y): x = y
if maxans < average(i, x) - A[i]:
maxans = average(i, x) - A[i]
argmax = (i, x)
print(argmax[1]*2 + 1)
for i in range(argmax[0] - argmax[1], argmax[0] + 1):
print(A[i], end = ' ')
for i in range(-argmax[1], 0):
print(A[i], end = ' ')
| {
"input": [
"2\n1 2\n",
"4\n1 1 2 2\n",
"4\n1 2 3 12\n"
],
"output": [
"1\n 1 \n",
"3\n 1 1 2 \n",
"3\n 1 2 12 \n"
]
} |
437 | 7 | Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 β€ n β€ 100) β the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 β€ ai β€ n), where ai is equal to the element at the i-th position.
Output
Print a single integer β the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2. | def answer():
a =int(input())
b = input().split()
b = [int(x) for x in b]
up=max(b)
down=min(b)
print(max(len(b)-b.index(up)-1,len(b)-b.index(down)-1,b.index(up),b.index(down)))
answer() | {
"input": [
"6\n6 5 4 3 2 1\n",
"7\n1 6 5 3 4 7 2\n",
"5\n4 5 1 3 2\n"
],
"output": [
"5\n",
"6\n",
"3\n"
]
} |
438 | 7 | A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. Specifically, he forgot to complete his physics tasks. Next day the teacher got very angry at Vasya and decided to teach him a lesson. He gave the lazy student a seemingly easy task: You are given an idle body in space and the forces that affect it. The body can be considered as a material point with coordinates (0; 0; 0). Vasya had only to answer whether it is in equilibrium. "Piece of cake" β thought Vasya, we need only to check if the sum of all vectors is equal to 0. So, Vasya began to solve the problem. But later it turned out that there can be lots and lots of these forces, and Vasya can not cope without your help. Help him. Write a program that determines whether a body is idle or is moving by the given vectors of forces.
Input
The first line contains a positive integer n (1 β€ n β€ 100), then follow n lines containing three integers each: the xi coordinate, the yi coordinate and the zi coordinate of the force vector, applied to the body ( - 100 β€ xi, yi, zi β€ 100).
Output
Print the word "YES" if the body is in equilibrium, or the word "NO" if it is not.
Examples
Input
3
4 1 7
-2 4 -1
1 -5 -3
Output
NO
Input
3
3 -1 7
-5 2 -4
2 -1 -3
Output
YES | def vectorsum(a,b):
return [a[i]+b[i] for i in range(3)]
n = int(input())
V = [0,0,0]
for i in range(n):
V = vectorsum(V,[int(x) for x in input().split()])
print(['NO','YES'][V==[0,0,0]])
| {
"input": [
"3\n3 -1 7\n-5 2 -4\n2 -1 -3\n",
"3\n4 1 7\n-2 4 -1\n1 -5 -3\n"
],
"output": [
"YES\n",
"NO\n"
]
} |
439 | 7 | There exists an island called Arpaβs land, some beautiful girls live there, as ugly ones do.
Mehrdad wants to become minister of Arpaβs land. Arpa has prepared an exam. Exam has only one question, given n, print the last digit of 1378n.
<image>
Mehrdad has become quite confused and wants you to help him. Please help, although it's a naive cheat.
Input
The single line of input contains one integer n (0 β€ n β€ 109).
Output
Print single integer β the last digit of 1378n.
Examples
Input
1
Output
8
Input
2
Output
4
Note
In the first example, last digit of 13781 = 1378 is 8.
In the second example, last digit of 13782 = 1378Β·1378 = 1898884 is 4. | def main():
print(pow(8, int(input()), 10))
main()
| {
"input": [
"2\n",
"1\n"
],
"output": [
"4\n",
"8\n"
]
} |
440 | 11 | Vanya wants to minimize a tree. He can perform the following operation multiple times: choose a vertex v, and two disjoint (except for v) paths of equal length a0 = v, a1, ..., ak, and b0 = v, b1, ..., bk. Additionally, vertices a1, ..., ak, b1, ..., bk must not have any neighbours in the tree other than adjacent vertices of corresponding paths. After that, one of the paths may be merged into the other, that is, the vertices b1, ..., bk can be effectively erased:
<image>
Help Vanya determine if it possible to make the tree into a path via a sequence of described operations, and if the answer is positive, also determine the shortest length of such path.
Input
The first line of input contains the number of vertices n (2 β€ n β€ 2Β·105).
Next n - 1 lines describe edges of the tree. Each of these lines contains two space-separated integers u and v (1 β€ u, v β€ n, u β v) β indices of endpoints of the corresponding edge. It is guaranteed that the given graph is a tree.
Output
If it is impossible to obtain a path, print -1. Otherwise, print the minimum number of edges in a possible path.
Examples
Input
6
1 2
2 3
2 4
4 5
1 6
Output
3
Input
7
1 2
1 3
3 4
1 5
5 6
6 7
Output
-1
Note
In the first sample case, a path of three edges is obtained after merging paths 2 - 1 - 6 and 2 - 4 - 5.
It is impossible to perform any operation in the second sample case. For example, it is impossible to merge paths 1 - 3 - 4 and 1 - 5 - 6, since vertex 6 additionally has a neighbour 7 that is not present in the corresponding path. | import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
def LI(): return list(map(int, input().split()))
def II(): return int(input())
def LS(): return input().split()
def S(): return input()
def main():
n = II()
d = collections.defaultdict(set)
for _ in range(n-1):
a,b = LI()
d[a].add(b)
d[b].add(a)
memo = [-1] * (n+1)
def path(t,s):
ps = set()
dt = list(d[t])
for k in dt:
if memo[k] < 0:
continue
ps.add(memo[k])
if s == -1 and len(ps) == 2:
memo[t] = sum(ps) + 2
return memo[t]
if len(ps) > 1:
return -t
if len(ps) == 0:
memo[t] = 0
return 0
memo[t] = list(ps)[0] + 1
return memo[t]
def _path(tt,ss):
f = [False] * (n+1)
q = [(tt,ss)]
tq = []
qi = 0
while len(q) > qi:
t,s = q[qi]
for k in d[t]:
if k == s or memo[k] >= 0:
continue
q.append((k,t))
qi += 1
for t,s in q[::-1]:
r = path(t,s)
if r < 0:
return r
return memo[tt]
t = _path(1,-1)
if t < 0:
t = _path(-t,-1)
if t > 0:
while t%2 == 0:
t//=2
return t
return -1
print(main())
| {
"input": [
"6\n1 2\n2 3\n2 4\n4 5\n1 6\n",
"7\n1 2\n1 3\n3 4\n1 5\n5 6\n6 7\n"
],
"output": [
"3\n",
"-1\n"
]
} |
441 | 8 | Masha really loves algebra. On the last lesson, her strict teacher Dvastan gave she new exercise.
You are given geometric progression b defined by two integers b1 and q. Remind that a geometric progression is a sequence of integers b1, b2, b3, ..., where for each i > 1 the respective term satisfies the condition bi = bi - 1Β·q, where q is called the common ratio of the progression. Progressions in Uzhlyandia are unusual: both b1 and q can equal 0. Also, Dvastan gave Masha m "bad" integers a1, a2, ..., am, and an integer l.
Masha writes all progression terms one by one onto the board (including repetitive) while condition |bi| β€ l is satisfied (|x| means absolute value of x). There is an exception: if a term equals one of the "bad" integers, Masha skips it (doesn't write onto the board) and moves forward to the next term.
But the lesson is going to end soon, so Masha has to calculate how many integers will be written on the board. In order not to get into depression, Masha asked you for help: help her calculate how many numbers she will write, or print "inf" in case she needs to write infinitely many integers.
Input
The first line of input contains four integers b1, q, l, m (-109 β€ b1, q β€ 109, 1 β€ l β€ 109, 1 β€ m β€ 105) β the initial term and the common ratio of progression, absolute value of maximal number that can be written on the board and the number of "bad" integers, respectively.
The second line contains m distinct integers a1, a2, ..., am (-109 β€ ai β€ 109) β numbers that will never be written on the board.
Output
Print the only integer, meaning the number of progression terms that will be written on the board if it is finite, or "inf" (without quotes) otherwise.
Examples
Input
3 2 30 4
6 14 25 48
Output
3
Input
123 1 2143435 4
123 11 -5453 141245
Output
0
Input
123 1 2143435 4
54343 -13 6 124
Output
inf
Note
In the first sample case, Masha will write integers 3, 12, 24. Progression term 6 will be skipped because it is a "bad" integer. Terms bigger than 24 won't be written because they exceed l by absolute value.
In the second case, Masha won't write any number because all terms are equal 123 and this is a "bad" integer.
In the third case, Masha will write infinitely integers 123. | #!/usr/bin/env python3
from math import *
def ri():
return map(int, input().split())
b, q, l, m = ri()
a = list(ri())
ans = 0
if abs(b) <= l:
if not b in a:
ans+=1
else:
print(0)
exit()
i = 0
while True:
i += 1
b = b*q
if b in a:
pass
elif abs(b) <= l:
ans+=1
else:
print(ans)
break
if i > 10:
if b == b*q*q or b == b*q:
if b in a and b*q in a:
print(ans)
exit()
else:
print("inf")
exit() | {
"input": [
"123 1 2143435 4\n123 11 -5453 141245\n",
"3 2 30 4\n6 14 25 48\n",
"123 1 2143435 4\n54343 -13 6 124\n"
],
"output": [
"0\n",
"3\n",
"inf\n"
]
} |
442 | 10 | For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 β€ t β€ 10000) β amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 β€ a, b β€ 106).
Pretests contain all the tests with 0 < a < 10, 0 β€ b < 10.
Output
Print t lines β the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000 | def li():
return list(map(int, input().split(" ")))
for _ in range(int(input())):
a, b=li()
if b != 0 and a != 0:
s = (max(0, a-4*b) + a)/2
s*=min((a/4), b)
ans = 1/2 + s/(2*a*b)
print("{:.8f}".format(ans))
elif b == 0:
print(1)
else:
print(0.5) | {
"input": [
"2\n4 2\n1 2\n"
],
"output": [
"0.6250000000\n0.5312500000\n"
]
} |
443 | 8 | Some natural number was written on the board. Its sum of digits was not less than k. But you were distracted a bit, and someone changed this number to n, replacing some digits with others. It's known that the length of the number didn't change.
You have to find the minimum number of digits in which these two numbers can differ.
Input
The first line contains integer k (1 β€ k β€ 109).
The second line contains integer n (1 β€ n < 10100000).
There are no leading zeros in n. It's guaranteed that this situation is possible.
Output
Print the minimum number of digits in which the initial number and n can differ.
Examples
Input
3
11
Output
1
Input
3
99
Output
0
Note
In the first example, the initial number could be 12.
In the second example the sum of the digits of n is not less than k. The initial number could be equal to n. | def r():
return list(map(int, input().split()))
k = int(input())
s = sorted(map(int, input()))
ck, i = sum(s), 0
while ck < k:
ck += 9 - s[i]
i += 1
print(i) | {
"input": [
"3\n11\n",
"3\n99\n"
],
"output": [
"1\n",
"0\n"
]
} |
444 | 9 | Two best friends Serozha and Gena play a game.
Initially there is one pile consisting of n stones on the table. During one move one pile should be taken and divided into an arbitrary number of piles consisting of a1 > a2 > ... > ak > 0 stones. The piles should meet the condition a1 - a2 = a2 - a3 = ... = ak - 1 - ak = 1. Naturally, the number of piles k should be no less than two.
The friends play in turns. The player who cannot make a move loses. Serozha makes the first move. Who will win if both players play in the optimal way?
Input
The single line contains a single integer n (1 β€ n β€ 105).
Output
If Serozha wins, print k, which represents the minimal number of piles into which he can split the initial one during the first move in order to win the game.
If Gena wins, print "-1" (without the quotes).
Examples
Input
3
Output
2
Input
6
Output
-1
Input
100
Output
8 | import math
from collections import Counter
n = int(input())
g = [0 for i in range(n + 1)]
prefix_xor = g.copy()
def in_range(d, k):
if (2 * k - d * d + d) % (2 * d) != 0:
return -1
x = (2 * k - d * d + d) / (2 * d)
return int(x) if x > 0 else -1
def mex(arr):
counter = Counter()
for i in arr:
counter[i] += 1
for i in range(0, len(arr) + 1):
if counter[i] == 0:
return i
def find_move(arr):
for i in range(0, len(arr)):
if arr[i] == 0:
return i
return -1
if n < 3:
print(-1)
exit(0)
for i in range(3, n + 1):
for_range = range(2, int(math.sqrt(2 * i)) + 1)
filter_range = [l for l in for_range if in_range(l, i) > 0]
branches = [prefix_xor[in_range(d, i) + d - 1] ^ prefix_xor[in_range(d, i) - 1] for d in filter_range]
g[i] = mex(branches)
prefix_xor[i] = prefix_xor[i - 1] ^ g[i]
if i == n:
print(-1 if g[i] == 0 else filter_range[find_move(branches)])
| {
"input": [
"6\n",
"100\n",
"3\n"
],
"output": [
"-1\n",
"8\n",
"2\n"
]
} |
445 | 11 | We had a string s consisting of n lowercase Latin letters. We made k copies of this string, thus obtaining k identical strings s1, s2, ..., sk. After that, in each of these strings we swapped exactly two characters (the characters we swapped could be identical, but they had different indices in the string).
You are given k strings s1, s2, ..., sk, and you have to restore any string s so that it is possible to obtain these strings by performing aforementioned operations. Note that the total length of the strings you are given doesn't exceed 5000 (that is, kΒ·n β€ 5000).
Input
The first line contains two integers k and n (1 β€ k β€ 2500, 2 β€ n β€ 5000, k Β· n β€ 5000) β the number of strings we obtained, and the length of each of these strings.
Next k lines contain the strings s1, s2, ..., sk, each consisting of exactly n lowercase Latin letters.
Output
Print any suitable string s, or -1 if such string doesn't exist.
Examples
Input
3 4
abac
caab
acba
Output
acab
Input
3 4
kbbu
kbub
ubkb
Output
kbub
Input
5 4
abcd
dcba
acbd
dbca
zzzz
Output
-1
Note
In the first example s1 is obtained by swapping the second and the fourth character in acab, s2 is obtained by swapping the first and the second character, and to get s3, we swap the third and the fourth character.
In the second example s1 is obtained by swapping the third and the fourth character in kbub, s2 β by swapping the second and the fourth, and s3 β by swapping the first and the third.
In the third example it's impossible to obtain given strings by aforementioned operations. | import collections
def swapCharacters(strings, k, n):
"""
Time: O(n^2 * k)
Space: O(1)
"""
if k == 1:
s0 = list(strings[0])
s0[0], s0[1] = s0[1], s0[0]
return ''.join(s0)
# Initial check for validity
freq = collections.Counter(strings[0])
canSame = (max(freq.values()) >= 2) # could swap two of the same characters ==> same string
for s in strings:
if collections.Counter(s) != freq:
return -1
# Find diff indices between first two strings
max_dist = 0
max_dist_s = None
s0 = strings[0]
for s1 in strings[1:]:
dist = HammingDistance(s0, s1, n)
if dist > max_dist:
max_dist = dist
max_dist_s = s1
# Hamming distance <= 2*2 between input strings to be valid
if max_dist > 4:
return -1
diffs = [i for i in range(n) if s0[i] != s1[i]]
# Checks all possible strings which match first two -- Finding strings (O(N)), testing string (O(KN))
s0 = list(s0)
for i in diffs:
for j in range(n):
# try swapping
s0[i], s0[j] = s0[j], s0[i]
# see if matches second string now
#dist = sum([s0[i] != s1[i] for i in diffs])
dist = HammingDistance(s0, s1, n)
if dist == 2 or (dist == 0 and canSame):
cand = ''.join(s0)
if verifyAll(strings, k, n, cand, canSame):
return cand
# revert
s0[i], s0[j] = s0[j], s0[i]
# nothing works
return -1
def HammingDistance(s0, s1, n):
count = 0
for i in range(n):
if s0[i] != s1[i]:
count += 1
return count
def verifyAll(strings, k, n, cand, canSame):
for s in strings:
dist = HammingDistance(s, cand, n)
if (dist != 0 or not canSame) and dist != 2:
return False
return True
k, n = [int(x) for x in input().split()]
strings = set() # discard duplicates
for _ in range(k):
strings.add(input())
strings = list(strings)
k = len(strings)
res = swapCharacters(strings, k, n)
print(res) | {
"input": [
"5 4\nabcd\ndcba\nacbd\ndbca\nzzzz\n",
"3 4\nabac\ncaab\nacba\n",
"3 4\nkbbu\nkbub\nubkb\n"
],
"output": [
"-1\n",
"acab\n",
"kbub\n"
]
} |
446 | 7 | You received a notebook which is called Death Note. This notebook has infinite number of pages. A rule is written on the last page (huh) of this notebook. It says: "You have to write names in this notebook during n consecutive days. During the i-th day you have to write exactly a_i names.". You got scared (of course you got scared, who wouldn't get scared if he just receive a notebook which is named Death Note with a some strange rule written in it?).
Of course, you decided to follow this rule. When you calmed down, you came up with a strategy how you will write names in the notebook. You have calculated that each page of the notebook can contain exactly m names. You will start writing names from the first page. You will write names on the current page as long as the limit on the number of names on this page is not exceeded. When the current page is over, you turn the page. Note that you always turn the page when it ends, it doesn't matter if it is the last day or not. If after some day the current page still can hold at least one name, during the next day you will continue writing the names from the current page.
Now you are interested in the following question: how many times will you turn the page during each day? You are interested in the number of pages you will turn each day from 1 to n.
Input
The first line of the input contains two integers n, m (1 β€ n β€ 2 β
10^5, 1 β€ m β€ 10^9) β the number of days you will write names in the notebook and the number of names which can be written on each page of the notebook.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i means the number of names you will write in the notebook during the i-th day.
Output
Print exactly n integers t_1, t_2, ..., t_n, where t_i is the number of times you will turn the page during the i-th day.
Examples
Input
3 5
3 7 9
Output
0 2 1
Input
4 20
10 9 19 2
Output
0 0 1 1
Input
1 100
99
Output
0
Note
In the first example pages of the Death Note will look like this [1, 1, 1, 2, 2], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [3, 3, 3, 3]. Each number of the array describes during which day name on the corresponding position will be written. It is easy to see that you should turn the first and the second page during the second day and the third page during the third day. | def main():
n, m = map(int, input().split())
a_string = input()
a = map(int, a_string.split())
t = []
used = 0
for ai in a:
used += ai
t.append(used // m)
used %= m
print(*t)
main()
| {
"input": [
"1 100\n99\n",
"4 20\n10 9 19 2\n",
"3 5\n3 7 9\n"
],
"output": [
"0\n",
"0 0 1 1\n",
"0 2 1\n"
]
} |
447 | 7 | The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness".
The test consists of n questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question n. Question i contains ai answer variants, exactly one of them is correct.
A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the n questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves.
Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?
Input
The first line contains a positive integer n (1 β€ n β€ 100). It is the number of questions in the test. The second line contains space-separated n positive integers ai (1 β€ ai β€ 109), the number of answer variants to question i.
Output
Print a single number β the minimal number of clicks needed to pass the test it the worst-case scenario.
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1 1
Output
2
Input
2
2 2
Output
5
Input
1
10
Output
10
Note
Note to the second sample. In the worst-case scenario you will need five clicks:
* the first click selects the first variant to the first question, this answer turns out to be wrong.
* the second click selects the second variant to the first question, it proves correct and we move on to the second question;
* the third click selects the first variant to the second question, it is wrong and we go back to question 1;
* the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question;
* the fifth click selects the second variant to the second question, it proves correct, the test is finished. | n=int(input())
arr=[int(x) for x in input().split()]
ans=0
def func(i):
return (i+1)*(arr[i]-1)+1
for i in range(n):
ans+=func(i)
print(ans)
| {
"input": [
"2\n2 2\n",
"2\n1 1\n",
"1\n10\n"
],
"output": [
"5",
"2",
"10"
]
} |
448 | 8 | JATC's math teacher always gives the class some interesting math problems so that they don't get bored. Today the problem is as follows. Given an integer n, you can perform the following operations zero or more times:
* mul x: multiplies n by x (where x is an arbitrary positive integer).
* sqrt: replaces n with β{n} (to apply this operation, β{n} must be an integer).
You can perform these operations as many times as you like. What is the minimum value of n, that can be achieved and what is the minimum number of operations, to achieve that minimum value?
Apparently, no one in the class knows the answer to this problem, maybe you can help them?
Input
The only line of the input contains a single integer n (1 β€ n β€ 10^6) β the initial number.
Output
Print two integers: the minimum integer n that can be achieved using the described operations and the minimum number of operations required.
Examples
Input
20
Output
10 2
Input
5184
Output
6 4
Note
In the first example, you can apply the operation mul 5 to get 100 and then sqrt to get 10.
In the second example, you can first apply sqrt to get 72, then mul 18 to get 1296 and finally two more sqrt and you get 6.
Note, that even if the initial value of n is less or equal 10^6, it can still become greater than 10^6 after applying one or more operations. | def smol(n):
prod = 1
orig = n
d = 2
while d*d <= orig and n>1:
if n%d == 0:
prod *= d
while n % d == 0:
n //=d
d += 1
if n > 1:
prod *= n
return prod
num = int(input())
small = smol(num)
ans = 0
while small%num > 0:
small *= small
ans += 1
if small != num:
ans += 1
print(smol(num),ans)
| {
"input": [
"20\n",
"5184\n"
],
"output": [
"10 2\n",
"6 4\n"
]
} |
449 | 7 | The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of floors.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100) β the number of people on each floor.
Output
In a single line, print the answer to the problem β the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 β
2 + 8 β
1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor. | def solve():
_ = map(int, input())
m = list(map(int, input().split()))
answer = 0
for i in range(len(m)):
answer += i*4*m[i]
return answer
print(solve())
| {
"input": [
"2\n1 1\n",
"3\n0 2 1\n"
],
"output": [
"4\n",
"16\n"
]
} |
450 | 9 | Cowboy Vlad has a birthday today! There are n children who came to the celebration. In order to greet Vlad, the children decided to form a circle around him. Among the children who came, there are both tall and low, so if they stand in a circle arbitrarily, it may turn out, that there is a tall and low child standing next to each other, and it will be difficult for them to hold hands. Therefore, children want to stand in a circle so that the maximum difference between the growth of two neighboring children would be minimal possible.
Formally, let's number children from 1 to n in a circle order, that is, for every i child with number i will stand next to the child with number i+1, also the child with number 1 stands next to the child with number n. Then we will call the discomfort of the circle the maximum absolute difference of heights of the children, who stand next to each other.
Please help children to find out how they should reorder themselves, so that the resulting discomfort is smallest possible.
Input
The first line contains a single integer n (2 β€ n β€ 100) β the number of the children who came to the cowboy Vlad's birthday.
The second line contains integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) denoting heights of every child.
Output
Print exactly n integers β heights of the children in the order in which they should stand in a circle. You can start printing a circle with any child.
If there are multiple possible answers, print any of them.
Examples
Input
5
2 1 1 3 2
Output
1 2 3 2 1
Input
3
30 10 20
Output
10 20 30
Note
In the first example, the discomfort of the circle is equal to 1, since the corresponding absolute differences are 1, 1, 1 and 0. Note, that sequences [2, 3, 2, 1, 1] and [3, 2, 1, 1, 2] form the same circles and differ only by the selection of the starting point.
In the second example, the discomfort of the circle is equal to 20, since the absolute difference of 10 and 30 is equal to 20. | def main():
n = int(input())
height = list(map(int, input().split()))
height.sort()
odd = height[::2]
even = height[1::2]
even.reverse()
print(' '.join(map(str, odd + even)))
main() | {
"input": [
"3\n30 10 20\n",
"5\n2 1 1 3 2\n"
],
"output": [
"10 30 20 ",
"1 2 3 2 1 "
]
} |
451 | 11 | The Kingdom of Kremland is a tree (a connected undirected graph without cycles) consisting of n vertices. Each vertex i has its own value a_i. All vertices are connected in series by edges. Formally, for every 1 β€ i < n there is an edge between the vertices of i and i+1.
Denote the function f(l, r), which takes two integers l and r (l β€ r):
* We leave in the tree only vertices whose values ββrange from l to r.
* The value of the function will be the number of connected components in the new graph.
Your task is to calculate the following sum: $$$β_{l=1}^{n} β_{r=l}^{n} f(l, r) $$$
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the number of vertices in the tree.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ n) β the values of the vertices.
Output
Print one number β the answer to the problem.
Examples
Input
3
2 1 3
Output
7
Input
4
2 1 1 3
Output
11
Input
10
1 5 2 5 5 3 10 6 5 1
Output
104
Note
In the first example, the function values ββwill be as follows:
* f(1, 1)=1 (there is only a vertex with the number 2, which forms one component)
* f(1, 2)=1 (there are vertices 1 and 2 that form one component)
* f(1, 3)=1 (all vertices remain, one component is obtained)
* f(2, 2)=1 (only vertex number 1)
* f(2, 3)=2 (there are vertices 1 and 3 that form two components)
* f(3, 3)=1 (only vertex 3)
Totally out 7.
In the second example, the function values ββwill be as follows:
* f(1, 1)=1
* f(1, 2)=1
* f(1, 3)=1
* f(1, 4)=1
* f(2, 2)=1
* f(2, 3)=2
* f(2, 4)=2
* f(3, 3)=1
* f(3, 4)=1
* f(4, 4)=0 (there is no vertex left, so the number of components is 0)
Totally out 11. | N = int(input())
A = [int(a) for a in input().split()]
def calc(a0, b0):
a, b = min(a0, b0), max(a0, b0)
return b-1 + (a-1) * (b-a-1) + N-a + (b-a-1) * (N-b)
def calc0(a):
return N+(a-1)*(N-a)
s = calc0(A[0]) + calc0(A[-1])
for i in range(N-1):
s += calc(A[i], A[i+1])
print(s//2)
| {
"input": [
"3\n2 1 3\n",
"10\n1 5 2 5 5 3 10 6 5 1\n",
"4\n2 1 1 3\n"
],
"output": [
"7\n",
"104\n",
"11\n"
]
} |
452 | 10 | Nauuo is a girl who loves drawing circles.
One day she has drawn a circle and wanted to draw a tree on it.
The tree is a connected undirected graph consisting of n nodes and n-1 edges. The nodes are numbered from 1 to n.
Nauuo wants to draw a tree on the circle, the nodes of the tree should be in n distinct points on the circle, and the edges should be straight without crossing each other.
"Without crossing each other" means that every two edges have no common point or the only common point is an endpoint of both edges.
Nauuo wants to draw the tree using a permutation of n elements. A permutation of n elements is a sequence of integers p_1,p_2,β¦,p_n in which every integer from 1 to n appears exactly once.
After a permutation is chosen Nauuo draws the i-th node in the p_i-th point on the circle, then draws the edges connecting the nodes.
The tree is given, Nauuo wants to know how many permutations are there so that the tree drawn satisfies the rule (the edges are straight without crossing each other). She only wants to know the answer modulo 998244353, can you help her?
It is obvious that whether a permutation is valid or not does not depend on which n points on the circle are chosen.
Input
The first line contains a single integer n (2β€ nβ€ 2β
10^5) β the number of nodes in the tree.
Each of the next n-1 lines contains two integers u and v (1β€ u,vβ€ n), denoting there is an edge between u and v.
It is guaranteed that the given edges form a tree.
Output
The output contains a single integer β the number of permutations suitable to draw the given tree on a circle satisfying the rule, modulo 998244353.
Examples
Input
4
1 2
1 3
2 4
Output
16
Input
4
1 2
1 3
1 4
Output
24
Note
Example 1
All valid permutations and their spanning trees are as follows.
<image>
Here is an example of invalid permutation: the edges (1,3) and (2,4) are crossed.
<image>
Example 2
Every permutation leads to a valid tree, so the answer is 4! = 24. | import sys
def topological_sort_tree(E, p):
Q = [p]
L = []
visited = set([p])
while Q:
p = Q.pop()
L.append(p)
for vf in E[p]:
if vf not in visited:
visited.add(vf)
Q.append(vf)
return L
def getpar(Edge, p):
N = len(Edge)
par = [0]*N
par[p] -= 1
stack = [p]
visited = set([p])
while stack:
vn = stack.pop()
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
stack.append(vf)
return par
mod = 998244353
frac = [1]*364364
for i in range(2,364364):
frac[i] = i * frac[i-1]%mod
N = int(input())
Dim = [0]*N
Edge = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, sys.stdin.readline().split())
a -= 1
b -= 1
Dim[a] += 1
Dim[b] += 1
Edge[a].append(b)
Edge[b].append(a)
L = topological_sort_tree(Edge, 0)
P = getpar(Edge, 0)
dp = [1]*N
for l in L[::-1]:
dp[l] = dp[l]*frac[Dim[l]] % mod
dp[P[l]] = dp[P[l]]*dp[l] % mod
print((N*dp[0])%mod) | {
"input": [
"4\n1 2\n1 3\n1 4\n",
"4\n1 2\n1 3\n2 4\n"
],
"output": [
"24\n",
"16\n"
]
} |
453 | 7 | Tokitsukaze is one of the characters in the game "Kantai Collection". In this game, every character has a common attribute β health points, shortened to HP.
In general, different values of HP are grouped into 4 categories:
* Category A if HP is in the form of (4 n + 1), that is, when divided by 4, the remainder is 1;
* Category B if HP is in the form of (4 n + 3), that is, when divided by 4, the remainder is 3;
* Category C if HP is in the form of (4 n + 2), that is, when divided by 4, the remainder is 2;
* Category D if HP is in the form of 4 n, that is, when divided by 4, the remainder is 0.
The above-mentioned n can be any integer.
These 4 categories ordered from highest to lowest as A > B > C > D, which means category A is the highest and category D is the lowest.
While playing the game, players can increase the HP of the character. Now, Tokitsukaze wants you to increase her HP by at most 2 (that is, either by 0, 1 or 2). How much should she increase her HP so that it has the highest possible category?
Input
The only line contains a single integer x (30 β€ x β€ 100) β the value Tokitsukaze's HP currently.
Output
Print an integer a (0 β€ a β€ 2) and an uppercase letter b (b β { A, B, C, D }), representing that the best way is to increase her HP by a, and then the category becomes b.
Note that the output characters are case-sensitive.
Examples
Input
33
Output
0 A
Input
98
Output
1 B
Note
For the first example, the category of Tokitsukaze's HP is already A, so you don't need to enhance her ability.
For the second example:
* If you don't increase her HP, its value is still 98, which equals to (4 Γ 24 + 2), and its category is C.
* If you increase her HP by 1, its value becomes 99, which equals to (4 Γ 24 + 3), and its category becomes B.
* If you increase her HP by 2, its value becomes 100, which equals to (4 Γ 25), and its category becomes D.
Therefore, the best way is to increase her HP by 1 so that the category of her HP becomes B. | def f(x):
return 'DACB'[x % 4]
n = int(input())
x = min(range(n, n + 3), key=f)
print(x - n, f(x))
| {
"input": [
"33\n",
"98\n"
],
"output": [
"0 A\n",
"1 B\n"
]
} |
454 | 10 | Petya loves lucky numbers. Everybody knows that lucky numbers are positive integers whose decimal representation contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya has a number consisting of n digits without leading zeroes. He represented it as an array of digits without leading zeroes. Let's call it d. The numeration starts with 1, starting from the most significant digit. Petya wants to perform the following operation k times: find the minimum x (1 β€ x < n) such that dx = 4 and dx + 1 = 7, if x is odd, then to assign dx = dx + 1 = 4, otherwise to assign dx = dx + 1 = 7. Note that if no x was found, then the operation counts as completed and the array doesn't change at all.
You are given the initial number as an array of digits and the number k. Help Petya find the result of completing k operations.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 109) β the number of digits in the number and the number of completed operations. The second line contains n digits without spaces representing the array of digits d, starting with d1. It is guaranteed that the first digit of the number does not equal zero.
Output
In the single line print the result without spaces β the number after the k operations are fulfilled.
Examples
Input
7 4
4727447
Output
4427477
Input
4 2
4478
Output
4478
Note
In the first sample the number changes in the following sequence: 4727447 β 4427447 β 4427477 β 4427447 β 4427477.
In the second sample: 4478 β 4778 β 4478. | def solve(n, k, digits):
if k == 0:
return ''.join(digits)
for i in range(n):
r_i = i + 1
if digits[i] == "4" and i < (n - 1) and digits[i + 1] == "7":
if r_i % 2 == 1:
digits[i + 1] = "4"
else:
digits[i] = "7"
k = k - 1
if k == 0:
break
if digits[i] == "7" and i - 1 >= 0 and digits[i - 1] == "4":
k = k % 2
if k:
digits[i] = "4"
return ''.join(digits)
# print(i, k, ''.join(digits))
return ''.join(digits)
n, k = input().split()
d = input()
# print("====")
print(solve(int(n), int(k), [i for i in d])) | {
"input": [
"4 2\n4478\n",
"7 4\n4727447\n"
],
"output": [
"4478\n",
"4427477\n"
]
} |
455 | 9 | You are given a huge integer a consisting of n digits (n is between 1 and 3 β
10^5, inclusive). It may contain leading zeros.
You can swap two digits on adjacent (neighboring) positions if the swapping digits are of different parity (that is, they have different remainders when divided by 2).
For example, if a = 032867235 you can get the following integers in a single operation:
* 302867235 if you swap the first and the second digits;
* 023867235 if you swap the second and the third digits;
* 032876235 if you swap the fifth and the sixth digits;
* 032862735 if you swap the sixth and the seventh digits;
* 032867325 if you swap the seventh and the eighth digits.
Note, that you can't swap digits on positions 2 and 4 because the positions are not adjacent. Also, you can't swap digits on positions 3 and 4 because the digits have the same parity.
You can perform any number (possibly, zero) of such operations.
Find the minimum integer you can obtain.
Note that the resulting integer also may contain leading zeros.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the input.
The only line of each test case contains the integer a, its length n is between 1 and 3 β
10^5, inclusive.
It is guaranteed that the sum of all values n does not exceed 3 β
10^5.
Output
For each test case print line β the minimum integer you can obtain.
Example
Input
3
0709
1337
246432
Output
0079
1337
234642
Note
In the first test case, you can perform the following sequence of operations (the pair of swapped digits is highlighted): 0 \underline{70} 9 β 0079.
In the second test case, the initial integer is optimal.
In the third test case you can perform the following sequence of operations: 246 \underline{43} 2 β 24 \underline{63}42 β 2 \underline{43} 642 β 234642. | from collections import deque
def move(t):
od = deque()
ev = deque()
for x in t:
if int(x)%2:
od.append(x)
else:
ev.append(x)
ans = list()
while od and ev:
if od[0] < ev[0]:
ans.append(od.popleft())
else:
ans.append(ev.popleft())
ans += od
ans += ev
return "".join(ans)
q = int(input())
for _ in range(q):
print(move(input())) | {
"input": [
"3\n0709\n1337\n246432\n"
],
"output": [
"0079\n1337\n234642\n"
]
} |
456 | 7 | A new delivery of clothing has arrived today to the clothing store. This delivery consists of a ties, b scarves, c vests and d jackets.
The store does not sell single clothing items β instead, it sells suits of two types:
* a suit of the first type consists of one tie and one jacket;
* a suit of the second type consists of one scarf, one vest and one jacket.
Each suit of the first type costs e coins, and each suit of the second type costs f coins.
Calculate the maximum possible cost of a set of suits that can be composed from the delivered clothing items. Note that one item cannot be used in more than one suit (though some items may be left unused).
Input
The first line contains one integer a (1 β€ a β€ 100 000) β the number of ties.
The second line contains one integer b (1 β€ b β€ 100 000) β the number of scarves.
The third line contains one integer c (1 β€ c β€ 100 000) β the number of vests.
The fourth line contains one integer d (1 β€ d β€ 100 000) β the number of jackets.
The fifth line contains one integer e (1 β€ e β€ 1 000) β the cost of one suit of the first type.
The sixth line contains one integer f (1 β€ f β€ 1 000) β the cost of one suit of the second type.
Output
Print one integer β the maximum total cost of some set of suits that can be composed from the delivered items.
Examples
Input
4
5
6
3
1
2
Output
6
Input
12
11
13
20
4
6
Output
102
Input
17
14
5
21
15
17
Output
325
Note
It is possible to compose three suits of the second type in the first example, and their total cost will be 6. Since all jackets will be used, it's impossible to add anything to this set.
The best course of action in the second example is to compose nine suits of the first type and eleven suits of the second type. The total cost is 9 β
4 + 11 β
6 = 102. | def suit(n):
ret = (C[4] * n) + min(C[1], C[2], C[3]-n)*C[5]
return ret
C = []
for i in range(6):
C.append(int(input()))
ans = 0
for i in range(min(C[0], C[3])+1):
ans = max(ans, suit(i))
print(ans)
| {
"input": [
"4\n5\n6\n3\n1\n2\n",
"17\n14\n5\n21\n15\n17\n",
"12\n11\n13\n20\n4\n6\n"
],
"output": [
"6\n",
"325\n",
"102\n"
]
} |
457 | 8 | There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image> | def get():
n = int(input())
c = [(0, 0)]
for i in range(n):
c.append(tuple(map(int, input().split())))
c.sort()
way = ''
for i in range(n):
if c[i + 1][0] - c[i][0] < 0 or c[i + 1][1] - c[i][1] < 0: return 'NO'
else:way+=(c[i + 1][0] - c[i][0])*'R'+(c[i + 1][1] - c[i][1])*'U'
return 'YES\n'+way
for _ in range(int(input())):
print(get()) | {
"input": [
"3\n5\n1 3\n1 2\n3 3\n5 5\n4 3\n2\n1 0\n0 1\n1\n4 3\n"
],
"output": [
"YES\nRUUURRRRUU\nNO\nYES\nRRRRUUU\n"
]
} |
458 | 8 | After a long party Petya decided to return home, but he turned out to be at the opposite end of the town from his home. There are n crossroads in the line in the town, and there is either the bus or the tram station at each crossroad.
The crossroads are represented as a string s of length n, where s_i = A, if there is a bus station at i-th crossroad, and s_i = B, if there is a tram station at i-th crossroad. Currently Petya is at the first crossroad (which corresponds to s_1) and his goal is to get to the last crossroad (which corresponds to s_n).
If for two crossroads i and j for all crossroads i, i+1, β¦, j-1 there is a bus station, one can pay a roubles for the bus ticket, and go from i-th crossroad to the j-th crossroad by the bus (it is not necessary to have a bus station at the j-th crossroad). Formally, paying a roubles Petya can go from i to j if s_t = A for all i β€ t < j.
If for two crossroads i and j for all crossroads i, i+1, β¦, j-1 there is a tram station, one can pay b roubles for the tram ticket, and go from i-th crossroad to the j-th crossroad by the tram (it is not necessary to have a tram station at the j-th crossroad). Formally, paying b roubles Petya can go from i to j if s_t = B for all i β€ t < j.
For example, if s="AABBBAB", a=4 and b=3 then Petya needs:
<image>
* buy one bus ticket to get from 1 to 3,
* buy one tram ticket to get from 3 to 6,
* buy one bus ticket to get from 6 to 7.
Thus, in total he needs to spend 4+3+4=11 roubles. Please note that the type of the stop at the last crossroad (i.e. the character s_n) does not affect the final expense.
Now Petya is at the first crossroad, and he wants to get to the n-th crossroad. After the party he has left with p roubles. He's decided to go to some station on foot, and then go to home using only public transport.
Help him to choose the closest crossroad i to go on foot the first, so he has enough money to get from the i-th crossroad to the n-th, using only tram and bus tickets.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 β€ t β€ 10^4).
The first line of each test case consists of three integers a, b, p (1 β€ a, b, p β€ 10^5) β the cost of bus ticket, the cost of tram ticket and the amount of money Petya has.
The second line of each test case consists of one string s, where s_i = A, if there is a bus station at i-th crossroad, and s_i = B, if there is a tram station at i-th crossroad (2 β€ |s| β€ 10^5).
It is guaranteed, that the sum of the length of strings s by all test cases in one test doesn't exceed 10^5.
Output
For each test case print one number β the minimal index i of a crossroad Petya should go on foot. The rest of the path (i.e. from i to n he should use public transport).
Example
Input
5
2 2 1
BB
1 1 1
AB
3 2 8
AABBBBAABB
5 3 4
BBBBB
2 1 1
ABABAB
Output
2
1
3
1
6 | def solve(s, a, b, p):
index = len(s)
totalSum = 0
while totalSum <= p and index > 0:
index -= 1
if index == len(s) - 1 or s[index - 1] != s[index]:
totalSum += a if s[index - 1] == "A" else b
return index + 1
for case in range(int(input())):
a,b,p = map(int, input().split())
s = input()
print(solve(s,a,b,p)) | {
"input": [
"5\n2 2 1\nBB\n1 1 1\nAB\n3 2 8\nAABBBBAABB\n5 3 4\nBBBBB\n2 1 1\nABABAB\n"
],
"output": [
"2\n1\n3\n1\n6\n"
]
} |
459 | 11 | This is the easy version of the problem. The only difference between easy and hard versions is the constraint of m. You can make hacks only if both versions are solved.
Chiori loves dolls and now she is going to decorate her bedroom!
<image>
As a doll collector, Chiori has got n dolls. The i-th doll has a non-negative integer value a_i (a_i < 2^m, m is given). Chiori wants to pick some (maybe zero) dolls for the decoration, so there are 2^n different picking ways.
Let x be the bitwise-xor-sum of values of dolls Chiori picks (in case Chiori picks no dolls x = 0). The value of this picking way is equal to the number of 1-bits in the binary representation of x. More formally, it is also equal to the number of indices 0 β€ i < m, such that \leftβ (x)/(2^i) \rightβ is odd.
Tell her the number of picking ways with value i for each integer i from 0 to m. Due to the answers can be very huge, print them by modulo 998 244 353.
Input
The first line contains two integers n and m (1 β€ n β€ 2 β
10^5, 0 β€ m β€ 35) β the number of dolls and the maximum value of the picking way.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i < 2^m) β the values of dolls.
Output
Print m+1 integers p_0, p_1, β¦, p_m β p_i is equal to the number of picking ways with value i by modulo 998 244 353.
Examples
Input
4 4
3 5 8 14
Output
2 2 6 6 0
Input
6 7
11 45 14 9 19 81
Output
1 2 11 20 15 10 5 0 | MOD = 998244353
BOUND = 19
n, m = map(int, input().split())
l = list(map(int,input().split()))
basis = []
for p in range(m-1,-1,-1):
p2 = pow(2,p)
nex = -1
for i in range(n):
if l[i] >= p2:
nex = l[i]
break
if nex != -1:
basis.append(nex)
for i in range(n):
if l[i] >= p2:
l[i] ^= nex
extra = n - len(basis)
def add(a, b):
out = [0] * (max(len(a), len(b)))
for i in range(len(a)):
out[i] = a[i]
for i in range(len(b)):
out[i] += b[i]
out[i] %= MOD
return out
def addSh(a, b):
out = [0] * (max(len(a) + 1, len(b)))
for i in range(len(a)):
out[i + 1] = a[i]
for i in range(len(b)):
out[i] += b[i]
out[i] %= MOD
return out
i = 0
curr = dict()
curr[0] = [1]
for p in range(m-1,-1,-1):
p2 = pow(2,p)
if i < len(basis) and basis[i] >= p2:
currN = dict(curr)
for v in curr:
if v ^ basis[i] not in currN:
currN[v ^ basis[i]] = [0]
currN[v ^ basis[i]] = add(curr[v], currN[v ^ basis[i]])
curr = currN
i += 1
currN = dict(curr)
for v in curr:
if v >= p2:
if v ^ p2 not in currN:
currN[v ^ p2] = [0]
currN[v ^ p2] = addSh(curr[v], currN[v ^ p2])
del currN[v]
curr = currN
out = curr[0]
while len(out) < m + 1:
out.append(0)
for i in range(m + 1):
out[i] *= pow(2, extra, MOD)
out[i] %= MOD
print(' '.join(map(str,out)))
| {
"input": [
"6 7\n11 45 14 9 19 81\n",
"4 4\n3 5 8 14\n"
],
"output": [
"1 2 11 20 15 10 5 0 \n",
"2 2 6 6 0 \n"
]
} |
460 | 8 | You might have remembered Theatre square from the [problem 1A](https://codeforces.com/problemset/problem/1/A). Now it's finally getting repaved.
The square still has a rectangular shape of n Γ m meters. However, the picture is about to get more complicated now. Let a_{i,j} be the j-th square in the i-th row of the pavement.
You are given the picture of the squares:
* if a_{i,j} = "*", then the j-th square in the i-th row should be black;
* if a_{i,j} = ".", then the j-th square in the i-th row should be white.
The black squares are paved already. You have to pave the white squares. There are two options for pavement tiles:
* 1 Γ 1 tiles β each tile costs x burles and covers exactly 1 square;
* 1 Γ 2 tiles β each tile costs y burles and covers exactly 2 adjacent squares of the same row. Note that you are not allowed to rotate these tiles or cut them into 1 Γ 1 tiles.
You should cover all the white squares, no two tiles should overlap and no black squares should be covered by tiles.
What is the smallest total price of the tiles needed to cover all the white squares?
Input
The first line contains a single integer t (1 β€ t β€ 500) β the number of testcases. Then the description of t testcases follow.
The first line of each testcase contains four integers n, m, x and y (1 β€ n β€ 100; 1 β€ m β€ 1000; 1 β€ x, y β€ 1000) β the size of the Theatre square, the price of the 1 Γ 1 tile and the price of the 1 Γ 2 tile.
Each of the next n lines contains m characters. The j-th character in the i-th line is a_{i,j}. If a_{i,j} = "*", then the j-th square in the i-th row should be black, and if a_{i,j} = ".", then the j-th square in the i-th row should be white.
It's guaranteed that the sum of n Γ m over all testcases doesn't exceed 10^5.
Output
For each testcase print a single integer β the smallest total price of the tiles needed to cover all the white squares in burles.
Example
Input
4
1 1 10 1
.
1 2 10 1
..
2 1 10 1
.
.
3 3 3 7
..*
*..
.*.
Output
10
1
20
18
Note
In the first testcase you are required to use a single 1 Γ 1 tile, even though 1 Γ 2 tile is cheaper. So the total price is 10 burles.
In the second testcase you can either use two 1 Γ 1 tiles and spend 20 burles or use a single 1 Γ 2 tile and spend 1 burle. The second option is cheaper, thus the answer is 1.
The third testcase shows that you can't rotate 1 Γ 2 tiles. You still have to use two 1 Γ 1 tiles for the total price of 20.
In the fourth testcase the cheapest way is to use 1 Γ 1 tiles everywhere. The total cost is 6 β
3 = 18. | import sys
def I():
return sys.stdin.readline().rstrip()
for tc in range(1, 1+int(I())):
R, C, x, y = map(int, I().split())
y = min(y, 2 * x)
ans = 0
for row in range(R):
for s in I().split('*'):
ans += len(s) // 2 * y
ans += len(s) % 2 * x
print(ans)
| {
"input": [
"4\n1 1 10 1\n.\n1 2 10 1\n..\n2 1 10 1\n.\n.\n3 3 3 7\n..*\n*..\n.*.\n"
],
"output": [
"10\n1\n20\n18\n"
]
} |
461 | 10 | There are many freight trains departing from Kirnes planet every day. One day on that planet consists of h hours, and each hour consists of m minutes, where m is an even number. Currently, there are n freight trains, and they depart every day at the same time: i-th train departs at h_i hours and m_i minutes.
The government decided to add passenger trams as well: they plan to add a regular tram service with half-hour intervals. It means that the first tram of the day must depart at 0 hours and t minutes, where 0 β€ t < {m \over 2}, the second tram departs m \over 2 minutes after the first one and so on. This schedule allows exactly two passenger trams per hour, which is a great improvement.
To allow passengers to board the tram safely, the tram must arrive k minutes before. During the time when passengers are boarding the tram, no freight train can depart from the planet. However, freight trains are allowed to depart at the very moment when the boarding starts, as well as at the moment when the passenger tram departs. Note that, if the first passenger tram departs at 0 hours and t minutes, where t < k, then the freight trains can not depart during the last k - t minutes of the day.
<image> A schematic picture of the correct way to run passenger trams. Here h=2 (therefore, the number of passenger trams is 2h=4), the number of freight trains is n=6. The passenger trams are marked in red (note that the spaces between them are the same). The freight trains are marked in blue. Time segments of length k before each passenger tram are highlighted in red. Note that there are no freight trains inside these segments.
Unfortunately, it might not be possible to satisfy the requirements of the government without canceling some of the freight trains. Please help the government find the optimal value of t to minimize the number of canceled freight trains in case all passenger trams depart according to schedule.
Input
The first line of input contains four integers n, h, m, k (1 β€ n β€ 100 000, 1 β€ h β€ 10^9, 2 β€ m β€ 10^9, m is even, 1 β€ k β€ {m \over 2}) β the number of freight trains per day, the number of hours and minutes on the planet, and the boarding time for each passenger tram.
n lines follow, each contains two integers h_i and m_i (0 β€ h_i < h, 0 β€ m_i < m) β the time when i-th freight train departs. It is guaranteed that no freight trains depart at the same time.
Output
The first line of output should contain two integers: the minimum number of trains that need to be canceled, and the optimal starting time t. Second line of output should contain freight trains that need to be canceled.
Examples
Input
2 24 60 15
16 0
17 15
Output
0 0
Input
2 24 60 16
16 0
17 15
Output
1 0
2
Note
In the first test case of the example the first tram can depart at 0 hours and 0 minutes. Then the freight train at 16 hours and 0 minutes can depart at the same time as the passenger tram, and the freight train at 17 hours and 15 minutes can depart at the same time as the boarding starts for the upcoming passenger tram.
In the second test case of the example it is not possible to design the passenger tram schedule without cancelling any of the freight trains: if t β [1, 15], then the freight train at 16 hours and 0 minutes is not able to depart (since boarding time is 16 minutes). If t = 0 or t β [16, 29], then the freight train departing at 17 hours 15 minutes is not able to depart. However, if the second freight train is canceled, one can choose t = 0. Another possible option is to cancel the first train and choose t = 13. | import sys
import re
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
def solve():
n, h, m, k = mints()
m //= 2
a = [0]*n
e = [None]*(2*n+2)
c = 0
for i in range(n):
hh, mm = mints()
x = mm % m
a[i] = mm
e[2*i] = ((x+k)%m, -1, i)
e[2*i+1] = ((x+1)%m, 1, i)
if (x+1)%m > (x+k)%m:
c += 1
e[2*n] = (0,0,0)
e[2*n+1] = (m-1,0,0)
#print(e)
e.sort()
p = -1
r = (int(1e9),0)
#print(e)
for x, t, id in e:
#print(x,t,id,c)
if p != x and p != -1:
r = min(r, (c, p))
p = x
c += t
r = min(r, (c, p))
print(*r)
p = r[1]
for i in range(n):
mm = a[i]
x = (mm-p) % m
if (x+1)%m > (x+k)%m and (x+k)%m != 0 \
or (x+1)%m < (x+k)%m and (x+1)%m == 0:
print(i+1,end=' ')
#for i in range(mint()):
solve()
| {
"input": [
"2 24 60 16\n16 0\n17 15\n",
"2 24 60 15\n16 0\n17 15\n"
],
"output": [
"1 0\n2 ",
"0 0\n"
]
} |
462 | 8 | Having bought his own apartment, Boris decided to paper the walls in every room. Boris's flat has n rooms, each of which has the form of a rectangular parallelepiped. For every room we known its length, width and height of the walls in meters (different rooms can have different dimensions, including height).
Boris chose m types of wallpaper to paper the walls of the rooms with (but it is not necessary to use all the types). Each type of wallpaper is sold in rolls of a fixed length and width (the length, naturally, shows how long the unfolded roll will be). In addition, for each type we know the price of one roll of this type.
The wallpaper of each type contains strips running along the length of the roll. When gluing the strips must be located strictly vertically (so the roll cannot be rotated, even if the length is less than the width). Besides, a roll can be cut in an arbitrary manner, but the joints of glued pieces should also be vertical. In addition, each room should be papered by only one type of wallpaper. And pieces of the same roll cannot be used to paper different rooms. That is, for each room the rolls are purchased separately. Also, some rolls can be used not completely.
After buying an apartment Boris is short of cash, so he wants to spend the minimum money on wallpaper. Help him.
Input
The first line contains a positive integer n (1 β€ n β€ 500) β the number of rooms in Boris's apartment.
Each of the next n lines contains three space-separated positive integers β the length, width and height of the walls in a given room in meters, respectively.
The next line contains a positive integer m (1 β€ m β€ 500) β the number of available wallpaper types.
Each of the following m lines contains three space-separated positive integers β the length and width in meters of a given wallpaper and the price of one roll, respectively.
All numbers in the input data do not exceed 500. It is guaranteed that each room can be papered using these types of wallpaper.
Output
Print a single number β the minimum total cost of the rolls.
Examples
Input
1
5 5 3
3
10 1 100
15 2 320
3 19 500
Output
640
Note
Note to the sample:
The total length of the walls (the perimeter) of the room is 20 m.
One roll of the first type can be cut into pieces to get three vertical 1 meter wide strips, ergo you need 7 rolls of this type, the price equals 700.
A roll of the second type can be cut into pieces to get five 2 meter wide strips, we need 2 rolls, the price is 640.
One roll of the third type can immediately paper 19 meters out of 20, but we cannot use other types and we have to buy a second roll, the price is 1000. | n = int(input())
rooms = []
for _ in range(n):
rooms.append(list(map(int, input().split())))
m = int(input())
wallpapers = []
for _ in range(m):
wallpapers.append(list(map(int, input().split())))
def room_cost(room, wallpapers):
min_cost = 10**18
parimeter = 2 * (room[0] + room[1])
if room[2] == 0:
return 0
for wallpaper in wallpapers:
if wallpaper[1] != 0:
stripes_needed = (parimeter + wallpaper[1] - 1) // wallpaper[1]
stripes_from_one_roll = wallpaper[0] // room[2]
if stripes_from_one_roll == 0:
continue
amount_of_rolls = (stripes_needed + stripes_from_one_roll - 1) // stripes_from_one_roll
min_cost = min([min_cost, amount_of_rolls * wallpaper[2]])
return min_cost
print(sum([room_cost(room, wallpapers) for room in rooms]))
| {
"input": [
"1\n5 5 3\n3\n10 1 100\n15 2 320\n3 19 500\n"
],
"output": [
"640\n"
]
} |
463 | 12 | A famous gang of pirates, Sea Dogs, has come back to their hideout from one of their extravagant plunders. They want to split their treasure fairly amongst themselves, that is why You, their trusted financial advisor, devised a game to help them:
All of them take a sit at their round table, some of them with the golden coins they have just stolen. At each iteration of the game if one of them has equal or more than 2 coins, he is eligible to the splitting and he gives one coin to each pirate sitting next to him. If there are more candidates (pirates with equal or more than 2 coins) then You are the one that chooses which one of them will do the splitting in that iteration. The game ends when there are no more candidates eligible to do the splitting.
Pirates can call it a day, only when the game ends. Since they are beings with a finite amount of time at their disposal, they would prefer if the game that they are playing can end after finite iterations, and if so, they call it a good game. On the other hand, if no matter how You do the splitting, the game cannot end in finite iterations, they call it a bad game. Can You help them figure out before they start playing if the game will be good or bad?
Input
The first line of input contains two integer numbers n and k (1 β€ n β€ 10^{9}, 0 β€ k β€ 2β
10^5), where n denotes total number of pirates and k is the number of pirates that have any coins.
The next k lines of input contain integers a_i and b_i (1 β€ a_i β€ n, 1 β€ b_i β€ 10^{9}), where a_i denotes the index of the pirate sitting at the round table (n and 1 are neighbours) and b_i the total number of coins that pirate a_i has at the start of the game.
Output
Print 1 if the game is a good game: There is a way to do the splitting so the game ends after finite number of iterations.
Print -1 if the game is a bad game: No matter how You do the splitting the game does not end in finite number of iterations.
Examples
Input
4 2
1 2
2 2
Output
1
Input
6 2
2 3
4 1
Output
1
Input
3 2
1 1
2 2
Output
-1
Note
In the third example the game has no end, because You always only have only one candidate, after whose splitting you end up in the same position as the starting one. | import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def main():
n, k = [int(x) for x in input().split()]
p, s = 0, 0
for _ in range(k):
a, b = [int(x) for x in input().split()]
s += b
p += a * b
p %= n
print(['-1', '1'][s < n or (s == n and p == (n * (n + 1) // 2) % n)])
main() | {
"input": [
"4 2\n1 2\n2 2\n",
"3 2\n1 1\n2 2\n",
"6 2\n2 3\n4 1\n"
],
"output": [
"1",
"-1",
"1"
]
} |
464 | 7 | You are given two integers n and k. You are asked to choose maximum number of distinct integers from 1 to n so that there is no subset of chosen numbers with sum equal to k.
A subset of a set is a set that can be obtained from initial one by removing some (possibly all or none) elements of it.
Input
The first line contains the number of test cases T (1 β€ T β€ 100).
Each of the next T lines contains two integers n and k (1 β€ k β€ n β€ 1000) β the description of test cases.
Output
For each test case output two lines. In the first line output a single integer m β the number of chosen integers.
In the second line output m distinct integers from 1 to n β the chosen numbers.
If there are multiple answers, print any. You can print the numbers in any order.
Example
Input
3
3 2
5 3
1 1
Output
2
3 1
3
4 5 2
0 | def solve1():
n, k = map(int,input().split())
a = []
for i in range(k+1,n+1):
a.append(i)
t = (k+1)//2
for i in range(t,k):
a.append(i)
print(len(a))
print(*a)
for testis in range(int(input())):
solve1() | {
"input": [
"3\n3 2\n5 3\n1 1\n"
],
"output": [
"\n2\n3 1 \n3\n4 5 2 \n0\n\n"
]
} |
465 | 7 |
Input
The input contains two integers a1, a2 (0 β€ ai β€ 109), separated by a single space.
Output
Output a single integer.
Examples
Input
3 14
Output
44
Input
27 12
Output
48
Input
100 200
Output
102 | #!/usr/bin/python3
def readln(): return tuple(map(int, input().split()))
a, b = readln()
print(a + int(''.join(reversed(list(str(b))))))
| {
"input": [
"27 12\n",
"3 14\n",
"100 200\n"
],
"output": [
"48\n",
"44\n",
"102\n"
]
} |
466 | 10 | Berland starts to seize the initiative on the war with Flatland. To drive the enemy from their native land, the berlanders need to know exactly how many more flatland soldiers are left in the enemy's reserve. Fortunately, the scouts captured an enemy in the morning, who had a secret encrypted message with the information the berlanders needed so much.
The captured enemy had an array of positive integers. Berland intelligence have long been aware of the flatland code: to convey the message, which contained a number m, the enemies use an array of integers a. The number of its subarrays, in which there are at least k equal numbers, equals m. The number k has long been known in the Berland army so General Touristov has once again asked Corporal Vasya to perform a simple task: to decipher the flatlanders' message.
Help Vasya, given an array of integers a and number k, find the number of subarrays of the array of numbers a, which has at least k equal numbers.
Subarray a[i... j] (1 β€ i β€ j β€ n) of array a = (a1, a2, ..., an) is an array, made from its consecutive elements, starting from the i-th one and ending with the j-th one: a[i... j] = (ai, ai + 1, ..., aj).
Input
The first line contains two space-separated integers n, k (1 β€ k β€ n β€ 4Β·105), showing how many numbers an array has and how many equal numbers the subarrays are required to have, correspondingly.
The second line contains n space-separated integers ai (1 β€ ai β€ 109) β elements of the array.
Output
Print the single number β the number of such subarrays of array a, that they have at least k equal integers.
Please do not use the %lld specifier to read or write 64-bit integers in Π‘++. In is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
4 2
1 2 1 2
Output
3
Input
5 3
1 2 1 1 3
Output
2
Input
3 1
1 1 1
Output
6
Note
In the first sample are three subarrays, containing at least two equal numbers: (1,2,1), (2,1,2) and (1,2,1,2).
In the second sample are two subarrays, containing three equal numbers: (1,2,1,1,3) and (1,2,1,1).
In the third sample any subarray contains at least one 1 number. Overall they are 6: (1), (1), (1), (1,1), (1,1) and (1,1,1). | def answer():
ans,count,j=0,0,0
d=dict()
for i in range(n):
while(j==0 or d[a[j-1]] < k):
if(j==n):
j+=1
break
try:d[a[j]]+=1
except:d[a[j]]=1
count += 1
m=n-count+1
j+=1
if(j > n):break
ans+=m
d[a[i]] -= 1
return ans
n,k=map(int,input().split())
a=list(map(int,input().split()))
print(answer())
| {
"input": [
"5 3\n1 2 1 1 3\n",
"4 2\n1 2 1 2\n",
"3 1\n1 1 1\n"
],
"output": [
" 2\n",
" 3\n",
" 6\n"
]
} |
467 | 8 | Vasya has found a piece of paper with a coordinate system written on it. There are n distinct squares drawn in this coordinate system. Let's number the squares with integers from 1 to n. It turned out that points with coordinates (0, 0) and (ai, ai) are the opposite corners of the i-th square.
Vasya wants to find such integer point (with integer coordinates) of the plane, that belongs to exactly k drawn squares. We'll say that a point belongs to a square, if the point is located either inside the square, or on its boundary.
Help Vasya find a point that would meet the described limits.
Input
The first line contains two space-separated integers n, k (1 β€ n, k β€ 50). The second line contains space-separated integers a1, a2, ..., an (1 β€ ai β€ 109).
It is guaranteed that all given squares are distinct.
Output
In a single line print two space-separated integers x and y (0 β€ x, y β€ 109) β the coordinates of the point that belongs to exactly k squares. If there are multiple answers, you are allowed to print any of them.
If there is no answer, print "-1" (without the quotes).
Examples
Input
4 3
5 1 3 4
Output
2 1
Input
3 1
2 4 1
Output
4 0
Input
4 50
5 1 10 2
Output
-1 | #!/usr/bin/python
def next_split():
return input().split()
n, k = map(int, next_split())
data = list(map(int, next_split()))
if k > n:
print(-1)
exit(0)
data.sort(reverse = True)
print(data[k - 1], 0)
| {
"input": [
"3 1\n2 4 1\n",
"4 3\n5 1 3 4\n",
"4 50\n5 1 10 2\n"
],
"output": [
"4 4\n",
"3 3\n",
"-1\n"
]
} |
468 | 8 | Vova, the Ultimate Thule new shaman, wants to build a pipeline. As there are exactly n houses in Ultimate Thule, Vova wants the city to have exactly n pipes, each such pipe should be connected to the water supply. A pipe can be connected to the water supply if there's water flowing out of it. Initially Vova has only one pipe with flowing water. Besides, Vova has several splitters.
A splitter is a construction that consists of one input (it can be connected to a water pipe) and x output pipes. When a splitter is connected to a water pipe, water flows from each output pipe. You can assume that the output pipes are ordinary pipes. For example, you can connect water supply to such pipe if there's water flowing out from it. At most one splitter can be connected to any water pipe.
<image> The figure shows a 4-output splitter
Vova has one splitter of each kind: with 2, 3, 4, ..., k outputs. Help Vova use the minimum number of splitters to build the required pipeline or otherwise state that it's impossible.
Vova needs the pipeline to have exactly n pipes with flowing out water. Note that some of those pipes can be the output pipes of the splitters.
Input
The first line contains two space-separated integers n and k (1 β€ n β€ 1018, 2 β€ k β€ 109).
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single integer β the minimum number of splitters needed to build the pipeline. If it is impossible to build a pipeline with the given splitters, print -1.
Examples
Input
4 3
Output
2
Input
5 5
Output
1
Input
8 4
Output
-1 | N, K = map(int, input().split())
def in_bounds(k):
return N <= K*(K+1)//2 - (K-k)*(K-k+1)//2 - k + 1
l = 0
r = K
while l <= r:
c = (l + r) // 2
if in_bounds(c):
r = c - 1
else:
l = c + 1
if in_bounds(K):
print(l)
else:
print(-1)
| {
"input": [
"4 3\n",
"8 4\n",
"5 5\n"
],
"output": [
"2\n",
"-1\n",
"1\n"
]
} |
469 | 8 | SmallR is an archer. SmallR is taking a match of archer with Zanoes. They try to shoot in the target in turns, and SmallR shoots first. The probability of shooting the target each time is <image> for SmallR while <image> for Zanoes. The one who shoots in the target first should be the winner.
Output the probability that SmallR will win the match.
Input
A single line contains four integers <image>.
Output
Print a single real number, the probability that SmallR will win the match.
The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
1 2 1 2
Output
0.666666666667 | ##B
def main():
a,b,c,d=map(int,input().split())
PA=a/b
PB=c/d
qA=1-PA
qB=1-PB
print((PA/(1-qA*qB)))
main()
| {
"input": [
"1 2 1 2\n"
],
"output": [
"0.666666667\n"
]
} |
470 | 9 | Now it's time of Olympiads. Vanya and Egor decided to make his own team to take part in a programming Olympiad. They've been best friends ever since primary school and hopefully, that can somehow help them in teamwork.
For each team Olympiad, Vanya takes his play cards with numbers. He takes only the cards containing numbers 1 and 0. The boys are very superstitious. They think that they can do well at the Olympiad if they begin with laying all the cards in a row so that:
* there wouldn't be a pair of any side-adjacent cards with zeroes in a row;
* there wouldn't be a group of three consecutive cards containing numbers one.
Today Vanya brought n cards with zeroes and m cards with numbers one. The number of cards was so much that the friends do not know how to put all those cards in the described way. Help them find the required arrangement of the cards or else tell the guys that it is impossible to arrange cards in such a way.
Input
The first line contains two integers: n (1 β€ n β€ 106) β the number of cards containing number 0; m (1 β€ m β€ 106) β the number of cards containing number 1.
Output
In a single line print the required sequence of zeroes and ones without any spaces. If such sequence is impossible to obtain, print -1.
Examples
Input
1 2
Output
101
Input
4 8
Output
110110110101
Input
4 10
Output
11011011011011
Input
1 5
Output
-1 | def main():
n, m = map(int, input().split())
c = [0] * (n + 1)
for i in range(1, m + 1):
c[i % (n + 1)] += 1
if (len(c) > 2 and min(c[1:-1]) == 0) or max(c) > 2:
print(-1)
else:
print('0'.join('1' * x for x in c))
if __name__ == '__main__':
main()
| {
"input": [
"4 8\n",
"1 5\n",
"1 2\n",
"4 10\n"
],
"output": [
"110110110110\n",
"-1\n",
"110\n",
"11011011011011\n"
]
} |
471 | 10 | Iahub and Sorin are the best competitive programmers in their town. However, they can't both qualify to an important contest. The selection will be made with the help of a single problem. Blatnatalag, a friend of Iahub, managed to get hold of the problem before the contest. Because he wants to make sure Iahub will be the one qualified, he tells Iahub the following task.
You're given an (1-based) array a with n elements. Let's define function f(i, j) (1 β€ i, j β€ n) as (i - j)2 + g(i, j)2. Function g is calculated by the following pseudo-code:
int g(int i, int j) {
int sum = 0;
for (int k = min(i, j) + 1; k <= max(i, j); k = k + 1)
sum = sum + a[k];
return sum;
}
Find a value mini β j f(i, j).
Probably by now Iahub already figured out the solution to this problem. Can you?
Input
The first line of input contains a single integer n (2 β€ n β€ 100000). Next line contains n integers a[1], a[2], ..., a[n] ( - 104 β€ a[i] β€ 104).
Output
Output a single integer β the value of mini β j f(i, j).
Examples
Input
4
1 0 0 -1
Output
1
Input
2
1 -1
Output
2 | import os
import math
cumsum = [int(x) for x in os.read(0, os.fstat(0).st_size).split()]
n = cumsum[0]
cumsum[0] = 0
for i in range(n):
cumsum[i+1] += cumsum[i]
def work(besta, i, sqrtbesta, lowerbound, upperbound, cumsumi):
for j in range(i+1, min(n, i - 1 + sqrtbesta) + 1):
if lowerbound < cumsum[j] < upperbound and (j-i)**2 + (cumsum[j] - cumsumi)**2 < besta:
besta = (j-i)**2 + (cumsum[j] - cumsumi)**2
return besta
besta = 10100**2
for i in range(1, n):
sqrtbesta = int(math.sqrt(besta)) + 1
lowerbound = -sqrtbesta + cumsum[i]
upperbound = sqrtbesta + cumsum[i]
besta = work(besta, i, sqrtbesta, lowerbound, upperbound, cumsum[i])
print(besta)
| {
"input": [
"4\n1 0 0 -1\n",
"2\n1 -1\n"
],
"output": [
"1\n",
"2\n"
]
} |
472 | 8 | Being a programmer, you like arrays a lot. For your birthday, your friends have given you an array a consisting of n distinct integers.
Unfortunately, the size of a is too small. You want a bigger array! Your friends agree to give you a bigger array, but only if you are able to answer the following question correctly: is it possible to sort the array a (in increasing order) by reversing exactly one segment of a? See definitions of segment and reversing in the notes.
Input
The first line of the input contains an integer n (1 β€ n β€ 105) β the size of array a.
The second line contains n distinct space-separated integers: a[1], a[2], ..., a[n] (1 β€ a[i] β€ 109).
Output
Print "yes" or "no" (without quotes), depending on the answer.
If your answer is "yes", then also print two space-separated integers denoting start and end (start must not be greater than end) indices of the segment to be reversed. If there are multiple ways of selecting these indices, print any of them.
Examples
Input
3
3 2 1
Output
yes
1 3
Input
4
2 1 3 4
Output
yes
1 2
Input
4
3 1 2 4
Output
no
Input
2
1 2
Output
yes
1 1
Note
Sample 1. You can reverse the entire array to get [1, 2, 3], which is sorted.
Sample 3. No segment can be reversed such that the array will be sorted.
Definitions
A segment [l, r] of array a is the sequence a[l], a[l + 1], ..., a[r].
If you have an array a of size n and you reverse its segment [l, r], the array will become:
a[1], a[2], ..., a[l - 2], a[l - 1], a[r], a[r - 1], ..., a[l + 1], a[l], a[r + 1], a[r + 2], ..., a[n - 1], a[n]. | def reverse(a):
return a[::-1]
n=int(input())
a=[int(i) for i in input().split()]
b=sorted(a)
if a==b:
print("yes")
print(1,1)
exit(0)
for i in range(n):
if a[i] != b[i]:
x=a.index(b[i])
y=i
break
if b == a[:y]+reverse(a[y:x+1])+a[x+1:]:
print("yes")
print(y+1,x+1)
else: print("no")
| {
"input": [
"2\n1 2\n",
"4\n2 1 3 4\n",
"4\n3 1 2 4\n",
"3\n3 2 1\n"
],
"output": [
"yes\n1 1\n",
"yes\n1 2\n",
"no\n",
"yes\n1 3\n"
]
} |
473 | 7 | Our good friend Mole is trying to code a big message. He is typing on an unusual keyboard with characters arranged in following way:
qwertyuiop
asdfghjkl;
zxcvbnm,./
Unfortunately Mole is blind, so sometimes it is problem for him to put his hands accurately. He accidentally moved both his hands with one position to the left or to the right. That means that now he presses not a button he wants, but one neighboring button (left or right, as specified in input).
We have a sequence of characters he has typed and we want to find the original message.
Input
First line of the input contains one letter describing direction of shifting ('L' or 'R' respectively for left or right).
Second line contains a sequence of characters written by Mole. The size of this sequence will be no more than 100. Sequence contains only symbols that appear on Mole's keyboard. It doesn't contain spaces as there is no space on Mole's keyboard.
It is guaranteed that even though Mole hands are moved, he is still pressing buttons on keyboard and not hitting outside it.
Output
Print a line that contains the original message.
Examples
Input
R
s;;upimrrfod;pbr
Output
allyouneedislove |
def main():
v = -1 if input() == 'R' else 1
table = 'qwertyuiopasdfghjkl;zxcvbnm,./'
s = input()
t = ''.join([table[table.find(x) + v] for x in s])
print ( t )
main()
| {
"input": [
"R\ns;;upimrrfod;pbr\n"
],
"output": [
"allyouneedislove\n"
]
} |
474 | 7 | Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27 | def fast_pow(x, y):
if y == 0:
return 1
p = fast_pow(x, y // 2)
p = p * p % 1000000007
if y % 2:
p = p * x % 1000000007
return p
n = int(input())
s = input()
cnts = [s.count(ch) for ch in ['A', 'G', 'T', 'C']]
k = cnts.count(max(cnts))
if k == 1:
print(1)
else:
print(fast_pow(k, n))
| {
"input": [
"2\nAG\n",
"3\nTTT\n",
"1\nC\n"
],
"output": [
"4\n",
"1\n",
"1\n"
]
} |
475 | 9 | Wilbur is playing with a set of n points on the coordinate plane. All points have non-negative integer coordinates. Moreover, if some point (x, y) belongs to the set, then all points (x', y'), such that 0 β€ x' β€ x and 0 β€ y' β€ y also belong to this set.
Now Wilbur wants to number the points in the set he has, that is assign them distinct integer numbers from 1 to n. In order to make the numbering aesthetically pleasing, Wilbur imposes the condition that if some point (x, y) gets number i, then all (x',y') from the set, such that x' β₯ x and y' β₯ y must be assigned a number not less than i. For example, for a set of four points (0, 0), (0, 1), (1, 0) and (1, 1), there are two aesthetically pleasing numberings. One is 1, 2, 3, 4 and another one is 1, 3, 2, 4.
Wilbur's friend comes along and challenges Wilbur. For any point he defines it's special value as s(x, y) = y - x. Now he gives Wilbur some w1, w2,..., wn, and asks him to find an aesthetically pleasing numbering of the points in the set, such that the point that gets number i has it's special value equal to wi, that is s(xi, yi) = yi - xi = wi.
Now Wilbur asks you to help him with this challenge.
Input
The first line of the input consists of a single integer n (1 β€ n β€ 100 000) β the number of points in the set Wilbur is playing with.
Next follow n lines with points descriptions. Each line contains two integers x and y (0 β€ x, y β€ 100 000), that give one point in Wilbur's set. It's guaranteed that all points are distinct. Also, it is guaranteed that if some point (x, y) is present in the input, then all points (x', y'), such that 0 β€ x' β€ x and 0 β€ y' β€ y, are also present in the input.
The last line of the input contains n integers. The i-th of them is wi ( - 100 000 β€ wi β€ 100 000) β the required special value of the point that gets number i in any aesthetically pleasing numbering.
Output
If there exists an aesthetically pleasant numbering of points in the set, such that s(xi, yi) = yi - xi = wi, then print "YES" on the first line of the output. Otherwise, print "NO".
If a solution exists, proceed output with n lines. On the i-th of these lines print the point of the set that gets number i. If there are multiple solutions, print any of them.
Examples
Input
5
2 0
0 0
1 0
1 1
0 1
0 -1 -2 1 0
Output
YES
0 0
1 0
2 0
0 1
1 1
Input
3
1 0
0 0
2 0
0 1 2
Output
NO
Note
In the first sample, point (2, 0) gets number 3, point (0, 0) gets number one, point (1, 0) gets number 2, point (1, 1) gets number 5 and point (0, 1) gets number 4. One can easily check that this numbering is aesthetically pleasing and yi - xi = wi.
In the second sample, the special values of the points in the set are 0, - 1, and - 2 while the sequence that the friend gives to Wilbur is 0, 1, 2. Therefore, the answer does not exist. | read = lambda: map(int, input().split())
n = int(input())
Max = {}
for i in range(n):
x, y = read()
s = y - x
if s not in Max or y > Max[s]:
Max[s] = y
cur = {i: max(i, 0) for i in Max}
ans = []
def no():
print('NO')
exit()
for i in read():
if i not in cur: no()
y = cur[i]
f2 = y > Max[i]
f3 = i + 1 in cur and cur[i + 1] != y + 1
f4 = i - 1 in cur and cur[i - 1] != y
if f2 or f3 or f4: no()
ans.append('%d %d' % (y - i, y))
cur[i] = y + 1
print('YES\n' + '\n'.join(ans)) | {
"input": [
"5\n2 0\n0 0\n1 0\n1 1\n0 1\n0 -1 -2 1 0\n",
"3\n1 0\n0 0\n2 0\n0 1 2\n"
],
"output": [
"YES\n0 0\n1 0\n2 0\n0 1\n1 1\n",
"NO\n"
]
} |
476 | 11 | Bob has a favorite number k and ai of length n. Now he asks you to answer m queries. Each query is given by a pair li and ri and asks you to count the number of pairs of integers i and j, such that l β€ i β€ j β€ r and the xor of the numbers ai, ai + 1, ..., aj is equal to k.
Input
The first line of the input contains integers n, m and k (1 β€ n, m β€ 100 000, 0 β€ k β€ 1 000 000) β the length of the array, the number of queries and Bob's favorite number respectively.
The second line contains n integers ai (0 β€ ai β€ 1 000 000) β Bob's array.
Then m lines follow. The i-th line contains integers li and ri (1 β€ li β€ ri β€ n) β the parameters of the i-th query.
Output
Print m lines, answer the queries in the order they appear in the input.
Examples
Input
6 2 3
1 2 1 1 0 3
1 6
3 5
Output
7
0
Input
5 3 1
1 1 1 1 1
1 5
2 4
1 3
Output
9
4
4
Note
In the first sample the suitable pairs of i and j for the first query are: (1, 2), (1, 4), (1, 5), (2, 3), (3, 6), (5, 6), (6, 6). Not a single of these pairs is suitable for the second query.
In the second sample xor equals 1 for all subarrays of an odd length. | # [https://codeforces.com/contest/617/submission/15550846 <- https://codeforces.com/blog/entry/22971 <- https://codeforces.com/problemset/problem/617/E <- https://algoprog.ru/material/pc617pE]
BLOCK_SIZE = 316 #sqrt(1e5)
class Query:
def __init__(self, left, right, number):
self.left = left
self.right = right
self.number = number
def __lt__(self, other):
return self.right < other.right
cnt = [0] * (1 << 20)
result = 0
favourite = 0
def add(v):
global result
result += cnt[v ^ favourite]
cnt[v] += 1
def delv(v):
global result
cnt[v] -= 1
result -= cnt[v ^ favourite]
(n, m, favourite) = map(int, input().split())
a = list(map(int, input().split()))
pref = [0] * (n + 1)
for i in range(1, n + 1):
pref[i] = pref[i - 1] ^ a[i - 1]
blocks = [[] for i in range(n // BLOCK_SIZE + 2)]
for i in range(m):
(left, right) = map(int, input().split())
left -= 1
right += 1
blocks[left // BLOCK_SIZE].append(Query(left, right, i))
for b in blocks:
b.sort()
answer = [0] * m
for i in range(len(blocks)):
left = i * BLOCK_SIZE
right = left
for q in blocks[i]:
while right < q.right:
add(pref[right])
right += 1
while left < q.left:
delv(pref[left])
left += 1
while left > q.left:
left -= 1
add(pref[left])
answer[q.number] = result
for j in range(left, right):
delv(pref[j])
print(*answer, sep = "\n") | {
"input": [
"6 2 3\n1 2 1 1 0 3\n1 6\n3 5\n",
"5 3 1\n1 1 1 1 1\n1 5\n2 4\n1 3\n"
],
"output": [
"7\n0\n",
"9\n4\n4\n"
]
} |
477 | 8 | Berland scientists face a very important task - given the parts of short DNA fragments, restore the dinosaur DNA! The genome of a berland dinosaur has noting in common with the genome that we've used to: it can have 26 distinct nucleotide types, a nucleotide of each type can occur at most once. If we assign distinct English letters to all nucleotides, then the genome of a Berland dinosaur will represent a non-empty string consisting of small English letters, such that each letter occurs in it at most once.
Scientists have n genome fragments that are represented as substrings (non-empty sequences of consecutive nucleotides) of the sought genome.
You face the following problem: help scientists restore the dinosaur genome. It is guaranteed that the input is not contradictory and at least one suitable line always exists. When the scientists found out that you are a strong programmer, they asked you in addition to choose the one with the minimum length. If there are multiple such strings, choose any string.
Input
The first line of the input contains a positive integer n (1 β€ n β€ 100) β the number of genome fragments.
Each of the next lines contains one descriptions of a fragment. Each fragment is a non-empty string consisting of distinct small letters of the English alphabet. It is not guaranteed that the given fragments are distinct. Fragments could arbitrarily overlap and one fragment could be a substring of another one.
It is guaranteed that there is such string of distinct letters that contains all the given fragments as substrings.
Output
In the single line of the output print the genome of the minimum length that contains all the given parts. All the nucleotides in the genome must be distinct. If there are multiple suitable strings, print the string of the minimum length. If there also are multiple suitable strings, you can print any of them.
Examples
Input
3
bcd
ab
cdef
Output
abcdef
Input
4
x
y
z
w
Output
xyzw | def main():
ab, tails, res = {}, set(), []
for _ in range(int(input())):
a, *s = input()
for b in s:
ab[a] = a = b
tails.add(b)
ab.setdefault(a, '')
for a in ab.keys():
if a not in tails:
while a:
res.append(a)
a = ab[a]
print(''.join(res))
if __name__ == '__main__':
main()
| {
"input": [
"3\nbcd\nab\ncdef\n",
"4\nx\ny\nz\nw\n"
],
"output": [
"abcdef\n",
"wxyz\n"
]
} |
478 | 8 | Memory is performing a walk on the two-dimensional plane, starting at the origin. He is given a string s with his directions for motion:
* An 'L' indicates he should move one unit left.
* An 'R' indicates he should move one unit right.
* A 'U' indicates he should move one unit up.
* A 'D' indicates he should move one unit down.
But now Memory wants to end at the origin. To do this, he has a special trident. This trident can replace any character in s with any of 'L', 'R', 'U', or 'D'. However, because he doesn't want to wear out the trident, he wants to make the minimum number of edits possible. Please tell Memory what is the minimum number of changes he needs to make to produce a string that, when walked, will end at the origin, or if there is no such string.
Input
The first and only line contains the string s (1 β€ |s| β€ 100 000) β the instructions Memory is given.
Output
If there is a string satisfying the conditions, output a single integer β the minimum number of edits required. In case it's not possible to change the sequence in such a way that it will bring Memory to to the origin, output -1.
Examples
Input
RRU
Output
-1
Input
UDUR
Output
1
Input
RUUR
Output
2
Note
In the first sample test, Memory is told to walk right, then right, then up. It is easy to see that it is impossible to edit these instructions to form a valid walk.
In the second sample test, Memory is told to walk up, then down, then up, then right. One possible solution is to change s to "LDUR". This string uses 1 edit, which is the minimum possible. It also ends at the origin. | def compute():
s = input()
if len(s)%2 == 1:return -1
d = {'R':0,'L':0,'U':0,'D':0}
for x in s:d[x] += 1
return (abs(d['L']-d['R']) + abs(d['U']-d['D']))//2
print(compute())
| {
"input": [
"UDUR\n",
"RUUR\n",
"RRU\n"
],
"output": [
"1\n",
"2\n",
"-1\n"
]
} |
479 | 7 | One day, the Grasshopper was jumping on the lawn and found a piece of paper with a string. Grasshopper became interested what is the minimum jump ability he should have in order to be able to reach the far end of the string, jumping only on vowels of the English alphabet. Jump ability is the maximum possible length of his jump.
Formally, consider that at the begginning the Grasshopper is located directly in front of the leftmost character of the string. His goal is to reach the position right after the rightmost character of the string. In one jump the Grasshopper could jump to the right any distance from 1 to the value of his jump ability.
<image> The picture corresponds to the first example.
The following letters are vowels: 'A', 'E', 'I', 'O', 'U' and 'Y'.
Input
The first line contains non-empty string consisting of capital English letters. It is guaranteed that the length of the string does not exceed 100.
Output
Print single integer a β the minimum jump ability of the Grasshopper (in the number of symbols) that is needed to overcome the given string, jumping only on vowels.
Examples
Input
ABABBBACFEYUKOTT
Output
4
Input
AAA
Output
1 | v=['A','E','I','O','U','Y']
def fun(c,ss):
if not(ss): return c
if ss[0] in v: return max(c,fun(1,ss[1:]))
return fun(c+1,ss[1:])
ss=input()
print(fun(1,ss)) | {
"input": [
"ABABBBACFEYUKOTT\n",
"AAA\n"
],
"output": [
"4\n",
"1\n"
]
} |
480 | 8 | Bash has set out on a journey to become the greatest Pokemon master. To get his first Pokemon, he went to Professor Zulu's Lab. Since Bash is Professor Zulu's favourite student, Zulu allows him to take as many Pokemon from his lab as he pleases.
But Zulu warns him that a group of k > 1 Pokemon with strengths {s1, s2, s3, ..., sk} tend to fight among each other if gcd(s1, s2, s3, ..., sk) = 1 (see notes for gcd definition).
Bash, being smart, does not want his Pokemon to fight among each other. However, he also wants to maximize the number of Pokemon he takes from the lab. Can you help Bash find out the maximum number of Pokemon he can take?
Note: A Pokemon cannot fight with itself.
Input
The input consists of two lines.
The first line contains an integer n (1 β€ n β€ 105), the number of Pokemon in the lab.
The next line contains n space separated integers, where the i-th of them denotes si (1 β€ si β€ 105), the strength of the i-th Pokemon.
Output
Print single integer β the maximum number of Pokemons Bash can take.
Examples
Input
3
2 3 4
Output
2
Input
5
2 3 4 6 7
Output
3
Note
gcd (greatest common divisor) of positive integers set {a1, a2, ..., an} is the maximum positive integer that divides all the integers {a1, a2, ..., an}.
In the first sample, we can take Pokemons with strengths {2, 4} since gcd(2, 4) = 2.
In the second sample, we can take Pokemons with strengths {2, 4, 6}, and there is no larger group with gcd β 1. | import math
factor = [0] * (100001)
def factors(x):
i = 0
for i in range(2, int(math.sqrt(x)) + 1):
if x % i == 0:
factor[i] += 1
if x // i != i:
factor[x // i] += 1
if x != 1 and i < x:
factor[x] += 1
n = int(input())
s = list(map(int, input().split()))
for x in s:
factors(x)
# print(factor)
print(max(max(factor), 1)) | {
"input": [
"5\n2 3 4 6 7\n",
"3\n2 3 4\n"
],
"output": [
"3\n",
"2\n"
]
} |
481 | 10 | Peter decided to lay a parquet in the room of size n Γ m, the parquet consists of tiles of size 1 Γ 2. When the workers laid the parquet, it became clear that the tiles pattern looks not like Peter likes, and workers will have to re-lay it.
The workers decided that removing entire parquet and then laying it again is very difficult task, so they decided to make such an operation every hour: remove two tiles, which form a 2 Γ 2 square, rotate them 90 degrees and put them back on the same place.
<image>
They have no idea how to obtain the desired configuration using these operations, and whether it is possible at all.
Help Peter to make a plan for the workers or tell that it is impossible. The plan should contain at most 100 000 commands.
Input
The first line contains integer n and m, size of the room (1 β€ n, m β€ 50). At least one of them is even number.
The following n lines contain m characters each, the description of the current configuration of the parquet tiles. Each character represents the position of the half-tile. Characters 'L', 'R', 'U' and 'D' correspond to the left, right, upper and lower halves, respectively.
The following n lines contain m characters each, describing the desired configuration in the same format.
Output
In the first line output integer k, the number of operations. In the next k lines output description of operations. The operation is specified by coordinates (row and column) of the left upper half-tile on which the operation is performed.
If there is no solution, output -1 in the first line.
Examples
Input
2 3
ULR
DLR
LRU
LRD
Output
2
1 2
1 1
Input
4 3
ULR
DLR
LRU
LRD
ULR
DUU
UDD
DLR
Output
3
3 1
3 2
2 2
Note
In the first sample test first operation is to rotate two rightmost tiles, after this all tiles lie vertically. Second operation is to rotate two leftmost tiles, after this we will get desired configuration.
<image> | #!/usr/bin/env python3
board = []
n, m = 0, 0
def rotate(x, y):
if board[x][y] == 'L':
board[x][y] = board[x][y+1] = 'U'
board[x+1][y] = board[x+1][y+1] = 'D'
else:
board[x][y] = board[x+1][y] = 'L'
board[x][y+1] = board[x+1][y+1] = 'R'
def fix(x, y, moves):
if board[x+1][y] == 'U':
if board[x+1][y+1] == 'L':
fix(x+1, y+1, moves)
rotate(x+1, y)
moves.append((x+2, y+1))
rotate(x, y)
moves.append((x+1, y+1))
def solve_board(moves):
global board, n, m
board = []
for _ in range(n):
board.append(list(input()))
for i in range(n-1):
for j in range(m):
if board[i][j] == 'L':
fix(i, j, moves)
def main():
global n, m
n, m = map(int, input().split())
moves1 = []; moves2 = []
solve_board(moves1)
solve_board(moves2)
print(len(moves1) + len(moves2))
for move in moves1:
print(str(move[0]) + ' ' + str(move[1]))
for move in reversed(moves2):
print(str(move[0]) + ' ' + str(move[1]))
if __name__ == '__main__':
main() | {
"input": [
"4 3\nULR\nDLR\nLRU\nLRD\nULR\nDUU\nUDD\nDLR",
"2 3\nULR\nDLR\nLRU\nLRD\n"
],
"output": [
"5\n1 2\n3 1\n3 2\n1 2\n2 2\n",
"2\n1 2\n1 1\n"
]
} |
482 | 9 | Makes solves problems on Decoforces and lots of other different online judges. Each problem is denoted by its difficulty β a positive integer number. Difficulties are measured the same across all the judges (the problem with difficulty d on Decoforces is as hard as the problem with difficulty d on any other judge).
Makes has chosen n problems to solve on Decoforces with difficulties a1, a2, ..., an. He can solve these problems in arbitrary order. Though he can solve problem i with difficulty ai only if he had already solved some problem with difficulty <image> (no matter on what online judge was it).
Before starting this chosen list of problems, Makes has already solved problems with maximum difficulty k.
With given conditions it's easy to see that Makes sometimes can't solve all the chosen problems, no matter what order he chooses. So he wants to solve some problems on other judges to finish solving problems from his list.
For every positive integer y there exist some problem with difficulty y on at least one judge besides Decoforces.
Makes can solve problems on any judge at any time, it isn't necessary to do problems from the chosen list one right after another.
Makes doesn't have too much free time, so he asked you to calculate the minimum number of problems he should solve on other judges in order to solve all the chosen problems from Decoforces.
Input
The first line contains two integer numbers n, k (1 β€ n β€ 103, 1 β€ k β€ 109).
The second line contains n space-separated integer numbers a1, a2, ..., an (1 β€ ai β€ 109).
Output
Print minimum number of problems Makes should solve on other judges in order to solve all chosen problems on Decoforces.
Examples
Input
3 3
2 1 9
Output
1
Input
4 20
10 3 6 3
Output
0
Note
In the first example Makes at first solves problems 1 and 2. Then in order to solve the problem with difficulty 9, he should solve problem with difficulty no less than 5. The only available are difficulties 5 and 6 on some other judge. Solving any of these will give Makes opportunity to solve problem 3.
In the second example he can solve every problem right from the start. | def main():
n, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = k
p = 0
ans = 0
while p < n:
while 2 * b < a[p]:
b = 2 * b
ans += 1
b = max(b, a[p])
p += 1
print(ans)
main()
| {
"input": [
"4 20\n10 3 6 3\n",
"3 3\n2 1 9\n"
],
"output": [
"0",
"1"
]
} |
483 | 7 | From beginning till end, this message has been waiting to be conveyed.
For a given unordered multiset of n lowercase English letters ("multi" means that a letter may appear more than once), we treat all letters as strings of length 1, and repeat the following operation n - 1 times:
* Remove any two elements s and t from the set, and add their concatenation s + t to the set.
The cost of such operation is defined to be <image>, where f(s, c) denotes the number of times character c appears in string s.
Given a non-negative integer k, construct any valid non-empty set of no more than 100 000 letters, such that the minimum accumulative cost of the whole process is exactly k. It can be shown that a solution always exists.
Input
The first and only line of input contains a non-negative integer k (0 β€ k β€ 100 000) β the required minimum cost.
Output
Output a non-empty string of no more than 100 000 lowercase English letters β any multiset satisfying the requirements, concatenated to be a string.
Note that the printed string doesn't need to be the final concatenated string. It only needs to represent an unordered multiset of letters.
Examples
Input
12
Output
abababab
Input
3
Output
codeforces
Note
For the multiset {'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b'}, one of the ways to complete the process is as follows:
* {"ab", "a", "b", "a", "b", "a", "b"}, with a cost of 0;
* {"aba", "b", "a", "b", "a", "b"}, with a cost of 1;
* {"abab", "a", "b", "a", "b"}, with a cost of 1;
* {"abab", "ab", "a", "b"}, with a cost of 0;
* {"abab", "aba", "b"}, with a cost of 1;
* {"abab", "abab"}, with a cost of 1;
* {"abababab"}, with a cost of 8.
The total cost is 12, and it can be proved to be the minimum cost of the process. | def solve(k, c):
if k == 0: return c
n = 1
while f(n + 1) <= k: n += 1
return c * n + solve(k - f(n), chr(ord(c) + 1))
k = int(input())
f = lambda n: n * (n - 1) // 2
print(solve(k, 'a')) | {
"input": [
"12\n",
"3\n"
],
"output": [
"aaaaabbcc\n",
"aaa\n"
]
} |
484 | 8 | Arkady wants to water his only flower. Unfortunately, he has a very poor watering system that was designed for n flowers and so it looks like a pipe with n holes. Arkady can only use the water that flows from the first hole.
Arkady can block some of the holes, and then pour A liters of water into the pipe. After that, the water will flow out from the non-blocked holes proportionally to their sizes s_1, s_2, β¦, s_n. In other words, if the sum of sizes of non-blocked holes is S, and the i-th hole is not blocked, (s_i β
A)/(S) liters of water will flow out of it.
What is the minimum number of holes Arkady should block to make at least B liters of water flow out of the first hole?
Input
The first line contains three integers n, A, B (1 β€ n β€ 100 000, 1 β€ B β€ A β€ 10^4) β the number of holes, the volume of water Arkady will pour into the system, and the volume he wants to get out of the first hole.
The second line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ 10^4) β the sizes of the holes.
Output
Print a single integer β the number of holes Arkady should block.
Examples
Input
4 10 3
2 2 2 2
Output
1
Input
4 80 20
3 2 1 4
Output
0
Input
5 10 10
1000 1 1 1 1
Output
4
Note
In the first example Arkady should block at least one hole. After that, (10 β
2)/(6) β 3.333 liters of water will flow out of the first hole, and that suits Arkady.
In the second example even without blocking any hole, (80 β
3)/(10) = 24 liters will flow out of the first hole, that is not less than 20.
In the third example Arkady has to block all holes except the first to make all water flow out of the first hole. | def f(l1,l2):
n,a,b = l1
s = sum(l2)
l = l2[1:]
l.sort(reverse=True)
i = 0
while b*s>l2[0]*a:
s -= l[i]
i += 1
return i
l1 = list(map(int,input().split()))
l2 = list(map(int,input().split()))
print(f(l1,l2))
| {
"input": [
"4 10 3\n2 2 2 2\n",
"5 10 10\n1000 1 1 1 1\n",
"4 80 20\n3 2 1 4\n"
],
"output": [
"1\n",
"4\n",
"0\n"
]
} |
485 | 8 | Two participants are each given a pair of distinct numbers from 1 to 9 such that there's exactly one number that is present in both pairs. They want to figure out the number that matches by using a communication channel you have access to without revealing it to you.
Both participants communicated to each other a set of pairs of numbers, that includes the pair given to them. Each pair in the communicated sets comprises two different numbers.
Determine if you can with certainty deduce the common number, or if you can determine with certainty that both participants know the number but you do not.
Input
The first line contains two integers n and m (1 β€ n, m β€ 12) β the number of pairs the first participant communicated to the second and vice versa.
The second line contains n pairs of integers, each between 1 and 9, β pairs of numbers communicated from first participant to the second.
The third line contains m pairs of integers, each between 1 and 9, β pairs of numbers communicated from the second participant to the first.
All pairs within each set are distinct (in particular, if there is a pair (1,2), there will be no pair (2,1) within the same set), and no pair contains the same number twice.
It is guaranteed that the two sets do not contradict the statements, in other words, there is pair from the first set and a pair from the second set that share exactly one number.
Output
If you can deduce the shared number with certainty, print that number.
If you can with certainty deduce that both participants know the shared number, but you do not know it, print 0.
Otherwise print -1.
Examples
Input
2 2
1 2 3 4
1 5 3 4
Output
1
Input
2 2
1 2 3 4
1 5 6 4
Output
0
Input
2 3
1 2 4 5
1 2 1 3 2 3
Output
-1
Note
In the first example the first participant communicated pairs (1,2) and (3,4), and the second communicated (1,5), (3,4). Since we know that the actual pairs they received share exactly one number, it can't be that they both have (3,4). Thus, the first participant has (1,2) and the second has (1,5), and at this point you already know the shared number is 1.
In the second example either the first participant has (1,2) and the second has (1,5), or the first has (3,4) and the second has (6,4). In the first case both of them know the shared number is 1, in the second case both of them know the shared number is 4. You don't have enough information to tell 1 and 4 apart.
In the third case if the first participant was given (1,2), they don't know what the shared number is, since from their perspective the second participant might have been given either (1,3), in which case the shared number is 1, or (2,3), in which case the shared number is 2. While the second participant does know the number with certainty, neither you nor the first participant do, so the output is -1. | def rp():
cs = list(map(int, input().split(' ')))
cs = list(zip(cs[0::2], cs[1::2]))
return cs
def dist(p1, p2):
return len(set(p1).union(set(p2))) - 2
input()
ps = [rp(), rp()]
theyCan = True
myPos = set()
for ps1, ps2 in [ps, ps[::-1]]:
for p1 in ps1:
pos = set()
for p2 in ps2:
if dist(p1, p2) == 1:
pos = pos.union( set(p1).intersection(set(p2)) )
if len(pos) >= 2:
theyCan = False
myPos = myPos.union(pos)
print(next(iter(myPos)) if len(myPos)==1 else 0 if theyCan else -1)
| {
"input": [
"2 3\n1 2 4 5\n1 2 1 3 2 3\n",
"2 2\n1 2 3 4\n1 5 3 4\n",
"2 2\n1 2 3 4\n1 5 6 4\n"
],
"output": [
"-1",
"1",
"0"
]
} |
486 | 7 | You are given a string s consisting of n lowercase Latin letters. n is even.
For each position i (1 β€ i β€ n) in string s you are required to change the letter on this position either to the previous letter in alphabetic order or to the next one (letters 'a' and 'z' have only one of these options). Letter in every position must be changed exactly once.
For example, letter 'p' should be changed either to 'o' or to 'q', letter 'a' should be changed to 'b' and letter 'z' should be changed to 'y'.
That way string "codeforces", for example, can be changed to "dpedepqbft" ('c' β 'd', 'o' β 'p', 'd' β 'e', 'e' β 'd', 'f' β 'e', 'o' β 'p', 'r' β 'q', 'c' β 'b', 'e' β 'f', 's' β 't').
String s is called a palindrome if it reads the same from left to right and from right to left. For example, strings "abba" and "zz" are palindromes and strings "abca" and "zy" are not.
Your goal is to check if it's possible to make string s a palindrome by applying the aforementioned changes to every position. Print "YES" if string s can be transformed to a palindrome and "NO" otherwise.
Each testcase contains several strings, for each of them you are required to solve the problem separately.
Input
The first line contains a single integer T (1 β€ T β€ 50) β the number of strings in a testcase.
Then 2T lines follow β lines (2i - 1) and 2i of them describe the i-th string. The first line of the pair contains a single integer n (2 β€ n β€ 100, n is even) β the length of the corresponding string. The second line of the pair contains a string s, consisting of n lowercase Latin letters.
Output
Print T lines. The i-th line should contain the answer to the i-th string of the input. Print "YES" if it's possible to make the i-th string a palindrome by applying the aforementioned changes to every position. Print "NO" otherwise.
Example
Input
5
6
abccba
2
cf
4
adfa
8
abaazaba
2
ml
Output
YES
NO
YES
NO
NO
Note
The first string of the example can be changed to "bcbbcb", two leftmost letters and two rightmost letters got changed to the next letters, two middle letters got changed to the previous letters.
The second string can be changed to "be", "bg", "de", "dg", but none of these resulting strings are palindromes.
The third string can be changed to "beeb" which is a palindrome.
The fifth string can be changed to "lk", "lm", "nk", "nm", but none of these resulting strings are palindromes. Also note that no letter can remain the same, so you can't obtain strings "ll" or "mm". | def solve(n, s):
return 'YES' if all([(ord(s[i]) - ord(s[n - 1 - i])) in (-2, 0, 2) for i in range(n)]) else 'NO'
for t in range(int(input())):
print(solve(int(input()), input()))
| {
"input": [
"5\n6\nabccba\n2\ncf\n4\nadfa\n8\nabaazaba\n2\nml\n"
],
"output": [
"YES\nNO\nYES\nNO\nNO\n"
]
} |
487 | 9 | There are n people sitting in a circle, numbered from 1 to n in the order in which they are seated. That is, for all i from 1 to n-1, the people with id i and i+1 are adjacent. People with id n and 1 are adjacent as well.
The person with id 1 initially has a ball. He picks a positive integer k at most n, and passes the ball to his k-th neighbour in the direction of increasing ids, that person passes the ball to his k-th neighbour in the same direction, and so on until the person with the id 1 gets the ball back. When he gets it back, people do not pass the ball any more.
For instance, if n = 6 and k = 4, the ball is passed in order [1, 5, 3, 1].
Consider the set of all people that touched the ball. The fun value of the game is the sum of the ids of people that touched it. In the above example, the fun value would be 1 + 5 + 3 = 9.
Find and report the set of possible fun values for all choices of positive integer k. It can be shown that under the constraints of the problem, the ball always gets back to the 1-st player after finitely many steps, and there are no more than 10^5 possible fun values for given n.
Input
The only line consists of a single integer n (2 β€ n β€ 10^9) β the number of people playing with the ball.
Output
Suppose the set of all fun values is f_1, f_2, ..., f_m.
Output a single line containing m space separated integers f_1 through f_m in increasing order.
Examples
Input
6
Output
1 5 9 21
Input
16
Output
1 10 28 64 136
Note
In the first sample, we've already shown that picking k = 4 yields fun value 9, as does k = 2. Picking k = 6 results in fun value of 1. For k = 3 we get fun value 5 and with k = 1 or k = 5 we get 21.
<image>
In the second sample, the values 1, 10, 28, 64 and 136 are achieved for instance for k = 16, 8, 4, 10 and 11, respectively. | n=int(input())
def fun(a,b):
return (a*(2+b*(a-1)))//2
i=1
ans=set()
while i*i<=n:
if n%i==0:
ans.add(fun(n//i,i))
ans.add(fun(i,n//i))
i+=1
print(*sorted(ans)) | {
"input": [
"6\n",
"16\n"
],
"output": [
"1 5 9 21\n",
"1 10 28 64 136\n"
]
} |
488 | 7 | You are given an integer n (n β₯ 0) represented with k digits in base (radix) b. So,
$$$n = a_1 β
b^{k-1} + a_2 β
b^{k-2} + β¦ a_{k-1} β
b + a_k.$$$
For example, if b=17, k=3 and a=[11, 15, 7] then n=11β
17^2+15β
17+7=3179+255+7=3441.
Determine whether n is even or odd.
Input
The first line contains two integers b and k (2β€ bβ€ 100, 1β€ kβ€ 10^5) β the base of the number and the number of digits.
The second line contains k integers a_1, a_2, β¦, a_k (0β€ a_i < b) β the digits of n.
The representation of n contains no unnecessary leading zero. That is, a_1 can be equal to 0 only if k = 1.
Output
Print "even" if n is even, otherwise print "odd".
You can print each letter in any case (upper or lower).
Examples
Input
13 3
3 2 7
Output
even
Input
10 9
1 2 3 4 5 6 7 8 9
Output
odd
Input
99 5
32 92 85 74 4
Output
odd
Input
2 2
1 0
Output
even
Note
In the first example, n = 3 β
13^2 + 2 β
13 + 7 = 540, which is even.
In the second example, n = 123456789 is odd.
In the third example, n = 32 β
99^4 + 92 β
99^3 + 85 β
99^2 + 74 β
99 + 4 = 3164015155 is odd.
In the fourth example n = 2. | def mp():
return map(int, input().split())
b, k = mp()
a = list(mp())
t = a[-1]
for i in range(k - 1):
t += (a[i] * b) % 2
if t % 2 == 0:
print('even')
else:
print('odd') | {
"input": [
"13 3\n3 2 7\n",
"99 5\n32 92 85 74 4\n",
"2 2\n1 0\n",
"10 9\n1 2 3 4 5 6 7 8 9\n"
],
"output": [
"even\n",
"odd\n",
"even\n",
"odd\n"
]
} |
489 | 8 | Let s be some string consisting of symbols "0" or "1". Let's call a string t a substring of string s, if there exists such number 1 β€ l β€ |s| - |t| + 1 that t = s_l s_{l+1} β¦ s_{l + |t| - 1}. Let's call a substring t of string s unique, if there exist only one such l.
For example, let s = "1010111". A string t = "010" is an unique substring of s, because l = 2 is the only one suitable number. But, for example t = "10" isn't a unique substring of s, because l = 1 and l = 3 are suitable. And for example t ="00" at all isn't a substring of s, because there is no suitable l.
Today Vasya solved the following problem at the informatics lesson: given a string consisting of symbols "0" and "1", the task is to find the length of its minimal unique substring. He has written a solution to this problem and wants to test it. He is asking you to help him.
You are given 2 positive integers n and k, such that (n mod 2) = (k mod 2), where (x mod 2) is operation of taking remainder of x by dividing on 2. Find any string s consisting of n symbols "0" or "1", such that the length of its minimal unique substring is equal to k.
Input
The first line contains two integers n and k, separated by spaces (1 β€ k β€ n β€ 100 000, (k mod 2) = (n mod 2)).
Output
Print a string s of length n, consisting of symbols "0" and "1". Minimal length of the unique substring of s should be equal to k. You can find any suitable string. It is guaranteed, that there exists at least one such string.
Examples
Input
4 4
Output
1111
Input
5 3
Output
01010
Input
7 3
Output
1011011
Note
In the first test, it's easy to see, that the only unique substring of string s = "1111" is all string s, which has length 4.
In the second test a string s = "01010" has minimal unique substring t ="101", which has length 3.
In the third test a string s = "1011011" has minimal unique substring t ="110", which has length 3. | from math import *
from fractions import *
def li():
return list(map(int, input().split(" ")))
n,k = li()
if k == 1:
print("1" + "0"*(n-1))
else:
a = (n-k)//2
p = "1" + "0"*a
ans = p * (n//(a+1)) + p[:(n%(a+1))]
print(ans) | {
"input": [
"4 4\n",
"7 3\n",
"5 3\n"
],
"output": [
"1111\n",
"0010010\n",
"01010\n"
]
} |
490 | 7 | While playing with geometric figures Alex has accidentally invented a concept of a n-th order rhombus in a cell grid.
A 1-st order rhombus is just a square 1 Γ 1 (i.e just a cell).
A n-th order rhombus for all n β₯ 2 one obtains from a n-1-th order rhombus adding all cells which have a common side with it to it (look at the picture to understand it better).
<image>
Alex asks you to compute the number of cells in a n-th order rhombus.
Input
The first and only input line contains integer n (1 β€ n β€ 100) β order of a rhombus whose numbers of cells should be computed.
Output
Print exactly one integer β the number of cells in a n-th order rhombus.
Examples
Input
1
Output
1
Input
2
Output
5
Input
3
Output
13
Note
Images of rhombus corresponding to the examples are given in the statement. | def f(n):return n if n == 1 else f(n-1)+(n-1)*4
print(f(int(input()))) | {
"input": [
"3\n",
"1\n",
"2\n"
],
"output": [
"13\n",
"1\n",
"5\n"
]
} |
491 | 7 | For years, the Day of city N was held in the most rainy day of summer. New mayor decided to break this tradition and select a not-so-rainy day for the celebration. The mayor knows the weather forecast for the n days of summer. On the i-th day, a_i millimeters of rain will fall. All values a_i are distinct.
The mayor knows that citizens will watch the weather x days before the celebration and y days after. Because of that, he says that a day d is not-so-rainy if a_d is smaller than rain amounts at each of x days before day d and and each of y days after day d. In other words, a_d < a_j should hold for all d - x β€ j < d and d < j β€ d + y. Citizens only watch the weather during summer, so we only consider such j that 1 β€ j β€ n.
Help mayor find the earliest not-so-rainy day of summer.
Input
The first line contains three integers n, x and y (1 β€ n β€ 100 000, 0 β€ x, y β€ 7) β the number of days in summer, the number of days citizens watch the weather before the celebration and the number of days they do that after.
The second line contains n distinct integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i denotes the rain amount on the i-th day.
Output
Print a single integer β the index of the earliest not-so-rainy day of summer. We can show that the answer always exists.
Examples
Input
10 2 2
10 9 6 7 8 3 2 1 4 5
Output
3
Input
10 2 3
10 9 6 7 8 3 2 1 4 5
Output
8
Input
5 5 5
100000 10000 1000 100 10
Output
5
Note
In the first example days 3 and 8 are not-so-rainy. The 3-rd day is earlier.
In the second example day 3 is not not-so-rainy, because 3 + y = 6 and a_3 > a_6. Thus, day 8 is the answer. Note that 8 + y = 11, but we don't consider day 11, because it is not summer. | n, x, y = *map(int,input().split()),
a = *map(int,input().split()),
def check(i):
return all(map(lambda x: x > a[i], a[max(0, i-x):i] + a[i+1:i+y+1]))
for i in range(n):
if check(i):
print(i+1)
break
| {
"input": [
"5 5 5\n100000 10000 1000 100 10\n",
"10 2 2\n10 9 6 7 8 3 2 1 4 5\n",
"10 2 3\n10 9 6 7 8 3 2 1 4 5\n"
],
"output": [
"5\n",
"3\n",
"8\n"
]
} |
492 | 12 | In addition to complaints about lighting, a lot of complaints about insufficient radio signal covering has been received by Bertown city hall recently. n complaints were sent to the mayor, all of which are suspiciosly similar to each other: in the i-th complaint, one of the radio fans has mentioned that the signals of two radio stations x_i and y_i are not covering some parts of the city, and demanded that the signal of at least one of these stations can be received in the whole city.
Of cousre, the mayor of Bertown is currently working to satisfy these complaints. A new radio tower has been installed in Bertown, it can transmit a signal with any integer power from 1 to M (let's denote the signal power as f). The mayor has decided that he will choose a set of radio stations and establish a contract with every chosen station. To establish a contract with the i-th station, the following conditions should be met:
* the signal power f should be not less than l_i, otherwise the signal of the i-th station won't cover the whole city;
* the signal power f should be not greater than r_i, otherwise the signal will be received by the residents of other towns which haven't established a contract with the i-th station.
All this information was already enough for the mayor to realise that choosing the stations is hard. But after consulting with specialists, he learned that some stations the signals of some stations may interfere with each other: there are m pairs of stations (u_i, v_i) that use the same signal frequencies, and for each such pair it is impossible to establish contracts with both stations. If stations x and y use the same frequencies, and y and z use the same frequencies, it does not imply that x and z use the same frequencies.
The mayor finds it really hard to analyze this situation, so he hired you to help him. You have to choose signal power f and a set of stations to establish contracts with such that:
* all complaints are satisfied (formally, for every i β [1, n] the city establishes a contract either with station x_i, or with station y_i);
* no two chosen stations interfere with each other (formally, for every i β [1, m] the city does not establish a contract either with station u_i, or with station v_i);
* for each chosen station, the conditions on signal power are met (formally, for each chosen station i the condition l_i β€ f β€ r_i is met).
Input
The first line contains 4 integers n, p, M and m (2 β€ n, p, M, m β€ 4 β
10^5) β the number of complaints, the number of radio stations, maximum signal power and the number of interfering pairs, respectively.
Then n lines follow, which describe the complains. Each line contains two integers x_i and y_i (1 β€ x_i < y_i β€ p) β the indices of the radio stations mentioned in the i-th complaint). All complaints are distinct.
Then p lines follow, which describe the radio stations. Each line contains two integers l_i and r_i (1 β€ l_i β€ r_i β€ M) β the constrains on signal power that should be satisfied if the city establishes a contract with the i-th station.
Then m lines follow, which describe the pairs of interfering radio stations. Each line contains two integers u_i and v_i (1 β€ u_i < v_i β€ p) β the indices of interfering radio stations. All these pairs are distinct.
Output
If it is impossible to choose signal power and a set of stations to meet all conditions, print -1.
Otherwise print two integers k and f in the first line β the number of stations in the chosen set and the chosen signal power, respectively. In the second line print k distinct integers from 1 to p β the indices of stations to establish contracts with (in any order). If there are multiple answers, print any of them; you don't have to minimize/maximize the number of chosen stations, and the same applies to signal power.
Examples
Input
2 4 4 2
1 3
2 3
1 4
1 2
3 4
1 4
1 2
3 4
Output
2 3
1 3
Input
2 4 4 2
1 3
2 4
1 2
1 2
3 4
3 4
1 2
3 4
Output
-1 | # ------------------- fast io --------------------
import os
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
def find_SCC(graph):
SCC, S, P = [], [], []
depth = [0] * len(graph)
stack = list(range(len(graph)))
while stack:
node = stack.pop()
if node < 0:
d = depth[~node] - 1
if P[-1] > d:
SCC.append(S[d:])
del S[d:], P[-1]
for node in SCC[-1]:
depth[node] = -1
elif depth[node] > 0:
while P[-1] > depth[node]:
P.pop()
elif depth[node] == 0:
S.append(node)
P.append(len(S))
depth[node] = len(S)
stack.append(~node)
stack += graph[node]
SCC = SCC[::-1]
cx = [-1] * (len(graph))
for i in range(len(SCC)):
for j in SCC[i]:
cx[j] = i
return cx
for _ in range(int(input()) if not True else 1):
# n = int(input())
n, p, M, m = map(int, input().split())
# a, b = map(int, input().split())
# c, d = map(int, input().split())
# a = list(map(int, input().split()))
# b = list(map(int, input().split()))
# s = input()
graph = [[] for __ in range(2 * p + 2 * M + 1)]
for i in range(n):
x, y = map(int, input().split())
x2 = (x + p)
y2 = (y + p)
graph[x2] += [y]
graph[y2] += [x]
for x in range(1, p + 1):
l, r = map(int, input().split())
x2 = (x + p)
l += 2 * p
r += 2 * p + 1
graph[l+M] += [x2]
graph[x] += [l]
if r + M != 2 * p + 2 * M + 1:
graph[r] += [x2]
graph[x] += [r + M]
for i in range(m):
x, y = map(int, input().split())
x2 = (x + p)
y2 = (y + p)
graph[x] += [y2]
graph[y] += [x2]
for i in range(1, M):
graph[2 * p + i + M] += [2 * p + i + M + 1]
graph[2 * p + i + 1] += [2 * p + i]
cx = find_SCC(graph)
ans = []
for i in range(1, p + 1):
if cx[i] > cx[i + p]:
ans += [i]
if not ans:
print(-1)
quit()
for freq in range(M, 0, -1):
if cx[2 * p + freq] > cx[2 * p + freq + M]:
break
print(len(ans), freq)
print(*ans) | {
"input": [
"2 4 4 2\n1 3\n2 3\n1 4\n1 2\n3 4\n1 4\n1 2\n3 4\n",
"2 4 4 2\n1 3\n2 4\n1 2\n1 2\n3 4\n3 4\n1 2\n3 4\n"
],
"output": [
"2 3\n1 3 ",
"-1"
]
} |
493 | 7 | Recently Ivan the Fool decided to become smarter and study the probability theory. He thinks that he understands the subject fairly well, and so he began to behave like he already got PhD in that area.
To prove his skills, Ivan decided to demonstrate his friends a concept of random picture. A picture is a field of n rows and m columns, where each cell is either black or white. Ivan calls the picture random if for every cell it has at most one adjacent cell of the same color. Two cells are considered adjacent if they share a side.
Ivan's brothers spent some time trying to explain that it's not how the randomness usually works. Trying to convince Ivan, they want to count the number of different random (according to Ivan) pictures. Two pictures are considered different if at least one cell on those two picture is colored differently. Since the number of such pictures may be quite large, print it modulo 10^9 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 100 000), the number of rows and the number of columns of the field.
Output
Print one integer, the number of random pictures modulo 10^9 + 7.
Example
Input
2 3
Output
8
Note
The picture below shows all possible random pictures of size 2 by 3.
<image> | mod = 1000000007
n,m = map(int, input().split())
def fib(n):
a,b = 1,1
for i in range(n):
a,b = b,(a+b)%mod
return a
res = (2*(fib(n) + fib(m) - 1)) % mod
print(res)
| {
"input": [
"2 3\n"
],
"output": [
"8\n"
]
} |
494 | 9 | Let's call an array t dominated by value v in the next situation.
At first, array t should have at least 2 elements. Now, let's calculate number of occurrences of each number num in t and define it as occ(num). Then t is dominated (by v) if (and only if) occ(v) > occ(v') for any other number v'. For example, arrays [1, 2, 3, 4, 5, 2], [11, 11] and [3, 2, 3, 2, 3] are dominated (by 2, 11 and 3 respectevitely) but arrays [3], [1, 2] and [3, 3, 2, 2, 1] are not.
Small remark: since any array can be dominated only by one number, we can not specify this number and just say that array is either dominated or not.
You are given array a_1, a_2, ..., a_n. Calculate its shortest dominated subarray or say that there are no such subarrays.
The subarray of a is a contiguous part of the array a, i. e. the array a_i, a_{i + 1}, ..., a_j for some 1 β€ i β€ j β€ n.
Input
The first line contains single integer T (1 β€ T β€ 1000) β the number of test cases. Each test case consists of two lines.
The first line contains single integer n (1 β€ n β€ 2 β
10^5) β the length of the array a.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ n) β the corresponding values of the array a.
It's guaranteed that the total length of all arrays in one test doesn't exceed 2 β
10^5.
Output
Print T integers β one per test case. For each test case print the only integer β the length of the shortest dominated subarray, or -1 if there are no such subarrays.
Example
Input
4
1
1
6
1 2 3 4 5 1
9
4 1 2 4 5 4 3 2 1
4
3 3 3 3
Output
-1
6
3
2
Note
In the first test case, there are no subarrays of length at least 2, so the answer is -1.
In the second test case, the whole array is dominated (by 1) and it's the only dominated subarray.
In the third test case, the subarray a_4, a_5, a_6 is the shortest dominated subarray.
In the fourth test case, all subarrays of length more than one are dominated. | def dominated(n,l):
p={}
m=n+1
for i in range(n):
if l[i] in p.keys():
m=min(m,i-p[l[i]]+1)
p[l[i]]=i
return m if m!=n+1 else -1
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
print(dominated(n,l)) | {
"input": [
"4\n1\n1\n6\n1 2 3 4 5 1\n9\n4 1 2 4 5 4 3 2 1\n4\n3 3 3 3\n"
],
"output": [
"-1\n6\n3\n2\n"
]
} |
495 | 9 | Anu has created her own function f: f(x, y) = (x | y) - y where | denotes the [bitwise OR operation](https://en.wikipedia.org/wiki/Bitwise_operation#OR). For example, f(11, 6) = (11|6) - 6 = 15 - 6 = 9. It can be proved that for any nonnegative numbers x and y value of f(x, y) is also nonnegative.
She would like to research more about this function and has created multiple problems for herself. But she isn't able to solve all of them and needs your help. Here is one of these problems.
A value of an array [a_1, a_2, ..., a_n] is defined as f(f(... f(f(a_1, a_2), a_3), ... a_{n-1}), a_n) (see notes). You are given an array with not necessarily distinct elements. How should you reorder its elements so that the value of the array is maximal possible?
Input
The first line contains a single integer n (1 β€ n β€ 10^5).
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 10^9). Elements of the array are not guaranteed to be different.
Output
Output n integers, the reordering of the array with maximum value. If there are multiple answers, print any.
Examples
Input
4
4 0 11 6
Output
11 6 4 0
Input
1
13
Output
13
Note
In the first testcase, value of the array [11, 6, 4, 0] is f(f(f(11, 6), 4), 0) = f(f(9, 4), 0) = f(9, 0) = 9.
[11, 4, 0, 6] is also a valid answer. | def main():
n = int(input().strip())
A = [int(s) for s in input().strip().split()]
for i in range(31, -1, -1):
if sum((a >> i) & 1 for a in A) == 1:
break
for j, a in enumerate(A):
if (a >> i) & 1:
break
result = [A[j]] + A[:j] + A[j + 1:]
print(" ".join(str(x) for x in result))
main()
| {
"input": [
"1\n13\n",
"4\n4 0 11 6\n"
],
"output": [
"13\n",
"11 4 0 6 \n"
]
} |
496 | 10 | The next lecture in a high school requires two topics to be discussed. The i-th topic is interesting by a_i units for the teacher and by b_i units for the students.
The pair of topics i and j (i < j) is called good if a_i + a_j > b_i + b_j (i.e. it is more interesting for the teacher).
Your task is to find the number of good pairs of topics.
Input
The first line of the input contains one integer n (2 β€ n β€ 2 β
10^5) β the number of topics.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the interestingness of the i-th topic for the teacher.
The third line of the input contains n integers b_1, b_2, ..., b_n (1 β€ b_i β€ 10^9), where b_i is the interestingness of the i-th topic for the students.
Output
Print one integer β the number of good pairs of topic.
Examples
Input
5
4 8 2 6 2
4 5 4 1 3
Output
7
Input
4
1 3 2 4
1 3 2 4
Output
0 | import bisect
def f(n):
return (n*(n+1))//2
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=[a[i]-b[i] for i in range(n)]
c.sort()
ans=0
for i in range(n):
x=1-c[i]
j=bisect.bisect_left(c,x,i+1,n)
ans+=n-j
print(ans) | {
"input": [
"4\n1 3 2 4\n1 3 2 4\n",
"5\n4 8 2 6 2\n4 5 4 1 3\n"
],
"output": [
"0\n",
"7\n"
]
} |
497 | 9 | Recall that the sequence b is a a subsequence of the sequence a if b can be derived from a by removing zero or more elements without changing the order of the remaining elements. For example, if a=[1, 2, 1, 3, 1, 2, 1], then possible subsequences are: [1, 1, 1, 1], [3] and [1, 2, 1, 3, 1, 2, 1], but not [3, 2, 3] and [1, 1, 1, 1, 2].
You are given a sequence a consisting of n positive and negative elements (there is no zeros in the sequence).
Your task is to choose maximum by size (length) alternating subsequence of the given sequence (i.e. the sign of each next element is the opposite from the sign of the current element, like positive-negative-positive and so on or negative-positive-negative and so on). Among all such subsequences, you have to choose one which has the maximum sum of elements.
In other words, if the maximum length of alternating subsequence is k then your task is to find the maximum sum of elements of some alternating subsequence of length k.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 β€ n β€ 2 β
10^5) β the number of elements in a. The second line of the test case contains n integers a_1, a_2, ..., a_n (-10^9 β€ a_i β€ 10^9, a_i β 0), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer β the maximum sum of the maximum by size (length) alternating subsequence of a.
Example
Input
4
5
1 2 3 -1 -2
4
-1 -2 -1 -3
10
-2 8 3 8 -4 -15 5 -2 -3 1
6
1 -1000000000 1 -1000000000 1 -1000000000
Output
2
-1
6
-2999999997
Note
In the first test case of the example, one of the possible answers is [1, 2, \underline{3}, \underline{-1}, -2].
In the second test case of the example, one of the possible answers is [-1, -2, \underline{-1}, -3].
In the third test case of the example, one of the possible answers is [\underline{-2}, 8, 3, \underline{8}, \underline{-4}, -15, \underline{5}, \underline{-2}, -3, \underline{1}].
In the fourth test case of the example, one of the possible answers is [\underline{1}, \underline{-1000000000}, \underline{1}, \underline{-1000000000}, \underline{1}, \underline{-1000000000}]. | def solve():
n=int(input())
lis=list(map(int,input().split()))
j=0
ans=0
for i,v in enumerate(lis[1:],1):
if v*lis[j]<0:
ans+=max(lis[j:i])
j=i
ans+=max(lis[j:])
print(ans)
t=int(input())
for i in range(t):
solve()
| {
"input": [
"4\n5\n1 2 3 -1 -2\n4\n-1 -2 -1 -3\n10\n-2 8 3 8 -4 -15 5 -2 -3 1\n6\n1 -1000000000 1 -1000000000 1 -1000000000\n"
],
"output": [
"2\n-1\n6\n-2999999997\n"
]
} |
498 | 10 | Vivek has encountered a problem. He has a maze that can be represented as an n Γ m grid. Each of the grid cells may represent the following:
* Empty β '.'
* Wall β '#'
* Good person β 'G'
* Bad person β 'B'
The only escape from the maze is at cell (n, m).
A person can move to a cell only if it shares a side with their current cell and does not contain a wall. Vivek wants to block some of the empty cells by replacing them with walls in such a way, that all the good people are able to escape, while none of the bad people are able to. A cell that initially contains 'G' or 'B' cannot be blocked and can be travelled through.
Help him determine if there exists a way to replace some (zero or more) empty cells with walls to satisfy the above conditions.
It is guaranteed that the cell (n,m) is empty. Vivek can also block this cell.
Input
The first line contains one integer t (1 β€ t β€ 100) β the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n, m (1 β€ n, m β€ 50) β the number of rows and columns in the maze.
Each of the next n lines contain m characters. They describe the layout of the maze. If a character on a line equals '.', the corresponding cell is empty. If it equals '#', the cell has a wall. 'G' corresponds to a good person and 'B' corresponds to a bad person.
Output
For each test case, print "Yes" if there exists a way to replace some empty cells with walls to satisfy the given conditions. Otherwise print "No"
You may print every letter in any case (upper or lower).
Example
Input
6
1 1
.
1 2
G.
2 2
#B
G.
2 3
G.#
B#.
3 3
#B.
#..
GG.
2 2
#B
B.
Output
Yes
Yes
No
No
Yes
Yes
Note
For the first and second test cases, all conditions are already satisfied.
For the third test case, there is only one empty cell (2,2), and if it is replaced with a wall then the good person at (1,2) will not be able to escape.
For the fourth test case, the good person at (1,1) cannot escape.
For the fifth test case, Vivek can block the cells (2,3) and (2,2).
For the last test case, Vivek can block the destination cell (2, 2). | from math import *
def r1(t):
return t(input())
def r2(t):
return [t(i) for i in input().split()]
def r3(t):
return [t(i) for i in input()]
g=[]
def dfs(i,j,n,m):
if g[i][j]=='#':
return 0
ans=0
if g[i][j]=='G':
ans+=1
if g[i][j]=='B':
return -100000
g[i][j]='#'
if (i>0):
ans+=dfs(i-1,j,n,m)
if (i<n-1):
ans+=dfs(i+1,j,n,m)
if (j>0):
ans+=dfs(i,j-1,n,m)
if (j<m-1):
ans+=dfs(i,j+1,n,m)
return ans
for _ in range(r1(int)):
n,m=r2(int)
g=[]
used=[]
for i in range(n):
g.append(r3(str))
cnt=0
for i in range(n):
for j in range(m):
if g[i][j]=='B':
if (i>0) and g[i-1][j]=='.':
g[i-1][j]='#'
if (i<n-1) and g[i+1][j]=='.':
g[i+1][j]='#'
if (j>0) and g[i][j-1]=='.':
g[i][j-1]='#'
if (j<m-1) and g[i][j+1]=='.':
g[i][j+1]='#'
elif g[i][j]=='G':
cnt+=1
if (dfs(n-1,m-1,n,m)==cnt):
print("Yes")
else:
print("No")
| {
"input": [
"6\n1 1\n.\n1 2\nG.\n2 2\n#B\nG.\n2 3\nG.#\nB#.\n3 3\n#B.\n#..\nGG.\n2 2\n#B\nB.\n"
],
"output": [
"Yes\nYes\nNo\nNo\nYes\nYes\n"
]
} |
499 | 10 | You are given a string s[1 ... n] consisting of lowercase Latin letters. It is guaranteed that n = 2^k for some integer k β₯ 0.
The string s[1 ... n] is called c-good if at least one of the following three conditions is satisfied:
* The length of s is 1, and it consists of the character c (i.e. s_1=c);
* The length of s is greater than 1, the first half of the string consists of only the character c (i.e. s_1=s_2=...=s_{n/2}=c) and the second half of the string (i.e. the string s_{n/2 + 1}s_{n/2 + 2} ... s_n) is a (c+1)-good string;
* The length of s is greater than 1, the second half of the string consists of only the character c (i.e. s_{n/2 + 1}=s_{n/2 + 2}=...=s_n=c) and the first half of the string (i.e. the string s_1s_2 ... s_{n/2}) is a (c+1)-good string.
For example: "aabc" is 'a'-good, "ffgheeee" is 'e'-good.
In one move, you can choose one index i from 1 to n and replace s_i with any lowercase Latin letter (any character from 'a' to 'z').
Your task is to find the minimum number of moves required to obtain an 'a'-good string from s (i.e. c-good string for c= 'a'). It is guaranteed that the answer always exists.
You have to answer t independent test cases.
Another example of an 'a'-good string is as follows. Consider the string s = "cdbbaaaa". It is an 'a'-good string, because:
* the second half of the string ("aaaa") consists of only the character 'a';
* the first half of the string ("cdbb") is 'b'-good string, because:
* the second half of the string ("bb") consists of only the character 'b';
* the first half of the string ("cd") is 'c'-good string, because:
* the first half of the string ("c") consists of only the character 'c';
* the second half of the string ("d") is 'd'-good string.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 β€ n β€ 131~072) β the length of s. It is guaranteed that n = 2^k for some integer k β₯ 0. The second line of the test case contains the string s consisting of n lowercase Latin letters.
It is guaranteed that the sum of n does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer β the minimum number of moves required to obtain an 'a'-good string from s (i.e. c-good string with c = 'a'). It is guaranteed that the answer exists.
Example
Input
6
8
bbdcaaaa
8
asdfghjk
8
ceaaaabb
8
bbaaddcc
1
z
2
ac
Output
0
7
4
5
1
1 | def f(s,c):n=len(s)//2;m=n or 1;return s>''and min(m-s.count(chr(c),i,i+m)+f(s[n-i:][:n],c+1)for
i in{0,n})
for s in[*open(0)][2::2]:print(f(s[:-1],97)) | {
"input": [
"6\n8\nbbdcaaaa\n8\nasdfghjk\n8\nceaaaabb\n8\nbbaaddcc\n1\nz\n2\nac\n"
],
"output": [
"0\n7\n4\n5\n1\n1\n"
]
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.