index
int64 0
5.16k
| difficulty
int64 7
12
| question
stringlengths 126
7.12k
| solution
stringlengths 30
18.6k
| test_cases
dict |
|---|---|---|---|---|
2,900 | 10 | For his computer science class, Jacob builds a model tree with sticks and balls containing n nodes in the shape of a tree. Jacob has spent ai minutes building the i-th ball in the tree.
Jacob's teacher will evaluate his model and grade Jacob based on the effort he has put in. However, she does not have enough time to search his whole tree to determine this; Jacob knows that she will examine the first k nodes in a DFS-order traversal of the tree. She will then assign Jacob a grade equal to the minimum ai she finds among those k nodes.
Though Jacob does not have enough time to rebuild his model, he can choose the root node that his teacher starts from. Furthermore, he can rearrange the list of neighbors of each node in any order he likes. Help Jacob find the best grade he can get on this assignment.
A DFS-order traversal is an ordering of the nodes of a rooted tree, built by a recursive DFS-procedure initially called on the root of the tree. When called on a given node v, the procedure does the following:
1. Print v.
2. Traverse the list of neighbors of the node v in order and iteratively call DFS-procedure on each one. Do not call DFS-procedure on node u if you came to node v directly from u.
Input
The first line of the input contains two positive integers, n and k (2 β€ n β€ 200 000, 1 β€ k β€ n) β the number of balls in Jacob's tree and the number of balls the teacher will inspect.
The second line contains n integers, ai (1 β€ ai β€ 1 000 000), the time Jacob used to build the i-th ball.
Each of the next n - 1 lines contains two integers ui, vi (1 β€ ui, vi β€ n, ui β vi) representing a connection in Jacob's tree between balls ui and vi.
Output
Print a single integer β the maximum grade Jacob can get by picking the right root of the tree and rearranging the list of neighbors.
Examples
Input
5 3
3 6 1 4 2
1 2
2 4
2 5
1 3
Output
3
Input
4 2
1 5 5 5
1 2
1 3
1 4
Output
1
Note
In the first sample, Jacob can root the tree at node 2 and order 2's neighbors in the order 4, 1, 5 (all other nodes have at most two neighbors). The resulting preorder traversal is 2, 4, 1, 3, 5, and the minimum ai of the first 3 nodes is 3.
In the second sample, it is clear that any preorder traversal will contain node 1 as either its first or second node, so Jacob cannot do better than a grade of 1. | import sys
input = sys.stdin.readline
n, k = map(int, input().split())
a = [int(i) for i in input().split()]
g = [[] for _ in range(n)]
for i in range(n - 1):
u, v = map(int, input().split())
g[u-1].append(v-1)
g[v-1].append(u-1)
stack = [0]
done = [False] * n
par = [0] * n
order = []
while len(stack) > 0:
x = stack.pop()
done[x] = True
order.append(x)
for i in g[x]:
if done[i] == False:
par[i] = x
stack.append(i)
order = order[::-1]
sub = [0] * n
for i in order:
sub[i] = 1
for j in g[i]:
if par[j] == i:
sub[i] += sub[j]
def good(guess):
cnt = [0] * n
for i in order:
if a[i] < guess:
continue
cnt[i] = 1
opt = 0
for j in g[i]:
if par[j] == i:
if cnt[j] == sub[j]:
cnt[i] += cnt[j]
else:
opt = max(opt, cnt[j])
cnt[i] += opt
if cnt[0] >= k:
return True
up = [0] * n
for i in order[::-1]:
if a[i] < guess:
continue
opt, secondOpt = 0, 0
total = 1
for j in g[i]:
val, size = 0, 0
if par[j] == i:
val = cnt[j]
size = sub[j]
else:
val = up[i]
size = n - sub[i]
if val == size:
total += val
else:
if opt < val:
opt, secondOpt = val, opt
elif secondOpt < val:
secondOpt = val
for j in g[i]:
if par[j] == i:
up[j] = total
add = opt
if sub[j] == cnt[j]:
up[j] -= cnt[j]
elif cnt[j] == opt:
add = secondOpt
up[j] += add
for i in range(n):
if a[i] < guess:
continue
total, opt = 1, 0
for j in g[i]:
val, size = 0, 0
if par[j] == i:
val = cnt[j]
size = sub[j]
else:
val = up[i]
size = n - sub[i]
if val == size:
total += val
else:
opt = max(opt, val)
if total + opt >= k:
return True
return False
l, r = 0, max(a)
while l < r:
mid = (l + r + 1) // 2
if good(mid):
l = mid
else:
r = mid - 1
print(l) | {
"input": [
"4 2\n1 5 5 5\n1 2\n1 3\n1 4\n",
"5 3\n3 6 1 4 2\n1 2\n2 4\n2 5\n1 3\n"
],
"output": [
"1\n",
"3\n"
]
} |
2,901 | 10 | Vasya's telephone contains n photos. Photo number 1 is currently opened on the phone. It is allowed to move left and right to the adjacent photo by swiping finger over the screen. If you swipe left from the first photo, you reach photo n. Similarly, by swiping right from the last photo you reach photo 1. It takes a seconds to swipe from photo to adjacent.
For each photo it is known which orientation is intended for it β horizontal or vertical. Phone is in the vertical orientation and can't be rotated. It takes b second to change orientation of the photo.
Vasya has T seconds to watch photos. He want to watch as many photos as possible. If Vasya opens the photo for the first time, he spends 1 second to notice all details in it. If photo is in the wrong orientation, he spends b seconds on rotating it before watching it. If Vasya has already opened the photo, he just skips it (so he doesn't spend any time for watching it or for changing its orientation). It is not allowed to skip unseen photos.
Help Vasya find the maximum number of photos he is able to watch during T seconds.
Input
The first line of the input contains 4 integers n, a, b, T (1 β€ n β€ 5Β·105, 1 β€ a, b β€ 1000, 1 β€ T β€ 109) β the number of photos, time to move from a photo to adjacent, time to change orientation of a photo and time Vasya can spend for watching photo.
Second line of the input contains a string of length n containing symbols 'w' and 'h'.
If the i-th position of a string contains 'w', then the photo i should be seen in the horizontal orientation.
If the i-th position of a string contains 'h', then the photo i should be seen in vertical orientation.
Output
Output the only integer, the maximum number of photos Vasya is able to watch during those T seconds.
Examples
Input
4 2 3 10
wwhw
Output
2
Input
5 2 4 13
hhwhh
Output
4
Input
5 2 4 1000
hhwhh
Output
5
Input
3 1 100 10
whw
Output
0
Note
In the first sample test you can rotate the first photo (3 seconds), watch the first photo (1 seconds), move left (2 second), rotate fourth photo (3 seconds), watch fourth photo (1 second). The whole process takes exactly 10 seconds.
Note that in the last sample test the time is not enough even to watch the first photo, also you can't skip it. | #! /usr/bin/env python3
def main():
n, a, b, t = map(int, input().split())
oris = input()
def get_time(front, rear, count_rot):
span = front - rear
offset = min(front, -rear)
return span, span * a + (span + 1) + offset * a + count_rot * b
front = rear = span = count_rot = new_count_rot = time = 0
has_one = False
for i in range(0, -n, -1):
if oris[i] == 'w':
new_count_rot += 1
new_span, new_time = get_time(front, i, new_count_rot)
if new_time > t:
break
has_one = True
span, time, rear, count_rot = new_span, new_time, i, new_count_rot
if not has_one:
return 0
maxi = max_span = n - 1
while front < maxi and rear <= 0 and span != max_span:
front += 1
if oris[front] == 'w':
count_rot += 1
while True:
new_span, time = get_time(front, rear, count_rot)
if time <= t:
break
if oris[rear] == 'w':
count_rot -= 1
rear += 1
if rear > 0:
return span + 1
span = max(new_span, span)
return span + 1
print(main())
| {
"input": [
"5 2 4 1000\nhhwhh\n",
"5 2 4 13\nhhwhh\n",
"4 2 3 10\nwwhw\n",
"3 1 100 10\nwhw\n"
],
"output": [
"5",
"4",
"2",
"0"
]
} |
2,902 | 8 | Vanya smashes potato in a vertical food processor. At each moment of time the height of the potato in the processor doesn't exceed h and the processor smashes k centimeters of potato each second. If there are less than k centimeters remaining, than during this second processor smashes all the remaining potato.
Vanya has n pieces of potato, the height of the i-th piece is equal to ai. He puts them in the food processor one by one starting from the piece number 1 and finishing with piece number n. Formally, each second the following happens:
1. If there is at least one piece of potato remaining, Vanya puts them in the processor one by one, until there is not enough space for the next piece.
2. Processor smashes k centimeters of potato (or just everything that is inside).
Provided the information about the parameter of the food processor and the size of each potato in a row, compute how long will it take for all the potato to become smashed.
Input
The first line of the input contains integers n, h and k (1 β€ n β€ 100 000, 1 β€ k β€ h β€ 109) β the number of pieces of potato, the height of the food processor and the amount of potato being smashed each second, respectively.
The second line contains n integers ai (1 β€ ai β€ h) β the heights of the pieces.
Output
Print a single integer β the number of seconds required to smash all the potatoes following the process described in the problem statement.
Examples
Input
5 6 3
5 4 3 2 1
Output
5
Input
5 6 3
5 5 5 5 5
Output
10
Input
5 6 3
1 2 1 1 1
Output
2
Note
Consider the first sample.
1. First Vanya puts the piece of potato of height 5 into processor. At the end of the second there is only amount of height 2 remaining inside.
2. Now Vanya puts the piece of potato of height 4. At the end of the second there is amount of height 3 remaining.
3. Vanya puts the piece of height 3 inside and again there are only 3 centimeters remaining at the end of this second.
4. Vanya finally puts the pieces of height 2 and 1 inside. At the end of the second the height of potato in the processor is equal to 3.
5. During this second processor finally smashes all the remaining potato and the process finishes.
In the second sample, Vanya puts the piece of height 5 inside and waits for 2 seconds while it is completely smashed. Then he repeats the same process for 4 other pieces. The total time is equal to 2Β·5 = 10 seconds.
In the third sample, Vanya simply puts all the potato inside the processor and waits 2 seconds. | import sys
input = sys.stdin.readline
def main():
n,h,k = map(int,input().split())
l = list(map(int,input().split()))
ret = 0
rem = 0
for a in l:
ret += rem//k
rem %= k
if rem + a <= h:
rem += a
else:
ret += 1
rem = a
ret += (rem+k-1)//k
print(ret)
main()
| {
"input": [
"5 6 3\n5 5 5 5 5\n",
"5 6 3\n1 2 1 1 1\n",
"5 6 3\n5 4 3 2 1\n"
],
"output": [
"10\n",
"2\n",
"5\n"
]
} |
2,903 | 8 | President of Berland has a very vast office-room, where, apart from him, work his subordinates. Each subordinate, as well as President himself, has his own desk of a unique colour. Each desk is rectangular, and its sides are parallel to the office walls. One day President decided to establish an assembly, of which all his deputies will be members. Unfortunately, he does not remember the exact amount of his deputies, but he remembers that the desk of each his deputy is adjacent to his own desk, that is to say, the two desks (President's and each deputy's) have a common side of a positive length.
The office-room plan can be viewed as a matrix with n rows and m columns. Each cell of this matrix is either empty, or contains a part of a desk. An uppercase Latin letter stands for each desk colour. The Β«periodΒ» character (Β«.Β») stands for an empty cell.
Input
The first line contains two separated by a space integer numbers n, m (1 β€ n, m β€ 100) β the length and the width of the office-room, and c character β the President's desk colour. The following n lines contain m characters each β the office-room description. It is guaranteed that the colour of each desk is unique, and each desk represents a continuous subrectangle of the given matrix. All colours are marked by uppercase Latin letters.
Output
Print the only number β the amount of President's deputies.
Examples
Input
3 4 R
G.B.
.RR.
TTT.
Output
2
Input
3 3 Z
...
.H.
..Z
Output
0 | def main():
*l, c = input().split()
n, m = map(int, l)
l, s = [input() for _ in range(n)], {c, '.'}
for _ in 1, 2:
for r1, r2 in zip(l, l[1:]):
for a, b in zip(r1, r2):
if a == c:
s.add(b)
if b == c:
s.add(a)
l = list(zip(*l))
print(len(s) - 2)
if __name__ == '__main__':
main()
| {
"input": [
"3 4 R\nG.B.\n.RR.\nTTT.\n",
"3 3 Z\n...\n.H.\n..Z\n"
],
"output": [
"2\n",
"0\n"
]
} |
2,904 | 10 | Recently Maxim has found an array of n integers, needed by no one. He immediately come up with idea of changing it: he invented positive integer x and decided to add or subtract it from arbitrary array elements. Formally, by applying single operation Maxim chooses integer i (1 β€ i β€ n) and replaces the i-th element of array ai either with ai + x or with ai - x. Please note that the operation may be applied more than once to the same position.
Maxim is a curious minimalis, thus he wants to know what is the minimum value that the product of all array elements (i.e. <image>) can reach, if Maxim would apply no more than k operations to it. Please help him in that.
Input
The first line of the input contains three integers n, k and x (1 β€ n, k β€ 200 000, 1 β€ x β€ 109) β the number of elements in the array, the maximum number of operations and the number invented by Maxim, respectively.
The second line contains n integers a1, a2, ..., an (<image>) β the elements of the array found by Maxim.
Output
Print n integers b1, b2, ..., bn in the only line β the array elements after applying no more than k operations to the array. In particular, <image> should stay true for every 1 β€ i β€ n, but the product of all array elements should be minimum possible.
If there are multiple answers, print any of them.
Examples
Input
5 3 1
5 4 3 5 2
Output
5 4 3 5 -1
Input
5 3 1
5 4 3 5 5
Output
5 4 0 5 5
Input
5 3 1
5 4 4 5 5
Output
5 1 4 5 5
Input
3 2 7
5 4 2
Output
5 11 -5 | def main():
from heapq import heapify, heappop, heappushpop,heappush
n, k, x = map(int, input().split())
l, sign, h = list(map(int, input().split())), [False] * n, []
helper = lambda: print(' '.join(str(-a if s else a) for a, s in zip(l, sign)))
for i, a in enumerate(l):
if a < 0:
sign[i] = True
h.append((-a, i))
else:
h.append((a, i))
heapify(h)
a, i = heappop(h)
if 1 - sum(sign) % 2:
j = min(a // x + (1 if a % x else 0), k)
a -= j * x
if a > 0:
l[i] = a
return helper()
k -= j
a = -a
sign[i] ^= True
for _ in range(k):
a, i = heappushpop(h, (a, i))
a += x
l[i] = a
for a, i in h:
l[i] = a
helper()
if __name__ == '__main__':
main()
| {
"input": [
"3 2 7\n5 4 2\n",
"5 3 1\n5 4 4 5 5\n",
"5 3 1\n5 4 3 5 2\n",
"5 3 1\n5 4 3 5 5\n"
],
"output": [
"5 11 -5 \n",
"5 1 4 5 5 \n",
"5 4 3 5 -1 \n",
"5 4 0 5 5 \n"
]
} |
2,905 | 8 | Chloe, the same as Vladik, is a competitive programmer. She didn't have any problems to get to the olympiad like Vladik, but she was confused by the task proposed on the olympiad.
Let's consider the following algorithm of generating a sequence of integers. Initially we have a sequence consisting of a single element equal to 1. Then we perform (n - 1) steps. On each step we take the sequence we've got on the previous step, append it to the end of itself and insert in the middle the minimum positive integer we haven't used before. For example, we get the sequence [1, 2, 1] after the first step, the sequence [1, 2, 1, 3, 1, 2, 1] after the second step.
The task is to find the value of the element with index k (the elements are numbered from 1) in the obtained sequence, i. e. after (n - 1) steps.
Please help Chloe to solve the problem!
Input
The only line contains two integers n and k (1 β€ n β€ 50, 1 β€ k β€ 2n - 1).
Output
Print single integer β the integer at the k-th position in the obtained sequence.
Examples
Input
3 2
Output
2
Input
4 8
Output
4
Note
In the first sample the obtained sequence is [1, 2, 1, 3, 1, 2, 1]. The number on the second position is 2.
In the second sample the obtained sequence is [1, 2, 1, 3, 1, 2, 1, 4, 1, 2, 1, 3, 1, 2, 1]. The number on the eighth position is 4. | n,k=map(int,input().split())
def cal(n,k):
if(k==2**(n-1)):
print(n)
else:
cal(n-1,k%2**(n-1))
cal(n,k) | {
"input": [
"4 8\n",
"3 2\n"
],
"output": [
"4\n",
"2\n"
]
} |
2,906 | 10 | Mahmoud wants to write a new dictionary that contains n words and relations between them. There are two types of relations: synonymy (i. e. the two words mean the same) and antonymy (i. e. the two words mean the opposite). From time to time he discovers a new relation between two words.
He know that if two words have a relation between them, then each of them has relations with the words that has relations with the other. For example, if like means love and love is the opposite of hate, then like is also the opposite of hate. One more example: if love is the opposite of hate and hate is the opposite of like, then love means like, and so on.
Sometimes Mahmoud discovers a wrong relation. A wrong relation is a relation that makes two words equal and opposite at the same time. For example if he knows that love means like and like is the opposite of hate, and then he figures out that hate means like, the last relation is absolutely wrong because it makes hate and like opposite and have the same meaning at the same time.
After Mahmoud figured out many relations, he was worried that some of them were wrong so that they will make other relations also wrong, so he decided to tell every relation he figured out to his coder friend Ehab and for every relation he wanted to know is it correct or wrong, basing on the previously discovered relations. If it is wrong he ignores it, and doesn't check with following relations.
After adding all relations, Mahmoud asked Ehab about relations between some words based on the information he had given to him. Ehab is busy making a Codeforces round so he asked you for help.
Input
The first line of input contains three integers n, m and q (2 β€ n β€ 105, 1 β€ m, q β€ 105) where n is the number of words in the dictionary, m is the number of relations Mahmoud figured out and q is the number of questions Mahmoud asked after telling all relations.
The second line contains n distinct words a1, a2, ..., an consisting of small English letters with length not exceeding 20, which are the words in the dictionary.
Then m lines follow, each of them contains an integer t (1 β€ t β€ 2) followed by two different words xi and yi which has appeared in the dictionary words. If t = 1, that means xi has a synonymy relation with yi, otherwise xi has an antonymy relation with yi.
Then q lines follow, each of them contains two different words which has appeared in the dictionary. That are the pairs of words Mahmoud wants to know the relation between basing on the relations he had discovered.
All words in input contain only lowercase English letters and their lengths don't exceed 20 characters. In all relations and in all questions the two words are different.
Output
First, print m lines, one per each relation. If some relation is wrong (makes two words opposite and have the same meaning at the same time) you should print "NO" (without quotes) and ignore it, otherwise print "YES" (without quotes).
After that print q lines, one per each question. If the two words have the same meaning, output 1. If they are opposites, output 2. If there is no relation between them, output 3.
See the samples for better understanding.
Examples
Input
3 3 4
hate love like
1 love like
2 love hate
1 hate like
love like
love hate
like hate
hate like
Output
YES
YES
NO
1
2
2
2
Input
8 6 5
hi welcome hello ihateyou goaway dog cat rat
1 hi welcome
1 ihateyou goaway
2 hello ihateyou
2 hi goaway
2 hi hello
1 hi hello
dog cat
dog hi
hi hello
ihateyou goaway
welcome ihateyou
Output
YES
YES
YES
YES
NO
YES
3
3
1
1
2 | f = lambda: input().split()
n, m, k = map(int, f())
u = list(range(n + 1))
v = [n] * n
s = {q: i for i, q in zip(u, f())}
p = ['YES'] * m
def g(i):
k = u[i]
while k != u[k]: k = u[k]
while u[i] != k: i, u[i] = u[i], k
return k
for l in range(m):
r, x, y = f()
i, j = s[x], s[y]
a, b = g(i), g(j)
i, j = v[a], v[b]
c, d = g(i), g(j)
if r == '2': b, d = d, b
if a == d: p[l] = 'NO'
elif c == b == n: v[a], v[d] = d, a
elif c == b: p[l] = 'NO'
elif c == n: u[a] = b
elif b == n: u[d] = c
elif d == n: u[b] = a
else: u[a], u[c] = b, d
u = [g(q) for q in u]
v = [u[q] for q in v]
for l in range(k):
x, y = f()
i, j = s[x], s[y]
a, c = u[i], u[j]
p.append(str(3 - 2 * (a == c) - (a == v[c])))
print('\n'.join(p)) | {
"input": [
"8 6 5\nhi welcome hello ihateyou goaway dog cat rat\n1 hi welcome\n1 ihateyou goaway\n2 hello ihateyou\n2 hi goaway\n2 hi hello\n1 hi hello\ndog cat\ndog hi\nhi hello\nihateyou goaway\nwelcome ihateyou\n",
"3 3 4\nhate love like\n1 love like\n2 love hate\n1 hate like\nlove like\nlove hate\nlike hate\nhate like\n"
],
"output": [
"YES\nYES\nYES\nYES\nNO\nYES\n3\n3\n1\n1\n2\n",
"YES\nYES\nNO\n1\n2\n2\n2\n"
]
} |
2,907 | 9 | Two beavers, Timur and Marsel, play the following game.
There are n logs, each of exactly m meters in length. The beavers move in turns. For each move a beaver chooses a log and gnaws it into some number (more than one) of equal parts, the length of each one is expressed by an integer and is no less than k meters. Each resulting part is also a log which can be gnawed in future by any beaver. The beaver that can't make a move loses. Thus, the other beaver wins.
Timur makes the first move. The players play in the optimal way. Determine the winner.
Input
The first line contains three integers n, m, k (1 β€ n, m, k β€ 109).
Output
Print "Timur", if Timur wins, or "Marsel", if Marsel wins. You should print everything without the quotes.
Examples
Input
1 15 4
Output
Timur
Input
4 9 5
Output
Marsel
Note
In the first sample the beavers only have one log, of 15 meters in length. Timur moves first. The only move he can do is to split the log into 3 parts each 5 meters in length. Then Marsel moves but he can't split any of the resulting logs, as k = 4. Thus, the winner is Timur.
In the second example the beavers have 4 logs 9 meters in length. Timur can't split any of them, so that the resulting parts possessed the length of not less than 5 meters, that's why he loses instantly. | def check(a, b, c):
return (b <= a and a < c)
def can(n, m, k):
if n % 2 == 0:
return False
d = 1
while d*d <= m:
if m % d == 0 and (check(d, k, m) or check(m/d, k, m)):
return True
d += 1
return False
n, m, k = map(int, input().split(' '))
print ('Timur' if can(n, m, k) else 'Marsel')
| {
"input": [
"1 15 4\n",
"4 9 5\n"
],
"output": [
"Timur\n",
"Marsel\n"
]
} |
2,908 | 8 | The flag of Berland is such rectangular field n Γ m that satisfies following conditions:
* Flag consists of three colors which correspond to letters 'R', 'G' and 'B'.
* Flag consists of three equal in width and height stripes, parralel to each other and to sides of the flag. Each stripe has exactly one color.
* Each color should be used in exactly one stripe.
You are given a field n Γ m, consisting of characters 'R', 'G' and 'B'. Output "YES" (without quotes) if this field corresponds to correct flag of Berland. Otherwise, print "NO" (without quotes).
Input
The first line contains two integer numbers n and m (1 β€ n, m β€ 100) β the sizes of the field.
Each of the following n lines consisting of m characters 'R', 'G' and 'B' β the description of the field.
Output
Print "YES" (without quotes) if the given field corresponds to correct flag of Berland . Otherwise, print "NO" (without quotes).
Examples
Input
6 5
RRRRR
RRRRR
BBBBB
BBBBB
GGGGG
GGGGG
Output
YES
Input
4 3
BRG
BRG
BRG
BRG
Output
YES
Input
6 7
RRRGGGG
RRRGGGG
RRRGGGG
RRRBBBB
RRRBBBB
RRRBBBB
Output
NO
Input
4 4
RRRR
RRRR
BBBB
GGGG
Output
NO
Note
The field in the third example doesn't have three parralel stripes.
Rows of the field in the fourth example are parralel to each other and to borders. But they have different heights β 2, 1 and 1. | def c(f, n, m):
if n % 3 != 0:return 0
s=n//3;s=f[0],f[s],f[2*s]
if set(s)!=set(map(lambda x:x*m,'RGB')):return 0
for i in range(n):
if f[i] != s[i*3 // n]:return 0
return 1
n,m=map(int, input().split())
f=[input() for _ in range(n)]
print('Yes'if c(f,n,m) or c([''.join(f[j][i] for j in range(n)) for i in range(m)],m,n)else'No')
| {
"input": [
"6 5\nRRRRR\nRRRRR\nBBBBB\nBBBBB\nGGGGG\nGGGGG\n",
"4 4\nRRRR\nRRRR\nBBBB\nGGGG\n",
"6 7\nRRRGGGG\nRRRGGGG\nRRRGGGG\nRRRBBBB\nRRRBBBB\nRRRBBBB\n",
"4 3\nBRG\nBRG\nBRG\nBRG\n"
],
"output": [
"YES\n",
"NO\n",
"NO\n",
"YES\n"
]
} |
2,909 | 11 | This is an interactive problem.
Bob lives in a square grid of size n Γ n, with rows numbered 1 through n from top to bottom, and columns numbered 1 through n from left to right. Every cell is either allowed or blocked, but you don't know the exact description of the grid. You are given only an integer n.
Bob can move through allowed cells but only in some limited directions. When Bob is in an allowed cell in the grid, he can move down or right to an adjacent cell, if it is allowed.
You can ask at most 4 β
n queries of form "? r_1 c_1 r_2 c_2" (1 β€ r_1 β€ r_2 β€ n, 1 β€ c_1 β€ c_2 β€ n). The answer will be "YES" if Bob can get from a cell (r_1, c_1) to a cell (r_2, c_2), and "NO" otherwise. In particular, if one of the two cells (or both) is a blocked cell then the answer is "NO" for sure. Since Bob doesn't like short trips, you can only ask queries with the manhattan distance between the two cells at least n - 1, i.e. the following condition must be satisfied: (r_2 - r_1) + (c_2 - c_1) β₯ n - 1.
It's guaranteed that Bob can get from the top-left corner (1, 1) to the bottom-right corner (n, n) and your task is to find a way to do it. You should print the answer in form "! S" where S is a string of length 2 β
n - 2 consisting of characters 'D' and 'R', denoting moves down and right respectively. The down move increases the first coordinate by 1, the right move increases the second coordinate by 1. If there are multiple solutions, any of them will be accepted. You should terminate immediately after printing the solution.
Input
The only line of the input contains an integer n (2 β€ n β€ 500) β the size of the grid.
Output
When you are ready to print the answer, print a single line containing "! S" where where S is a string of length 2 β
n - 2 consisting of characters 'D' and 'R', denoting moves down and right respectively. The path should be a valid path going from the cell (1, 1) to the cell (n, n) passing only through allowed cells.
Interaction
You can ask at most 4 β
n queries. To ask a query, print a line containing "? r_1 c_1 r_2 c_2" (1 β€ r_1 β€ r_2 β€ n, 1 β€ c_1 β€ c_2 β€ n). After that you should read a single line containing "YES" or "NO" depending on the answer of the query. "YES" means Bob can go from the cell (r_1, c_1) to the cell (r_2, c_2), "NO" means the opposite.
Note that the grid is fixed before the start of your solution and does not depend on your queries.
After printing a query do not forget to output end of line and flush the output. Otherwise you will get Idleness limit exceeded or other negative verdict. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Answer "BAD" instead of "YES" or "NO" means that you made an invalid query. Exit immediately after receiving "BAD" and you will see Wrong answer verdict. Otherwise you can get an arbitrary verdict because your solution will continue to read from a closed stream.
Example
Input
4
Β
YES
Β
NO
Β
YES
Β
YES
Β
Output
Β
? 1 1 4 4
Β
? 1 2 4 3
Β
? 4 1 4 4
Β
? 1 4 4 4
Β
! RDRRDD
Note
The first example is shown on the picture below.
<image>
To hack, use the following input format:
The first line should contain a single integer n (2 β€ n β€ 500) β the size of the grid.
Each of the next n lines should contain a string of n characters '#' or '.', where '#' denotes a blocked cell, and '.' denotes an allowed cell.
For example, the following text encodes the example shown above:
4
..#.
#...
###.
....
|
import sys
def pos(x1,y1,x2,y2):
print('?',y1,x1,y2,x2)
sys.stdout.flush()
ans=input()
if(ans=='YES'):
return True
else:
return False
n=int(input())
curx=n
cury=n
s=''
while(curx+cury>n+1):
if(pos(1,1,curx,cury-1)):
s+='D'
cury-=1
else:
s+='R'
curx-=1
s=s[::-1]
s1=''
curx1=1
cury1=1
while(curx1 + cury1 < n+1):
if(pos(curx1+1,cury1,n,n)):
s1+='R'
curx1+=1
else:
s1+='D'
cury1+=1
print('!',s1+s)
| {
"input": [
"4\nΒ \nYES\nΒ \nNO\nΒ \nYES\nΒ \nYES\nΒ \n"
],
"output": [
"? 2 1 4 4\n? 2 2 4 4\n? 3 2 4 4\n? 1 1 4 3\n? 1 1 3 3\n? 1 1 2 3\n! RDRRDD\n"
]
} |
2,910 | 9 | The German University in Cairo (GUC) dorm houses are numbered from 1 to n. Underground water pipes connect these houses together. Each pipe has certain direction (water can flow only in this direction and not vice versa), and diameter (which characterizes the maximal amount of water it can handle).
For each house, there is at most one pipe going into it and at most one pipe going out of it. With the new semester starting, GUC student and dorm resident, Lulu, wants to install tanks and taps at the dorms. For every house with an outgoing water pipe and without an incoming water pipe, Lulu should install a water tank at that house. For every house with an incoming water pipe and without an outgoing water pipe, Lulu should install a water tap at that house. Each tank house will convey water to all houses that have a sequence of pipes from the tank to it. Accordingly, each tap house will receive water originating from some tank house.
In order to avoid pipes from bursting one week later (like what happened last semester), Lulu also has to consider the diameter of the pipes. The amount of water each tank conveys should not exceed the diameter of the pipes connecting a tank to its corresponding tap. Lulu wants to find the maximal amount of water that can be safely conveyed from each tank to its corresponding tap.
Input
The first line contains two space-separated integers n and p (1 β€ n β€ 1000, 0 β€ p β€ n) β the number of houses and the number of pipes correspondingly.
Then p lines follow β the description of p pipes. The i-th line contains three integers ai bi di, indicating a pipe of diameter di going from house ai to house bi (1 β€ ai, bi β€ n, ai β bi, 1 β€ di β€ 106).
It is guaranteed that for each house there is at most one pipe going into it and at most one pipe going out of it.
Output
Print integer t in the first line β the number of tank-tap pairs of houses.
For the next t lines, print 3 integers per line, separated by spaces: tanki, tapi, and diameteri, where tanki β tapi (1 β€ i β€ t). Here tanki and tapi are indexes of tank and tap houses respectively, and diameteri is the maximum amount of water that can be conveyed. All the t lines should be ordered (increasingly) by tanki.
Examples
Input
3 2
1 2 10
2 3 20
Output
1
1 3 10
Input
3 3
1 2 20
2 3 10
3 1 5
Output
0
Input
4 2
1 2 60
3 4 50
Output
2
1 2 60
3 4 50 | 'code by AanchalTiwari'
def dfs(node):
stack = [node]
capacity = float("inf")
while stack:
node = stack.pop()
if outdeg[node] == 0:
return node, capacity
for child, dia in g[node]:
capacity = min(capacity, dia)
stack.append(child)
n, m = map(int, input().split())
g = {i: [] for i in range(1, n + 1)}
indeg = [0 for i in range(n + 1)]
outdeg = [0 for i in range(n+1)]
for i in range(m):
u, v, d = map(int, input().split())
g[u].append([v, d])
indeg[v] += 1
outdeg[u] += 1
ans = set()
for i in range(1, n + 1):
if indeg[i] == 0 and outdeg[i] > 0:
start = i
end, capacity = dfs(i)
indeg[end] += 1
outdeg[start] += 1
ans.add((start, end, capacity))
ans = sorted(list(ans))
print(len(ans))
for i in ans:
print(*i)
| {
"input": [
"3 3\n1 2 20\n2 3 10\n3 1 5\n",
"4 2\n1 2 60\n3 4 50\n",
"3 2\n1 2 10\n2 3 20\n"
],
"output": [
"0\n",
"2\n1 2 60\n3 4 50\n",
"1\n1 3 10\n"
]
} |
2,911 | 8 | Reading books is one of Sasha's passions. Once while he was reading one book, he became acquainted with an unusual character. The character told about himself like that: "Many are my names in many countries. Mithrandir among the Elves, TharkΓ»n to the Dwarves, OlΓ³rin I was in my youth in the West that is forgotten, in the South IncΓ‘nus, in the North Gandalf; to the East I go not."
And at that moment Sasha thought, how would that character be called in the East? In the East all names are palindromes. A string is a palindrome if it reads the same backward as forward. For example, such strings as "kazak", "oo" and "r" are palindromes, but strings "abb" and "ij" are not.
Sasha believed that the hero would be named after one of the gods of the East. As long as there couldn't be two equal names, so in the East people did the following: they wrote the original name as a string on a piece of paper, then cut the paper minimum number of times k, so they got k+1 pieces of paper with substrings of the initial string, and then unite those pieces together to get a new string. Pieces couldn't be turned over, they could be shuffled.
In this way, it's possible to achive a string abcdefg from the string f|de|abc|g using 3 cuts (by swapping papers with substrings f and abc). The string cbadefg can't be received using the same cuts.
More formally, Sasha wants for the given palindrome s find such minimum k, that you can cut this string into k + 1 parts, and then unite them in such a way that the final string will be a palindrome and it won't be equal to the initial string s. It there is no answer, then print "Impossible" (without quotes).
Input
The first line contains one string s (1 β€ |s| β€ 5 000) β the initial name, which consists only of lowercase Latin letters. It is guaranteed that s is a palindrome.
Output
Print one integer k β the minimum number of cuts needed to get a new name, or "Impossible" (without quotes).
Examples
Input
nolon
Output
2
Input
otto
Output
1
Input
qqqq
Output
Impossible
Input
kinnikkinnik
Output
1
Note
In the first example, you can cut the string in those positions: no|l|on, and then unite them as follows on|l|no. It can be shown that there is no solution with one cut.
In the second example, you can cut the string right in the middle, and swap peaces, so you get toot.
In the third example, you can't make a string, that won't be equal to the initial one.
In the fourth example, you can cut the suffix nik and add it to the beginning, so you get nikkinnikkin. | from sys import *
s = input();
def check(t):
return (t == t[::-1]) and (t != s)
for i in range(1, len(s)):
t = s[i:] + s[:i]
if check(t):
print("1")
exit()
for i in range(1, len(s)//2 + (len(s)%2)):
t = s[-i:] + s[i:-i] + s[:i]
if check(t):
print("2")
exit()
print("Impossible") | {
"input": [
"otto\n",
"qqqq\n",
"nolon\n",
"kinnikkinnik\n"
],
"output": [
"1",
"Impossible",
"2",
"1"
]
} |
2,912 | 7 | Recently, on the course of algorithms and data structures, Valeriy learned how to use a deque. He built a deque filled with n elements. The i-th element is a_i (i = 1, 2, β¦, n). He gradually takes the first two leftmost elements from the deque (let's call them A and B, respectively), and then does the following: if A > B, he writes A to the beginning and writes B to the end of the deque, otherwise, he writes to the beginning B, and A writes to the end of the deque. We call this sequence of actions an operation.
For example, if deque was [2, 3, 4, 5, 1], on the operation he will write B=3 to the beginning and A=2 to the end, so he will get [3, 4, 5, 1, 2].
The teacher of the course, seeing Valeriy, who was passionate about his work, approached him and gave him q queries. Each query consists of the singular number m_j (j = 1, 2, β¦, q). It is required for each query to answer which two elements he will pull out on the m_j-th operation.
Note that the queries are independent and for each query the numbers A and B should be printed in the order in which they will be pulled out of the deque.
Deque is a data structure representing a list of elements where insertion of new elements or deletion of existing elements can be made from both sides.
Input
The first line contains two integers n and q (2 β€ n β€ 10^5, 0 β€ q β€ 3 β
10^5) β the number of elements in the deque and the number of queries. The second line contains n integers a_1, a_2, ..., a_n, where a_i (0 β€ a_i β€ 10^9) β the deque element in i-th position. The next q lines contain one number each, meaning m_j (1 β€ m_j β€ 10^{18}).
Output
For each teacher's query, output two numbers A and B β the numbers that Valeriy pulls out of the deque for the m_j-th operation.
Examples
Input
5 3
1 2 3 4 5
1
2
10
Output
1 2
2 3
5 2
Input
2 0
0 0
Output
Note
Consider all 10 steps for the first test in detail:
1. [1, 2, 3, 4, 5] β on the first operation, A and B are 1 and 2, respectively.
So, 2 we write to the beginning of the deque, and 1 β to the end.
We get the following status of the deque: [2, 3, 4, 5, 1].
2. [2, 3, 4, 5, 1] β A = 2, B = 3.
3. [3, 4, 5, 1, 2]
4. [4, 5, 1, 2, 3]
5. [5, 1, 2, 3, 4]
6. [5, 2, 3, 4, 1]
7. [5, 3, 4, 1, 2]
8. [5, 4, 1, 2, 3]
9. [5, 1, 2, 3, 4]
10. [5, 2, 3, 4, 1] β A = 5, B = 2. | n,q = map(int,input().split())
a = list(map(int,input().split()))
MAX = max(a)
max_idx = a.index(MAX)
pulled = [[-1,-1]]
for i in range(max_idx):
pulled.append([a[i],a[i+1]])
(a[i],a[i+1]) = (a[i+1],a[i]) if a[i]>a[i+1] else (a[i],a[i+1])
k = max_idx
l = []
for i in range(k+1,len(a)):
l.append(a[i])
for i in range(k):
l.append(a[i])
def pair(m):
ans = []
if m<=max_idx:
ans = pulled[m]
else:
ans = [MAX,l[(m - max_idx -1) %(n-1)]]
return(ans)
for _ in range(q):
m = int(input())
print(*pair(m)) | {
"input": [
"5 3\n1 2 3 4 5\n1\n2\n10\n",
"2 0\n0 0\n"
],
"output": [
"1 2\n2 3\n5 2\n",
"\n"
]
} |
2,913 | 9 | You are given a sorted array a_1, a_2, ..., a_n (for each index i > 1 condition a_i β₯ a_{i-1} holds) and an integer k.
You are asked to divide this array into k non-empty consecutive subarrays. Every element in the array should be included in exactly one subarray.
Let max(i) be equal to the maximum in the i-th subarray, and min(i) be equal to the minimum in the i-th subarray. The cost of division is equal to β_{i=1}^{k} (max(i) - min(i)). For example, if a = [2, 4, 5, 5, 8, 11, 19] and we divide it into 3 subarrays in the following way: [2, 4], [5, 5], [8, 11, 19], then the cost of division is equal to (4 - 2) + (5 - 5) + (19 - 8) = 13.
Calculate the minimum cost you can obtain by dividing the array a into k non-empty consecutive subarrays.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 3 β
10^5).
The second line contains n integers a_1, a_2, ..., a_n ( 1 β€ a_i β€ 10^9, a_i β₯ a_{i-1}).
Output
Print the minimum cost you can obtain by dividing the array a into k nonempty consecutive subarrays.
Examples
Input
6 3
4 8 15 16 23 42
Output
12
Input
4 4
1 3 3 7
Output
0
Input
8 1
1 1 2 3 5 8 13 21
Output
20
Note
In the first test we can divide array a in the following way: [4, 8, 15, 16], [23], [42]. | def mp():
return map(int, input().split())
n, k = mp()
a = list(mp())
b = [0] * (n - 1)
for i in range(n - 1):
b[i] = a[i + 1] - a[i]
k -= 1
b.sort(reverse = True)
print(sum(b[k:])) | {
"input": [
"4 4\n1 3 3 7\n",
"6 3\n4 8 15 16 23 42\n",
"8 1\n1 1 2 3 5 8 13 21\n"
],
"output": [
"0\n",
"12\n",
"20\n"
]
} |
2,914 | 10 | All of us love treasures, right? That's why young Vasya is heading for a Treasure Island.
Treasure Island may be represented as a rectangular table n Γ m which is surrounded by the ocean. Let us number rows of the field with consecutive integers from 1 to n from top to bottom and columns with consecutive integers from 1 to m from left to right. Denote the cell in r-th row and c-th column as (r, c). Some of the island cells contain impassable forests, and some cells are free and passable. Treasure is hidden in cell (n, m).
Vasya got off the ship in cell (1, 1). Now he wants to reach the treasure. He is hurrying up, so he can move only from cell to the cell in next row (downwards) or next column (rightwards), i.e. from cell (x, y) he can move only to cells (x+1, y) and (x, y+1). Of course Vasya can't move through cells with impassable forests.
Evil Witch is aware of Vasya's journey and she is going to prevent him from reaching the treasure. Before Vasya's first move she is able to grow using her evil magic impassable forests in previously free cells. Witch is able to grow a forest in any number of any free cells except cells (1, 1) where Vasya got off his ship and (n, m) where the treasure is hidden.
Help Evil Witch by finding out the minimum number of cells she has to turn into impassable forests so that Vasya is no longer able to reach the treasure.
Input
First line of input contains two positive integers n, m (3 β€ n β
m β€ 1 000 000), sizes of the island.
Following n lines contains strings s_i of length m describing the island, j-th character of string s_i equals "#" if cell (i, j) contains an impassable forest and "." if the cell is free and passable. Let us remind you that Vasya gets of his ship at the cell (1, 1), i.e. the first cell of the first row, and he wants to reach cell (n, m), i.e. the last cell of the last row.
It's guaranteed, that cells (1, 1) and (n, m) are empty.
Output
Print the only integer k, which is the minimum number of cells Evil Witch has to turn into impassable forest in order to prevent Vasya from reaching the treasure.
Examples
Input
2 2
..
..
Output
2
Input
4 4
....
#.#.
....
.#..
Output
1
Input
3 4
....
.##.
....
Output
2
Note
The following picture illustrates the island in the third example. Blue arrows show possible paths Vasya may use to go from (1, 1) to (n, m). Red illustrates one possible set of cells for the Witch to turn into impassable forest to make Vasya's trip from (1, 1) to (n, m) impossible.
<image> | from sys import stdin
def main():
n, m = map(int, input().split())
field = stdin.read()
if n == 1 or m == 1:
return print('10'['#' in field])
field = [c == '.' for c in field]
field += (False,) * (m + 2)
visited1, visited2 = ([False] * len(field) for _ in '12')
cnt = [0] * (n + m)
m += 1
visited1[0] = visited2[n * m - 2] = True
for i in range(n * m - 2, 0, -1):
if field[i] and (visited2[i + 1] or visited2[i + m]):
visited2[i] = True
for i in range(n * m):
if field[i] and (visited1[i - 1] or visited1[i - m]):
visited1[i] = True
if visited2[i]:
cnt[i // m + i % m] += 1
print(min(cnt[1:-2]))
if __name__ == '__main__':
main()
| {
"input": [
"4 4\n....\n#.#.\n....\n.#..\n",
"2 2\n..\n..\n",
"3 4\n....\n.##.\n....\n"
],
"output": [
"1\n",
"2\n",
"2\n"
]
} |
2,915 | 11 | This is the harder version of the problem. In this version, 1 β€ n β€ 10^6 and 0 β€ a_i β€ 10^6. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, β¦, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 β€ n β€ 10^6) β the number of chocolate boxes.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 10^6) β the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, β¦, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x β the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
4 8 5
Output
9
Input
5
3 10 2 1 5
Output
2
Input
4
0 5 15 10
Output
0
Input
1
1
Output
-1
Note
In the first example, Charlie can move all chocolate pieces to the second box. Each box will be divisible by 17.
In the second example, Charlie can move a piece from box 2 to box 3 and a piece from box 4 to box 5. Each box will be divisible by 3.
In the third example, each box is already divisible by 5.
In the fourth example, since Charlie has no available move, he cannot help Bob make Alice happy. | n = int(input())
l = list(map(int,input().split()))
def jebaj(d, k):
res = 0
pyk = d[0]%k
for i in range(n - 2):
res += min(pyk, k - pyk)
pyk = (pyk + d[i+1])%k
res += min(pyk, k - pyk)
return res
s = sum(l)
out = 10000000000000000000000000
if s <= 1:
print(-1)
else:
i = 2
ss = s
primes = []
while ss > 1 and i * i <= s:
if ss%i == 0:
ss //= i
if len(primes) == 0 or i != primes[-1]:
primes.append(i)
else:
i += 1
if ss * ss > s:
primes.append(ss)
for i in primes:
out = min(out, jebaj(l, i))
print(out) | {
"input": [
"1\n1\n",
"3\n4 8 5\n",
"5\n3 10 2 1 5\n",
"4\n0 5 15 10\n"
],
"output": [
"-1\n",
"9\n",
"2\n",
"0\n"
]
} |
2,916 | 11 | Yeah, we failed to make up a New Year legend for this problem.
A permutation of length n is an array of n integers such that every integer from 1 to n appears in it exactly once.
An element y of permutation p is reachable from element x if x = y, or p_x = y, or p_{p_x} = y, and so on.
The decomposition of a permutation p is defined as follows: firstly, we have a permutation p, all elements of which are not marked, and an empty list l. Then we do the following: while there is at least one not marked element in p, we find the leftmost such element, list all elements that are reachable from it in the order they appear in p, mark all of these elements, then cyclically shift the list of those elements so that the maximum appears at the first position, and add this list as an element of l. After all elements are marked, l is the result of this decomposition.
For example, if we want to build a decomposition of p = [5, 4, 2, 3, 1, 7, 8, 6], we do the following:
1. initially p = [5, 4, 2, 3, 1, 7, 8, 6] (bold elements are marked), l = [];
2. the leftmost unmarked element is 5; 5 and 1 are reachable from it, so the list we want to shift is [5, 1]; there is no need to shift it, since maximum is already the first element;
3. p = [5, 4, 2, 3, 1, 7, 8, 6], l = [[5, 1]];
4. the leftmost unmarked element is 4, the list of reachable elements is [4, 2, 3]; the maximum is already the first element, so there's no need to shift it;
5. p = [5, 4, 2, 3, 1, 7, 8, 6], l = [[5, 1], [4, 2, 3]];
6. the leftmost unmarked element is 7, the list of reachable elements is [7, 8, 6]; we have to shift it, so it becomes [8, 6, 7];
7. p = [5, 4, 2, 3, 1, 7, 8, 6], l = [[5, 1], [4, 2, 3], [8, 6, 7]];
8. all elements are marked, so [[5, 1], [4, 2, 3], [8, 6, 7]] is the result.
The New Year transformation of a permutation is defined as follows: we build the decomposition of this permutation; then we sort all lists in decomposition in ascending order of the first elements (we don't swap the elements in these lists, only the lists themselves); then we concatenate the lists into one list which becomes a new permutation. For example, the New Year transformation of p = [5, 4, 2, 3, 1, 7, 8, 6] is built as follows:
1. the decomposition is [[5, 1], [4, 2, 3], [8, 6, 7]];
2. after sorting the decomposition, it becomes [[4, 2, 3], [5, 1], [8, 6, 7]];
3. [4, 2, 3, 5, 1, 8, 6, 7] is the result of the transformation.
We call a permutation good if the result of its transformation is the same as the permutation itself. For example, [4, 3, 1, 2, 8, 5, 6, 7] is a good permutation; and [5, 4, 2, 3, 1, 7, 8, 6] is bad, since the result of transformation is [4, 2, 3, 5, 1, 8, 6, 7].
Your task is the following: given n and k, find the k-th (lexicographically) good permutation of length n.
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases.
Then the test cases follow. Each test case is represented by one line containing two integers n and k (1 β€ n β€ 50, 1 β€ k β€ 10^{18}).
Output
For each test case, print the answer to it as follows: if the number of good permutations of length n is less than k, print one integer -1; otherwise, print the k-th good permutation on n elements (in lexicographical order).
Example
Input
5
3 3
5 15
4 13
6 8
4 2
Output
2 1 3
3 1 2 5 4
-1
1 2 6 3 4 5
1 2 4 3 | from math import factorial as fact
N = 55
c = [1]
for i in range(N):
c.append(fact(i))
dp = [0] * N
dp[0] = 1
for i in range(1, N):
for j in range(i):
dp[i] += dp[j] * c[i - j - 1]
def get_kth_cycle(n, k):
if n == 1:
return [1]
ans = [-1] * n
ans[0] = n - 1
fin = [i for i in range(n)]
fin[0] = n - 1
init = [i for i in range(n)]
init[n - 1] = 0
used = [False] * n
used[n - 1] = True
for i in range(1, n - 1):
j = 0
cur = fact(n - i - 2)
while True:
while used[j] or (i < n - 1 and j == init[i]):
j += 1
if k > cur:
k -= cur
j += 1
else:
fin[init[i]] = fin[j]
init[fin[j]] = init[i]
ans[i] = j
used[j] = True
break
ans[-1] = init[-1]
return [x + 1 for x in ans]
def f(n, k):
if n == 0:
assert k == 1
return []
cl = 1
while c[cl - 1] * dp[n - cl] < k:
k -= c[cl - 1] * dp[n - cl]
cl += 1
rest = f(n - cl, (k - 1) % dp[n - cl] + 1)
rest = [x + cl for x in rest]
k = (k - 1) // dp[n - cl] + 1
return get_kth_cycle(cl, k) + rest
def solve():
n, k = map(int, input().split())
if k > dp[n]:
print(-1)
return
print(*f(n, k))
def main():
t = int(input())
while t > 0:
t -= 1
solve()
main() | {
"input": [
"5\n3 3\n5 15\n4 13\n6 8\n4 2\n"
],
"output": [
"2 1 3 \n3 1 2 5 4 \n-1\n1 2 6 3 4 5 \n1 2 4 3 \n"
]
} |
2,917 | 9 | In this task Anna and Maria play a game with a very unpleasant rival. Anna and Maria are in the opposite squares of a chessboard (8 Γ 8): Anna is in the upper right corner, and Maria is in the lower left one. Apart from them, the board has several statues. Each statue occupies exactly one square. A square that contains a statue cannot have anything or anyone β neither any other statues, nor Anna, nor Maria.
Anna is present on the board as a figurant (she stands still and never moves), and Maria has been actively involved in the game. Her goal is β to come to Anna's square. Maria and statues move in turn, Maria moves first. During one move Maria can go to any adjacent on the side or diagonal cell in which there is no statue, or she can stay in the cell where she is. The statues during their move must go one square down simultaneously, and those statues that were in the bottom row fall from the board and are no longer appeared.
At that moment, when one of the statues is in the cell in which the Maria is, the statues are declared winners. At the moment when Maria comes into the cell where Anna has been waiting, Maria is declared the winner.
Obviously, nothing depends on the statues, so it all depends on Maria. Determine who will win, if Maria does not make a strategic error.
Input
You are given the 8 strings whose length equals 8, describing the initial position on the board. The first line represents the top row of the board, the next one β for the second from the top, and so on, the last line represents the bottom row. Each character string matches a single cell board in the appropriate row, and the characters are in the same manner as that of the corresponding cell. If the cell is empty, the corresponding character is ".". If a cell has Maria, then it is represented by character "M". If a cell has Anna, it is represented by the character "A". If a cell has a statue, then the cell is represented by character "S".
It is guaranteed that the last character of the first row is always "A", the first character of the last line is always "M". The remaining characters are "." or "S".
Output
If Maria wins, print string "WIN". If the statues win, print string "LOSE".
Examples
Input
.......A
........
........
........
........
........
........
M.......
Output
WIN
Input
.......A
........
........
........
........
........
SS......
M.......
Output
LOSE
Input
.......A
........
........
........
........
.S......
S.......
MS......
Output
LOSE | start=[]
for i in range(8): start.append(input())
a=[start]
#start=[".......A","........","........","........","........",".SSSSSSS","S.......","M......."]
#a=[start]
for i in range(10):
tmp=a[-1]
tmp=[".......A"]+tmp
tmp[1]=tmp[1][:-1]+"."
a.append(tmp[:-1])
dx=[-1,1,0,0,0,1,1,-1,-1]
dy=[0,0,-1,1,0,-1,1,-1,1]
def chk(x,y,step):
if a[step][y][x]=="S": return False
if step==9:return True
for i in range(8):
x_,y_=x+dx[i],y+dy[i]
if min(x_,y_)<0 or max(x_,y_)>7:continue
if a[step][y_][x_]!='S' and chk(x_,y_,step+1): return True
return False
if chk(0,7,0):
print("WIN")
else:
print("LOSE")
| {
"input": [
".......A\n........\n........\n........\n........\n........\n........\nM.......\n",
".......A\n........\n........\n........\n........\n........\nSS......\nM.......\n",
".......A\n........\n........\n........\n........\n.S......\nS.......\nMS......\n"
],
"output": [
"WIN",
"LOSE",
"LOSE"
]
} |
2,918 | 11 | If the girl doesn't go to Denis, then Denis will go to the girl. Using this rule, the young man left home, bought flowers and went to Nastya.
On the way from Denis's house to the girl's house is a road of n lines. This road can't be always crossed in one green light. Foreseeing this, the good mayor decided to place safety islands in some parts of the road. Each safety island is located after a line, as well as at the beginning and at the end of the road. Pedestrians can relax on them, gain strength and wait for a green light.
Denis came to the edge of the road exactly at the moment when the green light turned on. The boy knows that the traffic light first lights up g seconds green, and then r seconds red, then again g seconds green and so on.
Formally, the road can be represented as a segment [0, n]. Initially, Denis is at point 0. His task is to get to point n in the shortest possible time.
He knows many different integers d_1, d_2, β¦, d_m, where 0 β€ d_i β€ n β are the coordinates of points, in which the safety islands are located. Only at one of these points, the boy can be at a time when the red light is on.
Unfortunately, Denis isn't always able to control himself because of the excitement, so some restrictions are imposed:
* He must always move while the green light is on because it's difficult to stand when so beautiful girl is waiting for you. Denis can change his position by Β± 1 in 1 second. While doing so, he must always stay inside the segment [0, n].
* He can change his direction only on the safety islands (because it is safe). This means that if in the previous second the boy changed his position by +1 and he walked on a safety island, then he can change his position by Β± 1. Otherwise, he can change his position only by +1. Similarly, if in the previous second he changed his position by -1, on a safety island he can change position by Β± 1, and at any other point by -1.
* At the moment when the red light is on, the boy must be on one of the safety islands. He can continue moving in any direction when the green light is on.
Denis has crossed the road as soon as his coordinate becomes equal to n.
This task was not so simple, because it's possible that it is impossible to cross the road. Since Denis has all thoughts about his love, he couldn't solve this problem and asked us to help him. Find the minimal possible time for which he can cross the road according to these rules, or find that it is impossible to do.
Input
The first line contains two integers n and m (1 β€ n β€ 10^6, 2 β€ m β€ min(n + 1, 10^4)) β road width and the number of safety islands.
The second line contains m distinct integers d_1, d_2, β¦, d_m (0 β€ d_i β€ n) β the points where the safety islands are located. It is guaranteed that there are 0 and n among them.
The third line contains two integers g, r (1 β€ g, r β€ 1000) β the time that the green light stays on and the time that the red light stays on.
Output
Output a single integer β the minimum time for which Denis can cross the road with obeying all the rules.
If it is impossible to cross the road output -1.
Examples
Input
15 5
0 3 7 14 15
11 11
Output
45
Input
13 4
0 3 7 13
9 9
Output
-1
Note
In the first test, the optimal route is:
* for the first green light, go to 7 and return to 3. In this case, we will change the direction of movement at the point 7, which is allowed, since there is a safety island at this point. In the end, we will be at the point of 3, where there is also a safety island. The next 11 seconds we have to wait for the red light.
* for the second green light reaches 14. Wait for the red light again.
* for 1 second go to 15. As a result, Denis is at the end of the road.
In total, 45 seconds are obtained.
In the second test, it is impossible to cross the road according to all the rules. | import sys
from array import array # noqa: F401
import typing as Tp # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def output(*args):
sys.stdout.buffer.write(
('\n'.join(map(str, args)) + '\n').encode('utf-8')
)
def main():
from collections import deque
n, m = map(int, input().split())
pos = [-10**9] + sorted(map(int, input().split())) + [10**9]
g, r = map(int, input().split())
inf = 10**9
dp = [array('i', [inf]) * (g + 1) for _ in range(m + 2)]
dp[1][0] = 0
dq = deque([(1, 0)])
while dq:
v, time = dq.popleft()
p_dist, n_dist = pos[v] - pos[v - 1], pos[v + 1] - pos[v]
if time == g:
if p_dist <= g and dp[v - 1][p_dist] > dp[v][time] + 1:
dp[v - 1][p_dist] = dp[v][time] + 1
dq.append((v - 1, p_dist))
if n_dist <= g and dp[v + 1][n_dist] > dp[v][time] + 1:
dp[v + 1][n_dist] = dp[v][time] + 1
dq.append((v + 1, n_dist))
else:
if time + p_dist <= g and dp[v - 1][time + p_dist] > dp[v][time]:
dp[v - 1][time + p_dist] = dp[v][time]
dq.appendleft((v - 1, time + p_dist))
if time + n_dist <= g and dp[v + 1][time + n_dist] > dp[v][time]:
dp[v + 1][time + n_dist] = dp[v][time]
dq.appendleft((v + 1, time + n_dist))
ans = min(dp[-2][i] * (g + r) + i for i in range(g + 1))
print(ans if ans < inf else -1)
if __name__ == '__main__':
main()
| {
"input": [
"15 5\n0 3 7 14 15\n11 11\n",
"13 4\n0 3 7 13\n9 9\n"
],
"output": [
"45",
"-1"
]
} |
2,919 | 11 | Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k β
a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 β€ n β€ 2 β
10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 β€ a_i β€ 10^9, 0 β€ b_i, c_i β€ 1) β the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 β€ u, v β€ n, u β v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 β
1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 β
2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 β
2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially. | import sys
def f():
return map(int,sys.stdin.readline().split())
n=int(input())
val=[]
bit=[]
for i in range(n):
v,a,b=f()
val.append((v,i))
bit.append(a-b)
val.sort()
go=[set() for _ in range(n)]
for _ in range(n-1):
a,b=f()
a-=1
b-=1
go[a].add(b)
go[b].add(a)
if sum(bit)!=0:
print(-1)
exit()
q=[0]
while len(q)!=0:
now=q.pop()
for x in go[now]:
go[x].remove(now)
q.append(x)
ans=0
for v,i in val:
pos=neg=0
q=[i]
while len(q)!=0:
now=q.pop()
for x in go[now]:
if bit[x]>0:
pos+=bit[x]
else:
neg+=bit[x]
bit[x]=0
q.append(x)
go[now]=[]
if bit[i]>0:
pos+=bit[i]
else:
neg+=bit[i]
ans+=v*min(pos,-neg)*2
bit[i]=pos+neg
print(ans) | {
"input": [
"5\n10000 0 1\n2000 1 0\n300 0 1\n40 0 0\n1 1 0\n1 2\n2 3\n2 4\n1 5\n",
"5\n1 0 1\n20 1 0\n300 0 1\n4000 0 0\n50000 1 0\n1 2\n2 3\n2 4\n1 5\n",
"2\n109 0 1\n205 0 1\n1 2\n"
],
"output": [
"24000",
"4",
"-1"
]
} |
2,920 | 7 | The length of the longest common prefix of two strings s = s_1 s_2 β¦ s_n and t = t_1 t_2 β¦ t_m is defined as the maximum integer k (0 β€ k β€ min(n,m)) such that s_1 s_2 β¦ s_k equals t_1 t_2 β¦ t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 β€ i β€ n) she calculated a_i β the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 β€ t β€ 100) β the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 100) β the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 50) β the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 β€ |s_i| β€ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri β 1
* Between \color{red}{ar}i and \color{red}{ar}ousal β 2
* Between \color{red}{arou}sal and \color{red}{arou}nd β 4
* Between \color{red}{ar}ound and \color{red}{ar}i β 2 | t=int(input())
def another(c):
return 'b' if c=='a' else 'a'
for i in range(t):
n=int(input())
a=[int(x) for x in input().split(' ') ]
s=['a']*60
print(''.join(s))
for x in a:
s[x]=another(s[x])
print(''.join(s)) | {
"input": [
"4\n4\n1 2 4 2\n2\n5 3\n3\n1 3 1\n3\n0 0 0\n"
],
"output": [
"aaaaa\nabaaa\nabbaa\nabbab\nabaab\naaaaaa\naaaaab\naaabab\naaaa\nabaa\nabab\naaab\na\nb\na\nb\n"
]
} |
2,921 | 8 | You're given an array a of n integers, such that a_1 + a_2 + β
β
β
+ a_n = 0.
In one operation, you can choose two different indices i and j (1 β€ i, j β€ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 β€ n β€ 10^5) β the number of elements.
The next line contains n integers a_1, β¦, a_n (-10^9 β€ a_i β€ 10^9). It is given that β_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0]. | def solve():
n = int(input())
l = list(map(int, input().split()))
cur = 0
for x in l:
cur = max(0, cur + x)
return cur
for __ in range(int(input())):
print(solve())
| {
"input": [
"7\n4\n-3 5 -3 1\n2\n1 -1\n4\n-3 2 -3 4\n4\n-1 1 1 -1\n7\n-5 7 -6 -4 17 -13 4\n6\n-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000\n1\n0\n"
],
"output": [
"3\n0\n4\n1\n8\n3000000000\n0\n"
]
} |
2,922 | 10 | Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 β€ n β€ 200 000) β the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} β€ a_i β€ 10^{9}, a_i β 0) β the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything. | def main():
n = eval(input())
arr = list(map(int,input().split()))
mp = set()
mp.add(0)
sum=0
ans=0
for i in arr:
sum+=i
if(sum in mp) :
ans += 1
mp = set()
mp.add(0)
sum=i
mp.add(sum)
print(ans)
main()
| {
"input": [
"5\n4 -2 3 -9 2\n",
"9\n-1 1 -1 1 -1 1 1 -1 -1\n",
"8\n16 -5 -11 -15 10 5 4 -4\n",
"4\n1 -5 3 2\n"
],
"output": [
"0\n",
"6\n",
"3\n",
"1\n"
]
} |
2,923 | 9 | A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = Β«abaΒ», then the string "a??" is good, and the string Β«?bcΒ» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a"). | from collections import Counter
s, p = input(), input()
def g(sc, pc):
d = 0
for k in sc:
if k != '?' and sc[k] > pc[k]:
return False
elif k != '?':
d += sc[k]
return sc['?'] == len(p) - d
sc, pc = Counter(s[:len(p)]), Counter(p)
v = g(sc, pc)
for i in range(len(p), len(s)):
sc[s[i - len(p)]] -= 1
sc[s[i]] += 1
v += g(sc, pc)
print(int(v))
| {
"input": [
"bb??x???\naab\n",
"ab?c\nacb\n"
],
"output": [
"2\n",
"2\n"
]
} |
2,924 | 9 | You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k β€ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i β t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
The first and only line of each test case contains two integers n and k (k β€ n < 2k; 1 β€ k β€ 10^5) β the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers β the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum. | import sys
input = sys.stdin.readline
def solution(n,k):
arr = []
for i in range(1,k-(n-k)):
arr.append(i)
for i in range(k,k-(n-k)-1,-1):
arr.append(i)
return arr
t = int(input())
for i in range(t):
n,k = map(int,input().split())
print(*solution(n,k))
| {
"input": [
"4\n1 1\n2 2\n3 2\n4 3\n"
],
"output": [
"\n1 \n1 2 \n2 1 \n1 3 2 \n"
]
} |
2,925 | 11 | You are given two strings x and y, both consist only of lowercase Latin letters. Let |s| be the length of string s.
Let's call a sequence a a merging sequence if it consists of exactly |x| zeros and exactly |y| ones in some order.
A merge z is produced from a sequence a by the following rules:
* if a_i=0, then remove a letter from the beginning of x and append it to the end of z;
* if a_i=1, then remove a letter from the beginning of y and append it to the end of z.
Two merging sequences a and b are different if there is some position i such that a_i β b_i.
Let's call a string z chaotic if for all i from 2 to |z| z_{i-1} β z_i.
Let s[l,r] for some 1 β€ l β€ r β€ |s| be a substring of consecutive letters of s, starting from position l and ending at position r inclusive.
Let f(l_1, r_1, l_2, r_2) be the number of different merging sequences of x[l_1,r_1] and y[l_2,r_2] that produce chaotic merges. Note that only non-empty substrings of x and y are considered.
Calculate β _{1 β€ l_1 β€ r_1 β€ |x| \\\ 1 β€ l_2 β€ r_2 β€ |y|} f(l_1, r_1, l_2, r_2). Output the answer modulo 998 244 353.
Input
The first line contains a string x (1 β€ |x| β€ 1000).
The second line contains a string y (1 β€ |y| β€ 1000).
Both strings consist only of lowercase Latin letters.
Output
Print a single integer β the sum of f(l_1, r_1, l_2, r_2) over 1 β€ l_1 β€ r_1 β€ |x| and 1 β€ l_2 β€ r_2 β€ |y| modulo 998 244 353.
Examples
Input
aaa
bb
Output
24
Input
code
forces
Output
1574
Input
aaaaa
aaa
Output
0
Input
justamassivetesttocheck
howwellyouhandlemodulooperations
Output
667387032
Note
In the first example there are:
* 6 pairs of substrings "a" and "b", each with valid merging sequences "01" and "10";
* 3 pairs of substrings "a" and "bb", each with a valid merging sequence "101";
* 4 pairs of substrings "aa" and "b", each with a valid merging sequence "010";
* 2 pairs of substrings "aa" and "bb", each with valid merging sequences "0101" and "1010";
* 2 pairs of substrings "aaa" and "b", each with no valid merging sequences;
* 1 pair of substrings "aaa" and "bb" with a valid merging sequence "01010";
Thus, the answer is 6 β
2 + 3 β
1 + 4 β
1 + 2 β
2 + 2 β
0 + 1 β
1 = 24. | mod = 998244353
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
S = input().rstrip('\n')
T = input().rstrip('\n')
NS = len(S)
NT = len(T)
dp_S = [[0] * (NT+1) for _ in range(NS+1)]
dp_T = [[0] * (NT+1) for _ in range(NS+1)]
for i in range(1, NS+1):
dp_S[i][0] = 1
for j in range(1, NT+1):
dp_T[0][j] = 1
for i in range(NS+1):
for j in range(NT+1):
if i == j == 0:
continue
elif i == 0:
if S[0] != T[j-1]:
dp_S[1][j] = (dp_S[1][j] + dp_T[0][j])%mod
if j+1 <= NT:
if T[j-1] != T[j]:
dp_T[0][j+1] = (dp_T[0][j+1] + dp_T[0][j])%mod
elif j == 0:
if T[0] != S[i-1]:
dp_T[i][1] = (dp_T[i][1] + dp_S[i][0]) % mod
if i + 1 <= NS:
if S[i - 1] != S[i]:
dp_S[i+1][0] = (dp_S[i+1][0] + dp_S[i][0]) % mod
else:
if i+1 <= NS:
if S[i-1] != S[i]:
dp_S[i+1][j] = (dp_S[i+1][j] + dp_S[i][j])%mod
if T[j-1] != S[i]:
dp_S[i+1][j] = (dp_S[i+1][j] + dp_T[i][j] + dp_T[0][j])%mod
if j+1 <= NT:
if T[j-1] != T[j]:
dp_T[i][j+1] = (dp_T[i][j+1] + dp_T[i][j])%mod
if S[i-1] != T[j]:
dp_T[i][j+1] = (dp_T[i][j+1] + dp_S[i][j] + dp_S[i][0])%mod
ans = 0
for i in range(1, NS+1):
for j in range(1, NT+1):
ans = (ans + dp_S[i][j] + dp_T[i][j])%mod
print(ans)
if __name__ == '__main__':
main()
| {
"input": [
"code\nforces\n",
"aaa\nbb\n",
"aaaaa\naaa\n",
"justamassivetesttocheck\nhowwellyouhandlemodulooperations\n"
],
"output": [
"\n1574\n",
"\n24\n",
"\n0\n",
"\n667387032\n"
]
} |
2,926 | 9 | This is an interactive problem!
Nastia has a hidden permutation p of length n consisting of integers from 1 to n. You, for some reason, want to figure out the permutation. To do that, you can give her an integer t (1 β€ t β€ 2), two different indices i and j (1 β€ i, j β€ n, i β j), and an integer x (1 β€ x β€ n - 1).
Depending on t, she will answer:
* t = 1: max{(min{(x, p_i)}, min{(x + 1, p_j)})};
* t = 2: min{(max{(x, p_i)}, max{(x + 1, p_j)})}.
You can ask Nastia at most β \frac {3 β
n} { 2} β + 30 times. It is guaranteed that she will not change her permutation depending on your queries. Can you guess the permutation?
Input
The input consists of several test cases. In the beginning, you receive the integer T (1 β€ T β€ 10 000) β the number of test cases.
At the beginning of each test case, you receive an integer n (3 β€ n β€ 10^4) β the length of the permutation p.
It's guaranteed that the permutation is fixed beforehand and that the sum of n in one test doesn't exceed 2 β
10^4.
Interaction
To ask a question, print "? t i j x" (t = 1 or t = 2, 1 β€ i, j β€ n, i β j, 1 β€ x β€ n - 1) Then, you should read the answer.
If we answer with β1 instead of a valid answer, that means you exceeded the number of queries or made an invalid query. Exit immediately after receiving β1 and you will see the Wrong Answer verdict. Otherwise, you can get an arbitrary verdict because your solution will continue to read from a closed stream.
To print the answer, print "! p_1 p_2 β¦ p_{n} (without quotes). Note that answering doesn't count as one of the β \frac {3 β
n} {2} β + 30 queries.
After printing a query or printing the answer, do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* See the documentation for other languages.
Hacks
To hack the solution, use the following test format.
The first line should contain a single integer T (1 β€ T β€ 10 000) β the number of test cases.
For each test case in the first line print a single integer n (3 β€ n β€ 10^4) β the length of the hidden permutation p.
In the second line print n space-separated integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p is permutation.
Note that the sum of n over all test cases should not exceed 2 β
10^4.
Example
Input
2
4
3
2
5
3
Output
? 2 4 1 3
? 1 2 4 2
! 3 1 4 2
? 2 3 4 2
! 2 5 3 4 1
Note
Consider the first test case.
The hidden permutation is [3, 1, 4, 2].
We print: "? 2 4 1 3" and get back min{(max{(3, p_4}), max{(4, p_1)})} = 3.
We print: "? 1 2 4 2" and get back max{(min{(2, p_2)}, min{(3, p_4)})} = 2.
Consider the second test case.
The hidden permutation is [2, 5, 3, 4, 1].
We print: "? 2 3 4 2" and get back min{(max{(2, p_3}), max{(3, p_4)})} = 3. | import math,sys
## from itertools import permutations, combinations;import heapq,random;
from collections import defaultdict,deque
import bisect as bi
def yes():print('YES')
def no():print('NO')
# sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
def I():return (int(sys.stdin.readline()))
def In():return(map(int,sys.stdin.readline().split()))
def Sn():return sys.stdin.readline().strip()
#sys.setrecursionlimit(1500)
def dict(a):
d={}
for x in a:
if d.get(x,-1)!=-1:
d[x]+=1
else:
d[x]=1
return d
def find_gt(a, x):
'Find leftmost value greater than x'
i = bi.bisect_left(a, x)
if i != len(a):
return i
else:
return -1
def query(type,st,end,x):
print('?',type,st,end,x,flush=True)
def main():
try:
global topi,ans
n=I()
d={}
st=-1
ans=[0]*(n+1)
topi=n-1
end = n-1 if n&1==1 else n
for i in range(0,end,2):
query(1,i+1,i+2,topi)
q=I()
if q==topi:
query(1,i+2,i+1,topi)
x=I()
if x==n:
st=i+1
break
elif q==n:
st=i+2
break
if st==-1:
st=n
ans[st]=n
for i in range(st-1,0,-1):
query(2,i,st,1)
q=I()
ans[i]=q
for i in range(st+1,n+1):
query(2,i,st,1)
q=I()
ans[i]=q
print('!',*ans[1:],flush=True)
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
for _ in range(I()):main()
# for _ in range(1):main()
#End#
# ******************* All The Best ******************* # | {
"input": [
"2\n4\n\n3\n\n2\n\n5\n\n3"
],
"output": [
"\n? 2 4 1 3\n\n? 1 2 4 2\n\n! 3 1 4 2\n\n? 2 3 4 2\n\n! 2 5 3 4 1\n"
]
} |
2,927 | 9 | Suppose you have two points p = (x_p, y_p) and q = (x_q, y_q). Let's denote the Manhattan distance between them as d(p, q) = |x_p - x_q| + |y_p - y_q|.
Let's say that three points p, q, r form a bad triple if d(p, r) = d(p, q) + d(q, r).
Let's say that an array b_1, b_2, ..., b_m is good if it is impossible to choose three distinct indices i, j, k such that the points (b_i, i), (b_j, j) and (b_k, k) form a bad triple.
You are given an array a_1, a_2, ..., a_n. Calculate the number of good subarrays of a. A subarray of the array a is the array a_l, a_{l + 1}, ..., a_r for some 1 β€ l β€ r β€ n.
Note that, according to the definition, subarrays of length 1 and 2 are good.
Input
The first line contains one integer t (1 β€ t β€ 5000) β the number of test cases.
The first line of each test case contains one integer n (1 β€ n β€ 2 β
10^5) β the length of array a.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
It's guaranteed that the sum of n doesn't exceed 2 β
10^5.
Output
For each test case, print the number of good subarrays of array a.
Example
Input
3
4
2 4 1 3
5
6 9 1 9 6
2
13 37
Output
10
12
3
Note
In the first test case, it can be proven that any subarray of a is good. For example, subarray [a_2, a_3, a_4] is good since it contains only three elements and:
* d((a_2, 2), (a_4, 4)) = |4 - 3| + |2 - 4| = 3 < d((a_2, 2), (a_3, 3)) + d((a_3, 3), (a_4, 4)) = 3 + 1 + 2 + 1 = 7;
* d((a_2, 2), (a_3, 3)) < d((a_2, 2), (a_4, 4)) + d((a_4, 4), (a_3, 3));
* d((a_3, 3), (a_4, 4)) < d((a_3, 3), (a_2, 2)) + d((a_2, 2), (a_4, 4));
In the second test case, for example, subarray [a_1, a_2, a_3, a_4] is not good, since it contains a bad triple (a_1, 1), (a_2, 2), (a_4, 4):
* d((a_1, 1), (a_4, 4)) = |6 - 9| + |1 - 4| = 6;
* d((a_1, 1), (a_2, 2)) = |6 - 9| + |1 - 2| = 4;
* d((a_2, 2), (a_4, 4)) = |9 - 9| + |2 - 4| = 2;
So, d((a_1, 1), (a_4, 4)) = d((a_1, 1), (a_2, 2)) + d((a_2, 2), (a_4, 4)). | def fun(arr):
total = 2*n - 1
for i in range(n-2):
total += (arr[i]-arr[i+1]) * (arr[i+1]-arr[i+2]) < 0
for i in range(n-3):
total += ((arr[i+1]-arr[i+3])*(arr[i+3]-arr[i+2]) > 0 and (arr[i+1]-arr[i])*(arr[i]-arr[i+2]) > 0)
print(total)
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
fun(arr) | {
"input": [
"3\n4\n2 4 1 3\n5\n6 9 1 9 6\n2\n13 37\n"
],
"output": [
"10\n12\n3\n"
]
} |
2,928 | 7 | The Smart Beaver from ABBYY got hooked on square matrices. Now he is busy studying an n Γ n size matrix, where n is odd. The Smart Beaver considers the following matrix elements good:
* Elements of the main diagonal.
* Elements of the secondary diagonal.
* Elements of the "middle" row β the row which has exactly <image> rows above it and the same number of rows below it.
* Elements of the "middle" column β the column that has exactly <image> columns to the left of it and the same number of columns to the right of it.
<image> The figure shows a 5 Γ 5 matrix. The good elements are marked with green.
Help the Smart Beaver count the sum of good elements of the given matrix.
Input
The first line of input data contains a single odd integer n. Each of the next n lines contains n integers aij (0 β€ aij β€ 100) separated by single spaces β the elements of the given matrix.
The input limitations for getting 30 points are:
* 1 β€ n β€ 5
The input limitations for getting 100 points are:
* 1 β€ n β€ 101
Output
Print a single integer β the sum of good matrix elements.
Examples
Input
3
1 2 3
4 5 6
7 8 9
Output
45
Input
5
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
Output
17
Note
In the first sample all matrix elements will be good. Good elements in the second sample are shown on the figure. | #!/usr/bin/python3
def readln(): return tuple(map(int, input().split()))
n, = readln()
a = [readln() for _ in range(n)]
m = n // 2
print(sum([a[i][i] + a[i][n - i - 1] + a[m][i] + a[i][m] for i in range(n)]) - 3 * a[m][m])
| {
"input": [
"3\n1 2 3\n4 5 6\n7 8 9\n",
"5\n1 1 1 1 1\n1 1 1 1 1\n1 1 1 1 1\n1 1 1 1 1\n1 1 1 1 1\n"
],
"output": [
"45",
"17"
]
} |
2,929 | 9 | You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 β€ p1 < p2 < ... < pk β€ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA | def lms(s):
t=""
if len(s)==1:
return s
else:
while(len(s)>1):
l=0
j=0
for i in range(len(s)):
if ord(s[i])>l:
l=ord(s[i])
j=i
t+= (s.count(s[j]))*s[j]
y = len(s) - 1 - s[::-1].index(s[j])
s=s[y+1:]
if len(set(map(str,s)))==1:
t+=s
break
return t
print(lms(input())) | {
"input": [
"abbcbccacbbcbaaba\n",
"ababba\n"
],
"output": [
"cccccbba\n",
"bbba\n"
]
} |
2,930 | 9 | Once Bob decided to lay a parquet floor in his living room. The living room is of size n Γ m metres. Bob had planks of three types: a planks 1 Γ 2 meters, b planks 2 Γ 1 meters, and c planks 2 Γ 2 meters. Help Bob find out, if it is possible to parquet the living room with such a set of planks, and if it is possible, find one of the possible ways to do so. Bob doesn't have to use all the planks.
Input
The first input line contains 5 space-separated integer numbers n, m, a, b, c (1 β€ n, m β€ 100, 0 β€ a, b, c β€ 104), n and m β the living room dimensions, a, b and c β amount of planks 1 Γ 2, 2 Γ 1 ΠΈ 2 Γ 2 respectively. It's not allowed to turn the planks.
Output
If it is not possible to parquet the room with such a set of planks, output IMPOSSIBLE. Otherwise output one of the possible ways to parquet the room β output n lines with m lower-case Latin letters each. Two squares with common sides should contain the same letters, if they belong to one and the same plank, and different letters otherwise. Different planks can be marked with one and the same letter (see examples). If the answer is not unique, output any.
Examples
Input
2 6 2 2 1
Output
aabcca
aabdda
Input
1 1 100 100 100
Output
IMPOSSIBLE
Input
4 4 10 10 10
Output
aabb
aabb
bbaa
bbaa | import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n, m, b, a, c = map(int, input().split())
def ng():
print('IMPOSSIBLE')
exit()
if (n * m) & 1:
ng()
ans = [['*'] * m for _ in range(n)]
if n % 2:
s = ['y', 'z']
for i, j in enumerate(range(0, m, 2)):
ans[-1][j] = ans[-1][j + 1] = s[i & 1]
b -= 1
if m % 2:
s = ['y', 'z']
for i, j in enumerate(range(0, n, 2)):
ans[j][-1] = ans[j + 1][-1] = s[i & 1]
a -= 1
s1 = [['a', 'b'], ['c', 'd']]
s2 = [['e', 'f'], ['g', 'h']]
for i in range(0, n - (n & 1), 2):
for j in range(0, m - (m & 1), 2):
if c:
ans[i][j] = ans[i + 1][j] = ans[i][j + 1] = ans[i + 1][j + 1] = s1[0][0]
c -= 1
elif a >= 2:
ans[i][j] = ans[i + 1][j] = s1[0][0]
ans[i][j + 1] = ans[i + 1][j + 1] = s1[0][1]
a -= 2
else:
ans[i][j] = ans[i][j + 1] = s1[0][0]
ans[i + 1][j] = ans[i + 1][j + 1] = s1[0][1]
b -= 2
s1[0], s1[1] = s1[1], s1[0]
s1, s2 = s2, s1
if a < 0 or b < 0:
ng()
else:
for row in ans:
print(*row, sep='')
| {
"input": [
"2 6 2 2 1\n",
"4 4 10 10 10\n",
"1 1 100 100 100\n"
],
"output": [
"aabbab\naaccab\n",
"aabb\naabb\nbbaa\nbbaa\n",
"IMPOSSIBLE\n"
]
} |
2,931 | 11 | We often have to copy large volumes of information. Such operation can take up many computer resources. Therefore, in this problem you are advised to come up with a way to copy some part of a number array into another one, quickly.
More formally, you've got two arrays of integers a1, a2, ..., an and b1, b2, ..., bn of length n. Also, you've got m queries of two types:
1. Copy the subsegment of array a of length k, starting from position x, into array b, starting from position y, that is, execute by + q = ax + q for all integer q (0 β€ q < k). The given operation is correct β both subsegments do not touch unexistent elements.
2. Determine the value in position x of array b, that is, find value bx.
For each query of the second type print the result β the value of the corresponding element of array b.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 105) β the number of elements in the arrays and the number of queries, correspondingly. The second line contains an array of integers a1, a2, ..., an (|ai| β€ 109). The third line contains an array of integers b1, b2, ..., bn (|bi| β€ 109).
Next m lines contain the descriptions of the queries. The i-th line first contains integer ti β the type of the i-th query (1 β€ ti β€ 2). If ti = 1, then the i-th query means the copying operation. If ti = 2, then the i-th query means taking the value in array b. If ti = 1, then the query type is followed by three integers xi, yi, ki (1 β€ xi, yi, ki β€ n) β the parameters of the copying query. If ti = 2, then the query type is followed by integer xi (1 β€ xi β€ n) β the position in array b.
All numbers in the lines are separated with single spaces. It is guaranteed that all the queries are correct, that is, the copying borders fit into the borders of arrays a and b.
Output
For each second type query print the result on a single line.
Examples
Input
5 10
1 2 0 -1 3
3 1 5 -2 0
2 5
1 3 3 3
2 5
2 4
2 1
1 2 1 4
2 1
2 4
1 4 2 1
2 2
Output
0
3
-1
3
2
3
-1 | import sys
'''
SEGMENT TREE
Assign
'''
class SegmTree():
'''
- modify elements on interval
- get single element
'''
def __init__(self, size):
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2*N)
def modify_range(self, l, r, value):
l += self.N
r += self.N
while l < r:
if l & 1:
self.tree[l] = value
l += 1
if r & 1:
r -= 1
self.tree[r] = value
l >>= 1
r >>= 1
def query(self, i):
i += self.N
latest_change = self.tree[i]
p = i
while p > 1:
p >>= 1
latest_change = max(latest_change, self.tree[p])
return latest_change
# inf = open('input.txt', 'r')
# reader = (map(int, line.split()) for line in inf)
reader = (map(int, line.split()) for line in sys.stdin)
input = reader.__next__
n, m = input()
a = list(input())
b = list(input())
st = SegmTree(n)
request = [None] * (m + 1)
for i in range(1, m+1):
t, *arg = input()
if t == 1:
x, y, k = request[i] = arg
st.modify_range(y-1, y-1+k, i)
else:
pos = arg[0] - 1
req_id = st.query(pos)
if req_id > 0:
x, y, k = request[req_id]
ans = a[x+(pos-y)]
else:
ans = b[pos]
sys.stdout.write(f'{ans}\n')
# inf.close()
| {
"input": [
"5 10\n1 2 0 -1 3\n3 1 5 -2 0\n2 5\n1 3 3 3\n2 5\n2 4\n2 1\n1 2 1 4\n2 1\n2 4\n1 4 2 1\n2 2\n"
],
"output": [
"0\n3\n-1\n3\n2\n3\n-1\n"
]
} |
2,932 | 9 | Iahub is a big fan of tourists. He wants to become a tourist himself, so he planned a trip. There are n destinations on a straight road that Iahub wants to visit. Iahub starts the excursion from kilometer 0. The n destinations are described by a non-negative integers sequence a1, a2, ..., an. The number ak represents that the kth destination is at distance ak kilometers from the starting point. No two destinations are located in the same place.
Iahub wants to visit each destination only once. Note that, crossing through a destination is not considered visiting, unless Iahub explicitly wants to visit it at that point. Also, after Iahub visits his last destination, he doesn't come back to kilometer 0, as he stops his trip at the last destination.
The distance between destination located at kilometer x and next destination, located at kilometer y, is |x - y| kilometers. We call a "route" an order of visiting the destinations. Iahub can visit destinations in any order he wants, as long as he visits all n destinations and he doesn't visit a destination more than once.
Iahub starts writing out on a paper all possible routes and for each of them, he notes the total distance he would walk. He's interested in the average number of kilometers he would walk by choosing a route. As he got bored of writing out all the routes, he asks you to help him.
Input
The first line contains integer n (2 β€ n β€ 105). Next line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 107).
Output
Output two integers β the numerator and denominator of a fraction which is equal to the wanted average number. The fraction must be irreducible.
Examples
Input
3
2 3 5
Output
22 3
Note
Consider 6 possible routes:
* [2, 3, 5]: total distance traveled: |2 β 0| + |3 β 2| + |5 β 3| = 5;
* [2, 5, 3]: |2 β 0| + |5 β 2| + |3 β 5| = 7;
* [3, 2, 5]: |3 β 0| + |2 β 3| + |5 β 2| = 7;
* [3, 5, 2]: |3 β 0| + |5 β 3| + |2 β 5| = 8;
* [5, 2, 3]: |5 β 0| + |2 β 5| + |3 β 2| = 9;
* [5, 3, 2]: |5 β 0| + |3 β 5| + |2 β 3| = 8.
The average travel distance is <image> = <image> = <image>. | def gcd(a, b): return gcd(b % a, a) if a else b
n = int(input())
a = sorted(map(int, input().split()))
p, q = 0, n
for i in range(1, n): p += i * (n - i) * (a[i] - a[i - 1])
p = 2 * p + sum(a)
r = gcd(p, q)
print(p // r, q // r)
| {
"input": [
"3\n2 3 5\n"
],
"output": [
"22 3"
]
} |
2,933 | 10 | George loves graphs. Most of all, he loves interesting graphs. We will assume that a directed graph is interesting, if it meets the following criteria:
* The graph doesn't contain any multiple arcs;
* There is vertex v (we'll call her the center), such that for any vertex of graph u, the graph contains arcs (u, v) and (v, u). Please note that the graph also contains loop (v, v).
* The outdegree of all vertexes except for the center equals two and the indegree of all vertexes except for the center equals two. The outdegree of vertex u is the number of arcs that go out of u, the indegree of vertex u is the number of arcs that go in u. Please note that the graph can contain loops.
However, not everything's that simple. George got a directed graph of n vertices and m arcs as a present. The graph didn't have any multiple arcs. As George loves interesting graphs, he wants to slightly alter the presented graph and transform it into an interesting one. In one alteration he can either remove an arbitrary existing arc from the graph or add an arbitrary arc to the graph.
George wonders: what is the minimum number of changes that he needs to obtain an interesting graph from the graph he's got as a present? Help George and find the answer to the question.
Input
The first line contains two space-separated integers n and m (2 β€ n β€ 500, 1 β€ m β€ 1000) β the number of vertices and arcs in the presented graph.
Each of the next m lines contains two space-separated integers ai, bi (1 β€ ai, bi β€ n) β the descriptions of the graph's arcs. Pair (ai, bi) means that the graph contains an arc from vertex number ai to vertex number bi. It is guaranteed that the presented graph doesn't contain multiple arcs.
Assume that the grah vertices are numbered 1 through n.
Output
Print a single integer β the answer to George's question.
Examples
Input
3 7
1 1
2 2
3 1
1 3
3 2
2 3
3 3
Output
0
Input
3 6
1 1
2 2
3 1
3 2
2 3
3 3
Output
1
Input
3 1
2 2
Output
6
Note
For more information about directed graphs, please visit: http://en.wikipedia.org/wiki/Directed_graph
In the first sample the graph already is interesting, its center is vertex 3. | # by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def matching(n,m,path):
# Hopkrocft Karp O(EV^0.5)
match1 = [-1]*n
match2 = [-1]*m
for node in range(n):
for nei in path[node]:
if match2[nei] == -1:
match1[node] = nei
match2[nei] = node
break
while 1:
bfs = [node for node in range(n) if match1[node] == -1]
depth = [-1]*n
for node in bfs:
depth[node] = 0
for node in bfs:
for nei in path[node]:
next_node = match2[nei]
if next_node == -1:
break
if depth[next_node] == -1:
depth[next_node] = depth[node]+1
bfs.append(next_node)
else:
continue
break
else:
break
pointer = [len(c) for c in path]
dfs = [node for node in range(n) if depth[node] == 0]
while dfs:
node = dfs[-1]
while pointer[node]:
pointer[node] -= 1
nei = path[node][pointer[node]]
next_node = match2[nei]
if next_node == -1:
while nei != -1:
node = dfs.pop()
match2[nei],match1[node],nei = node,nei,match1[node]
break
elif depth[node]+1 == depth[next_node]:
dfs.append(next_node)
break
else:
dfs.pop()
return n-match1.count(-1)
def main():
n,m = map(int,input().split())
edg = [tuple(map(lambda xx:int(xx)-1,input().split())) for _ in range(m)]
ans = float("inf")
for centre in range(n):
path = [[] for _ in range(n)]
cost = 2*n-1
extra = m
for u,v in edg:
if u == centre or v == centre:
cost -= 1
extra -= 1
else:
path[u].append(v)
maxMatch = matching(n,n,path)
extra -= maxMatch
cost += n-1-maxMatch+extra
ans = min(ans,cost)
print(ans)
# Fast IO Region
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")
if __name__ == "__main__":
main() | {
"input": [
"3 1\n2 2\n",
"3 6\n1 1\n2 2\n3 1\n3 2\n2 3\n3 3\n",
"3 7\n1 1\n2 2\n3 1\n1 3\n3 2\n2 3\n3 3\n"
],
"output": [
"6\n",
"1\n",
"0\n"
]
} |
2,934 | 8 | Once little Vasya read an article in a magazine on how to make beautiful handmade garland from colored paper. Vasya immediately went to the store and bought n colored sheets of paper, the area of each sheet is 1 square meter.
The garland must consist of exactly m pieces of colored paper of arbitrary area, each piece should be of a certain color. To make the garland, Vasya can arbitrarily cut his existing colored sheets into pieces. Vasya is not obliged to use all the sheets to make the garland.
Vasya wants the garland to be as attractive as possible, so he wants to maximize the total area of ββm pieces of paper in the garland. Calculate what the maximum total area of ββthe pieces of paper in the garland Vasya can get.
Input
The first line contains a non-empty sequence of n (1 β€ n β€ 1000) small English letters ("a"..."z"). Each letter means that Vasya has a sheet of paper of the corresponding color.
The second line contains a non-empty sequence of m (1 β€ m β€ 1000) small English letters that correspond to the colors of the pieces of paper in the garland that Vasya wants to make.
Output
Print an integer that is the maximum possible total area of the pieces of paper in the garland Vasya wants to get or -1, if it is impossible to make the garland from the sheets he's got. It is guaranteed that the answer is always an integer.
Examples
Input
aaabbac
aabbccac
Output
6
Input
a
z
Output
-1
Note
In the first test sample Vasya can make an garland of area 6: he can use both sheets of color b, three (but not four) sheets of color a and cut a single sheet of color c in three, for example, equal pieces. Vasya can use the resulting pieces to make a garland of area 6.
In the second test sample Vasya cannot make a garland at all β he doesn't have a sheet of color z. | def garland(a,b):
ans=0
for i in set(b):
mini=min(a.count(i),b.count(i))
if mini==0:
return -1
ans+=mini
return ans
a=input()
b=input()
print(garland(a,b)) | {
"input": [
"aaabbac\naabbccac\n",
"a\nz\n"
],
"output": [
"6\n",
"-1\n"
]
} |
2,935 | 9 | In this problem, your task is to use ASCII graphics to paint a cardiogram.
A cardiogram is a polyline with the following corners:
<image>
That is, a cardiogram is fully defined by a sequence of positive integers a1, a2, ..., an.
Your task is to paint a cardiogram by given sequence ai.
Input
The first line contains integer n (2 β€ n β€ 1000). The next line contains the sequence of integers a1, a2, ..., an (1 β€ ai β€ 1000). It is guaranteed that the sum of all ai doesn't exceed 1000.
Output
Print max |yi - yj| lines (where yk is the y coordinate of the k-th point of the polyline), in each line print <image> characters. Each character must equal either Β« / Β» (slash), Β« \ Β» (backslash), Β« Β» (space). The printed image must be the image of the given polyline. Please study the test samples for better understanding of how to print a cardiogram.
Note that in this problem the checker checks your answer taking spaces into consideration. Do not print any extra characters. Remember that the wrong answer to the first pretest doesn't give you a penalty.
Examples
Input
5
3 1 2 5 1
Output
<span class="tex-span">β/β</span><span class="tex-span">\</span>
<span class="tex-span">β/β</span><span class="tex-span">\</span><span class="tex-span">β/β</span> <span class="tex-span">\</span>
<span class="tex-span">β/β</span> <span class="tex-span">\</span>
<span class="tex-span">β/β</span> <span class="tex-span">\</span>
<span class="tex-span">\</span><span class="tex-span">β/β</span>
Input
3
1 5 1
Output
<span class="tex-span">β/β</span><span class="tex-span">\</span>
<span class="tex-span">\</span>
<span class="tex-span">\</span>
<span class="tex-span">\</span>
<span class="tex-span">\</span><span class="tex-span">β/β</span>
Note
Due to the technical reasons the answers for the samples cannot be copied from the statement. We've attached two text documents with the answers below.
http://assets.codeforces.com/rounds/435/1.txt
http://assets.codeforces.com/rounds/435/2.txt | import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
n = mint()
y = 0
x = 0
a = []
t = 0
mx = dict()
my = 10**9
for i in mints():
for j in range(i):
if t == 0:
a.append((x,y,'/'))
mx[y] = max(mx.get(y, -1), x)
my = min(my, y)
y -= 1
else:
y += 1
a.append((x,y,'\\'))
mx[y] = max(mx.get(y, -1), x)
my = min(my, y)
x += 1
t ^= 1
i = 0
b = []
while (my+i) in mx:
b.append([' ']*(mx[my+i]+1))
i += 1
for i in a:
b[i[1]-my][i[0]] = i[2]
for i in b:
print(*(i+[' ']*(x-len(i))),sep='')
| {
"input": [
"5\n3 1 2 5 1\n",
"3\n1 5 1\n"
],
"output": [
" /\\ \n /\\/ \\ \n / \\ \n/ \\ \n \\/",
"/\\ \n \\ \n \\ \n \\ \n \\/"
]
} |
2,936 | 9 | Vasya trains to compose crossword puzzles. He can only compose crosswords of a very simplΠ΅ type so far. All of them consist of exactly six words; the words can be read only from top to bottom vertically and from the left to the right horizontally. The words are arranged in the form of a rectangular "eight" or infinity sign, not necessarily symmetrical.
The top-left corner of the crossword coincides with the top-left corner of the rectangle. The same thing is correct for the right-bottom corners. The crossword can't degrade, i.e. it always has exactly four blank areas, two of which are surrounded by letters. Look into the output for the samples for clarification.
Help Vasya β compose a crossword of the described type using the given six words. It is allowed to use the words in any order.
Input
Six lines contain the given words. Every word consists of no more than 30 and no less than 3 uppercase Latin letters.
Output
If it is impossible to solve the problem, print Impossible. Otherwise, print the sought crossword. All the empty squares should be marked as dots.
If there can be several solutions to that problem, print the lexicographically minimum one. I.e. the solution where the first line is less than the first line of other solutions should be printed. If the two lines are equal, compare the second lines and so on. The lexicographical comparison of lines is realized by the < operator in the modern programming languages.
Examples
Input
NOD
BAA
YARD
AIRWAY
NEWTON
BURN
Output
BAA...
U.I...
R.R...
NEWTON
..A..O
..YARD
Input
AAA
AAA
AAAAA
AAA
AAA
AAAAA
Output
AAA..
A.A..
AAAAA
..A.A
..AAA
Input
PTC
JYNYFDSGI
ZGPPC
IXEJNDOP
JJFS
SSXXQOFGJUZ
Output
JJFS....
Y..S....
N..X....
Y..X....
F..Q....
D..O....
S..F....
G..G....
IXEJNDOP
...U...T
...ZGPPC | import sys
from array import array # noqa: F401
from itertools import permutations
def input():
return sys.stdin.buffer.readline().decode('utf-8')
a = [input().rstrip() for _ in range(6)]
ans = ['z' * 100 for _ in range(6)]
inf = ['z' * 100 for _ in range(6)]
for words in permutations(a):
if (
len(words[0]) + len(words[4]) - 1 == len(words[2])
and len(words[1]) + len(words[5]) - 1 == len(words[3])
and words[0][0] == words[1][0]
and words[1][-1] == words[2][0]
and words[0][-1] == words[3][0]
and words[2][len(words[0]) - 1] == words[3][len(words[1]) - 1]
and words[2][-1] == words[5][0]
and words[3][-1] == words[4][0]
and words[4][-1] == words[5][-1]
):
res = [['.'] * len(words[2]) for _ in range(len(words[3]))]
for i in range(len(words[0])):
res[0][i] = words[0][i]
for i in range(len(words[1])):
res[i][0] = words[1][i]
for i in range(len(words[2])):
res[len(words[1]) - 1][i] = words[2][i]
for i in range(len(words[3])):
res[i][len(words[0]) - 1] = words[3][i]
for i in range(len(words[4])):
res[len(words[3]) - 1][len(words[0]) - 1 + i] = words[4][i]
for i in range(len(words[5])):
res[len(words[1]) - 1 + i][len(words[2]) - 1] = words[5][i]
res = [''.join(row) for row in res]
if ans > res:
ans = res
if ans == inf:
print('Impossible')
else:
print('\n'.join(ans))
| {
"input": [
"NOD\nBAA\nYARD\nAIRWAY\nNEWTON\nBURN\n",
"PTC\nJYNYFDSGI\nZGPPC\nIXEJNDOP\nJJFS\nSSXXQOFGJUZ\n",
"AAA\nAAA\nAAAAA\nAAA\nAAA\nAAAAA\n"
],
"output": [
"BAA...\nU.I...\nR.R...\nNEWTON\n..A..O\n..YARD\n",
"JJFS....\nY..S....\nN..X....\nY..X....\nF..Q....\nD..O....\nS..F....\nG..G....\nIXEJNDOP\n...U...T\n...ZGPPC\n",
"AAA..\nA.A..\nAAAAA\n..A.A\n..AAA\n"
]
} |
2,937 | 7 | Leonid wants to become a glass carver (the person who creates beautiful artworks by cutting the glass). He already has a rectangular w mm Γ h mm sheet of glass, a diamond glass cutter and lots of enthusiasm. What he lacks is understanding of what to carve and how.
In order not to waste time, he decided to practice the technique of carving. To do this, he makes vertical and horizontal cuts through the entire sheet. This process results in making smaller rectangular fragments of glass. Leonid does not move the newly made glass fragments. In particular, a cut divides each fragment of glass that it goes through into smaller fragments.
After each cut Leonid tries to determine what area the largest of the currently available glass fragments has. Since there appear more and more fragments, this question takes him more and more time and distracts him from the fascinating process.
Leonid offers to divide the labor β he will cut glass, and you will calculate the area of the maximum fragment after each cut. Do you agree?
Input
The first line contains three integers w, h, n (2 β€ w, h β€ 200 000, 1 β€ n β€ 200 000).
Next n lines contain the descriptions of the cuts. Each description has the form H y or V x. In the first case Leonid makes the horizontal cut at the distance y millimeters (1 β€ y β€ h - 1) from the lower edge of the original sheet of glass. In the second case Leonid makes a vertical cut at distance x (1 β€ x β€ w - 1) millimeters from the left edge of the original sheet of glass. It is guaranteed that Leonid won't make two identical cuts.
Output
After each cut print on a single line the area of the maximum available glass fragment in mm2.
Examples
Input
4 3 4
H 2
V 2
V 3
V 1
Output
8
4
4
2
Input
7 6 5
H 4
V 3
V 5
H 2
V 1
Output
28
16
12
6
4
Note
Picture for the first sample test:
<image> Picture for the second sample test: <image> | def main():
w, h, n = map(int, input().split())
res, vrt, hor = [], [], []
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0])
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag] = v
print('\n'.join(map(str, res)))
if __name__ == '__main__':
main()
| {
"input": [
"4 3 4\nH 2\nV 2\nV 3\nV 1\n",
"7 6 5\nH 4\nV 3\nV 5\nH 2\nV 1\n"
],
"output": [
"8\n4\n4\n2\n",
"28\n16\n12\n6\n4\n"
]
} |
2,938 | 10 | Nudist Beach is planning a military operation to attack the Life Fibers. In this operation, they will attack and capture several cities which are currently under the control of the Life Fibers.
There are n cities, labeled from 1 to n, and m bidirectional roads between them. Currently, there are Life Fibers in every city. In addition, there are k cities that are fortresses of the Life Fibers that cannot be captured under any circumstances. So, the Nudist Beach can capture an arbitrary non-empty subset of cities with no fortresses.
After the operation, Nudist Beach will have to defend the captured cities from counterattack. If they capture a city and it is connected to many Life Fiber controlled cities, it will be easily defeated. So, Nudist Beach would like to capture a set of cities such that for each captured city the ratio of Nudist Beach controlled neighbors among all neighbors of that city is as high as possible.
More formally, they would like to capture a non-empty set of cities S with no fortresses of Life Fibers. The strength of a city <image> is defined as (number of neighbors of x in S) / (total number of neighbors of x). Here, two cities are called neighbors if they are connnected with a road. The goal is to maximize the strength of the weakest city in S.
Given a description of the graph, and the cities with fortresses, find a non-empty subset that maximizes the strength of the weakest city.
Input
The first line of input contains three integers n, m, k (2 β€ n β€ 100 000, 1 β€ m β€ 100 000, 1 β€ k β€ n - 1).
The second line of input contains k integers, representing the cities with fortresses. These cities will all be distinct.
The next m lines contain the roads. The i-th of these lines will have 2 integers ai, bi (1 β€ ai, bi β€ n, ai β bi). Every city will have at least one road adjacent to it.
There is no more than one road between each pair of the cities.
Output
The first line should contain an integer r, denoting the size of an optimum set (1 β€ r β€ n - k).
The second line should contain r integers, denoting the cities in the set. Cities may follow in an arbitrary order. This line should not contain any of the cities with fortresses.
If there are multiple possible answers, print any of them.
Examples
Input
9 8 4
3 9 6 8
1 2
1 3
1 4
1 5
2 6
2 7
2 8
2 9
Output
3
1 4 5
Input
10 8 2
2 9
1 3
2 9
4 5
5 6
6 7
7 8
8 10
10 4
Output
8
1 5 4 8 10 6 3 7
Note
The first example case achieves a strength of 1/2. No other subset is strictly better.
The second example case achieves a strength of 1. Note that the subset doesn't necessarily have to be connected. | import heapq
def read_data():
'''
n: number of cities
m: number of roads
k: initial numuber of fortresses of Life Fibers
Es: list of edges
fs: fs[i] = True -> city i is under control of Life Fibers
gs: gs[i] number of edges connected to city i
hs: hs[i] number of adjacent cities under control of Life Fibers
'''
n, m, k = map(int, input().split())
Es = [[] for i in range(n)]
fs = [False] * n
gs = [0.0] * n
hs = [0.0] * n
fortresses = list(map(int, input().split()))
for f in fortresses:
fs[f-1] = True
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
Es[a].append(b)
Es[b].append(a)
gs[a] += 1
gs[b] += 1
hs[a] += fs[b]
hs[b] += fs[a]
return n, m, k, fs, gs, hs, Es
def solve(n, m, k, fs, gs, hs, Es):
hq = [(-h/g, i) for i, (g, h) in enumerate(zip(gs, hs))]
hq.sort()
f_diff = set()
while hq:
p, i = heapq.heappop(hq)
if fs[i] or i in f_diff:
continue
update_fs(fs, f_diff)
f_diff = set()
dfs(p, i, hq, f_diff, fs, gs, hs, Es)
return [i + 1 for i, f in enumerate(fs) if not f]
def update_fs(fs, f_diff):
for f in f_diff:
fs[f] = True
def dfs(p, i, hq, f_diff, fs, gs, hs, Es):
fifo = [i]
f_diff.add(i)
while fifo:
i = fifo.pop(-1)
for j in Es[i]:
if fs[j] or j in f_diff:
continue
hs[j] += 1
pj = -hs[j]/gs[j]
if pj > p:
heapq.heappush(hq, (pj, j))
else:
fifo.append(j)
f_diff.add(j)
if __name__ == '__main__':
n, m, k, fs, gs, hs, Es = read_data()
beaches = solve(n, m, k, fs, gs, hs, Es)
print(len(beaches))
print(*beaches) | {
"input": [
"10 8 2\n2 9\n1 3\n2 9\n4 5\n5 6\n6 7\n7 8\n8 10\n10 4\n",
"9 8 4\n3 9 6 8\n1 2\n1 3\n1 4\n1 5\n2 6\n2 7\n2 8\n2 9\n"
],
"output": [
"8\n1 3 4 5 6 7 8 10 ",
"3\n1 4 5 "
]
} |
2,939 | 9 | Chris the Rabbit has been interested in arrays ever since he was a child. At the moment he is researching arrays with the length of n, containing only integers from 1 to n. He is not good at math, that's why some simple things drive him crazy. For example, yesterday he grew keen on counting how many different beautiful arrays there are. Chris thinks that an array is beautiful if it meets one of the two conditions:
* each elements, starting from the second one, is no more than the preceding one
* each element, starting from the second one, is no less than the preceding one
Having got absolutely mad at himself and at math, Chris came to Stewie and Brian to ask them for help. However, they only laughed at him and said that the answer is too simple and not interesting. Help Chris the Rabbit to find the answer at last.
Input
The single line contains an integer n which is the size of the array (1 β€ n β€ 105).
Output
You must print the answer on a single line. As it can be rather long, you should print it modulo 1000000007.
Examples
Input
2
Output
4
Input
3
Output
17 | def fact(n):
res=1
for i in range(2,n+1):
res=(res*i)%(10**9+7)
return res
def rev(a):
return pow(a,10**9+5,10**9+7)
def c2nn(n):
return fact(2*n)*(rev(fact(n))**2)%(10**9+7)
n=int(input())
print(c2nn(n)-n) | {
"input": [
"2\n",
"3\n"
],
"output": [
"4\n",
"17\n"
]
} |
2,940 | 8 | A function <image> is called Lipschitz continuous if there is a real constant K such that the inequality |f(x) - f(y)| β€ KΒ·|x - y| holds for all <image>. We'll deal with a more... discrete version of this term.
For an array <image>, we define it's Lipschitz constant <image> as follows:
* if n < 2, <image>
* if n β₯ 2, <image> over all 1 β€ i < j β€ n
In other words, <image> is the smallest non-negative integer such that |h[i] - h[j]| β€ LΒ·|i - j| holds for all 1 β€ i, j β€ n.
You are given an array <image> of size n and q queries of the form [l, r]. For each query, consider the subarray <image>; determine the sum of Lipschitz constants of all subarrays of <image>.
Input
The first line of the input contains two space-separated integers n and q (2 β€ n β€ 100 000 and 1 β€ q β€ 100) β the number of elements in array <image> and the number of queries respectively.
The second line contains n space-separated integers <image> (<image>).
The following q lines describe queries. The i-th of those lines contains two space-separated integers li and ri (1 β€ li < ri β€ n).
Output
Print the answers to all queries in the order in which they are given in the input. For the i-th query, print one line containing a single integer β the sum of Lipschitz constants of all subarrays of <image>.
Examples
Input
10 4
1 5 2 9 1 3 4 2 1 7
2 4
3 8
7 10
1 9
Output
17
82
23
210
Input
7 6
5 7 7 4 6 6 2
1 2
2 3
2 6
1 7
4 7
3 5
Output
2
0
22
59
16
8
Note
In the first query of the first sample, the Lipschitz constants of subarrays of <image> with length at least 2 are:
* <image>
* <image>
* <image>
The answer to the query is their sum. | def read_data():
n, q = map(int, input().split())
As = list(map(int, input().split()))
LRs = []
for i in range(q):
L, R = list(map(int, input().split()))
LRs.append((L, R))
return n, q, As, LRs
def solve(n, q, As, LRs):
difs = calc_difs(As)
Ls = get_Ls(difs)
Rs = get_Rs_allow_ties(difs)
for L, R in LRs:
print(calc(L-1, R-2, Ls, Rs, difs))
def calc_difs(As):
difs = [abs(a0 - a1) for a0, a1 in zip(As, As[1:])]
return difs
def get_Ls(Vs):
L = []
st = []
for i, v in enumerate(Vs):
while st and Vs[st[-1]] < v:
st.pop()
if st:
L.append(st[-1] + 1)
else:
L.append(0)
st.append(i)
return L
def get_Ls_allow_ties(Vs):
L = []
st = []
for i, v in enumerate(Vs):
while st and Vs[st[-1]] <= v:
st.pop()
if st:
L.append(st[-1] + 1)
else:
L.append(0)
st.append(i)
return L
def get_Rs(Vs):
n = len(Vs)
revVs = Vs[::-1]
revRs = get_Ls(revVs)
revRs.reverse()
return [n - 1 - R for R in revRs]
def get_Rs_allow_ties(Vs):
n = len(Vs)
revVs = Vs[::-1]
revRs = get_Ls_allow_ties(revVs)
revRs.reverse()
return [n - 1 - R for R in revRs]
def calc(L, R, Ls, Rs, difs):
ans = 0
for i in range(L, R + 1):
ans += difs[i] * (i - max(Ls[i], L) + 1) * (min(Rs[i], R) - i + 1)
return ans
n, q, As, LRs = read_data()
solve(n, q, As, LRs) | {
"input": [
"7 6\n5 7 7 4 6 6 2\n1 2\n2 3\n2 6\n1 7\n4 7\n3 5\n",
"10 4\n1 5 2 9 1 3 4 2 1 7\n2 4\n3 8\n7 10\n1 9\n"
],
"output": [
"2\n0\n22\n59\n16\n8\n",
"17\n82\n23\n210\n"
]
} |
2,941 | 10 | While Farmer John rebuilds his farm in an unfamiliar portion of Bovinia, Bessie is out trying some alternative jobs. In her new gig as a reporter, Bessie needs to know about programming competition results as quickly as possible. When she covers the 2016 Robot Rap Battle Tournament, she notices that all of the robots operate under deterministic algorithms. In particular, robot i will beat robot j if and only if robot i has a higher skill level than robot j. And if robot i beats robot j and robot j beats robot k, then robot i will beat robot k. Since rapping is such a subtle art, two robots can never have the same skill level.
Given the results of the rap battles in the order in which they were played, determine the minimum number of first rap battles that needed to take place before Bessie could order all of the robots by skill level.
Input
The first line of the input consists of two integers, the number of robots n (2 β€ n β€ 100 000) and the number of rap battles m (<image>).
The next m lines describe the results of the rap battles in the order they took place. Each consists of two integers ui and vi (1 β€ ui, vi β€ n, ui β vi), indicating that robot ui beat robot vi in the i-th rap battle. No two rap battles involve the same pair of robots.
It is guaranteed that at least one ordering of the robots satisfies all m relations.
Output
Print the minimum k such that the ordering of the robots by skill level is uniquely defined by the first k rap battles. If there exists more than one ordering that satisfies all m relations, output -1.
Examples
Input
4 5
2 1
1 3
2 3
4 2
4 3
Output
4
Input
3 2
1 2
3 2
Output
-1
Note
In the first sample, the robots from strongest to weakest must be (4, 2, 1, 3), which Bessie can deduce after knowing the results of the first four rap battles.
In the second sample, both (1, 3, 2) and (3, 1, 2) are possible orderings of the robots from strongest to weakest after both rap battles. | from collections import defaultdict,deque
def bfs(q,n,mid):
g=defaultdict(list)
vis=[0]*(n)
for i in range(mid):
x,y=q[i]
g[x].append(y)
vis[y]+=1
q=deque()
for i in range(n):
if vis[i]==0:
q.append(i)
flag=True
cnt=0
while q and flag:
# print(q)
if len(q)!=1 : # ek se zyada winner us pos ke liye
flag=False
t=q.popleft()
cnt+=1
for i in g[t]:
vis[i]-=1
if vis[i]==0:
q.append(i)
return cnt==n and flag==True
def f(q,n):
lo=0
hi=len(q)
ans=-1
while lo<=hi:
mid=(lo+hi)//2
if bfs(q,n,mid):
ans=mid
hi=mid-1
else:
lo=mid+1
return ans
q=[]
n,m=map(int,input().strip().split())
for _ in range(m):
x,y=map(int,input().strip().split())
q.append((x-1,y-1))
print(f(q,n)) | {
"input": [
"3 2\n1 2\n3 2\n",
"4 5\n2 1\n1 3\n2 3\n4 2\n4 3\n"
],
"output": [
"-1",
"4"
]
} |
2,942 | 8 | A wise man told Kerem "Different is good" once, so Kerem wants all things in his life to be different.
Kerem recently got a string s consisting of lowercase English letters. Since Kerem likes it when things are different, he wants all substrings of his string s to be distinct. Substring is a string formed by some number of consecutive characters of the string. For example, string "aba" has substrings "" (empty substring), "a", "b", "a", "ab", "ba", "aba".
If string s has at least two equal substrings then Kerem will change characters at some positions to some other lowercase English letters. Changing characters is a very tiring job, so Kerem want to perform as few changes as possible.
Your task is to find the minimum number of changes needed to make all the substrings of the given string distinct, or determine that it is impossible.
Input
The first line of the input contains an integer n (1 β€ n β€ 100 000) β the length of the string s.
The second line contains the string s of length n consisting of only lowercase English letters.
Output
If it's impossible to change the string s such that all its substring are distinct print -1. Otherwise print the minimum required number of changes.
Examples
Input
2
aa
Output
1
Input
4
koko
Output
2
Input
5
murat
Output
0
Note
In the first sample one of the possible solutions is to change the first character to 'b'.
In the second sample, one may change the first character to 'a' and second character to 'b', so the string becomes "abko". | def main():
n = int(input())
print(n - len(set(input())) if n < 27 else -1)
if __name__ == '__main__':
main()
| {
"input": [
"2\naa\n",
"4\nkoko\n",
"5\nmurat\n"
],
"output": [
"1\n",
"2\n",
"0\n"
]
} |
2,943 | 10 | Barney lives in country USC (United States of Charzeh). USC has n cities numbered from 1 through n and n - 1 roads between them. Cities and roads of USC form a rooted tree (Barney's not sure why it is rooted). Root of the tree is the city number 1. Thus if one will start his journey from city 1, he can visit any city he wants by following roads.
<image>
Some girl has stolen Barney's heart, and Barney wants to find her. He starts looking for in the root of the tree and (since he is Barney Stinson not a random guy), he uses a random DFS to search in the cities. A pseudo code of this algorithm is as follows:
let starting_time be an array of length n
current_time = 0
dfs(v):
current_time = current_time + 1
starting_time[v] = current_time
shuffle children[v] randomly (each permutation with equal possibility)
// children[v] is vector of children cities of city v
for u in children[v]:
dfs(u)
As told before, Barney will start his journey in the root of the tree (equivalent to call dfs(1)).
Now Barney needs to pack a backpack and so he wants to know more about his upcoming journey: for every city i, Barney wants to know the expected value of starting_time[i]. He's a friend of Jon Snow and knows nothing, that's why he asked for your help.
Input
The first line of input contains a single integer n (1 β€ n β€ 105) β the number of cities in USC.
The second line contains n - 1 integers p2, p3, ..., pn (1 β€ pi < i), where pi is the number of the parent city of city number i in the tree, meaning there is a road between cities numbered pi and i in USC.
Output
In the first and only line of output print n numbers, where i-th number is the expected value of starting_time[i].
Your answer for each city will be considered correct if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7
1 2 1 1 4 4
Output
1.0 4.0 5.0 3.5 4.5 5.0 5.0
Input
12
1 1 2 2 4 4 3 3 1 10 8
Output
1.0 5.0 5.5 6.5 7.5 8.0 8.0 7.0 7.5 6.5 7.5 8.0 | n = int(input())
if n == 1:
print(1.0)
exit()
val = [1] + list(map(int, input().split()))
for i in range(n):
val[i] -= 1
size = [1] * n
par = [[] for i in range(n)]
for i in reversed(range(n)):
if val[i] != i:
size[val[i]] += size[i]
par[val[i]].append(i)
ans = [0.0] * n
ans[0] = 1.0
def solve(v):
c = size[v] - 1
k = len(par[v])
if k > 1:
t = sum((1.0 / k) * i / (k - 1) for i in range(k))
else:
t = 0.0
for child in par[v]:
ans[child] = ans[v] + 1.0 + t * (c - size[child])
for i in range(1, n):
if ans[i] > 0.0:
continue
solve(val[i])
print(*ans) | {
"input": [
"12\n1 1 2 2 4 4 3 3 1 10 8\n",
"7\n1 2 1 1 4 4\n"
],
"output": [
"1.000000 5.000000 5.500000 6.500000 7.500000 8.000000 8.000000 7.000000 7.500000 6.500000 7.500000 8.000000\n",
"1.000000 4.000000 5.000000 3.500000 4.500000 5.000000 5.000000\n"
]
} |
2,944 | 8 | Vasya plays the Need For Brake. He plays because he was presented with a new computer wheel for birthday! Now he is sure that he will win the first place in the championship in his favourite racing computer game!
n racers take part in the championship, which consists of a number of races. After each race racers are arranged from place first to n-th (no two racers share the same place) and first m places are awarded. Racer gains bi points for i-th awarded place, which are added to total points, obtained by him for previous races. It is known that current summary score of racer i is ai points. In the final standings of championship all the racers will be sorted in descending order of points. Racers with an equal amount of points are sorted by increasing of the name in lexicographical order.
Unfortunately, the championship has come to an end, and there is only one race left. Vasya decided to find out what the highest and lowest place he can take up as a result of the championship.
Input
The first line contains number n (1 β€ n β€ 105) β number of racers. Each of the next n lines contains si and ai β nick of the racer (nonempty string, which consist of no more than 20 lowercase Latin letters) and the racer's points (0 β€ ai β€ 106). Racers are given in the arbitrary order.
The next line contains the number m (0 β€ m β€ n). Then m nonnegative integer numbers bi follow. i-th number is equal to amount of points for the i-th awarded place (0 β€ bi β€ 106).
The last line contains Vasya's racer nick.
Output
Output two numbers β the highest and the lowest place Vasya can take up as a result of the championship.
Examples
Input
3
teama 10
teamb 20
teamc 40
2
10 20
teama
Output
2 3
Input
2
teama 10
teamb 10
2
10 10
teamb
Output
2 2 | class Racer:
def __init__(self, name, points):
self.name = name
self.points = points
def __str__(self):
return '%s %d' % (self.name, self.points)
n = int(input())
best = n * [ None ]
worst = n * [ None ]
for i in range(n):
name, points = input().split()
points = int(points)
best[i] = Racer(name, points)
worst[i] = Racer(name, points)
m = int(input())
place_bonus = list(reversed(sorted(map(int, input().split()))))
your_name = input().strip()
debugging = False
def debug_print(s):
if debugging:
print(s)
def find(racers, name):
for i in range(n):
if racers[i].name == name:
return i
def sort_racers(racers):
racers.sort(key=lambda racer: (-racer.points, racer.name))
#--- Highest possible ranking.
# You get the biggest bonus.
you = best[find(best, your_name)]
if m != 0:
you.points += place_bonus[0]
sort_racers(best)
# People ahead of you get the next biggest bonuses.
bonus_pos = 1 + find(best, your_name)
# People at the end get the remaining bonuses.
for i in range(n - 1, -1, -1):
if bonus_pos >= m:
break
best[i].points += place_bonus[bonus_pos]
bonus_pos += 1
sort_racers(best)
debug_print(list(map(str, best)))
best_ranking = find(best, your_name) + 1
debug_print('best ranking: %d' % best_ranking)
#--- Lowest possible ranking.
# If you must get a bonus, it's the smallest one.
you = worst[find(worst, your_name)]
if m == n:
you.points += place_bonus.pop()
m -= 1
sort_racers(worst)
# Award the smallest possible bonus to the person who can pass you most easily.
bonus_pos = m - 1
worst_pos = find(worst, your_name) + 1
while bonus_pos >= 0 and worst_pos < n:
debug_print('bonus_pos = %d, worst_pos = %d' % (bonus_pos, worst_pos))
candidate = worst[worst_pos]
need = you.points - candidate.points
if candidate.name > you.name:
need += 1
if place_bonus[bonus_pos] >= need:
candidate.points += place_bonus[bonus_pos]
worst_pos += 1
bonus_pos -= 1
sort_racers(worst)
debug_print(list(map(str, worst)))
worst_ranking = find(worst, your_name) + 1
debug_print('worst ranking: %d' % worst_ranking)
print('%d %d' % (best_ranking, worst_ranking))
| {
"input": [
"3\nteama 10\nteamb 20\nteamc 40\n2\n10 20\nteama\n",
"2\nteama 10\nteamb 10\n2\n10 10\nteamb\n"
],
"output": [
"2 3",
"2 2"
]
} |
2,945 | 7 | Apart from having lots of holidays throughout the year, residents of Berland also have whole lucky years. Year is considered lucky if it has no more than 1 non-zero digit in its number. So years 100, 40000, 5 are lucky and 12, 3001 and 12345 are not.
You are given current year in Berland. Your task is to find how long will residents of Berland wait till the next lucky year.
Input
The first line contains integer number n (1 β€ n β€ 109) β current year in Berland.
Output
Output amount of years from the current year to the next lucky one.
Examples
Input
4
Output
1
Input
201
Output
99
Input
4000
Output
1000
Note
In the first example next lucky year is 5. In the second one β 300. In the third β 5000. | def main():
s = input()
n = len(s)
t = int(str(int(s[0]) + 1) + '0' * (n - 1))
print(t - int(s))
main()
| {
"input": [
"4000\n",
"4\n",
"201\n"
],
"output": [
"1000\n",
"1\n",
"99\n"
]
} |
2,946 | 8 | It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern β a string s of lowercase English letters, characters "?" and "*" (1 β€ |s| β€ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 β€ n β€ 105) β the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters β a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x". | z=input;g = z();p= z();n = int(z())
def m(p, t):
d = len(t) - len(p)
if d < -1:return 0
p=p.replace('*', '#' * (d+1))
if len(p) != len(t):return 0
for i in range(len(p)):
if p[i] == '?':
if t[i] not in g:return 0
elif p[i] == '#':
if t[i] in g:return 0
else:
if t[i] != p[i]:return 0
return 1
for i in range(n):
t = z()
print("YES" if m(p, t) else "NO")
| {
"input": [
"ab\na?a\n2\naaa\naab\n",
"abc\na?a?a*\n4\nabacaba\nabaca\napapa\naaaaax\n"
],
"output": [
"YES\nNO\n",
"NO\nYES\nNO\nYES\n"
]
} |
2,947 | 10 | Olya loves energy drinks. She loves them so much that her room is full of empty cans from energy drinks.
Formally, her room can be represented as a field of n Γ m cells, each cell of which is empty or littered with cans.
Olya drank a lot of energy drink, so now she can run k meters per second. Each second she chooses one of the four directions (up, down, left or right) and runs from 1 to k meters in this direction. Of course, she can only run through empty cells.
Now Olya needs to get from cell (x1, y1) to cell (x2, y2). How many seconds will it take her if she moves optimally?
It's guaranteed that cells (x1, y1) and (x2, y2) are empty. These cells can coincide.
Input
The first line contains three integers n, m and k (1 β€ n, m, k β€ 1000) β the sizes of the room and Olya's speed.
Then n lines follow containing m characters each, the i-th of them contains on j-th position "#", if the cell (i, j) is littered with cans, and "." otherwise.
The last line contains four integers x1, y1, x2, y2 (1 β€ x1, x2 β€ n, 1 β€ y1, y2 β€ m) β the coordinates of the first and the last cells.
Output
Print a single integer β the minimum time it will take Olya to get from (x1, y1) to (x2, y2).
If it's impossible to get from (x1, y1) to (x2, y2), print -1.
Examples
Input
3 4 4
....
###.
....
1 1 3 1
Output
3
Input
3 4 1
....
###.
....
1 1 3 1
Output
8
Input
2 2 1
.#
#.
1 1 2 2
Output
-1
Note
In the first sample Olya should run 3 meters to the right in the first second, 2 meters down in the second second and 3 meters to the left in the third second.
In second sample Olya should run to the right for 3 seconds, then down for 2 seconds and then to the left for 3 seconds.
Olya does not recommend drinking energy drinks and generally believes that this is bad. | from sys import *
f = lambda: map(int, input().split())
n, m, k = f()
t = [[1e9 * (q == '.') for q in stdin.readline()] for i in range(n)]
t.append([0] * m)
a, b, c, d = [q - 1 for q in f()]
u = [(a, b)]
t[a][b] = l = 0
def g(i, x, y):
if i > k or t[x][y] < l: return 0
if t[x][y] > l:
t[x][y] = l
v.append((x, y))
return 1
while u and t[c][d] == 1e9:
l += 1
v = []
for x, y in u:
i = j = 1
while g(i, x - i, y): i += 1
while g(j, x + j, y): j += 1
i = j = 1
while g(i, x, y - i): i += 1
while g(j, x, y + j): j += 1
u = v
print(l if t[c][d] < 1e9 else -1) | {
"input": [
"3 4 4\n....\n###.\n....\n1 1 3 1\n",
"2 2 1\n.#\n#.\n1 1 2 2\n",
"3 4 1\n....\n###.\n....\n1 1 3 1\n"
],
"output": [
"3",
"-1\n",
"8"
]
} |
2,948 | 11 | Vasya wrote down two strings s of length n and t of length m consisting of small English letters 'a' and 'b'. What is more, he knows that string t has a form "abab...", namely there are letters 'a' on odd positions and letters 'b' on even positions.
Suddenly in the morning, Vasya found that somebody spoiled his string. Some letters of the string s were replaced by character '?'.
Let's call a sequence of positions i, i + 1, ..., i + m - 1 as occurrence of string t in s, if 1 β€ i β€ n - m + 1 and t1 = si, t2 = si + 1, ..., tm = si + m - 1.
The boy defines the beauty of the string s as maximum number of disjoint occurrences of string t in s. Vasya can replace some letters '?' with 'a' or 'b' (letters on different positions can be replaced with different letter). Vasya wants to make some replacements in such a way that beauty of string s is maximum possible. From all such options, he wants to choose one with the minimum number of replacements. Find the number of replacements he should make.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the length of s.
The second line contains the string s of length n. It contains small English letters 'a', 'b' and characters '?' only.
The third line contains a single integer m (1 β€ m β€ 105) β the length of t. The string t contains letters 'a' on odd positions and 'b' on even positions.
Output
Print the only integer β the minimum number of replacements Vasya has to perform to make the beauty of string s the maximum possible.
Examples
Input
5
bb?a?
1
Output
2
Input
9
ab??ab???
3
Output
2
Note
In the first sample string t has a form 'a'. The only optimal option is to replace all characters '?' by 'a'.
In the second sample using two replacements we can make string equal to "aba?aba??". It is impossible to get more than two occurrences. | match = 0
nonmatch = 0
count = 0
def calc_match(s, t, p):
global match
global nonmatch
global count
if p == len(s)-len(t):
return
if p+len(t) < len(s):
if s[p+len(t)] == '?':
count -= 1
elif s[p+len(t)] == t[-1]:
match -= 1
else:
nonmatch -= 1
match, nonmatch = nonmatch, match
if p+len(t) < len(s):
if s[p] == '?':
count += 1
elif s[p] == 'a':
match += 1
else:
nonmatch += 1
def init_match(s, t):
global match
global nonmatch
global count
p = len(s)-len(t)
for i in range(len(t)):
if s[p+i] == '?':
count += 1
elif s[p+i] == t[i]:
match += 1
else:
nonmatch += 1
n = int(input())
s = input()
m = int(input())
t = ""
for i in range(m):
if i%2==0:
t = t + 'a'
else:
t = t + 'b'
init_match(s,t)
dp = []
for i in range(n+3):
dp.append((0, 0))
p = n-m
while p >= 0:
calc_match(s, t, p)
if nonmatch == 0:
if dp[p+1][0] == dp[p+m][0]+1:
dp[p] = (dp[p+1][0], min(dp[p+1][1], dp[p+m][1]+count))
elif dp[p+1][0] > dp[p+m][0]+1:
dp[p] = dp[p+1]
else:
dp[p] = (dp[p+m][0]+1, dp[p+m][1]+count)
else:
dp[p] = dp[p+1]
p -= 1
print(dp[0][1]) | {
"input": [
"9\nab??ab???\n3\n",
"5\nbb?a?\n1\n"
],
"output": [
"2\n",
"2\n"
]
} |
2,949 | 9 | Alice has a very important message M consisting of some non-negative integers that she wants to keep secret from Eve. Alice knows that the only theoretically secure cipher is one-time pad. Alice generates a random key K of the length equal to the message's length. Alice computes the bitwise xor of each element of the message and the key (<image>, where <image> denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR)) and stores this encrypted message A. Alice is smart. Be like Alice.
For example, Alice may have wanted to store a message M = (0, 15, 9, 18). She generated a key K = (16, 7, 6, 3). The encrypted message is thus A = (16, 8, 15, 17).
Alice realised that she cannot store the key with the encrypted message. Alice sent her key K to Bob and deleted her own copy. Alice is smart. Really, be like Alice.
Bob realised that the encrypted message is only secure as long as the key is secret. Bob thus randomly permuted the key before storing it. Bob thinks that this way, even if Eve gets both the encrypted message and the key, she will not be able to read the message. Bob is not smart. Don't be like Bob.
In the above example, Bob may have, for instance, selected a permutation (3, 4, 1, 2) and stored the permuted key P = (6, 3, 16, 7).
One year has passed and Alice wants to decrypt her message. Only now Bob has realised that this is impossible. As he has permuted the key randomly, the message is lost forever. Did we mention that Bob isn't smart?
Bob wants to salvage at least some information from the message. Since he is not so smart, he asks for your help. You know the encrypted message A and the permuted key P. What is the lexicographically smallest message that could have resulted in the given encrypted text?
More precisely, for given A and P, find the lexicographically smallest message O, for which there exists a permutation Ο such that <image> for every i.
Note that the sequence S is lexicographically smaller than the sequence T, if there is an index i such that Si < Ti and for all j < i the condition Sj = Tj holds.
Input
The first line contains a single integer N (1 β€ N β€ 300000), the length of the message.
The second line contains N integers A1, A2, ..., AN (0 β€ Ai < 230) representing the encrypted message.
The third line contains N integers P1, P2, ..., PN (0 β€ Pi < 230) representing the permuted encryption key.
Output
Output a single line with N integers, the lexicographically smallest possible message O. Note that all its elements should be non-negative.
Examples
Input
3
8 4 13
17 2 7
Output
10 3 28
Input
5
12 7 87 22 11
18 39 9 12 16
Output
0 14 69 6 44
Input
10
331415699 278745619 998190004 423175621 42983144 166555524 843586353 802130100 337889448 685310951
226011312 266003835 342809544 504667531 529814910 684873393 817026985 844010788 993949858 1031395667
Output
128965467 243912600 4281110 112029883 223689619 76924724 429589 119397893 613490433 362863284
Note
In the first case, the solution is (10, 3, 28), since <image>, <image> and <image>. Other possible permutations of key yield messages (25, 6, 10), (25, 3, 15), (10, 21, 10), (15, 21, 15) and (15, 6, 28), which are all lexicographically larger than the solution. | def add(x):
global tree
now = 0
tree[now][2] += 1
for i in range(29, -1, -1):
bit = (x>>i)&1
if tree[now][bit]==0:
tree[now][bit]=len(tree)
tree.append([0, 0, 0])
now = tree[now][bit]
tree[now][2] += 1
def find_min(x):
global tree
now = ans = 0
for i in range(29, -1, -1):
bit = (x>>i)&1
if tree[now][bit] and tree[tree[now][bit]][2]:
now = tree[now][bit]
else:
now = tree[now][bit^1]
ans |= (1<<i)
tree[now][2] -= 1
return ans
tree = [[0, 0, 0]]
n = int(input())
a = list(map(int, input().split()))
list(map(add, map(int, input().split())))
[print(x, end=' ') for x in list(map(find_min, a))] | {
"input": [
"10\n331415699 278745619 998190004 423175621 42983144 166555524 843586353 802130100 337889448 685310951\n226011312 266003835 342809544 504667531 529814910 684873393 817026985 844010788 993949858 1031395667\n",
"5\n12 7 87 22 11\n18 39 9 12 16\n",
"3\n8 4 13\n17 2 7\n"
],
"output": [
"\n128965467 \n243912600 \n4281110 \n112029883 \n223689619 \n76924724 \n429589 \n119397893 \n613490433 \n362863284 ",
"\n0 \n14 \n69 \n6 \n44 ",
"\n10 \n3 \n28 "
]
} |
2,950 | 7 | Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 β€ n β€ 10^{18}) β the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer β the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts. | def solve():
n = int(input()) + 1
print(n // 2 if n % 2 == 0 or n == 1 else n)
solve()
| {
"input": [
"4\n",
"3\n"
],
"output": [
"5\n",
"2\n"
]
} |
2,951 | 8 | A string s of length n can be encrypted by the following algorithm:
* iterate over all divisors of n in decreasing order (i.e. from n to 1),
* for each divisor d, reverse the substring s[1 ... d] (i.e. the substring which starts at position 1 and ends at position d).
For example, the above algorithm applied to the string s="codeforces" leads to the following changes: "codeforces" β "secrofedoc" β "orcesfedoc" β "rocesfedoc" β "rocesfedoc" (obviously, the last reverse operation doesn't change the string because d=1).
You are given the encrypted string t. Your task is to decrypt this string, i.e., to find a string s such that the above algorithm results in string t. It can be proven that this string s always exists and is unique.
Input
The first line of input consists of a single integer n (1 β€ n β€ 100) β the length of the string t. The second line of input consists of the string t. The length of t is n, and it consists only of lowercase Latin letters.
Output
Print a string s such that the above algorithm results in t.
Examples
Input
10
rocesfedoc
Output
codeforces
Input
16
plmaetwoxesisiht
Output
thisisexampletwo
Input
1
z
Output
z
Note
The first example is described in the problem statement. | def rev(s,i):
return(s[:i][::-1]+s[i:])
n=int(input())
s=input()
for i in range(2,n//2+1):
if n%i==0:
s=rev(s,i)
print(s[::-1])
| {
"input": [
"10\nrocesfedoc\n",
"1\nz\n",
"16\nplmaetwoxesisiht\n"
],
"output": [
"codeforces\n",
"z\n",
"thisisexampletwo\n"
]
} |
2,952 | 10 | Childan is making up a legendary story and trying to sell his forgery β a necklace with a strong sense of "Wu" to the Kasouras. But Mr. Kasoura is challenging the truth of Childan's story. So he is going to ask a few questions about Childan's so-called "personal treasure" necklace.
This "personal treasure" is a multiset S of m "01-strings".
A "01-string" is a string that contains n characters "0" and "1". For example, if n=4, strings "0110", "0000", and "1110" are "01-strings", but "00110" (there are 5 characters, not 4) and "zero" (unallowed characters) are not.
Note that the multiset S can contain equal elements.
Frequently, Mr. Kasoura will provide a "01-string" t and ask Childan how many strings s are in the multiset S such that the "Wu" value of the pair (s, t) is not greater than k.
Mrs. Kasoura and Mr. Kasoura think that if s_i = t_i (1β€ iβ€ n) then the "Wu" value of the character pair equals to w_i, otherwise 0. The "Wu" value of the "01-string" pair is the sum of the "Wu" values of every character pair. Note that the length of every "01-string" is equal to n.
For example, if w=[4, 5, 3, 6], "Wu" of ("1001", "1100") is 7 because these strings have equal characters only on the first and third positions, so w_1+w_3=4+3=7.
You need to help Childan to answer Mr. Kasoura's queries. That is to find the number of strings in the multiset S such that the "Wu" value of the pair is not greater than k.
Input
The first line contains three integers n, m, and q (1β€ nβ€ 12, 1β€ q, mβ€ 5β
10^5) β the length of the "01-strings", the size of the multiset S, and the number of queries.
The second line contains n integers w_1, w_2, β¦, w_n (0 β€ w_i β€ 100) β the value of the i-th caracter.
Each of the next m lines contains the "01-string" s of length n β the string in the multiset S.
Each of the next q lines contains the "01-string" t of length n and integer k (0β€ kβ€ 100) β the query.
Output
For each query, print the answer for this query.
Examples
Input
2 4 5
40 20
01
01
10
11
00 20
00 40
11 20
11 40
11 60
Output
2
4
2
3
4
Input
1 2 4
100
0
1
0 0
0 100
1 0
1 100
Output
1
2
1
2
Note
In the first example, we can get:
"Wu" of ("01", "00") is 40.
"Wu" of ("10", "00") is 20.
"Wu" of ("11", "00") is 0.
"Wu" of ("01", "11") is 20.
"Wu" of ("10", "11") is 40.
"Wu" of ("11", "11") is 60.
In the first query, pairs ("11", "00") and ("10", "00") satisfy the condition since their "Wu" is not greater than 20.
In the second query, all strings satisfy the condition.
In the third query, pairs ("01", "11") and ("01", "11") satisfy the condition. Note that since there are two "01" strings in the multiset, the answer is 2, not 1.
In the fourth query, since k was increased, pair ("10", "11") satisfies the condition too.
In the fifth query, since k was increased, pair ("11", "11") satisfies the condition too. | from sys import stdin
def main():
n, m, q = map(int, input().split())
c = sz = 1 << n
costs, cnt = [0] * sz, [0] * sz
for w in map(int, input().split()):
c //= 2
for i in range(c, sz, c * 2):
for j in range(i, i + c):
costs[j] += w
for i, c in enumerate(costs):
if c > 101:
costs[i] = 101
costs.reverse()
l = stdin.read().splitlines()
for s in l[:m]:
cnt[int(s, 2)] += 1
del l[:m]
cache = []
for i in range(sz):
row = [0] * 102
cache.append(row)
for j, c in enumerate(cnt):
row[costs[i ^ j]] += c
a = 0
for j, b in enumerate(row):
a += b
row[j] = a
for i, s in enumerate(l):
row = s.split()
l[i] = str(cache[int(row[0], 2)][int(row[1])])
print('\n'.join(l))
if __name__ == '__main__':
main()
| {
"input": [
"2 4 5\n40 20\n01\n01\n10\n11\n00 20\n00 40\n11 20\n11 40\n11 60\n",
"1 2 4\n100\n0\n1\n0 0\n0 100\n1 0\n1 100\n"
],
"output": [
"2\n4\n2\n3\n4\n",
"1\n2\n1\n2\n"
]
} |
2,953 | 7 | There was an electronic store heist last night.
All keyboards which were in the store yesterday were numbered in ascending order from some integer number x. For example, if x = 4 and there were 3 keyboards in the store, then the devices had indices 4, 5 and 6, and if x = 10 and there were 7 of them then the keyboards had indices 10, 11, 12, 13, 14, 15 and 16.
After the heist, only n keyboards remain, and they have indices a_1, a_2, ..., a_n. Calculate the minimum possible number of keyboards that have been stolen. The staff remember neither x nor the number of keyboards in the store before the heist.
Input
The first line contains single integer n (1 β€ n β€ 1 000) β the number of keyboards in the store that remained after the heist.
The second line contains n distinct integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^{9}) β the indices of the remaining keyboards. The integers a_i are given in arbitrary order and are pairwise distinct.
Output
Print the minimum possible number of keyboards that have been stolen if the staff remember neither x nor the number of keyboards in the store before the heist.
Examples
Input
4
10 13 12 8
Output
2
Input
5
7 5 6 4 8
Output
0
Note
In the first example, if x=8 then minimum number of stolen keyboards is equal to 2. The keyboards with indices 9 and 11 were stolen during the heist.
In the second example, if x=4 then nothing was stolen during the heist. | def sol(n,a):
print(max(a)-min(a)+1-n)
n=int(input())
a=list(map(int,input().split()))
sol(n,a) | {
"input": [
"4\n10 13 12 8\n",
"5\n7 5 6 4 8\n"
],
"output": [
"2\n",
"0\n"
]
} |
2,954 | 9 | Ayoub had an array a of integers of size n and this array had two interesting properties:
* All the integers in the array were between l and r (inclusive).
* The sum of all the elements was divisible by 3.
Unfortunately, Ayoub has lost his array, but he remembers the size of the array n and the numbers l and r, so he asked you to find the number of ways to restore the array.
Since the answer could be very large, print it modulo 10^9 + 7 (i.e. the remainder when dividing by 10^9 + 7). In case there are no satisfying arrays (Ayoub has a wrong memory), print 0.
Input
The first and only line contains three integers n, l and r (1 β€ n β€ 2 β
10^5 , 1 β€ l β€ r β€ 10^9) β the size of the lost array and the range of numbers in the array.
Output
Print the remainder when dividing by 10^9 + 7 the number of ways to restore the array.
Examples
Input
2 1 3
Output
3
Input
3 2 2
Output
1
Input
9 9 99
Output
711426616
Note
In the first example, the possible arrays are : [1,2], [2,1], [3, 3].
In the second example, the only possible array is [2, 2, 2]. | # import sys
# input=sys.stdin.readline
def fu(l,r):
return [r//3-(l-1)//3,(r-1)//3-(l-2)//3,(r-2)//3-(l-3)//3]
n,l,r=list(map(int,input().split()))
a=fu(l,r)
m=10**9+7
dp0=[a[0]]
dp1=[a[1]]
dp2=[a[2]]
for i in range(1,n):
x=(dp0[-1]*a[0]+dp1[-1]*a[2]+dp2[-1]*a[1])%m
y=(dp0[-1]*a[1]+dp1[-1]*a[0]+dp2[-1]*a[2])%m
z=(dp0[-1]*a[2]+dp1[-1]*a[1]+dp2[-1]*a[0])%m
dp0.append(x)
dp1.append(y)
dp2.append(z)
print((dp0[-1])%m) | {
"input": [
"9 9 99\n",
"2 1 3\n",
"3 2 2\n"
],
"output": [
"711426616",
"3",
"1"
]
} |
2,955 | 8 | Luckily, Serval got onto the right bus, and he came to the kindergarten on time. After coming to kindergarten, he found the toy bricks very funny.
He has a special interest to create difficult problems for others to solve. This time, with many 1 Γ 1 Γ 1 toy bricks, he builds up a 3-dimensional object. We can describe this object with a n Γ m matrix, such that in each cell (i,j), there are h_{i,j} bricks standing on the top of each other.
However, Serval doesn't give you any h_{i,j}, and just give you the front view, left view, and the top view of this object, and he is now asking you to restore the object. Note that in the front view, there are m columns, and in the i-th of them, the height is the maximum of h_{1,i},h_{2,i},...,h_{n,i}. It is similar for the left view, where there are n columns. And in the top view, there is an n Γ m matrix t_{i,j}, where t_{i,j} is 0 or 1. If t_{i,j} equals 1, that means h_{i,j}>0, otherwise, h_{i,j}=0.
However, Serval is very lonely because others are bored about his unsolvable problems before, and refused to solve this one, although this time he promises there will be at least one object satisfying all the views. As his best friend, can you have a try?
Input
The first line contains three positive space-separated integers n, m, h (1β€ n, m, h β€ 100) β the length, width and height.
The second line contains m non-negative space-separated integers a_1,a_2,...,a_m, where a_i is the height in the i-th column from left to right of the front view (0β€ a_i β€ h).
The third line contains n non-negative space-separated integers b_1,b_2,...,b_n (0β€ b_j β€ h), where b_j is the height in the j-th column from left to right of the left view.
Each of the following n lines contains m numbers, each is 0 or 1, representing the top view, where j-th number of i-th row is 1 if h_{i, j}>0, and 0 otherwise.
It is guaranteed that there is at least one structure satisfying the input.
Output
Output n lines, each of them contains m integers, the j-th number in the i-th line should be equal to the height in the corresponding position of the top view. If there are several objects satisfying the views, output any one of them.
Examples
Input
3 7 3
2 3 0 0 2 0 1
2 1 3
1 0 0 0 1 0 0
0 0 0 0 0 0 1
1 1 0 0 0 0 0
Output
1 0 0 0 2 0 0
0 0 0 0 0 0 1
2 3 0 0 0 0 0
Input
4 5 5
3 5 2 0 4
4 2 5 4
0 0 0 0 1
1 0 1 0 0
0 1 0 0 0
1 1 1 0 0
Output
0 0 0 0 4
1 0 2 0 0
0 5 0 0 0
3 4 1 0 0
Note
<image>
The graph above illustrates the object in the first example.
<image> <image>
The first graph illustrates the object in the example output for the second example, and the second graph shows the three-view drawing of it. | def mp():
return map(int, input().split())
n, m, h = mp()
a = list(mp())
b = list(mp())
f = [list(mp()) for i in range(n)]
for i in range(m):
for j in range(n):
f[j][i] *= min(a[i], b[j])
for i in range(n):
for j in range(m):
print(f[i][j], end = ' ')
print() | {
"input": [
"4 5 5\n3 5 2 0 4\n4 2 5 4\n0 0 0 0 1\n1 0 1 0 0\n0 1 0 0 0\n1 1 1 0 0\n",
"3 7 3\n2 3 0 0 2 0 1\n2 1 3\n1 0 0 0 1 0 0\n0 0 0 0 0 0 1\n1 1 0 0 0 0 0\n"
],
"output": [
"0 0 0 0 4 \n2 0 2 0 0 \n0 5 0 0 0 \n3 4 2 0 0 \n",
"2 0 0 0 2 0 0 \n0 0 0 0 0 0 1 \n2 3 0 0 0 0 0 \n"
]
} |
2,956 | 7 | You are given an integer n and an integer k.
In one step you can do one of the following moves:
* decrease n by 1;
* divide n by k if n is divisible by k.
For example, if n = 27 and k = 3 you can do the following steps: 27 β 26 β 25 β 24 β 8 β 7 β 6 β 2 β 1 β 0.
You are asked to calculate the minimum number of steps to reach 0 from n.
Input
The first line contains one integer t (1 β€ t β€ 100) β the number of queries.
The only line of each query contains two integers n and k (1 β€ n β€ 10^{18}, 2 β€ k β€ 10^{18}).
Output
For each query print the minimum number of steps to reach 0 from n in single line.
Example
Input
2
59 3
1000000000000000000 10
Output
8
19
Note
Steps for the first test case are: 59 β 58 β 57 β 19 β 18 β 6 β 2 β 1 β 0.
In the second test case you have to divide n by k 18 times and then decrease n by 1. | def f():
n,k=map(int,input().split())
a=-1
while n:
a+=(n%k+1)
n//=k
return a
for k in range(int(input())):
print(f())
| {
"input": [
"2\n59 3\n1000000000000000000 10\n"
],
"output": [
"8\n19\n"
]
} |
2,957 | 9 | In this problem, a n Γ m rectangular matrix a is called increasing if, for each row of i, when go from left to right, the values strictly increase (that is, a_{i,1}<a_{i,2}<...<a_{i,m}) and for each column j, when go from top to bottom, the values strictly increase (that is, a_{1,j}<a_{2,j}<...<a_{n,j}).
In a given matrix of non-negative integers, it is necessary to replace each value of 0 with some positive integer so that the resulting matrix is increasing and the sum of its elements is maximum, or find that it is impossible.
It is guaranteed that in a given value matrix all values of 0 are contained only in internal cells (that is, not in the first or last row and not in the first or last column).
Input
The first line contains integers n and m (3 β€ n, m β€ 500) β the number of rows and columns in the given matrix a.
The following lines contain m each of non-negative integers β the values in the corresponding row of the given matrix: a_{i,1}, a_{i,2}, ..., a_{i,m} (0 β€ a_{i,j} β€ 8000).
It is guaranteed that for all a_{i,j}=0, 1 < i < n and 1 < j < m are true.
Output
If it is possible to replace all zeros with positive numbers so that the matrix is increasing, print the maximum possible sum of matrix elements. Otherwise, print -1.
Examples
Input
4 5
1 3 5 6 7
3 0 7 0 9
5 0 0 0 10
8 9 10 11 12
Output
144
Input
3 3
1 2 3
2 0 4
4 5 6
Output
30
Input
3 3
1 2 3
3 0 4
4 5 6
Output
-1
Input
3 3
1 2 3
2 3 4
3 4 2
Output
-1
Note
In the first example, the resulting matrix is as follows:
1 3 5 6 7
3 6 7 8 9
5 7 8 9 10
8 9 10 11 12
In the second example, the value 3 must be put in the middle cell.
In the third example, the desired resultant matrix does not exist. | n, m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
def go():
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
if not a[i][j]:
a[i][j] = min(a[i + 1][j], a[i][j + 1]) - 1
if (i + 1 < n and a[i][j] >= a[i + 1][j]) or (j + 1 < m and a[i][j] >= a[i][j + 1]):
print(-1)
return
s = 0
for v in a:
s += sum(v)
print(s)
go()
| {
"input": [
"3 3\n1 2 3\n2 0 4\n4 5 6\n",
"3 3\n1 2 3\n2 3 4\n3 4 2\n",
"4 5\n1 3 5 6 7\n3 0 7 0 9\n5 0 0 0 10\n8 9 10 11 12\n",
"3 3\n1 2 3\n3 0 4\n4 5 6\n"
],
"output": [
"30\n",
"-1\n",
"144\n",
"-1\n"
]
} |
2,958 | 11 | You are given an array a consisting of n integers. In one move, you can jump from the position i to the position i - a_i (if 1 β€ i - a_i) or to the position i + a_i (if i + a_i β€ n).
For each position i from 1 to n you want to know the minimum the number of moves required to reach any position j such that a_j has the opposite parity from a_i (i.e. if a_i is odd then a_j has to be even and vice versa).
Input
The first line of the input contains one integer n (1 β€ n β€ 2 β
10^5) β the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ n), where a_i is the i-th element of a.
Output
Print n integers d_1, d_2, ..., d_n, where d_i is the minimum the number of moves required to reach any position j such that a_j has the opposite parity from a_i (i.e. if a_i is odd then a_j has to be even and vice versa) or -1 if it is impossible to reach such a position.
Example
Input
10
4 5 7 6 7 5 4 4 6 4
Output
1 1 1 2 -1 1 1 3 1 1 | from math import inf
n = int(input())
l = [-1]
l.extend(list(map(int, input().split())))
g = [[] for _ in range(n+1)]
for i in range(1, n+1):
if i+l[i]<=n:
g[i+l[i]].append(i)
if i-l[i]>0:
g[i-l[i]].append(i)
ans = [-1]*(n)
def bfs(v):
vis = [0]*(n+1)
q = []
for i in range(1, n+1):
if l[i]%2==v:
q.append((i,0))
pos = 0
while len(q)>pos:
i,dis = q[pos]
pos += 1
if vis[i]==1:
continue
vis[i]=1
if not l[i]%2==v:
ans[i-1] = dis
for j in g[i]:
q.append((j, dis+1))
bfs(0)
bfs(1)
print(*ans) | {
"input": [
"10\n4 5 7 6 7 5 4 4 6 4\n"
],
"output": [
"1 1 1 2 -1 1 1 3 1 1 \n"
]
} |
2,959 | 12 | An online contest will soon be held on ForceCoders, a large competitive programming platform. The authors have prepared n problems; and since the platform is very popular, 998244351 coder from all over the world is going to solve them.
For each problem, the authors estimated the number of people who would solve it: for the i-th problem, the number of accepted solutions will be between l_i and r_i, inclusive.
The creator of ForceCoders uses different criteria to determine if the contest is good or bad. One of these criteria is the number of inversions in the problem order. An inversion is a pair of problems (x, y) such that x is located earlier in the contest (x < y), but the number of accepted solutions for y is strictly greater.
Obviously, both the creator of ForceCoders and the authors of the contest want the contest to be good. Now they want to calculate the probability that there will be no inversions in the problem order, assuming that for each problem i, any integral number of accepted solutions for it (between l_i and r_i) is equally probable, and all these numbers are independent.
Input
The first line contains one integer n (2 β€ n β€ 50) β the number of problems in the contest.
Then n lines follow, the i-th line contains two integers l_i and r_i (0 β€ l_i β€ r_i β€ 998244351) β the minimum and maximum number of accepted solutions for the i-th problem, respectively.
Output
The probability that there will be no inversions in the contest can be expressed as an irreducible fraction x/y, where y is coprime with 998244353. Print one integer β the value of xy^{-1}, taken modulo 998244353, where y^{-1} is an integer such that yy^{-1} β‘ 1 (mod 998244353).
Examples
Input
3
1 2
1 2
1 2
Output
499122177
Input
2
42 1337
13 420
Output
578894053
Input
2
1 1
0 0
Output
1
Input
2
1 1
1 1
Output
1
Note
The real answer in the first test is 1/2. | from bisect import bisect_left
M = 998244353
def pw(x, y):
if y == 0:
return 1
res = pw(x, y//2)
res = res * res % M
if y % 2 == 1:
res = res * x % M
return res
def cal(x, y):
y += x - 1
res = 1
for i in range(1, x + 1):
res = res * (y - i + 1)
res = res * pw(i, M - 2) % M
return res % M
n = int(input())
a = []
b = []
res = 1
for i in range(n):
a.append(list(map(int, input().split())))
res = res * (a[-1][1] + 1 - a[-1][0]) % M
b.append(a[-1][0])
b.append(a[-1][1] + 1)
b = set(b)
b = sorted(list(b))
g = [b[i + 1] - b[i] for i in range(len(b) - 1)]
for i in range(n):
a[i][0] = bisect_left(b, a[i][0])
a[i][1] = bisect_left(b, a[i][1] + 1)
a = a[::-1]
f = [[0 for _ in range(len(b))] for __ in range(n)]
for i in range(a[0][0], len(b)):
if i == 0:
f[0][i] = g[i]
else:
if i < a[0][1]:
f[0][i] = (f[0][i - 1] + g[i]) % M
else:
f[0][i] = f[0][i - 1]
for i in range(1, n):
for j in range(a[i][0], len(b)):
if j > 0:
f[i][j] = f[i][j - 1]
if j < a[i][1]:
for k in range(i, -1, -1):
if a[k][1] <= j or j < a[k][0]:
break
if k == 0 or j != 0:
tmp = cal(i - k + 1, g[j])
if k > 0:
f[i][j] += f[k - 1][j - 1] * tmp % M
else:
f[i][j] += tmp
f[i][j] %= M
#print(f)
#print(f[n - 1][len(b) - 1], res)
print(f[n - 1][len(b) - 1] * pw(res, M - 2) % M)
| {
"input": [
"2\n1 1\n0 0\n",
"2\n1 1\n1 1\n",
"2\n42 1337\n13 420\n",
"3\n1 2\n1 2\n1 2\n"
],
"output": [
"1\n",
"1\n",
"578894053\n",
"499122177\n"
]
} |
2,960 | 8 | You have unweighted tree of n vertices. You have to assign a positive weight to each edge so that the following condition would hold:
* For every two different leaves v_{1} and v_{2} of this tree, [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of weights of all edges on the simple path between v_{1} and v_{2} has to be equal to 0.
Note that you can put very large positive integers (like 10^{(10^{10})}).
It's guaranteed that such assignment always exists under given constraints. Now let's define f as the number of distinct weights in assignment.
<image> In this example, assignment is valid, because bitwise XOR of all edge weights between every pair of leaves is 0. f value is 2 here, because there are 2 distinct edge weights(4 and 5).
<image> In this example, assignment is invalid, because bitwise XOR of all edge weights between vertex 1 and vertex 6 (3, 4, 5, 4) is not 0.
What are the minimum and the maximum possible values of f for the given tree? Find and print both.
Input
The first line contains integer n (3 β€ n β€ 10^{5}) β the number of vertices in given tree.
The i-th of the next n-1 lines contains two integers a_{i} and b_{i} (1 β€ a_{i} < b_{i} β€ n) β it means there is an edge between a_{i} and b_{i}. It is guaranteed that given graph forms tree of n vertices.
Output
Print two integers β the minimum and maximum possible value of f can be made from valid assignment of given tree. Note that it's always possible to make an assignment under given constraints.
Examples
Input
6
1 3
2 3
3 4
4 5
5 6
Output
1 4
Input
6
1 3
2 3
3 4
4 5
4 6
Output
3 3
Input
7
1 2
2 7
3 4
4 7
5 6
6 7
Output
1 6
Note
In the first example, possible assignments for each minimum and maximum are described in picture below. Of course, there are multiple possible assignments for each minimum and maximum.
<image>
In the second example, possible assignments for each minimum and maximum are described in picture below. The f value of valid assignment of this tree is always 3.
<image>
In the third example, possible assignments for each minimum and maximum are described in picture below. Of course, there are multiple possible assignments for each minimum and maximum.
<image> | #!/usr/bin/env python3
import sys
input = sys.stdin.readline
n = int(input())
edge = [[] for _ in range(n)]
for _ in range(n-1):
u, v = map(int, input().split())
u -= 1; v -= 1
edge[u].append(v)
edge[v].append(u)
is_leaf = [False] * n
for i in range(n):
if len(edge[i]) == 1:
is_leaf[i] = True
else:
start = i
oe = [0, 0]
def dfs(d, p, v):
queue = [(d, p, v)]
while queue:
d, p, v = queue.pop()
if is_leaf[v]:
oe[d%2] += 1
continue
for nv in edge[v]:
if nv == p:
continue
queue.append((d+1, v, nv))
dfs(0, -1, start)
if 0 in oe:
minima = 1
else:
minima = 3
dim = 0
for i in range(n):
cnt = 0
for v in edge[i]:
cnt += is_leaf[v]
if cnt > 1:
dim += cnt - 1
print(minima, n - 1 - dim) | {
"input": [
"6\n1 3\n2 3\n3 4\n4 5\n4 6\n",
"6\n1 3\n2 3\n3 4\n4 5\n5 6\n",
"7\n1 2\n2 7\n3 4\n4 7\n5 6\n6 7\n"
],
"output": [
"3 3\n",
"1 4\n",
"1 6\n"
]
} |
2,961 | 7 | Find the minimum area of a square land on which you can place two identical rectangular a Γ b houses. The sides of the houses should be parallel to the sides of the desired square land.
Formally,
* You are given two identical rectangles with side lengths a and b (1 β€ a, b β€ 100) β positive integers (you are given just the sizes, but not their positions).
* Find the square of the minimum area that contains both given rectangles. Rectangles can be rotated (both or just one), moved, but the sides of the rectangles should be parallel to the sides of the desired square.
Two rectangles can touch each other (side or corner), but cannot intersect. Rectangles can also touch the sides of the square but must be completely inside it. You can rotate the rectangles. Take a look at the examples for a better understanding.
<image> The picture shows a square that contains red and green rectangles.
Input
The first line contains an integer t (1 β€ t β€ 10 000) βthe number of test cases in the input. Then t test cases follow.
Each test case is a line containing two integers a, b (1 β€ a, b β€ 100) β side lengths of the rectangles.
Output
Print t answers to the test cases. Each answer must be a single integer β minimal area of square land, that contains two rectangles with dimensions a Γ b.
Example
Input
8
3 2
4 2
1 1
3 1
4 7
1 3
7 4
100 100
Output
16
16
4
9
64
9
64
40000
Note
Below are the answers for the first two test cases:
<image> <image> | def main():
for _ in range(int(input())):
a,b = list(map(int,input().split()))
print(min(max(a,2*b),max(b,2*a))**2)
main() | {
"input": [
"8\n3 2\n4 2\n1 1\n3 1\n4 7\n1 3\n7 4\n100 100\n"
],
"output": [
"16\n16\n4\n9\n64\n9\n64\n40000\n"
]
} |
2,962 | 8 | Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 β€ pos β€ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round β on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
Next t lines contain test cases β one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 β€ n β€ 2 β
10^5; s_i β \{R, S, P\}) β the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 β
10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image> | def solve():
s = input()
d = {'R':0, 'S':0, 'P':0}
for c in s: d[c] += 1
m = max(d.values())
print(len(s)*'PRS'[[*d.values()].index(m)])
def main():
for _ in range(int(input())): solve()
main() | {
"input": [
"3\nRRRR\nRSP\nS\n"
],
"output": [
"PPPP\nPPP\nR\n"
]
} |
2,963 | 8 | You are playing one RPG from the 2010s. You are planning to raise your smithing skill, so you need as many resources as possible. So how to get resources? By stealing, of course.
You decided to rob a town's blacksmith and you take a follower with you. You can carry at most p units and your follower β at most f units.
In the blacksmith shop, you found cnt_s swords and cnt_w war axes. Each sword weights s units and each war axe β w units. You don't care what to take, since each of them will melt into one steel ingot.
What is the maximum number of weapons (both swords and war axes) you and your follower can carry out from the shop?
Input
The first line contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
The first line of each test case contains two integers p and f (1 β€ p, f β€ 10^9) β yours and your follower's capacities.
The second line of each test case contains two integers cnt_s and cnt_w (1 β€ cnt_s, cnt_w β€ 2 β
10^5) β the number of swords and war axes in the shop.
The third line of each test case contains two integers s and w (1 β€ s, w β€ 10^9) β the weights of each sword and each war axe.
It's guaranteed that the total number of swords and the total number of war axes in all test cases don't exceed 2 β
10^5.
Output
For each test case, print the maximum number of weapons (both swords and war axes) you and your follower can carry.
Example
Input
3
33 27
6 10
5 6
100 200
10 10
5 5
1 19
1 3
19 5
Output
11
20
3
Note
In the first test case:
* you should take 3 swords and 3 war axes: 3 β
5 + 3 β
6 = 33 β€ 33
* and your follower β 3 swords and 2 war axes: 3 β
5 + 2 β
6 = 27 β€ 27.
3 + 3 + 3 + 2 = 11 weapons in total.
In the second test case, you can take all available weapons even without your follower's help, since 5 β
10 + 5 β
10 β€ 100.
In the third test case, you can't take anything, but your follower can take 3 war axes: 3 β
5 β€ 19. | def read():
return list(map(int, input().split()))
for _ in range(int(input())):
p, f = read()
cnts, cntw = read()
s, w = read()
if s > w:
s, w = w, s
cnts, cntw = cntw, cnts
res = 0
for i in range(min(p // s, cnts) + 1):
j = min((p - i * s) // w, cntw)
k = min(f // s, cnts - i)
l = min((f - k * s) // w, cntw - j)
res = max(res, i + j + k + l)
print(res) | {
"input": [
"3\n33 27\n6 10\n5 6\n100 200\n10 10\n5 5\n1 19\n1 3\n19 5\n"
],
"output": [
"11\n20\n3\n"
]
} |
2,964 | 8 | The pandemic is upon us, and the world is in shortage of the most important resource: toilet paper. As one of the best prepared nations for this crisis, BubbleLand promised to help all other world nations with this valuable resource. To do that, the country will send airplanes to other countries carrying toilet paper.
In BubbleLand, there are N toilet paper factories, and N airports. Because of how much it takes to build a road, and of course legal issues, every factory must send paper to only one airport, and every airport can only take toilet paper from one factory.
Also, a road can't be built between all airport-factory pairs, again because of legal issues. Every possible road has number d given, number of days it takes to build that road.
Your job is to choose N factory-airport pairs, such that if the country starts building all roads at the same time, it takes the least amount of days to complete them.
Input
The first line contains two integers N (1 β€ N β€ 10^4) - number of airports/factories, and M (1 β€ M β€ 10^5) - number of available pairs to build a road between.
On next M lines, there are three integers u, v (1 β€ u,v β€ N), d (1 β€ d β€ 10^9) - meaning that you can build a road between airport u and factory v for d days.
Output
If there are no solutions, output -1. If there exists a solution, output the minimal number of days to complete all roads, equal to maximal d among all chosen roads.
Example
Input
3 5
1 2 1
2 3 2
3 3 3
2 1 4
2 2 5
Output
4 | def check(k, adj, n):
a = [0 for i in range(n+1)]
f = [0 for i in range(n+1)]
for i in range(n+1):
arr = adj[i]
for j in range(len(arr)):
if arr[j][1] <= k:
a[i] = 1
f[arr[j][0]] = 1
if sum(a) == n and sum(f) == n:
return True
return False
def binSearch(adj, n):
l = 0
r = 10**9
ans = -1
while l<=r:
mid = (l+r)//2
if check(mid, adj, n):
ans = mid
r = mid - 1
else:
l = mid + 1
return ans
n, m = map(int, input().split())
adj = [[] for i in range(n+1)]
for i in range(m):
u, v, d = map(int, input().split())
adj[u].append((v,d))
print(binSearch(adj, n)) | {
"input": [
"3 5\n1 2 1\n2 3 2\n3 3 3\n2 1 4\n2 2 5\n"
],
"output": [
"4\n"
]
} |
2,965 | 10 | You have an array a_1, a_2, ..., a_n where a_i = i.
In one step, you can choose two indices x and y (x β y) and set a_x = \leftβ (a_x)/(a_y) \rightβ (ceiling function).
Your goal is to make array a consist of n - 1 ones and 1 two in no more than n + 5 steps. Note that you don't have to minimize the number of steps.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
The first and only line of each test case contains the single integer n (3 β€ n β€ 2 β
10^5) β the length of array a.
It's guaranteed that the sum of n over test cases doesn't exceed 2 β
10^5.
Output
For each test case, print the sequence of operations that will make a as n - 1 ones and 1 two in the following format: firstly, print one integer m (m β€ n + 5) β the number of operations; next print m pairs of integers x and y (1 β€ x, y β€ n; x β y) (x may be greater or less than y) β the indices of the corresponding operation.
It can be proven that for the given constraints it's always possible to find a correct sequence of operations.
Example
Input
2
3
4
Output
2
3 2
3 2
3
3 4
4 2
4 2
Note
In the first test case, you have array a = [1, 2, 3]. For example, you can do the following:
1. choose 3, 2: a_3 = \leftβ (a_3)/(a_2) \rightβ = 2 and array a = [1, 2, 2];
2. choose 3, 2: a_3 = \leftβ 2/2 \rightβ = 1 and array a = [1, 2, 1].
You've got array with 2 ones and 1 two in 2 steps.
In the second test case, a = [1, 2, 3, 4]. For example, you can do the following:
1. choose 3, 4: a_3 = \leftβ 3/4 \rightβ = 1 and array a = [1, 2, 1, 4];
2. choose 4, 2: a_4 = \leftβ 4/2 \rightβ = 2 and array a = [1, 2, 1, 2];
3. choose 4, 2: a_4 = \leftβ 2/2 \rightβ = 1 and array a = [1, 2, 1, 1]. | import math
def div (n):
if n==2:
return
x = math.ceil(math.sqrt(n))
for i in range(x+1,n):
print(i,n)
print(n,x)
print(n,x)
div(x)
for _ in range(int(input())):
n = int(input())
count = 0
x = n
while x!=2:
count+=1
x=math.ceil(math.sqrt(x))
print(n-2+count)
div(n) | {
"input": [
"2\n3\n4\n"
],
"output": [
"\n2\n3 2\n3 2\n3\n3 4\n4 2\n4 2\n"
]
} |
2,966 | 11 | In the 2050 Conference, some people from the competitive programming community meet together and are going to take a photo. The n people form a line. They are numbered from 1 to n from left to right. Each of them either holds a cardboard with the letter 'C' or a cardboard with the letter 'P'.
Let C=\\{c_1,c_2,...,c_m\} (c_1<c_2<β¦ <c_m) be the set of people who hold cardboards of 'C'. Let P=\\{p_1,p_2,...,p_k\} (p_1<p_2<β¦ <p_k) be the set of people who hold cardboards of 'P'. The photo is good if and only if it satisfies the following constraints:
1. Cβͺ P=\{1,2,...,n\}
2. Cβ© P =β
.
3. c_i-c_{i-1}β€ c_{i+1}-c_i(1< i <m).
4. p_i-p_{i-1}β₯ p_{i+1}-p_i(1< i <k).
Given an array a_1,β¦, a_n, please find the number of good photos satisfying the following condition: $$$β_{xβ C} a_x < β_{yβ P} a_y.$$$
The answer can be large, so output it modulo 998 244 353. Two photos are different if and only if there exists at least one person who holds a cardboard of 'C' in one photo but holds a cardboard of 'P' in the other.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 200 000). Description of the test cases follows.
The first line of each test case contains a single integer n (1β€ nβ€ 200 000).
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 200 000.
Output
For each test case, output the answer modulo 998 244 353 in a separate line.
Example
Input
3
5
2 1 2 1 1
4
9 2 2 2
1
998244353
Output
10
7
1
Note
For the first test case, there are 10 possible good photos satisfying the condition: PPPPP, CPPPP, PCPPP, CCPPP, PCCPP, PCPCP, PPPPC, CPPPC, PCPPC, PPPCC.
For the second test case, there are 7 possible good photos satisfying the condition: PPPP, PCPP, PCCP, PPPC, PCPC, PPCC, PCCC. | import sys,io,os
try:Z=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
except:Z=lambda:sys.stdin.readline().encode()
Y=lambda:map(int,Z().split())
from bisect import bisect
M=998244353
def add(a,b):
v=a+b
if v>=M:v-=M
if v<0:v+=M
return v
def sol(n,a,disp=0):
if n<2:return 1
if n<3:return 2-(a[0]==a[1])
x0=[0];x1=[0];z=1;y=a[-1];s=sum(a)
for i in range(n):
if i&1:x1.append(x1[-1]+a[i])
else:x0.append(x0[-1]+a[i])
c=(s+1)//2
while y<c:z+=1;y+=a[-z]
if disp:print(c)
for i in range(n-1):
if i&1:
aps=x0[i//2+1]
if aps+x1[i//2+1]>=c:break
j=bisect(x1,c-aps-1)
if(n&1)<1:
if j==n//2+1:j-=1
else:
aps=x1[i//2]
if aps+x0[i//2+1]>=c:break
j=bisect(x0,c-aps-1)
if n&1:
if j==n//2+2:j-=1
z=add(z,j-i//2-1)
if disp:print(i,j-i//2-1)
c-=a[-1]
if disp:print(c)
for i in range(n-2):
if i&1:
aps=x0[i//2+1]
if aps+x1[i//2+1]>=c:break
j=bisect(x1,c-aps-1)
if n&1:
if j==n//2+1:j-=1
else:
if j==n//2+1:j-=1
else:
aps=x1[i//2]
if aps+x0[i//2+1]>=c:break
j=bisect(x0,c-aps-1)
if n&1:
if j==n//2+2:j-=1
else:
if j==n//2+1:j-=1
z=add(z,j-i//2-1)
if disp:print(i,j-i//2-1)
c+=a[0]
if disp:print(c)
for i in range(1,n-2):
if i&1:
aps=x0[i//2+1]
if aps+x1[i//2+1]>=c:break
j=bisect(x1,c-aps-1)
if n&1:
if j==n//2+1:j-=1
else:
if j==n//2+1:j-=1
else:
aps=x1[i//2]
if aps+x0[i//2+1]>=c:break
j=bisect(x0,c-aps-1)
if n&1:
if j==n//2+2:j-=1
else:
if j==n//2+1:j-=1
z=add(z,j-i//2-1)
if disp:print(i,j-i//2-1)
c+=a[-1]
if disp:print(c)
for i in range(1,n-1):
if i&1:
aps=x0[i//2+1]
if aps+x1[i//2+1]>=c:break
j=bisect(x1,c-aps-1)
if(n&1)<1:
if j==n//2+1:j-=1
else:
aps=x1[i//2]
if aps+x0[i//2+1]>=c:break
j=bisect(x0,c-aps-1)
if n&1:
if j==n//2+2:j-=1
z=add(z,j-i//2-1)
if disp:print(i,j-i//2-1)
if disp:print(z)
return z
O=[]
for _ in range(int(Z())):O.append(str(sol(int(Z()),[*Y()])))
print('\n'.join(O)) | {
"input": [
"3\n5\n2 1 2 1 1\n4\n9 2 2 2\n1\n998244353\n"
],
"output": [
"\n10\n7\n1\n"
]
} |
2,967 | 9 | There is a bus stop near the university. The lessons are over, and n students come to the stop. The i-th student will appear at the bus stop at time ti (all ti's are distinct).
We shall assume that the stop is located on the coordinate axis Ox, at point x = 0, and the bus goes along the ray Ox, that is, towards the positive direction of the coordinate axis, and back. The i-th student needs to get to the point with coordinate xi (xi > 0).
The bus moves by the following algorithm. Initially it is at point 0. The students consistently come to the stop and get on it. The bus has a seating capacity which is equal to m passengers. At the moment when m students get on the bus, it starts moving in the positive direction of the coordinate axis. Also it starts moving when the last (n-th) student gets on the bus. The bus is moving at a speed of 1 unit of distance per 1 unit of time, i.e. it covers distance y in time y.
Every time the bus passes the point at which at least one student needs to get off, it stops and these students get off the bus. The students need 1 + [k / 2] units of time to get off the bus, where k is the number of students who leave at this point. Expression [k / 2] denotes rounded down k / 2. As soon as the last student leaves the bus, the bus turns around and goes back to the point x = 0. It doesn't make any stops until it reaches the point. At the given point the bus fills with students once more, and everything is repeated.
If students come to the stop when there's no bus, they form a line (queue) and get on the bus in the order in which they came. Any number of students get on the bus in negligible time, you should assume that it doesn't take any time. Any other actions also take no time. The bus has no other passengers apart from the students.
Write a program that will determine for each student the time when he got off the bus. The moment a student got off the bus is the moment the bus stopped at the student's destination stop (despite the fact that the group of students need some time to get off).
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of students and the number of passengers the bus can transport, correspondingly. Next n lines contain descriptions of the students, one per line. Each line contains a pair of integers ti, xi (1 β€ ti β€ 105, 1 β€ xi β€ 104). The lines are given in the order of strict increasing of ti. Values of xi can coincide.
Output
Print n numbers w1, w2, ..., wn, wi β the moment of time when the i-th student got off the bus. Print the numbers on one line and separate them with single spaces.
Examples
Input
1 10
3 5
Output
8
Input
2 1
3 5
4 5
Output
8 19
Input
5 4
3 5
4 5
5 5
6 5
7 1
Output
11 11 11 11 20
Input
20 4
28 13
31 13
35 6
36 4
52 6
53 4
83 2
84 4
87 1
93 6
108 4
113 6
116 1
125 2
130 2
136 13
162 2
166 4
184 1
192 2
Output
51 51 43 40 93 89 86 89 114 121 118 121 137 139 139 152 195 199 193 195
Note
In the first sample the bus waits for the first student for 3 units of time and drives him to his destination in additional 5 units of time. So the student leaves the bus at the moment of time 3 + 5 = 8.
In the second sample the capacity of the bus equals 1, that's why it will drive the first student alone. This student is the same as the student from the first sample. So the bus arrives to his destination at the moment of time 8, spends 1 + [1 / 2] = 1 units of time on getting him off, and returns back to 0 in additional 5 units of time. That is, the bus returns to the bus stop at the moment of time 14. By this moment the second student has already came to the bus stop. So he immediately gets in the bus, and is driven to his destination in additional 5 units of time. He gets there at the moment 14 + 5 = 19.
In the third sample the bus waits for the fourth student for 6 units of time, then drives for 5 units of time, then gets the passengers off for 1 + [4 / 2] = 3 units of time, then returns for 5 units of time, and then drives the fifth student for 1 unit of time. | import sys
from heapq import *
def solve():
n,m = map(int, input().split())
waiting = []
for i in range(n):
ti, xi = map(int, input().split())
heappush(waiting, (ti, xi, i))
res = [None] * n
curtime, curloc = 0, 0
while True:
if len(waiting) == 0: break
bus = []
lasttime = 0
while len(bus) < m and len(waiting) > 0:
firstinline = heappop(waiting)
heappush(bus, (firstinline[1], firstinline[2]))
lasttime = firstinline[0]
curtime = max(lasttime, curtime)
while len(bus) > 0:
curleave = heappop(bus)
count = 1
newloc = curleave[0]
traveled = newloc - curloc
curtime += traveled
res[curleave[1]] = curtime
curloc = newloc
while len(bus) > 0 and bus[0][0] == curleave[0]:
count+=1
curleave = heappop(bus)
res[curleave[1]] = curtime
curtime += (count // 2) + 1
curtime += curloc
curloc = 0
print(' '.join(map(str, res)))
if sys.hexversion == 50594544 : sys.stdin = open("test.txt")
solve() | {
"input": [
"20 4\n28 13\n31 13\n35 6\n36 4\n52 6\n53 4\n83 2\n84 4\n87 1\n93 6\n108 4\n113 6\n116 1\n125 2\n130 2\n136 13\n162 2\n166 4\n184 1\n192 2\n",
"2 1\n3 5\n4 5\n",
"5 4\n3 5\n4 5\n5 5\n6 5\n7 1\n",
"1 10\n3 5\n"
],
"output": [
"51 51 43 40 93 89 86 89 114 121 118 121 137 139 139 152 195 199 193 195 ",
"8 19 ",
"11 11 11 11 20 ",
"8 "
]
} |
2,968 | 10 | Paw the Spider is making a web. Web-making is a real art, Paw has been learning to do it his whole life. Let's consider the structure of the web.
<image>
There are n main threads going from the center of the web. All main threads are located in one plane and divide it into n equal infinite sectors. The sectors are indexed from 1 to n in the clockwise direction. Sectors i and i + 1 are adjacent for every i, 1 β€ i < n. In addition, sectors 1 and n are also adjacent.
Some sectors have bridge threads. Each bridge connects the two main threads that make up this sector. The points at which the bridge is attached to the main threads will be called attachment points. Both attachment points of a bridge are at the same distance from the center of the web. At each attachment point exactly one bridge is attached. The bridges are adjacent if they are in the same sector, and there are no other bridges between them.
A cell of the web is a trapezoid, which is located in one of the sectors and is bounded by two main threads and two adjacent bridges. You can see that the sides of the cell may have the attachment points of bridges from adjacent sectors. If the number of attachment points on one side of the cell is not equal to the number of attachment points on the other side, it creates an imbalance of pulling forces on this cell and this may eventually destroy the entire web. We'll call such a cell unstable. The perfect web does not contain unstable cells.
Unstable cells are marked red in the figure. Stable cells are marked green.
Paw the Spider isn't a skillful webmaker yet, he is only learning to make perfect webs. Help Paw to determine the number of unstable cells in the web he has just spun.
Input
The first line contains integer n (3 β€ n β€ 1000) β the number of main threads.
The i-th of following n lines describe the bridges located in the i-th sector: first it contains integer ki (1 β€ ki β€ 105) equal to the number of bridges in the given sector. Then follow ki different integers pij (1 β€ pij β€ 105; 1 β€ j β€ ki). Number pij equals the distance from the attachment points of the j-th bridge of the i-th sector to the center of the web.
It is guaranteed that any two bridges between adjacent sectors are attached at a different distance from the center of the web. It is guaranteed that the total number of the bridges doesn't exceed 105.
Output
Print a single integer β the number of unstable cells in Paw the Spider's web.
Examples
Input
7
3 1 6 7
4 3 5 2 9
2 8 1
4 3 7 6 4
3 2 5 9
3 6 3 8
3 4 2 9
Output
6 | #------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
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")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=1000000007
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
n=Int()
sector=[]
for i in range(n):
sector.append(sorted(array()[1:]))
# for i in sector: print(*i)
# print()
ans=0
for cur in range(n):
aage=(cur+1)%n
peeche=(cur-1+n)%n
for i in range(1,len(sector[cur])):
l=sector[cur][i-1]
r=sector[cur][i]
left_count= bisect_left(sector[peeche],r) - bisect_right(sector[peeche],l)
right_count= bisect_left(sector[aage],r) - bisect_right(sector[aage],l)
# print(left_count,right_count)
ans+=(left_count!=right_count)
print(ans)
| {
"input": [
"7\n3 1 6 7\n4 3 5 2 9\n2 8 1\n4 3 7 6 4\n3 2 5 9\n3 6 3 8\n3 4 2 9\n"
],
"output": [
"6\n"
]
} |
2,969 | 8 | Squirrel Liss loves nuts. There are n trees (numbered 1 to n from west to east) along a street and there is a delicious nut on the top of each tree. The height of the tree i is hi. Liss wants to eat all nuts.
Now Liss is on the root of the tree with the number 1. In one second Liss can perform one of the following actions:
* Walk up or down one unit on a tree.
* Eat a nut on the top of the current tree.
* Jump to the next tree. In this action the height of Liss doesn't change. More formally, when Liss is at height h of the tree i (1 β€ i β€ n - 1), she jumps to height h of the tree i + 1. This action can't be performed if h > hi + 1.
Compute the minimal time (in seconds) required to eat all nuts.
Input
The first line contains an integer n (1 β€ n β€ 105) β the number of trees.
Next n lines contains the height of trees: i-th line contains an integer hi (1 β€ hi β€ 104) β the height of the tree with the number i.
Output
Print a single integer β the minimal time required to eat all nuts in seconds.
Examples
Input
2
1
2
Output
5
Input
5
2
1
2
1
1
Output
14 | def main():
cur, val = 0, -1
for i in range(int(input())):
h = int(input())
val += abs(cur - h) + 2
cur = h
print(val)
if __name__ == '__main__':
main() | {
"input": [
"5\n2\n1\n2\n1\n1\n",
"2\n1\n2\n"
],
"output": [
"14\n",
"5\n"
]
} |
2,970 | 8 | Little penguin Polo has an n Γ m matrix, consisting of integers. Let's index the matrix rows from 1 to n from top to bottom and let's index the columns from 1 to m from left to right. Let's represent the matrix element on the intersection of row i and column j as aij.
In one move the penguin can add or subtract number d from some matrix element. Find the minimum number of moves needed to make all matrix elements equal. If the described plan is impossible to carry out, say so.
Input
The first line contains three integers n, m and d (1 β€ n, m β€ 100, 1 β€ d β€ 104) β the matrix sizes and the d parameter. Next n lines contain the matrix: the j-th integer in the i-th row is the matrix element aij (1 β€ aij β€ 104).
Output
In a single line print a single integer β the minimum number of moves the penguin needs to make all matrix elements equal. If that is impossible, print "-1" (without the quotes).
Examples
Input
2 2 2
2 4
6 8
Output
4
Input
1 2 7
6 7
Output
-1 | def mlt(): return map(int, input().split())
def arp(): return [*mlt()]
x, y, d = mlt()
#
z = []
for n in range(x):
z += arp()
z.sort()
x = x*y
md = z[x//2]
sm = 0
for n in z:
sm += abs(md-n)
if abs(md-n) % d != 0:
print(-1)
exit(0)
print(sm//d)
| {
"input": [
"1 2 7\n6 7\n",
"2 2 2\n2 4\n6 8\n"
],
"output": [
"-1\n",
"4\n"
]
} |
2,971 | 10 | Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 β€ n, m β€ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 β€ a[i][j] β€ 105).
Output
The output contains a single number β the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] β a[1][2] β a[2][2] β a[3][2] β a[3][3]. Iahubina will choose exercises a[3][1] β a[2][1] β a[2][2] β a[2][3] β a[1][3]. | def main():
n, m = map(int, input().split())
aa = []
for _ in range(n):
row = list(map(int, input().split()))
row.append(0)
aa.append(row)
aa.append([0] * (m + 1))
d1, d2, d3, d4 = ([[0] * (m + 1) for _ in range(n + 1)] for _ in (1, 2, 3, 4))
for i in range(n):
for j in range(m):
d1[i][j] = max(d1[i - 1][j], d1[i][j - 1]) + aa[i][j]
for i in range(n):
for j in range(m - 1, -1, -1):
d2[i][j] = max(d2[i - 1][j], d2[i][j + 1]) + aa[i][j]
for i in range(n - 1, -1, -1):
for j in range(m):
d3[i][j] = max(d3[i + 1][j], d3[i][j - 1]) + aa[i][j]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
d4[i][j] = max(d4[i + 1][j], d4[i][j + 1]) + aa[i][j]
print(max(
max(d1[i][j - 1] + d2[i - 1][j] + d3[i + 1][j] + d4[i][j + 1] for i in range(1, n - 1) for j in range(1, m - 1)),
max(d1[i - 1][j] + d2[i][j + 1] + d3[i][j - 1] + d4[i + 1][j] for i in range(1, n - 1) for j in range(1, m - 1))))
if __name__ == '__main__':
main()
| {
"input": [
"3 3\n100 100 100\n100 1 100\n100 100 100\n"
],
"output": [
"800\n"
]
} |
2,972 | 7 | Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 β€ m, n β€ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value | def ans(m,n):
out=m
for i in range(1,m):
out-=((i/m)**n)
return out
m,n=map(int,input().split())
print(ans(m,n))
| {
"input": [
"2 2\n",
"6 1\n",
"6 3\n"
],
"output": [
"1.75",
"3.5",
"4.95833"
]
} |
2,973 | 8 | In this problem you will have to deal with a real algorithm that is used in the VK social network.
As in any other company that creates high-loaded websites, the VK developers have to deal with request statistics regularly. An important indicator reflecting the load of the site is the mean number of requests for a certain period of time of T seconds (for example, T = 60 seconds = 1 min and T = 86400 seconds = 1 day). For example, if this value drops dramatically, that shows that the site has access problem. If this value grows, that may be a reason to analyze the cause for the growth and add more servers to the website if it is really needed.
However, even such a natural problem as counting the mean number of queries for some period of time can be a challenge when you process the amount of data of a huge social network. That's why the developers have to use original techniques to solve problems approximately, but more effectively at the same time.
Let's consider the following formal model. We have a service that works for n seconds. We know the number of queries to this resource at at each moment of time t (1 β€ t β€ n). Let's formulate the following algorithm of calculating the mean with exponential decay. Let c be some real number, strictly larger than one.
// setting this constant value correctly can adjust
// the time range for which statistics will be calculated
double c = some constant value;
// as the result of the algorithm's performance this variable will contain
// the mean number of queries for the last
// T seconds by the current moment of time
double mean = 0.0;
for t = 1..n: // at each second, we do the following:
// at is the number of queries that came at the last second;
mean = (mean + at / T) / c;
Thus, the mean variable is recalculated each second using the number of queries that came at that second. We can make some mathematical calculations and prove that choosing the value of constant c correctly will make the value of mean not very different from the real mean value ax at t - T + 1 β€ x β€ t.
The advantage of such approach is that it only uses the number of requests at the current moment of time and doesn't require storing the history of requests for a large time range. Also, it considers the recent values with the weight larger than the weight of the old ones, which helps to react to dramatic change in values quicker.
However before using the new theoretical approach in industrial programming, there is an obligatory step to make, that is, to test its credibility practically on given test data sets. Your task is to compare the data obtained as a result of the work of an approximate algorithm to the real data.
You are given n values at, integer T and real number c. Also, you are given m moments pj (1 β€ j β€ m), where we are interested in the mean value of the number of queries for the last T seconds. Implement two algorithms. The first one should calculate the required value by definition, i.e. by the formula <image>. The second algorithm should calculate the mean value as is described above. Print both values and calculate the relative error of the second algorithm by the formula <image>, where approx is the approximate value, obtained by the second algorithm, and real is the exact value obtained by the first algorithm.
Input
The first line contains integer n (1 β€ n β€ 2Β·105), integer T (1 β€ T β€ n) and real number c (1 < c β€ 100) β the time range when the resource should work, the length of the time range during which we need the mean number of requests and the coefficient c of the work of approximate algorithm. Number c is given with exactly six digits after the decimal point.
The next line contains n integers at (1 β€ at β€ 106) β the number of queries to the service at each moment of time.
The next line contains integer m (1 β€ m β€ n) β the number of moments of time when we are interested in the mean number of queries for the last T seconds.
The next line contains m integers pj (T β€ pj β€ n), representing another moment of time for which we need statistics. Moments pj are strictly increasing.
Output
Print m lines. The j-th line must contain three numbers real, approx and error, where:
* <image> is the real mean number of queries for the last T seconds;
* approx is calculated by the given algorithm and equals mean at the moment of time t = pj (that is, after implementing the pj-th iteration of the cycle);
* <image> is the relative error of the approximate algorithm.
The numbers you printed will be compared to the correct numbers with the relative or absolute error 10 - 4. It is recommended to print the numbers with at least five digits after the decimal point.
Examples
Input
1 1 2.000000
1
1
1
Output
1.000000 0.500000 0.500000
Input
11 4 1.250000
9 11 7 5 15 6 6 6 6 6 6
8
4 5 6 7 8 9 10 11
Output
8.000000 4.449600 0.443800
9.500000 6.559680 0.309507
8.250000 6.447744 0.218455
8.000000 6.358195 0.205226
8.250000 6.286556 0.237993
6.000000 6.229245 0.038207
6.000000 6.183396 0.030566
6.000000 6.146717 0.024453
Input
13 4 1.250000
3 3 3 3 3 20 3 3 3 3 3 3 3
10
4 5 6 7 8 9 10 11 12 13
Output
3.000000 1.771200 0.409600
3.000000 2.016960 0.327680
7.250000 5.613568 0.225715
7.250000 5.090854 0.297813
7.250000 4.672684 0.355492
7.250000 4.338147 0.401635
3.000000 4.070517 0.356839
3.000000 3.856414 0.285471
3.000000 3.685131 0.228377
3.000000 3.548105 0.182702 | def main():
s = input().split()
n,T,c = int(s[0]), int(s[1]), float(s[2])
a = list(map(int, input().split()))
m = int(input())
q = list(map(int, input().split()))
sumA, approx, mean = [0], [], 0.
for i in range(1, n+1):
mean = (mean+a[i-1]/T)/c
approx.append(mean)
sumA.append(a[i-1] + sumA[i-1])
ans = [(sumA[q[i]]-sumA[q[i]-T])/T for i in range(m)]
for i in range(m):
print('%.6f' % ans[i], '%.6f' % approx[q[i]-1], '%.6f' % (abs(approx[q[i]-1]- ans[i])/ans[i]))
if __name__ == '__main__':
main()
| {
"input": [
"13 4 1.250000\n3 3 3 3 3 20 3 3 3 3 3 3 3\n10\n4 5 6 7 8 9 10 11 12 13\n",
"11 4 1.250000\n9 11 7 5 15 6 6 6 6 6 6\n8\n4 5 6 7 8 9 10 11\n",
"1 1 2.000000\n1\n1\n1\n"
],
"output": [
"3.0 1.7711999999999999 0.4096\n3.0 2.01696 0.32767999999999997\n7.25 5.613568 0.22571475862068968\n7.25 5.0908544 0.2978131862068966\n7.25 4.67268352 0.3554919282758621\n7.25 4.338146816 0.40163492193103445\n3.0 4.0705174528 0.3568391509333333\n3.0 3.85641396224 0.28547132074666665\n3.0 3.6851311697919997 0.22837705659733323\n3.0 3.5481049358335994 0.18270164527786648\n",
"8.0 4.449599999999999 0.4438000000000001\n9.5 6.55968 0.3095073684210526\n8.25 6.447744 0.21845527272727272\n8.0 6.3581952 0.2052256\n8.25 6.28655616 0.23799319272727273\n6.0 6.229244928 0.03820748799999999\n6.0 6.1833959424 0.030565990399999965\n6.0 6.14671675392 0.024452792319999972\n",
"1.0 0.5 0.5\n"
]
} |
2,974 | 7 | Vasya and Petya are playing a simple game. Vasya thought of number x between 1 and n, and Petya tries to guess the number.
Petya can ask questions like: "Is the unknown number divisible by number y?".
The game is played by the following rules: first Petya asks all the questions that interest him (also, he can ask no questions), and then Vasya responds to each question with a 'yes' or a 'no'. After receiving all the answers Petya should determine the number that Vasya thought of.
Unfortunately, Petya is not familiar with the number theory. Help him find the minimum number of questions he should ask to make a guaranteed guess of Vasya's number, and the numbers yi, he should ask the questions about.
Input
A single line contains number n (1 β€ n β€ 103).
Output
Print the length of the sequence of questions k (0 β€ k β€ n), followed by k numbers β the questions yi (1 β€ yi β€ n).
If there are several correct sequences of questions of the minimum length, you are allowed to print any of them.
Examples
Input
4
Output
3
2 4 3
Input
6
Output
4
2 4 3 5
Note
The sequence from the answer to the first sample test is actually correct.
If the unknown number is not divisible by one of the sequence numbers, it is equal to 1.
If the unknown number is divisible by 4, it is 4.
If the unknown number is divisible by 3, then the unknown number is 3.
Otherwise, it is equal to 2. Therefore, the sequence of questions allows you to guess the unknown number. It can be shown that there is no correct sequence of questions of length 2 or shorter. | n = int(input())
t = 0
def prime(n):
for i in range(2,n):
if n%i == 0:
return 0
return 1
l = []
for i in range(2,n+1):
if prime(i) == 1:
l.append(i)
k=2
while i**k <= n:
l.append(i**k)
k+=1
print(len(l))
print(*l)
| {
"input": [
"4\n",
"6\n"
],
"output": [
"3\n2 4 3\n",
"4\n2 4 3 5\n"
]
} |
2,975 | 11 | You have a rectangular chocolate bar consisting of n Γ m single squares. You want to eat exactly k squares, so you may need to break the chocolate bar.
In one move you can break any single rectangular piece of chocolate in two rectangular pieces. You can break only by lines between squares: horizontally or vertically. The cost of breaking is equal to square of the break length.
For example, if you have a chocolate bar consisting of 2 Γ 3 unit squares then you can break it horizontally and get two 1 Γ 3 pieces (the cost of such breaking is 32 = 9), or you can break it vertically in two ways and get two pieces: 2 Γ 1 and 2 Γ 2 (the cost of such breaking is 22 = 4).
For several given values n, m and k find the minimum total cost of breaking. You can eat exactly k squares of chocolate if after all operations of breaking there is a set of rectangular pieces of chocolate with the total size equal to k squares. The remaining nΒ·m - k squares are not necessarily form a single rectangular piece.
Input
The first line of the input contains a single integer t (1 β€ t β€ 40910) β the number of values n, m and k to process.
Each of the next t lines contains three integers n, m and k (1 β€ n, m β€ 30, 1 β€ k β€ min(nΒ·m, 50)) β the dimensions of the chocolate bar and the number of squares you want to eat respectively.
Output
For each n, m and k print the minimum total cost needed to break the chocolate bar, in order to make it possible to eat exactly k squares.
Examples
Input
4
2 2 1
2 2 3
2 2 2
2 2 4
Output
5
5
4
0
Note
In the first query of the sample one needs to perform two breaks:
* to split 2 Γ 2 bar into two pieces of 2 Γ 1 (cost is 22 = 4),
* to split the resulting 2 Γ 1 into two 1 Γ 1 pieces (cost is 12 = 1).
In the second query of the sample one wants to eat 3 unit squares. One can use exactly the same strategy as in the first query of the sample. | d = [0] * 49011
def g(n, m, k):
t = 1e9
for i in range(1, m // 2 + 1):
for j in range(k + 1):
t = min(t, f(n, m - i, k - j) + f(n, i, j))
return n * n + t
def f(n, m, k):
if n > m: n, m = m, n
k = min(k, n * m - k)
if k == 0: return 0
if k < 0: return 1e9
q = n + 31 * m + 961 * k
if d[q] == 0: d[q] = min(g(n, m, k), g(m, n, k))
return d[q]
for q in range(int(input())):
n, m, k = map(int, input().split())
print(f(n, m, k)) | {
"input": [
"4\n2 2 1\n2 2 3\n2 2 2\n2 2 4\n"
],
"output": [
" 5\n 5\n 4\n 0\n"
]
} |
2,976 | 9 | It's now 260 AD. Shapur, being extremely smart, became the King of Persia. He is now called Shapur, His majesty King of kings of Iran and Aniran.
Recently the Romans declared war on Persia. They dreamed to occupy Armenia. In the recent war, the Romans were badly defeated. Now their senior army general, Philip is captured by Shapur and Shapur is now going to capture Valerian, the Roman emperor.
Being defeated, the cowardly Valerian hid in a room at the top of one of his castles. To capture him, Shapur has to open many doors. Fortunately Valerian was too scared to make impenetrable locks for the doors.
Each door has 4 parts. The first part is an integer number a. The second part is either an integer number b or some really odd sign which looks like R. The third one is an integer c and the fourth part is empty! As if it was laid for writing something. Being extremely gifted, after opening the first few doors, Shapur found out the secret behind the locks.
c is an integer written in base a, to open the door we should write it in base b. The only bad news is that this R is some sort of special numbering system that is used only in Roman empire, so opening the doors is not just a piece of cake!
Here's an explanation of this really weird number system that even doesn't have zero:
Roman numerals are based on seven symbols: a stroke (identified with the letter I) for a unit, a chevron (identified with the letter V) for a five, a cross-stroke (identified with the letter X) for a ten, a C (identified as an abbreviation of Centum) for a hundred, etc.:
* I=1
* V=5
* X=10
* L=50
* C=100
* D=500
* M=1000
Symbols are iterated to produce multiples of the decimal (1, 10, 100, 1, 000) values, with V, L, D substituted for a multiple of five, and the iteration continuing: I 1, II 2, III 3, V 5, VI 6, VII 7, etc., and the same for other bases: X 10, XX 20, XXX 30, L 50, LXXX 80; CC 200, DCC 700, etc. At the fourth and ninth iteration, a subtractive principle must be employed, with the base placed before the higher base: IV 4, IX 9, XL 40, XC 90, CD 400, CM 900.
Also in bases greater than 10 we use A for 10, B for 11, etc.
Help Shapur capture Valerian and bring peace back to Persia, especially Armenia.
Input
The first line contains two integers a and b (2 β€ a, b β€ 25). Only b may be replaced by an R which indicates Roman numbering system.
The next line contains a single non-negative integer c in base a which may contain leading zeros but its length doesn't exceed 103.
It is guaranteed that if we have Roman numerals included the number would be less than or equal to 300010 and it won't be 0. In any other case the number won't be greater than 101510.
Output
Write a single line that contains integer c in base b. You must omit leading zeros.
Examples
Input
10 2
1
Output
1
Input
16 R
5
Output
V
Input
5 R
4
Output
IV
Input
2 2
1111001
Output
1111001
Input
12 13
A
Output
A
Note
You can find more information about roman numerals here: http://en.wikipedia.org/wiki/Roman_numerals | def main() :
def intToRoman(num) :
pattern = {'0':'', '1':'a', '2':'aa', '3':'aaa', '4':'ab',
'5':'b', '6':'ba', '7':'baa', '8':'baaa', '9':'ac'}
code = ['IVX', 'XLC', 'CDM', 'M__']
ret = []
for i,x in enumerate(reversed(str(num))) :
tmp = pattern[x]
for p,r in zip('abc', code[i]) :
tmp = tmp.replace(p, r)
ret.append(tmp)
return ''.join(reversed(ret))
encodeB = '0123456789ABCDEFGHIJKLMNO'
decodeA = {x:i for i,x in enumerate(encodeB)}
a,b = input().split()
a = int(a)
if b != 'R' : b = int(b)
c = sum(decodeA[x] * a**i
for i,x in enumerate(reversed(input().lstrip('0'))))
if b == 'R' :
print(intToRoman(c))
return
ans = []
while c :
ans.append(encodeB[c % b])
c //= b
ans = ''.join(reversed(ans))
if not ans : ans = 0 # θ§θ½οΌ
print(ans)
main() | {
"input": [
"2 2\n1111001\n",
"12 13\nA\n",
"5 R\n4\n",
"10 2\n1\n",
"16 R\n5\n"
],
"output": [
"1111001\n",
"A\n",
"IV\n",
"1\n",
"V\n"
]
} |
2,977 | 8 | In a strategic computer game "Settlers II" one has to build defense structures to expand and protect the territory. Let's take one of these buildings. At the moment the defense structure accommodates exactly n soldiers. Within this task we can assume that the number of soldiers in the defense structure won't either increase or decrease.
Every soldier has a rank β some natural number from 1 to k. 1 stands for a private and k stands for a general. The higher the rank of the soldier is, the better he fights. Therefore, the player profits from having the soldiers of the highest possible rank.
To increase the ranks of soldiers they need to train. But the soldiers won't train for free, and each training session requires one golden coin. On each training session all the n soldiers are present.
At the end of each training session the soldiers' ranks increase as follows. First all the soldiers are divided into groups with the same rank, so that the least possible number of groups is formed. Then, within each of the groups where the soldiers below the rank k are present, exactly one soldier increases his rank by one.
You know the ranks of all n soldiers at the moment. Determine the number of golden coins that are needed to increase the ranks of all the soldiers to the rank k.
Input
The first line contains two integers n and k (1 β€ n, k β€ 100). They represent the number of soldiers and the number of different ranks correspondingly. The second line contains n numbers in the non-decreasing order. The i-th of them, ai, represents the rank of the i-th soldier in the defense building (1 β€ i β€ n, 1 β€ ai β€ k).
Output
Print a single integer β the number of golden coins needed to raise all the soldiers to the maximal rank.
Examples
Input
4 4
1 2 2 3
Output
4
Input
4 3
1 1 1 1
Output
5
Note
In the first example the ranks will be raised in the following manner:
1 2 2 3 β 2 2 3 4 β 2 3 4 4 β 3 4 4 4 β 4 4 4 4
Thus totals to 4 training sessions that require 4 golden coins. | import sys
from array import array # noqa: F401
from collections import Counter
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n, k = map(int, input().split())
counter = Counter(map(int, input().split()))
ans = 0
while counter[k] < n:
for i in range(k - 1, 0, -1):
if counter[i]:
counter[i + 1] += 1
counter[i] -= 1
ans += 1
print(ans)
| {
"input": [
"4 4\n1 2 2 3\n",
"4 3\n1 1 1 1\n"
],
"output": [
"4\n",
"5\n"
]
} |
2,978 | 11 | Group of Berland scientists, with whom you have a close business relationship, makes a research in the area of peaceful nuclear energy. In particular, they found that a group of four nanobots, placed on a surface of a plate, can run a powerful chain reaction under certain conditions.
To be precise, researchers introduced a rectangular Cartesian coordinate system on a flat plate and selected four distinct points with integer coordinates where bots will be placed initially. Next each bot will be assigned with one of the four directions (up, down, left or right) parallel to the coordinate axes. After that, each bot is shifted by an integer distance (which may be different for different bots) along its direction. The chain reaction starts, if the bots are in the corners of a square with positive area with sides parallel to the coordinate axes. Each corner of the square must contain one nanobot. This reaction will be stronger, if bots spend less time to move. We can assume that bots move with unit speed. In other words, the lesser is the maximum length traveled by bot, the stronger is reaction.
Scientists have prepared a set of plates and selected starting position for the bots for each plate. Now they ask you to assign the direction for each bot to move after landing such that the maximum length traveled by bot is as small as possible.
Input
The first line contains an integer number t (1 β€ t β€ 50) β the number of plates.
t descriptions of plates follow. A description of each plate consists of four lines. Each line consists of a pair of integers numbers xi, yi ( - 108 β€ xi, yi β€ 108) β coordinates of the next bot. All bots are in different locations.
Note, though, the problem can include several records in one test, you can hack other people's submissions only with the test of one plate, i.e. parameter t in a hack test should be equal to 1.
Output
Print answers for all plates separately. First goes a single integer number in a separate line. If scientists have made an unfortunate mistake and nanobots are not able to form the desired square, print -1. Otherwise, print the minimum possible length of the longest bot's path.
If a solution exists, in the next four lines print two integer numbers β positions of each bot after moving. Print bots' positions in the order they are specified in the input data.
If there are multiple solution, you can print any of them.
Examples
Input
2
1 1
1 -1
-1 1
-1 -1
1 1
2 2
4 4
6 6
Output
0
1 1
1 -1
-1 1
-1 -1
-1 | import sys
sys.stderr = sys.stdout
from collections import namedtuple
Bot = namedtuple('Bot', ('x', 'y', 'i'))
def yxi(bot):
return bot.y, bot.x, bot.i
def reaction1(B, V):
Bv = sorted(B[i] for i in range(4) if V[i])
Bh = sorted((B[i] for i in range(4) if not V[i]), key=yxi)
S = [None] * 4
if len(Bv) == 0:
if not (Bh[0].y == Bh[1].y < Bh[2].y == Bh[3].y):
return None, None
y0 = Bh[0].y
y1 = Bh[2].y
d = y1 - y0
X = [Bh[0].x, Bh[1].x - d, Bh[2].x, Bh[3].x - d]
Xmin = min(X)
Xmax = max(X)
x0 = (Xmin + Xmax) // 2
l = Xmax - x0
S[Bh[0].i] = x0, y0
S[Bh[1].i] = x0 + d, y0
S[Bh[2].i] = x0, y1
S[Bh[3].i] = x0 + d, y1
return l, S
elif len(Bv) == 1:
if Bh[0].y == Bh[1].y < Bh[2].y:
y0 = Bh[0].y
y1 = Bh[2].y
x0 = Bv[0].x
d = y1 - y0
l0 = abs(Bv[0].y - y1)
l1 = max(abs(x0 - Bh[0].x), abs(x0 + d - Bh[1].x),
l0, abs(x0 + d - Bh[2].x))
l2 = max(abs(x0 - d - Bh[0].x), abs(x0 - Bh[1].x),
abs(x0 - d - Bh[2].x), l0)
if l1 <= l2:
l = l1
S[Bh[0].i] = x0, y0
S[Bh[1].i] = x0 + d, y0
S[Bv[0].i] = x0, y1
S[Bh[2].i] = x0 + d, y1
else:
l = l2
S[Bh[0].i] = x0 - d, y0
S[Bh[1].i] = x0, y0
S[Bh[2].i] = x0 - d, y1
S[Bv[0].i] = x0, y1
return l, S
elif Bh[0].y < Bh[1].y == Bh[2].y:
y0 = Bh[0].y
y1 = Bh[2].y
x0 = Bv[0].x
d = y1 - y0
l0 = abs(Bv[0].y - y0)
l1 = max(l0, abs(x0 + d - Bh[0].x),
abs(x0 - Bh[1].x), abs(x0 + d - Bh[2].x))
l2 = max(abs(x0 - d - Bh[0].x), l0,
abs(x0 - d - Bh[1].x), abs(x0 - Bh[2].x))
if l1 <= l2:
l = l1
S[Bv[0].i] = x0, y0
S[Bh[0].i] = x0 + d, y0
S[Bh[1].i] = x0, y1
S[Bh[2].i] = x0 + d, y1
else:
l = l2
S[Bh[0].i] = x0 - d, y0
S[Bv[0].i] = x0, y0
S[Bh[1].i] = x0 - d, y1
S[Bh[2].i] = x0, y1
return l, S
else:
return None, None
elif len(Bv) == 2:
if Bv[0].x < Bv[1].x and Bh[0].y < Bh[1].y:
x0 = Bv[0].x
x1 = Bv[1].x
y0 = Bh[0].y
y1 = Bh[1].y
if x1 - x0 != y1 - y0:
return None, None
l1 = max(abs(Bh[0].x - x0), abs(Bv[0].y - y1),
abs(Bh[1].x - x1), abs(Bv[1].y - y0))
l2 = max(abs(Bh[0].x - x1), abs(Bv[0].y - y0),
abs(Bh[1].x - x0), abs(Bv[1].y - y1))
S = [None] * 4
if l1 <= l2:
l = l1
S[Bh[0].i] = x0, y0
S[Bh[1].i] = x1, y1
S[Bv[0].i] = x0, y1
S[Bv[1].i] = x1, y0
else:
l = l2
S[Bh[0].i] = x1, y0
S[Bh[1].i] = x0, y1
S[Bv[0].i] = x0, y0
S[Bv[1].i] = x1, y1
return l, S
elif Bv[0].x != Bv[1].x:
x0 = Bv[0].x
x1 = Bv[1].x
y0 = Bh[0].y
d = x1 - x0
lh = max(abs(Bh[0].x - x0), abs(Bh[1].x - x1))
l1 = max(lh, abs(y0 - d - Bv[0].y), abs(y0 - d - Bv[1].y))
l2 = max(lh, abs(y0 + d - Bv[0].y), abs(y0 + d - Bv[1].y))
S = [None] * 4
if l1 <= l2:
l = l1
S[Bh[0].i] = x0, y0
S[Bh[1].i] = x1, y0
S[Bv[0].i] = x0, y0 - d
S[Bv[1].i] = x1, y0 - d
else:
l = l2
S[Bh[0].i] = x0, y0
S[Bh[1].i] = x1, y0
S[Bv[0].i] = x0, y0 + d
S[Bv[1].i] = x1, y0 + d
return l, S
elif Bh[0].y != Bh[1].y:
y0 = Bh[0].y
y1 = Bh[1].y
x0 = Bv[0].x
d = y1 - y0
lh = max(abs(Bv[0].y - y0), abs(Bv[1].y - y1))
l1 = max(lh, abs(x0 - d - Bh[0].x), abs(x0 - d - Bh[1].x))
l2 = max(lh, abs(x0 + d - Bh[0].x), abs(x0 + d - Bh[1].x))
S = [None] * 4
if l1 <= l2:
l = l1
S[Bv[0].i] = x0, y0
S[Bv[1].i] = x0, y1
S[Bh[0].i] = x0 - d, y0
S[Bh[1].i] = x0 - d, y1
else:
l = l2
S[Bv[0].i] = x0, y0
S[Bv[1].i] = x0, y1
S[Bh[0].i] = x0 + d, y0
S[Bh[1].i] = x0 + d, y1
return l, S
else:
return None, None
elif len(Bv) == 3:
if Bv[0].x == Bv[1].x < Bv[2].x:
x0 = Bv[0].x
x1 = Bv[2].x
y0 = Bh[0].y
d = x1 - x0
l0 = abs(Bh[0].x - x1)
l1 = max(abs(y0 - Bv[0].y), abs(y0 + d - Bv[1].y),
l0, abs(y0 + d - Bv[2].y))
l2 = max(abs(y0 - d - Bv[0].y), abs(y0 - Bv[1].y),
abs(y0 - d - Bv[2].y), l0)
if l1 <= l2:
l = l1
S[Bv[0].i] = x0, y0
S[Bv[1].i] = x0, y0 + d
S[Bh[0].i] = x1, y0
S[Bv[2].i] = x1, y0 + d
else:
l = l2
S[Bv[0].i] = x0, y0 - d
S[Bv[1].i] = x0, y0
S[Bv[2].i] = x1, y0 - d
S[Bh[0].i] = x1, y0
return l, S
elif Bv[0].x < Bv[1].x == Bv[2].x:
x0 = Bv[0].x
x1 = Bv[2].x
y0 = Bh[0].y
d = x1 - x0
l0 = abs(Bh[0].x - x0)
l1 = max(l0, abs(y0 + d - Bv[0].y),
abs(y0 - Bv[1].y), abs(y0 + d - Bv[2].y))
l2 = max(abs(y0 - d - Bv[0].y), l0,
abs(y0 - d - Bv[1].y), abs(y0 - Bv[2].y))
if l1 <= l2:
l = l1
S[Bh[0].i] = x0, y0
S[Bv[0].i] = x0, y0 + d
S[Bv[1].i] = x1, y0
S[Bv[2].i] = x1, y0 + d
else:
l = l2
S[Bv[0].i] = x0, y0 - d
S[Bh[0].i] = x0, y0
S[Bv[1].i] = x1, y0 - d
S[Bv[2].i] = x1, y0
return l, S
else:
return None, None
elif len(Bv) == 4:
if not (Bv[0].x == Bv[1].x < Bv[2].x == Bv[3].x):
return None, None
x0 = Bv[0].x
x1 = Bv[2].x
d = x1 - x0
Y = [Bv[0].y, Bv[1].y - d, Bv[2].y, Bv[3].y - d]
Ymin = min(Y)
Ymax = max(Y)
y0 = (Ymin + Ymax) // 2
l = Ymax - y0
S[Bv[0].i] = x0, y0
S[Bv[1].i] = x0, y0 + d
S[Bv[2].i] = x1, y0
S[Bv[3].i] = x1, y0 + d
return l, S
def reaction(B):
l = None
S = None
for v0 in (True, False):
for v1 in (True, False):
for v2 in (True, False):
for v3 in (True, False):
l1, S1 = reaction1(B, (v0, v1, v2, v3))
if l1 is not None and (l is None or l1 < l):
l = l1
S = S1
return l, S
def readb(i):
x, y = readinti()
return Bot(x, y, i)
def main():
t = readint()
L = []
for _ in range(t):
B = [readb(i) for i in range(4)]
l, S = reaction(B)
if l is None:
L.append('-1')
else:
L.append(str(l))
L.extend(f'{b1} {b2}' for b1, b2 in S)
print('\n'.join(L))
##########
def readint():
return int(input())
def readinti():
return map(int, input().split())
def readintt():
return tuple(readinti())
def readintl():
return list(readinti())
def readinttl(k):
return [readintt() for _ in range(k)]
def readintll(k):
return [readintl() for _ in range(k)]
def log(*args, **kwargs):
print(*args, **kwargs, file=sys.__stderr__)
if __name__ == '__main__':
main()
| {
"input": [
"2\n1 1\n1 -1\n-1 1\n-1 -1\n1 1\n2 2\n4 4\n6 6\n"
],
"output": [
"0\n1 1\n1 -1\n-1 1\n-1 -1\n-1\n"
]
} |
2,979 | 8 | Today, hedgehog Filya went to school for the very first time! Teacher gave him a homework which Filya was unable to complete without your help.
Filya is given an array of non-negative integers a1, a2, ..., an. First, he pick an integer x and then he adds x to some elements of the array (no more than once), subtract x from some other elements (also, no more than once) and do no change other elements. He wants all elements of the array to be equal.
Now he wonders if it's possible to pick such integer x and change some elements of the array using this x in order to make all elements equal.
Input
The first line of the input contains an integer n (1 β€ n β€ 100 000) β the number of integers in the Filya's array. The second line contains n integers a1, a2, ..., an (0 β€ ai β€ 109) β elements of the array.
Output
If it's impossible to make all elements of the array equal using the process given in the problem statement, then print "NO" (without quotes) in the only line of the output. Otherwise print "YES" (without quotes).
Examples
Input
5
1 3 3 2 1
Output
YES
Input
5
1 2 3 4 5
Output
NO
Note
In the first sample Filya should select x = 1, then add it to the first and the last elements of the array and subtract from the second and the third elements. | def if_equal(n,s):
return ['NO','YES'][len(s)<3 or (len(s)==3 and s[0]+s[2]==s[1]*2)]
n=int(input())
s=sorted(list(set(list(map(int,input().split())))))
print(if_equal(n,s)) | {
"input": [
"5\n1 3 3 2 1\n",
"5\n1 2 3 4 5\n"
],
"output": [
"YES\n",
"NO\n"
]
} |
2,980 | 11 | Anton is growing a tree in his garden. In case you forgot, the tree is a connected acyclic undirected graph.
There are n vertices in the tree, each of them is painted black or white. Anton doesn't like multicolored trees, so he wants to change the tree such that all vertices have the same color (black or white).
To change the colors Anton can use only operations of one type. We denote it as paint(v), where v is some vertex of the tree. This operation changes the color of all vertices u such that all vertices on the shortest path from v to u have the same color (including v and u). For example, consider the tree
<image>
and apply operation paint(3) to get the following:
<image>
Anton is interested in the minimum number of operation he needs to perform in order to make the colors of all vertices equal.
Input
The first line of the input contains a single integer n (1 β€ n β€ 200 000) β the number of vertices in the tree.
The second line contains n integers colori (0 β€ colori β€ 1) β colors of the vertices. colori = 0 means that the i-th vertex is initially painted white, while colori = 1 means it's initially painted black.
Then follow n - 1 line, each of them contains a pair of integers ui and vi (1 β€ ui, vi β€ n, ui β vi) β indices of vertices connected by the corresponding edge. It's guaranteed that all pairs (ui, vi) are distinct, i.e. there are no multiple edges.
Output
Print one integer β the minimum number of operations Anton has to apply in order to make all vertices of the tree black or all vertices of the tree white.
Examples
Input
11
0 0 0 1 1 0 1 0 0 1 1
1 2
1 3
2 4
2 5
5 6
5 7
3 8
3 9
3 10
9 11
Output
2
Input
4
0 0 0 0
1 2
2 3
3 4
Output
0
Note
In the first sample, the tree is the same as on the picture. If we first apply operation paint(3) and then apply paint(6), the tree will become completely black, so the answer is 2.
In the second sample, the tree is already white, so there is no need to apply any operations and the answer is 0. | def main():
from collections import defaultdict
n, colors = int(input()), input()[::2]
dsu, edges, d = list(range(n)), [], defaultdict(list)
for _ in range(n - 1):
u, v = map(int, input().split())
u -= 1
v -= 1
if colors[u] == colors[v]:
a, b = dsu[u], dsu[v]
while a != dsu[a]:
a = dsu[a]
while b != dsu[b]:
b = dsu[b]
if a < b:
dsu[b] = dsu[v] = a
else:
dsu[a] = dsu[u] = b
else:
edges.append(u)
edges.append(v)
for u, v in enumerate(dsu):
dsu[u] = dsu[v]
while edges:
u, v = dsu[edges.pop()], dsu[edges.pop()]
d[u].append(v)
d[v].append(u)
def bfs(x):
nxt, avail, t = [x], [True] * n, 0
while nxt:
t += 1
cur, nxt = nxt, []
for y in cur:
avail[y] = False
for y in d[y]:
if avail[y]:
nxt.append(y)
return t if x else cur[0]
print(bfs(bfs(0)) // 2)
if __name__ == '__main__':
main()
| {
"input": [
"11\n0 0 0 1 1 0 1 0 0 1 1\n1 2\n1 3\n2 4\n2 5\n5 6\n5 7\n3 8\n3 9\n3 10\n9 11\n",
"4\n0 0 0 0\n1 2\n2 3\n3 4\n"
],
"output": [
"2\n",
"0\n"
]
} |
2,981 | 8 | You are given the array of integer numbers a0, a1, ..., an - 1. For each element find the distance to the nearest zero (to the element which equals to zero). There is at least one zero element in the given array.
Input
The first line contains integer n (1 β€ n β€ 2Β·105) β length of the array a. The second line contains integer elements of the array separated by single spaces ( - 109 β€ ai β€ 109).
Output
Print the sequence d0, d1, ..., dn - 1, where di is the difference of indices between i and nearest j such that aj = 0. It is possible that i = j.
Examples
Input
9
2 1 0 3 0 0 3 2 4
Output
2 1 0 1 0 0 1 2 3
Input
5
0 1 2 3 4
Output
0 1 2 3 4
Input
7
5 6 0 1 -2 3 4
Output
2 1 0 1 2 3 4 | inf = 10**10
input()
nums = [int(x) for x in input().split()]
def run(ns):
curr = inf
res = []
for num in ns:
if num == 0:
curr = 0
res.append(curr)
curr += 1
return res
fw = run(nums)
rew = (run(reversed(nums)))[::-1]
print(' '.join(str(min(fw[i], rew[i])) for i in range(len(nums))))
| {
"input": [
"7\n5 6 0 1 -2 3 4\n",
"5\n0 1 2 3 4\n",
"9\n2 1 0 3 0 0 3 2 4\n"
],
"output": [
"2 1 0 1 2 3 4 ",
"0 1 2 3 4 ",
"2 1 0 1 0 0 1 2 3 "
]
} |
2,982 | 7 | The hero of our story, Valera, and his best friend Arcady are still in school, and therefore they spend all the free time playing turn-based strategy "GAGA: Go And Go Again". The gameplay is as follows.
There are two armies on the playing field each of which consists of n men (n is always even). The current player specifies for each of her soldiers an enemy's soldier he will shoot (a target) and then all the player's soldiers shot simultaneously. This is a game world, and so each soldier shoots perfectly, that is he absolutely always hits the specified target. If an enemy soldier is hit, he will surely die. It may happen that several soldiers had been indicated the same target. Killed soldiers do not participate in the game anymore.
The game "GAGA" consists of three steps: first Valera makes a move, then Arcady, then Valera again and the game ends.
You are asked to calculate the maximum total number of soldiers that may be killed during the game.
Input
The input data consist of a single integer n (2 β€ n β€ 108, n is even). Please note that before the game starts there are 2n soldiers on the fields.
Output
Print a single number β a maximum total number of soldiers that could be killed in the course of the game in three turns.
Examples
Input
2
Output
3
Input
4
Output
6
Note
The first sample test:
1) Valera's soldiers 1 and 2 shoot at Arcady's soldier 1.
2) Arcady's soldier 2 shoots at Valera's soldier 1.
3) Valera's soldier 1 shoots at Arcady's soldier 2.
There are 3 soldiers killed in total: Valera's soldier 1 and Arcady's soldiers 1 and 2. | def main():
n=int(input())
print(2*n-n//2)
main()
| {
"input": [
"2\n",
"4\n"
],
"output": [
"3",
"6"
]
} |
2,983 | 9 | Vasya has several phone books, in which he recorded the telephone numbers of his friends. Each of his friends can have one or several phone numbers.
Vasya decided to organize information about the phone numbers of friends. You will be given n strings β all entries from Vasya's phone books. Each entry starts with a friend's name. Then follows the number of phone numbers in the current entry, and then the phone numbers themselves. It is possible that several identical phones are recorded in the same record.
Vasya also believes that if the phone number a is a suffix of the phone number b (that is, the number b ends up with a), and both numbers are written by Vasya as the phone numbers of the same person, then a is recorded without the city code and it should not be taken into account.
The task is to print organized information about the phone numbers of Vasya's friends. It is possible that two different people have the same number. If one person has two numbers x and y, and x is a suffix of y (that is, y ends in x), then you shouldn't print number x. If the number of a friend in the Vasya's phone books is recorded several times in the same format, it is necessary to take it into account exactly once.
Read the examples to understand statement and format of the output better.
Input
First line contains the integer n (1 β€ n β€ 20) β number of entries in Vasya's phone books.
The following n lines are followed by descriptions of the records in the format described in statement. Names of Vasya's friends are non-empty strings whose length does not exceed 10. They consists only of lowercase English letters. Number of phone numbers in one entry is not less than 1 is not more than 10. The telephone numbers consist of digits only. If you represent a phone number as a string, then its length will be in range from 1 to 10. Phone numbers can contain leading zeros.
Output
Print out the ordered information about the phone numbers of Vasya's friends. First output m β number of friends that are found in Vasya's phone books.
The following m lines must contain entries in the following format "name number_of_phone_numbers phone_numbers". Phone numbers should be separated by a space. Each record must contain all the phone numbers of current friend.
Entries can be displayed in arbitrary order, phone numbers for one record can also be printed in arbitrary order.
Examples
Input
2
ivan 1 00123
masha 1 00123
Output
2
masha 1 00123
ivan 1 00123
Input
3
karl 2 612 12
petr 1 12
katya 1 612
Output
3
katya 1 612
petr 1 12
karl 1 612
Input
4
ivan 3 123 123 456
ivan 2 456 456
ivan 8 789 3 23 6 56 9 89 2
dasha 2 23 789
Output
2
dasha 2 23 789
ivan 4 789 123 2 456 | def print_arr(arr):
for i in arr:
print(i, "", end="")
print()
n = int(input())
d = {}
for _ in range(n):
name, num, *numbers = input().split()
if name in d:
s = d[name]
else:
s = []
for nm in numbers:
for i in s:
if i.endswith(nm):
state=1
break
if nm.endswith(i):
s.remove(i)
else:
s.append(nm)
d[name] = s
print(len(d))
for name in d:
print(name, len(d[name]), end=" ")
print_arr(d[name]) | {
"input": [
"4\nivan 3 123 123 456\nivan 2 456 456\nivan 8 789 3 23 6 56 9 89 2\ndasha 2 23 789\n",
"3\nkarl 2 612 12\npetr 1 12\nkatya 1 612\n",
"2\nivan 1 00123\nmasha 1 00123\n"
],
"output": [
"2\ndasha 2 23 789 \nivan 4 123 2 456 789 \n",
"3\nkarl 1 612\npetr 1 12\nkatya 1 612\n",
"2\nivan 1 00123 \nmasha 1 00123 \n"
]
} |
2,984 | 10 | You are given a graph with n nodes and m directed edges. One lowercase letter is assigned to each node. We define a path's value as the number of the most frequently occurring letter. For example, if letters on a path are "abaca", then the value of that path is 3. Your task is find a path whose value is the largest.
Input
The first line contains two positive integers n, m (1 β€ n, m β€ 300 000), denoting that the graph has n nodes and m directed edges.
The second line contains a string s with only lowercase English letters. The i-th character is the letter assigned to the i-th node.
Then m lines follow. Each line contains two integers x, y (1 β€ x, y β€ n), describing a directed edge from x to y. Note that x can be equal to y and there can be multiple edges between x and y. Also the graph can be not connected.
Output
Output a single line with a single integer denoting the largest value. If the value can be arbitrarily large, output -1 instead.
Examples
Input
5 4
abaca
1 2
1 3
3 4
4 5
Output
3
Input
6 6
xzyabc
1 2
3 1
2 3
5 4
4 3
6 4
Output
-1
Input
10 14
xzyzyzyzqx
1 2
2 4
3 5
4 5
2 6
6 8
6 5
2 10
3 9
10 9
4 6
1 10
2 8
3 7
Output
4
Note
In the first sample, the path with largest value is 1 β 3 β 4 β 5. The value is 3 because the letter 'a' appears 3 times. | import sys
from collections import defaultdict, deque
input = sys.stdin.readline
def beauty(n,m,z,x,y):
l=z
degree=[0 for i in range(n)]
graph=defaultdict(list)
for i in range(m):
a,b=x[i],y[i]
a-=1
b-=1
graph[a].append(b)
degree[b]+=1
q=deque()
for i in range(n):
if degree[i]==0:
q.append(i)
count=0
ans=0
# print(degree)
dp=[[0 for i in range(26)] for i in range(n)]
while count<n and q:
x=q.popleft()
count+=1
# print(ord(l[x])-97)
dp[x][ord(l[x])-97]+=1
for i in graph[x]:
for j in range(26):
dp[i][j]=max(dp[i][j],dp[x][j])
degree[i]-=1
if degree[i]==0:
q.append(i)
# print(degree)
if count!=n:
return -1
else:
ans=0
for i in range(n):
ans=max(ans,max(dp[i]))
return ans
n,m = map(int,input().split())
z = list(input())
x = [None]*m
y = [None]*m
for i in range(m):
x[i],y[i] = map(int,input().split())
print(beauty(n,m,z,x,y)) | {
"input": [
"10 14\nxzyzyzyzqx\n1 2\n2 4\n3 5\n4 5\n2 6\n6 8\n6 5\n2 10\n3 9\n10 9\n4 6\n1 10\n2 8\n3 7\n",
"5 4\nabaca\n1 2\n1 3\n3 4\n4 5\n",
"6 6\nxzyabc\n1 2\n3 1\n2 3\n5 4\n4 3\n6 4\n"
],
"output": [
"4",
"3",
"-1"
]
} |
2,985 | 9 | You are given a string s consisting of |s| small english letters.
In one move you can replace any character of this string to the next character in alphabetical order (a will be replaced with b, s will be replaced with t, etc.). You cannot replace letter z with any other letter.
Your target is to make some number of moves (not necessary minimal) to get string abcdefghijklmnopqrstuvwxyz (english alphabet) as a subsequence. Subsequence of the string is the string that is obtained by deleting characters at some positions. You need to print the string that will be obtained from the given string and will be contain english alphabet as a subsequence or say that it is impossible.
Input
The only one line of the input consisting of the string s consisting of |s| (1 β€ |s| β€ 105) small english letters.
Output
If you can get a string that can be obtained from the given string and will contain english alphabet as a subsequence, print it. Otherwise print Β«-1Β» (without quotes).
Examples
Input
aacceeggiikkmmooqqssuuwwyy
Output
abcdefghijklmnopqrstuvwxyz
Input
thereisnoanswer
Output
-1 | def evolution(s):
t, c = '', ord('a')
for elem in s:
if ord(elem) <= c <= ord('z'):
t += chr(c)
c += 1
else:
t += elem
if c <= ord('z'):
t = -1
return t
print(evolution(input()))
| {
"input": [
"aacceeggiikkmmooqqssuuwwyy\n",
"thereisnoanswer\n"
],
"output": [
"abcdefghijklmnopqrstuvwxyz\n",
"-1\n"
]
} |
2,986 | 7 | In Aramic language words can only represent objects.
Words in Aramic have special properties:
* A word is a root if it does not contain the same letter more than once.
* A root and all its permutations represent the same object.
* The root x of a word y is the word that contains all letters that appear in y in a way that each letter appears once. For example, the root of "aaaa", "aa", "aaa" is "a", the root of "aabb", "bab", "baabb", "ab" is "ab".
* Any word in Aramic represents the same object as its root.
You have an ancient script in Aramic. What is the number of different objects mentioned in the script?
Input
The first line contains one integer n (1 β€ n β€ 10^3) β the number of words in the script.
The second line contains n words s_1, s_2, β¦, s_n β the script itself. The length of each string does not exceed 10^3.
It is guaranteed that all characters of the strings are small latin letters.
Output
Output one integer β the number of different objects mentioned in the given ancient Aramic script.
Examples
Input
5
a aa aaa ab abb
Output
2
Input
3
amer arem mrea
Output
1
Note
In the first test, there are two objects mentioned. The roots that represent them are "a","ab".
In the second test, there is only one object, its root is "amer", the other strings are just permutations of "amer". | input()
def f(s):
return "".join(sorted(set(s)))
arr = set(map(f, input().split()))
print(len(arr)) | {
"input": [
"5\na aa aaa ab abb\n",
"3\namer arem mrea\n"
],
"output": [
"2\n",
"1\n"
]
} |
2,987 | 12 | You need to execute several tasks, each associated with number of processors it needs, and the compute power it will consume.
You have sufficient number of analog computers, each with enough processors for any task. Each computer can execute up to one task at a time, and no more than two tasks total. The first task can be any, the second task on each computer must use strictly less power than the first. You will assign between 1 and 2 tasks to each computer. You will then first execute the first task on each computer, wait for all of them to complete, and then execute the second task on each computer that has two tasks assigned.
If the average compute power per utilized processor (the sum of all consumed powers for all tasks presently running divided by the number of utilized processors) across all computers exceeds some unknown threshold during the execution of the first tasks, the entire system will blow up. There is no restriction on the second tasks execution. Find the lowest threshold for which it is possible.
Due to the specifics of the task, you need to print the answer multiplied by 1000 and rounded up.
Input
The first line contains a single integer n (1 β€ n β€ 50) β the number of tasks.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 108), where ai represents the amount of power required for the i-th task.
The third line contains n integers b1, b2, ..., bn (1 β€ bi β€ 100), where bi is the number of processors that i-th task will utilize.
Output
Print a single integer value β the lowest threshold for which it is possible to assign all tasks in such a way that the system will not blow up after the first round of computation, multiplied by 1000 and rounded up.
Examples
Input
6
8 10 9 9 8 10
1 1 1 1 1 1
Output
9000
Input
6
8 10 9 9 8 10
1 10 5 5 1 10
Output
1160
Note
In the first example the best strategy is to run each task on a separate computer, getting average compute per processor during the first round equal to 9.
In the second task it is best to run tasks with compute 10 and 9 on one computer, tasks with compute 10 and 8 on another, and tasks with compute 9 and 8 on the last, averaging (10 + 10 + 9) / (10 + 10 + 5) = 1.16 compute power per processor during the first round. | # Codeforces Round #488 by NEAR (Div. 2)
import collections
from functools import cmp_to_key
#key=cmp_to_key(lambda x,y: 1 if x not in y else -1 )
import math
import sys
def getIntList():
return list(map(int, input().split()))
import bisect
def makePair(z):
return [(z[i], z[i+1]) for i in range(0,len(z),2) ]
N, = getIntList()
za = getIntList()
zb = getIntList()
sa = set(za)
xa = list(sa)
xa.sort(reverse = True)
zz = [(t, sorted([zb[i] for i in range(N) if za[i] == t]) ) for t in xa ]
#print(zz)
lastdp = [[] for i in range(52)]
lastdp[0] = [(0,0)]
def addres(z, t):
if len(z) ==0:
z.append(t)
return
i = bisect.bisect_right(z,t)
if i>0 and z[i-1][1] >= t[1]: return
if i<len(z) and t[1] >= z[i][1]:
z[i] = t
return
z.insert(i,t)
for x in zz:
nowdp = [[] for i in range(52)]
for i in range(len(lastdp)):
tz = lastdp[i]
if len( tz ) ==0 : continue
num = len(x[1])
hide = min(i, num )
tb = sum(x[1])
acc =0;
for j in range(hide + 1):
la = x[0] * (num-j)
lb = tb - acc
if j<num: acc += x[1][j]
for t in tz:
# t = (0,0)
tr = (t[0] + la, t[1] + lb)
addres(nowdp[ i -j + num -j] ,tr)
lastdp = nowdp
#print(lastdp)
res = 10 ** 20
for x in lastdp:
for y in x:
t = math.ceil(y[0] *1000 / y[1] )
res = min( res,t)
print(res)
| {
"input": [
"6\n8 10 9 9 8 10\n1 10 5 5 1 10\n",
"6\n8 10 9 9 8 10\n1 1 1 1 1 1\n"
],
"output": [
"1160\n",
"9000\n"
]
} |
2,988 | 9 | You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = β_{1 β€ i β€ a}d_i, sum_2 = β_{a + 1 β€ i β€ a + b}d_i, sum_3 = β_{a + b + 1 β€ i β€ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 β€ n β€ 2 β
10^5) β the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 β€ d_i β€ 10^9) β the elements of the array d.
Output
Print a single integer β the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~]. |
def mp():return map(int,input().split())
def it():return int(input())
n=it()
l=list(mp())
s1=0
s3=0
ans=0
i=0
j=n-1
while i<=j:
if s1>s3:
s3+=l[j]
j-=1
else:
s1+=l[i]
i+=1
# print(s1,s3)
if s1==s3:
ans=s1
print(ans)
| {
"input": [
"3\n4 1 2\n",
"5\n1 3 1 1 4\n",
"5\n1 3 2 1 4\n"
],
"output": [
"0\n",
"5\n",
"4\n"
]
} |
2,989 | 8 | Having watched the last Harry Potter film, little Gerald also decided to practice magic. He found in his father's magical book a spell that turns any number in the sum of its digits. At the moment Gerald learned that, he came across a number n. How many times can Gerald put a spell on it until the number becomes one-digit?
Input
The first line contains the only integer n (0 β€ n β€ 10100000). It is guaranteed that n doesn't contain any leading zeroes.
Output
Print the number of times a number can be replaced by the sum of its digits until it only contains one digit.
Examples
Input
0
Output
0
Input
10
Output
1
Input
991
Output
3
Note
In the first sample the number already is one-digit β Herald can't cast a spell.
The second test contains number 10. After one casting of a spell it becomes 1, and here the process is completed. Thus, Gerald can only cast the spell once.
The third test contains number 991. As one casts a spell the following transformations take place: 991 β 19 β 10 β 1. After three transformations the number becomes one-digit. | n=int(input())
def sm(n):
return sum(int(i) for i in str(n))
cnt=0
while n>9:
n=sm(n)
cnt+=1
print(cnt) | {
"input": [
"0\n",
"10\n",
"991\n"
],
"output": [
"0\n",
"1\n",
"3\n"
]
} |
2,990 | 8 | You are given a set of all integers from l to r inclusive, l < r, (r - l + 1) β€ 3 β
10^5 and (r - l) is always odd.
You want to split these numbers into exactly (r - l + 1)/(2) pairs in such a way that for each pair (i, j) the greatest common divisor of i and j is equal to 1. Each number should appear in exactly one of the pairs.
Print the resulting pairs or output that no solution exists. If there are multiple solutions, print any of them.
Input
The only line contains two integers l and r (1 β€ l < r β€ 10^{18}, r - l + 1 β€ 3 β
10^5, (r - l) is odd).
Output
If any solution exists, print "YES" in the first line. Each of the next (r - l + 1)/(2) lines should contain some pair of integers. GCD of numbers in each pair should be equal to 1. All (r - l + 1) numbers should be pairwise distinct and should have values from l to r inclusive.
If there are multiple solutions, print any of them.
If there exists no solution, print "NO".
Example
Input
1 8
Output
YES
2 7
4 1
3 8
6 5 | def inp():
return map(int, input().split())
l,r=inp()
print('YES')
for i in range(l,r+1,2):
print(i,i+1) | {
"input": [
"1 8\n"
],
"output": [
"YES\n1 2\n3 4\n5 6\n7 8\n"
]
} |
2,991 | 9 | Vasya has got a robot which is situated on an infinite Cartesian plane, initially in the cell (0, 0). Robot can perform the following four kinds of operations:
* U β move from (x, y) to (x, y + 1);
* D β move from (x, y) to (x, y - 1);
* L β move from (x, y) to (x - 1, y);
* R β move from (x, y) to (x + 1, y).
Vasya also has got a sequence of n operations. Vasya wants to modify this sequence so after performing it the robot will end up in (x, y).
Vasya wants to change the sequence so the length of changed subsegment is minimum possible. This length can be calculated as follows: maxID - minID + 1, where maxID is the maximum index of a changed operation, and minID is the minimum index of a changed operation. For example, if Vasya changes RRRRRRR to RLRRLRL, then the operations with indices 2, 5 and 7 are changed, so the length of changed subsegment is 7 - 2 + 1 = 6. Another example: if Vasya changes DDDD to DDRD, then the length of changed subsegment is 1.
If there are no changes, then the length of changed subsegment is 0. Changing an operation means replacing it with some operation (possibly the same); Vasya can't insert new operations into the sequence or remove them.
Help Vasya! Tell him the minimum length of subsegment that he needs to change so that the robot will go from (0, 0) to (x, y), or tell him that it's impossible.
Input
The first line contains one integer number n~(1 β€ n β€ 2 β
10^5) β the number of operations.
The second line contains the sequence of operations β a string of n characters. Each character is either U, D, L or R.
The third line contains two integers x, y~(-10^9 β€ x, y β€ 10^9) β the coordinates of the cell where the robot should end its path.
Output
Print one integer β the minimum possible length of subsegment that can be changed so the resulting sequence of operations moves the robot from (0, 0) to (x, y). If this change is impossible, print -1.
Examples
Input
5
RURUU
-2 3
Output
3
Input
4
RULR
1 1
Output
0
Input
3
UUU
100 100
Output
-1
Note
In the first example the sequence can be changed to LULUU. So the length of the changed subsegment is 3 - 1 + 1 = 3.
In the second example the given sequence already leads the robot to (x, y), so the length of the changed subsegment is 0.
In the third example the robot can't end his path in the cell (x, y). | def is_check(x):
i=1
j=x
h,v=0,0
while j<=n:
h=((sum_x[n]-sum_x[j])+(sum_x[i-1]-sum_x[0]))
v=((sum_y[n]-sum_y[j])+(sum_y[i-1]-sum_y[0]))
i+=1
j+=1
if abs(x_f-h)+abs(y_f-v)<=x:
return 1
return 0
n=int(input())
st=input()
x_f,y_f=map(int,input().split())
sum_x=[0]
sum_y=[0]
add_x,add_y=0,0
for i in range(n):
if st[i]=="R":
add_x+=1
elif st[i]=="L":
add_x-=1
elif st[i]=="U":
add_y+=1
else:
add_y-=1
sum_x.append(add_x)
sum_y.append(add_y)
i=0
j=n
while i<j:
m=(i+j)//2
if is_check(m):
j=m-1
else:
i=m+1
if abs(x_f)+abs(y_f)>n or (abs(x_f)+abs(y_f)+n)%2==1:
print(-1)
elif is_check(i):
print(i)
else:
print(i+1) | {
"input": [
"5\nRURUU\n-2 3\n",
"4\nRULR\n1 1\n",
"3\nUUU\n100 100\n"
],
"output": [
"3\n",
"0\n",
"-1\n"
]
} |
2,992 | 9 | A positive integer x is called a power of two if it can be represented as x = 2^y, where y is a non-negative integer. So, the powers of two are 1, 2, 4, 8, 16, ....
You are given two positive integers n and k. Your task is to represent n as the sum of exactly k powers of two.
Input
The only line of the input contains two integers n and k (1 β€ n β€ 10^9, 1 β€ k β€ 2 β
10^5).
Output
If it is impossible to represent n as the sum of k powers of two, print NO.
Otherwise, print YES, and then print k positive integers b_1, b_2, ..., b_k such that each of b_i is a power of two, and β _{i = 1}^{k} b_i = n. If there are multiple answers, you may print any of them.
Examples
Input
9 4
Output
YES
1 2 2 4
Input
8 1
Output
YES
8
Input
5 1
Output
NO
Input
3 7
Output
NO | def solve():
n, k = [int(i) for i in input().split(' ')]
a = [1] * k
s = k
for i in range(k):
while (s + a[i] <= n):
s += a[i]
a[i] *= 2
if s != n:
return "NO"
o = "YES\n"
o += ' '.join(str(i) for i in a)
return o
print(solve())
| {
"input": [
"8 1\n",
"5 1\n",
"9 4\n",
"3 7\n"
],
"output": [
"YES\n8\n",
"NO\n",
"YES\n1 2 2 4\n",
"NO\n"
]
} |
2,993 | 10 | You are given a line of n colored squares in a row, numbered from 1 to n from left to right. The i-th square initially has the color c_i.
Let's say, that two squares i and j belong to the same connected component if c_i = c_j, and c_i = c_k for all k satisfying i < k < j. In other words, all squares on the segment from i to j should have the same color.
For example, the line [3, 3, 3] has 1 connected component, while the line [5, 2, 4, 4] has 3 connected components.
The game "flood fill" is played on the given line as follows:
* At the start of the game you pick any starting square (this is not counted as a turn).
* Then, in each game turn, change the color of the connected component containing the starting square to any other color.
Find the minimum number of turns needed for the entire line to be changed into a single color.
Input
The first line contains a single integer n (1 β€ n β€ 5000) β the number of squares.
The second line contains integers c_1, c_2, β¦, c_n (1 β€ c_i β€ 5000) β the initial colors of the squares.
Output
Print a single integer β the minimum number of the turns needed.
Examples
Input
4
5 2 2 1
Output
2
Input
8
4 5 2 2 1 3 5 5
Output
4
Input
1
4
Output
0
Note
In the first example, a possible way to achieve an optimal answer is to pick square with index 2 as the starting square and then play as follows:
* [5, 2, 2, 1]
* [5, 5, 5, 1]
* [1, 1, 1, 1]
In the second example, a possible way to achieve an optimal answer is to pick square with index 5 as the starting square and then perform recoloring into colors 2, 3, 5, 4 in that order.
In the third example, the line already consists of one color only. | def inpl(): return list(map(int, input().split()))
N = int(input())
A = inpl()
B = [0]
for a in A:
if B[-1] != a:
B.append(a)
B = B[1:]
k = len(B)
dp = [0]*((k*k + k)//2)
for d in range(1, k):
for i in range(k-d):
if B[i] == B[i+d]:
dp[d*(2*k-d+1)//2+i] = dp[(d-2)*(2*k-d+3)//2+i+1] + 1
else:
dp[d*(2*k-d+1)//2+i] = 1 + min(dp[(d-1)*(2*k-d+2)//2+i], dp[(d-1)*(2*k-d+2)//2+i+1])
print(dp[-1])
| {
"input": [
"1\n4\n",
"4\n5 2 2 1\n",
"8\n4 5 2 2 1 3 5 5\n"
],
"output": [
"0",
"2",
"4"
]
} |
2,994 | 7 | The three friends, Kuro, Shiro, and Katie, met up again! It's time for a party...
What the cats do when they unite? Right, they have a party. Since they wanted to have as much fun as possible, they invited all their friends. Now n cats are at the party, sitting in a circle and eating soup. The rules are simple: anyone having finished their soup leaves the circle.
Katie suddenly notices that whenever a cat leaves, the place where she was sitting becomes an empty space, which means the circle is divided into smaller continuous groups of cats sitting next to each other. At the moment Katie observes, there are m cats who left the circle. This raises a question for Katie: what is the maximum possible number of groups the circle is divided into at the moment?
Could you help her with this curiosity?
You can see the examples and their descriptions with pictures in the "Note" section.
Input
The only line contains two integers n and m (2 β€ n β€ 1000, 0 β€ m β€ n) β the initial number of cats at the party and the number of cats who left the circle at the moment Katie observes, respectively.
Output
Print a single integer β the maximum number of groups of cats at the moment Katie observes.
Examples
Input
7 4
Output
3
Input
6 2
Output
2
Input
3 0
Output
1
Input
2 2
Output
0
Note
In the first example, originally there are 7 cats sitting as shown below, creating a single group:
<image>
At the observed moment, 4 cats have left the table. Suppose the cats 2, 3, 5 and 7 have left, then there are 3 groups remaining. It is possible to show that it is the maximum possible number of groups remaining.
<image>
In the second example, there are 6 cats sitting as shown below:
<image>
At the observed moment, 2 cats have left the table. Suppose the cats numbered 3 and 6 left, then there will be 2 groups remaining (\{1, 2\} and \{4, 5\}). It is impossible to have more than 2 groups of cats remaining.
<image>
In the third example, no cats have left, so there is 1 group consisting of all cats.
In the fourth example, all cats have left the circle, so there are 0 groups. | def main():
n,m=map(int,input().split())
print(min(n-m,m) if(m!=0) else 1)
main() | {
"input": [
"2 2\n",
"3 0\n",
"6 2\n",
"7 4\n"
],
"output": [
"0\n",
"1\n",
"2\n",
"3\n"
]
} |
2,995 | 12 | One important contest will take place on the most famous programming platform (Topforces) very soon!
The authors have a pool of n problems and should choose at most three of them into this contest. The prettiness of the i-th problem is a_i. The authors have to compose the most pretty contest (in other words, the cumulative prettinesses of chosen problems should be maximum possible).
But there is one important thing in the contest preparation: because of some superstitions of authors, the prettinesses of problems cannot divide each other. In other words, if the prettinesses of chosen problems are x, y, z, then x should be divisible by neither y, nor z, y should be divisible by neither x, nor z and z should be divisible by neither x, nor y. If the prettinesses of chosen problems are x and y then neither x should be divisible by y nor y should be divisible by x. Any contest composed from one problem is considered good.
Your task is to find out the maximum possible total prettiness of the contest composed of at most three problems from the given pool.
You have to answer q independent queries.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 β€ q β€ 2 β
10^5) β the number of queries.
The first line of the query contains one integer n (1 β€ n β€ 2 β
10^5) β the number of problems.
The second line of the query contains n integers a_1, a_2, ..., a_n (2 β€ a_i β€ 2 β
10^5), where a_i is the prettiness of the i-th problem.
It is guaranteed that the sum of n over all queries does not exceed 2 β
10^5.
Output
For each query print one integer β the maximum possible cumulative prettiness of the contest composed of at most three problems from the given pool of problems in the query.
Example
Input
3
4
5 6 15 30
4
10 6 30 15
3
3 4 6
Output
30
31
10 | def calc(X, Y):
if len(Y) == 3: return sum(Y)
for x in X:
for y in Y:
if y % x == 0: break
else:
return calc([i for i in X if i != x], sorted(Y+[x])[::-1])
return sum(Y)
for _ in range(int(input())):
N = int(input())
A = sorted(set([int(a) for a in input().split()]))[::-1]
print(max(calc(A, []), calc(A[1:], [])))
| {
"input": [
"3\n4\n5 6 15 30\n4\n10 6 30 15\n3\n3 4 6\n"
],
"output": [
"30\n31\n10\n"
]
} |
2,996 | 7 | A class of students wrote a multiple-choice test.
There are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.
The students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class.
Input
The first line contains integers n and m (1 β€ n, m β€ 1000) β the number of students in the class and the number of questions in the test.
Each of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.
The last line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ 1000) β the number of points for the correct answer for every question.
Output
Print a single integer β the maximum possible total score of the class.
Examples
Input
2 4
ABCD
ABCE
1 2 3 4
Output
16
Input
3 3
ABC
BCD
CDE
5 4 12
Output
21
Note
In the first example, one of the most optimal test answers is "ABCD", this way the total number of points will be 16.
In the second example, one of the most optimal test answers is "CCC", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21. | def mp():
return map(int, input().split())
n, m = mp()
s = [input() for i in range(n)]
a = list(mp())
ans = 0
for j in range(m):
cnt = [0] * 5
for i in range(n):
cnt[ord(s[i][j]) - 65] += 1
ans += a[j] * max(cnt)
#print(j + 1, cnt, ans)
print(ans) | {
"input": [
"3 3\nABC\nBCD\nCDE\n5 4 12\n",
"2 4\nABCD\nABCE\n1 2 3 4\n"
],
"output": [
"21",
"16"
]
} |
2,997 | 7 | Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i Γ 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 Γ 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 Γ 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 β€ k β€ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 β€ n β€ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, β¦, a_n (1 β€ a_i β€ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 Γ 4 square.
In the third sample, the maximum possible square is 1 Γ 1 and can be taken simply as any of the planks. | t=int(input())
def f(n,a):
a.sort()
while a[0]<n:
del a[0]
n-=1
print(len(a))
for i in range(t):
n=int(input())
a=[int(i) for i in input().split()]
f(n,a)
| {
"input": [
"4\n5\n4 3 1 4 5\n4\n4 4 4 4\n3\n1 1 1\n5\n5 5 1 1 5\n"
],
"output": [
"3\n4\n1\n3\n"
]
} |
2,998 | 11 | You are given an integer array a_1, a_2, ..., a_n, where a_i represents the number of blocks at the i-th position. It is guaranteed that 1 β€ a_i β€ n.
In one operation you can choose a subset of indices of the given array and remove one block in each of these indices. You can't remove a block from a position without blocks.
All subsets that you choose should be different (unique).
You need to remove all blocks in the array using at most n+1 operations. It can be proved that the answer always exists.
Input
The first line contains a single integer n (1 β€ n β€ 10^3) β length of the given array.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ n) β numbers of blocks at positions 1, 2, ..., n.
Output
In the first line print an integer op (0 β€ op β€ n+1).
In each of the following op lines, print a binary string s of length n. If s_i='0', it means that the position i is not in the chosen subset. Otherwise, s_i should be equal to '1' and the position i is in the chosen subset.
All binary strings should be distinct (unique) and a_i should be equal to the sum of s_i among all chosen binary strings.
If there are multiple possible answers, you can print any.
It can be proved that an answer always exists.
Examples
Input
5
5 5 5 5 5
Output
6
11111
01111
10111
11011
11101
11110
Input
5
5 1 1 1 1
Output
5
11000
10000
10100
10010
10001
Input
5
4 1 5 3 4
Output
5
11111
10111
10101
00111
10100
Note
In the first example, the number of blocks decrease like that:
{ 5,5,5,5,5 } β { 4,4,4,4,4 } β { 4,3,3,3,3 } β { 3,3,2,2,2 } β { 2,2,2,1,1 } β { 1,1,1,1,0 } β { 0,0,0,0,0 }. And we can note that each operation differs from others. | n = int(input())
v, c = list([[0, 0]]), list()
z = ['0' for i in range(n)]
for i, x in enumerate(input().split()) : v.append([int(x), i])
v.sort(reverse=True)
def S_N_U_F_F(z, v, c) :
y, k, x, count = -1, 0, len(v)-1, len(v)-1
while v[0][0] != 0 :
if (k > 0 and k < len(v)-1) or (v[y+k][0] <= 1 and v[y+k+1][0] != 0) : z[v[y+k][1]] = '0'
else : v[y+k][0], z[v[y+k][1]], x = v[y+k][0]-1, '1', i
for i in range(0, y+k) : v[i][0], z[v[i][1]] = v[i][0]-1, '1'
for i in range(y+k+1, len(v)-1) :
if v[i][0] > 1 or (v[i][0] != 0 and v[i+1][0] == 0) : v[i][0], z[v[i][1]], x = v[i][0]-1, '1', i
else : z[v[i][1]] = '0'
while v[y+1][0] == count and count != 0 : y, k = y+1, k-1
if v[x-1][0] == 1 or v[x][0] == 0 : k = -1
count, k = count-1, k+1
c.append(''.join(z))
return len(c)
print(S_N_U_F_F(z, v, c))
print('\n'.join(c))
| {
"input": [
"5\n4 1 5 3 4\n",
"5\n5 1 1 1 1\n",
"5\n5 5 5 5 5\n"
],
"output": [
"6\n00100\n10100\n10101\n10111\n11111\n00011\n",
"6\n10000\n11000\n10100\n10010\n10001\n00000\n",
"6\n10111\n11011\n11101\n11110\n11111\n01111\n"
]
} |
2,999 | 8 | A sequence a = [a_1, a_2, β¦, a_l] of length l has an ascent if there exists a pair of indices (i, j) such that 1 β€ i < j β€ l and a_i < a_j. For example, the sequence [0, 2, 0, 2, 0] has an ascent because of the pair (1, 4), but the sequence [4, 3, 3, 3, 1] doesn't have an ascent.
Let's call a concatenation of sequences p and q the sequence that is obtained by writing down sequences p and q one right after another without changing the order. For example, the concatenation of the [0, 2, 0, 2, 0] and [4, 3, 3, 3, 1] is the sequence [0, 2, 0, 2, 0, 4, 3, 3, 3, 1]. The concatenation of sequences p and q is denoted as p+q.
Gyeonggeun thinks that sequences with ascents bring luck. Therefore, he wants to make many such sequences for the new year. Gyeonggeun has n sequences s_1, s_2, β¦, s_n which may have different lengths.
Gyeonggeun will consider all n^2 pairs of sequences s_x and s_y (1 β€ x, y β€ n), and will check if its concatenation s_x + s_y has an ascent. Note that he may select the same sequence twice, and the order of selection matters.
Please count the number of pairs (x, y) of sequences s_1, s_2, β¦, s_n whose concatenation s_x + s_y contains an ascent.
Input
The first line contains the number n (1 β€ n β€ 100 000) denoting the number of sequences.
The next n lines contain the number l_i (1 β€ l_i) denoting the length of s_i, followed by l_i integers s_{i, 1}, s_{i, 2}, β¦, s_{i, l_i} (0 β€ s_{i, j} β€ 10^6) denoting the sequence s_i.
It is guaranteed that the sum of all l_i does not exceed 100 000.
Output
Print a single integer, the number of pairs of sequences whose concatenation has an ascent.
Examples
Input
5
1 1
1 1
1 2
1 4
1 3
Output
9
Input
3
4 2 0 2 0
6 9 9 8 8 7 7
1 6
Output
7
Input
10
3 62 24 39
1 17
1 99
1 60
1 64
1 30
2 79 29
2 20 73
2 85 37
1 100
Output
72
Note
For the first example, the following 9 arrays have an ascent: [1, 2], [1, 2], [1, 3], [1, 3], [1, 4], [1, 4], [2, 3], [2, 4], [3, 4]. Arrays with the same contents are counted as their occurences. | from sys import stdin,stderr
def rl():
return [int(w) for w in stdin.readline().split()]
n, = rl()
xs = []
R = 0
for _ in range(n):
l, *s = rl()
ss = sorted(s, reverse=True)
if s == ss:
xs.append((s[-1], 0))
xs.append((s[0]-1, 1))
else:
R += n
xs.sort()
r = n
for x,t in xs:
if t == 1:
r -= 1
else:
R += r
print(R)
| {
"input": [
"5\n1 1\n1 1\n1 2\n1 4\n1 3\n",
"3\n4 2 0 2 0\n6 9 9 8 8 7 7\n1 6\n",
"10\n3 62 24 39\n1 17\n1 99\n1 60\n1 64\n1 30\n2 79 29\n2 20 73\n2 85 37\n1 100\n"
],
"output": [
"9\n",
"7\n",
"72\n"
]
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.