index
int64 0
5.16k
| difficulty
int64 7
12
| question
stringlengths 126
7.12k
| solution
stringlengths 30
18.6k
| test_cases
dict |
|---|---|---|---|---|
4,900 | 8 | Phoenix is playing with a new puzzle, which consists of n identical puzzle pieces. Each puzzle piece is a right isosceles triangle as shown below.
<image> A puzzle piece
The goal of the puzzle is to create a square using the n pieces. He is allowed to rotate and move the pieces around, but none of them can overlap and all n pieces must be used (of course, the square shouldn't contain any holes as well). Can he do it?
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 10^4) β the number of test cases.
The first line of each test case contains an integer n (1 β€ n β€ 10^9) β the number of puzzle pieces.
Output
For each test case, if Phoenix can create a square with the n puzzle pieces, print YES. Otherwise, print NO.
Example
Input
3
2
4
6
Output
YES
YES
NO
Note
For n=2, Phoenix can create a square like this:
<image>
For n=4, Phoenix can create a square like this:
<image>
For n=6, it is impossible for Phoenix to create a square. | def main():
for t in range(int(input())):
n = int(input())
if (n/2)%(n/2)**0.5 == 0 or (n/4)%(n/4)**0.5 == 0:
print("YES")
else:
print("NO")
main() | {
"input": [
"3\n2\n4\n6\n"
],
"output": [
"\nYES\nYES\nNO\n"
]
} |
4,901 | 7 | You are given a multiset (i. e. a set that can contain multiple equal integers) containing 2n integers. Determine if you can split it into exactly n pairs (i. e. each element should be in exactly one pair) so that the sum of the two elements in each pair is odd (i. e. when divided by 2, the remainder is 1).
Input
The input consists of multiple test cases. The first line contains an integer t (1β€ tβ€ 100) β the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1β€ nβ€ 100).
The second line of each test case contains 2n integers a_1,a_2,..., a_{2n} (0β€ a_iβ€ 100) β the numbers in the set.
Output
For each test case, print "Yes" if it can be split into exactly n pairs so that the sum of the two elements in each pair is odd, and "No" otherwise. You can print each letter in any case.
Example
Input
5
2
2 3 4 5
3
2 3 4 5 5 5
1
2 4
1
2 3
4
1 5 3 2 6 7 3 4
Output
Yes
No
No
Yes
No
Note
In the first test case, a possible way of splitting the set is (2,3), (4,5).
In the second, third and fifth test case, we can prove that there isn't any possible way.
In the fourth test case, a possible way of splitting the set is (2,3). | def solve(A):
odd = sum([1 for it in A if it%2])
return "Yes" if 2*odd == len(A) else "No"
for case in range(int(input())):n = int(input());print(solve(list(map(int, input().split())))) | {
"input": [
"5\n2\n2 3 4 5\n3\n2 3 4 5 5 5\n1\n2 4\n1\n2 3\n4\n1 5 3 2 6 7 3 4\n"
],
"output": [
"Yes\nNo\nNo\nYes\nNo\n"
]
} |
4,902 | 7 | According to a new ISO standard, a flag of every country should have a chequered field n Γ m, each square should be of one of 10 colours, and the flag should be Β«stripedΒ»: each horizontal row of the flag should contain squares of the same colour, and the colours of adjacent horizontal rows should be different. Berland's government asked you to find out whether their flag meets the new ISO standard.
Input
The first line of the input contains numbers n and m (1 β€ n, m β€ 100), n β the amount of rows, m β the amount of columns on the flag of Berland. Then there follows the description of the flag: each of the following n lines contain m characters. Each character is a digit between 0 and 9, and stands for the colour of the corresponding square.
Output
Output YES, if the flag meets the new ISO standard, and NO otherwise.
Examples
Input
3 3
000
111
222
Output
YES
Input
3 3
000
000
111
Output
NO
Input
3 3
000
111
002
Output
NO | def inp():
return map(int, input().split())
n, m = inp()
tem = ''
for i in range(n):
s = input()
if (s.count(s[0]) != m or s==tem):
exit(print('NO'))
tem = s
print('YES')
| {
"input": [
"3 3\n000\n111\n222\n",
"3 3\n000\n000\n111\n",
"3 3\n000\n111\n002\n"
],
"output": [
"YES\n",
"NO\n",
"NO\n"
]
} |
4,903 | 10 | Last year Bob earned by selling memory sticks. During each of n days of his work one of the two following events took place:
* A customer came to Bob and asked to sell him a 2x MB memory stick. If Bob had such a stick, he sold it and got 2x berllars.
* Bob won some programming competition and got a 2x MB memory stick as a prize. Bob could choose whether to present this memory stick to one of his friends, or keep it.
Bob never kept more than one memory stick, as he feared to mix up their capacities, and deceive a customer unintentionally. It is also known that for each memory stick capacity there was at most one customer, who wanted to buy that memory stick. Now, knowing all the customers' demands and all the prizes won at programming competitions during the last n days, Bob wants to know, how much money he could have earned, if he had acted optimally.
Input
The first input line contains number n (1 β€ n β€ 5000) β amount of Bob's working days. The following n lines contain the description of the days. Line sell x stands for a day when a customer came to Bob to buy a 2x MB memory stick (0 β€ x β€ 2000). It's guaranteed that for each x there is not more than one line sell x. Line win x stands for a day when Bob won a 2x MB memory stick (0 β€ x β€ 2000).
Output
Output the maximum possible earnings for Bob in berllars, that he would have had if he had known all the events beforehand. Don't forget, please, that Bob can't keep more than one memory stick at a time.
Examples
Input
7
win 10
win 5
win 3
sell 5
sell 3
win 10
sell 10
Output
1056
Input
3
win 5
sell 6
sell 4
Output
0 | import math
def solve():
n = int(input())
ans = 0
idx = [0]*2005
dp = [0]*5005
for i in range(1,n+1):
opt, x = input().split()
x = int(x)
dp[i] = dp[i-1]
if opt == "win":
idx[x] = i
else :
if idx[x] != 0:
dp[i] = max(dp[i], dp[idx[x]-1] + 2**x)
print(dp[n])
if __name__ == '__main__':
solve()
| {
"input": [
"7\nwin 10\nwin 5\nwin 3\nsell 5\nsell 3\nwin 10\nsell 10\n",
"3\nwin 5\nsell 6\nsell 4\n"
],
"output": [
"1056",
"0"
]
} |
4,904 | 10 | You've got a undirected tree s, consisting of n nodes. Your task is to build an optimal T-decomposition for it. Let's define a T-decomposition as follows.
Let's denote the set of all nodes s as v. Let's consider an undirected tree t, whose nodes are some non-empty subsets of v, we'll call them xi <image>. The tree t is a T-decomposition of s, if the following conditions holds:
1. the union of all xi equals v;
2. for any edge (a, b) of tree s exists the tree node t, containing both a and b;
3. if the nodes of the tree t xi and xj contain the node a of the tree s, then all nodes of the tree t, lying on the path from xi to xj also contain node a. So this condition is equivalent to the following: all nodes of the tree t, that contain node a of the tree s, form a connected subtree of tree t.
There are obviously many distinct trees t, that are T-decompositions of the tree s. For example, a T-decomposition is a tree that consists of a single node, equal to set v.
Let's define the cardinality of node xi as the number of nodes in tree s, containing in the node. Let's choose the node with the maximum cardinality in t. Let's assume that its cardinality equals w. Then the weight of T-decomposition t is value w. The optimal T-decomposition is the one with the minimum weight.
Your task is to find the optimal T-decomposition of the given tree s that has the minimum number of nodes.
Input
The first line contains a single integer n (2 β€ n β€ 105), that denotes the number of nodes in tree s.
Each of the following n - 1 lines contains two space-separated integers ai, bi (1 β€ ai, bi β€ n; ai β bi), denoting that the nodes of tree s with indices ai and bi are connected by an edge.
Consider the nodes of tree s indexed from 1 to n. It is guaranteed that s is a tree.
Output
In the first line print a single integer m that denotes the number of nodes in the required T-decomposition.
Then print m lines, containing descriptions of the T-decomposition nodes. In the i-th (1 β€ i β€ m) of them print the description of node xi of the T-decomposition. The description of each node xi should start from an integer ki, that represents the number of nodes of the initial tree s, that are contained in the node xi. Then you should print ki distinct space-separated integers β the numbers of nodes from s, contained in xi, in arbitrary order.
Then print m - 1 lines, each consisting two integers pi, qi (1 β€ pi, qi β€ m; pi β qi). The pair of integers pi, qi means there is an edge between nodes xpi and xqi of T-decomposition.
The printed T-decomposition should be the optimal T-decomposition for the given tree s and have the minimum possible number of nodes among all optimal T-decompositions. If there are multiple optimal T-decompositions with the minimum number of nodes, print any of them.
Examples
Input
2
1 2
Output
1
2 1 2
Input
3
1 2
2 3
Output
2
2 1 2
2 2 3
1 2
Input
4
2 1
3 1
4 1
Output
3
2 2 1
2 3 1
2 4 1
1 2
2 3 | import sys
input = sys.stdin.readline
N = 10**5 + 5
g = [[] for _ in range(N)]
p = [0]*N
def bfs(cur):
q = [cur]
i = 0
while i < len(q):
cur = q[i]
i += 1
for nxt in g[cur]:
if(nxt != p[cur]):
p[nxt] = cur
q.append(nxt)
n = int(input())
for i in range(n-1):
a, b = map(int, input().split())
g[a].append(b)
g[b].append(a)
bfs(1)
print(n-1)
for i in range(2, n+1):
print(2, i, p[i])
for i in range(len(g[1])-1):
print(g[1][i]-1, g[1][i+1]-1)
for i in range(2, n+1):
for c in g[i]:
if c != p[i]:
print(i-1, c-1)
| {
"input": [
"4\n2 1\n3 1\n4 1\n",
"2\n1 2\n",
"3\n1 2\n2 3\n"
],
"output": [
"3\n2 2 1\n2 3 1\n2 4 1\n1 2\n2 3\n",
"1\n2 1 2\n",
"2\n2 1 2\n2 2 3\n1 2\n"
]
} |
4,905 | 8 | Roma works in a company that sells TVs. Now he has to prepare a report for the last year.
Roma has got a list of the company's incomes. The list is a sequence that consists of n integers. The total income of the company is the sum of all integers in sequence. Roma decided to perform exactly k changes of signs of several numbers in the sequence. He can also change the sign of a number one, two or more times.
The operation of changing a number's sign is the operation of multiplying this number by -1.
Help Roma perform the changes so as to make the total income of the company (the sum of numbers in the resulting sequence) maximum. Note that Roma should perform exactly k changes.
Input
The first line contains two integers n and k (1 β€ n, k β€ 105), showing, how many numbers are in the sequence and how many swaps are to be made.
The second line contains a non-decreasing sequence, consisting of n integers ai (|ai| β€ 104).
The numbers in the lines are separated by single spaces. Please note that the given sequence is sorted in non-decreasing order.
Output
In the single line print the answer to the problem β the maximum total income that we can obtain after exactly k changes.
Examples
Input
3 2
-1 -1 1
Output
3
Input
3 1
-1 -1 1
Output
1
Note
In the first sample we can get sequence [1, 1, 1], thus the total income equals 3.
In the second test, the optimal strategy is to get sequence [-1, 1, 1], thus the total income equals 1. | def inp():
return map(int, input().split())
def arr_inp():
return [int(x) for x in input().split()]
n, k = inp()
a = arr_inp()
for i in range(n):
if k == 0 or a[i] > 0:
break
a[i] *= -1
k-=1
if k%2:
a[a.index(min(a))]*=-1
print(sum(a))
| {
"input": [
"3 2\n-1 -1 1\n",
"3 1\n-1 -1 1\n"
],
"output": [
"3\n",
"1\n"
]
} |
4,906 | 9 | Inna and Dima decided to surprise Sereja. They brought a really huge candy matrix, it's big even for Sereja! Let's number the rows of the giant matrix from 1 to n from top to bottom and the columns β from 1 to m, from left to right. We'll represent the cell on the intersection of the i-th row and j-th column as (i, j). Just as is expected, some cells of the giant candy matrix contain candies. Overall the matrix has p candies: the k-th candy is at cell (xk, yk).
The time moved closer to dinner and Inna was already going to eat p of her favourite sweets from the matrix, when suddenly Sereja (for the reason he didn't share with anyone) rotated the matrix x times clockwise by 90 degrees. Then he performed the horizontal rotate of the matrix y times. And then he rotated the matrix z times counterclockwise by 90 degrees. The figure below shows how the rotates of the matrix looks like.
<image>
Inna got really upset, but Duma suddenly understood two things: the candies didn't get damaged and he remembered which cells contained Inna's favourite sweets before Sereja's strange actions. Help guys to find the new coordinates in the candy matrix after the transformation Sereja made!
Input
The first line of the input contains fix integers n, m, x, y, z, p (1 β€ n, m β€ 109; 0 β€ x, y, z β€ 109; 1 β€ p β€ 105).
Each of the following p lines contains two integers xk, yk (1 β€ xk β€ n; 1 β€ yk β€ m) β the initial coordinates of the k-th candy. Two candies can lie on the same cell.
Output
For each of the p candies, print on a single line its space-separated new coordinates.
Examples
Input
3 3 3 1 1 9
1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3
Output
1 3
1 2
1 1
2 3
2 2
2 1
3 3
3 2
3 1
Note
Just for clarity. Horizontal rotating is like a mirroring of the matrix. For matrix:
QWER REWQ
ASDF -> FDSA
ZXCV VCXZ
| h, w, x, y, z, p = map(int, input().split())
x %= 4
y %= 2
z %= 4
def rot(a, b):
global h
global w
res = b, h - a + 1
w, h = h, w
return res
def flip(a, b):
return a, w - b + 1
for i in range(p):
a, b = map(int, input().split())
sh, sw = h, w
for i in range(x):
a, b = rot(a, b)
for i in range(y):
a, b = flip(a, b)
for i in range(3 * z):
a, b = rot(a, b)
print(a, b)
h, w = sh, sw | {
"input": [
"3 3 3 1 1 9\n1 1\n1 2\n1 3\n2 1\n2 2\n2 3\n3 1\n3 2\n3 3\n"
],
"output": [
"1 3\n1 2\n1 1\n2 3\n2 2\n2 1\n3 3\n3 2\n3 1\n"
]
} |
4,907 | 8 | Jzzhu has invented a kind of sequences, they meet the following property:
<image>
You are given x and y, please calculate fn modulo 1000000007 (109 + 7).
Input
The first line contains two integers x and y (|x|, |y| β€ 109). The second line contains a single integer n (1 β€ n β€ 2Β·109).
Output
Output a single integer representing fn modulo 1000000007 (109 + 7).
Examples
Input
2 3
3
Output
1
Input
0 -1
2
Output
1000000006
Note
In the first sample, f2 = f1 + f3, 3 = 2 + f3, f3 = 1.
In the second sample, f2 = - 1; - 1 modulo (109 + 7) equals (109 + 6). | x, y = map(int, input().split(' '))
n = int(input())
l = [x, y, y - x, -x, -y, x - y]
def f(n):
a = l[n % 6 - 1]
return(a % (10 ** 9 + 7))
print(f(n)) | {
"input": [
"0 -1\n2\n",
"2 3\n3\n"
],
"output": [
"1000000006\n",
"1\n"
]
} |
4,908 | 9 | A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull.
Let's try to make a new task. Firstly we will use the following task. There are n people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are n people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation p?
More formally, if we denote the handle of the i-th person as hi, then the following condition must hold: <image>.
Input
The first line contains an integer n (1 β€ n β€ 105) β the number of people.
The next n lines each contains two strings. The i-th line contains strings fi and si (1 β€ |fi|, |si| β€ 50) β the first name and last name of the i-th person. Each string consists only of lowercase English letters. All of the given 2n strings will be distinct.
The next line contains n distinct integers: p1, p2, ..., pn (1 β€ pi β€ n).
Output
If it is possible, output "YES", otherwise output "NO".
Examples
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
1 2 3
Output
NO
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
3 1 2
Output
YES
Input
2
galileo galilei
nicolaus copernicus
2 1
Output
YES
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
1 2 3 4 5 6 7 8 9 10
Output
NO
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
2 4 9 6 5 7 1 3 8 10
Output
YES
Note
In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last.
In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright. | def main():
n = int(input())
names = tuple(input() for _ in range(n))
a = ''
for i in map(int, input().split()):
l = names[i - 1].split()
l.append(a)
l.sort()
if l[2] == a:
print('NO')
return
a = l[(l[1] == a) + 1]
print('YES')
main() | {
"input": [
"3\ngennady korotkevich\npetr mitrichev\ngaoyuan chen\n3 1 2\n",
"2\ngalileo galilei\nnicolaus copernicus\n2 1\n",
"10\nrean schwarzer\nfei claussell\nalisa reinford\neliot craig\nlaura arseid\njusis albarea\nmachias regnitz\nsara valestin\nemma millstein\ngaius worzel\n2 4 9 6 5 7 1 3 8 10\n",
"3\ngennady korotkevich\npetr mitrichev\ngaoyuan chen\n1 2 3\n",
"10\nrean schwarzer\nfei claussell\nalisa reinford\neliot craig\nlaura arseid\njusis albarea\nmachias regnitz\nsara valestin\nemma millstein\ngaius worzel\n1 2 3 4 5 6 7 8 9 10\n"
],
"output": [
"YES\n",
"YES\n",
"YES\n",
"NO\n",
"NO\n"
]
} |
4,909 | 10 | Petya and Gena love playing table tennis. A single match is played according to the following rules: a match consists of multiple sets, each set consists of multiple serves. Each serve is won by one of the players, this player scores one point. As soon as one of the players scores t points, he wins the set; then the next set starts and scores of both players are being set to 0. As soon as one of the players wins the total of s sets, he wins the match and the match is over. Here s and t are some positive integer numbers.
To spice it up, Petya and Gena choose new numbers s and t before every match. Besides, for the sake of history they keep a record of each match: that is, for each serve they write down the winner. Serve winners are recorded in the chronological order. In a record the set is over as soon as one of the players scores t points and the match is over as soon as one of the players wins s sets.
Petya and Gena have found a record of an old match. Unfortunately, the sequence of serves in the record isn't divided into sets and numbers s and t for the given match are also lost. The players now wonder what values of s and t might be. Can you determine all the possible options?
Input
The first line contains a single integer n β the length of the sequence of games (1 β€ n β€ 105).
The second line contains n space-separated integers ai. If ai = 1, then the i-th serve was won by Petya, if ai = 2, then the i-th serve was won by Gena.
It is not guaranteed that at least one option for numbers s and t corresponds to the given record.
Output
In the first line print a single number k β the number of options for numbers s and t.
In each of the following k lines print two integers si and ti β the option for numbers s and t. Print the options in the order of increasing si, and for equal si β in the order of increasing ti.
Examples
Input
5
1 2 1 2 1
Output
2
1 3
3 1
Input
4
1 1 1 1
Output
3
1 4
2 2
4 1
Input
4
1 2 1 2
Output
0
Input
8
2 1 2 1 1 1 1 1
Output
3
1 6
2 3
6 1 | from itertools import chain
def main(n,a, info=False):
winner = a[-1]
looser = 3-winner
csw, csl, pw, pl, ans = [0], [0], [-1], [-1], []
nw,nl = a.count(winner), a.count(looser)
for i in range(n):
if a[i]==winner: pw.append(i)
else: pl.append(i)
csw.append(csw[-1] + int(a[i]==winner))
csl.append(csl[-1] + int(a[i]==looser))
pw += [n*10]*n
pl += [n*10]*n
csw += [0]*n
csl += [0]*n
if info:
print("a: ",a)
print("csw: ",csw)
print("csl: ",csl)
print("pw: ",pw)
print("pl: ",pl)
for t in chain(range(1,nw//2+1),[nw]):
s = l = i = 0
sw = sl = 0
while i < n:
xw = pw[csw[i]+t]
xl = pl[csl[i]+t]
if xw < xl: s += 1
else: l += 1
i = min(xw,xl)+1
if info:
print(s,t,": ",t,i,s,l,xw,xl)
if s>l and i<=n and csw[i]==nw:
ans.append((s,t))
print(len(ans))
for x,y in sorted(ans):
print(x,y)
def main_input():
n = int(input())
a = [int(i) for i in input().split()]
main(n,a)
if __name__ == "__main__":
main_input()
| {
"input": [
"8\n2 1 2 1 1 1 1 1\n",
"4\n1 1 1 1\n",
"5\n1 2 1 2 1\n",
"4\n1 2 1 2\n"
],
"output": [
"3\n1 6\n2 3\n6 1\n",
"3\n1 4\n2 2\n4 1\n",
"2\n1 3\n3 1\n",
"0\n"
]
} |
4,910 | 7 | A word or a sentence in some language is called a pangram if all the characters of the alphabet of this language appear in it at least once. Pangrams are often used to demonstrate fonts in printing or test the output devices.
You are given a string consisting of lowercase and uppercase Latin letters. Check whether this string is a pangram. We say that the string contains a letter of the Latin alphabet if this letter occurs in the string in uppercase or lowercase.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of characters in the string.
The second line contains the string. The string consists only of uppercase and lowercase Latin letters.
Output
Output "YES", if the string is a pangram and "NO" otherwise.
Examples
Input
12
toosmallword
Output
NO
Input
35
TheQuickBrownFoxJumpsOverTheLazyDog
Output
YES | def main():
input()
print('YES') if len(set(input().lower())) == 26 else print('NO')
main() | {
"input": [
"12\ntoosmallword\n",
"35\nTheQuickBrownFoxJumpsOverTheLazyDog\n"
],
"output": [
"NO\n",
"YES\n"
]
} |
4,911 | 9 | In the official contest this problem has a different statement, for which jury's solution was working incorrectly, and for this reason it was excluded from the contest. This mistake have been fixed and the current given problem statement and model solution corresponds to what jury wanted it to be during the contest.
Vova and Lesha are friends. They often meet at Vova's place and compete against each other in a computer game named The Ancient Papyri: Swordsink. Vova always chooses a warrior as his fighter and Leshac chooses an archer. After that they should choose initial positions for their characters and start the fight. A warrior is good at melee combat, so Vova will try to make the distance between fighters as small as possible. An archer prefers to keep the enemy at a distance, so Lesha will try to make the initial distance as large as possible.
There are n (n is always even) possible starting positions for characters marked along the Ox axis. The positions are given by their distinct coordinates x1, x2, ..., xn, two characters cannot end up at the same position.
Vova and Lesha take turns banning available positions, Vova moves first. During each turn one of the guys bans exactly one of the remaining positions. Banned positions cannot be used by both Vova and Lesha. They continue to make moves until there are only two possible positions remaining (thus, the total number of moves will be n - 2). After that Vova's character takes the position with the lesser coordinate and Lesha's character takes the position with the bigger coordinate and the guys start fighting.
Vova and Lesha are already tired by the game of choosing positions, as they need to play it before every fight, so they asked you (the developer of the The Ancient Papyri: Swordsink) to write a module that would automatically determine the distance at which the warrior and the archer will start fighting if both Vova and Lesha play optimally.
Input
The first line on the input contains a single integer n (2 β€ n β€ 200 000, n is even) β the number of positions available initially. The second line contains n distinct integers x1, x2, ..., xn (0 β€ xi β€ 109), giving the coordinates of the corresponding positions.
Output
Print the distance between the warrior and the archer at the beginning of the fight, provided that both Vova and Lesha play optimally.
Examples
Input
6
0 1 3 7 15 31
Output
7
Input
2
73 37
Output
36
Note
In the first sample one of the optimum behavior of the players looks like that:
1. Vova bans the position at coordinate 15;
2. Lesha bans the position at coordinate 3;
3. Vova bans the position at coordinate 31;
4. Lesha bans the position at coordinate 1.
After these actions only positions 0 and 7 will remain, and the distance between them is equal to 7.
In the second sample there are only two possible positions, so there will be no bans. | def main():
n = int(input())
l = sorted(map(int, input().split()))
print(min(b - a for a, b in zip(l, l[n // 2:])))
if __name__ == '__main__':
main()
| {
"input": [
"2\n73 37\n",
"6\n0 1 3 7 15 31\n"
],
"output": [
"36",
"7"
]
} |
4,912 | 7 | After celebrating the midcourse the students of one of the faculties of the Berland State University decided to conduct a vote for the best photo. They published the photos in the social network and agreed on the rules to choose a winner: the photo which gets most likes wins. If multiple photoes get most likes, the winner is the photo that gets this number first.
Help guys determine the winner photo by the records of likes.
Input
The first line of the input contains a single integer n (1 β€ n β€ 1000) β the total likes to the published photoes.
The second line contains n positive integers a1, a2, ..., an (1 β€ ai β€ 1 000 000), where ai is the identifier of the photo which got the i-th like.
Output
Print the identifier of the photo which won the elections.
Examples
Input
5
1 3 2 2 1
Output
2
Input
9
100 200 300 200 100 300 300 100 200
Output
300
Note
In the first test sample the photo with id 1 got two likes (first and fifth), photo with id 2 got two likes (third and fourth), and photo with id 3 got one like (second).
Thus, the winner is the photo with identifier 2, as it got:
* more likes than the photo with id 3;
* as many likes as the photo with id 1, but the photo with the identifier 2 got its second like earlier. | def main():
n = int(input())
l, m = [0] * 1000001, 0
for a in map(int, input().split()):
x = l[a] + 1
l[a] = x
if m < x:
m, res = x, a
print(res)
if __name__ == '__main__':
main()
| {
"input": [
"9\n100 200 300 200 100 300 300 100 200\n",
"5\n1 3 2 2 1\n"
],
"output": [
"300",
"2"
]
} |
4,913 | 7 | Buses run between the cities A and B, the first one is at 05:00 AM and the last one departs not later than at 11:59 PM. A bus from the city A departs every a minutes and arrives to the city B in a ta minutes, and a bus from the city B departs every b minutes and arrives to the city A in a tb minutes.
The driver Simion wants to make his job diverse, so he counts the buses going towards him. Simion doesn't count the buses he meet at the start and finish.
You know the time when Simion departed from the city A to the city B. Calculate the number of buses Simion will meet to be sure in his counting.
Input
The first line contains two integers a, ta (1 β€ a, ta β€ 120) β the frequency of the buses from the city A to the city B and the travel time. Both values are given in minutes.
The second line contains two integers b, tb (1 β€ b, tb β€ 120) β the frequency of the buses from the city B to the city A and the travel time. Both values are given in minutes.
The last line contains the departure time of Simion from the city A in the format hh:mm. It is guaranteed that there are a bus from the city A at that time. Note that the hours and the minutes are given with exactly two digits.
Output
Print the only integer z β the number of buses Simion will meet on the way. Note that you should not count the encounters in cities A and B.
Examples
Input
10 30
10 35
05:20
Output
5
Input
60 120
24 100
13:00
Output
9
Note
In the first example Simion departs form the city A at 05:20 AM and arrives to the city B at 05:50 AM. He will meet the first 5 buses from the city B that departed in the period [05:00 AM - 05:40 AM]. Also Simion will meet a bus in the city B at 05:50 AM, but he will not count it.
Also note that the first encounter will be between 05:26 AM and 05:27 AM (if we suggest that the buses are go with the sustained speed). | def main():
a, ta = map(int, input().split())
b, tb = map(int, input().split())
h, m = map(int, input().split(':'))
res, lo = 0, h * 60 + m - 300
hi = lo + ta
print(sum(max(lo, t) < min(hi, t + tb) for t in range(0, 1140, b)))
if __name__ == '__main__':
main()
| {
"input": [
"10 30\n10 35\n05:20\n",
"60 120\n24 100\n13:00\n"
],
"output": [
"5\n",
"9\n"
]
} |
4,914 | 10 | Mike and !Mike are old childhood rivals, they are opposite in everything they do, except programming. Today they have a problem they cannot solve on their own, but together (with you) β who knows?
Every one of them has an integer sequences a and b of length n. Being given a query of the form of pair of integers (l, r), Mike can instantly tell the value of <image> while !Mike can instantly tell the value of <image>.
Now suppose a robot (you!) asks them all possible different queries of pairs of integers (l, r) (1 β€ l β€ r β€ n) (so he will make exactly n(n + 1) / 2 queries) and counts how many times their answers coincide, thus for how many pairs <image> is satisfied.
How many occasions will the robot count?
Input
The first line contains only integer n (1 β€ n β€ 200 000).
The second line contains n integer numbers a1, a2, ..., an ( - 109 β€ ai β€ 109) β the sequence a.
The third line contains n integer numbers b1, b2, ..., bn ( - 109 β€ bi β€ 109) β the sequence b.
Output
Print the only integer number β the number of occasions the robot will count, thus for how many pairs <image> is satisfied.
Examples
Input
6
1 2 3 2 1 4
6 7 1 2 3 2
Output
2
Input
3
3 3 3
1 1 1
Output
0
Note
The occasions in the first sample case are:
1.l = 4,r = 4 since max{2} = min{2}.
2.l = 4,r = 5 since max{2, 1} = min{2, 3}.
There are no occasions in the second sample case since Mike will answer 3 to any query pair, but !Mike will always answer 1. | from bisect import bisect
HISENTINEL = 10**9 + 1
LOSENTINEL = -HISENTINEL
def main():
length = int(input())
a = [int(fld) for fld in input().strip().split()]
b = [int(fld) for fld in input().strip().split()]
print(countmaxminsubseq(a, b))
def countmaxminsubseq(a, b):
leq, lgt = getleftbounds(a, b, 0)
req, rgt = getleftbounds(reversed(a), reversed(b), 1)
req = reverseindex(req)
rgt = reverseindex(rgt)
count = 0
for i, (leq1, lgt1, req1, rgt1) in enumerate(zip(leq, lgt, req, rgt)):
count += (leq1 - lgt1)*(rgt1 - i) + (i - leq1)*(rgt1 - req1)
return count
def getleftbounds(a, b, bias):
astack = [(HISENTINEL, -1)]
bstack = [(LOSENTINEL, -1)]
leqarr, lgtarr = [], []
for i, (aelt, belt) in enumerate(zip(a, b)):
while astack[-1][0] < aelt + bias:
astack.pop()
lgt = astack[-1][1]
while bstack[-1][0] > belt:
bstack.pop()
if belt < aelt:
leq = lgt = i
elif belt == aelt:
leq = i
istack = bisect(bstack, (aelt, -2)) - 1
lgt = max(lgt, bstack[istack][1])
else:
istack = bisect(bstack, (aelt, i)) - 1
val, pos = bstack[istack]
if val < aelt:
lgt = leq = max(lgt, pos)
else:
leq = pos
istack = bisect(bstack, (aelt, -2)) - 1
val, pos = bstack[istack]
lgt = max(lgt, pos)
leq = max(leq, lgt)
leqarr.append(leq)
lgtarr.append(lgt)
astack.append((aelt, i))
bstack.append((belt, i))
return leqarr, lgtarr
def reverseindex(rind):
pivot = len(rind) - 1
return [pivot - i for i in reversed(rind)]
main()
| {
"input": [
"3\n3 3 3\n1 1 1\n",
"6\n1 2 3 2 1 4\n6 7 1 2 3 2\n"
],
"output": [
"0",
"2"
]
} |
4,915 | 8 | ZS the Coder and Chris the Baboon arrived at the entrance of Udayland. There is a n Γ n magic grid on the entrance which is filled with integers. Chris noticed that exactly one of the cells in the grid is empty, and to enter Udayland, they need to fill a positive integer into the empty cell.
Chris tried filling in random numbers but it didn't work. ZS the Coder realizes that they need to fill in a positive integer such that the numbers in the grid form a magic square. This means that he has to fill in a positive integer so that the sum of the numbers in each row of the grid (<image>), each column of the grid (<image>), and the two long diagonals of the grid (the main diagonal β <image> and the secondary diagonal β <image>) are equal.
Chris doesn't know what number to fill in. Can you help Chris find the correct positive integer to fill in or determine that it is impossible?
Input
The first line of the input contains a single integer n (1 β€ n β€ 500) β the number of rows and columns of the magic grid.
n lines follow, each of them contains n integers. The j-th number in the i-th of them denotes ai, j (1 β€ ai, j β€ 109 or ai, j = 0), the number in the i-th row and j-th column of the magic grid. If the corresponding cell is empty, ai, j will be equal to 0. Otherwise, ai, j is positive.
It is guaranteed that there is exactly one pair of integers i, j (1 β€ i, j β€ n) such that ai, j = 0.
Output
Output a single integer, the positive integer x (1 β€ x β€ 1018) that should be filled in the empty cell so that the whole grid becomes a magic square. If such positive integer x does not exist, output - 1 instead.
If there are multiple solutions, you may print any of them.
Examples
Input
3
4 0 2
3 5 7
8 1 6
Output
9
Input
4
1 1 1 1
1 1 0 1
1 1 1 1
1 1 1 1
Output
1
Input
4
1 1 1 1
1 1 0 1
1 1 2 1
1 1 1 1
Output
-1
Note
In the first sample case, we can fill in 9 into the empty cell to make the resulting grid a magic square. Indeed,
The sum of numbers in each row is:
4 + 9 + 2 = 3 + 5 + 7 = 8 + 1 + 6 = 15.
The sum of numbers in each column is:
4 + 3 + 8 = 9 + 5 + 1 = 2 + 7 + 6 = 15.
The sum of numbers in the two diagonals is:
4 + 5 + 6 = 2 + 5 + 8 = 15.
In the third sample case, it is impossible to fill a number in the empty square such that the resulting grid is a magic square. | def nums(a, n):
S={sum(a[i][i] for i in range(n)), sum(a[i][n-i-1] for i in range(n))}
for i in range(n):
S|={sum(a[i]), sum(a[j][i] for j in range(n))}
return 1 if S=={0} else max(S)-min(S)
n=int(input())
a=[list(map(int, input().split())) for i in range(n)]
x, y=next((i, j) for i in range(n) for j in range(n) if a[i][j]==0)
a[x][y]=nums(a, n)
print(-1 if nums(a, n)!=0 or a[x][y]<=0 else a[x][y]) | {
"input": [
"4\n1 1 1 1\n1 1 0 1\n1 1 1 1\n1 1 1 1\n",
"3\n4 0 2\n3 5 7\n8 1 6\n",
"4\n1 1 1 1\n1 1 0 1\n1 1 2 1\n1 1 1 1\n"
],
"output": [
"1\n",
"9\n",
"-1\n"
]
} |
4,916 | 8 | Recently a dog was bought for Polycarp. The dog's name is Cormen. Now Polycarp has a lot of troubles. For example, Cormen likes going for a walk.
Empirically Polycarp learned that the dog needs at least k walks for any two consecutive days in order to feel good. For example, if k = 5 and yesterday Polycarp went for a walk with Cormen 2 times, today he has to go for a walk at least 3 times.
Polycarp analysed all his affairs over the next n days and made a sequence of n integers a1, a2, ..., an, where ai is the number of times Polycarp will walk with the dog on the i-th day while doing all his affairs (for example, he has to go to a shop, throw out the trash, etc.).
Help Polycarp determine the minimum number of walks he needs to do additionaly in the next n days so that Cormen will feel good during all the n days. You can assume that on the day before the first day and on the day after the n-th day Polycarp will go for a walk with Cormen exactly k times.
Write a program that will find the minumum number of additional walks and the appropriate schedule β the sequence of integers b1, b2, ..., bn (bi β₯ ai), where bi means the total number of walks with the dog on the i-th day.
Input
The first line contains two integers n and k (1 β€ n, k β€ 500) β the number of days and the minimum number of walks with Cormen for any two consecutive days.
The second line contains integers a1, a2, ..., an (0 β€ ai β€ 500) β the number of walks with Cormen on the i-th day which Polycarp has already planned.
Output
In the first line print the smallest number of additional walks that Polycarp should do during the next n days so that Cormen will feel good during all days.
In the second line print n integers b1, b2, ..., bn, where bi β the total number of walks on the i-th day according to the found solutions (ai β€ bi for all i from 1 to n). If there are multiple solutions, print any of them.
Examples
Input
3 5
2 0 1
Output
4
2 3 2
Input
3 1
0 0 0
Output
1
0 1 0
Input
4 6
2 4 3 5
Output
0
2 4 3 5 | n, k = map(int, input().split())
a = list(map(int, input().split()))
def diff(l):
l = l[:]
for i in range(1, n):
l[i] += max(0, k - l[i] - l[i - 1])
return l
b = diff(a)
d = sum(b) - sum(a)
print(d)
print(' '.join(map(str, b)))
| {
"input": [
"3 5\n2 0 1\n",
"4 6\n2 4 3 5\n",
"3 1\n0 0 0\n"
],
"output": [
"4\n2 3 2\n",
"0\n2 4 3 5\n",
"1\n0 1 0\n"
]
} |
4,917 | 10 | Vasya is an administrator of a public page of organization "Mouse and keyboard" and his everyday duty is to publish news from the world of competitive programming. For each news he also creates a list of hashtags to make searching for a particular topic more comfortable. For the purpose of this problem we define hashtag as a string consisting of lowercase English letters and exactly one symbol '#' located at the beginning of the string. The length of the hashtag is defined as the number of symbols in it without the symbol '#'.
The head administrator of the page told Vasya that hashtags should go in lexicographical order (take a look at the notes section for the definition).
Vasya is lazy so he doesn't want to actually change the order of hashtags in already published news. Instead, he decided to delete some suffixes (consecutive characters at the end of the string) of some of the hashtags. He is allowed to delete any number of characters, even the whole string except for the symbol '#'. Vasya wants to pick such a way to delete suffixes that the total number of deleted symbols is minimum possible. If there are several optimal solutions, he is fine with any of them.
Input
The first line of the input contains a single integer n (1 β€ n β€ 500 000) β the number of hashtags being edited now.
Each of the next n lines contains exactly one hashtag of positive length.
It is guaranteed that the total length of all hashtags (i.e. the total length of the string except for characters '#') won't exceed 500 000.
Output
Print the resulting hashtags in any of the optimal solutions.
Examples
Input
3
#book
#bigtown
#big
Output
#b
#big
#big
Input
3
#book
#cool
#cold
Output
#book
#co
#cold
Input
4
#car
#cart
#art
#at
Output
#
#
#art
#at
Input
3
#apple
#apple
#fruit
Output
#apple
#apple
#fruit
Note
Word a1, a2, ..., am of length m is lexicographically not greater than word b1, b2, ..., bk of length k, if one of two conditions hold:
* at first position i, such that ai β bi, the character ai goes earlier in the alphabet than character bi, i.e. a has smaller character than b in the first position where they differ;
* if there is no such position i and m β€ k, i.e. the first word is a prefix of the second or two words are equal.
The sequence of words is said to be sorted in lexicographical order if each word (except the last one) is lexicographically not greater than the next word.
For the words consisting of lowercase English letters the lexicographical order coincides with the alphabet word order in the dictionary.
According to the above definition, if a hashtag consisting of one character '#' it is lexicographically not greater than any other valid hashtag. That's why in the third sample we can't keep first two hashtags unchanged and shorten the other two. | def g(c,d):
s=0
while s<len(a[d]) and a[c][s]==a[d][s]:s+=1
a[c]=a[c][:s]
def f(a):
for i in range(len(a)-1,0,-1):
if a[i-1]>a[i]:g(i-1,i)
print('\n'.join(a))
n=int(input())
a=[input()for i in range(n)]
f(a)
| {
"input": [
"3\n#book\n#bigtown\n#big\n",
"3\n#book\n#cool\n#cold\n",
"4\n#car\n#cart\n#art\n#at\n",
"3\n#apple\n#apple\n#fruit\n"
],
"output": [
"#b\n#big\n#big\n",
"#book\n#co\n#cold\n",
"#\n#\n#art\n#at\n",
"#apple\n#apple\n#fruit\n"
]
} |
4,918 | 8 | Whereas humans nowadays read fewer and fewer books on paper, book readership among marmots has surged. Heidi has expanded the library and is now serving longer request sequences.
Input
Same as the easy version, but the limits have changed: 1 β€ n, k β€ 400 000.
Output
Same as the easy version.
Examples
Input
4 100
1 2 2 1
Output
2
Input
4 1
1 2 2 1
Output
3
Input
4 2
1 2 3 1
Output
3 | import sys
import heapq
from collections import namedtuple
Record = namedtuple('Record', ['index', 'book_id'])
l1 = sys.stdin.readline()
l2 = sys.stdin.readline()
n, k = map(int, l1.split(' '))
books = list(map(int, l2.split(' ')))
cost = 0
cache = set()
prev = dict() # book_id -> index
next = [n+1] * n # index of next with the same value
inactive_ids = set() # set of inactive object id()s
book_to_record = dict()
def serve_book(book_id, i):
cache.add(book_id)
record = Record(-next[i], book_id)
heapq.heappush(h, record)
book_to_record[book_id] = record
h = []
for i, book_id in enumerate(books):
if book_id in prev:
next[prev[book_id]] = i
prev[book_id] = i
for i, book_id in enumerate(books):
# print("book_id=%s, h=%s, inactive=%s" %(book_id, h, inactive_ids))
if book_id in cache:
previous_record = book_to_record[book_id]
inactive_ids.add(id(previous_record))
serve_book(book_id, i)
# print('--> Serve book from library ', book_id)
continue
if len(cache) < k:
cost += 1
serve_book(book_id, i)
# print('--> Buy book', book_id)
continue
while True:
item = heapq.heappop(h)
if id(item) in inactive_ids:
# print("--> Ignore record", item)
inactive_ids.remove(id(item))
continue
cache.remove(item.book_id)
serve_book(book_id, i)
cost += 1
# print('--> Throw away book', item.book_id)
# print('--> Add book to libary', book_id)
break
# print("To evict %s" % to_evict)
print(cost)
| {
"input": [
"4 100\n1 2 2 1\n",
"4 2\n1 2 3 1\n",
"4 1\n1 2 2 1\n"
],
"output": [
"2\n",
"3\n",
"3\n"
]
} |
4,919 | 9 | Petya was late for the lesson too. The teacher gave him an additional task. For some array a Petya should find the number of different ways to select non-empty subset of elements from it in such a way that their product is equal to a square of some integer.
Two ways are considered different if sets of indexes of elements chosen by these ways are different.
Since the answer can be very large, you should find the answer modulo 109 + 7.
Input
First line contains one integer n (1 β€ n β€ 105) β the number of elements in the array.
Second line contains n integers ai (1 β€ ai β€ 70) β the elements of the array.
Output
Print one integer β the number of different ways to choose some elements so that their product is a square of a certain integer modulo 109 + 7.
Examples
Input
4
1 1 1 1
Output
15
Input
4
2 2 2 2
Output
7
Input
5
1 2 4 5 8
Output
7
Note
In first sample product of elements chosen by any way is 1 and 1 = 12. So the answer is 24 - 1 = 15.
In second sample there are six different ways to choose elements so that their product is 4, and only one way so that their product is 16. So the answer is 6 + 1 = 7. | MOD = int(1e9+7)
def is_prime(x):
for i in range(2, int(x**.5)+1):
if x % i == 0:
return False
return True
p = [i for i in range(2, 100) if is_prime(i)]
n = int(input())
arr = list(map(int, input().split()))
s = []
for i in set(arr):
b = 0
for j in p:
while i % j == 0:
i //= j
b ^= 1 << j
for j in s:
b = min(b, b^j)
if b > 0:
s.append(b)
print(pow(2, n-len(s), MOD) - 1)
| {
"input": [
"4\n1 1 1 1\n",
"4\n2 2 2 2\n",
"5\n1 2 4 5 8\n"
],
"output": [
"15\n",
"7\n",
"7\n"
]
} |
4,920 | 11 | You are given a multiset S consisting of positive integers (initially empty). There are two kind of queries:
1. Add a positive integer to S, the newly added integer is not less than any number in it.
2. Find a subset s of the set S such that the value <image> is maximum possible. Here max(s) means maximum value of elements in s, <image> β the average value of numbers in s. Output this maximum possible value of <image>.
Input
The first line contains a single integer Q (1 β€ Q β€ 5Β·105) β the number of queries.
Each of the next Q lines contains a description of query. For queries of type 1 two integers 1 and x are given, where x (1 β€ x β€ 109) is a number that you should add to S. It's guaranteed that x is not less than any number in S. For queries of type 2, a single integer 2 is given.
It's guaranteed that the first query has type 1, i. e. S is not empty when a query of type 2 comes.
Output
Output the answer for each query of the second type in the order these queries are given in input. Each number should be printed in separate line.
Your answer is considered correct, if each of your answers has absolute or relative error not greater than 10 - 6.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
6
1 3
2
1 4
2
1 8
2
Output
0.0000000000
0.5000000000
3.0000000000
Input
4
1 1
1 4
1 5
2
Output
2.0000000000 | import sys
def input():
return sys.stdin.buffer.readline()
Q = int(input())
stack = []
pos = 0
query = [tuple(map(int, input().split())) for i in range(Q)]
S = 0
for que in query:
command = que[0]
if command == 1:
stack.append(que[1])
continue
last_number = stack[-1]
while pos < len(stack) and (pos + 2)*(last_number + S) > (pos + 1)*(last_number + S + stack[pos]):
S += stack[pos]
pos += 1
print(last_number - (last_number + S)/(pos + 1))
continue
| {
"input": [
"4\n1 1\n1 4\n1 5\n2\n",
"6\n1 3\n2\n1 4\n2\n1 8\n2\n"
],
"output": [
"2.000000000000\n",
"0.000000000000\n0.500000000000\n3.000000000000\n"
]
} |
4,921 | 8 | Arkady is playing Battleship. The rules of this game aren't really important.
There is a field of n Γ n cells. There should be exactly one k-decker on the field, i. e. a ship that is k cells long oriented either horizontally or vertically. However, Arkady doesn't know where it is located. For each cell Arkady knows if it is definitely empty or can contain a part of the ship.
Consider all possible locations of the ship. Find such a cell that belongs to the maximum possible number of different locations of the ship.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 100) β the size of the field and the size of the ship.
The next n lines contain the field. Each line contains n characters, each of which is either '#' (denotes a definitely empty cell) or '.' (denotes a cell that can belong to the ship).
Output
Output two integers β the row and the column of a cell that belongs to the maximum possible number of different locations of the ship.
If there are multiple answers, output any of them. In particular, if no ship can be placed on the field, you can output any cell.
Examples
Input
4 3
#..#
#.#.
....
.###
Output
3 2
Input
10 4
#....##...
.#...#....
..#..#..#.
...#.#....
.#..##.#..
.....#...#
...#.##...
.#...#.#..
.....#..#.
...#.#...#
Output
6 1
Input
19 6
##..............###
#......#####.....##
.....#########.....
....###########....
...#############...
..###############..
.#################.
.#################.
.#################.
.#################.
#####....##....####
####............###
####............###
#####...####...####
.#####..####..#####
...###........###..
....###########....
.........##........
#.................#
Output
1 8
Note
The picture below shows the three possible locations of the ship that contain the cell (3, 2) in the first sample.
<image> | n,k=map(int,input().split())
def f(s,i):
l=max(0,i-k+1);c=s.rfind('#',l,i+1);r=min(n,i+k);d=s.find('#',i,r)
if c<0:c=l-1
if d<0:d=r
return max(0,d-c-k)
r=range(n)
a=[input()for _ in r]
b=[''.join(x)for x in zip(*a)]
m,i,j=max((f(a[i],j)+f(b[j],i),i,j)for
i in r for j in r)
print(i+1,j+1) | {
"input": [
"10 4\n#....##...\n.#...#....\n..#..#..#.\n...#.#....\n.#..##.#..\n.....#...#\n...#.##...\n.#...#.#..\n.....#..#.\n...#.#...#\n",
"19 6\n##..............###\n#......#####.....##\n.....#########.....\n....###########....\n...#############...\n..###############..\n.#################.\n.#################.\n.#################.\n.#################.\n#####....##....####\n####............###\n####............###\n#####...####...####\n.#####..####..#####\n...###........###..\n....###########....\n.........##........\n#.................#\n",
"4 3\n#..#\n#.#.\n....\n.###\n"
],
"output": [
"6 1",
"1 8",
"3 2"
]
} |
4,922 | 8 | Today on Informatics class Nastya learned about GCD and LCM (see links below). Nastya is very intelligent, so she solved all the tasks momentarily and now suggests you to solve one of them as well.
We define a pair of integers (a, b) good, if GCD(a, b) = x and LCM(a, b) = y, where GCD(a, b) denotes the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) of a and b, and LCM(a, b) denotes the [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) of a and b.
You are given two integers x and y. You are to find the number of good pairs of integers (a, b) such that l β€ a, b β€ r. Note that pairs (a, b) and (b, a) are considered different if a β b.
Input
The only line contains four integers l, r, x, y (1 β€ l β€ r β€ 109, 1 β€ x β€ y β€ 109).
Output
In the only line print the only integer β the answer for the problem.
Examples
Input
1 2 1 2
Output
2
Input
1 12 1 12
Output
4
Input
50 100 3 30
Output
0
Note
In the first example there are two suitable good pairs of integers (a, b): (1, 2) and (2, 1).
In the second example there are four suitable good pairs of integers (a, b): (1, 12), (12, 1), (3, 4) and (4, 3).
In the third example there are good pairs of integers, for example, (3, 30), but none of them fits the condition l β€ a, b β€ r. | l,r,x,y=map(int,input().split())
import math
def it(a):
if a<l or a>r:return(False)
return(True)
ans=0
div=set()
for i in range(1,int(y**0.5)+1):
if y%i==0 and (y//i)%x==0 and it(i*x) and it(y//i) and math.gcd(i,(y//i)//x)==1:
c=1 if i==(y//i)//x else 0
ans+=2-c
div.add(y//i)
div.add(i*x)
print(len(div)) | {
"input": [
"1 2 1 2\n",
"50 100 3 30\n",
"1 12 1 12\n"
],
"output": [
"2\n",
"0\n",
"4\n"
]
} |
4,923 | 8 | We get more and more news about DDoS-attacks of popular websites.
Arseny is an admin and he thinks that a website is under a DDoS-attack if the total number of requests for a some period of time exceeds 100 β
t, where t β the number of seconds in this time segment.
Arseny knows statistics on the number of requests per second since the server is booted. He knows the sequence r_1, r_2, ..., r_n, where r_i β the number of requests in the i-th second after boot.
Determine the length of the longest continuous period of time, which Arseny considers to be a DDoS-attack. A seeking time period should not go beyond the boundaries of the segment [1, n].
Input
The first line contains n (1 β€ n β€ 5000) β number of seconds since server has been booted. The second line contains sequence of integers r_1, r_2, ..., r_n (0 β€ r_i β€ 5000), r_i β number of requests in the i-th second.
Output
Print the only integer number β the length of the longest time period which is considered to be a DDoS-attack by Arseny. If it doesn't exist print 0.
Examples
Input
5
100 200 1 1 1
Output
3
Input
5
1 2 3 4 5
Output
0
Input
2
101 99
Output
1 | def prog():
n = int(input())
inp = list(map(int,input().split()))
ans = 0
for i in range(len(inp)):
x,y = 0 ,0
for j in range(i,len(inp)):
x+=inp[j]
y+=100
if(x>y):
ans = max(ans,(j-i)+1)
print(ans)
prog() | {
"input": [
"5\n100 200 1 1 1\n",
"5\n1 2 3 4 5\n",
"2\n101 99\n"
],
"output": [
"3\n",
"0\n",
"1\n"
]
} |
4,924 | 7 | Petya is having a party soon, and he has decided to invite his n friends.
He wants to make invitations in the form of origami. For each invitation, he needs two red sheets, five green sheets, and eight blue sheets. The store sells an infinite number of notebooks of each color, but each notebook consists of only one color with k sheets. That is, each notebook contains k sheets of either red, green, or blue.
Find the minimum number of notebooks that Petya needs to buy to invite all n of his friends.
Input
The first line contains two integers n and k (1β€ n, kβ€ 10^8) β the number of Petya's friends and the number of sheets in each notebook respectively.
Output
Print one number β the minimum number of notebooks that Petya needs to buy.
Examples
Input
3 5
Output
10
Input
15 6
Output
38
Note
In the first example, we need 2 red notebooks, 3 green notebooks, and 5 blue notebooks.
In the second example, we need 5 red notebooks, 13 green notebooks, and 20 blue notebooks. | def ceil(a,b):
return -(-a//b)
n, k = map(int,input().split())
print(ceil(n*2,k)+ceil(n*5,k)+ceil(n*8,k))
| {
"input": [
"3 5\n",
"15 6\n"
],
"output": [
"10\n",
"38\n"
]
} |
4,925 | 11 | A positive integer a is given. Baron Munchausen claims that he knows such a positive integer n that if one multiplies n by a, the sum of its digits decreases a times. In other words, S(an) = S(n)/a, where S(x) denotes the sum of digits of the number x.
Find out if what Baron told can be true.
Input
The only line contains a single integer a (2 β€ a β€ 10^3).
Output
If there is no such number n, print -1.
Otherwise print any appropriate positive integer n. Your number must not consist of more than 5β
10^5 digits. We can show that under given constraints either there is no answer, or there is an answer no longer than 5β
10^5 digits.
Examples
Input
2
Output
6
Input
3
Output
6669
Input
10
Output
-1 | #!/bin/pypy3
from itertools import*
from timeit import*
from typing import Optional
S=lambda x:sum(map(int,str(x)))
def ceil_s_divisible_a(x:int,a:int) -> Optional[int]:
z=S(x)%a
if z:
z=a-z
tail=[]
x=list(str(x))
while x:
digit=x.pop()
diff=min(z,9-int(digit))
z-=diff
tail.append(str(int(digit)+diff))
if z==0:break
else:
return ceil_s_divisible_a(10**len(tail),a)
x=''.join(x) + ''.join(reversed(tail))
assert S(x)%a==0
x=int(x)
return x
def smooth25(a):
a=int(bin(a).rstrip('0'),2)
while a%5==0: a//=5
return a==1
def solve(a):
for first in range(1,60): # 120
q=str((first*10**3000+a-1) // a) # 5000
for s1 in range(1,200):
i=1
s2=int(q[0])
while i<len(q) and s2<s1*a-10: s2+=int(q[i]); i+=1
for len1 in range(i,min(i+10,len(q))):
small=int(q[:len1])
for z in range(4): # 10
small=ceil_s_divisible_a(small,a)
if S(small*a)*a==S(small):
return small
small+=1
return None
def powform(x:int)->str:
s=str(x)
try:
i=s.find('00000')
return f'{s[:i]} * 10 ** {len(s)-i} + {int(s[i:])}'
except IndexError:
return str(x)
if 0:
#for a in (a for a in range(2,1000)):
for a in [999,909,813,777,957,921,855,933,831,942,891,846,807,783,888][1::3]:
#for a in [32]:
def work():
global x
x=solve(a)
t=timeit(work,number=1)
if t>0.5 or x==None:
if x!=None:
print(a,t,'>>',powform(a*x))
else:
print(a,t,'>> ?????')
#print(solve(int(input())))
special='''
660 0.5026652759997887 >> 3 * 10 ** 2640 + 35340
803 0.5102322779994211 >> 3 * 10 ** 2678 + 1614
912 0.5136937369998122 >> 3 * 10 ** 1825 + 240
918 0.5238579140004731 >> 3 * 10 ** 1813 + 1104
582 0.5302371079997101 >> 2 * 10 ** 2328 + 17116
612 0.5363936909998301 >> 2 * 10 ** 2413 + 10348
495 0.5372351949999938 >> 3 * 10 ** 2969 + 16305
927 0.5433051690006323 >> 3 * 10 ** 2195 + 21003
636 0.5471086210000067 >> 3 * 10 ** 1379 + 20004
531 0.5475810970001476 >> 2 * 10 ** 2140 + 439
64 0.5633312410000144 >> ?????
200 0.5639609099998779 >> ?????
100 0.565854023000611 >> ?????
125 0.5663040710005589 >> ?????
160 0.5668467480008985 >> ?????
800 0.5676178080002501 >> ?????
128 0.5676772269998764 >> ?????
80 0.5682811480000964 >> ?????
256 0.5685735130000467 >> ?????
250 0.5691464900000938 >> ?????
512 0.569266141999833 >> ?????
32 0.5692826909998985 >> ?????
50 0.5692834940000466 >> ?????
25 0.5696684799995637 >> ?????
400 0.5703751219998594 >> ?????
20 0.5706145570002263 >> ?????
500 0.5742691679997733 >> ?????
640 0.5749700739997934 >> ?????
40 0.5768258159996549 >> ?????
625 0.5775357299999087 >> ?????
16 0.5789494729997386 >> ?????
833 0.5855263899993588 >> 3 * 10 ** 2286 + 1404
792 0.5996652009998797 >> 3 * 10 ** 1903 + 16008
320 0.6031684260005932 >> ?????
10 0.6464516910000384 >> ?????
546 0.6579458010000963 >> 3 * 10 ** 2184 + 2454
5 0.6617960960002165 >> ?????
907 0.664109037000344 >> 3 * 10 ** 2538 + 2223
923 0.6807242180002504 >> 2 * 10 ** 2476 + 4141
723 0.6976773409996895 >> 3 * 10 ** 2892 + 1185
825 0.701172955000402 >> 4 * 10 ** 2476 + 123350
906 0.7062042559991824 >> 4 * 10 ** 1998 + 104
905 0.7086789289996887 >> 2 * 10 ** 2412 + 1540
911 0.711649564000254 >> 2 * 10 ** 2612 + 2044
934 0.7246100349993867 >> 2 * 10 ** 2570 + 51112
765 0.7552886830007992 >> 3 * 10 ** 2939 + 1725
981 0.7653923980005857 >> 4 * 10 ** 1965 + 1022
333 0.7884190810000291 >> 3 * 10 ** 2994 + 62934
663 0.8130600629992841 >> 3 * 10 ** 2546 + 11634
444 0.8443964660000347 >> 3 * 10 ** 1999 + 13956
720 0.8445076829993923 >> 2 * 10 ** 2779 + 159280
867 0.9858260920000248 >> 5 * 10 ** 1739 + 121
914 1.0558696210000562 >> 3 * 10 ** 1831 + 222
606 1.1190159360003236 >> 5 * 10 ** 2910 + 1318
948 1.1529914639995695 >> 6 * 10 ** 2466 + 1020
1000 1.2245053040005587 >> ?????
741 1.2366985769995154 >> 5 * 10 ** 2669 + 175
819 1.292531102999419 >> 8 * 10 ** 2949 + 31312
867 1.293641017000482 >> 5 * 10 ** 1739 + 121
961 1.431375496000328 >> 4 * 10 ** 1935 + 1112
913 2.0632996949998414 >> 5 * 10 ** 2323 + 16
861 2.1641551399998207 >> 11 * 10 ** 1847 + 1114
992 2.2718322470000203 >> 11 * 10 ** 2207 + 1504
936 2.3109037909998733 >> 11 * 10 ** 2108 + 3112
996 2.3603119750005135 >> 11 * 10 ** 1979 + 4300
951 2.380345242999283 >> 11 * 10 ** 1820 + 412
969 2.471255187000679 >> 11 * 10 ** 1942 + 241
828 2.504634874999283 >> 11 * 10 ** 1595 + 11212
693 2.5246166990000347 >> 13 * 10 ** 2494 + 423014
840 2.5490226490001078 >> 11 * 10 ** 1681 + 13120
983 2.618962229999852 >> 11 * 10 ** 1968 + 5011
963 2.641272683999887 >> 11 * 10 ** 2026 + 133
972 2.741184581000198 >> 12 * 10 ** 2130 + 312
555 2.787974407000547 >> 11 * 10 ** 2497 + 444445
873 2.8377116049996403 >> 11 * 10 ** 1774 + 133
903 2.898315477000324 >> 13 * 10 ** 1726 + 32
804 2.9635119349995875 >> 12 * 10 ** 1659 + 1500
864 3.032601443999738 >> 13 * 10 ** 2747 + 34016
759 3.0681308859993806 >> 13 * 10 ** 2504 + 311441
871 3.4960390779997397 >> 13 * 10 ** 2995 + 2405
902 4.413119433999782 >> 12 * 10 ** 1506 + 1110
997 4.446912733999852 >> 11 * 10 ** 1999 + 7
993 5.025415283999791 >> 23 * 10 ** 2130 + 31
837 5.286188959000356 >> 25 * 10 ** 2722 + 11063
786 5.390603378999913 >> 21 * 10 ** 1572 + 4002
801 5.4837765329994 >> 22 * 10 ** 1645 + 212
882 6.045185064999714 >> 22 * 10 ** 1822 + 1130
990 6.413724044000446 >> 39 * 10 ** 2970 + 302010
666 6.967028857000514 >> 33 * 10 ** 2997 + 32934
941 6.982767053000316 >> 21 * 10 ** 1885 + 312
924 7.134165846000542 >> 34 * 10 ** 2772 + 1110152
858 8.089877333000004 >> 41 * 10 ** 2573 + 12201142
939 8.241953895999359 >> 33 * 10 ** 1879 + 20001
813 3.1825667919993066 >> 3 * 10 ** 4065 + 7314
921 1.9310127280004963 >> 1 * 10 ** 3762 + 18008
831 1.683305384999585 >> 1 * 10 ** 3702 + 1646
846 1.4100486610004737 >> 1 * 10 ** 3419 + 44234
888 6.891388972000641 >> 3 * 10 ** 3998 + 27672
909 11.340291348999926 >> 7 * 10 ** 4673 + 17201
957 1.3982879649993265 >> 1 * 10 ** 4347 + 28403
933 0.9980270719997861 >> 1 * 10 ** 3746 + 233234
891 0.8806926099996417 >> 1 * 10 ** 3957 + 1079
783 0.6478317080000124 >> 1 * 10 ** 3162 + 22814
999 102.2252583720001 >> 89 * 10 ** 4760 + 20071
777 37.847382832999756 >> 24 * 10 ** 4661 + 474123
855 0.934857464999368 >> 1 * 10 ** 3420 + 21545
942 1.0410122209996189 >> 1 * 10 ** 4198 + 310058
807 0.7532789589995446 >> 1 * 10 ** 3234 + 1307123
'''
a=int(input())
for line in special.splitlines():
if line:
expr,out=line.split('>>')
expr=expr.split()[0]
if int(expr)==a:
print(-1 if out.strip()=='?????' else eval(out)//a)
break
else:
print(solve(a))
| {
"input": [
"3\n",
"2\n",
"10\n"
],
"output": [
"26667",
"15",
"-1\n"
]
} |
4,926 | 7 | Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab". | def mp():
return map(int, input().split())
a, b, c = mp()
print((min(a, b)) * 2 + int(b != a) + c * 2) | {
"input": [
"2 2 1\n",
"1 1 1\n",
"2 1 2\n",
"1000000000 1000000000 1000000000\n",
"3 5 2\n"
],
"output": [
"6\n",
"4\n",
"7\n",
"4000000000\n",
"11\n"
]
} |
4,927 | 9 | Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, β¦, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, β¦, i_k such that 1 β€ i_1 < i_2 < β¦ < i_k β€ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) β the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, β¦, a_n (0 β€ a_i < m) β the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1. | N, M = map(int, input().split())
A = [int(a) for a in input().split()]
def chk(k):
ret = 0
for i in range(N):
a, b = A[i], (A[i]+k)%M
if a <= b < ret:
return 0
if ret <= a <= b or b < ret <= a:
ret = a
return 1
l = -1
r = M
while r - l > 1:
m = (l+r) // 2
if chk(m):
r = m
else:
l = m
print(r) | {
"input": [
"5 3\n0 0 0 1 2\n",
"5 7\n0 6 1 3 2\n"
],
"output": [
"0\n",
"1\n"
]
} |
4,928 | 11 | You are given a tree (an undirected connected acyclic graph) consisting of n vertices. You are playing a game on this tree.
Initially all vertices are white. On the first turn of the game you choose one vertex and paint it black. Then on each turn you choose a white vertex adjacent (connected by an edge) to any black vertex and paint it black.
Each time when you choose a vertex (even during the first turn), you gain the number of points equal to the size of the connected component consisting only of white vertices that contains the chosen vertex. The game ends when all vertices are painted black.
Let's see the following example:
<image>
Vertices 1 and 4 are painted black already. If you choose the vertex 2, you will gain 4 points for the connected component consisting of vertices 2, 3, 5 and 6. If you choose the vertex 9, you will gain 3 points for the connected component consisting of vertices 7, 8 and 9.
Your task is to maximize the number of points you gain.
Input
The first line contains an integer n β the number of vertices in the tree (2 β€ n β€ 2 β
10^5).
Each of the next n - 1 lines describes an edge of the tree. Edge i is denoted by two integers u_i and v_i, the indices of vertices it connects (1 β€ u_i, v_i β€ n, u_i β v_i).
It is guaranteed that the given edges form a tree.
Output
Print one integer β the maximum number of points you gain if you will play optimally.
Examples
Input
9
1 2
2 3
2 5
2 6
1 4
4 9
9 7
9 8
Output
36
Input
5
1 2
1 3
2 4
2 5
Output
14
Note
The first example tree is shown in the problem statement. | import sys
import threading
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
N = int(input())
graph = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, input().split())
graph[a-1].append(b-1)
graph[b-1].append(a-1)
dp = [1]*N
checked1 = [False]*N
checked = [False]*N
ans = 0
def dfs(p):
checked1[p] = True
for np in graph[p]:
if not checked1[np]:
dfs(np)
dp[p] += dp[np]
def reroot(p, score):
global ans
ans = max(ans, score)
checked[p] = True
for np in graph[p]:
if not checked[np]:
root = dp[p]
goto = dp[np]
dp[np] = root
dp[p] = root - goto
reroot(np, score + root - 2*goto)
dp[np] = goto
dp[p] = root
def main():
dfs(0)
reroot(0, sum(dp))
print(ans)
if __name__ == "__main__":
threading.stack_size(1024 * 100000)
thread = threading.Thread(target=main)
thread.start()
thread.join()
| {
"input": [
"5\n1 2\n1 3\n2 4\n2 5\n",
"9\n1 2\n2 3\n2 5\n2 6\n1 4\n4 9\n9 7\n9 8\n"
],
"output": [
"14",
"36"
]
} |
4,929 | 10 | You are given n integer numbers a_1, a_2, ..., a_n. Consider graph on n nodes, in which nodes i, j (iβ j) are connected if and only if, a_i AND a_jβ 0, where AND denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).
Find the length of the shortest cycle in this graph or determine that it doesn't have cycles at all.
Input
The first line contains one integer n (1 β€ n β€ 10^5) β number of numbers.
The second line contains n integer numbers a_1, a_2, ..., a_n (0 β€ a_i β€ 10^{18}).
Output
If the graph doesn't have any cycles, output -1. Else output the length of the shortest cycle.
Examples
Input
4
3 6 28 9
Output
4
Input
5
5 12 9 16 48
Output
3
Input
4
1 2 4 8
Output
-1
Note
In the first example, the shortest cycle is (9, 3, 6, 28).
In the second example, the shortest cycle is (5, 12, 9).
The graph has no cycles in the third example. | import math
n = int(input())
ns = {}
a = list(map(int, input().split()))
for v in a:
if v == 0: continue
if v in ns:
ns[v] += 1
if ns[v] >= 3:
print(3)
exit(0)
else: ns[v] = 1
a = [v for v in ns]
n = len(a)
MAX_A = 10 ** 18
n_bits = math.ceil(math.log(MAX_A, 2)) + 1
if n > n_bits*3:
print(3)
exit(0)
comp = [[] for _ in range(n_bits)]
G = {}
def add(v):
G[v] = set()
v2, i = v, 0
while v2 != 0:
if v2 % 2 == 1: comp[i].append(v)
v2 //= 2
i += 1
for v in a:
add(v)
for c in comp:
if len(c) >= 3:
print(3)
exit(0)
elif len(c) == 2:
v, w = c
G[v].add(w)
G[w].add(v)
for v in a:
if ns[v] == 2 and len(G[v]) > 0:
print(3)
exit(0)
res = -1
for u in a:
level = {v:-1 for v in a}
level[u] = 0
l = [u]
i = 0
while len(l) > 0 and (res < 0 or 2*i < res):
l2 = []
for v in l:
for w in G[v]:
if level[w] == -1:
l2.append(w)
level[w] = i+1
elif level[w] >= i:
res = min(res, i+1+level[w]) if res > 0 else i+1+level[w]
l = l2
i += 1
print(res) | {
"input": [
"4\n3 6 28 9\n",
"4\n1 2 4 8\n",
"5\n5 12 9 16 48\n"
],
"output": [
"4\n",
"-1\n",
"3\n"
]
} |
4,930 | 9 | The only difference between easy and hard versions is the maximum value of n.
You are given a positive integer number n. You really love good numbers so you want to find the smallest good number greater than or equal to n.
The positive integer is called good if it can be represented as a sum of distinct powers of 3 (i.e. no duplicates of powers of 3 are allowed).
For example:
* 30 is a good number: 30 = 3^3 + 3^1,
* 1 is a good number: 1 = 3^0,
* 12 is a good number: 12 = 3^2 + 3^1,
* but 2 is not a good number: you can't represent it as a sum of distinct powers of 3 (2 = 3^0 + 3^0),
* 19 is not a good number: you can't represent it as a sum of distinct powers of 3 (for example, the representations 19 = 3^2 + 3^2 + 3^0 = 3^2 + 3^1 + 3^1 + 3^1 + 3^0 are invalid),
* 20 is also not a good number: you can't represent it as a sum of distinct powers of 3 (for example, the representation 20 = 3^2 + 3^2 + 3^0 + 3^0 is invalid).
Note, that there exist other representations of 19 and 20 as sums of powers of 3 but none of them consists of distinct powers of 3.
For the given positive integer n find such smallest m (n β€ m) that m is a good number.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 β€ q β€ 500) β the number of queries. Then q queries follow.
The only line of the query contains one integer n (1 β€ n β€ 10^4).
Output
For each query, print such smallest integer m (where n β€ m) that m is a good number.
Example
Input
7
1
2
6
13
14
3620
10000
Output
1
3
9
13
27
6561
19683 | def chq3(n):
po =10
s = set()
while po>=0:
k = 3**po
if n>=k:
n-=k
po-=1
return (n==0)
for _ in range(int(input())):
a = int(input())
t = a
while chq3(t)!=1:
t+=1
print(t) | {
"input": [
"7\n1\n2\n6\n13\n14\n3620\n10000\n"
],
"output": [
"1\n3\n9\n13\n27\n6561\n19683\n"
]
} |
4,931 | 10 | One day Anna got the following task at school: to arrange several numbers in a circle so that any two neighboring numbers differs exactly by 1. Anna was given several numbers and arranged them in a circle to fulfill the task. Then she wanted to check if she had arranged the numbers correctly, but at this point her younger sister Maria came and shuffled all numbers. Anna got sick with anger but what's done is done and the results of her work had been destroyed. But please tell Anna: could she have hypothetically completed the task using all those given numbers?
Input
The first line contains an integer n β how many numbers Anna had (3 β€ n β€ 105). The next line contains those numbers, separated by a space. All numbers are integers and belong to the range from 1 to 109.
Output
Print the single line "YES" (without the quotes), if Anna could have completed the task correctly using all those numbers (using all of them is necessary). If Anna couldn't have fulfilled the task, no matter how hard she would try, print "NO" (without the quotes).
Examples
Input
4
1 2 3 2
Output
YES
Input
6
1 1 2 2 2 3
Output
YES
Input
6
2 4 1 1 2 2
Output
NO | def no():
print("NO")
exit(0)
n, a = int(input()), list(map(int, input().split()))
x, y = min(a), max(a)
d = y-x
if 2*d > n:
print("NO")
exit(0)
c = [0] * (d+1)
for i in range(n):
c[a[i]-x] += 1
for i in range(1, d):
c[i] -= c[i-1]
if c[i] <= 0:
no()
if c[d] == c[d-1]:
print("YES")
else:
print("NO") | {
"input": [
"6\n1 1 2 2 2 3\n",
"4\n1 2 3 2\n",
"6\n2 4 1 1 2 2\n"
],
"output": [
"YES\n",
"YES\n",
"NO\n"
]
} |
4,932 | 11 | Alice has got addicted to a game called Sirtet recently.
In Sirtet, player is given an n Γ m grid. Initially a_{i,j} cubes are stacked up in the cell (i,j). Two cells are called adjacent if they share a side. Player can perform the following operations:
* stack up one cube in two adjacent cells;
* stack up two cubes in one cell.
Cubes mentioned above are identical in height.
Here is an illustration of the game. States on the right are obtained by performing one of the above operations on the state on the left, and grey cubes are added due to the operation.
<image>
Player's goal is to make the height of all cells the same (i.e. so that each cell has the same number of cubes in it) using above operations.
Alice, however, has found out that on some starting grids she may never reach the goal no matter what strategy she uses. Thus, she is wondering the number of initial grids such that
* L β€ a_{i,j} β€ R for all 1 β€ i β€ n, 1 β€ j β€ m;
* player can reach the goal using above operations.
Please help Alice with it. Notice that the answer might be large, please output the desired value modulo 998,244,353.
Input
The only line contains four integers n, m, L and R (1β€ n,m,L,R β€ 10^9, L β€ R, n β
m β₯ 2).
Output
Output one integer, representing the desired answer modulo 998,244,353.
Examples
Input
2 2 1 1
Output
1
Input
1 2 1 2
Output
2
Note
In the first sample, the only initial grid that satisfies the requirements is a_{1,1}=a_{2,1}=a_{1,2}=a_{2,2}=1. Thus the answer should be 1.
In the second sample, initial grids that satisfy the requirements are a_{1,1}=a_{1,2}=1 and a_{1,1}=a_{1,2}=2. Thus the answer should be 2. | def inv(x):
return pow(x, MOD-2, MOD)
n, m, L, R = map(int, input().split())
MOD = 998244353
E = R//2-(L-1)//2
O = R-L+1-E
ans = pow(E+O, n*m, MOD)
ans += pow(max(E, O)-min(E, O), n*m, MOD)*inv(2)
ans += pow(min(E, O)-max(E, O), n*m, MOD)*inv(2)
if m*n%2==0:
ans *= inv(2)
print(ans%MOD) | {
"input": [
"2 2 1 1\n",
"1 2 1 2\n"
],
"output": [
"1\n",
"2\n"
]
} |
4,933 | 7 | You are given two integers n and m. You have to construct the array a of length n consisting of non-negative integers (i.e. integers greater than or equal to zero) such that the sum of elements of this array is exactly m and the value β_{i=1}^{n-1} |a_i - a_{i+1}| is the maximum possible. Recall that |x| is the absolute value of x.
In other words, you have to maximize the sum of absolute differences between adjacent (consecutive) elements. For example, if the array a=[1, 3, 2, 5, 5, 0] then the value above for this array is |1-3| + |3-2| + |2-5| + |5-5| + |5-0| = 2 + 1 + 3 + 0 + 5 = 11. Note that this example doesn't show the optimal answer but it shows how the required value for some array is calculated.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 10^4) β the number of test cases. Then t test cases follow.
The only line of the test case contains two integers n and m (1 β€ n, m β€ 10^9) β the length of the array and its sum correspondingly.
Output
For each test case, print the answer β the maximum possible value of β_{i=1}^{n-1} |a_i - a_{i+1}| for the array a consisting of n non-negative integers with the sum m.
Example
Input
5
1 100
2 2
5 5
2 1000000000
1000000000 1000000000
Output
0
2
10
1000000000
2000000000
Note
In the first test case of the example, the only possible array is [100] and the answer is obviously 0.
In the second test case of the example, one of the possible arrays is [2, 0] and the answer is |2-0| = 2.
In the third test case of the example, one of the possible arrays is [0, 2, 0, 3, 0] and the answer is |0-2| + |2-0| + |0-3| + |3-0| = 10. | def solve():
n, m = map(int, input().split())
print(min(2, n - 1) * m)
t = int(input())
for _ in range(t):
solve() | {
"input": [
"5\n1 100\n2 2\n5 5\n2 1000000000\n1000000000 1000000000\n"
],
"output": [
"0\n2\n10\n1000000000\n2000000000\n"
]
} |
4,934 | 7 | So, the New Year holidays are over. Santa Claus and his colleagues can take a rest and have guests at last. When two "New Year and Christmas Men" meet, thear assistants cut out of cardboard the letters from the guest's name and the host's name in honor of this event. Then the hung the letters above the main entrance. One night, when everyone went to bed, someone took all the letters of our characters' names. Then he may have shuffled the letters and put them in one pile in front of the door.
The next morning it was impossible to find the culprit who had made the disorder. But everybody wondered whether it is possible to restore the names of the host and his guests from the letters lying at the door? That is, we need to verify that there are no extra letters, and that nobody will need to cut more letters.
Help the "New Year and Christmas Men" and their friends to cope with this problem. You are given both inscriptions that hung over the front door the previous night, and a pile of letters that were found at the front door next morning.
Input
The input file consists of three lines: the first line contains the guest's name, the second line contains the name of the residence host and the third line contains letters in a pile that were found at the door in the morning. All lines are not empty and contain only uppercase Latin letters. The length of each line does not exceed 100.
Output
Print "YES" without the quotes, if the letters in the pile could be permuted to make the names of the "New Year and Christmas Men". Otherwise, print "NO" without the quotes.
Examples
Input
SANTACLAUS
DEDMOROZ
SANTAMOROZDEDCLAUS
Output
YES
Input
PAPAINOEL
JOULUPUKKI
JOULNAPAOILELUPUKKI
Output
NO
Input
BABBONATALE
FATHERCHRISTMAS
BABCHRISTMASBONATALLEFATHER
Output
NO
Note
In the first sample the letters written in the last line can be used to write the names and there won't be any extra letters left.
In the second sample letter "P" is missing from the pile and there's an extra letter "L".
In the third sample there's an extra letter "L". | def sort(s):
return "".join(sorted(s))
s,t,y=input(),input(),input()
s+=t
if(sort(s)==sort(y)):print("YES")
else:print("NO") | {
"input": [
"BABBONATALE\nFATHERCHRISTMAS\nBABCHRISTMASBONATALLEFATHER\n",
"SANTACLAUS\nDEDMOROZ\nSANTAMOROZDEDCLAUS\n",
"PAPAINOEL\nJOULUPUKKI\nJOULNAPAOILELUPUKKI\n"
],
"output": [
"NO",
"YES",
"NO"
]
} |
4,935 | 7 | Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements β 6 β is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 β€ i β€ n), 1 β€ a_i β€ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 β€ n β€ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good. | t = int(input())
def solve():
ans = ["1"] * int(input())
print(" ".join(ans))
for i in range(t):
solve()
| {
"input": [
"3\n1\n2\n4\n"
],
"output": [
"1\n1 1\n1 1 1 1\n"
]
} |
4,936 | 12 | Polycarp found n segments on the street. A segment with the index i is described by two integers l_i and r_i β coordinates of the beginning and end of the segment, respectively. Polycarp realized that he didn't need all the segments, so he wanted to delete some of them.
Polycarp believes that a set of k segments is good if there is a segment [l_i, r_i] (1 β€ i β€ k) from the set, such that it intersects every segment from the set (the intersection must be a point or segment). For example, a set of 3 segments [[1, 4], [2, 3], [3, 6]] is good, since the segment [2, 3] intersects each segment from the set. Set of 4 segments [[1, 2], [2, 3], [3, 5], [4, 5]] is not good.
Polycarp wonders, what is the minimum number of segments he has to delete so that the remaining segments form a good set?
Input
The first line contains a single integer t (1 β€ t β€ 2 β
10^5) β number of test cases. Then t test cases follow.
The first line of each test case contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of segments. This is followed by n lines describing the segments.
Each segment is described by two integers l and r (1 β€ l β€ r β€ 10^9) β coordinates of the beginning and end of the segment, respectively.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case, output a single integer β the minimum number of segments that need to be deleted in order for the set of remaining segments to become good.
Example
Input
4
3
1 4
2 3
3 6
4
1 2
2 3
3 5
4 5
5
1 2
3 8
4 5
6 7
9 10
5
1 5
2 4
3 5
3 8
4 8
Output
0
1
2
0 | from bisect import bisect_right, bisect_left
import sys
input = sys.stdin.readline
def solve(s):
n = len(s)
sl = sorted([l for l, r in s])
sr = sorted([r for l, r in s])
best = n
for l, r in s:
cur = n - bisect_right(sl, r) + bisect_left(sr, l)
best = min(best, cur)
return best
t = int(input())
for _ in range(t):
n = int(input())
s = [tuple(map(int, input().split())) for _ in range(n)]
print(solve(s))
| {
"input": [
"4\n3\n1 4\n2 3\n3 6\n4\n1 2\n2 3\n3 5\n4 5\n5\n1 2\n3 8\n4 5\n6 7\n9 10\n5\n1 5\n2 4\n3 5\n3 8\n4 8\n"
],
"output": [
"\n0\n1\n2\n0\n"
]
} |
4,937 | 10 | Let's define the cost of a string s as the number of index pairs i and j (1 β€ i < j < |s|) such that s_i = s_j and s_{i+1} = s_{j+1}.
You are given two positive integers n and k. Among all strings with length n that contain only the first k characters of the Latin alphabet, find a string with minimum possible cost. If there are multiple such strings with minimum cost β find any of them.
Input
The only line contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 26).
Output
Print the string s such that it consists of n characters, each its character is one of the k first Latin letters, and it has the minimum possible cost among all these strings. If there are multiple such strings β print any of them.
Examples
Input
9 4
Output
aabacadbb
Input
5 1
Output
aaaaa
Input
10 26
Output
codeforces | def answer(n,k):
a = ""
s = "abcdefghijklmnopqrstuvwxyz"
for i in range(k):
j = i
while(True):
a+= s[j]
j+=1
if (j == k):
break
a+= s[i]
m = k*k
return a*(n//m)+a[:n%m]
n,k = map(int,input().split())
print(answer(n,k))
| {
"input": [
"9 4\n",
"5 1\n",
"10 26\n"
],
"output": [
"\naabacadbb\n",
"\naaaaa",
"\ncodeforces\n"
]
} |
4,938 | 8 | Petya once wrote a sad love song and shared it to Vasya. The song is a string consisting of lowercase English letters. Vasya made up q questions about this song. Each question is about a subsegment of the song starting from the l-th letter to the r-th letter. Vasya considers a substring made up from characters on this segment and repeats each letter in the subsegment k times, where k is the index of the corresponding letter in the alphabet. For example, if the question is about the substring "abbcb", then Vasya repeats letter 'a' once, each of the letters 'b' twice, letter 'c" three times, so that the resulting string is "abbbbcccbb", its length is 10. Vasya is interested about the length of the resulting string.
Help Petya find the length of each string obtained by Vasya.
Input
The first line contains two integers n and q (1β€ nβ€ 100 000, 1β€ q β€ 100 000) β the length of the song and the number of questions.
The second line contains one string s β the song, consisting of n lowercase letters of English letters.
Vasya's questions are contained in the next q lines. Each line contains two integers l and r (1 β€ l β€ r β€ n) β the bounds of the question.
Output
Print q lines: for each question print the length of the string obtained by Vasya.
Examples
Input
7 3
abacaba
1 3
2 5
1 7
Output
4
7
11
Input
7 4
abbabaa
1 3
5 7
6 6
2 4
Output
5
4
1
5
Input
13 7
sonoshikumiwo
1 5
2 10
7 7
1 13
4 8
2 5
3 9
Output
82
125
9
191
62
63
97
Note
In the first example Vasya is interested in three questions. In the first question Vasya considers the substring "aba", that transforms to "abba", so the answer is equal to 4. In the second question Vasya considers "baca", that transforms to "bbaccca", so the answer is 7. In the third question Vasya considers the string "abacaba",that transforms to "abbacccabba" of length 11. | def solve(l ,r):
return miku[r] - miku[l - 1]
n, q = map(int, input().split())
s = input()
miku = [0] * (n + 1)
for i in range(1, n + 1):
miku[i] += miku[i - 1] + ord(s[i - 1]) - 96
for i in range(q):
l, r = map(int, input().split())
print(solve(l, r))
| {
"input": [
"7 3\nabacaba\n1 3\n2 5\n1 7\n",
"13 7\nsonoshikumiwo\n1 5\n2 10\n7 7\n1 13\n4 8\n2 5\n3 9\n",
"7 4\nabbabaa\n1 3\n5 7\n6 6\n2 4\n"
],
"output": [
"4\n7\n11\n",
"82\n125\n9\n191\n62\n63\n97\n",
"5\n4\n1\n5\n"
]
} |
4,939 | 7 | A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 β€ i β€ n) (n is the permutation size) the following equations hold ppi = i and pi β i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 β€ n β€ 100) β the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn β permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3 | def main():
n = int(input())
if n & 1:
return -1,
return list(range(n, 0, -1))
print(*main()) | {
"input": [
"4\n",
"1\n",
"2\n"
],
"output": [
"2 1 4 3 ",
"-1",
"2 1 "
]
} |
4,940 | 10 | You are given a rectangle grid. That grid's size is n Γ m. Let's denote the coordinate system on the grid. So, each point on the grid will have coordinates β a pair of integers (x, y) (0 β€ x β€ n, 0 β€ y β€ m).
Your task is to find a maximum sub-rectangle on the grid (x1, y1, x2, y2) so that it contains the given point (x, y), and its length-width ratio is exactly (a, b). In other words the following conditions must hold: 0 β€ x1 β€ x β€ x2 β€ n, 0 β€ y1 β€ y β€ y2 β€ m, <image>.
The sides of this sub-rectangle should be parallel to the axes. And values x1, y1, x2, y2 should be integers.
<image>
If there are multiple solutions, find the rectangle which is closest to (x, y). Here "closest" means the Euclid distance between (x, y) and the center of the rectangle is as small as possible. If there are still multiple solutions, find the lexicographically minimum one. Here "lexicographically minimum" means that we should consider the sub-rectangle as sequence of integers (x1, y1, x2, y2), so we can choose the lexicographically minimum one.
Input
The first line contains six integers n, m, x, y, a, b (1 β€ n, m β€ 109, 0 β€ x β€ n, 0 β€ y β€ m, 1 β€ a β€ n, 1 β€ b β€ m).
Output
Print four integers x1, y1, x2, y2, which represent the founded sub-rectangle whose left-bottom point is (x1, y1) and right-up point is (x2, y2).
Examples
Input
9 9 5 5 2 1
Output
1 3 9 7
Input
100 100 52 50 46 56
Output
17 8 86 92 | #!/usr/bin/python3
def gcd(a, b):
while a:
a, b = b % a, a
return b
n, m, x, y, a, b = tuple(map(int, input().strip().split()))
g = gcd(a, b)
a //= g
b //= g
k = min(n // a, m // b)
w = k * a
h = k * b
ans = [x - w + w // 2, y - h + h // 2, x + w // 2, y + h // 2]
if ans[0] < 0:
ans[2] -= ans[0]
ans[0] = 0;
if ans[1] < 0:
ans[3] -= ans[1]
ans[1] = 0
if ans[2] > n:
ans[0] -= ans[2] - n
ans[2] = n
if ans[3] > m:
ans[1] -= ans[3] - m
ans[3] = m
print('%d %d %d %d' % tuple(ans)) | {
"input": [
"100 100 52 50 46 56\n",
"9 9 5 5 2 1\n"
],
"output": [
"17 8 86 92\n",
"1 3 9 7\n"
]
} |
4,941 | 9 | Jeff got 2n real numbers a1, a2, ..., a2n as a birthday present. The boy hates non-integer numbers, so he decided to slightly "adjust" the numbers he's got. Namely, Jeff consecutively executes n operations, each of them goes as follows:
* choose indexes i and j (i β j) that haven't been chosen yet;
* round element ai to the nearest integer that isn't more than ai (assign to ai: β ai β);
* round element aj to the nearest integer that isn't less than aj (assign to aj: β aj β).
Nevertheless, Jeff doesn't want to hurt the feelings of the person who gave him the sequence. That's why the boy wants to perform the operations so as to make the absolute value of the difference between the sum of elements before performing the operations and the sum of elements after performing the operations as small as possible. Help Jeff find the minimum absolute value of the difference.
Input
The first line contains integer n (1 β€ n β€ 2000). The next line contains 2n real numbers a1, a2, ..., a2n (0 β€ ai β€ 10000), given with exactly three digits after the decimal point. The numbers are separated by spaces.
Output
In a single line print a single real number β the required difference with exactly three digits after the decimal point.
Examples
Input
3
0.000 0.500 0.750 1.000 2.000 3.000
Output
0.250
Input
3
4469.000 6526.000 4864.000 9356.383 7490.000 995.896
Output
0.279
Note
In the first test case you need to perform the operations as follows: (i = 1, j = 4), (i = 2, j = 3), (i = 5, j = 6). In this case, the difference will equal |(0 + 0.5 + 0.75 + 1 + 2 + 3) - (0 + 0 + 1 + 1 + 2 + 3)| = 0.25. | from sys import *
import math
def numline(f = int):
return map(f, input().split())
n = int(input())
a = list(filter(lambda x: x != 0, numline(lambda s: int(s.split('.')[1]))))
# print(' '.join(map(str, a)))
c0 = min(2 * n - len(a), len(a))
s = sum(a) - 1000 * min(n, len(a))
ans = abs(s)
for i in range(c0):
s += 1000
ans = min(ans, abs(s))
print('{}.{:0>3}'.format(ans // 1000, ans % 1000)) | {
"input": [
"3\n0.000 0.500 0.750 1.000 2.000 3.000\n",
"3\n4469.000 6526.000 4864.000 9356.383 7490.000 995.896\n"
],
"output": [
"0.250\n",
"0.279\n"
]
} |
4,942 | 7 | User ainta is making a web site. This time he is going to make a navigation of the pages. In his site, there are n pages numbered by integers from 1 to n. Assume that somebody is on the p-th page now. The navigation will look like this:
<< p - k p - k + 1 ... p - 1 (p) p + 1 ... p + k - 1 p + k >>
When someone clicks the button "<<" he is redirected to page 1, and when someone clicks the button ">>" he is redirected to page n. Of course if someone clicks on a number, he is redirected to the corresponding page.
There are some conditions in the navigation:
* If page 1 is in the navigation, the button "<<" must not be printed.
* If page n is in the navigation, the button ">>" must not be printed.
* If the page number is smaller than 1 or greater than n, it must not be printed.
You can see some examples of the navigations. Make a program that prints the navigation.
Input
The first and the only line contains three integers n, p, k (3 β€ n β€ 100; 1 β€ p β€ n; 1 β€ k β€ n)
Output
Print the proper navigation. Follow the format of the output from the test samples.
Examples
Input
17 5 2
Output
<< 3 4 (5) 6 7 >>
Input
6 5 2
Output
<< 3 4 (5) 6
Input
6 1 2
Output
(1) 2 3 >>
Input
6 2 2
Output
1 (2) 3 4 >>
Input
9 6 3
Output
<< 3 4 5 (6) 7 8 9
Input
10 6 3
Output
<< 3 4 5 (6) 7 8 9 >>
Input
8 5 4
Output
1 2 3 4 (5) 6 7 8 | def f(i):
return str(i) if i != p else "(" + str(i) + ")"
s = input()
n, p, k = map(int, s.split())
l, r = max(1, p-k), min(n, p+k)
ans = "<< " if l != 1 else ""
for i in range(l, r):
ans += (f(i) + " ")
ans += f(r)
if r != n:
ans += " >>"
print(ans) | {
"input": [
"6 5 2\n",
"6 1 2\n",
"8 5 4\n",
"6 2 2\n",
"9 6 3\n",
"17 5 2\n",
"10 6 3\n"
],
"output": [
"<< 3 4 (5) 6 \n",
"(1) 2 3 >>\n",
"1 2 3 4 (5) 6 7 8 \n",
"1 (2) 3 4 >>\n",
"<< 3 4 5 (6) 7 8 9 \n",
"<< 3 4 (5) 6 7 >>\n",
"<< 3 4 5 (6) 7 8 9 >>\n"
]
} |
4,943 | 8 | Recently, a start up by two students of a state university of city F gained incredible popularity. Now it's time to start a new company. But what do we call it?
The market analysts came up with a very smart plan: the name of the company should be identical to its reflection in a mirror! In other words, if we write out the name of the company on a piece of paper in a line (horizontally, from left to right) with large English letters, then put this piece of paper in front of the mirror, then the reflection of the name in the mirror should perfectly match the line written on the piece of paper.
There are many suggestions for the company name, so coming up to the mirror with a piece of paper for each name wouldn't be sensible. The founders of the company decided to automatize this process. They asked you to write a program that can, given a word, determine whether the word is a 'mirror' word or not.
Input
The first line contains a non-empty name that needs to be checked. The name contains at most 105 large English letters. The name will be written with the next sans serif font:
<image>
Output
Print 'YES' (without the quotes), if the given name matches its mirror reflection. Otherwise, print 'NO' (without the quotes).
Examples
Input
AHA
Output
YES
Input
Z
Output
NO
Input
XO
Output
NO | def main():
s = input()
print(("NO", "YES")[s == s[::-1] and all(c in "AHIMOTUVWXY" for c in s)])
if __name__ == '__main__':
main()
| {
"input": [
"XO\n",
"Z\n",
"AHA\n"
],
"output": [
"NO\n",
"NO\n",
"YES\n"
]
} |
4,944 | 7 | A kindergarten teacher Natalia Pavlovna has invented a new ball game. This game not only develops the children's physique, but also teaches them how to count.
The game goes as follows. Kids stand in circle. Let's agree to think of the children as numbered with numbers from 1 to n clockwise and the child number 1 is holding the ball. First the first child throws the ball to the next one clockwise, i.e. to the child number 2. Then the child number 2 throws the ball to the next but one child, i.e. to the child number 4, then the fourth child throws the ball to the child that stands two children away from him, i.e. to the child number 7, then the ball is thrown to the child who stands 3 children away from the child number 7, then the ball is thrown to the child who stands 4 children away from the last one, and so on. It should be mentioned that when a ball is thrown it may pass the beginning of the circle. For example, if n = 5, then after the third throw the child number 2 has the ball again. Overall, n - 1 throws are made, and the game ends.
The problem is that not all the children get the ball during the game. If a child doesn't get the ball, he gets very upset and cries until Natalia Pavlovna gives him a candy. That's why Natalia Pavlovna asks you to help her to identify the numbers of the children who will get the ball after each throw.
Input
The first line contains integer n (2 β€ n β€ 100) which indicates the number of kids in the circle.
Output
In the single line print n - 1 numbers which are the numbers of children who will get the ball after each throw. Separate the numbers by spaces.
Examples
Input
10
Output
2 4 7 1 6 2 9 7 6
Input
3
Output
2 1 | def q46a():
n = int(input())
current_holder = 1
for i in range(1, n):
current_holder += i
print((current_holder-1) % n + 1, end=' ')
print("")
q46a() | {
"input": [
"10\n",
"3\n"
],
"output": [
"2 4 7 1 6 2 9 7 6 ",
"2 1 "
]
} |
4,945 | 8 | Vanya walks late at night along a straight street of length l, lit by n lanterns. Consider the coordinate system with the beginning of the street corresponding to the point 0, and its end corresponding to the point l. Then the i-th lantern is at the point ai. The lantern lights all points of the street that are at the distance of at most d from it, where d is some positive number, common for all lanterns.
Vanya wonders: what is the minimum light radius d should the lanterns have to light the whole street?
Input
The first line contains two integers n, l (1 β€ n β€ 1000, 1 β€ l β€ 109) β the number of lanterns and the length of the street respectively.
The next line contains n integers ai (0 β€ ai β€ l). Multiple lanterns can be located at the same point. The lanterns may be located at the ends of the street.
Output
Print the minimum light radius d, needed to light the whole street. The answer will be considered correct if its absolute or relative error doesn't exceed 10 - 9.
Examples
Input
7 15
15 5 3 7 9 14 0
Output
2.5000000000
Input
2 5
2 5
Output
2.0000000000
Note
Consider the second sample. At d = 2 the first lantern will light the segment [0, 4] of the street, and the second lantern will light segment [3, 5]. Thus, the whole street will be lit. | def I(): return(list(map(int,input().split())))
n,l=I()
a=I()
a.sort()
d=0
for i in range(n-1):d=max(a[i+1]-a[i],d)
# d=max(l-a[-1],d)
# d=max(a[0],d)
print(max(d/2,a[0],l-a[-1])) | {
"input": [
"7 15\n15 5 3 7 9 14 0\n",
"2 5\n2 5\n"
],
"output": [
"2.5\n",
"2.0\n"
]
} |
4,946 | 7 | Drazil is playing a math game with Varda.
Let's define <image> for positive integer x as a product of factorials of its digits. For example, <image>.
First, they choose a decimal number a consisting of n digits that contains at least one digit larger than 1. This number may possibly start with leading zeroes. Then they should find maximum positive number x satisfying following two conditions:
1. x doesn't contain neither digit 0 nor digit 1.
2. <image> = <image>.
Help friends find such number.
Input
The first line contains an integer n (1 β€ n β€ 15) β the number of digits in a.
The second line contains n digits of a. There is at least one digit in a that is larger than 1. Number a may possibly contain leading zeroes.
Output
Output a maximum possible integer satisfying the conditions above. There should be no zeroes and ones in this number decimal representation.
Examples
Input
4
1234
Output
33222
Input
3
555
Output
555
Note
In the first case, <image> | conv_mas = ["","","2","3","322","5","53","7","7222","7332"]
def conv(str1=""):
for i in range(10):
str1 = str1.replace(str(i),conv_mas[i])
return "".join(sorted(str1))[::-1]
n = int(input())
print(conv(input())) | {
"input": [
"4\n1234\n",
"3\n555\n"
],
"output": [
"33222\n",
"555\n"
]
} |
4,947 | 7 | Programmers working on a large project have just received a task to write exactly m lines of code. There are n programmers working on a project, the i-th of them makes exactly ai bugs in every line of code that he writes.
Let's call a sequence of non-negative integers v1, v2, ..., vn a plan, if v1 + v2 + ... + vn = m. The programmers follow the plan like that: in the beginning the first programmer writes the first v1 lines of the given task, then the second programmer writes v2 more lines of the given task, and so on. In the end, the last programmer writes the remaining lines of the code. Let's call a plan good, if all the written lines of the task contain at most b bugs in total.
Your task is to determine how many distinct good plans are there. As the number of plans can be large, print the remainder of this number modulo given positive integer mod.
Input
The first line contains four integers n, m, b, mod (1 β€ n, m β€ 500, 0 β€ b β€ 500; 1 β€ mod β€ 109 + 7) β the number of programmers, the number of lines of code in the task, the maximum total number of bugs respectively and the modulo you should use when printing the answer.
The next line contains n space-separated integers a1, a2, ..., an (0 β€ ai β€ 500) β the number of bugs per line for each programmer.
Output
Print a single integer β the answer to the problem modulo mod.
Examples
Input
3 3 3 100
1 1 1
Output
10
Input
3 6 5 1000000007
1 2 3
Output
0
Input
3 5 6 11
1 2 1
Output
0 | def main():
n,m,b,mod=map(int,input().split())
arr=list(map(int,input().split()))
dp=[[0 for _ in range(b+1)] for _ in range(m+1)]
dp[0]=[1]*(b+1)
for item in arr:
for x in range(1,m+1):
for y in range(item,b+1):
dp[x][y]=(dp[x][y]+dp[x-1][y-item])%mod
print(dp[m][b])
main() | {
"input": [
"3 6 5 1000000007\n1 2 3\n",
"3 3 3 100\n1 1 1\n",
"3 5 6 11\n1 2 1\n"
],
"output": [
"0\n",
"10\n",
"0\n"
]
} |
4,948 | 9 | The Beroil corporation structure is hierarchical, that is it can be represented as a tree. Let's examine the presentation of this structure as follows:
* employee ::= name. | name:employee1,employee2, ... ,employeek.
* name ::= name of an employee
That is, the description of each employee consists of his name, a colon (:), the descriptions of all his subordinates separated by commas, and, finally, a dot. If an employee has no subordinates, then the colon is not present in his description.
For example, line MIKE:MAX.,ARTEM:MIKE..,DMITRY:DMITRY.,DMITRY... is the correct way of recording the structure of a corporation where the director MIKE has subordinates MAX, ARTEM and DMITRY. ARTEM has a subordinate whose name is MIKE, just as the name of his boss and two subordinates of DMITRY are called DMITRY, just like himself.
In the Beroil corporation every employee can only correspond with his subordinates, at that the subordinates are not necessarily direct. Let's call an uncomfortable situation the situation when a person whose name is s writes a letter to another person whose name is also s. In the example given above are two such pairs: a pair involving MIKE, and two pairs for DMITRY (a pair for each of his subordinates).
Your task is by the given structure of the corporation to find the number of uncomfortable pairs in it.
<image>
Input
The first and single line contains the corporation structure which is a string of length from 1 to 1000 characters. It is guaranteed that the description is correct. Every name is a string consisting of capital Latin letters from 1 to 10 symbols in length.
Output
Print a single number β the number of uncomfortable situations in the company.
Examples
Input
MIKE:MAX.,ARTEM:MIKE..,DMITRY:DMITRY.,DMITRY...
Output
3
Input
A:A..
Output
1
Input
A:C:C:C:C.....
Output
6 | def P():
n=a[0];a.pop(0);d={n:1};r=0
while a[0]!='.':
a.pop(0);l,t=P();r+=l
for k in t.keys():
d[k]=d.get(k,0)+t[k]
if k==n:r+=t[k]
a.pop(0)
return r,d
a=[]
x=''
for i in input():
if i in ':.,':
if x:a+=[x]
a+=[i];x=''
else:x+=i
print(P()[0]) | {
"input": [
"MIKE:MAX.,ARTEM:MIKE..,DMITRY:DMITRY.,DMITRY...\n",
"A:C:C:C:C.....\n",
"A:A..\n"
],
"output": [
"3\n",
"6\n",
"1\n"
]
} |
4,949 | 7 | Harry Potter and He-Who-Must-Not-Be-Named engaged in a fight to the death once again. This time they are located at opposite ends of the corridor of length l. Two opponents simultaneously charge a deadly spell in the enemy. We know that the impulse of Harry's magic spell flies at a speed of p meters per second, and the impulse of You-Know-Who's magic spell flies at a speed of q meters per second.
The impulses are moving through the corridor toward each other, and at the time of the collision they turn round and fly back to those who cast them without changing their original speeds. Then, as soon as the impulse gets back to it's caster, the wizard reflects it and sends again towards the enemy, without changing the original speed of the impulse.
Since Harry has perfectly mastered the basics of magic, he knows that after the second collision both impulses will disappear, and a powerful explosion will occur exactly in the place of their collision. However, the young wizard isn't good at math, so he asks you to calculate the distance from his position to the place of the second meeting of the spell impulses, provided that the opponents do not change positions during the whole fight.
Input
The first line of the input contains a single integer l (1 β€ l β€ 1 000) β the length of the corridor where the fight takes place.
The second line contains integer p, the third line contains integer q (1 β€ p, q β€ 500) β the speeds of magical impulses for Harry Potter and He-Who-Must-Not-Be-Named, respectively.
Output
Print a single real number β the distance from the end of the corridor, where Harry is located, to the place of the second meeting of the spell impulses. Your answer will be considered correct if its absolute or relative error will not exceed 10 - 4.
Namely: let's assume that your answer equals a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
100
50
50
Output
50
Input
199
60
40
Output
119.4
Note
In the first sample the speeds of the impulses are equal, so both of their meetings occur exactly in the middle of the corridor. | def f(ll):
l,p,q=ll
return l*p/(p+q)
l = [int(input()) for _ in range(3)]
print(f(l))
| {
"input": [
"199\n60\n40\n",
"100\n50\n50\n"
],
"output": [
"119.4",
"50"
]
} |
4,950 | 11 | A permutation of length n is an array containing each integer from 1 to n exactly once. For example, q = [4, 5, 1, 2, 3] is a permutation. For the permutation q the square of permutation is the permutation p that p[i] = q[q[i]] for each i = 1... n. For example, the square of q = [4, 5, 1, 2, 3] is p = q2 = [2, 3, 4, 5, 1].
This problem is about the inverse operation: given the permutation p you task is to find such permutation q that q2 = p. If there are several such q find any of them.
Input
The first line contains integer n (1 β€ n β€ 106) β the number of elements in permutation p.
The second line contains n distinct integers p1, p2, ..., pn (1 β€ pi β€ n) β the elements of permutation p.
Output
If there is no permutation q such that q2 = p print the number "-1".
If the answer exists print it. The only line should contain n different integers qi (1 β€ qi β€ n) β the elements of the permutation q. If there are several solutions print any of them.
Examples
Input
4
2 1 4 3
Output
3 4 2 1
Input
4
2 1 3 4
Output
-1
Input
5
2 3 4 5 1
Output
4 5 1 2 3 | import sys
#import random
from bisect import bisect_right as rb
from collections import deque
#sys.setrecursionlimit(10**8)
from queue import PriorityQueue
from math import *
input_ = lambda: sys.stdin.readline().strip("\r\n")
ii = lambda : int(input_())
il = lambda : list(map(int, input_().split()))
ilf = lambda : list(map(float, input_().split()))
ip = lambda : input_()
fi = lambda : float(input_())
ap = lambda ab,bc,cd : ab[bc].append(cd)
li = lambda : list(input_())
pr = lambda x : print(x)
prinT = lambda x : print(x)
f = lambda : sys.stdout.flush()
mod = 10**9 + 7
n = ii()
a = [0] + il()
def dfs (i) :
vis[i] = 1
g.append(i)
if (vis[a[i]] == 0) :
dfs(a[i])
g = []
d = {}
vis = [0 for i in range (n+2)]
ans = [0 for i in range (n+1)]
for i in range (1,n+1) :
if (vis[i] == 0) :
i1 = i
while True :
vis[i1] = 1
g.append(i1)
if (vis[a[i1]] == 0) :
i1 = a[i1]
else :
break
l = len(g)
if (l%2) :
x = (l+1)//2
for j in range (l) :
ans[g[j]] = g[(x+j)%l]
elif (d.get(l)) :
v = d[l]
for j in range (l) :
ans[g[j]] = v[(j+1)%l]
ans[v[j]] = g[j]
del d[l]
else :
d[l] = g
g = []
for i in d :
print(-1)
exit(0)
print(*ans[1:])
| {
"input": [
"4\n2 1 3 4\n",
"4\n2 1 4 3\n",
"5\n2 3 4 5 1\n"
],
"output": [
"-1\n",
"3 4 2 1 ",
"4 5 1 2 3\n"
]
} |
4,951 | 8 | After the piece of a devilish mirror hit the Kay's eye, he is no longer interested in the beauty of the roses. Now he likes to watch snowflakes.
Once upon a time, he found a huge snowflake that has a form of the tree (connected acyclic graph) consisting of n nodes. The root of tree has index 1. Kay is very interested in the structure of this tree.
After doing some research he formed q queries he is interested in. The i-th query asks to find a centroid of the subtree of the node vi. Your goal is to answer all queries.
Subtree of a node is a part of tree consisting of this node and all it's descendants (direct or not). In other words, subtree of node v is formed by nodes u, such that node v is present on the path from u to root.
Centroid of a tree (or a subtree) is a node, such that if we erase it from the tree, the maximum size of the connected component will be at least two times smaller than the size of the initial tree (or a subtree).
Input
The first line of the input contains two integers n and q (2 β€ n β€ 300 000, 1 β€ q β€ 300 000) β the size of the initial tree and the number of queries respectively.
The second line contains n - 1 integer p2, p3, ..., pn (1 β€ pi β€ n) β the indices of the parents of the nodes from 2 to n. Node 1 is a root of the tree. It's guaranteed that pi define a correct tree.
Each of the following q lines contain a single integer vi (1 β€ vi β€ n) β the index of the node, that define the subtree, for which we want to find a centroid.
Output
For each query print the index of a centroid of the corresponding subtree. If there are many suitable nodes, print any of them. It's guaranteed, that each subtree has at least one centroid.
Example
Input
7 4
1 1 3 3 5 3
1
2
3
5
Output
3
2
3
6
Note
<image>
The first query asks for a centroid of the whole tree β this is node 3. If we delete node 3 the tree will split in four components, two of size 1 and two of size 2.
The subtree of the second node consists of this node only, so the answer is 2.
Node 3 is centroid of its own subtree.
The centroids of the subtree of the node 5 are nodes 5 and 6 β both answers are considered correct. | def main():
import sys
E=sys.stdin
R=E.readline
n,q=map(int,R().split())
P=[0,0]+[int(i) for i in R().split()]
#n=q=300000
#P=[0]+list(range(n))
#exit()
C=[[]]
i=0
while i<n:
i+=1
C.append([])
i=2
j=len(P)
while i<j:
C[P[i]].append(i)
i+=1
i=Qi=0
W=[0]*(n+1)
S=[0]*(n+1)
Q=[0]*(n+1)
while i<n:
i+=1
W[i]=len(C[i])
if W[i]==0:
Q[Qi]=i
Qi+=1
A=[0]*(n+1)
while Qi:
Qi-=1
x=Q[Qi]
S[x]+=1
if P[x]:
y=P[x]
S[y]+=S[x]
W[y]-=1
if W[y]==0:
Q[Qi]=y
Qi+=1
a=S[x]>>1
A[x]=x
for z in C[x]:
if S[z]>a:
A[x]=A[z]
b=S[x]-S[A[x]]
while b>a:
A[x]=P[A[x]]
b=S[x]-S[A[x]]
break
while q:
q-=1
sys.stdout.write(str(A[int(R())])+'\n')
main()
| {
"input": [
"7 4\n1 1 3 3 5 3\n1\n2\n3\n5\n"
],
"output": [
"3\n2\n3\n5\n"
]
} |
4,952 | 7 | You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 β€ |s| β€ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 β€ i β€ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti. | def dowhatever(s,si,ei):
r=s[:si-1]
if si>ei:
r+='z'
else:
r=s[:si]
for i in range(si,ei+1):
r+=(chr(ord(s[i])-1))
r+=s[ei+1:]
print(r)
s=input()
n=len(s)
i=0
while i<n and s[i]=='a':
i+=1
si=i
while i<n and s[i]!='a':
i+=1
ei=i-1
dowhatever(s,si,ei) | {
"input": [
"codeforces\n",
"abacaba\n"
],
"output": [
"bncdenqbdr",
"aaacaba"
]
} |
4,953 | 10 | One tradition of welcoming the New Year is launching fireworks into the sky. Usually a launched firework flies vertically upward for some period of time, then explodes, splitting into several parts flying in different directions. Sometimes those parts also explode after some period of time, splitting into even more parts, and so on.
Limak, who lives in an infinite grid, has a single firework. The behaviour of the firework is described with a recursion depth n and a duration for each level of recursion t1, t2, ..., tn. Once Limak launches the firework in some cell, the firework starts moving upward. After covering t1 cells (including the starting cell), it explodes and splits into two parts, each moving in the direction changed by 45 degrees (see the pictures below for clarification). So, one part moves in the top-left direction, while the other one moves in the top-right direction. Each part explodes again after covering t2 cells, splitting into two parts moving in directions again changed by 45 degrees. The process continues till the n-th level of recursion, when all 2n - 1 existing parts explode and disappear without creating new parts. After a few levels of recursion, it's possible that some parts will be at the same place and at the same time β it is allowed and such parts do not crash.
Before launching the firework, Limak must make sure that nobody stands in cells which will be visited at least once by the firework. Can you count the number of those cells?
Input
The first line of the input contains a single integer n (1 β€ n β€ 30) β the total depth of the recursion.
The second line contains n integers t1, t2, ..., tn (1 β€ ti β€ 5). On the i-th level each of 2i - 1 parts will cover ti cells before exploding.
Output
Print one integer, denoting the number of cells which will be visited at least once by any part of the firework.
Examples
Input
4
4 2 2 3
Output
39
Input
6
1 1 1 1 1 3
Output
85
Input
1
3
Output
3
Note
For the first sample, the drawings below show the situation after each level of recursion. Limak launched the firework from the bottom-most red cell. It covered t1 = 4 cells (marked red), exploded and divided into two parts (their further movement is marked green). All explosions are marked with an 'X' character. On the last drawing, there are 4 red, 4 green, 8 orange and 23 pink cells. So, the total number of visited cells is 4 + 4 + 8 + 23 = 39.
<image>
For the second sample, the drawings below show the situation after levels 4, 5 and 6. The middle drawing shows directions of all parts that will move in the next level.
<image> | dr = [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]]
n = int(input())
t = [int(i) for i in input().split()]
visited = set()
N = 150*2 + 10
covers = [[0]*N for i in range(N)]
def dfs(d, pos, path):
mem = (d, pos, path)
if mem in visited:
return set()
else:
visited.add(mem)
if d == n+1:
return
for _ in range(t[d-1]):
pos = (pos[0] + dr[path][0], pos[1] + dr[path][1])
covers[pos[0]][pos[1]] = 1
dfs(d+1, pos, (path+1) % 8)
dfs(d+1, pos, (path-1) % 8)
dfs(1, (int(N/2), int(N/2)), 0)
print(sum([sum(i) for i in covers]))
| {
"input": [
"6\n1 1 1 1 1 3\n",
"1\n3\n",
"4\n4 2 2 3\n"
],
"output": [
"85\n",
"3\n",
"39\n"
]
} |
4,954 | 8 | A new pack of n t-shirts came to a shop. Each of the t-shirts is characterized by three integers pi, ai and bi, where pi is the price of the i-th t-shirt, ai is front color of the i-th t-shirt and bi is back color of the i-th t-shirt. All values pi are distinct, and values ai and bi are integers from 1 to 3.
m buyers will come to the shop. Each of them wants to buy exactly one t-shirt. For the j-th buyer we know his favorite color cj.
A buyer agrees to buy a t-shirt, if at least one side (front or back) is painted in his favorite color. Among all t-shirts that have colors acceptable to this buyer he will choose the cheapest one. If there are no such t-shirts, the buyer won't buy anything. Assume that the buyers come one by one, and each buyer is served only after the previous one is served.
You are to compute the prices each buyer will pay for t-shirts.
Input
The first line contains single integer n (1 β€ n β€ 200 000) β the number of t-shirts.
The following line contains sequence of integers p1, p2, ..., pn (1 β€ pi β€ 1 000 000 000), where pi equals to the price of the i-th t-shirt.
The following line contains sequence of integers a1, a2, ..., an (1 β€ ai β€ 3), where ai equals to the front color of the i-th t-shirt.
The following line contains sequence of integers b1, b2, ..., bn (1 β€ bi β€ 3), where bi equals to the back color of the i-th t-shirt.
The next line contains single integer m (1 β€ m β€ 200 000) β the number of buyers.
The following line contains sequence c1, c2, ..., cm (1 β€ cj β€ 3), where cj equals to the favorite color of the j-th buyer. The buyers will come to the shop in the order they are given in the input. Each buyer is served only after the previous one is served.
Output
Print to the first line m integers β the j-th integer should be equal to the price of the t-shirt which the j-th buyer will buy. If the j-th buyer won't buy anything, print -1.
Examples
Input
5
300 200 400 500 911
1 2 1 2 3
2 1 3 2 1
6
2 3 1 2 1 1
Output
200 400 300 500 911 -1
Input
2
1000000000 1
1 1
1 2
2
2 1
Output
1 1000000000 | n, c, v = int(input()), [0] * 4, []
def adv():
for i in range(1, 4):
while c[i] < n and (a[c[i]][0] == -1 or i not in a[c[i]][1:]):
c[i] += 1
a = sorted([x, y, z] for x, y, z in zip(map(int, input().split()), map(int, input().split()), map(int, input().split())))
adv()
m = int(input())
for x in map(int, input().split()):
if c[x] == n:
v.append(-1)
else:
v.append(a[c[x]][0])
a[c[x]][0] = -1
c[x] += 1
adv()
print(' '.join(map(str, v))) | {
"input": [
"5\n300 200 400 500 911\n1 2 1 2 3\n2 1 3 2 1\n6\n2 3 1 2 1 1\n",
"2\n1000000000 1\n1 1\n1 2\n2\n2 1\n"
],
"output": [
"200 400 300 500 911 -1 \n",
"1 1000000000 \n"
]
} |
4,955 | 8 | Some time ago Mister B detected a strange signal from the space, which he started to study.
After some transformation the signal turned out to be a permutation p of length n or its cyclic shift. For the further investigation Mister B need some basis, that's why he decided to choose cyclic shift of this permutation which has the minimum possible deviation.
Let's define the deviation of a permutation p as <image>.
Find a cyclic shift of permutation p with minimum possible deviation. If there are multiple solutions, print any of them.
Let's denote id k (0 β€ k < n) of a cyclic shift of permutation p as the number of right shifts needed to reach this shift, for example:
* k = 0: shift p1, p2, ... pn,
* k = 1: shift pn, p1, ... pn - 1,
* ...,
* k = n - 1: shift p2, p3, ... pn, p1.
Input
First line contains single integer n (2 β€ n β€ 106) β the length of the permutation.
The second line contains n space-separated integers p1, p2, ..., pn (1 β€ pi β€ n) β the elements of the permutation. It is guaranteed that all elements are distinct.
Output
Print two integers: the minimum deviation of cyclic shifts of permutation p and the id of such shift. If there are multiple solutions, print any of them.
Examples
Input
3
1 2 3
Output
0 0
Input
3
2 3 1
Output
0 1
Input
3
3 2 1
Output
2 1
Note
In the first sample test the given permutation p is the identity permutation, that's why its deviation equals to 0, the shift id equals to 0 as well.
In the second sample test the deviation of p equals to 4, the deviation of the 1-st cyclic shift (1, 2, 3) equals to 0, the deviation of the 2-nd cyclic shift (3, 1, 2) equals to 4, the optimal is the 1-st cyclic shift.
In the third sample test the deviation of p equals to 4, the deviation of the 1-st cyclic shift (1, 3, 2) equals to 2, the deviation of the 2-nd cyclic shift (2, 1, 3) also equals to 2, so the optimal are both 1-st and 2-nd cyclic shifts. | def main():
n = int(input())
data = input().split()
#print(str(n) + " " + str(data))
data = list(map(lambda x: int(x), data))
res = 0
ires = 0
neg = 0
when = [0] * n
for i in range(n):
data[i] = i + 1 - data[i]
res += abs(data[i])
if data[i] <= 0:
neg += 1
a = -data[i]
if a < 0:
a = a + n
when[a] += 1
#print(when)
ares = res
#print(str(res) + " " + str(ires) + " " + str(neg))
for i in range(n):
neg -= when[i]
ares -= neg
ares += (n - neg)
x = data[n - i - 1] + i + 1
ares -= x
ares += n - x
#print(str(res) + " " + str(ires) + " " + str(ares) + " " + str(i) + " " + str(neg))
neg += 1
if ares < res:
res = ares
ires = i + 1
print(str(res) + " " + str(ires))
main()
| {
"input": [
"3\n1 2 3\n",
"3\n3 2 1\n",
"3\n2 3 1\n"
],
"output": [
"0 0\n",
"2 1\n",
"0 1\n"
]
} |
4,956 | 8 | It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 β€ N β€ 105, 1 β€ S β€ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 β€ si β€ 105, 1 β€ ai β€ 105, 1 β€ bi β€ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3Β·5 + 4Β·6 + 5Β·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3Β·7 + 4Β·7 + 5Β·5 = 74. | f = lambda: map(int, input().split())
n, s = f()
u, v = [], []
for i in range(n):
d, a, b = f()
if a > b:
u.append([a, b, d])
else:
v.append([b, a, d])
def g(t):
t.sort(key=lambda q: q[1] - q[0])
m = sum(d for a, b, d in t)
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, d in t:
if k >= d:
k -= d
z += d * a
elif k:
z += k * a
x = (d - k) * a
y = (d - k) * b
k = 0
else:
x += d * a
y += d * b
return x, y, z, n
a, b = g(u), g(v)
d = a[0] + b[0] if a[3] + b[3] > s else max(a[0] + b[1], a[1] + b[0])
print(a[2] + b[2] + d) | {
"input": [
"3 12\n3 5 7\n4 6 7\n5 9 5\n",
"6 10\n7 4 7\n5 8 8\n12 5 8\n6 11 6\n3 3 7\n5 9 6\n"
],
"output": [
"84\n",
"314\n"
]
} |
4,957 | 8 | You are given an array a with n distinct integers. Construct an array b by permuting a such that for every non-empty subset of indices S = {x1, x2, ..., xk} (1 β€ xi β€ n, 0 < k < n) the sums of elements on that positions in a and b are different, i. e.
<image>
Input
The first line contains one integer n (1 β€ n β€ 22) β the size of the array.
The second line contains n space-separated distinct integers a1, a2, ..., an (0 β€ ai β€ 109) β the elements of the array.
Output
If there is no such array b, print -1.
Otherwise in the only line print n space-separated integers b1, b2, ..., bn. Note that b must be a permutation of a.
If there are multiple answers, print any of them.
Examples
Input
2
1 2
Output
2 1
Input
4
1000 100 10 1
Output
100 1 1000 10
Note
An array x is a permutation of y, if we can shuffle elements of y such that it will coincide with x.
Note that the empty subset and the subset containing all indices are not counted. | def solve():
n=int(input())
a=list(map(int,input().split()))
b=sorted(a)+[min(a)]
for i in range(n):
a[i]=str(b[b.index(a[i])+1])
print(' '.join(a))
return
solve()
| {
"input": [
"4\n1000 100 10 1\n",
"2\n1 2\n"
],
"output": [
"1 1000 100 10 ",
"2 1 "
]
} |
4,958 | 11 | You are given a boolean function of three variables which is defined by its truth table. You need to find an expression of minimum length that equals to this function. The expression may consist of:
* Operation AND ('&', ASCII code 38)
* Operation OR ('|', ASCII code 124)
* Operation NOT ('!', ASCII code 33)
* Variables x, y and z (ASCII codes 120-122)
* Parentheses ('(', ASCII code 40, and ')', ASCII code 41)
If more than one expression of minimum length exists, you should find the lexicographically smallest one.
Operations have standard priority. NOT has the highest priority, then AND goes, and OR has the lowest priority. The expression should satisfy the following grammar:
E ::= E '|' T | T
T ::= T '&' F | F
F ::= '!' F | '(' E ')' | 'x' | 'y' | 'z'
Input
The first line contains one integer n β the number of functions in the input (1 β€ n β€ 10 000).
The following n lines contain descriptions of functions, the i-th of them contains a string of length 8 that consists of digits 0 and 1 β the truth table of the i-th function. The digit on position j (0 β€ j < 8) equals to the value of the function in case of <image>, <image> and <image>.
Output
You should output n lines, the i-th line should contain the expression of minimum length which equals to the i-th function. If there is more than one such expression, output the lexicographically smallest of them. Expressions should satisfy the given grammar and shouldn't contain white spaces.
Example
Input
4
00110011
00000111
11110000
00011111
Output
y
(y|z)&x
!x
x|y&z
Note
The truth table for the second function:
<image> | table = "!x&x x&y&z !z&x&y x&y !y&x&z x&z !y&x&z|!z&x&y (y|z)&x !y&!z&x !y&!z&x|x&y&z !z&x !z&x|x&y !y&x !y&x|x&z !(y&z)&x x !x&y&z y&z !x&y&z|!z&x&y (x|z)&y !x&y&z|!y&x&z (x|y)&z !x&y&z|!y&x&z|!z&x&y (x|y)&z|x&y !x&y&z|!y&!z&x !y&!z&x|y&z !x&y&z|!z&x !z&x|y&z !x&y&z|!y&x !y&x|y&z !(y&z)&x|!x&y&z x|y&z !x&!z&y !x&!z&y|x&y&z !z&y !z&y|x&y !x&!z&y|!y&x&z !x&!z&y|x&z !y&x&z|!z&y !z&y|x&z !(!x&!y|x&y|z) !(!x&!y|x&y|z)|x&y&z !z&(x|y) !z&(x|y)|x&y !x&!z&y|!y&x !x&!z&y|!y&x|x&z !y&x|!z&y !z&y|x !x&y !x&y|y&z !(x&z)&y y !x&y|!y&x&z !x&y|x&z !(x&z)&y|!y&x&z x&z|y !x&y|!y&!z&x !x&y|!y&!z&x|y&z !x&y|!z&x !z&x|y !x&y|!y&x !x&y|!y&x|x&z !(x&z)&y|!y&x x|y !x&!y&z !x&!y&z|x&y&z !x&!y&z|!z&x&y !x&!y&z|x&y !y&z !y&z|x&z !y&z|!z&x&y !y&z|x&y !(!x&!z|x&z|y) !(!x&!z|x&z|y)|x&y&z !x&!y&z|!z&x !x&!y&z|!z&x|x&y !y&(x|z) !y&(x|z)|x&z !y&z|!z&x !y&z|x !x&z !x&z|y&z !x&z|!z&x&y !x&z|x&y !(x&y)&z z !(x&y)&z|!z&x&y x&y|z !x&z|!y&!z&x !x&z|!y&!z&x|y&z !x&z|!z&x !x&z|!z&x|x&y !x&z|!y&x !y&x|z !(x&y)&z|!z&x x|z !(!y&!z|x|y&z) !(!y&!z|x|y&z)|x&y&z !x&!y&z|!z&y !x&!y&z|!z&y|x&y !x&!z&y|!y&z !x&!z&y|!y&z|x&z !y&z|!z&y !y&z|!z&y|x&y !(!x&!y|x&y|z)|!x&!y&z !(!x&!y|x&y|z)|!x&!y&z|x&y&z !x&!y&z|!z&(x|y) !x&!y&z|!z&(x|y)|x&y !x&!z&y|!y&(x|z) !x&!z&y|!y&(x|z)|x&z !y&(x|z)|!z&y !y&z|!z&y|x !x&(y|z) !x&(y|z)|y&z !x&z|!z&y !x&z|y !x&y|!y&z !x&y|z !(x&y)&z|!z&y y|z !x&(y|z)|!y&!z&x !x&(y|z)|!y&!z&x|y&z !x&(y|z)|!z&x !x&z|!z&x|y !x&(y|z)|!y&x !x&y|!y&x|z !x&y|!y&z|!z&x x|y|z !(x|y|z) !(x|y|z)|x&y&z !(!x&y|!y&x|z) !(x|y|z)|x&y !(!x&z|!z&x|y) !(x|y|z)|x&z !(!x&y|!y&x|z)|!y&x&z !(x|y|z)|(y|z)&x !y&!z !y&!z|x&y&z !(!x&y|z) !y&!z|x&y !(!x&z|y) !y&!z|x&z !(!x&y|z)|!y&x !y&!z|x !(!y&z|!z&y|x) !(x|y|z)|y&z !(!x&y|!y&x|z)|!x&y&z !(x|y|z)|(x|z)&y !(!x&z|!z&x|y)|!x&y&z !(x|y|z)|(x|y)&z !(!x&y|!y&x|z)|!x&y&z|!y&x&z !(x|y|z)|(x|y)&z|x&y !x&y&z|!y&!z !y&!z|y&z !(!x&y|z)|!x&y&z !(!x&y|z)|y&z !(!x&z|y)|!x&y&z !(!x&z|y)|y&z !(!x&y|z)|!x&y&z|!y&x !y&!z|x|y&z !x&!z !x&!z|x&y&z !(!y&x|z) !x&!z|x&y !x&!z|!y&x&z !x&!z|x&z !(!y&x|z)|!y&x&z !(!y&x|z)|x&z !(x&y|z) !(x&y|z)|x&y&z !z !z|x&y !x&!z|!y&x !(x&y|z)|x&z !y&x|!z !z|x !(!y&z|x) !x&!z|y&z !(!y&x|z)|!x&y !x&!z|y !(!y&z|x)|!y&x&z !(!y&z|x)|x&z !(!y&x|z)|!x&y|!y&x&z !x&!z|x&z|y !x&y|!y&!z !(x&y|z)|y&z !x&y|!z !z|y !(!x&!y&z|x&y) !x&!z|!y&x|y&z !x&y|!y&x|!z !z|x|y !x&!y !x&!y|x&y&z !x&!y|!z&x&y !x&!y|x&y !(!z&x|y) !x&!y|x&z !(!z&x|y)|!z&x&y !(!z&x|y)|x&y !(x&z|y) !(x&z|y)|x&y&z !x&!y|!z&x !(x&z|y)|x&y !y !y|x&z !y|!z&x !y|x !(!z&y|x) !x&!y|y&z !(!z&y|x)|!z&x&y !(!z&y|x)|x&y !(!z&x|y)|!x&z !x&!y|z !(!z&x|y)|!x&z|!z&x&y !x&!y|x&y|z !x&z|!y&!z !(x&z|y)|y&z !(!x&!z&y|x&z) !x&!y|!z&x|y&z !x&z|!y !y|z !x&z|!y|!z&x !y|x|z !(x|y&z) !(x|y&z)|x&y&z !x&!y|!z&y !(x|y&z)|x&y !x&!z|!y&z !(x|y&z)|x&z !(!y&!z&x|y&z) !x&!y|!z&y|x&z !((x|y)&z|x&y) !((x|y)&z|x&y)|x&y&z !x&!y|!z !x&!y|!z|x&y !x&!z|!y !x&!z|!y|x&z !y|!z !y|!z|x !x !x|y&z !x|!z&y !x|y !x|!y&z !x|z !x|!y&z|!z&y !x|y|z !x|!y&!z !x|!y&!z|y&z !x|!z !x|!z|y !x|!y !x|!y|z !(x&y&z) !x|x".split()
n = int(input())
for i in range(n):
print(table[int(input(), 2)])
exit(0)
E = set()
T = set()
F = set('xyz')
prv = 0
x = int('00001111', 2)
y = int('00110011', 2)
z = int('01010101', 2)
fam = 2 ** 8
tmpl = '#' * 99
ans = [tmpl] * fam
def cmpr(E):
global ans
ans = [tmpl] * fam
for e in E:
res = eval(e.replace('!', '~')) & (fam - 1)
if len(ans[res]) > len(e) or len(ans[res]) == len(e) and ans[res] > e:
ans[res] = e
return set(ans) - {tmpl}
def cmpr3(E, T, F):
return cmpr(E), cmpr(T), cmpr(F)
while prv != (E, T, F):
prv = E.copy(), T.copy(), F.copy()
for f in prv[2]:
F.add('!' + f)
T.add(f)
for t in prv[1]:
T.add(t + '&' + f)
for t in prv[1]:
E.add(t)
for e in prv[0]:
if e not in F:
F.add('(' + e + ')')
for t in prv[1]:
E.add(e + '|' + t)
E, T, F = cmpr3(E, T, F)
cmpr(E)
for f in ans:
print(f)
print(ans.count(tmpl), fam - ans.count(tmpl)) | {
"input": [
"4\n00110011\n00000111\n11110000\n00011111\n"
],
"output": [
"y\n(y|z)&x\n!x\nx|y&z\n"
]
} |
4,959 | 11 | Ancient Egyptians are known to have understood difficult concepts in mathematics. The ancient Egyptian mathematician Ahmes liked to write a kind of arithmetic expressions on papyrus paper which he called as Ahmes arithmetic expression.
An Ahmes arithmetic expression can be defined as:
* "d" is an Ahmes arithmetic expression, where d is a one-digit positive integer;
* "(E1 op E2)" is an Ahmes arithmetic expression, where E1 and E2 are valid Ahmes arithmetic expressions (without spaces) and op is either plus ( + ) or minus ( - ).
For example 5, (1-1) and ((1+(2-3))-5) are valid Ahmes arithmetic expressions.
On his trip to Egypt, Fafa found a piece of papyrus paper having one of these Ahmes arithmetic expressions written on it. Being very ancient, the papyrus piece was very worn out. As a result, all the operators were erased, keeping only the numbers and the brackets. Since Fafa loves mathematics, he decided to challenge himself with the following task:
Given the number of plus and minus operators in the original expression, find out the maximum possible value for the expression on the papyrus paper after putting the plus and minus operators in the place of the original erased operators.
Input
The first line contains a string E (1 β€ |E| β€ 104) β a valid Ahmes arithmetic expression. All operators are erased and replaced with '?'.
The second line contains two space-separated integers P and M (0 β€ min(P, M) β€ 100) β the number of plus and minus operators, respectively.
It is guaranteed that P + M = the number of erased operators.
Output
Print one line containing the answer to the problem.
Examples
Input
(1?1)
1 0
Output
2
Input
(2?(1?2))
1 1
Output
1
Input
((1?(5?7))?((6?2)?7))
3 2
Output
18
Input
((1?(5?7))?((6?2)?7))
2 3
Output
16
Note
* The first sample will be (1 + 1) = 2.
* The second sample will be (2 + (1 - 2)) = 1.
* The third sample will be ((1 - (5 - 7)) + ((6 + 2) + 7)) = 18.
* The fourth sample will be ((1 + (5 + 7)) - ((6 - 2) - 7)) = 16. | from math import inf
class Node:
def __init__(self, parent = None, leftExp = None, rightExp = None, signQ = 0):
self.parent, self.leftExp, self.rightExp, self.signQ = parent, leftExp, rightExp, signQ
def __str__(self):
return "Node"
memo = {}
def Memoize(node, p, maxValue, minValue):
if not node in memo:
memo.update({node : {p : [maxValue, minValue]} })
else:
memo[node].update({p : [maxValue, minValue]})
def ExpMaxValue(root: Node, p):
m = root.signQ - p
"""if root.signQ == 1:
if p == 1:
return [root.leftExp.value + root.rightExp.value, root.leftExp.value + root.rightExp.value]
else:
return [root.leftExp.value - root.rightExp.value, root.leftExp.value - root.rightExp.value]"""
if root.signQ == 0:
return [root.value, root.value]
if root in memo:
if p in memo[root]:
return memo[root][p]
if m == 0:
value = ExpMaxValue(root.leftExp, root.leftExp.signQ)[0] + ExpMaxValue(root.rightExp, root.rightExp.signQ)[0]
Memoize(root, p, value, value)
return [value, value]
if p == 0:
value = ExpMaxValue(root.leftExp, 0)[0] - ExpMaxValue(root.rightExp, 0)[0]
Memoize(root, p, value, value)
return [value, value]
maxValue = -inf
minValue = inf
if m >= p:
for pQMid in range(2):
pQLeftMin = min(p - pQMid, root.leftExp.signQ)
for pQLeft in range(pQLeftMin + 1):
if root.leftExp.signQ - pQLeft + (1 - pQMid) > m:
continue
resLeft = ExpMaxValue(root.leftExp, pQLeft)
resRight = ExpMaxValue(root.rightExp, p - pQMid - pQLeft)
if pQMid == 1:
maxValue = max(resLeft[0] + resRight[0], maxValue)
minValue = min(resLeft[1] + resRight[1], minValue)
else:
maxValue = max(resLeft[0] - resRight[1], maxValue)
minValue = min(resLeft[1] - resRight[0], minValue)
else:
for mQMid in range(2):
mQLeftMin = min(m - mQMid, root.leftExp.signQ)
for mQLeft in range(mQLeftMin + 1):
pQLeft = root.leftExp.signQ - mQLeft
if pQLeft + (1 - mQMid) > p:
continue
resLeft = ExpMaxValue(root.leftExp, pQLeft)
resRight = ExpMaxValue(root.rightExp, p - (1 - mQMid) - pQLeft)
if mQMid == 0:
maxValue = max(resLeft[0] + resRight[0], maxValue)
minValue = min(resLeft[1] + resRight[1], minValue)
else:
maxValue = max(resLeft[0] - resRight[1], maxValue)
minValue = min(resLeft[1] - resRight[0], minValue)
Memoize(root, p, int(maxValue), int(minValue))
return [int(maxValue), int(minValue)]
def PrintNodes(root: Node):
if root.signQ != 0:
leftExp = root.leftExp if root.leftExp.signQ != 0 else root.leftExp.value
rightExp = root.rightExp if root.rightExp.signQ != 0 else root.rightExp.value
check = root.signQ == root.leftExp.signQ + root.rightExp.signQ + 1
print(root.signQ, root.parent, leftExp, rightExp, check)
PrintNodes(root.leftExp)
PrintNodes(root.rightExp)
def main():
exp = str(input())
if len(exp) == 1:
print(exp)
return
#root = Node(None, None, None)
#root.parent = root
cNode = Node()
isRight = False
for i in range(1, len(exp) - 1):
if exp[i] == '(':
if not isRight:
cNode.leftExp = Node(cNode)
cNode = cNode.leftExp
else:
cNode.rightExp = Node(cNode)
cNode = cNode.rightExp
isRight = False
elif exp[i] == '?':
isRight = True
cNode.signQ += 1
elif exp[i] == ')':
if cNode.parent != None:
cNode.parent.signQ += cNode.signQ
cNode = cNode.parent
isRight = False
else:
if not isRight:
cNode.leftExp = Node(cNode)
cNode.leftExp.value = int(exp[i])
else:
cNode.rightExp = Node(cNode)
cNode.rightExp.value = int(exp[i])
#PrintNodes(cNode)
ss = str(input()).split()
p, m = int(ss[0]), int(ss[1])
print(ExpMaxValue(cNode, p)[0])
main() | {
"input": [
"((1?(5?7))?((6?2)?7))\n3 2\n",
"(1?1)\n1 0\n",
"((1?(5?7))?((6?2)?7))\n2 3\n",
"(2?(1?2))\n1 1\n"
],
"output": [
"18",
"2",
"16",
"1"
]
} |
4,960 | 10 | You are given n points on Cartesian plane. Every point is a lattice point (i. e. both of its coordinates are integers), and all points are distinct.
You may draw two straight lines (not necessarily distinct). Is it possible to do this in such a way that every point lies on at least one of these lines?
Input
The first line contains one integer n (1 β€ n β€ 105) β the number of points you are given.
Then n lines follow, each line containing two integers xi and yi (|xi|, |yi| β€ 109)β coordinates of i-th point. All n points are distinct.
Output
If it is possible to draw two straight lines in such a way that each of given points belongs to at least one of these lines, print YES. Otherwise, print NO.
Examples
Input
5
0 0
0 1
1 1
1 -1
2 2
Output
YES
Input
5
0 0
1 0
2 1
1 1
2 3
Output
NO
Note
In the first example it is possible to draw two lines, the one containing the points 1, 3 and 5, and another one containing two remaining points.
<image> | n = int(input())
p = [list(map(int, input().split())) for _ in range(n)]
f = lambda a, b, c: (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])
def g(fi, se, p):
q = []
for x in p:
if f(fi, se, x):
if len(q) < 2:
q.append(x)
else:
if f(q[0], q[1], x):
return 1
return 0
print('NO' if n > 4 and all([g(p[0], p[1], p), g(p[0], p[2], p), g(p[1], p[2], p)]) else 'YES')
| {
"input": [
"5\n0 0\n0 1\n1 1\n1 -1\n2 2\n",
"5\n0 0\n1 0\n2 1\n1 1\n2 3\n"
],
"output": [
"YES\n",
"NO\n"
]
} |
4,961 | 9 | As the boat drifts down the river, a wood full of blossoms shows up on the riverfront.
"I've been here once," Mino exclaims with delight, "it's breathtakingly amazing."
"What is it like?"
"Look, Kanno, you've got your paintbrush, and I've got my words. Have a try, shall we?"
There are four kinds of flowers in the wood, Amaranths, Begonias, Centaureas and Dianthuses.
The wood can be represented by a rectangular grid of n rows and m columns. In each cell of the grid, there is exactly one type of flowers.
According to Mino, the numbers of connected components formed by each kind of flowers are a, b, c and d respectively. Two cells are considered in the same connected component if and only if a path exists between them that moves between cells sharing common edges and passes only through cells containing the same flowers.
You are to help Kanno depict such a grid of flowers, with n and m arbitrarily chosen under the constraints given below. It can be shown that at least one solution exists under the constraints of this problem.
Note that you can choose arbitrary n and m under the constraints below, they are not given in the input.
Input
The first and only line of input contains four space-separated integers a, b, c and d (1 β€ a, b, c, d β€ 100) β the required number of connected components of Amaranths, Begonias, Centaureas and Dianthuses, respectively.
Output
In the first line, output two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and the number of columns in the grid respectively.
Then output n lines each consisting of m consecutive English letters, representing one row of the grid. Each letter should be among 'A', 'B', 'C' and 'D', representing Amaranths, Begonias, Centaureas and Dianthuses, respectively.
In case there are multiple solutions, print any. You can output each letter in either case (upper or lower).
Examples
Input
5 3 2 1
Output
4 7
DDDDDDD
DABACAD
DBABACD
DDDDDDD
Input
50 50 1 1
Output
4 50
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
ABABABABABABABABABABABABABABABABABABABABABABABABAB
BABABABABABABABABABABABABABABABABABABABABABABABABA
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
Input
1 6 4 5
Output
7 7
DDDDDDD
DDDBDBD
DDCDCDD
DBDADBD
DDCDCDD
DBDBDDD
DDDDDDD
Note
In the first example, each cell of Amaranths, Begonias and Centaureas forms a connected component, while all the Dianthuses form one.
<image> | quotas = [int(x) - 1 for x in input().split()]
grid = [['a'] * 50 for _ in range(12)] + \
[['b'] * 50 for _ in range(12)] + \
[['c'] * 50 for _ in range(12)] + \
[['d'] * 50 for _ in range(12)]
def poke(row, f_idx):
for i in range(row + 1, row + 12, 2):
for j in range(1, 50, 2):
if quotas[f_idx] > 0:
grid[i][j] = chr(ord('a') + f_idx)
quotas[f_idx] -= 1
poke(0, 3)
poke(12, 2)
poke(24, 1)
poke(36, 0)
print('48 50')
print('\n'.join([''.join(row) for row in grid]))
| {
"input": [
"5 3 2 1\n",
"1 6 4 5\n",
"50 50 1 1\n"
],
"output": [
"50 50\nAAAAAAAAAAAAAAAAAAAAAAAAACBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nBCBCCCCCCCCCCCCCCCCCCCCCCADADADADDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\n",
"50 50\nDADADADAAAAAAAAAAAAAAAAAACBCBCBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nBCBCBCBCBCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\n",
"50 50\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nABABABABABABABABABABABABABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nABABABABABABABABABABABABABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nABABABABABABABABABABABABABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nABABABABABABABABABABABABABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nABAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBB\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDADADADADADADADADADADADAD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDADADADADADADADADADADADAD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDADADADADADADADADADADADAD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDADADADADADADADADADADADAD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDADDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\nCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDD\n"
]
} |
4,962 | 8 | You are given two strings s and t. Both strings have length n and consist of lowercase Latin letters. The characters in the strings are numbered from 1 to n.
You can successively perform the following move any number of times (possibly, zero):
* swap any two adjacent (neighboring) characters of s (i.e. for any i = \{1, 2, ..., n - 1\} you can swap s_i and s_{i + 1}).
You can't apply a move to the string t. The moves are applied to the string s one after another.
Your task is to obtain the string t from the string s. Find any way to do it with at most 10^4 such moves.
You do not have to minimize the number of moves, just find any sequence of moves of length 10^4 or less to transform s into t.
Input
The first line of the input contains one integer n (1 β€ n β€ 50) β the length of strings s and t.
The second line of the input contains the string s consisting of n lowercase Latin letters.
The third line of the input contains the string t consisting of n lowercase Latin letters.
Output
If it is impossible to obtain the string t using moves, print "-1".
Otherwise in the first line print one integer k β the number of moves to transform s to t. Note that k must be an integer number between 0 and 10^4 inclusive.
In the second line print k integers c_j (1 β€ c_j < n), where c_j means that on the j-th move you swap characters s_{c_j} and s_{c_j + 1}.
If you do not need to apply any moves, print a single integer 0 in the first line and either leave the second line empty or do not print it at all.
Examples
Input
6
abcdef
abdfec
Output
4
3 5 4 5
Input
4
abcd
accd
Output
-1
Note
In the first example the string s changes as follows: "abcdef" β "abdcef" β "abdcfe" β "abdfce" β "abdfec".
In the second example there is no way to transform the string s into the string t through any allowed moves. | def find(i):
a = t[i]
while i != n and s[i] != a:
i += 1
if i == n:
print(-1)
raise SystemExit()
return i
n = int(input())
s = [i for i in input()]
t = [i for i in input()]
ans = []
for i in range(n):
it = find(i)
while it != i:
s[it], s[it - 1] = s[it - 1], s[it]
ans.append(it)
it -= 1
print(len(ans))
print(*ans)
| {
"input": [
"4\nabcd\naccd\n",
"6\nabcdef\nabdfec\n"
],
"output": [
"-1",
"4\n3 5 4 5 "
]
} |
4,963 | 8 | You came to the exhibition and one exhibit has drawn your attention. It consists of n stacks of blocks, where the i-th stack consists of a_i blocks resting on the surface.
The height of the exhibit is equal to m. Consequently, the number of blocks in each stack is less than or equal to m.
There is a camera on the ceiling that sees the top view of the blocks and a camera on the right wall that sees the side view of the blocks.
<image>
Find the maximum number of blocks you can remove such that the views for both the cameras would not change.
Note, that while originally all blocks are stacked on the floor, it is not required for them to stay connected to the floor after some blocks are removed. There is no gravity in the whole exhibition, so no block would fall down, even if the block underneath is removed. It is not allowed to move blocks by hand either.
Input
The first line contains two integers n and m (1 β€ n β€ 100 000, 1 β€ m β€ 10^9) β the number of stacks and the height of the exhibit.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ m) β the number of blocks in each stack from left to right.
Output
Print exactly one integer β the maximum number of blocks that can be removed.
Examples
Input
5 6
3 3 3 3 3
Output
10
Input
3 5
1 2 4
Output
3
Input
5 5
2 3 1 4 4
Output
9
Input
1 1000
548
Output
0
Input
3 3
3 1 1
Output
1
Note
The following pictures illustrate the first example and its possible solution.
Blue cells indicate removed blocks. There are 10 blue cells, so the answer is 10.
<image> |
# Main
def run():
n, mmm = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
ans = 0
for i in range(n):
if arr[i] > ans:
ans += 1
left = arr[n-1] - ans
sol = sum(arr) - n - left
print(sol)
# end main
# Program Start
if __name__ == "__main__":
run() | {
"input": [
"3 5\n1 2 4\n",
"5 6\n3 3 3 3 3\n",
"5 5\n2 3 1 4 4\n",
"3 3\n3 1 1\n",
"1 1000\n548\n"
],
"output": [
"3\n",
"10\n",
"9\n",
"1\n",
"0\n"
]
} |
4,964 | 7 | The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 β€ n β€ 3 β
10^5) β the number of cities.
The second line contains n integers w_1, w_2, β¦, w_n (0 β€ w_{i} β€ 10^9) β the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 β€ u, v β€ n, 1 β€ c β€ 10^9, u β v), where u and v β cities that are connected by this road and c β its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number β the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 β 1 β 3.
<image>
The optimal way in the second example is 2 β 4.
<image> | import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
adj = [[] for i in range(n)]
for i in range(n-1):
u, v, w = map(int, input().split())
u -= 1
v -= 1
adj[u].append((v, w))
adj[v].append((u, w))
best = [0] * n
ans = 0
def dfs(u):
stack = list()
visit = [False] * n
stack.append((u, -1))
while stack:
u, par = stack[-1]
if not visit[u]:
visit[u] = True
for v, w in adj[u]:
if v != par:
stack.append((v, u))
else:
cand = []
for v, w in adj[u]:
if v != par:
cand.append(best[v] + a[v] - w)
cand.sort(reverse=True)
cur = a[u]
for i in range(2):
if i < len(cand) and cand[i] > 0:
cur += cand[i]
global ans
ans = max(ans, cur)
best[u] = cand[0] if len(cand) > 0 and cand[0] > 0 else 0
stack.pop()
dfs(0)
print(ans) | {
"input": [
"3\n1 3 3\n1 2 2\n1 3 2\n",
"5\n6 3 2 5 0\n1 2 10\n2 3 3\n2 4 1\n1 5 1\n"
],
"output": [
" 3\n",
" 7\n"
]
} |
4,965 | 9 | You are policeman and you are playing a game with Slavik. The game is turn-based and each turn consists of two phases. During the first phase you make your move and during the second phase Slavik makes his move.
There are n doors, the i-th door initially has durability equal to a_i.
During your move you can try to break one of the doors. If you choose door i and its current durability is b_i then you reduce its durability to max(0, b_i - x) (the value x is given).
During Slavik's move he tries to repair one of the doors. If he chooses door i and its current durability is b_i then he increases its durability to b_i + y (the value y is given). Slavik cannot repair doors with current durability equal to 0.
The game lasts 10^{100} turns. If some player cannot make his move then he has to skip it.
Your goal is to maximize the number of doors with durability equal to 0 at the end of the game. You can assume that Slavik wants to minimize the number of such doors. What is the number of such doors in the end if you both play optimally?
Input
The first line of the input contains three integers n, x and y (1 β€ n β€ 100, 1 β€ x, y β€ 10^5) β the number of doors, value x and value y, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^5), where a_i is the initial durability of the i-th door.
Output
Print one integer β the number of doors with durability equal to 0 at the end of the game, if you and Slavik both play optimally.
Examples
Input
6 3 2
2 3 1 3 4 2
Output
6
Input
5 3 3
1 2 4 2 3
Output
2
Input
5 5 6
1 2 6 10 3
Output
2
Note
Clarifications about the optimal strategy will be ignored. | def get_ints():
return list(map(int, input().split()))
n,x,y = get_ints()
l=get_ints()
if x>y:
print(n)
else:
print((sum([i <= x for i in l])+1)//2) | {
"input": [
"5 5 6\n1 2 6 10 3\n",
"6 3 2\n2 3 1 3 4 2\n",
"5 3 3\n1 2 4 2 3\n"
],
"output": [
"2\n",
"6\n",
"2\n"
]
} |
4,966 | 9 | Alice lives on a flat planet that can be modeled as a square grid of size n Γ n, with rows and columns enumerated from 1 to n. We represent the cell at the intersection of row r and column c with ordered pair (r, c). Each cell in the grid is either land or water.
<image> An example planet with n = 5. It also appears in the first sample test.
Alice resides in land cell (r_1, c_1). She wishes to travel to land cell (r_2, c_2). At any moment, she may move to one of the cells adjacent to where she isβin one of the four directions (i.e., up, down, left, or right).
Unfortunately, Alice cannot swim, and there is no viable transportation means other than by foot (i.e., she can walk only on land). As a result, Alice's trip may be impossible.
To help Alice, you plan to create at most one tunnel between some two land cells. The tunnel will allow Alice to freely travel between the two endpoints. Indeed, creating a tunnel is a lot of effort: the cost of creating a tunnel between cells (r_s, c_s) and (r_t, c_t) is (r_s-r_t)^2 + (c_s-c_t)^2.
For now, your task is to find the minimum possible cost of creating at most one tunnel so that Alice could travel from (r_1, c_1) to (r_2, c_2). If no tunnel needs to be created, the cost is 0.
Input
The first line contains one integer n (1 β€ n β€ 50) β the width of the square grid.
The second line contains two space-separated integers r_1 and c_1 (1 β€ r_1, c_1 β€ n) β denoting the cell where Alice resides.
The third line contains two space-separated integers r_2 and c_2 (1 β€ r_2, c_2 β€ n) β denoting the cell to which Alice wishes to travel.
Each of the following n lines contains a string of n characters. The j-th character of the i-th such line (1 β€ i, j β€ n) is 0 if (i, j) is land or 1 if (i, j) is water.
It is guaranteed that (r_1, c_1) and (r_2, c_2) are land.
Output
Print an integer that is the minimum possible cost of creating at most one tunnel so that Alice could travel from (r_1, c_1) to (r_2, c_2).
Examples
Input
5
1 1
5 5
00001
11111
00111
00110
00110
Output
10
Input
3
1 3
3 1
010
101
010
Output
8
Note
In the first sample, a tunnel between cells (1, 4) and (4, 5) should be created. The cost of doing so is (1-4)^2 + (4-5)^2 = 10, which is optimal. This way, Alice could walk from (1, 1) to (1, 4), use the tunnel from (1, 4) to (4, 5), and lastly walk from (4, 5) to (5, 5).
In the second sample, clearly a tunnel between cells (1, 3) and (3, 1) needs to be created. The cost of doing so is (1-3)^2 + (3-1)^2 = 8. | import sys
sys.setrecursionlimit(10000)
def dfs(r1,c1,l1):
if(r1<1 or r1>n or c1<1 or c1>n or l[r1-1][c1-1]=='1'):
return
if (r1,c1) in l1:
return
l1.append((r1,c1))
dfs(r1-1,c1,l1)
dfs(r1,c1-1,l1)
dfs(r1,c1+1,l1)
dfs(r1+1,c1,l1)
n=int(input())
r1,c1=map(int,input().split())
r2,c2=map(int,input().split())
l=[]
for i in range(n):
l.append(list(input()))
l2=[]
l3=[]
dfs(r1,c1,l2)
dfs(r2,c2,l3)
ans=float('INF')
for i in range(len(l2)):
for j in range(len(l3)):
a=abs(l2[i][0]-l3[j][0])**2+abs(l2[i][1]-l3[j][1])**2
if(a<ans):
ans=a
print(ans) | {
"input": [
"5\n1 1\n5 5\n00001\n11111\n00111\n00110\n00110\n",
"3\n1 3\n3 1\n010\n101\n010\n"
],
"output": [
"10\n",
"8\n"
]
} |
4,967 | 7 | Recently, Tokitsukaze found an interesting game. Tokitsukaze had n items at the beginning of this game. However, she thought there were too many items, so now she wants to discard m (1 β€ m β€ n) special items of them.
These n items are marked with indices from 1 to n. In the beginning, the item with index i is placed on the i-th position. Items are divided into several pages orderly, such that each page contains exactly k positions and the last positions on the last page may be left empty.
Tokitsukaze would do the following operation: focus on the first special page that contains at least one special item, and at one time, Tokitsukaze would discard all special items on this page. After an item is discarded or moved, its old position would be empty, and then the item below it, if exists, would move up to this empty position. The movement may bring many items forward and even into previous pages, so Tokitsukaze would keep waiting until all the items stop moving, and then do the operation (i.e. check the special page and discard the special items) repeatedly until there is no item need to be discarded.
<image> Consider the first example from the statement: n=10, m=4, k=5, p=[3, 5, 7, 10]. The are two pages. Initially, the first page is special (since it is the first page containing a special item). So Tokitsukaze discards the special items with indices 3 and 5. After, the first page remains to be special. It contains [1, 2, 4, 6, 7], Tokitsukaze discards the special item with index 7. After, the second page is special (since it is the first page containing a special item). It contains [9, 10], Tokitsukaze discards the special item with index 10.
Tokitsukaze wants to know the number of operations she would do in total.
Input
The first line contains three integers n, m and k (1 β€ n β€ 10^{18}, 1 β€ m β€ 10^5, 1 β€ m, k β€ n) β the number of items, the number of special items to be discarded and the number of positions in each page.
The second line contains m distinct integers p_1, p_2, β¦, p_m (1 β€ p_1 < p_2 < β¦ < p_m β€ n) β the indices of special items which should be discarded.
Output
Print a single integer β the number of operations that Tokitsukaze would do in total.
Examples
Input
10 4 5
3 5 7 10
Output
3
Input
13 4 5
7 8 9 10
Output
1
Note
For the first example:
* In the first operation, Tokitsukaze would focus on the first page [1, 2, 3, 4, 5] and discard items with indices 3 and 5;
* In the second operation, Tokitsukaze would focus on the first page [1, 2, 4, 6, 7] and discard item with index 7;
* In the third operation, Tokitsukaze would focus on the second page [9, 10] and discard item with index 10.
For the second example, Tokitsukaze would focus on the second page [6, 7, 8, 9, 10] and discard all special items at once. | import math
def solve():
n, m, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
current = k
index = 0
iteration = 0
while index < m:
# None of the numbers found
if current < arr[index]:
current += math.ceil((arr[index] - current) / k) * k
continue
val = 0
# Find out how many special numbers are within the range
while index < m and current >= arr[index]:
val += 1
index += 1
iteration += 1
if index == m:
break
if val == 0:
current += math.ceil((arr[index] - current) / k) * k
else:
current += val
print(iteration)
solve() | {
"input": [
"13 4 5\n7 8 9 10\n",
"10 4 5\n3 5 7 10\n"
],
"output": [
"1\n",
"3\n"
]
} |
4,968 | 11 | This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n Γ m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+β¦+r_n?
Input
The first line contains an integer t (1 β€ t β€ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 β€ n β€ 4, 1 β€ m β€ 100) β the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 β€ a_{i, j} β€ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9. | rnd_mod = 1234567890133
rnd_x = 987654321098
def rnd():
global rnd_x
rnd_x = rnd_x**2 % rnd_mod
return (rnd_x>>5) % (1<<20)
def randrange(a):
return rnd() % a
T = int(input())
for _ in range(T):
N, M = map(int, input().split())
X = []
for __ in range(N):
X.append([int(a) for a in input().split()])
Y = [[X[i][j] for i in range(N)] for j in range(M)]
ma = 0
for t in range(577):
for i in range(M):
a = randrange(N)
Y[i] = [Y[i][j-a] for j in range(N)]
ma = max(ma, sum([max([Y[i][j] for i in range(M)]) for j in range(N)]))
print(ma)
| {
"input": [
"2\n2 3\n2 5 7\n4 2 4\n3 6\n4 1 5 2 10 4\n8 6 6 4 9 10\n5 4 9 5 8 7\n"
],
"output": [
"12\n29\n"
]
} |
4,969 | 10 | You have a simple undirected graph consisting of n vertices and m edges. The graph doesn't contain self-loops, there is at most one edge between a pair of vertices. The given graph can be disconnected.
Let's make a definition.
Let v_1 and v_2 be two some nonempty subsets of vertices that do not intersect. Let f(v_{1}, v_{2}) be true if and only if all the conditions are satisfied:
1. There are no edges with both endpoints in vertex set v_1.
2. There are no edges with both endpoints in vertex set v_2.
3. For every two vertices x and y such that x is in v_1 and y is in v_2, there is an edge between x and y.
Create three vertex sets (v_{1}, v_{2}, v_{3}) which satisfy the conditions below;
1. All vertex sets should not be empty.
2. Each vertex should be assigned to only one vertex set.
3. f(v_{1}, v_{2}), f(v_{2}, v_{3}), f(v_{3}, v_{1}) are all true.
Is it possible to create such three vertex sets? If it's possible, print matching vertex set for each vertex.
Input
The first line contains two integers n and m (3 β€ n β€ 10^{5}, 0 β€ m β€ min(3 β
10^{5}, (n(n-1))/(2))) β the number of vertices and edges in the graph.
The i-th of the next m 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}. The graph doesn't contain self-loops, there is at most one edge between a pair of vertices. The given graph can be disconnected.
Output
If the answer exists, print n integers. i-th integer means the vertex set number (from 1 to 3) of i-th vertex. Otherwise, print -1.
If there are multiple answers, print any.
Examples
Input
6 11
1 2
1 3
1 4
1 5
1 6
2 4
2 5
2 6
3 4
3 5
3 6
Output
1 2 2 3 3 3
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
-1
Note
In the first example, if v_{1} = \{ 1 \}, v_{2} = \{ 2, 3 \}, and v_{3} = \{ 4, 5, 6 \} then vertex sets will satisfy all conditions. But you can assign vertices to vertex sets in a different way; Other answers like "2 3 3 1 1 1" will be accepted as well.
<image>
In the second example, it's impossible to make such vertex sets. | def exitprint():
print(-1)
exit(0)
n, m = list(map(int, input().split()))
al = [list() for _ in range(n)]
for _ in range(m):
u, v = list(map(int, input().split()))
al[u-1].append(v-1)
al[v-1].append(u-1)
for i in range(n):
al[i] = frozenset(al[i])
a={}
k=1
ans = []
for i in range(n):
if len(al[i]) == 0:
exitprint()
if al[i] in a:
ans.append(a[al[i]])
else:
a[al[i]] = k
k+=1
ans.append(a[al[i]])
if len(a)>3:
exitprint()
if len(a) < 3:
exitprint()
print(*ans) | {
"input": [
"4 6\n1 2\n1 3\n1 4\n2 3\n2 4\n3 4\n",
"6 11\n1 2\n1 3\n1 4\n1 5\n1 6\n2 4\n2 5\n2 6\n3 4\n3 5\n3 6\n"
],
"output": [
"-1\n",
"1 2 2 3 3 3\n"
]
} |
4,970 | 10 | This problem is interactive.
We have hidden an array a of n pairwise different numbers (this means that no two numbers are equal). You can get some information about this array using a new device you just ordered on Amazon.
This device can answer queries of the following form: in response to the positions of k different elements of the array, it will return the position and value of the m-th among them in the ascending order.
Unfortunately, the instruction for the device was lost during delivery. However, you remember k, but don't remember m. Your task is to find m using queries to this device.
You can ask not more than n queries.
Note that the array a and number m are fixed before the start of the interaction and don't depend on your queries. In other words, interactor is not adaptive.
Note that you don't have to minimize the number of queries, and you don't need to guess array a. You just have to guess m.
Input
The first line contains two integers n and k (1β€ k < n β€ 500) β the length of the array and the number of the elements in the query.
It is guaranteed that number m satisfies 1β€ m β€ k, elements a_1, a_2, ..., a_n of the array satisfy 0β€ a_i β€ 10^9, and all of them are different.
Interaction
You begin the interaction by reading n and k.
To ask a question about elements on positions x_1, x_2, ..., x_k, in a separate line output
? x_1 x_2 x_3 ... x_k
Numbers in the query have to satisfy 1 β€ x_i β€ n, and all x_i have to be different. Don't forget to 'flush', to get the answer.
In response, you will receive two integers pos and a_{pos} β the position in the array a of the m-th in ascending order element among a_{x_1}, a_{x_2}, ..., a_{x_k}, and the element on this position.
In case your query is invalid or you asked more than n queries, the program will print -1 and will finish interaction. You will receive a Wrong answer verdict. Make sure to exit immediately to avoid getting other verdicts.
When you determine m, output
! m
After printing a query 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 documentation for other languages.
Hack format
For the hacks use the following format:
The first line has to contain three integers n, k, m (1 β€ m β€ k < n β€ 500) β the length of the array, number of elements in the query, and which in the ascending order number the device returns.
In the next line output n integers a_1, a_2, ..., a_n (0β€ a_i β€ 10^9) β the elements of the array. They have to be pairwise different.
Example
Input
4 3
4 9
4 9
4 9
1 2
Output
? 2 3 4
? 1 3 4
? 1 2 4
? 1 2 3
! 3
Note
In the example, n = 4, k = 3, m = 3, a = [2, 0, 1, 9]. | import sys
n, k = map(int,input().split())
def guess(arr):
print(*(["?"]+arr))
sys.stdout.flush()
pos, val = map(int,input().split())
return val
odp = ["chuj"]
for i in range(1, k + 2):
lis = list(range(1,k + 2))
lis.pop(i - 1)
new = guess(lis)
odp.append(new)
x = max(odp[1:])
print("!", odp.count(x)) | {
"input": [
"4 3\n4 9\n4 9\n4 9\n1 2"
],
"output": [
"? 2 3 4 \n? 1 3 4 \n? 1 2 4 \n? 1 2 3 \n! 3\n"
]
} |
4,971 | 8 | [3R2 - Standby for Action](https://www.youtube.com/watch?v=P2ZVC9aoiKo)
Our dear Cafe's owner, JOE Miller, will soon take part in a new game TV-show "1 vs. n"!
The game goes in rounds, where in each round the host asks JOE and his opponents a common question. All participants failing to answer are eliminated. The show ends when only JOE remains (we assume that JOE never answers a question wrong!).
For each question JOE answers, if there are s (s > 0) opponents remaining and t (0 β€ t β€ s) of them make a mistake on it, JOE receives \displaystylet/s dollars, and consequently there will be s - t opponents left for the next question.
JOE wonders what is the maximum possible reward he can receive in the best possible scenario. Yet he has little time before show starts, so can you help him answering it instead?
Input
The first and single line contains a single integer n (1 β€ n β€ 10^5), denoting the number of JOE's opponents in the show.
Output
Print a number denoting the maximum prize (in dollars) JOE could have.
Your answer will be considered correct if it's absolute or relative error won't exceed 10^{-4}. In other words, if your answer is a and the jury answer is b, then it must hold that (|a - b|)/(max(1, b)) β€ 10^{-4}.
Examples
Input
1
Output
1.000000000000
Input
2
Output
1.500000000000
Note
In the second example, the best scenario would be: one contestant fails at the first question, the other fails at the next one. The total reward will be \displaystyle 1/2 + 1/1 = 1.5 dollars. | def main():
n = int(input())
print(sum([1/k for k in range(1, n+1)]))
main() | {
"input": [
"1\n",
"2\n"
],
"output": [
"1.0\n",
"1.5\n"
]
} |
4,972 | 8 | Nikolay has only recently started in competitive programming, but already qualified to the finals of one prestigious olympiad. There going to be n participants, one of whom is Nikolay. Like any good olympiad, it consists of two rounds. Tired of the traditional rules, in which the participant who solved the largest number of problems wins, the organizers came up with different rules.
Suppose in the first round participant A took x-th place and in the second round β y-th place. Then the total score of the participant A is sum x + y. The overall place of the participant A is the number of participants (including A) having their total score less than or equal to the total score of A. Note, that some participants may end up having a common overall place. It is also important to note, that in both the first and the second round there were no two participants tying at a common place. In other words, for every i from 1 to n exactly one participant took i-th place in first round and exactly one participant took i-th place in second round.
Right after the end of the Olympiad, Nikolay was informed that he got x-th place in first round and y-th place in the second round. Nikolay doesn't know the results of other participants, yet he wonders what is the minimum and maximum place he can take, if we consider the most favorable and unfavorable outcome for him. Please help Nikolay to find the answer to this question.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases to solve.
Each of the following t lines contains integers n, x, y (1 β€ n β€ 10^9, 1 β€ x, y β€ n) β the number of participants in the olympiad, the place that Nikolay took in the first round and the place that Nikolay took in the second round.
Output
Print two integers β the minimum and maximum possible overall place Nikolay could take.
Examples
Input
1
5 1 3
Output
1 3
Input
1
6 3 4
Output
2 6
Note
Explanation for the first example:
Suppose there were 5 participants A-E. Let's denote Nikolay as A. The the most favorable results for Nikolay could look as follows:
<image>
However, the results of the Olympiad could also look like this:
<image>
In the first case Nikolay would have taken first place, and in the second β third place. | def solve():
n, a, b = map(int, input().split())
best = min(max(a + b + 1 - n, 1), n)
worst = max(min(a + b - 1, n), 1)
print(best, worst)
t = int(input())
for i in range(t):
solve() | {
"input": [
"1\n6 3 4\n",
"1\n5 1 3\n"
],
"output": [
"2 6\n",
"1 3\n"
]
} |
4,973 | 11 | The only difference between easy and hard versions is constraints.
You are given a sequence a consisting of n positive integers.
Let's define a three blocks palindrome as the sequence, consisting of at most two distinct elements (let these elements are a and b, a can be equal b) and is as follows: [\underbrace{a, a, ..., a}_{x}, \underbrace{b, b, ..., b}_{y}, \underbrace{a, a, ..., a}_{x}]. There x, y are integers greater than or equal to 0. For example, sequences [], [2], [1, 1], [1, 2, 1], [1, 2, 2, 1] and [1, 1, 2, 1, 1] are three block palindromes but [1, 2, 3, 2, 1], [1, 2, 1, 2, 1] and [1, 2] are not.
Your task is to choose the maximum by length subsequence of a that is a three blocks palindrome.
You have to answer t independent test cases.
Recall that the sequence t is a a subsequence of the sequence s if t can be derived from s by removing zero or more elements without changing the order of the remaining elements. For example, if s=[1, 2, 1, 3, 1, 2, 1], then possible subsequences are: [1, 1, 1, 1], [3] and [1, 2, 1, 3, 1, 2, 1], but not [3, 2, 3] and [1, 1, 1, 1, 2].
Input
The first line of the input contains one integer t (1 β€ t β€ 10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 β€ n β€ 2 β
10^5) β the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 200), where a_i is the i-th element of a. Note that the maximum value of a_i can be up to 200.
It is guaranteed that the sum of n over all test cases does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer β the maximum possible length of some subsequence of a that is a three blocks palindrome.
Example
Input
6
8
1 1 2 2 3 2 1 1
3
1 3 3
4
1 10 10 1
1
26
2
2 1
3
1 1 1
Output
7
2
4
1
1
3 | def getmid(s, e, count):
mx = -1
for i in range(201):
mx = max(count[e][i]-count[s][i], mx)
return mx
for tc in range(int(input())):
n = int(input())
a = list(map(int, input().split(' ')))
count = n*[201*[0]]
pos = [[] for i in range(201)]
for i in range(n):
count[i] = count[i-1].copy()
count[i][a[i]] += 1
pos[a[i]].append(i)
ans = 0
for i in range(len(a)):
l = count[i][a[i]]
j = pos[a[i]][-l]
if (i < j):
ans = max(ans, 2*l + getmid(i, j-1, count))
elif i == j:
ans = max(ans, 2*l - 1)
print(ans)
| {
"input": [
"6\n8\n1 1 2 2 3 2 1 1\n3\n1 3 3\n4\n1 10 10 1\n1\n26\n2\n2 1\n3\n1 1 1\n"
],
"output": [
"7\n2\n4\n1\n1\n3\n"
]
} |
4,974 | 8 | Maria is the most active old lady in her house. She was tired of sitting at home. She decided to organize a ceremony against the coronavirus.
She has n friends who are also grannies (Maria is not included in this number). The i-th granny is ready to attend the ceremony, provided that at the time of her appearance in the courtyard there will be at least a_i other grannies there. Note that grannies can come into the courtyard at the same time. Formally, the granny i agrees to come if the number of other grannies who came earlier or at the same time with her is greater than or equal to a_i.
Grannies gather in the courtyard like that.
* Initially, only Maria is in the courtyard (that is, the initial number of grannies in the courtyard is 1). All the remaining n grannies are still sitting at home.
* On each step Maria selects a subset of grannies, none of whom have yet to enter the courtyard. She promises each of them that at the time of her appearance there will be at least a_i other grannies (including Maria) in the courtyard. Maria can call several grannies at once. In this case, the selected grannies will go out into the courtyard at the same moment of time.
* She cannot deceive grannies, that is, the situation when the i-th granny in the moment of appearing in the courtyard, finds that now there are strictly less than a_i other grannies (except herself, but including Maria), is prohibited. Please note that if several grannies appeared in the yard at the same time, then each of them sees others at the time of appearance.
Your task is to find what maximum number of grannies (including herself) Maria can collect in the courtyard for the ceremony. After all, the more people in one place during quarantine, the more effective the ceremony!
Consider an example: if n=6 and a=[1,5,4,5,1,9], then:
* at the first step Maria can call grannies with numbers 1 and 5, each of them will see two grannies at the moment of going out into the yard (note that a_1=1 β€ 2 and a_5=1 β€ 2);
* at the second step, Maria can call grannies with numbers 2, 3 and 4, each of them will see five grannies at the moment of going out into the yard (note that a_2=5 β€ 5, a_3=4 β€ 5 and a_4=5 β€ 5);
* the 6-th granny cannot be called into the yard β therefore, the answer is 6 (Maria herself and another 5 grannies).
Input
The first line contains a single integer t (1 β€ t β€ 10^4) β the number of test cases in the input. Then test cases follow.
The first line of a test case contains a single integer n (1 β€ n β€ 10^5) β the number of grannies (Maria is not included in this number).
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 2β
10^5).
It is guaranteed that the sum of the values n over all test cases of the input does not exceed 10^5.
Output
For each test case, print a single integer k (1 β€ k β€ n + 1) β the maximum possible number of grannies in the courtyard.
Example
Input
4
5
1 1 2 2 1
6
2 3 4 5 6 7
6
1 5 4 5 1 9
5
1 2 3 5 6
Output
6
1
6
4
Note
In the first test case in the example, on the first step Maria can call all the grannies. Then each of them will see five grannies when they come out. Therefore, Maria and five other grannies will be in the yard.
In the second test case in the example, no one can be in the yard, so Maria will remain there alone.
The third test case in the example is described in the details above.
In the fourth test case in the example, on the first step Maria can call grannies with numbers 1, 2 and 3. If on the second step Maria calls 4 or 5 (one of them), then when a granny appears in the yard, she will see only four grannies (but it is forbidden). It means that Maria can't call the 4-th granny or the 5-th granny separately (one of them). If she calls both: 4 and 5, then when they appear, they will see 4+1=5 grannies. Despite the fact that it is enough for the 4-th granny, the 5-th granny is not satisfied. So, Maria cannot call both the 4-th granny and the 5-th granny at the same time. That is, Maria and three grannies from the first step will be in the yard in total. | def solve():
n = int(input())
a = sorted(map(int, input().split()))
i = n-1
while i >= 0 and a[i] > i+1:
i -= 1
print(i+2)
for i in range(int(input())):
solve() | {
"input": [
"4\n5\n1 1 2 2 1\n6\n2 3 4 5 6 7\n6\n1 5 4 5 1 9\n5\n1 2 3 5 6\n"
],
"output": [
"6\n1\n6\n4\n"
]
} |
4,975 | 9 | There are n people who want to participate in a boat competition. The weight of the i-th participant is w_i. Only teams consisting of two people can participate in this competition. As an organizer, you think that it's fair to allow only teams with the same total weight.
So, if there are k teams (a_1, b_1), (a_2, b_2), ..., (a_k, b_k), where a_i is the weight of the first participant of the i-th team and b_i is the weight of the second participant of the i-th team, then the condition a_1 + b_1 = a_2 + b_2 = ... = a_k + b_k = s, where s is the total weight of each team, should be satisfied.
Your task is to choose such s that the number of teams people can create is the maximum possible. Note that each participant can be in no more than one team.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 β€ n β€ 50) β the number of participants. The second line of the test case contains n integers w_1, w_2, ..., w_n (1 β€ w_i β€ n), where w_i is the weight of the i-th participant.
Output
For each test case, print one integer k: the maximum number of teams people can compose with the total weight s, if you choose s optimally.
Example
Input
5
5
1 2 3 4 5
8
6 6 6 6 6 6 8 8
8
1 2 2 1 2 1 1 2
3
1 3 3
6
1 1 3 4 2 2
Output
2
3
4
1
2
Note
In the first test case of the example, we can reach the optimal answer for s=6. Then the first boat is used by participants 1 and 5 and the second boat is used by participants 2 and 4 (indices are the same as weights).
In the second test case of the example, we can reach the optimal answer for s=12. Then first 6 participants can form 3 pairs.
In the third test case of the example, we can reach the optimal answer for s=3. The answer is 4 because we have 4 participants with weight 1 and 4 participants with weight 2.
In the fourth test case of the example, we can reach the optimal answer for s=4 or s=6.
In the fifth test case of the example, we can reach the optimal answer for s=3. Note that participant with weight 3 can't use the boat because there is no suitable pair for him in the list. | from collections import Counter
def solve():
n=int(input())
*a,=map(int, input().split())
ca=Counter(a)
ans=0
for i in range(2,n*2+1):
tmp=0
for k in ca:
tmp+=min(ca[k],ca[i-k])
tmp//=2
ans=max(ans,tmp)
print(ans)
t=int(input())
for _ in range(t):
solve() | {
"input": [
"5\n5\n1 2 3 4 5\n8\n6 6 6 6 6 6 8 8\n8\n1 2 2 1 2 1 1 2\n3\n1 3 3\n6\n1 1 3 4 2 2\n"
],
"output": [
"2\n3\n4\n1\n2\n"
]
} |
4,976 | 7 | Let's call a sequence b_1, b_2, b_3 ..., b_{k - 1}, b_k almost increasing if $$$min(b_1, b_2) β€ min(b_2, b_3) β€ ... β€ min(b_{k - 1}, b_k).$$$ In particular, any sequence with no more than two elements is almost increasing.
You are given a sequence of integers a_1, a_2, ..., a_n. Calculate the length of its longest almost increasing subsequence.
You'll be given t test cases. Solve each test case independently.
Reminder: a subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of independent test cases.
The first line of each test case contains a single integer n (2 β€ n β€ 5 β
10^5) β the length of the sequence a.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ n) β the sequence itself.
It's guaranteed that the total sum of n over all test cases doesn't exceed 5 β
10^5.
Output
For each test case, print one integer β the length of the longest almost increasing subsequence.
Example
Input
3
8
1 2 7 3 2 1 2 3
2
2 1
7
4 1 5 2 6 3 7
Output
6
2
7
Note
In the first test case, one of the optimal answers is subsequence 1, 2, 7, 2, 2, 3.
In the second and third test cases, the whole sequence a is already almost increasing. | import sys
input = sys.stdin.readline
def ri(): return [int(i) for i in input().split()]
# Fenwick max
def ft_max_set(t, at, val):
while at < len(t):
t[at] = max(t[at], val)
at |= at + 1
def ft_max_query(t, at):
res = 0
while at >= 0:
res = max(res, t[at])
at = (at & (at + 1)) - 1
return res
def do_nxt(b):
st = []
nxt = [len(b)] * len(b)
for i in range(len(b)):
while len(st) > 0 and st[-1][0] < b[i]:
(val, at) = st.pop()
nxt[at] = i
st.append((b[i], i))
return nxt
def main():
t = ri()[0]
for _ in range(t):
n = ri()[0]
b = ri()
MAX_VAL = 5 * 10 ** 5 + 10
nxt = do_nxt(b) # ==len(b) if not found
extra = [[] for _ in range(n)]
t = [0] * MAX_VAL # Fenwick: lastvalβlongest
# prepend 0 to the sequence (will _always_ be too long by 1)
ft_max_set(t, 0, 1)
extra[0].append((0, 2))
for i in range(n):
# print(f'---------i={i}')
# seek best with last min-accepted = b[i]
best = ft_max_query(t, b[i])
# print(f'query\tbest for {b[i]} β {best}')
best += 1 # accept this one
ft_max_set(t, at=b[i], val=best)
# print(f'set \tai={b[i]} β best={best}')
if nxt[i] < n:
# print(f'write extra at {nxt[i]} as ai={b[i]} β {best + 1}')
extra[nxt[i]].append((b[i], best + 1))
# extra updates; all ai < b[i]
for (ai, e_best) in extra[i]:
# print(f'extra at ai={ai} β best={e_best}')
ft_max_set(t, at=ai, val=e_best)
print(ft_max_query(t, MAX_VAL - 1)-1)
main()
| {
"input": [
"3\n8\n1 2 7 3 2 1 2 3\n2\n2 1\n7\n4 1 5 2 6 3 7\n"
],
"output": [
"\n6\n2\n7\n"
]
} |
4,977 | 7 | Phoenix has collected n pieces of gold, and he wants to weigh them together so he can feel rich. The i-th piece of gold has weight w_i. All weights are distinct. He will put his n pieces of gold on a weight scale, one piece at a time.
The scale has an unusual defect: if the total weight on it is exactly x, it will explode. Can he put all n gold pieces onto the scale in some order, without the scale exploding during the process? If so, help him find some possible order.
Formally, rearrange the array w so that for each i (1 β€ i β€ n), β_{j = 1}^{i}w_j β x.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains two integers n and x (1 β€ n β€ 100; 1 β€ x β€ 10^4) β the number of gold pieces that Phoenix has and the weight to avoid, respectively.
The second line of each test case contains n space-separated integers (1 β€ w_i β€ 100) β the weights of the gold pieces. It is guaranteed that the weights are pairwise distinct.
Output
For each test case, if Phoenix cannot place all n pieces without the scale exploding, print NO. Otherwise, print YES followed by the rearranged array w. If there are multiple solutions, print any.
Example
Input
3
3 2
3 2 1
5 3
1 2 3 4 8
1 5
5
Output
YES
3 2 1
YES
8 1 2 3 4
NO
Note
In the first test case, Phoenix puts the gold piece with weight 3 on the scale first, then the piece with weight 2, and finally the piece with weight 1. The total weight on the scale is 3, then 5, then 6. The scale does not explode because the total weight on the scale is never 2.
In the second test case, the total weight on the scale is 8, 9, 11, 14, then 18. It is never 3.
In the third test case, Phoenix must put the gold piece with weight 5 on the scale, and the scale will always explode. | def inpl():
return list(map(int, input().split()))
def inpi():
return int(input())
def f():
n, x = inpl()
w = inpl()
w.sort()
if sum(w) == x:
print("NO")
return
print("YES")
for i in range(1,n):
if sum(w[:i]) == x:
w[i-1], w[i] = w[i], w[i-1]
break
print(' '.join(str(c) for c in w))
t = int(input())
for _ in range(t):
f()
| {
"input": [
"3\n3 2\n3 2 1\n5 3\n1 2 3 4 8\n1 5\n5\n"
],
"output": [
"\nYES\n3 2 1\nYES\n8 1 2 3 4\nNO\n"
]
} |
4,978 | 9 | Once Bob took a paper stripe of n squares (the height of the stripe is 1 square). In each square he wrote an integer number, possibly negative. He became interested in how many ways exist to cut this stripe into two pieces so that the sum of numbers from one piece is equal to the sum of numbers from the other piece, and each piece contains positive integer amount of squares. Would you help Bob solve this problem?
Input
The first input line contains integer n (1 β€ n β€ 105) β amount of squares in the stripe. The second line contains n space-separated numbers β they are the numbers written in the squares of the stripe. These numbers are integer and do not exceed 10000 in absolute value.
Output
Output the amount of ways to cut the stripe into two non-empty pieces so that the sum of numbers from one piece is equal to the sum of numbers from the other piece. Don't forget that it's allowed to cut the stripe along the squares' borders only.
Examples
Input
9
1 5 -6 7 9 -16 0 -2 2
Output
3
Input
3
1 1 1
Output
0
Input
2
0 0
Output
1 | ##c
def main():
n=int(input())
ans=0
A=list(map(int,input().split()))
l=0
r=sum(A)
for s in range(n-1):
l+=A[s]
r-=A[s]
if ( r==l ):
ans+=1
print(ans)
main()
| {
"input": [
"2\n0 0\n",
"3\n1 1 1\n",
"9\n1 5 -6 7 9 -16 0 -2 2\n"
],
"output": [
"1\n",
"0\n",
"3\n"
]
} |
4,979 | 9 | You've decided to carry out a survey in the theory of prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors.
Consider positive integers a, a + 1, ..., b (a β€ b). You want to find the minimum integer l (1 β€ l β€ b - a + 1) such that for any integer x (a β€ x β€ b - l + 1) among l integers x, x + 1, ..., x + l - 1 there are at least k prime numbers.
Find and print the required minimum l. If no value l meets the described limitations, print -1.
Input
A single line contains three space-separated integers a, b, k (1 β€ a, b, k β€ 106; a β€ b).
Output
In a single line print a single integer β the required minimum l. If there's no solution, print -1.
Examples
Input
2 4 2
Output
3
Input
6 13 1
Output
4
Input
1 4 3
Output
-1 | def f(a, b):
t = [1] * (b + 1)
for i in range(3, int(b ** 0.5) + 1):
if t[i]:
t[i * i :: 2 * i] = [0] * ((b - i * i) // (2 * i) + 1)
return [i for i in range(3, b + 1, 2) if t[i] and i > a]
a, b, k = map(int, input().split())
p = f(a - 1, b)
if 3 > a and b > 1:
p = [2] + p
if k > len(p): print(-1)
elif len(p) == k:
print(max(p[k - 1] - a + 1, b - p[0] + 1))
else:
print(max(p[k - 1] - a + 1, b - p[len(p) - k] + 1, max(p[i + k] - p[i] for i in range(len(p) - k)))) | {
"input": [
"2 4 2\n",
"1 4 3\n",
"6 13 1\n"
],
"output": [
"3",
"-1",
"4"
]
} |
4,980 | 7 | Roma (a popular Russian name that means 'Roman') loves the Little Lvov Elephant's lucky numbers.
Let us remind you that lucky numbers are positive integers whose decimal representation only contains lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Roma's got n positive integers. He wonders, how many of those integers have not more than k lucky digits? Help him, write the program that solves the problem.
Input
The first line contains two integers n, k (1 β€ n, k β€ 100). The second line contains n integers ai (1 β€ ai β€ 109) β the numbers that Roma has.
The numbers in the lines are separated by single spaces.
Output
In a single line print a single integer β the answer to the problem.
Examples
Input
3 4
1 2 4
Output
3
Input
3 2
447 44 77
Output
2
Note
In the first sample all numbers contain at most four lucky digits, so the answer is 3.
In the second sample number 447 doesn't fit in, as it contains more than two lucky digits. All other numbers are fine, so the answer is 2. | def main():
n, k = map(int, input().strip().split())
print(sum(s.count('4') + s.count('7') <= k for s in input().strip().split()))
main() | {
"input": [
"3 4\n1 2 4\n",
"3 2\n447 44 77\n"
],
"output": [
"3\n",
"2\n"
]
} |
4,981 | 7 | A permutation p of size n is the sequence p1, p2, ..., pn, consisting of n distinct integers, each of them is from 1 to n (1 β€ pi β€ n).
A lucky permutation is such permutation p, that any integer i (1 β€ i β€ n) meets this condition ppi = n - i + 1.
You have integer n. Find some lucky permutation p of size n.
Input
The first line contains integer n (1 β€ n β€ 105) β the required permutation size.
Output
Print "-1" (without the quotes) if the lucky permutation p of size n doesn't exist.
Otherwise, print n distinct integers p1, p2, ..., pn (1 β€ pi β€ n) after a space β the required permutation.
If there are multiple answers, you can print any of them.
Examples
Input
1
Output
1
Input
2
Output
-1
Input
4
Output
2 4 1 3
Input
5
Output
2 5 3 1 4 | n = int(input())
if n % 4 > 1:
print(-1)
exit()
a = [i for i in range(0, n+1)]
for i in range(1, n//2+1, 2):
p, q, r, s = i, i+1, n-i,n-i+1
a[p], a[q], a[r], a[s] = a[q], a[s], a[p], a[r]
def check(arr):
for i in range(1, n+1):
k = arr[i]
if arr[arr[k]] != n-k+1:
return False
return True
# print(check(a))
print(*a[1:])
| {
"input": [
"4\n",
"2\n",
"1\n",
"5\n"
],
"output": [
"2 4 1 3 ",
"-1",
"1 ",
"2 5 3 1 4 "
]
} |
4,982 | 7 | Currently Tiny is learning Computational Geometry. When trying to solve a problem called "The Closest Pair Of Points In The Plane", he found that a code which gave a wrong time complexity got Accepted instead of Time Limit Exceeded.
The problem is the follows. Given n points in the plane, find a pair of points between which the distance is minimized. Distance between (x1, y1) and (x2, y2) is <image>.
The pseudo code of the unexpected code is as follows:
input n
for i from 1 to n
input the i-th point's coordinates into p[i]
sort array p[] by increasing of x coordinate first and increasing of y coordinate second
d=INF //here INF is a number big enough
tot=0
for i from 1 to n
for j from (i+1) to n
++tot
if (p[j].x-p[i].x>=d) then break //notice that "break" is only to be
//out of the loop "for j"
d=min(d,distance(p[i],p[j]))
output d
Here, tot can be regarded as the running time of the code. Due to the fact that a computer can only run a limited number of operations per second, tot should not be more than k in order not to get Time Limit Exceeded.
You are a great hacker. Would you please help Tiny generate a test data and let the code get Time Limit Exceeded?
Input
A single line which contains two space-separated integers n and k (2 β€ n β€ 2000, 1 β€ k β€ 109).
Output
If there doesn't exist such a data which let the given code get TLE, print "no solution" (without quotes); else print n lines, and the i-th line contains two integers xi, yi (|xi|, |yi| β€ 109) representing the coordinates of the i-th point.
The conditions below must be held:
* All the points must be distinct.
* |xi|, |yi| β€ 109.
* After running the given code, the value of tot should be larger than k.
Examples
Input
4 3
Output
0 0
0 1
1 0
1 1
Input
2 100
Output
no solution | n,k=[int(i) for i in input().split(' ')]
def down():
if k>=n*(n-1)/2:
print('no solution')
return
else:
i,j=0,0
ar=[(i,j)]
for j in range(1, n):
ar.append((i,j))
for i in ar:
print('%s %s' %i)
down() | {
"input": [
"4 3\n",
"2 100\n"
],
"output": [
"0 0\n0 1\n0 2\n0 3\n",
"no solution\n"
]
} |
4,983 | 9 | Berland scientists know that the Old Berland language had exactly n words. Those words had lengths of l1, l2, ..., ln letters. Every word consisted of two letters, 0 and 1. Ancient Berland people spoke quickly and didnβt make pauses between the words, but at the same time they could always understand each other perfectly. It was possible because no word was a prefix of another one. The prefix of a string is considered to be one of its substrings that starts from the initial symbol.
Help the scientists determine whether all the words of the Old Berland language can be reconstructed and if they can, output the words themselves.
Input
The first line contains one integer N (1 β€ N β€ 1000) β the number of words in Old Berland language. The second line contains N space-separated integers β the lengths of these words. All the lengths are natural numbers not exceeding 1000.
Output
If thereβs no such set of words, in the single line output NO. Otherwise, in the first line output YES, and in the next N lines output the words themselves in the order their lengths were given in the input file. If the answer is not unique, output any.
Examples
Input
3
1 2 3
Output
YES
0
10
110
Input
3
1 1 1
Output
NO | import sys
sys.setrecursionlimit(100000)
def dfs (x, s):
global count
global done
if x == sorted_a[count][1]:
sorted_a[count][2] = s
count += 1
if count == num_words:
done = True
return
dfs(x + 1, s + '0')
if count == num_words:
return
dfs(x + 1, s + '1')
num_words = int(input())
word_lens = list(map(int, input().split()))
a = []
for i in range(num_words):
a.append([i, word_lens[i], ""])
#a[i] = Node(i, word_lens[i], "")
sorted_a = sorted(a, key=lambda x: x[1])
# print(sorted_a)
count = 0
done = False
dfs(0, "")
# done = dfs(sorted_a)
ordered_a = sorted(sorted_a, key=lambda x: x[0])
# print(ordered_a)
if not done:
print("NO")
else:
print("YES")
for k in ordered_a:
print(k[2]) | {
"input": [
"3\n1 2 3\n",
"3\n1 1 1\n"
],
"output": [
"YES\n0\n10\n110",
"NO\n\n"
]
} |
4,984 | 8 | Inna likes sweets and a game called the "Candy Matrix". Today, she came up with the new game "Candy Matrix 2: Reload".
The field for the new game is a rectangle table of size n Γ m. Each line of the table contains one cell with a dwarf figurine, one cell with a candy, the other cells of the line are empty. The game lasts for several moves. During each move the player should choose all lines of the matrix where dwarf is not on the cell with candy and shout "Let's go!". After that, all the dwarves from the chosen lines start to simultaneously move to the right. During each second, each dwarf goes to the adjacent cell that is located to the right of its current cell. The movement continues until one of the following events occurs:
* some dwarf in one of the chosen lines is located in the rightmost cell of his row;
* some dwarf in the chosen lines is located in the cell with the candy.
The point of the game is to transport all the dwarves to the candy cells.
Inna is fabulous, as she came up with such an interesting game. But what about you? Your task is to play this game optimally well. Specifically, you should say by the given game field what minimum number of moves the player needs to reach the goal of the game.
Input
The first line of the input contains two integers n and m (1 β€ n β€ 1000; 2 β€ m β€ 1000).
Next n lines each contain m characters β the game field for the "Candy Martix 2: Reload". Character "*" represents an empty cell of the field, character "G" represents a dwarf and character "S" represents a candy. The matrix doesn't contain other characters. It is guaranteed that each line contains exactly one character "G" and one character "S".
Output
In a single line print a single integer β either the minimum number of moves needed to achieve the aim of the game, or -1, if the aim cannot be achieved on the given game field.
Examples
Input
3 4
*G*S
G**S
*G*S
Output
2
Input
1 3
S*G
Output
-1 | def dist(s):
return s.find('S') - s.find('G') - 1
n, m = map(int, input().split())
res = [dist(input()) for i in range(n)]
print(-1 if min(res) < 0 else len(set(res)))
| {
"input": [
"3 4\n*G*S\nG**S\n*G*S\n",
"1 3\nS*G\n"
],
"output": [
"2\n",
"-1\n"
]
} |
4,985 | 9 | Your city has n junctions. There are m one-way roads between the junctions. As a mayor of the city, you have to ensure the security of all the junctions.
To ensure the security, you have to build some police checkposts. Checkposts can only be built in a junction. A checkpost at junction i can protect junction j if either i = j or the police patrol car can go to j from i and then come back to i.
Building checkposts costs some money. As some areas of the city are more expensive than others, building checkpost at some junctions might cost more money than other junctions.
You have to determine the minimum possible money needed to ensure the security of all the junctions. Also you have to find the number of ways to ensure the security in minimum price and in addition in minimum number of checkposts. Two ways are different if any of the junctions contains a checkpost in one of them and do not contain in the other.
Input
In the first line, you will be given an integer n, number of junctions (1 β€ n β€ 105). In the next line, n space-separated integers will be given. The ith integer is the cost of building checkpost at the ith junction (costs will be non-negative and will not exceed 109).
The next line will contain an integer m (0 β€ m β€ 3Β·105). And each of the next m lines contains two integers ui and vi (1 β€ ui, vi β€ n; u β v). A pair ui, vi means, that there is a one-way road which goes from ui to vi. There will not be more than one road between two nodes in the same direction.
Output
Print two integers separated by spaces. The first one is the minimum possible money needed to ensure the security of all the junctions. And the second one is the number of ways you can ensure the security modulo 1000000007 (109 + 7).
Examples
Input
3
1 2 3
3
1 2
2 3
3 2
Output
3 1
Input
5
2 8 0 6 0
6
1 4
1 3
2 4
3 4
4 5
5 1
Output
8 2
Input
10
1 3 2 2 1 3 1 4 10 10
12
1 2
2 3
3 1
3 4
4 5
5 6
5 7
6 4
7 3
8 9
9 10
10 9
Output
15 6
Input
2
7 91
2
1 2
2 1
Output
7 1 | from collections import defaultdict,Counter
from sys import setrecursionlimit,stdin
setrecursionlimit(10**5)
import threading
input=stdin.readline
#SCC DO BE OP BRUH
def dfs(node,vis,g,ans):
vis[node]=1
for i in g[node]:
if vis[i]==0:
dfs(i,vis,g,ans)
ans.append(node)
return
def dfs2(node,vis,g,component):
vis[node] = 1
component.append(node)
for i in g[node]:
if vis[i] == 0:
dfs2(i, vis, g,component)
def main():
n=int(input())
g=defaultdict(list)
graph_reversed=defaultdict(list)
lst=list(map(int,input().strip().split()))
for i in range(int(input())):
x,y=map(int,input().strip().split())
g[x].append(y)
graph_reversed[y].append(x)
vis=[0]*(n+1)
order=[]
cost=0
for ind in range(1,n+1):
if vis[ind]==0:
dfs(ind,vis,g,order)
order=order[::-1]
vis=[0]*(n+1)
ans=0
total=1
for ind in order:
if vis[ind]==0:
component=[]
dfs2(ind,vis,graph_reversed,component)
ls=[lst[i-1] for i in component]
cnt=Counter(ls)
mn=min(cnt.keys())
ans+=mn
total=(total*cnt[mn])%(10**9+7)
print(ans,total)
threading.stack_size(10 ** 8)
t = threading.Thread(target=main)
t.start()
t.join() | {
"input": [
"5\n2 8 0 6 0\n6\n1 4\n1 3\n2 4\n3 4\n4 5\n5 1\n",
"3\n1 2 3\n3\n1 2\n2 3\n3 2\n",
"2\n7 91\n2\n1 2\n2 1\n",
"10\n1 3 2 2 1 3 1 4 10 10\n12\n1 2\n2 3\n3 1\n3 4\n4 5\n5 6\n5 7\n6 4\n7 3\n8 9\n9 10\n10 9\n"
],
"output": [
"8 2\n",
"3 1\n",
"7 1\n",
"15 6\n"
]
} |
4,986 | 7 | There are n children in Jzzhu's school. Jzzhu is going to give some candies to them. Let's number all the children from 1 to n. The i-th child wants to get at least ai candies.
Jzzhu asks children to line up. Initially, the i-th child stands at the i-th place of the line. Then Jzzhu start distribution of the candies. He follows the algorithm:
1. Give m candies to the first child of the line.
2. If this child still haven't got enough candies, then the child goes to the end of the line, else the child go home.
3. Repeat the first two steps while the line is not empty.
Consider all the children in the order they go home. Jzzhu wants to know, which child will be the last in this order?
Input
The first line contains two integers n, m (1 β€ n β€ 100; 1 β€ m β€ 100). The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100).
Output
Output a single integer, representing the number of the last child.
Examples
Input
5 2
1 3 1 4 2
Output
4
Input
6 4
1 1 2 2 3 3
Output
6
Note
Let's consider the first sample.
Firstly child 1 gets 2 candies and go home. Then child 2 gets 2 candies and go to the end of the line. Currently the line looks like [3, 4, 5, 2] (indices of the children in order of the line). Then child 3 gets 2 candies and go home, and then child 4 gets 2 candies and goes to the end of the line. Currently the line looks like [5, 2, 4]. Then child 5 gets 2 candies and goes home. Then child 2 gets two candies and goes home, and finally child 4 gets 2 candies and goes home.
Child 4 is the last one who goes home. | import math
n,m = map(int,input().split())
def mo(x):
return math.ceil(int(x)/m)
l = list(map(mo,input().split()))
print(n - l[::-1].index(max(l)))
| {
"input": [
"5 2\n1 3 1 4 2\n",
"6 4\n1 1 2 2 3 3\n"
],
"output": [
"4\n",
"6\n"
]
} |
4,987 | 8 | One way to create a task is to learn from life. You can choose some experience in real life, formalize it and then you will get a new task.
Let's think about a scene in real life: there are lots of people waiting in front of the elevator, each person wants to go to a certain floor. We can formalize it in the following way. We have n people standing on the first floor, the i-th person wants to go to the fi-th floor. Unfortunately, there is only one elevator and its capacity equal to k (that is at most k people can use it simultaneously). Initially the elevator is located on the first floor. The elevator needs |a - b| seconds to move from the a-th floor to the b-th floor (we don't count the time the people need to get on and off the elevator).
What is the minimal number of seconds that is needed to transport all the people to the corresponding floors and then return the elevator to the first floor?
Input
The first line contains two integers n and k (1 β€ n, k β€ 2000) β the number of people and the maximal capacity of the elevator.
The next line contains n integers: f1, f2, ..., fn (2 β€ fi β€ 2000), where fi denotes the target floor of the i-th person.
Output
Output a single integer β the minimal time needed to achieve the goal.
Examples
Input
3 2
2 3 4
Output
8
Input
4 2
50 100 50 100
Output
296
Input
10 3
2 2 2 2 2 2 2 2 2 2
Output
8
Note
In first sample, an optimal solution is:
1. The elevator takes up person #1 and person #2.
2. It goes to the 2nd floor.
3. Both people go out of the elevator.
4. The elevator goes back to the 1st floor.
5. Then the elevator takes up person #3.
6. And it goes to the 2nd floor.
7. It picks up person #2.
8. Then it goes to the 3rd floor.
9. Person #2 goes out.
10. Then it goes to the 4th floor, where person #3 goes out.
11. The elevator goes back to the 1st floor. | def read():
return list(map(int,input().split()))
n, k = read()
a = sorted(read(),reverse=True)
ans = 0
for i in range((n+k-1)//k):
ans += a[i*k]-1
print(2*ans)
| {
"input": [
"10 3\n2 2 2 2 2 2 2 2 2 2\n",
"4 2\n50 100 50 100\n",
"3 2\n2 3 4\n"
],
"output": [
"8\n",
"296\n",
"8\n"
]
} |
4,988 | 9 | You are given an n Γ m rectangular table consisting of lower case English letters. In one operation you can completely remove one column from the table. The remaining parts are combined forming a new table. For example, after removing the second column from the table
abcd
edfg
hijk
we obtain the table:
acd
efg
hjk
A table is called good if its rows are ordered from top to bottom lexicographically, i.e. each row is lexicographically no larger than the following one. Determine the minimum number of operations of removing a column needed to make a given table good.
Input
The first line contains two integers β n and m (1 β€ n, m β€ 100).
Next n lines contain m small English letters each β the characters of the table.
Output
Print a single number β the minimum number of columns that you need to remove in order to make the table good.
Examples
Input
1 10
codeforces
Output
0
Input
4 4
case
care
test
code
Output
2
Input
5 4
code
forc
esco
defo
rces
Output
4
Note
In the first sample the table is already good.
In the second sample you may remove the first and third column.
In the third sample you have to remove all the columns (note that the table where all rows are empty is considered good by definition).
Let strings s and t have equal length. Then, s is lexicographically larger than t if they are not equal and the character following the largest common prefix of s and t (the prefix may be empty) in s is alphabetically larger than the corresponding character of t. | def solve():
n,m=map(int,input().split())
s=[input() for i in range(n)]
f=['' for i in range(n)]
ans=0
for i in range(m):
t=[f[j]+s[j][i] for j in range(n)]
if t==sorted(t):
f=t
else:
ans+=1
print(ans)
solve() | {
"input": [
"1 10\ncodeforces\n",
"5 4\ncode\nforc\nesco\ndefo\nrces\n",
"4 4\ncase\ncare\ntest\ncode\n"
],
"output": [
"0",
"4",
"2"
]
} |
4,989 | 8 | Mike is the president of country What-The-Fatherland. There are n bears living in this country besides Mike. All of them are standing in a line and they are numbered from 1 to n from left to right. i-th bear is exactly ai feet high.
<image>
A group of bears is a non-empty contiguous segment of the line. The size of a group is the number of bears in that group. The strength of a group is the minimum height of the bear in that group.
Mike is a curious to know for each x such that 1 β€ x β€ n the maximum strength among all groups of size x.
Input
The first line of input contains integer n (1 β€ n β€ 2 Γ 105), the number of bears.
The second line contains n integers separated by space, a1, a2, ..., an (1 β€ ai β€ 109), heights of bears.
Output
Print n integers in one line. For each x from 1 to n, print the maximum strength among all groups of size x.
Examples
Input
10
1 2 3 4 5 4 3 2 1 6
Output
6 4 4 3 3 2 2 1 1 1 | from sys import stdin, stdout
def input(): return stdin.readline().strip()
def print(x, end='\n'): stdout.write(str(x) + end)
n, lst = int(input()), list(map(int, input().split()))
nse, pse, stk, ans = [n for i in range(n)], [-1 for i in range(n)], [], [0 for i in range(n)]
for i in range(n):
while stk and lst[stk[-1]] > lst[i]: nse[stk.pop()] = i
stk.append(i)
stk.clear()
for i in range(n-1, -1, -1):
while stk and lst[stk[-1]] > lst[i]: pse[stk.pop()] = i
stk.append(i)
for i in range(n): ans[nse[i] - pse[i] - 2] = max(lst[i], ans[nse[i] - pse[i] - 2])
for i in range(n-2, -1, -1): ans[i] = max(ans[i+1], ans[i])
print(' '.join(map(str, ans))) | {
"input": [
"10\n1 2 3 4 5 4 3 2 1 6\n"
],
"output": [
"6 4 4 3 3 2 2 1 1 1 \n"
]
} |
4,990 | 8 | Pasha has recently bought a new phone jPager and started adding his friends' phone numbers there. Each phone number consists of exactly n digits.
Also Pasha has a number k and two sequences of length n / k (n is divisible by k) a1, a2, ..., an / k and b1, b2, ..., bn / k. Let's split the phone number into blocks of length k. The first block will be formed by digits from the phone number that are on positions 1, 2,..., k, the second block will be formed by digits from the phone number that are on positions k + 1, k + 2, ..., 2Β·k and so on. Pasha considers a phone number good, if the i-th block doesn't start from the digit bi and is divisible by ai if represented as an integer.
To represent the block of length k as an integer, let's write it out as a sequence c1, c2,...,ck. Then the integer is calculated as the result of the expression c1Β·10k - 1 + c2Β·10k - 2 + ... + ck.
Pasha asks you to calculate the number of good phone numbers of length n, for the given k, ai and bi. As this number can be too big, print it modulo 109 + 7.
Input
The first line of the input contains two integers n and k (1 β€ n β€ 100 000, 1 β€ k β€ min(n, 9)) β the length of all phone numbers and the length of each block, respectively. It is guaranteed that n is divisible by k.
The second line of the input contains n / k space-separated positive integers β sequence a1, a2, ..., an / k (1 β€ ai < 10k).
The third line of the input contains n / k space-separated positive integers β sequence b1, b2, ..., bn / k (0 β€ bi β€ 9).
Output
Print a single integer β the number of good phone numbers of length n modulo 109 + 7.
Examples
Input
6 2
38 56 49
7 3 4
Output
8
Input
8 2
1 22 3 44
5 4 3 2
Output
32400
Note
In the first test sample good phone numbers are: 000000, 000098, 005600, 005698, 380000, 380098, 385600, 385698. | def c(a, b, k):
v = (10 ** k - 1) // a + 1
v -= (10 ** (k - 1) * (b + 1) - 1) // a - (10 ** (k - 1) * b - 1) // a
return v
MOD, v = 1000000007, 1
n, k = map(int, input().split())
for a, b in zip(map(int, input().split()), map(int, input().split())):
v = (v * c(a, b, k)) % MOD
print(v) | {
"input": [
"8 2\n1 22 3 44\n5 4 3 2\n",
"6 2\n38 56 49\n7 3 4\n"
],
"output": [
"32400\n",
"8\n"
]
} |
4,991 | 11 | Calculate the value of the sum: n mod 1 + n mod 2 + n mod 3 + ... + n mod m. As the result can be very large, you should print the value modulo 109 + 7 (the remainder when divided by 109 + 7).
The modulo operator a mod b stands for the remainder after dividing a by b. For example 10 mod 3 = 1.
Input
The only line contains two integers n, m (1 β€ n, m β€ 1013) β the parameters of the sum.
Output
Print integer s β the value of the required sum modulo 109 + 7.
Examples
Input
3 4
Output
4
Input
4 4
Output
1
Input
1 1
Output
0 | def sub(a, b):
if a - b < 0:
return a - b + MOD
else:
return a - b
MOD = 10 ** 9 + 7
n, m = [int(x) for x in input().split()]
ans = n * m % MOD
k = min(n, m)
d1 = 1
while d1 * d1 <= n:
if d1 <= k:
ans = sub(ans, (n // d1) * d1 % MOD)
d1 += 1
d = 1
while d * d <= n:
r = min(k, (n // d))
l = max(d1, n // (d + 1) + 1)
if l <= r and l <= k:
s = (l + r) * (r - l + 1) // 2
ans = sub(ans, d * s % MOD)
d += 1
print(ans)
| {
"input": [
"3 4\n",
"4 4\n",
"1 1\n"
],
"output": [
"4\n",
"1\n",
"0\n"
]
} |
4,992 | 9 | Bad news came to Mike's village, some thieves stole a bunch of chocolates from the local factory! Horrible!
Aside from loving sweet things, thieves from this area are known to be very greedy. So after a thief takes his number of chocolates for himself, the next thief will take exactly k times more than the previous one. The value of k (k > 1) is a secret integer known only to them. It is also known that each thief's bag can carry at most n chocolates (if they intend to take more, the deal is cancelled) and that there were exactly four thieves involved.
Sadly, only the thieves know the value of n, but rumours say that the numbers of ways they could have taken the chocolates (for a fixed n, but not fixed k) is m. Two ways are considered different if one of the thieves (they should be numbered in the order they take chocolates) took different number of chocolates in them.
Mike want to track the thieves down, so he wants to know what their bags are and value of n will help him in that. Please find the smallest possible value of n or tell him that the rumors are false and there is no such n.
Input
The single line of input contains the integer m (1 β€ m β€ 1015) β the number of ways the thieves might steal the chocolates, as rumours say.
Output
Print the only integer n β the maximum amount of chocolates that thieves' bags can carry. If there are more than one n satisfying the rumors, print the smallest one.
If there is no such n for a false-rumoured m, print - 1.
Examples
Input
1
Output
8
Input
8
Output
54
Input
10
Output
-1
Note
In the first sample case the smallest n that leads to exactly one way of stealing chocolates is n = 8, whereas the amounts of stealed chocolates are (1, 2, 4, 8) (the number of chocolates stolen by each of the thieves).
In the second sample case the smallest n that leads to exactly 8 ways is n = 54 with the possibilities: (1, 2, 4, 8), (1, 3, 9, 27), (2, 4, 8, 16), (2, 6, 18, 54), (3, 6, 12, 24), (4, 8, 16, 32), (5, 10, 20, 40), (6, 12, 24, 48).
There is no n leading to exactly 10 ways of stealing chocolates in the third sample case. | cubes = [i**3.0 for i in range(2, int(1.8e5+5))]
def valid(mid):
return sum([mid//i for i in cubes if i <= mid])
def binary_search(k):
l = int(4.8 * k)
r = min(8.0 * k, 5.0 * (10**15))
while (l+1 < r):
mid = (l+r) / 2.0
res = valid(mid)
if (res < k):
l = mid
else:
r = mid
return int(r) if int(valid(r)) == k else -1
def main():
k = int(input())
print(binary_search(k))
main()
| {
"input": [
"10\n",
"1\n",
"8\n"
],
"output": [
"-1\n",
"8\n",
"54\n"
]
} |
4,993 | 7 | ZS the Coder and Chris the Baboon are travelling to Udayland! To get there, they have to get on the special IOI bus. The IOI bus has n rows of seats. There are 4 seats in each row, and the seats are separated into pairs by a walkway. When ZS and Chris came, some places in the bus was already occupied.
ZS and Chris are good friends. They insist to get a pair of neighbouring empty seats. Two seats are considered neighbouring if they are in the same row and in the same pair. Given the configuration of the bus, can you help ZS and Chris determine where they should sit?
Input
The first line of the input contains a single integer n (1 β€ n β€ 1000) β the number of rows of seats in the bus.
Then, n lines follow. Each line contains exactly 5 characters, the first two of them denote the first pair of seats in the row, the third character denotes the walkway (it always equals '|') and the last two of them denote the second pair of seats in the row.
Each character, except the walkway, equals to 'O' or to 'X'. 'O' denotes an empty seat, 'X' denotes an occupied seat. See the sample cases for more details.
Output
If it is possible for Chris and ZS to sit at neighbouring empty seats, print "YES" (without quotes) in the first line. In the next n lines print the bus configuration, where the characters in the pair of seats for Chris and ZS is changed with characters '+'. Thus the configuration should differ from the input one by exactly two charaters (they should be equal to 'O' in the input and to '+' in the output).
If there is no pair of seats for Chris and ZS, print "NO" (without quotes) in a single line.
If there are multiple solutions, you may print any of them.
Examples
Input
6
OO|OX
XO|XX
OX|OO
XX|OX
OO|OO
OO|XX
Output
YES
++|OX
XO|XX
OX|OO
XX|OX
OO|OO
OO|XX
Input
4
XO|OX
XO|XX
OX|OX
XX|OX
Output
NO
Input
5
XX|XX
XX|XX
XO|OX
XO|OO
OX|XO
Output
YES
XX|XX
XX|XX
XO|OX
XO|++
OX|XO
Note
Note that the following is an incorrect configuration for the first sample case because the seats must be in the same pair.
O+|+X
XO|XX
OX|OO
XX|OX
OO|OO
OO|XX | import sys
flag = True
def f(l):
global flag
if flag and "OO" in l:
flag = False
l = l.replace("OO", "++", 1)
return l
res = list(map(f, sys.stdin.readlines()[1:]))
print("NO") if flag else print("YES", "".join(res), sep="\n")
| {
"input": [
"4\nXO|OX\nXO|XX\nOX|OX\nXX|OX\n",
"5\nXX|XX\nXX|XX\nXO|OX\nXO|OO\nOX|XO\n",
"6\nOO|OX\nXO|XX\nOX|OO\nXX|OX\nOO|OO\nOO|XX\n"
],
"output": [
"NO\n",
"YES\nXX|XX\nXX|XX\nXO|OX\nXO|++\nOX|XO\n",
"YES\n++|OX\nXO|XX\nOX|OO\nXX|OX\nOO|OO\nOO|XX\n"
]
} |
4,994 | 7 | Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 β€ r β€ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 β€ k β€ 1000, 1 β€ r β€ 9) β the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9Β·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2Β·15 = 30 burles. It is obvious that he can pay this sum without any change. | def ans(a,b):
i=1
while (i*a)%10!=b and (i*a)%10!=0:
i+=1
return i
k,r=map(int,input().split())
print(ans(k,r))
| {
"input": [
"237 7\n",
"15 2\n",
"117 3\n"
],
"output": [
"1\n",
"2\n",
"9\n"
]
} |
4,995 | 8 | A new innovative ticketing systems for public transport is introduced in Bytesburg. Now there is a single travel card for all transport. To make a trip a passenger scan his card and then he is charged according to the fare.
The fare is constructed in the following manner. There are three types of tickets:
1. a ticket for one trip costs 20 byteland rubles,
2. a ticket for 90 minutes costs 50 byteland rubles,
3. a ticket for one day (1440 minutes) costs 120 byteland rubles.
Note that a ticket for x minutes activated at time t can be used for trips started in time range from t to t + x - 1, inclusive. Assume that all trips take exactly one minute.
To simplify the choice for the passenger, the system automatically chooses the optimal tickets. After each trip starts, the system analyses all the previous trips and the current trip and chooses a set of tickets for these trips with a minimum total cost. Let the minimum total cost of tickets to cover all trips from the first to the current is a, and the total sum charged before is b. Then the system charges the passenger the sum a - b.
You have to write a program that, for given trips made by a passenger, calculates the sum the passenger is charged after each trip.
Input
The first line of input contains integer number n (1 β€ n β€ 105) β the number of trips made by passenger.
Each of the following n lines contains the time of trip ti (0 β€ ti β€ 109), measured in minutes from the time of starting the system. All ti are different, given in ascending order, i. e. ti + 1 > ti holds for all 1 β€ i < n.
Output
Output n integers. For each trip, print the sum the passenger is charged after it.
Examples
Input
3
10
20
30
Output
20
20
10
Input
10
13
45
46
60
103
115
126
150
256
516
Output
20
20
10
0
20
0
0
20
20
10
Note
In the first example, the system works as follows: for the first and second trips it is cheaper to pay for two one-trip tickets, so each time 20 rubles is charged, after the third trip the system understands that it would be cheaper to buy a ticket for 90 minutes. This ticket costs 50 rubles, and the passenger had already paid 40 rubles, so it is necessary to charge 10 rubles only. | def go(l, key, plus):
while t[l + 1] + plus - 1 < key:
l += 1
return l
INF = 10 ** 9
n = int(input())
t = [INF] * (n + 1)
t[0] = -INF
c = [0] * (n + 1)
l1 = 0
l2 = 0
for i in range(1, n + 1):
t[i] = int(input())
l1 = go(l1, t[i], 90)
l2 = go(l2, t[i], 1440)
c1 = c[i - 1] + 20
c2 = c[l1] + 50
c3 = c[l2] + 120
c[i] = min(c1, c2, c3)
print(c[i] - c[i - 1]) | {
"input": [
"10\n13\n45\n46\n60\n103\n115\n126\n150\n256\n516\n",
"3\n10\n20\n30\n"
],
"output": [
"20\n20\n10\n0\n20\n0\n0\n20\n20\n10\n",
"20\n20\n10\n"
]
} |
4,996 | 9 | During the lesson small girl Alyona works with one famous spreadsheet computer program and learns how to edit tables.
Now she has a table filled with integers. The table consists of n rows and m columns. By ai, j we will denote the integer located at the i-th row and the j-th column. We say that the table is sorted in non-decreasing order in the column j if ai, j β€ ai + 1, j for all i from 1 to n - 1.
Teacher gave Alyona k tasks. For each of the tasks two integers l and r are given and Alyona has to answer the following question: if one keeps the rows from l to r inclusive and deletes all others, will the table be sorted in non-decreasing order in at least one column? Formally, does there exist such j that ai, j β€ ai + 1, j for all i from l to r - 1 inclusive.
Alyona is too small to deal with this task and asks you to help!
Input
The first line of the input contains two positive integers n and m (1 β€ nΒ·m β€ 100 000) β the number of rows and the number of columns in the table respectively. Note that your are given a constraint that bound the product of these two integers, i.e. the number of elements in the table.
Each of the following n lines contains m integers. The j-th integers in the i of these lines stands for ai, j (1 β€ ai, j β€ 109).
The next line of the input contains an integer k (1 β€ k β€ 100 000) β the number of task that teacher gave to Alyona.
The i-th of the next k lines contains two integers li and ri (1 β€ li β€ ri β€ n).
Output
Print "Yes" to the i-th line of the output if the table consisting of rows from li to ri inclusive is sorted in non-decreasing order in at least one column. Otherwise, print "No".
Example
Input
5 4
1 2 3 5
3 1 3 2
4 5 2 3
5 5 3 2
4 4 3 4
6
1 1
2 5
4 5
3 5
1 3
1 5
Output
Yes
No
Yes
Yes
Yes
No
Note
In the sample, the whole table is not sorted in any column. However, rows 1β3 are sorted in column 1, while rows 4β5 are sorted in column 3. | #!/usr/bin/env python3
def ri():
return map(int, input().split())
n, m = ri()
a = []
for i in range(n):
a.append(list(ri()))
t = [[0 for i in range(m)] for j in range(n)]
T = [0 for i in range(n)]
for i in range(m):
for j in range(n-1):
if a[j][i] > a[j+1][i]:
t[j+1][i] = 0
else:
t[j+1][i] = t[j][i] + 1
for i in range(n):
T[i] = max(t[i])
k = int(input())
ans = []
for i in range(k):
l, r = ri()
l = l-1
r = r-1
if T[r] >= r-l:
ans.append("Yes")
else:
ans.append("No")
print('\n'.join(ans))
| {
"input": [
"5 4\n1 2 3 5\n3 1 3 2\n4 5 2 3\n5 5 3 2\n4 4 3 4\n6\n1 1\n2 5\n4 5\n3 5\n1 3\n1 5\n"
],
"output": [
"Yes\nNo\nYes\nYes\nYes\nNo\n"
]
} |
4,997 | 7 | Your search for Heidi is over β you finally found her at a library, dressed up as a human. In fact, she has spent so much time there that she now runs the place! Her job is to buy books and keep them at the library so that people can borrow and read them. There are n different books, numbered 1 through n.
We will look at the library's operation during n consecutive days. Heidi knows in advance that on the i-th day (1 β€ i β€ n) precisely one person will come to the library, request to borrow the book ai, read it in a few hours, and return the book later on the same day.
Heidi desperately wants to please all her guests, so she will make sure to always have the book ai available in the library on the i-th day. During the night before the i-th day, she has the option of going to the bookstore (which operates at nights to avoid competition with the library) and buying any book for the price of 1 CHF. Of course, if she already has a book at the library, she does not need to buy it again. Initially, the library contains no books.
There is a problem, though. The capacity of the library is k β this means that at any time, there can be at most k books at the library. If buying a new book would cause Heidi to have more than k books, she must first get rid of some book that she already has, in order to make room for the new book. If she later needs a book that she got rid of, she will need to buy that book again.
You are given k and the sequence of requests for books a1, a2, ..., an. What is the minimum cost (in CHF) of buying new books to satisfy all the requests?
Input
The first line of input will contain two integers n and k (1 β€ n, k β€ 80). The second line will contain n integers a1, a2, ..., an (1 β€ ai β€ n) β the sequence of book requests.
Output
On a single line print the minimum cost of buying books at the store so as to satisfy all requests.
Examples
Input
4 80
1 2 2 1
Output
2
Input
4 1
1 2 2 1
Output
3
Input
4 2
1 2 3 1
Output
3
Note
In the first test case, Heidi is able to keep all books forever. Therefore, she only needs to buy the book 1 before the first day and the book 2 before the second day.
In the second test case, she can only keep one book at a time. Therefore she will need to buy new books on the first, second and fourth day.
In the third test case, before buying book 3 on the third day, she must decide which of the books 1 and 2 she should get rid of. Of course, she should keep the book 1, which will be requested on the fourth day. | (n,k) = (int(i) for i in input().split())
order = [int(i) for i in input().split()]
def calculateMinCost(n,k,order):
cost = 0
books = set()
for i in range(n):
if order[i] in books: continue
if len(books)!=k:
cost+=1
books.add(order[i])
else:
lpos = -1
cc = -1
for j in books:
try:
pos = order[i+1:].index(j)
except ValueError:
cc = j
break
if pos>lpos:
lpos = pos
cc = j
books.remove(cc)
books.add(order[i])
cost += 1
print(cost)
calculateMinCost(n,k,order)
| {
"input": [
"4 2\n1 2 3 1\n",
"4 80\n1 2 2 1\n",
"4 1\n1 2 2 1\n"
],
"output": [
"3\n",
"2\n",
"3\n"
]
} |
4,998 | 9 | It's well known that the best way to distract from something is to do one's favourite thing. Job is such a thing for Leha.
So the hacker began to work hard in order to get rid of boredom. It means that Leha began to hack computers all over the world. For such zeal boss gave the hacker a vacation of exactly x days. You know the majority of people prefer to go somewhere for a vacation, so Leha immediately went to the travel agency. There he found out that n vouchers left. i-th voucher is characterized by three integers li, ri, costi β day of departure from ViΔkopolis, day of arriving back in ViΔkopolis and cost of the voucher correspondingly. The duration of the i-th voucher is a value ri - li + 1.
At the same time Leha wants to split his own vocation into two parts. Besides he wants to spend as little money as possible. Formally Leha wants to choose exactly two vouchers i and j (i β j) so that they don't intersect, sum of their durations is exactly x and their total cost is as minimal as possible. Two vouchers i and j don't intersect if only at least one of the following conditions is fulfilled: ri < lj or rj < li.
Help Leha to choose the necessary vouchers!
Input
The first line contains two integers n and x (2 β€ n, x β€ 2Β·105) β the number of vouchers in the travel agency and the duration of Leha's vacation correspondingly.
Each of the next n lines contains three integers li, ri and costi (1 β€ li β€ ri β€ 2Β·105, 1 β€ costi β€ 109) β description of the voucher.
Output
Print a single integer β a minimal amount of money that Leha will spend, or print - 1 if it's impossible to choose two disjoint vouchers with the total duration exactly x.
Examples
Input
4 5
1 3 4
1 2 5
5 6 1
1 2 4
Output
5
Input
3 2
4 6 3
2 4 1
3 5 4
Output
-1
Note
In the first sample Leha should choose first and third vouchers. Hereupon the total duration will be equal to (3 - 1 + 1) + (6 - 5 + 1) = 5 and the total cost will be 4 + 1 = 5.
In the second sample the duration of each voucher is 3 therefore it's impossible to choose two vouchers with the total duration equal to 2. | Q = map
E = input
B = range
W = enumerate
o = len
P = min
q = print
def U():
return Q(int, E().split())
n, x = U()
s = [[] for i in B(x-1)]
for d in B(n):
l, r, c = U()
if r-l < x-1:
s[r-l] += [[l, c]]
for t in s:
t.sort(key=lambda q: q[0])
m = 3e9
for d, t in W(s):
D = x-2-d
i, T = 0, s[D]
M = 3e9
for l, c in t:
while i < o(T)and l > T[i][0]+D:
M = P(M, T[i][1])
i += 1
m = P(m, c+M)
q(-1 if m == 3e9 else m)
| {
"input": [
"4 5\n1 3 4\n1 2 5\n5 6 1\n1 2 4\n",
"3 2\n4 6 3\n2 4 1\n3 5 4\n"
],
"output": [
"5",
"-1"
]
} |
4,999 | 9 | β This is not playing but duty as allies of justice, Nii-chan!
β Not allies but justice itself, Onii-chan!
With hands joined, go everywhere at a speed faster than our thoughts! This time, the Fire Sisters β Karen and Tsukihi β is heading for somewhere they've never reached β water-surrounded islands!
There are three clusters of islands, conveniently coloured red, blue and purple. The clusters consist of a, b and c distinct islands respectively.
Bridges have been built between some (possibly all or none) of the islands. A bridge bidirectionally connects two different islands and has length 1. For any two islands of the same colour, either they shouldn't be reached from each other through bridges, or the shortest distance between them is at least 3, apparently in order to prevent oddities from spreading quickly inside a cluster.
The Fire Sisters are ready for the unknown, but they'd also like to test your courage. And you're here to figure out the number of different ways to build all bridges under the constraints, and give the answer modulo 998 244 353. Two ways are considered different if a pair of islands exist, such that there's a bridge between them in one of them, but not in the other.
Input
The first and only line of input contains three space-separated integers a, b and c (1 β€ a, b, c β€ 5 000) β the number of islands in the red, blue and purple clusters, respectively.
Output
Output one line containing an integer β the number of different ways to build bridges, modulo 998 244 353.
Examples
Input
1 1 1
Output
8
Input
1 2 2
Output
63
Input
1 3 5
Output
3264
Input
6 2 9
Output
813023575
Note
In the first example, there are 3 bridges that can possibly be built, and no setup of bridges violates the restrictions. Thus the answer is 23 = 8.
In the second example, the upper two structures in the figure below are instances of valid ones, while the lower two are invalid due to the blue and purple clusters, respectively.
<image> | a,b,c=map(int,input().split())
M=998244353
def C(x, y):
z,t=0, 1
for i in range(min(x,y)+1):
z+=t
t*=(x-i)*(y-i)*pow(i+1,M-2,M)%M
return z
print(C(a,b)*C(a,c)*C(b,c)%M)
| {
"input": [
"1 3 5\n",
"1 1 1\n",
"6 2 9\n",
"1 2 2\n"
],
"output": [
"3264\n",
"8\n",
"813023575\n",
"63\n"
]
} |