question large_stringlengths 265 13.2k |
|---|
Solve the programming task below in a Python markdown code block.
Selection of Participants of an Experiment
Dr. Tsukuba has devised a new method of programming training. In order to evaluate the effectiveness of this method, he plans to carry out a control experiment. Having two students as the participants of the experiment, one of them will be trained under the conventional method and the other under his new method. Comparing the final scores of these two, he will be able to judge the effectiveness of his method.
It is important to select two students having the closest possible scores, for making the comparison fair. He has a list of the scores of all students who can participate in the experiment. You are asked to write a program which selects two of them having the smallest difference in their scores.
Input
The input consists of multiple datasets, each in the following format.
n
a1 a2 β¦ an
A dataset consists of two lines. The number of students n is given in the first line. n is an integer satisfying 2 β€ n β€ 1000. The second line gives scores of n students. ai (1 β€ i β€ n) is the score of the i-th student, which is a non-negative integer not greater than 1,000,000.
The end of the input is indicated by a line containing a zero. The sum of n's of all the datasets does not exceed 50,000.
Output
For each dataset, select two students with the smallest difference in their scores, and output in a line (the absolute value of) the difference.
Sample Input
5
10 10 10 10 10
5
1 5 8 9 11
7
11 34 83 47 59 29 70
0
Output for the Sample Input
0
1
5
Example
Input
5
10 10 10 10 10
5
1 5 8 9 11
7
11 34 83 47 59 29 70
0
Output
0
1
5
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Taro has decided to move. Taro has a lot of luggage, so I decided to ask a moving company to carry the luggage. Since there are various weights of luggage, I asked them to arrange them in order from the lightest one for easy understanding, but the mover left the luggage in a different order. So Taro tried to sort the luggage, but the luggage is heavy and requires physical strength to carry. Each piece of luggage can be carried from where it is now to any place you like, such as between other pieces of luggage or at the edge of the piece of luggage, but carrying one piece of luggage uses as much physical strength as the weight of that piece of luggage. Taro doesn't have much physical strength, so I decided to think of a way to arrange the luggage in order from the lightest one without using as much physical strength as possible.
Constraints
> 1 β€ n β€ 105
> 1 β€ xi β€ n (1 β€ i β€ n)
> xi β xj (1 β€ i, j β€ n and i β j)
>
* All inputs are given as integers
Input
> n
> x1 x2 ... xn
>
* n represents the number of luggage that Taro has
* x1 to xn represent the weight of each piece of luggage, and are currently arranged in the order of x1, x2, ..., xn.
Output
> S
>
* Output the total S of the minimum physical strength required to arrange the luggage in order from the lightest, but output the line break at the end
Examples
Input
4
1 4 2 3
Output
4
Input
5
1 5 3 2 4
Output
7
Input
7
1 2 3 4 5 6 7
Output
0
Input
8
6 2 1 3 8 5 4 7
Output
19
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Curry making
As the ACM-ICPC domestic qualifying is approaching, you who wanted to put more effort into practice decided to participate in a competitive programming camp held at a friend's house. Participants decided to prepare their own meals.
On the first night of the training camp, the participants finished the day's practice and began preparing dinner. Not only in competitive programming, but also in self-catering, you are often said to be a "professional", and you have spared time because you have finished making the menu for your charge in a blink of an eye. Therefore, I decided to help other people make curry.
Now, there is a curry made by mixing R0 [g] roux with W0 [L] water. There is one type of roux used this time, and each roux is R [g]. Ru has a sufficient stockpile. When you use this roux, you think that the curry with a concentration of C [g / L] is the most delicious, so add some roux and water to this curry appropriately to make the concentration C [g / L]. I want to. Here, the concentration of curry in which roux R0 [g] is dissolved in water W0 [L] is R0 / W0 [g / L], and X roux of R [g] and water Y [L] are added to this curry. ] Is added, the concentration becomes (R0 + XR) / (W0 + Y) [g / L]. Although there are a lot of roux, you thought that it was not good to use too much, so you decided to make a curry with a concentration of C [g / L] by reducing the number of roux to be added as much as possible.
When making a curry with a concentration of C [g / L] by properly adding either roux, water, or both to a curry with a concentration of R0 / W0 [g / L], the number of roux X to be added Find the minimum value.
However, please note the following points regarding the curry making this time.
* Number of roux to be added The value of X must be an integer greater than or equal to 0. In other words, it is not possible to add only 1/3 of the roux.
* The value of the volume Y of water to be added can be a real number greater than or equal to 0, and does not have to be an integer.
* In some cases, it is possible to make curry with a concentration of C without adding either roux, water, or both.
* Since a sufficient amount of roux and water is secured, it is good that the situation that the curry with concentration C cannot be made due to lack of roux and water does not occur.
Input
The input consists of multiple datasets. Each dataset consists of one line and is expressed in the following format.
> R0 W0 C R
Here, R0, W0, C, and R are the mass of roux already dissolved in the curry that is being made [g], the volume of water contained in the curry [L], and the concentration of the curry you want to make [g / L]. , Represents the mass [g] per roux. All of these values ββare integers between 1 and 100. The end of the input is indicated by a line of four zeros separated by blanks.
Output
For each dataset, one line is the minimum number of roux that needs to be added to make a curry with a concentration of C from a fake curry that is a mixture of W0 [L] water and R0 [g] roux. To output. Do not output the amount of water to add.
Note that due to input constraints, the minimum number of roux that is the answer for each dataset is guaranteed to be within the range represented by a 32-bit signed integer.
Sample Input
10 5 3 4
2 5 2 3
91 13 7 62
10 1 3 5
20 100 2 20
2 14 7 1
0 0 0 0
Output for Sample Input
2
3
0
0
9
96
Example
Input
10 5 3 4
2 5 2 3
91 13 7 62
10 1 3 5
20 100 2 20
2 14 7 1
0 0 0 0
Output
2
3
0
0
9
96
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Revised
The current era, Heisei, will end on April 30, 2019, and a new era will begin the next day. The day after the last day of Heisei will be May 1, the first year of the new era.
In the system developed by the ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG), the date uses the Japanese calendar (the Japanese calendar that expresses the year by the era name and the number of years following it). It is saved in the database in the format of "d days". Since this storage format cannot be changed, JAG saves the date expressed in the Japanese calendar in the database assuming that the era name does not change, and converts the date to the format using the correct era name at the time of output. It was to be.
Your job is to write a program that converts the dates stored in the JAG database to dates using the Heisei or new era. Since the new era has not been announced yet, we will use "?" To represent it.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> g y m d
g is a character string representing the era name, and g = HEISEI holds. y, m, and d are integers that represent the year, month, and day, respectively. 1 β€ y β€ 100, 1 β€ m β€ 12, 1 β€ d β€ 31 holds.
Dates that do not exist in the Japanese calendar, such as February 30, are not given as a dataset. When converted correctly as the Japanese calendar, the date on which the era before Heisei must be used is not given as a data set.
The end of the input is represented by a line consisting of only one'#'. The number of datasets does not exceed 100.
Output
For each data set, separate the converted era, year, month, and day with a space and output it on one line. If the converted era is "Heisei", use "HEISEI" as the era, and if it is a new era, use "?".
Normally, the first year of the era is written as the first year, but in the output of this problem, ignore this rule and output 1 as the year.
Sample Input
HEISEI 1 1 8
HEISEI 31 4 30
HEISEI 31 5 1
HEISEI 99 12 31
HEISEI 38 8 30
HEISEI 98 2 22
HEISEI 2 3 26
HEISEI 28 4 23
Output for the Sample Input
HEISEI 1 1 8
HEISEI 31 4 30
? 1 5 1
? 69 12 31
? 8 8 30
? 68 2 22
HEISEI 2 3 26
HEISEI 28 4 23
Example
Input
HEISEI 1 1 8
HEISEI 31 4 30
HEISEI 31 5 1
HEISEI 99 12 31
HEISEI 38 8 30
HEISEI 98 2 22
HEISEI 2 3 26
HEISEI 28 4 23
#
Output
HEISEI 1 1 8
HEISEI 31 4 30
? 1 5 1
? 69 12 31
? 8 8 30
? 68 2 22
HEISEI 2 3 26
HEISEI 28 4 23
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Problem
Given the strings $ s $, $ t $.
First, let the string set $ A = $ {$ s $}, $ B = \ phi $.
At this time, I want to perform the following operations as much as possible.
operation
step1
Perform the following processing for all $ u β A $.
1. From all subsequences of $ u $ (not necessarily contiguous), choose any one that is equal to $ t $. Let the indexes corresponding to $ u $ of the selected subsequence be $ z_1 $, $ z_2 $,β¦, $ z_ {| t |} $ (however, 1 $ \ le $ $ z_1 $ $ \ lt $ $ z_2). $$ \ lt $β¦ $ \ lt $ $ z_ {| t |} $ $ \ le $ $ | u | $). If there is no such subsequence, the operation ends.
2. Divide the original string with the selected substring characters $ u_ {z_1} $, $ u_ {z_2} $,β¦, $ u_ {z_ {| t |}} $ and convert them to $ B $ to add.
For example, in the case of $ u = $ "abcdcd" and $ t = $ "ac", the following two division methods can be considered.
If you choose the first and third characters of $ u $, it will be split into "", "b" and "dcd".
If you choose the first and fifth characters of $ u $, it will be split into "", "bcd" and "d".
step2
Replace $ A $ with $ B $ and empty $ B $.
Increase the number of operations by 1.
Subsequence example
The subsequences of "abac" are {"", "a", "b", "c", "aa", "ab", "ac", "ba", "bc", "aac", "aba" "," abc "," bac "," abac "}.
"a" is a subsequence created by extracting the first or third character of "abac".
"ac" is a subsequence created by extracting the 1st and 4th characters of "abac" or the 3rd and 4th characters.
Constraints
The input satisfies the following conditions.
* 1 $ \ le $ $ | t | $ $ \ le $ $ | s | $ $ \ le $ $ 10 ^ 5 $
* Characters contained in the strings $ s $ and $ t $ are uppercase or lowercase letters of the alphabet
Input
The input is given in the following format.
$ s $
$ t $
The string $ s $ is given on the first line, and the string $ t $ is given on the second line.
Output
Output the maximum number of operations.
Examples
Input
AABABCAC
A
Output
2
Input
abaabbabaabaabbabbabaabbab
ab
Output
3
Input
AbCdEfG
aBcDeFg
Output
0
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Write a program which converts uppercase/lowercase letters to lowercase/uppercase for a given string.
Constraints
* The length of the input string < 1200
Input
A string is given in a line.
Output
Print the converted string in a line. Note that you do not need to convert any characters other than alphabetical letters.
Example
Input
fAIR, LATER, OCCASIONALLY CLOUDY.
Output
Fair, later, occasionally cloudy.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Chef has a box full of infinite number of identical coins. One day while playing, he made N piles each containing equal number of coins. Chef suddenly remembered an important task and left the room for sometime. While he was away, his newly hired assistant came across the piles and mixed them up while playing.
When Chef returned home, he was angry to see that all of his piles didn't contain equal number of coins as he very strongly believes in the policy of equality for all, may it be people or piles of coins.
In order to calm down the Chef, the assistant proposes to make all the piles equal. Chef agrees to give this task to him, but as a punishment gives him only two type of operations that he can perform.
Pick some coins from any pile and put them back in Chef's coin box.
Pick some coins from the Chef's coin box and put them on any one pile.
The assistant wants to do this task as fast as possible. So he wants to know the minimum number of operations needed to make all the piles equal.
Input
The first line of the input contains an integer T denoting the number of test cases.
The first line of each test case contains a single integer N denoting the number of piles.
The second line contains N space-separated integers A1, A2, ..., AN denoting the number of coins in each pile.
Output
For each test case, output a single line containing an integer corresponding to the minimum number of operations assistant needs to do.
Constraints
1 β€ T β€ 10
1 β€ N β€ 10^5
1 β€ Ai β€ 10^5
Sub tasks
Example
Input:
1
4
1 2 3 4
Output:
3
Explanation
In test case 1, if you decide to convert all the piles to contain either of 1, 2, 3, or 4 coins you will have to change the other 3 piles. For any other choice you will have to alter more than 3 (i.e. 4) piles.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
The sequence of integers a_1, a_2, ..., a_k is called a good array if a_1 = k - 1 and a_1 > 0. For example, the sequences [3, -1, 44, 0], [1, -99] are good arrays, and the sequences [3, 7, 8], [2, 5, 4, 1], [0] β are not.
A sequence of integers is called good if it can be divided into a positive number of good arrays. Each good array should be a subsegment of sequence and each element of the sequence should belong to exactly one array. For example, the sequences [2, -3, 0, 1, 4], [1, 2, 3, -3, -9, 4] are good, and the sequences [2, -3, 0, 1], [1, 2, 3, -3 -9, 4, 1] β are not.
For a given sequence of numbers, count the number of its subsequences that are good sequences, and print the number of such subsequences modulo 998244353.
Input
The first line contains the number n~(1 β€ n β€ 10^3) β the length of the initial sequence. The following line contains n integers a_1, a_2, ..., a_n~(-10^9 β€ a_i β€ 10^9) β the sequence itself.
Output
In the single line output one integer β the number of subsequences of the original sequence that are good sequences, taken modulo 998244353.
Examples
Input
3
2 1 1
Output
2
Input
4
1 1 1 1
Output
7
Note
In the first test case, two good subsequences β [a_1, a_2, a_3] and [a_2, a_3].
In the second test case, seven good subsequences β [a_1, a_2, a_3, a_4], [a_1, a_2], [a_1, a_3], [a_1, a_4], [a_2, a_3], [a_2, a_4] and [a_3, a_4].
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly β you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cardsβ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
There are n houses along the road where Anya lives, each one is painted in one of k possible colors.
Anya likes walking along this road, but she doesn't like when two adjacent houses at the road have the same color. She wants to select a long segment of the road such that no two adjacent houses have the same color.
Help Anya find the longest segment with this property.
Input
The first line contains two integers n and k β the number of houses and the number of colors (1 β€ n β€ 100 000, 1 β€ k β€ 100 000).
The next line contains n integers a_1, a_2, β¦, a_n β the colors of the houses along the road (1 β€ a_i β€ k).
Output
Output a single integer β the maximum number of houses on the road segment having no two adjacent houses of the same color.
Example
Input
8 3
1 2 3 3 2 1 2 2
Output
4
Note
In the example, the longest segment without neighboring houses of the same color is from the house 4 to the house 7. The colors of the houses are [3, 2, 1, 2] and its length is 4 houses.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 β€ n β€ 106) β the sum of digits of the required lucky number.
Output
Print on the single line the result β the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations β or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 β€ n β€ 2 β
10^{5}) β the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k β the minimum number of operations required to make the strings equal. In each of the next k lines print two integers β the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You have a password which you often type β a string s of length n. Every character of this string is one of the first m lowercase Latin letters.
Since you spend a lot of time typing it, you want to buy a new keyboard.
A keyboard is a permutation of the first m Latin letters. For example, if m = 3, then there are six possible keyboards: abc, acb, bac, bca, cab and cba.
Since you type your password with one finger, you need to spend time moving your finger from one password character to the next. The time to move from character s_i to character s_{i+1} is equal to the distance between these characters on keyboard. The total time you have to spend typing the password with a keyboard is called the slowness of this keyboard.
More formaly, the slowness of keyboard is equal to β_{i=2}^{n} |pos_{s_{i-1}} - pos_{s_i} |, where pos_x is position of letter x in keyboard.
For example, if s is aacabc and the keyboard is bac, then the total time of typing this password is |pos_a - pos_a| + |pos_a - pos_c| + |pos_c - pos_a| + |pos_a - pos_b| + |pos_b - pos_c| = |2 - 2| + |2 - 3| + |3 - 2| + |2 - 1| + |1 - 3| = 0 + 1 + 1 + 1 + 2 = 5.
Before buying a new keyboard you want to know the minimum possible slowness that the keyboard can have.
Input
The first line contains two integers n and m (1 β€ n β€ 10^5, 1 β€ m β€ 20).
The second line contains the string s consisting of n characters. Each character is one of the first m Latin letters (lowercase).
Output
Print one integer β the minimum slowness a keyboard can have.
Examples
Input
6 3
aacabc
Output
5
Input
6 4
aaaaaa
Output
0
Input
15 4
abacabadabacaba
Output
16
Note
The first test case is considered in the statement.
In the second test case the slowness of any keyboard is 0.
In the third test case one of the most suitable keyboards is bacd.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You are given two strings s and t both of length n and both consisting of lowercase Latin letters.
In one move, you can choose any length len from 1 to n and perform the following operation:
* Choose any contiguous substring of the string s of length len and reverse it;
* at the same time choose any contiguous substring of the string t of length len and reverse it as well.
Note that during one move you reverse exactly one substring of the string s and exactly one substring of the string t.
Also note that borders of substrings you reverse in s and in t can be different, the only restriction is that you reverse the substrings of equal length. For example, if len=3 and n=5, you can reverse s[1 ... 3] and t[3 ... 5], s[2 ... 4] and t[2 ... 4], but not s[1 ... 3] and t[1 ... 2].
Your task is to say if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 β€ q β€ 10^4) β the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 β€ n β€ 2 β
10^5) β the length of s and t.
The second line of the test case contains one string s consisting of n lowercase Latin letters.
The third line of the test case contains one string t consisting of n lowercase Latin letters.
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 on it β "YES" (without quotes) if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves and "NO" otherwise.
Example
Input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc
Output
NO
YES
NO
YES
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
We start with a string s consisting only of the digits 1, 2, or 3. The length of s is denoted by |s|. For each i from 1 to |s|, the i-th character of s is denoted by s_i.
There is one cursor. The cursor's location β is denoted by an integer in \{0, β¦, |s|\}, with the following meaning:
* If β = 0, then the cursor is located before the first character of s.
* If β = |s|, then the cursor is located right after the last character of s.
* If 0 < β < |s|, then the cursor is located between s_β and s_{β+1}.
We denote by s_left the string to the left of the cursor and s_right the string to the right of the cursor.
We also have a string c, which we call our clipboard, which starts out as empty. There are three types of actions:
* The Move action. Move the cursor one step to the right. This increments β once.
* The Cut action. Set c β s_right, then set s β s_left.
* The Paste action. Append the value of c to the end of the string s. Note that this doesn't modify c.
The cursor initially starts at β = 0. Then, we perform the following procedure:
1. Perform the Move action once.
2. Perform the Cut action once.
3. Perform the Paste action s_β times.
4. If β = x, stop. Otherwise, return to step 1.
You're given the initial string s and the integer x. What is the length of s when the procedure stops? Since this value may be very large, only find it modulo 10^9 + 7.
It is guaranteed that β β€ |s| at any time.
Input
The first line of input contains a single integer t (1 β€ t β€ 1000) denoting the number of test cases. The next lines contain descriptions of the test cases.
The first line of each test case contains a single integer x (1 β€ x β€ 10^6). The second line of each test case consists of the initial string s (1 β€ |s| β€ 500). It is guaranteed, that s consists of the characters "1", "2", "3".
It is guaranteed that the sum of x in a single file is at most 10^6. It is guaranteed that in each test case before the procedure will stop it will be true that β β€ |s| at any time.
Output
For each test case, output a single line containing a single integer denoting the answer for that test case modulo 10^9 + 7.
Example
Input
4
5
231
7
2323
6
333
24
133321333
Output
25
1438
1101
686531475
Note
Let's illustrate what happens with the first test case. Initially, we have s = 231. Initially, β = 0 and c = \varepsilon (the empty string). The following things happen if we follow the procedure above:
* Step 1, Move once: we get β = 1.
* Step 2, Cut once: we get s = 2 and c = 31.
* Step 3, Paste s_β = 2 times: we get s = 23131.
* Step 4: β = 1 not= x = 5, so we return to step 1.
* Step 1, Move once: we get β = 2.
* Step 2, Cut once: we get s = 23 and c = 131.
* Step 3, Paste s_β = 3 times: we get s = 23131131131.
* Step 4: β = 2 not= x = 5, so we return to step 1.
* Step 1, Move once: we get β = 3.
* Step 2, Cut once: we get s = 231 and c = 31131131.
* Step 3, Paste s_β = 1 time: we get s = 23131131131.
* Step 4: β = 3 not= x = 5, so we return to step 1.
* Step 1, Move once: we get β = 4.
* Step 2, Cut once: we get s = 2313 and c = 1131131.
* Step 3, Paste s_β = 3 times: we get s = 2313113113111311311131131.
* Step 4: β = 4 not= x = 5, so we return to step 1.
* Step 1, Move once: we get β = 5.
* Step 2, Cut once: we get s = 23131 and c = 13113111311311131131.
* Step 3, Paste s_β = 1 times: we get s = 2313113113111311311131131.
* Step 4: β = 5 = x, so we stop.
At the end of the procedure, s has length 25.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You are given some Tetris field consisting of n columns. The initial height of the i-th column of the field is a_i blocks. On top of these columns you can place only figures of size 2 Γ 1 (i.e. the height of this figure is 2 blocks and the width of this figure is 1 block). Note that you cannot rotate these figures.
Your task is to say if you can clear the whole field by placing such figures.
More formally, the problem can be described like this:
The following process occurs while at least one a_i is greater than 0:
1. You place one figure 2 Γ 1 (choose some i from 1 to n and replace a_i with a_i + 2);
2. then, while all a_i are greater than zero, replace each a_i with a_i - 1.
And your task is to determine if it is possible to clear the whole field (i.e. finish the described process), choosing the places for new figures properly.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases.
The next 2t lines describe test cases. The first line of the test case contains one integer n (1 β€ n β€ 100) β the number of columns in the Tetris field. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 100), where a_i is the initial height of the i-th column of the Tetris field.
Output
For each test case, print the answer β "YES" (without quotes) if you can clear the whole Tetris field and "NO" otherwise.
Example
Input
4
3
1 1 3
4
1 1 2 1
2
11 11
1
100
Output
YES
NO
YES
YES
Note
The first test case of the example field is shown below:
<image>
Gray lines are bounds of the Tetris field. Note that the field has no upper bound.
One of the correct answers is to first place the figure in the first column. Then after the second step of the process, the field becomes [2, 0, 2]. Then place the figure in the second column and after the second step of the process, the field becomes [0, 0, 0].
And the second test case of the example field is shown below:
<image>
It can be shown that you cannot do anything to end the process.
In the third test case of the example, you first place the figure in the second column after the second step of the process, the field becomes [0, 2]. Then place the figure in the first column and after the second step of the process, the field becomes [0, 0].
In the fourth test case of the example, place the figure in the first column, then the field becomes [102] after the first step of the process, and then the field becomes [0] after the second step of the process.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 β€ t β€ 50) β the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 β€ n, m β€ 50) β the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} β \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You are given a sequence of n integers a_1, a_2, β¦, a_n.
You have to construct two sequences of integers b and c with length n that satisfy:
* for every i (1β€ iβ€ n) b_i+c_i=a_i
* b is non-decreasing, which means that for every 1<iβ€ n, b_iβ₯ b_{i-1} must hold
* c is non-increasing, which means that for every 1<iβ€ n, c_iβ€ c_{i-1} must hold
You have to minimize max(b_i,c_i). In other words, you have to minimize the maximum number in sequences b and c.
Also there will be q changes, the i-th change is described by three integers l,r,x. You should add x to a_l,a_{l+1}, β¦, a_r.
You have to find the minimum possible value of max(b_i,c_i) for the initial sequence and for sequence after each change.
Input
The first line contains an integer n (1β€ nβ€ 10^5).
The secound line contains n integers a_1,a_2,β¦,a_n (1β€ iβ€ n, -10^9β€ a_iβ€ 10^9).
The third line contains an integer q (1β€ qβ€ 10^5).
Each of the next q lines contains three integers l,r,x (1β€ lβ€ rβ€ n,-10^9β€ xβ€ 10^9), desribing the next change.
Output
Print q+1 lines.
On the i-th (1 β€ i β€ q+1) line, print the answer to the problem for the sequence after i-1 changes.
Examples
Input
4
2 -1 7 3
2
2 4 -3
3 4 2
Output
5
5
6
Input
6
-9 -10 -9 -6 -5 4
3
2 6 -9
1 2 -10
4 6 -3
Output
3
3
3
1
Input
1
0
2
1 1 -1
1 1 -1
Output
0
0
-1
Note
In the first test:
* The initial sequence a = (2, -1, 7, 3). Two sequences b=(-3,-3,5,5),c=(5,2,2,-2) is a possible choice.
* After the first change a = (2, -4, 4, 0). Two sequences b=(-3,-3,5,5),c=(5,-1,-1,-5) is a possible choice.
* After the second change a = (2, -4, 6, 2). Two sequences b=(-4,-4,6,6),c=(6,0,0,-4) is a possible choice.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You found a useless array a of 2n positive integers. You have realized that you actually don't need this array, so you decided to throw out all elements of a.
It could have been an easy task, but it turned out that you should follow some rules:
1. In the beginning, you select any positive integer x.
2. Then you do the following operation n times:
* select two elements of array with sum equals x;
* remove them from a and replace x with maximum of that two numbers.
For example, if initially a = [3, 5, 1, 2], you can select x = 6. Then you can select the second and the third elements of a with sum 5 + 1 = 6 and throw them out. After this operation, x equals 5 and there are two elements in array: 3 and 2. You can throw them out on the next operation.
Note, that you choose x before the start and can't change it as you want between the operations.
Determine how should you behave to throw out all elements of a.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains the single integer n (1 β€ n β€ 1000).
The second line of each test case contains 2n integers a_1, a_2, ..., a_{2n} (1 β€ a_i β€ 10^6) β the initial array a.
It is guaranteed that the total sum of n over all test cases doesn't exceed 1000.
Output
For each test case in the first line print YES if it is possible to throw out all elements of the array and NO otherwise.
If it is possible to throw out all elements, print the initial value of x you've chosen. Print description of n operations next. For each operation, print the pair of integers you remove.
Example
Input
4
2
3 5 1 2
3
1 1 8 8 64 64
2
1 1 2 4
5
1 2 3 4 5 6 7 14 3 11
Output
YES
6
1 5
2 3
NO
NO
YES
21
14 7
3 11
5 6
2 4
3 1
Note
The first test case was described in the statement.
In the second and third test cases, we can show that it is impossible to throw out all elements of array a.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
By 2312 there were n Large Hadron Colliders in the inhabited part of the universe. Each of them corresponded to a single natural number from 1 to n. However, scientists did not know what activating several colliders simultaneously could cause, so the colliders were deactivated.
In 2312 there was a startling discovery: a collider's activity is safe if and only if all numbers of activated colliders are pairwise relatively prime to each other (two numbers are relatively prime if their greatest common divisor equals 1)! If two colliders with relatively nonprime numbers are activated, it will cause a global collapse.
Upon learning this, physicists rushed to turn the colliders on and off and carry out all sorts of experiments. To make sure than the scientists' quickness doesn't end with big trouble, the Large Hadron Colliders' Large Remote Control was created. You are commissioned to write the software for the remote (well, you do not expect anybody to operate it manually, do you?).
Initially, all colliders are deactivated. Your program receives multiple requests of the form "activate/deactivate the i-th collider". The program should handle requests in the order of receiving them. The program should print the processed results in the format described below.
To the request of "+ i" (that is, to activate the i-th collider), the program should print exactly one of the following responses:
* "Success" if the activation was successful.
* "Already on", if the i-th collider was already activated before the request.
* "Conflict with j", if there is a conflict with the j-th collider (that is, the j-th collider is on, and numbers i and j are not relatively prime). In this case, the i-th collider shouldn't be activated. If a conflict occurs with several colliders simultaneously, you should print the number of any of them.
The request of "- i" (that is, to deactivate the i-th collider), should receive one of the following responses from the program:
* "Success", if the deactivation was successful.
* "Already off", if the i-th collider was already deactivated before the request.
You don't need to print quotes in the output of the responses to the requests.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 105) β the number of colliders and the number of requests, correspondingly.
Next m lines contain numbers of requests, one per line, in the form of either "+ i" (without the quotes) β activate the i-th collider, or "- i" (without the quotes) β deactivate the i-th collider (1 β€ i β€ n).
Output
Print m lines β the results of executing requests in the above given format. The requests should be processed in the order, in which they are given in the input. Don't forget that the responses to the requests should be printed without quotes.
Examples
Input
10 10
+ 6
+ 10
+ 5
- 10
- 5
- 6
+ 10
+ 3
+ 6
+ 3
Output
Success
Conflict with 6
Success
Already off
Success
Success
Success
Success
Conflict with 10
Already on
Note
Note that in the sample the colliders don't turn on after the second and ninth requests. The ninth request could also receive response "Conflict with 3".
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
The Smart Beaver from ABBYY invented a new message encryption method and now wants to check its performance. Checking it manually is long and tiresome, so he decided to ask the ABBYY Cup contestants for help.
A message is a sequence of n integers a1, a2, ..., an. Encryption uses a key which is a sequence of m integers b1, b2, ..., bm (m β€ n). All numbers from the message and from the key belong to the interval from 0 to c - 1, inclusive, and all the calculations are performed modulo c.
Encryption is performed in n - m + 1 steps. On the first step we add to each number a1, a2, ..., am a corresponding number b1, b2, ..., bm. On the second step we add to each number a2, a3, ..., am + 1 (changed on the previous step) a corresponding number b1, b2, ..., bm. And so on: on step number i we add to each number ai, ai + 1, ..., ai + m - 1 a corresponding number b1, b2, ..., bm. The result of the encryption is the sequence a1, a2, ..., an after n - m + 1 steps.
Help the Beaver to write a program that will encrypt messages in the described manner.
Input
The first input line contains three integers n, m and c, separated by single spaces.
The second input line contains n integers ai (0 β€ ai < c), separated by single spaces β the original message.
The third input line contains m integers bi (0 β€ bi < c), separated by single spaces β the encryption key.
The input limitations for getting 30 points are:
* 1 β€ m β€ n β€ 103
* 1 β€ c β€ 103
The input limitations for getting 100 points are:
* 1 β€ m β€ n β€ 105
* 1 β€ c β€ 103
Output
Print n space-separated integers β the result of encrypting the original message.
Examples
Input
4 3 2
1 1 1 1
1 1 1
Output
0 1 1 0
Input
3 1 5
1 2 3
4
Output
0 1 2
Note
In the first sample the encryption is performed in two steps: after the first step a = (0, 0, 0, 1) (remember that the calculations are performed modulo 2), after the second step a = (0, 1, 1, 0), and that is the answer.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
One day shooshuns found a sequence of n integers, written on a blackboard. The shooshuns can perform one operation with it, the operation consists of two steps:
1. Find the number that goes k-th in the current sequence and add the same number to the end of the sequence;
2. Delete the first number of the current sequence.
The shooshuns wonder after how many operations all numbers on the board will be the same and whether all numbers will ever be the same.
Input
The first line contains two space-separated integers n and k (1 β€ k β€ n β€ 105).
The second line contains n space-separated integers: a1, a2, ..., an (1 β€ ai β€ 105) β the sequence that the shooshuns found.
Output
Print the minimum number of operations, required for all numbers on the blackboard to become the same. If it is impossible to achieve, print -1.
Examples
Input
3 2
3 1 1
Output
1
Input
3 1
3 1 1
Output
-1
Note
In the first test case after the first operation the blackboard will have sequence [1, 1, 1]. So, one operation is enough to make all numbers the same. Thus, the answer equals one.
In the second test case the sequence will never consist of the same numbers. It will always contain at least two distinct numbers 3 and 1. Thus, the answer equals -1.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Shaass has n books. He wants to make a bookshelf for all his books. He wants the bookshelf's dimensions to be as small as possible. The thickness of the i-th book is ti and its pages' width is equal to wi. The thickness of each book is either 1 or 2. All books have the same page heights.
<image>
Shaass puts the books on the bookshelf in the following way. First he selects some of the books and put them vertically. Then he puts the rest of the books horizontally above the vertical books. The sum of the widths of the horizontal books must be no more than the total thickness of the vertical books. A sample arrangement of the books is depicted in the figure.
<image>
Help Shaass to find the minimum total thickness of the vertical books that we can achieve.
Input
The first line of the input contains an integer n, (1 β€ n β€ 100). Each of the next n lines contains two integers ti and wi denoting the thickness and width of the i-th book correspondingly, (1 β€ ti β€ 2, 1 β€ wi β€ 100).
Output
On the only line of the output print the minimum total thickness of the vertical books that we can achieve.
Examples
Input
5
1 12
1 3
2 15
2 5
2 1
Output
5
Input
3
1 10
2 1
2 4
Output
3
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You have array a1, a2, ..., an. Segment [l, r] (1 β€ l β€ r β€ n) is good if ai = ai - 1 + ai - 2, for all i (l + 2 β€ i β€ r).
Let's define len([l, r]) = r - l + 1, len([l, r]) is the length of the segment [l, r]. Segment [l1, r1], is longer than segment [l2, r2], if len([l1, r1]) > len([l2, r2]).
Your task is to find a good segment of the maximum length in array a. Note that a segment of length 1 or 2 is always good.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of elements in the array. The second line contains integers: a1, a2, ..., an (0 β€ ai β€ 109).
Output
Print the length of the longest good segment in array a.
Examples
Input
10
1 2 3 5 8 13 21 34 55 89
Output
10
Input
5
1 1 1 1 1
Output
2
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Fox Ciel is playing a game with numbers now.
Ciel has n positive integers: x1, x2, ..., xn. She can do the following operation as many times as needed: select two different indexes i and j such that xi > xj hold, and then apply assignment xi = xi - xj. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input
The first line contains an integer n (2 β€ n β€ 100). Then the second line contains n integers: x1, x2, ..., xn (1 β€ xi β€ 100).
Output
Output a single integer β the required minimal sum.
Examples
Input
2
1 2
Output
2
Input
3
2 4 6
Output
6
Input
2
12 18
Output
12
Input
5
45 12 27 30 18
Output
15
Note
In the first example the optimal way is to do the assignment: x2 = x2 - x1.
In the second example the optimal sequence of operations is: x3 = x3 - x2, x2 = x2 - x1.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Little Petya wanted to give an April Fools Day present to some scientists. After some hesitation he decided to give them the array that he got as a present in Codeforces Round #153 (Div.2). The scientists rejoiced at the gift and decided to put some important facts to this array. Here are the first few of the facts:
* The highest mountain above sea level in the world is Mount Everest. Its peak rises to 8848 m.
* The largest board game tournament consisted of 958 participants playing chapaev.
* The largest online maths competition consisted of 12766 participants.
* The Nile is credited as the longest river in the world. From its farthest stream in Burundi, it extends 6695 km in length.
* While not in flood, the main stretches of the Amazon river in South America can reach widths of up to 1100 km at its widest points.
* Angel Falls is the highest waterfall. Its greatest single drop measures 807 m.
* The Hotel Everest View above Namche, Nepal β the village closest to Everest base camp β is at a record height of 31962 m
* Uranium is the heaviest of all the naturally occurring elements. Its most common isotope has a nucleus containing 146 neutrons.
* The coldest permanently inhabited place is the Siberian village of Oymyakon, where the temperature of -68Β°C was registered in the twentieth century.
* The longest snake held in captivity is over 25 feet long. Its name is Medusa.
* Colonel Meow holds the world record for longest fur on a cat β almost 134 centimeters.
* Sea otters can have up to 10000 hairs per square inch. This is the most dense fur in the animal kingdom.
* The largest state of USA is Alaska; its area is 663268 square miles
* Alaska has a longer coastline than all of the other 49 U.S. States put together: it is 154103 miles long.
* Lake Baikal is the largest freshwater lake in the world. It reaches 1642 meters in depth and contains around one-fifth of the worldβs unfrozen fresh water.
* The most colorful national flag is the one of Turkmenistan, with 106 colors.
Input
The input will contain a single integer between 1 and 16.
Output
Output a single integer.
Examples
Input
1
Output
1
Input
7
Output
0
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Today Vasya visited a widely known site and learned that the continuation of his favourite game Codecraft II will appear after exactly k months. He looked at the calendar and learned that at the moment is the month number s. Vasya immediately got interested in what month Codecraft III will appear. Help him understand that.
All the twelve months in Vasya's calendar are named using their usual English names: January, February, March, April, May, June, July, August, September, October, November, December.
Input
The first input line contains the name of the current month. It is guaranteed that it is a proper English name of one of twelve months. The first letter is uppercase, the rest are lowercase. The second line contains integer k (0 β€ k β€ 100) β the number of months left till the appearance of Codecraft III.
Output
Print starting from an uppercase letter the name of the month in which the continuation of Codeforces II will appear. The printed name must be contained in the list January, February, March, April, May, June, July, August, September, October, November, December.
Examples
Input
November
3
Output
February
Input
May
24
Output
May
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Polycarpus got an internship in one well-known social network. His test task is to count the number of unique users who have visited a social network during the day. Polycarpus was provided with information on all user requests for this time period. For each query, we know its time... and nothing else, because Polycarpus has already accidentally removed the user IDs corresponding to the requests from the database. Thus, it is now impossible to determine whether any two requests are made by the same person or by different people.
But wait, something is still known, because that day a record was achieved β M simultaneous users online! In addition, Polycarpus believes that if a user made a request at second s, then he was online for T seconds after that, that is, at seconds s, s + 1, s + 2, ..., s + T - 1. So, the user's time online can be calculated as the union of time intervals of the form [s, s + T - 1] over all times s of requests from him.
Guided by these thoughts, Polycarpus wants to assign a user ID to each request so that:
* the number of different users online did not exceed M at any moment,
* at some second the number of distinct users online reached value M,
* the total number of users (the number of distinct identifiers) was as much as possible.
Help Polycarpus cope with the test.
Input
The first line contains three integers n, M and T (1 β€ n, M β€ 20 000, 1 β€ T β€ 86400) β the number of queries, the record number of online users and the time when the user was online after a query was sent. Next n lines contain the times of the queries in the format "hh:mm:ss", where hh are hours, mm are minutes, ss are seconds. The times of the queries follow in the non-decreasing order, some of them can coincide. It is guaranteed that all the times and even all the segments of type [s, s + T - 1] are within one 24-hour range (from 00:00:00 to 23:59:59).
Output
In the first line print number R β the largest possible number of distinct users. The following n lines should contain the user IDs for requests in the same order in which the requests are given in the input. User IDs must be integers from 1 to R. The requests of the same user must correspond to the same identifiers, the requests of distinct users must correspond to distinct identifiers. If there are multiple solutions, print any of them. If there is no solution, print "No solution" (without the quotes).
Examples
Input
4 2 10
17:05:53
17:05:58
17:06:01
22:39:47
Output
3
1
2
2
3
Input
1 2 86400
00:00:00
Output
No solution
Note
Consider the first sample. The user who sent the first request was online from 17:05:53 to 17:06:02, the user who sent the second request was online from 17:05:58 to 17:06:07, the user who sent the third request, was online from 17:06:01 to 17:06:10. Thus, these IDs cannot belong to three distinct users, because in that case all these users would be online, for example, at 17:06:01. That is impossible, because M = 2. That means that some two of these queries belonged to the same user. One of the correct variants is given in the answer to the sample. For it user 1 was online from 17:05:53 to 17:06:02, user 2 β from 17:05:58 to 17:06:10 (he sent the second and third queries), user 3 β from 22:39:47 to 22:39:56.
In the second sample there is only one query. So, only one user visited the network within the 24-hour period and there couldn't be two users online on the network simultaneously. (The time the user spent online is the union of time intervals for requests, so users who didn't send requests could not be online in the network.)
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Andrewid the Android is a galaxy-famous detective. He is now investigating the case of vandalism at the exhibition of contemporary art.
The main exhibit is a construction of n matryoshka dolls that can be nested one into another. The matryoshka dolls are numbered from 1 to n. A matryoshka with a smaller number can be nested in a matryoshka with a higher number, two matryoshkas can not be directly nested in the same doll, but there may be chain nestings, for example, 1 β 2 β 4 β 5.
In one second, you can perform one of the two following operations:
* Having a matryoshka a that isn't nested in any other matryoshka and a matryoshka b, such that b doesn't contain any other matryoshka and is not nested in any other matryoshka, you may put a in b;
* Having a matryoshka a directly contained in matryoshka b, such that b is not nested in any other matryoshka, you may get a out of b.
According to the modern aesthetic norms the matryoshka dolls on display were assembled in a specific configuration, i.e. as several separate chains of nested matryoshkas, but the criminal, following the mysterious plan, took out all the dolls and assembled them into a single large chain (1 β 2 β ... β n). In order to continue the investigation Andrewid needs to know in what minimum time it is possible to perform this action.
Input
The first line contains integers n (1 β€ n β€ 105) and k (1 β€ k β€ 105) β the number of matryoshkas and matryoshka chains in the initial configuration.
The next k lines contain the descriptions of the chains: the i-th line first contains number mi (1 β€ mi β€ n), and then mi numbers ai1, ai2, ..., aimi β the numbers of matryoshkas in the chain (matryoshka ai1 is nested into matryoshka ai2, that is nested into matryoshka ai3, and so on till the matryoshka aimi that isn't nested into any other matryoshka).
It is guaranteed that m1 + m2 + ... + mk = n, the numbers of matryoshkas in all the chains are distinct, in each chain the numbers of matryoshkas follow in the ascending order.
Output
In the single line print the minimum number of seconds needed to assemble one large chain from the initial configuration.
Examples
Input
3 2
2 1 2
1 3
Output
1
Input
7 3
3 1 3 7
2 2 5
2 4 6
Output
10
Note
In the first sample test there are two chains: 1 β 2 and 3. In one second you can nest the first chain into the second one and get 1 β 2 β 3.
In the second sample test you need to disassemble all the three chains into individual matryoshkas in 2 + 1 + 1 = 4 seconds and then assemble one big chain in 6 seconds.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
A long time ago, in a galaxy far far away two giant IT-corporations Pineapple and Gogol continue their fierce competition. Crucial moment is just around the corner: Gogol is ready to release it's new tablet Lastus 3000.
This new device is equipped with specially designed artificial intelligence (AI). Employees of Pineapple did their best to postpone the release of Lastus 3000 as long as possible. Finally, they found out, that the name of the new artificial intelligence is similar to the name of the phone, that Pineapple released 200 years ago. As all rights on its name belong to Pineapple, they stand on changing the name of Gogol's artificial intelligence.
Pineapple insists, that the name of their phone occurs in the name of AI as a substring. Because the name of technology was already printed on all devices, the Gogol's director decided to replace some characters in AI name with "#". As this operation is pretty expensive, you should find the minimum number of characters to replace with "#", such that the name of AI doesn't contain the name of the phone as a substring.
Substring is a continuous subsequence of a string.
Input
The first line of the input contains the name of AI designed by Gogol, its length doesn't exceed 100 000 characters. Second line contains the name of the phone released by Pineapple 200 years ago, its length doesn't exceed 30. Both string are non-empty and consist of only small English letters.
Output
Print the minimum number of characters that must be replaced with "#" in order to obtain that the name of the phone doesn't occur in the name of AI as a substring.
Examples
Input
intellect
tell
Output
1
Input
google
apple
Output
0
Input
sirisiri
sir
Output
2
Note
In the first sample AI's name may be replaced with "int#llect".
In the second sample Gogol can just keep things as they are.
In the third sample one of the new possible names of AI may be "s#ris#ri".
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Bearland has n cities, numbered 1 through n. Cities are connected via bidirectional roads. Each road connects two distinct cities. No two roads connect the same pair of cities.
Bear Limak was once in a city a and he wanted to go to a city b. There was no direct connection so he decided to take a long walk, visiting each city exactly once. Formally:
* There is no road between a and b.
* There exists a sequence (path) of n distinct cities v1, v2, ..., vn that v1 = a, vn = b and there is a road between vi and vi + 1 for <image>.
On the other day, the similar thing happened. Limak wanted to travel between a city c and a city d. There is no road between them but there exists a sequence of n distinct cities u1, u2, ..., un that u1 = c, un = d and there is a road between ui and ui + 1 for <image>.
Also, Limak thinks that there are at most k roads in Bearland. He wonders whether he remembers everything correctly.
Given n, k and four distinct cities a, b, c, d, can you find possible paths (v1, ..., vn) and (u1, ..., un) to satisfy all the given conditions? Find any solution or print -1 if it's impossible.
Input
The first line of the input contains two integers n and k (4 β€ n β€ 1000, n - 1 β€ k β€ 2n - 2) β the number of cities and the maximum allowed number of roads, respectively.
The second line contains four distinct integers a, b, c and d (1 β€ a, b, c, d β€ n).
Output
Print -1 if it's impossible to satisfy all the given conditions. Otherwise, print two lines with paths descriptions. The first of these two lines should contain n distinct integers v1, v2, ..., vn where v1 = a and vn = b. The second line should contain n distinct integers u1, u2, ..., un where u1 = c and un = d.
Two paths generate at most 2n - 2 roads: (v1, v2), (v2, v3), ..., (vn - 1, vn), (u1, u2), (u2, u3), ..., (un - 1, un). Your answer will be considered wrong if contains more than k distinct roads or any other condition breaks. Note that (x, y) and (y, x) are the same road.
Examples
Input
7 11
2 4 7 3
Output
2 7 1 3 6 5 4
7 1 5 4 6 2 3
Input
1000 999
10 20 30 40
Output
-1
Note
In the first sample test, there should be 7 cities and at most 11 roads. The provided sample solution generates 10 roads, as in the drawing. You can also see a simple path of length n between 2 and 4, and a path between 7 and 3.
<image>
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome.
Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation.
This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes.
Thus, "localization" will be spelt as "l10n", and "internationalizationΒ» will be spelt as "i18n".
You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes.
Input
The first line contains an integer n (1 β€ n β€ 100). Each of the following n lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters.
Output
Print n lines. The i-th line should contain the result of replacing of the i-th word from the input data.
Examples
Input
4
word
localization
internationalization
pneumonoultramicroscopicsilicovolcanoconiosis
Output
word
l10n
i18n
p43s
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Young Timofey has a birthday today! He got kit of n cubes as a birthday present from his parents. Every cube has a number ai, which is written on it. Timofey put all the cubes in a row and went to unpack other presents.
In this time, Timofey's elder brother, Dima reordered the cubes using the following rule. Suppose the cubes are numbered from 1 to n in their order. Dima performs several steps, on step i he reverses the segment of cubes from i-th to (n - i + 1)-th. He does this while i β€ n - i + 1.
After performing the operations Dima went away, being very proud of himself. When Timofey returned to his cubes, he understood that their order was changed. Help Timofey as fast as you can and save the holiday β restore the initial order of the cubes using information of their current location.
Input
The first line contains single integer n (1 β€ n β€ 2Β·105) β the number of cubes.
The second line contains n integers a1, a2, ..., an ( - 109 β€ ai β€ 109), where ai is the number written on the i-th cube after Dima has changed their order.
Output
Print n integers, separated by spaces β the numbers written on the cubes in their initial order.
It can be shown that the answer is unique.
Examples
Input
7
4 3 7 6 9 1 2
Output
2 3 9 6 7 1 4
Input
8
6 1 4 2 5 6 9 2
Output
2 1 6 2 5 4 9 6
Note
Consider the first sample.
1. At the begining row was [2, 3, 9, 6, 7, 1, 4].
2. After first operation row was [4, 1, 7, 6, 9, 3, 2].
3. After second operation row was [4, 3, 9, 6, 7, 1, 2].
4. After third operation row was [4, 3, 7, 6, 9, 1, 2].
5. At fourth operation we reverse just middle element, so nothing has changed. The final row is [4, 3, 7, 6, 9, 1, 2]. So the answer for this case is row [2, 3, 9, 6, 7, 1, 4].
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Maxim wants to buy an apartment in a new house at Line Avenue of Metropolis. The house has n apartments that are numbered from 1 to n and are arranged in a row. Two apartments are adjacent if their indices differ by 1. Some of the apartments can already be inhabited, others are available for sale.
Maxim often visits his neighbors, so apartment is good for him if it is available for sale and there is at least one already inhabited apartment adjacent to it. Maxim knows that there are exactly k already inhabited apartments, but he doesn't know their indices yet.
Find out what could be the minimum possible and the maximum possible number of apartments that are good for Maxim.
Input
The only line of the input contains two integers: n and k (1 β€ n β€ 109, 0 β€ k β€ n).
Output
Print the minimum possible and the maximum possible number of apartments good for Maxim.
Example
Input
6 3
Output
1 3
Note
In the sample test, the number of good apartments could be minimum possible if, for example, apartments with indices 1, 2 and 3 were inhabited. In this case only apartment 4 is good. The maximum possible number could be, for example, if apartments with indices 1, 3 and 5 were inhabited. In this case all other apartments: 2, 4 and 6 are good.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You are given a rooted tree with n vertices. The vertices are numbered from 1 to n, the root is the vertex number 1.
Each vertex has a color, let's denote the color of vertex v by cv. Initially cv = 0.
You have to color the tree into the given colors using the smallest possible number of steps. On each step you can choose a vertex v and a color x, and then color all vectices in the subtree of v (including v itself) in color x. In other words, for every vertex u, such that the path from root to u passes through v, set cu = x.
It is guaranteed that you have to color each vertex in a color different from 0.
You can learn what a rooted tree is using the link: https://en.wikipedia.org/wiki/Tree_(graph_theory).
Input
The first line contains a single integer n (2 β€ n β€ 104) β the number of vertices in the tree.
The second line contains n - 1 integers p2, p3, ..., pn (1 β€ pi < i), where pi means that there is an edge between vertices i and pi.
The third line contains n integers c1, c2, ..., cn (1 β€ ci β€ n), where ci is the color you should color the i-th vertex into.
It is guaranteed that the given graph is a tree.
Output
Print a single integer β the minimum number of steps you have to perform to color the tree into given colors.
Examples
Input
6
1 2 2 1 5
2 1 1 1 1 1
Output
3
Input
7
1 1 2 3 1 4
3 3 1 1 1 2 3
Output
5
Note
The tree from the first sample is shown on the picture (numbers are vetices' indices):
<image>
On first step we color all vertices in the subtree of vertex 1 into color 2 (numbers are colors):
<image>
On seond step we color all vertices in the subtree of vertex 5 into color 1:
<image>
On third step we color all vertices in the subtree of vertex 2 into color 1:
<image>
The tree from the second sample is shown on the picture (numbers are vetices' indices):
<image>
On first step we color all vertices in the subtree of vertex 1 into color 3 (numbers are colors):
<image>
On second step we color all vertices in the subtree of vertex 3 into color 1:
<image>
On third step we color all vertices in the subtree of vertex 6 into color 2:
<image>
On fourth step we color all vertices in the subtree of vertex 4 into color 1:
<image>
On fith step we color all vertices in the subtree of vertex 7 into color 3:
<image>
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
One very experienced problem writer decided to prepare a problem for April Fools Day contest. The task was very simple - given an arithmetic expression, return the result of evaluating this expression. However, looks like there is a bug in the reference solution...
Input
The only line of input data contains the arithmetic expression. The expression will contain between 2 and 10 operands, separated with arithmetic signs plus and/or minus. Each operand will be an integer between 0 and 255, inclusive.
Output
Reproduce the output of the reference solution, including the bug.
Examples
Input
8-7+6-5+4-3+2-1-0
Output
4
Input
2+2
Output
-46
Input
112-37
Output
375
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Vasilisa the Wise from a far away kingdom got a present from her friend Helga the Wise from a farther away kingdom. The present is a surprise box, yet Vasilisa the Wise doesn't know yet what the surprise actually is because she cannot open the box. She hopes that you can help her in that.
The box's lock is constructed like that. The box itself is represented by an absolutely perfect black cube with the identical deepening on each face (those are some foreign nanotechnologies that the far away kingdom scientists haven't dreamt of). The box is accompanied by six gems whose form matches the deepenings in the box's faces. The box can only be opened after it is correctly decorated by the gems, that is, when each deepening contains exactly one gem. Two ways of decorating the box are considered the same if they can be obtained one from the other one by arbitrarily rotating the box (note that the box is represented by a perfect nanotechnological cube)
Now Vasilisa the Wise wants to know by the given set of colors the following: in how many ways would she decorate the box in the worst case to open it? To answer this question it is useful to know that two gems of one color are indistinguishable from each other. Help Vasilisa to solve this challenging problem.
Input
The first line contains exactly 6 characters without spaces from the set {R, O, Y, G, B, V} β they are the colors of gems with which the box should be decorated.
Output
Print the required number of different ways to decorate the box.
Examples
Input
YYYYYY
Output
1
Input
BOOOOB
Output
2
Input
ROYGBV
Output
30
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Jesse and Walter recently got a into a problem. They need to check if a compound can be converted to the other one.
A compound is decoded into a binary strings of 0s and 1s. They have 2 binary strings. First string contains characters
'0', '1' and '?', whereas second contains '0' and '1' only. As Jesse and Walter are busy cooking meth, they need your
help.
For each case, you need to calculate number of steps needed to convert first compound to second. You can perform the
following operations:
Change '0' to '1'
Change '?' to '0' or '1'
Swap any two characters
Input:
First Line of the Input contains T, denoting number of test cases.
Then for each test case, there are two lines containg 2 strings denoting the compounds.
Output:
For each test case
Print minimum number of steps needed to convert 1st compound to the 2nd in seperate lines.
If it is not possible, output -1.
Constraints:
1 β€ Length of strings β€ 100
Register for IndiaHacksSAMPLE INPUT
3
01??00
001010
01
10
110001
000000
SAMPLE OUTPUT
Case 1: 3
Case 2: 1
Case 3: -1
Register for IndiaHacks
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
"RMS Lusitania" was one of the world biggest ship of her time.On the outbreak of the First World War in 1914, she was commandeered by the Admiralty as an armed merchant cruiser. When Lusitania left New York for Liverpool on what would be her final voyage on 1 May 1915, submarine warfare was intensifying in the Atlantic. Germany had declared the seas around the United Kingdom to be a war-zone..On the afternoon of May 7, Lusitania was bombarded by a German U-Boat,few miles off the southern coast of Ireland and inside the declared βzone of warβ.Lusitania was officially carrying among her cargo rifle/machine-gun ammunition, shrapnel artillery shells without powder charges and artillery fuses.Captain "Dow" of Lusitania sensed the danger before and ordered his men to save the ammunition materials as much as they can.
They had few small boats and the overall load those small boats could carry was "W".Captain "Dow" knew the value of all the "N" ammunition items.So he told his men the weight "W_i" and value "V_i" of each ammunition item.As it is too difficult to save all the ammunition,Captain then asked his men to smarty choose ammunition items such that the total weight of the ammunition is less than or equal to maximum load those small ships can afford and the corresponding total value of ammunitions saved is maximum.
INPUT:
the first line contain number of testcases "T"."T" testcases follows then.For each testcase,the first line contains the number of ammunition items "N",the second line contains the maximum load "W" those small ships can afford.The third line contains the individual weight of each ammunition item.Then the next line contains the value "V" of those "N" ammunition items.
OUTPUT:
for each testcase output the maximum value of the ammunitions that can be saved.
Constraint:
1 β€ T β€ 100
0 β€ N β€ 1000
1 β€ maximum\; load β€ 1000
1 β€ weight\; of\; individual\; items β€ 1000
1 β€ value\; of\; individual\; items β€ 1000
SAMPLE INPUT
2
3
3
1 2 3
2 4 8
4
8
2 4 5 7
4 9 7 5
SAMPLE OUTPUT
8
13
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Marut loves good strings. According to him, good strings are those which contain either all alphabets of uppercase or lowercase.
While he is preparing for his exams, he finds many bad strings in his book and wants to convert them to good strings.
But he wants to do this in minimum number of operations.
In one operation, he can pick only one character of any case and convert it
to any other case.
As his exams are going on, he wants your help.
Input:
The first line contains an integer T, denoting the number of test cases.
Each test case consists of only one line with a string S which contains uppercase and lowercase alphabets..
Output:
Print the minimum number of operations, in which Marut can obtain a good string.
Print the answer for each test case in new line.
Constraints:
1 β€ T β€ 10
If T is not in this range, print "Invalid Test" (without the quotes)
1 β€ Length of S β€ 100
S can contain numbers, special characters but no spaces.
If the length of string is not in the above range or it does not contain any alphabets, print "Invalid Input" (without the quotes)
For Example, if the input is:
0
TestString
Print "Invalid Test" (without the quotes)
SAMPLE INPUT
3
abcEfg
!@6#2
123A
SAMPLE OUTPUT
1
Invalid Input
0
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Rahul has set upon the quest for a new logo of his company. He has created the following continuous logo:
/\
/ \
/ /\ \
/ / \ \
/ / /\ \ \
\ \ \/ / /
\ \ / /
\ \/ /
\ /
\/
However, his sister, Rashi, likes the following discontinuous design more
/\
/ \
/ /\ \
/ / \ \
\ \ / /
\ \/ /
\ /
\/
The size of a logo is the longest continuous streak of same characters on an arm.
So, size of 1st logo is 5 while that of 2nd one is 4.
Now, he wants to paint both of these logos on a canvas.
Given an integer N, write a program that outputs these logos for sizes N and N + 1, one below the other.
Please note that Rahul's logo is only valid for odd sizes and Rashi's logo is only valid for even values.
Input Format:
Each file has just one line containing integer N.
Output Format:
Output the two logos, one below the other.
Constraints:
N β€ 100
Notes:
An exact checker is used, so please make sure that you strictly adhere to the output format and leave no trailing spaces.
SAMPLE INPUT
3
SAMPLE OUTPUT
/\
/ \
/ /\ \
\ \/ /
\ /
\/
/\
/ \
/ /\ \
/ / \ \
\ \ / /
\ \/ /
\ /
\/
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Bangalore City, where peace prevails most of the time. Not everyone is a huge fan of peace, though. Certainly not Mr. XYZ, whose identity is not known to us - yet. Mr. XYZ has somehow managed to bring vampires and zombies to Bangalore City to attack and destroy the city.
Fatal Eagle, an ordinary citizen of the city is extremely worried on seeing his city being attacked by these weird creatures. But, as of now, he has no power to stop these creatures from their silent attacks. He wants to analyze these creatures firstly. He figured out some things about these creatures, like:
Zombies have power in terms of an EVEN number.
Vampires have power in terms of an ODD number.
If he sees a zombie or a vampire, he marks them in his list with their power. After generating the entire list of power of these creatures, he decides to arrange this data in the following manner:
All the zombies arranged in sorted manner of their power, followed by the total power of zombies.
All the vampires arranged in sorted manner of their power, followed by the total power of vampires.
You've to help him produce the following list to help him save his city.
Input constraints:
The first line of input will contain an integer β N, denoting the number of creatures. The next line will contain N integers denoting the elements of the list containing the power of zombies and vampires.
Output constraints:
Print the required list in a single line.
Constraints:
1 β€ N β€ 10^3
1 β€ Ni β€ 10^3
SAMPLE INPUT
6
2 3 10 12 15 22
SAMPLE OUTPUT
2 10 12 22 46 3 15 18
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
We have an H \times W grid, where each square is painted white or black in the initial state. Given are strings A_1, A_2, ..., A_H representing the colors of the squares in the initial state. For each pair (i, j) (1 \leq i \leq H, 1 \leq j \leq W), if the j-th character of A_i is `.`, the square at the i-th row and j-th column is painted white; if that character is `#`, that square is painted black.
Among the 2^{HW} ways for each square in the grid to be painted white or black, how many can be obtained from the initial state by performing the operations below any number of times (possibly zero) in any order? Find this count modulo 998,244,353.
* Choose one row, then paint all the squares in that row white.
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column white.
* Choose one column, then paint all the squares in that column black.
Constraints
* 1 \leq H, W \leq 10
* |A_i| = W (1 \leq i \leq H)
* All strings A_i consist of `.` and `#`.
* H and W are integers.
Input
Input is given from Standard Input in the following format:
H W
A_1
A_2
\vdots
A_H
Output
Print the answer.
Examples
Input
2 2
#.
.#
Output
15
Input
2 2
.
.#
Output
15
Input
3 3
...
...
...
Output
230
Input
2 4
...
...#
Output
150
Input
6 7
.......
.......
.#.....
..#....
.#.#...
.......
Output
203949910
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Given is a rooted tree with N vertices numbered 1 to N. The root is Vertex 1, and the i-th edge (1 \leq i \leq N - 1) connects Vertex a_i and b_i.
Each of the vertices has a counter installed. Initially, the counters on all the vertices have the value 0.
Now, the following Q operations will be performed:
* Operation j (1 \leq j \leq Q): Increment by x_j the counter on every vertex contained in the subtree rooted at Vertex p_j.
Find the value of the counter on each vertex after all operations.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq Q \leq 2 \times 10^5
* 1 \leq a_i < b_i \leq N
* 1 \leq p_j \leq N
* 1 \leq x_j \leq 10^4
* The given graph is a tree.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N Q
a_1 b_1
:
a_{N-1} b_{N-1}
p_1 x_1
:
p_Q x_Q
Output
Print the values of the counters on Vertex 1, 2, \ldots, N after all operations, in this order, with spaces in between.
Examples
Input
4 3
1 2
2 3
2 4
2 10
1 100
3 1
Output
100 110 111 110
Input
6 2
1 2
1 3
2 4
3 6
2 5
1 10
1 10
Output
20 20 20 20 20 20
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
N tiles are arranged in a row from left to right. The initial color of each tile is represented by a string S of length N.
The i-th tile from the left is painted black if the i-th character of S is `0`, and painted white if that character is `1`.
You want to repaint some of the tiles black or white, so that any two adjacent tiles have different colors.
At least how many tiles need to be repainted to satisfy the condition?
Constraints
* 1 \leq |S| \leq 10^5
* S_i is `0` or `1`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum number of tiles that need to be repainted to satisfy the condition.
Examples
Input
000
Output
1
Input
10010010
Output
3
Input
0
Output
0
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
One day, Niwango-kun, an employee of Dwango Co., Ltd., found an integer sequence (a_1, ..., a_N) of length N. He is interested in properties of the sequence a.
For a nonempty contiguous subsequence a_l, ..., a_r (1 \leq l \leq r \leq N) of the sequence a, its beauty is defined as a_l + ... + a_r. Niwango-kun wants to know the maximum possible value of the bitwise AND of the beauties of K nonempty contiguous subsequences among all N(N+1)/2 nonempty contiguous subsequences. (Subsequences may share elements.)
Find the maximum possible value for him.
Constraints
* 2 \leq N \leq 1000
* 1 \leq a_i \leq 10^9
* 1 \leq K \leq N(N+1)/2
* All numbers given in input are integers
Input
Input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the answer.
Examples
Input
4 2
2 5 2 5
Output
12
Input
8 4
9 1 8 2 7 5 6 4
Output
32
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Snuke has two boards, each divided into a grid with N rows and N columns. For both of these boards, the square at the i-th row from the top and the j-th column from the left is called Square (i,j).
There is a lowercase English letter written in each square on the first board. The letter written in Square (i,j) is S_{i,j}. On the second board, nothing is written yet.
Snuke will write letters on the second board, as follows:
* First, choose two integers A and B ( 0 \leq A, B < N ).
* Write one letter in each square on the second board. Specifically, write the letter written in Square ( i+A, j+B ) on the first board into Square (i,j) on the second board. Here, the k-th row is also represented as the (N+k)-th row, and the k-th column is also represented as the (N+k)-th column.
After this operation, the second board is called a good board when, for every i and j ( 1 \leq i, j \leq N ), the letter in Square (i,j) and the letter in Square (j,i) are equal.
Find the number of the ways to choose integers A and B ( 0 \leq A, B < N ) such that the second board is a good board.
Constraints
* 1 \leq N \leq 300
* S_{i,j} ( 1 \leq i, j \leq N ) is a lowercase English letter.
Input
Input is given from Standard Input in the following format:
N
S_{1,1}S_{1,2}..S_{1,N}
S_{2,1}S_{2,2}..S_{2,N}
:
S_{N,1}S_{N,2}..S_{N,N}
Output
Print the number of the ways to choose integers A and B ( 0 \leq A, B < N ) such that the second board is a good board.
Examples
Input
2
ab
ca
Output
2
Input
4
aaaa
aaaa
aaaa
aaaa
Output
16
Input
5
abcde
fghij
klmno
pqrst
uvwxy
Output
0
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Snuke can change a string t of length N into a string t' of length N - 1 under the following rule:
* For each i (1 β€ i β€ N - 1), the i-th character of t' must be either the i-th or (i + 1)-th character of t.
There is a string s consisting of lowercase English letters. Snuke's objective is to apply the above operation to s repeatedly so that all the characters in s are the same. Find the minimum necessary number of operations.
Constraints
* 1 β€ |s| β€ 100
* s consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
Output
Print the minimum necessary number of operations to achieve the objective.
Examples
Input
serval
Output
3
Input
jackal
Output
2
Input
zzz
Output
0
Input
whbrjpjyhsrywlqjxdbrbaomnw
Output
8
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
A tetromino is a figure formed by joining four squares edge to edge. We will refer to the following seven kinds of tetromino as I-, O-, T-, J-, L-, S- and Z-tetrominos, respectively:
a60bcb8e9e8f22e3af51049eda063392.png
Snuke has many tetrominos. The number of I-, O-, T-, J-, L-, S- and Z-tetrominos in his possession are a_I, a_O, a_T, a_J, a_L, a_S and a_Z, respectively. Snuke will join K of his tetrominos to form a rectangle that is two squares tall and 2K squares wide. Here, the following rules must be followed:
* When placing each tetromino, rotation is allowed, but reflection is not.
* Each square in the rectangle must be covered by exactly one tetromino.
* No part of each tetromino may be outside the rectangle.
Snuke wants to form as large a rectangle as possible. Find the maximum possible value of K.
Constraints
* 0β€a_I,a_O,a_T,a_J,a_L,a_S,a_Zβ€10^9
* a_I+a_O+a_T+a_J+a_L+a_S+a_Zβ₯1
Input
The input is given from Standard Input in the following format:
a_I a_O a_T a_J a_L a_S a_Z
Output
Print the maximum possible value of K. If no rectangle can be formed, print `0`.
Examples
Input
2 1 1 0 0 0 0
Output
3
Input
0 0 10 0 0 0 0
Output
0
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Snuke and Ciel went to a strange stationery store. Each of them got a transparent graph paper with H rows and W columns.
Snuke painted some of the cells red in his paper. Here, the cells painted red were 4-connected, that is, it was possible to traverse from any red cell to any other red cell, by moving to vertically or horizontally adjacent red cells only.
Ciel painted some of the cells blue in her paper. Here, the cells painted blue were 4-connected.
Afterwards, they precisely overlaid the two sheets in the same direction. Then, the intersection of the red cells and the blue cells appeared purple.
You are given a matrix of letters a_{ij} (1β€iβ€H, 1β€jβ€W) that describes the positions of the purple cells. If the cell at the i-th row and j-th column is purple, then a_{ij} is `#`, otherwise a_{ij} is `.`. Here, it is guaranteed that no outermost cell is purple. That is, if i=1, H or j = 1, W, then a_{ij} is `.`.
Find a pair of the set of the positions of the red cells and the blue cells that is consistent with the situation described. It can be shown that a solution always exists.
Constraints
* 3β€H,Wβ€500
* a_{ij} is `#` or `.`.
* If i=1,H or j=1,W, then a_{ij} is `.`.
* At least one of a_{ij} is `#`.
Input
The input is given from Standard Input in the following format:
H W
a_{11}...a_{1W}
:
a_{H1}...a_{HW}
Output
Print a pair of the set of the positions of the red cells and the blue cells that is consistent with the situation, as follows:
* The first H lines should describe the positions of the red cells.
* The following 1 line should be empty.
* The following H lines should describe the positions of the blue cells.
The description of the positions of the red or blue cells should follow the format of the description of the positions of the purple cells.
Examples
Input
5 5
.....
.#.#.
.....
.#.#.
.....
Output
.....
#####
#....
#####
.....
.###.
.#.#.
.#.#.
.#.#.
.....
Input
7 13
.............
.###.###.###.
.#.#.#...#...
.###.#...#...
.#.#.#.#.#...
.#.#.###.###.
.............
Output
.............
.###########.
.###.###.###.
.###.###.###.
.###.###.###.
.###.###.###.
.............
.............
.###.###.###.
.#.#.#...#...
.###.#...#...
.#.#.#.#.#...
.#.#########.
.............
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Create a program that outputs all leap years between the year a and year b.
The leap year conditions are as follows. However, 0 <a β€ b <3,000. If there is no leap year in the given period, output "NA".
* The year is divisible by 4.
* However, a year divisible by 100 is not a leap year.
* However, a year divisible by 400 is a leap year.
Input
Given multiple datasets. The format of each dataset is as follows:
a b
Input ends when both a and b are 0. The number of datasets does not exceed 50.
Output
Print the year or NA for each dataset.
Insert one blank line between the datasets.
Example
Input
2001 2010
2005 2005
2001 2010
0 0
Output
2004
2008
NA
2004
2008
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Relative B man came to A child's house. He is 3 years old and loves singing. He is singing the song "Kobutanuki Tsuneko" (written and composed by Naozumi Yamamoto), which he learned from kindergarten. In this song, the four words "kobuta," "raccoon dog," "fox," and "cat" are arranged in order, and the last and first sounds are the same. Mr. B was asked by Mr. A to tell him if he could make a similar shiritori from the words that Mr. B said.
So, in order to help Ako, from the given words, use all the words to make a shiritori in order, and then the first letter of the first word and the last letter of the last word are the same. Let's write a program that determines whether or not it can be done.
Create a program that takes n words as input, determines whether or not a shiritori can be created from those word pairs, and outputs OK if possible and NG if not.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
word1
word2
::
wordn
The number of words n (2 β€ n β€ 10000) is given on the first line. The next n lines are given n words wordi (a string of up to 32 single-byte lowercase letters).
The number of datasets does not exceed 50.
Output
The judgment result is output to one line for each input data set.
Example
Input
5
apple
yellow
georgia
king
email
7
apple
yellow
georgia
king
email
wink
lucky
0
Output
NG
OK
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
There are a number of ways to shuffle a deck of cards. Riffle shuffle is one such example. The following is how to perform riffle shuffle.
There is a deck of n cards. First, we divide it into two decks; deck A which consists of the top half of it and deck B of the bottom half. Deck A will have one more card when n is odd.
Next, c cards are pulled from bottom of deck A and are stacked on deck C, which is empty initially. Then c cards are pulled from bottom of deck B and stacked on deck C, likewise. This operation is repeated until deck A and B become empty. When the number of cards of deck A(B) is less than c, all cards are pulled. Finally we obtain shuffled deck C. See an example below:
- A single riffle operation where n = 9, c = 3
for given deck [0 1 2 3 4 5 6 7 8] (right is top)
- Step 0
deck A [4 5 6 7 8]
deck B [0 1 2 3]
deck C []
- Step 1
deck A [7 8]
deck B [0 1 2 3]
deck C [4 5 6]
- Step 2
deck A [7 8]
deck B [3]
deck C [4 5 6 0 1 2]
- Step 3
deck A []
deck B [3]
deck C [4 5 6 0 1 2 7 8]
- Step 4
deck A []
deck B []
deck C [4 5 6 0 1 2 7 8 3]
shuffled deck [4 5 6 0 1 2 7 8 3]
This operation, called riffle operation, is repeated several times.
Write a program that simulates Riffle shuffle and answer which card will be finally placed on the top of the deck.
Input
The input consists of multiple data sets. Each data set starts with a line containing two positive integers n(1 β€ n β€ 50) and r(1 β€ r β€ 50); n and r are the number of cards in the deck and the number of riffle operations, respectively.
r more positive integers follow, each of which represents a riffle operation. These riffle operations are performed in the listed order. Each integer represents c, which is explained above.
The end of the input is indicated by EOF. The number of data sets is less than 100.
Output
For each data set in the input, your program should print the number of the top card after the shuffle. Assume that at the beginning the cards are numbered from 0 to n-1, from the bottom to the top. Each number should be written in a sparate line without any superfluous characters such as leading or following spaces.
Example
Input
9 1
3
9 4
1 2 3 4
Output
3
0
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 β€ n β€ 50 and 2 β€ p β€ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Karakuri Doll
Karakuri doll
English text is not available in this practice contest.
After many years of research, Karakuri puppeteer JAG has succeeded in developing a wonderful tea-drawing doll that combines traditional and latest techniques. This tea-drawing doll is placed in a teacup with tea in the kitchen (K) in a house divided by a grid as shown in the figure below, and it is taken to the place of the master (M), and the master takes it to the place of the master (M). The job is to return to the kitchen when you put the cup of tea you have finished drinking. However, this doll is not smart enough to find the round-trip route between the kitchen and the master. The user needs to pre-populate this doll with a program so that the doll can reciprocate properly.
Example of house structure
Figure F-1: Example of house structure
There are two commands that the doll accepts, "turn left" and "turn right", and the programs that can be input to the doll are a finite sequence of commands. After leaving the kitchen, the doll advances until it hits a wall (the square represented by "#" in the figure), and when it hits the wall, it turns left or right according to the first command. After that, it moves forward until it hits the wall again, and when it hits, it executes the next command, and things proceed in the same way. If you still hit a wall and cannot move forward after changing direction, execute the next command without moving from that location. When it hits a wall, the doll will stop if there are no commands left to execute. This is called sequential execution of the program.
When returning to the kitchen from the master's whereabouts, the instruction sequence of the program is executed in reverse order, and the direction is changed to the left and right. This is called reverse execution of the program. The behavior other than the instruction execution order and direction change is the same as the forward execution.
For example, in the house shown above, if you give this doll a program of "right, right, left", on the outbound route, point a will turn to the right, point b will turn to the right, and point c will turn to the left. Arrive at. On the return trip, the direction is changed to the right at point c, to the left at point b, and to the left at point a, and returns to the kitchen. On the other hand, when the program "left, left" is given, the doll first turns to the left at point a. He tries to go straight, but he hits the wall on the left side, so he turns to the left according to the second command while staying at point a. Then, when I went straight and came back to the kitchen, I hit a wall and stopped because there were no commands left.
By the way, Mr. JAG made a big mistake. In fact, there are cases where no matter what kind of program is given, it is not possible to reach the whereabouts of the master. Also, even if you arrive at your husband's place, you may not be able to bring the cup to the kitchen.
Your job is to write a program to determine if this doll can reach your husband's whereabouts and return to the kitchen when you use it in a house.
Input
The input consists of multiple datasets, with the last line written 0 0 indicating the end of the input. The number of data sets is 128 or less.
The first line of each dataset contains two space-separated integers W and H that represent the size of the house. These integers satisfy 3 β€ W β€ 64, 3 β€ H β€ 16. The following H line means the structure of the room. Each line consists of a W character, where "#` "indicates the wall," `.`" (Period) indicates the floor, "` K` "indicates the kitchen, and" `M`" indicates the location of the master. .. Characters other than these are not included.
The outermost part of this house is always guaranteed to be a wall ("` # `"). Also, there is always one "` K` "and" `M`" for each dataset, with three directions being walls ("` # `") and the remaining one direction being floors ("`. `"). ).
Output
For each dataset, output the message on one line as described below.
* If you do not arrive at your husband's whereabouts no matter what program you give, "He cannot bring tea to his master."
* If you arrive at your husband's whereabouts but cannot program to return to the kitchen afterwards, "He cannot return to the kitchen."
* If you can program to arrive at your husband's whereabouts and return to the kitchen, "He can accomplish his mission."
Here, arriving at the master's whereabouts means that the doll is present at the master's whereabouts at the time of stopping when the program is executed in order from the state where the doll is placed in the kitchen and turned in the direction without a wall. Returning to the kitchen means that the doll is present in the kitchen at the time of stop when the program is run backwards from the state where the doll is placed in the owner's place and turned in the direction without a wall. The orientation of the doll at the time of stop does not matter. In addition, both the outbound and inbound routes may pass through the kitchen or the master in the middle of the route. However, even if the doll passes through the kitchen or the master in the middle of the route, if the doll is elsewhere at the time of stop, it is not considered to have arrived at the master's whereabouts or returned to the kitchen.
Sample Input
5 3
K.M #
9 5
..... ###
. ### .. M #
K #######
9 5
K ...... #
.####
M ####
9 5
M ...... #
.####
K ####
7 9
M #
. #
..... #
. ###. #
..... #
. #####
K #####
7 6
. #
.... #
K .. #. #
M #. #
7 8
... ##
. # M #
..... #
. # ... #
. # .. ##
.K ####
9 6
.. ##. #
...... #
K .... #. #
.. # M #. #
9 6
. #######
.... # M. #
. # ... #. #
K # ββ... #
12 7
...####. #
K # ββ... M ##. #
..... # ... #
........ #. #
.. # ... #. #
23 16
...############
. ###. ########
..... ########
. #. #. ### ... ##
. #. #. ######. ###
............ ###
. ###. ######. ###
.######. ###
K ....... #####. ###
. #######. ######. ###
. #######. ######. ###
................. M #
. #######. ##########
...##### ... #########
46 16
.............. # .. ##############################
.. # .......... #. #. ### .... # ......... #
................. ###. #. #. # ............ # .. #
... # ... # .... # ... #. ###. # ...................... #
... # .... # .... #. #. ###. #. # ... # .... # .... # .... # ... #
. # .......... # .......... #. #. # .... # .... # .... # ... #
... # ... # ....... ###. # ........ # ......... # ... #. #
. # ... # ......... ###. # .. ## ....... # ........ # ... #
... # ........ # .. ###. # .. ##......... # ........ #. #
............... ###. # .. ## .. # ............ # ... # ... #
.######. # .. ## ..................... #
K ....... #. ########. ############
............... M ###########
....... #######################
0 0
Output for the Sample Input
He can accomplish his mission.
He can accomplish his mission.
He cannot bring tea to his master.
He cannot return to the kitchen.
He can accomplish his mission.
He can accomplish his mission.
He cannot return to the kitchen.
He cannot return to the kitchen.
He can accomplish his mission.
He can accomplish his mission.
He cannot return to the kitchen.
He can accomplish his mission.
Example
Input
5 3
#####
#K.M#
#####
9 5
#########
#.....###
#.###..M#
#K#######
#########
9 5
#########
#K......#
####.####
####M####
#########
9 5
#########
#M......#
####.####
####K####
#########
7 9
#######
#####M#
#####.#
#.....#
#.###.#
#.....#
#.#####
#K#####
#######
7 6
#######
#####.#
##....#
#K..#.#
###M#.#
#######
7 8
#######
##...##
###.#M#
#.....#
#.#...#
#.#..##
#.K####
#######
9 6
#########
###..##.#
##......#
#K....#.#
##..#M#.#
#########
9 6
#########
#.#######
#....#M.#
#.#...#.#
###K#...#
#########
12 7
############
###...####.#
##K#...M##.#
##.....#...#
#........#.#
###..#...#.#
############
23 16
#######################
#########...###########
##########.###.########
##########.....########
##########.#.#.###...##
########.#.#.######.###
########............###
########.###.######.###
############.######.###
#K...........######.###
####.#######.######.###
####.#######.######.###
####.................M#
####.#######.##########
###...#####...#########
#######################
46 16
##############################################
#..............#..############################
#..#..........#.#.###....#...................#
#.................###.#.#.#...............#..#
#...#..#....#...#.###.#......................#
#...#....#....#.#.###.#.#...#....#....#..#...#
#.#........#..........#.#.#....#....#....#...#
#...#...#.......###.#........#.........#...#.#
#.#...#.........###.#..##.......#........#...#
#...#........#..###.#..##.........#........#.#
#...............###.#..##..#.........#...#...#
############.######.#..##....................#
###########K...........#.########.############
###################...............M###########
##################.......#####################
##############################################
0 0
Output
He can accomplish his mission.
He can accomplish his mission.
He cannot bring tea to his master.
He cannot return to the kitchen.
He can accomplish his mission.
He can accomplish his mission.
He cannot return to the kitchen.
He cannot return to the kitchen.
He can accomplish his mission.
He can accomplish his mission.
He cannot return to the kitchen.
He can accomplish his mission.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
A tatami mat, a Japanese traditional floor cover, has a rectangular form with aspect ratio 1:2. When spreading tatami mats on a floor, it is prohibited to make a cross with the border of the tatami mats, because it is believed to bring bad luck.
Your task is to write a program that reports how many possible ways to spread tatami mats of the same size on a floor of given height and width.
Input
The input consists of multiple datasets. Each dataset cosists of a line which contains two integers H and W in this order, separated with a single space. H and W are the height and the width of the floor respectively. The length of the shorter edge of a tatami mat is regarded as a unit length.
You may assume 0 < H, W β€ 20.
The last dataset is followed by a line containing two zeros. This line is not a part of any dataset and should not be processed.
Output
For each dataset, print the number of possible ways to spread tatami mats in one line.
Example
Input
3 4
4 4
0 0
Output
4
2
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
The Kingdom of Neva is home to two ethnic groups, the Totata and the Tutete. The biggest feature of the Totata tribe is that they eat sweet and sour pork with pineapple. However, the Tutete tribe eats vinegared pork in pineapple. These two peoples couldn't get along with each other, and the Totata and Tutete have been in conflict for hundreds of years.
One day, a petition arrived from two ethnic groups under King Neva. According to it, the Totata tribe wants to build a road connecting the town A and the town B where they live. On the other hand, the Tutete tribe also wants to build a road connecting the town C and the town D where they live.
To prevent the two races from clashing, the roads of the Totata and Tutete cannot be crossed. Also, due to technical restrictions, it is only possible to build a road that connects the two cities in a straight line. In other words, if necessary, instead of connecting city A and city B directly with a road, it would indirectly connect city A and city B via some Totata towns (of course, of the Tutete tribe). Do not go through the city). At that time, the roads connecting the towns of the Totata tribe may intersect. The same applies to town C and town D.
Building a road costs proportional to its length. Therefore, I would like to make the total length of the roads to be constructed as short as possible while satisfying the conditions. Now, what is the minimum length?
Input
NA NB
xA, 1 yA, 1
xA, 2 yA, 2
..
..
..
xA, NA yA, NA
xB, 1 yB, 1
xB, 2 yB, 2
..
..
..
xB, NB yB, NB
The integer NA (2 β€ NA β€ 1,000) and the integer NB (2 β€ NB β€ 1,000) are written on the first line of the input, separated by blanks. This means that there are NA towns where the Totata tribe lives and NB towns where the Tutete tribe lives in the Kingdom of Neva. In the initial state, no road has been built anywhere.
The following NA line contains the integers xA, i (-10,000 β€ xA, i β€ 10,000) and the integers yA, i (-10,000 β€ yA, i β€ 10,000), separated by blanks. The geography of the Kingdom of Neva is represented by a two-dimensional Cartesian coordinate plane, and the integers xA, i and yA, i written on the 1 + i line are the position coordinates of the i-th city where the Totata tribe lives (xA, i, yA). , I). (xA, 1, yA, 1) and (xA, 2, yA, 2) are the coordinates of the two cities to be connected.
On the following NB line, the integers xB, i (-10,000 β€ xB, i β€ 10,000) and the integers yB, i (-10,000 β€ yB, i β€ 10,000) are written separated by blanks. The integers xB, i and yB, i written on the 1 + NA + i line indicate that the position coordinates of the i-th city where the Ytterbium live are (xB, i, yB, i). (xB, 1, yB, 1) and (xB, 2, yB, 2) are the coordinates of the two cities to be connected.
It can be assumed that the coordinates of the two cities are different and that none of the three cities are on the same straight line.
Output
When the road is constructed so as to meet the conditions of the problem statement, output the minimum value of the total length of the road. The "length" here is the Euclidean distance. However, if you cannot build a road that meets the conditions, output -1 instead. The output may contain errors, but the relative error to the true value must be less than 10-9.
Examples
Input
2 2
0 0
1 1
2 0
2 -1
Output
2.414213562373
Input
2 3
4 0
0 0
2 3
2 -2
3 1
Output
-1
Input
5 2
-2 1
1 2
-1 3
-1 5
1 4
0 4
0 0
Output
12.359173603117
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Palindrome
Problem Statement
Find the number of palindromes closest to the integer n.
Note that the non-negative integer x is the number of palindromes, which means that the character string in which x is expressed in decimal notation and the character string in which it is inverted are equal.
For example, 0,7,33,10301 is the number of palindromes, and 32,90,1010 is not the number of palindromes.
Constraints
* 1 β€ n β€ 10 ^ 4
Input
Input follows the following format. All given numbers are integers.
n
Output
Output the number of palindromes closest to n.
If there are multiple such numbers, output the smallest one.
Examples
Input
13
Output
11
Input
7447
Output
7447
Input
106
Output
101
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
This year too, the time has come for the National Programming Championships. In the district tournament where the right to participate in the national tournament is bet, 2n teams will face each other in a one-on-one winning tournament system.
Team numbers 0, .. .2n β 1 are assigned to the tournament table, and the confrontation procedure from the first round to the nth round is as follows.
1. In the first round, (team with team number l) and (team with team number l + 1) will face each other. (l β‘ 0 (mod 2))
2. In the i + 1st round (1 β€ i <n), "the team whose team number is l or more and less than l + 2i who has not lost even once in the confrontation up to the i round" and "the team number is l" Of the teams with + 2i or more and less than l + 2i + 1, the team that has never lost in the confrontation up to the i round will confront. (l β‘ 0 (mod 2i + 1))
After the nth round, the ranking of each team is fixed at 2n β (the number of times that team has won). Since there is no draw in this confrontation, one of the confronting teams wins and the other loses.
As we were selected to represent the district conference on a sunny day, we decided to have the manager examine the results of other district conferences. The result of the examination here was the "ranking table received from the manager". To explain the "ranking table received from the manager" in more detail, the ranking of the team with team number i is written in the i (0 β€ i β€ 2n β 1) th element in a sequence of length 2n. ..
However, the "stands received from the manager" had a large number of the same rankings! Due to the rules of the tournament, it is unlikely that the same ranking will be lined up in large numbers. Therefore, let's calculate the minimum number of teams to change the ranking in order to make the "standings received from the manager" a "consistent standings" and tell the manager how wrong the standings are. A "consistent standings" is a standings that can occur as a result of a tournament with a fixed ranking.
Input
The "ranking table received from the manager" is given to the input in the following format.
n m
a0 a1 .. .am
b0 b1 ... bmβ1
* The first line consists of two integers, n and m, where 2n is the "number of participating teams in the district tournament" and m is the "number of sections in which consecutive rankings are lined up in the" standings received from the manager "". Represents.
* The second line consists of m + 1 integers of ai (0 β€ i β€ m), and each ai represents "the division position of the section where consecutive rankings are lined up in the'ranking table received from the manager'". ..
* The third line consists of m integers of bi (0 β€ i <m), and each 2bi represents "the ranking of teams whose team numbers are greater than or equal to ai and less than ai + 1 in the standings received from the manager". ..
Constraints
* 1 β€ n β€ 30
* 1 β€ m β€ 10,000
* 0 = a0 <a1 β€ ... β€ amβ1 <am = 2n
* 0 β€ bi β€ n
Output
Output the minimum number of teams to change the ranking in one line so that the "standings received from the manager" becomes a "consistent standings".
Sample Input 1
1 1
0 2
1
Output for the Sample Input 1
1
There are two "consistent standings" with 2 participating teams: {"ranking of teams with team number 0" and "ranking of teams with team number 1"}, {1, 2} and {2, 1}. There is. In order to modify the standings {2, 2} to a "consistent standings", the ranking of one of the teams must be changed to 1.
Sample Input 2
twenty three
0 1 2 4
0 1 2
Output for the Sample Input 2
2
Sample Input 3
twenty three
0 1 3 4
0 2 1
Output for the Sample Input 3
0
Sample Input 4
4 5
0 1 2 4 8 16
0 1 2 3 4
Output for the Sample Input 4
Ten
Example
Input
1 1
0 2
1
Output
1
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
problem
There are $ N $ propositions, named $ 1, 2, \ cdots, N $, respectively. Also, $ M $ information about the propositions is given. The $ i $ th information is "$ a_i $$". Given in the form "b_i $", which means that $ a_i $ is $ b_i $. ("If" is a logical conditional and the transition law holds.) $ For each proposition $ i $ Output all propositions that have the same value as i $ in ascending order. However, proposition $ i $ and proposition $ i $ are always the same value. Proposition $ X $ and proposition $ Y $ have the same value as "$ if $ X $". It means "Y $" and "$ X $ if $ Y $".
output
On the $ i $ line, output all propositions that have the same value as the proposition $ i $, separated by blanks in ascending order. Also, output a line break at the end of each line.
Example
Input
5 2
1 2
2 1
Output
1 2
1 2
3
4
5
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Find the difference of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$, $A - B$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements in $A$ and $B$ are given in ascending order. There are no duplicate elements in each set.
Output
Print elements in the difference in ascending order. Print an element in a line.
Example
Input
5
1 2 3 5 8
2
2 5
Output
1
3
8
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
A Little Elephant and his friends from the Zoo of Lviv like candies very much.
There are N elephants in the Zoo. The elephant with number K (1 β€ K β€ N) will be happy if he receives at least AK candies. There are C candies in all in the Zoo.
The Zoo staff is interested in knowing whether it is possible to make all the N elephants happy by giving each elephant at least as many candies as he wants, that is, the K^th elephant should receive at least AK candies. Each candy can be given to only one elephant. Print Yes if it is possible and No otherwise.
Input
The first line of the input file contains an integer T, the number of test cases. T test cases follow. Each test case consists of exactly 2 lines. The first line of each test case contains two space separated integers N and C, the total number of elephants and the total number of candies in the Zoo respectively. The second line contains N space separated integers A1, A2, ..., AN.
Output
For each test case output exactly one line containing the string Yes if it possible to make all elephants happy and the string No otherwise. Output is case sensitive. So do not print YES or yes.
Constraints
1 β€ T β€ 1000
1 β€ N β€ 100
1 β€ C β€ 10^9
1 β€ AK β€ 10000, for K = 1, 2, ..., N
Example
Input:
2
2 3
1 1
3 7
4 2 2
Output:
Yes
No
Explanation
Case 1. We can give one candy to the first elephant and two candies to the second elephant and make them both happy. Hence the answer is Yes. Alternatively we can give one candy to each elephant and left one candy for ourselves but they again will be happy.
Case 2. Even if we give four candies to the first elephant and two candies to the second elephant we will have only one candy left and can not make last elephant happy since he needs two candies for his happiness. Hence the answer is No.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You are a given a list of integers a_1, a_2, β¦, a_n and s of its segments [l_j; r_j] (where 1 β€ l_j β€ r_j β€ n).
You need to select exactly m segments in such a way that the k-th order statistic of the multiset of a_i, where i is contained in at least one segment, is the smallest possible. If it's impossible to select a set of m segments in such a way that the multiset contains at least k elements, print -1.
The k-th order statistic of a multiset is the value of the k-th element after sorting the multiset in non-descending order.
Input
The first line contains four integers n, s, m and k (1 β€ m β€ s β€ 1500, 1 β€ k β€ n β€ 1500) β the size of the list, the number of segments, the number of segments to choose and the statistic number.
The second line contains n integers a_i (1 β€ a_i β€ 10^9) β the values of the numbers in the list.
Each of the next s lines contains two integers l_i and r_i (1 β€ l_i β€ r_i β€ n) β the endpoints of the segments.
It is possible that some segments coincide.
Output
Print exactly one integer β the smallest possible k-th order statistic, or -1 if it's impossible to choose segments in a way that the multiset contains at least k elements.
Examples
Input
4 3 2 2
3 1 3 2
1 2
2 3
4 4
Output
2
Input
5 2 1 1
1 2 3 4 5
2 4
1 5
Output
1
Input
5 3 3 5
5 5 2 1 1
1 2
2 3
3 4
Output
-1
Note
In the first example, one possible solution is to choose the first and the third segment. Together they will cover three elements of the list (all, except for the third one). This way the 2-nd order statistic for the covered elements is 2.
<image>
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
The only difference between easy and hard versions is the constraints.
Vova likes pictures with kittens. The news feed in the social network he uses can be represented as an array of n consecutive pictures (with kittens, of course). Vova likes all these pictures, but some are more beautiful than the others: the i-th picture has beauty a_i.
Vova wants to repost exactly x pictures in such a way that:
* each segment of the news feed of at least k consecutive pictures has at least one picture reposted by Vova;
* the sum of beauty values of reposted pictures is maximum possible.
For example, if k=1 then Vova has to repost all the pictures in the news feed. If k=2 then Vova can skip some pictures, but between every pair of consecutive pictures Vova has to repost at least one of them.
Your task is to calculate the maximum possible sum of values of reposted pictures if Vova follows conditions described above, or say that there is no way to satisfy all conditions.
Input
The first line of the input contains three integers n, k and x (1 β€ k, x β€ n β€ 200) β the number of pictures in the news feed, the minimum length of segment with at least one repost in it and the number of pictures Vova is ready to repost.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9), where a_i is the beauty of the i-th picture.
Output
Print -1 if there is no way to repost some pictures to satisfy all the conditions in the problem statement.
Otherwise print one integer β the maximum sum of values of reposted pictures if Vova follows conditions described in the problem statement.
Examples
Input
5 2 3
5 1 3 10 1
Output
18
Input
6 1 5
10 30 30 70 10 10
Output
-1
Input
4 3 1
1 100 1 1
Output
100
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
There is a weighted tree with n nodes and n-1 edges. The nodes are conveniently labeled from 1 to n. The weights are positive integers at most 100. Define the distance between two nodes to be the sum of edges on the unique path between the nodes. You would like to find the diameter of the tree. Diameter is the maximum distance between a pair of nodes.
Unfortunately, the tree isn't given to you, but you can ask some questions about it. In one question, you can specify two nonempty disjoint sets of nodes p and q, and the judge will return the maximum distance between a node in p and a node in q. In the words, maximum distance between x and y, where x β p and y β q. After asking not more than 9 questions, you must report the maximum distance between any pair of nodes.
Interaction
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 1 000). Description of the test cases follows.
The first line of each test case contains an integer n (2 β€ n β€ 100) β the number of nodes in the tree.
To ask a question, print "k_1\ k_2\ a_1\ a_2\ β¦\ a_{k_1}\ b_1\ b_2\ β¦\ b_{k_2}" (k_1, k_2 β₯ 1 and k_1+k_2 β€ n). These two sets must be nonempty and disjoint. The judge will respond with a single integer max_{p,q} dist(a_p, b_q). If you ever get a result of -1 (because you printed an invalid query), exit immediately to avoid getting other verdicts.
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.
When you are ready to answer, print "-1\ d", where d is the maximum shortest distance over all pairs of nodes.
You can only ask at most 9 questions per test case.
Hack Format
To hack, use the following format. Note that you can only hack with one test case.
The first line should contain a single integer t (t=1).
The second line should contain a single integer n (2 β€ n β€ 100).
Each of the next n-1 lines should contain three integers a_i, b_i, c_i (1β€ a_i, b_iβ€ n, 1 β€ c_i β€ 100). This denotes an undirected edge between nodes a_i and b_i with weight c_i. These edges must form a tree.
Example
Input
2
5
9
6
10
9
10
2
99
Output
1 4 1 2 3 4 5
1 4 2 3 4 5 1
1 4 3 4 5 1 2
1 4 4 5 1 2 3
1 4 5 1 2 3 4
-1 10
1 1 1 2
-1 99
Note
In the first example, the first tree looks as follows: <image>
In the first question, we have p = {1}, and q = {2, 3, 4, 5}. The maximum distance between a node in p and a node in q is 9 (the distance between nodes 1 and 5).
The second tree is a tree with two nodes with an edge with weight 99 between them.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
In some social network, there are n users communicating with each other in m groups of friends. Let's analyze the process of distributing some news between users.
Initially, some user x receives the news from some source. Then he or she sends the news to his or her friends (two users are friends if there is at least one group such that both of them belong to this group). Friends continue sending the news to their friends, and so on. The process ends when there is no pair of friends such that one of them knows the news, and another one doesn't know.
For each user x you have to determine what is the number of users that will know the news if initially only user x starts distributing it.
Input
The first line contains two integers n and m (1 β€ n, m β€ 5 β
10^5) β the number of users and the number of groups of friends, respectively.
Then m lines follow, each describing a group of friends. The i-th line begins with integer k_i (0 β€ k_i β€ n) β the number of users in the i-th group. Then k_i distinct integers follow, denoting the users belonging to the i-th group.
It is guaranteed that β _{i = 1}^{m} k_i β€ 5 β
10^5.
Output
Print n integers. The i-th integer should be equal to the number of users that will know the news if user i starts distributing it.
Example
Input
7 5
3 2 5 4
0
2 1 2
1 1
2 6 7
Output
4 4 1 4 4 2 2
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
A company of n friends wants to order exactly two pizzas. It is known that in total there are 9 pizza ingredients in nature, which are denoted by integers from 1 to 9.
Each of the n friends has one or more favorite ingredients: the i-th of friends has the number of favorite ingredients equal to f_i (1 β€ f_i β€ 9) and your favorite ingredients form the sequence b_{i1}, b_{i2}, ..., b_{if_i} (1 β€ b_{it} β€ 9).
The website of CodePizza restaurant has exactly m (m β₯ 2) pizzas. Each pizza is characterized by a set of r_j ingredients a_{j1}, a_{j2}, ..., a_{jr_j} (1 β€ r_j β€ 9, 1 β€ a_{jt} β€ 9) , which are included in it, and its price is c_j.
Help your friends choose exactly two pizzas in such a way as to please the maximum number of people in the company. It is known that a person is pleased with the choice if each of his/her favorite ingredients is in at least one ordered pizza. If there are several ways to choose two pizzas so as to please the maximum number of friends, then choose the one that minimizes the total price of two pizzas.
Input
The first line of the input contains two integers n and m (1 β€ n β€ 10^5, 2 β€ m β€ 10^5) β the number of friends in the company and the number of pizzas, respectively.
Next, the n lines contain descriptions of favorite ingredients of the friends: the i-th of them contains the number of favorite ingredients f_i (1 β€ f_i β€ 9) and a sequence of distinct integers b_{i1}, b_{i2}, ..., b_{if_i} (1 β€ b_{it} β€ 9).
Next, the m lines contain pizza descriptions: the j-th of them contains the integer price of the pizza c_j (1 β€ c_j β€ 10^9), the number of ingredients r_j (1 β€ r_j β€ 9) and the ingredients themselves as a sequence of distinct integers a_{j1}, a_{j2}, ..., a_{jr_j} (1 β€ a_{jt} β€ 9).
Output
Output two integers j_1 and j_2 (1 β€ j_1,j_2 β€ m, j_1 β j_2) denoting the indices of two pizzas in the required set. If there are several solutions, output any of them. Pizza indices can be printed in any order.
Examples
Input
3 4
2 6 7
4 2 3 9 5
3 2 3 9
100 1 7
400 3 3 2 5
100 2 9 2
500 3 2 9 5
Output
2 3
Input
4 3
1 1
1 2
1 3
1 4
10 4 1 2 3 4
20 4 1 2 3 4
30 4 1 2 3 4
Output
1 2
Input
1 5
9 9 8 7 6 5 4 3 2 1
3 4 1 2 3 4
1 4 5 6 7 8
4 4 1 3 5 7
1 4 2 4 6 8
5 4 1 9 2 8
Output
2 4
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
The only difference between easy and hard versions is the length of the string. You can hack this problem only if you solve both problems.
Kirk has a binary string s (a string which consists of zeroes and ones) of length n and he is asking you to find a binary string t of the same length which satisfies the following conditions:
* For any l and r (1 β€ l β€ r β€ n) the length of the longest non-decreasing subsequence of the substring s_{l}s_{l+1} β¦ s_{r} is equal to the length of the longest non-decreasing subsequence of the substring t_{l}t_{l+1} β¦ t_{r};
* The number of zeroes in t is the maximum possible.
A non-decreasing subsequence of a string p is a sequence of indices i_1, i_2, β¦, i_k such that i_1 < i_2 < β¦ < i_k and p_{i_1} β€ p_{i_2} β€ β¦ β€ p_{i_k}. The length of the subsequence is k.
If there are multiple substrings which satisfy the conditions, output any.
Input
The first line contains a binary string of length not more than 2\: 000.
Output
Output a binary string which satisfied the above conditions. If there are many such strings, output any of them.
Examples
Input
110
Output
010
Input
010
Output
010
Input
0001111
Output
0000000
Input
0111001100111011101000
Output
0011001100001011101000
Note
In the first example:
* For the substrings of the length 1 the length of the longest non-decreasing subsequnce is 1;
* For l = 1, r = 2 the longest non-decreasing subsequnce of the substring s_{1}s_{2} is 11 and the longest non-decreasing subsequnce of the substring t_{1}t_{2} is 01;
* For l = 1, r = 3 the longest non-decreasing subsequnce of the substring s_{1}s_{3} is 11 and the longest non-decreasing subsequnce of the substring t_{1}t_{3} is 00;
* For l = 2, r = 3 the longest non-decreasing subsequnce of the substring s_{2}s_{3} is 1 and the longest non-decreasing subsequnce of the substring t_{2}t_{3} is 1;
The second example is similar to the first one.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You are given a chess board with n rows and n columns. Initially all cells of the board are empty, and you have to put a white or a black knight into each cell of the board.
A knight is a chess piece that can attack a piece in cell (x_2, y_2) from the cell (x_1, y_1) if one of the following conditions is met:
* |x_1 - x_2| = 2 and |y_1 - y_2| = 1, or
* |x_1 - x_2| = 1 and |y_1 - y_2| = 2.
Here are some examples of which cells knight can attack. In each of the following pictures, if the knight is currently in the blue cell, it can attack all red cells (and only them).
<image>
A duel of knights is a pair of knights of different colors such that these knights attack each other. You have to put a knight (a white one or a black one) into each cell in such a way that the number of duels is maximum possible.
Input
The first line contains one integer n (3 β€ n β€ 100) β the number of rows (and columns) in the board.
Output
Print n lines with n characters in each line. The j-th character in the i-th line should be W, if the cell (i, j) contains a white knight, or B, if it contains a black knight. The number of duels should be maximum possible. If there are multiple optimal answers, print any of them.
Example
Input
3
Output
WBW
BBB
WBW
Note
In the first example, there are 8 duels:
1. the white knight in (1, 1) attacks the black knight in (3, 2);
2. the white knight in (1, 1) attacks the black knight in (2, 3);
3. the white knight in (1, 3) attacks the black knight in (3, 2);
4. the white knight in (1, 3) attacks the black knight in (2, 1);
5. the white knight in (3, 1) attacks the black knight in (1, 2);
6. the white knight in (3, 1) attacks the black knight in (2, 3);
7. the white knight in (3, 3) attacks the black knight in (1, 2);
8. the white knight in (3, 3) attacks the black knight in (2, 1).
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Let a be a matrix of size r Γ c containing positive integers, not necessarily distinct. Rows of the matrix are numbered from 1 to r, columns are numbered from 1 to c. We can construct an array b consisting of r + c integers as follows: for each i β [1, r], let b_i be the greatest common divisor of integers in the i-th row, and for each j β [1, c] let b_{r+j} be the greatest common divisor of integers in the j-th column.
We call the matrix diverse if all r + c numbers b_k (k β [1, r + c]) are pairwise distinct.
The magnitude of a matrix equals to the maximum of b_k.
For example, suppose we have the following matrix:
\begin{pmatrix} 2 & 9 & 7\\\ 4 & 144 & 84 \end{pmatrix}
We construct the array b:
1. b_1 is the greatest common divisor of 2, 9, and 7, that is 1;
2. b_2 is the greatest common divisor of 4, 144, and 84, that is 4;
3. b_3 is the greatest common divisor of 2 and 4, that is 2;
4. b_4 is the greatest common divisor of 9 and 144, that is 9;
5. b_5 is the greatest common divisor of 7 and 84, that is 7.
So b = [1, 4, 2, 9, 7]. All values in this array are distinct, so the matrix is diverse. The magnitude is equal to 9.
For a given r and c, find a diverse matrix that minimises the magnitude. If there are multiple solutions, you may output any of them. If there are no solutions, output a single integer 0.
Input
The only line in the input contains two space separated integers r and c (1 β€ r,c β€ 500) β the number of rows and the number of columns of the matrix to be found.
Output
If there is no solution, output a single integer 0.
Otherwise, output r rows. The i-th of them should contain c space-separated integers, the j-th of which is a_{i,j} β the positive integer in the i-th row and j-th column of a diverse matrix minimizing the magnitude.
Furthermore, it must hold that 1 β€ a_{i,j} β€ 10^9. It can be shown that if a solution exists, there is also a solution with this additional constraint (still having minimum possible magnitude).
Examples
Input
2 2
Output
4 12
2 9
Input
1 1
Output
0
Note
In the first example, the GCDs of rows are b_1 = 4 and b_2 = 1, and the GCDs of columns are b_3 = 2 and b_4 = 3. All GCDs are pairwise distinct and the maximum of them is 4. Since the GCDs have to be distinct and at least 1, it is clear that there are no diverse matrices of size 2 Γ 2 with magnitude smaller than 4.
In the second example, no matter what a_{1,1} is, b_1 = b_2 will always hold, so there are no diverse matrices.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
This problem is different with hard version only by constraints on total answers length
It is an interactive problem
Venya joined a tour to the madhouse, in which orderlies play with patients the following game. Orderlies pick a string s of length n, consisting only of lowercase English letters. The player can ask two types of queries:
* ? l r β ask to list all substrings of s[l..r]. Substrings will be returned in random order, and in every substring, all characters will be randomly shuffled.
* ! s β guess the string picked by the orderlies. This query can be asked exactly once, after that the game will finish. If the string is guessed correctly, the player wins, otherwise he loses.
The player can ask no more than 3 queries of the first type.
To make it easier for the orderlies, there is an additional limitation: the total number of returned substrings in all queries of the first type must not exceed (n+1)^2.
Venya asked you to write a program, which will guess the string by interacting with the orderlies' program and acting by the game's rules.
Your program should immediately terminate after guessing the string using a query of the second type. In case your program guessed the string incorrectly, or it violated the game rules, it will receive verdict Wrong answer.
Note that in every test case the string is fixed beforehand and will not change during the game, which means that the interactor is not adaptive.
Input
First line contains number n (1 β€ n β€ 100) β the length of the picked string.
Interaction
You start the interaction by reading the number n.
To ask a query about a substring from l to r inclusively (1 β€ l β€ r β€ n), you should output
? l r
on a separate line. After this, all substrings of s[l..r] will be returned in random order, each substring exactly once. In every returned substring all characters will be randomly shuffled.
In the case, if you ask an incorrect query, ask more than 3 queries of the first type or there will be more than (n+1)^2 substrings returned in total, you will receive verdict Wrong answer.
To guess the string s, you should output
! s
on a separate line.
After printing each query, do not forget to flush the output. Otherwise, you will get Idleness limit exceeded. To flush the output, you can 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.
If you received - (dash) as an answer to any query, you need to terminate your program with exit code 0 (for example, by calling exit(0)). This means that there was an error in the interaction protocol. If you don't terminate with exit code 0, you can receive any unsuccessful verdict.
Hack format
To hack a solution, use the following format:
The first line should contain one integer n (1 β€ n β€ 100) β the length of the string, and the following line should contain the string s.
Example
Input
4
a
aa
a
cb
b
c
c
Output
? 1 2
? 3 4
? 4 4
! aabc
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
After a successful year of milk production, Farmer John is rewarding his cows with their favorite treat: tasty grass!
On the field, there is a row of n units of grass, each with a sweetness s_i. Farmer John has m cows, each with a favorite sweetness f_i and a hunger value h_i. He would like to pick two disjoint subsets of cows to line up on the left and right side of the grass row. There is no restriction on how many cows must be on either side. The cows will be treated in the following manner:
* The cows from the left and right side will take turns feeding in an order decided by Farmer John.
* When a cow feeds, it walks towards the other end without changing direction and eats grass of its favorite sweetness until it eats h_i units.
* The moment a cow eats h_i units, it will fall asleep there, preventing further cows from passing it from both directions.
* If it encounters another sleeping cow or reaches the end of the grass row, it will get upset. Farmer John absolutely does not want any cows to get upset.
Note that grass does not grow back. Also, to prevent cows from getting upset, not every cow has to feed since FJ can choose a subset of them.
Surprisingly, FJ has determined that sleeping cows are the most satisfied. If FJ orders optimally, what is the maximum number of sleeping cows that can result, and how many ways can FJ choose the subset of cows on the left and right side to achieve that maximum number of sleeping cows (modulo 10^9+7)? The order in which FJ sends the cows does not matter as long as no cows get upset.
Input
The first line contains two integers n and m (1 β€ n β€ 5000, 1 β€ m β€ 5000) β the number of units of grass and the number of cows.
The second line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ n) β the sweetness values of the grass.
The i-th of the following m lines contains two integers f_i and h_i (1 β€ f_i, h_i β€ n) β the favorite sweetness and hunger value of the i-th cow. No two cows have the same hunger and favorite sweetness simultaneously.
Output
Output two integers β the maximum number of sleeping cows that can result and the number of ways modulo 10^9+7.
Examples
Input
5 2
1 1 1 1 1
1 2
1 3
Output
2 2
Input
5 2
1 1 1 1 1
1 2
1 4
Output
1 4
Input
3 2
2 3 2
3 1
2 1
Output
2 4
Input
5 1
1 1 1 1 1
2 5
Output
0 1
Note
In the first example, FJ can line up the cows as follows to achieve 2 sleeping cows:
* Cow 1 is lined up on the left side and cow 2 is lined up on the right side.
* Cow 2 is lined up on the left side and cow 1 is lined up on the right side.
In the second example, FJ can line up the cows as follows to achieve 1 sleeping cow:
* Cow 1 is lined up on the left side.
* Cow 2 is lined up on the left side.
* Cow 1 is lined up on the right side.
* Cow 2 is lined up on the right side.
In the third example, FJ can line up the cows as follows to achieve 2 sleeping cows:
* Cow 1 and 2 are lined up on the left side.
* Cow 1 and 2 are lined up on the right side.
* Cow 1 is lined up on the left side and cow 2 is lined up on the right side.
* Cow 1 is lined up on the right side and cow 2 is lined up on the left side.
In the fourth example, FJ cannot end up with any sleeping cows, so there will be no cows lined up on either side.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Drazil likes heap very much. So he created a problem with heap:
There is a max heap with a height h implemented on the array. The details of this heap are the following:
This heap contains exactly 2^h - 1 distinct positive non-zero integers. All integers are distinct. These numbers are stored in the array a indexed from 1 to 2^h-1. For any 1 < i < 2^h, a[i] < a[\left β{i/2}\right β].
Now we want to reduce the height of this heap such that the height becomes g with exactly 2^g-1 numbers in heap. To reduce the height, we should perform the following action 2^h-2^g times:
Choose an index i, which contains an element and call the following function f in index i:
<image>
Note that we suppose that if a[i]=0, then index i don't contain an element.
After all operations, the remaining 2^g-1 element must be located in indices from 1 to 2^g-1. Now Drazil wonders what's the minimum possible sum of the remaining 2^g-1 elements. Please find this sum and find a sequence of the function calls to achieve this value.
Input
The first line of the input contains an integer t (1 β€ t β€ 70 000): the number of test cases.
Each test case contain two lines. The first line contains two integers h and g (1 β€ g < h β€ 20). The second line contains n = 2^h-1 distinct positive integers a[1], a[2], β¦, a[n] (1 β€ a[i] < 2^{20}). For all i from 2 to 2^h - 1, a[i] < a[\left β{i/2}\right β].
The total sum of n is less than 2^{20}.
Output
For each test case, print two lines.
The first line should contain one integer denoting the minimum sum after reducing the height of heap to g. The second line should contain 2^h - 2^g integers v_1, v_2, β¦, v_{2^h-2^g}. In i-th operation f(v_i) should be called.
Example
Input
2
3 2
7 6 3 5 4 2 1
3 2
7 6 5 4 3 2 1
Output
10
3 2 3 1
8
2 1 3 1
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
A penguin Rocher has n sticks. He has exactly one stick with length i for all 1 β€ i β€ n.
He can connect some sticks. If he connects two sticks that have lengths a and b, he gets one stick with length a + b. Two sticks, that were used in the operation disappear from his set and the new connected stick appears in his set and can be used for the next connections.
He wants to create the maximum number of sticks that have the same length. It is not necessary to make all sticks have the same length, some sticks can have the other length. How many sticks with the equal length he can create?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases. Next t lines contain descriptions of test cases.
For each test case, the only line contains a single integer n (1 β€ n β€ 10^{9}).
Output
For each test case, print a single integer β the answer to the problem.
Example
Input
4
1
2
3
4
Output
1
1
2
2
Note
In the third case, he can connect two sticks with lengths 1 and 2 and he will get one stick with length 3. So, he will have two sticks with lengths 3.
In the fourth case, he can connect two sticks with lengths 1 and 3 and he will get one stick with length 4. After that, he will have three sticks with lengths \{2, 4, 4\}, so two sticks have the same length, and one stick has the other length.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Carousel Boutique is busy again! Rarity has decided to visit the pony ball and she surely needs a new dress, because going out in the same dress several times is a sign of bad manners. First of all, she needs a dress pattern, which she is going to cut out from the rectangular piece of the multicolored fabric.
The piece of the multicolored fabric consists of n Γ m separate square scraps. Since Rarity likes dresses in style, a dress pattern must only include scraps sharing the same color. A dress pattern must be the square, and since Rarity is fond of rhombuses, the sides of a pattern must form a 45^{\circ} angle with sides of a piece of fabric (that way it will be resembling the traditional picture of a rhombus).
Examples of proper dress patterns: <image> Examples of improper dress patterns: <image> The first one consists of multi-colored scraps, the second one goes beyond the bounds of the piece of fabric, the third one is not a square with sides forming a 45^{\circ} angle with sides of the piece of fabric.
Rarity wonders how many ways to cut out a dress pattern that satisfies all the conditions that do exist. Please help her and satisfy her curiosity so she can continue working on her new masterpiece!
Input
The first line contains two integers n and m (1 β€ n, m β€ 2000). Each of the next n lines contains m characters: lowercase English letters, the j-th of which corresponds to scrap in the current line and in the j-th column. Scraps having the same letter share the same color, scraps having different letters have different colors.
Output
Print a single integer: the number of ways to cut out a dress pattern to satisfy all of Rarity's conditions.
Examples
Input
3 3
aaa
aaa
aaa
Output
10
Input
3 4
abab
baba
abab
Output
12
Input
5 5
zbacg
baaac
aaaaa
eaaad
weadd
Output
31
Note
In the first example, all the dress patterns of size 1 and one of size 2 are satisfactory.
In the second example, only the dress patterns of size 1 are satisfactory.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You and your friend are playing the game Mortal Kombat XI. You are trying to pass a challenge tower. There are n bosses in this tower, numbered from 1 to n. The type of the i-th boss is a_i. If the i-th boss is easy then its type is a_i = 0, otherwise this boss is hard and its type is a_i = 1.
During one session, either you or your friend can kill one or two bosses (neither you nor your friend can skip the session, so the minimum number of bosses killed during one session is at least one). After your friend session, your session begins, then again your friend session begins, your session begins, and so on. The first session is your friend's session.
Your friend needs to get good because he can't actually kill hard bosses. To kill them, he uses skip points. One skip point can be used to kill one hard boss.
Your task is to find the minimum number of skip points your friend needs to use so you and your friend kill all n bosses in the given order.
For example: suppose n = 8, a = [1, 0, 1, 1, 0, 1, 1, 1]. Then the best course of action is the following:
* your friend kills two first bosses, using one skip point for the first boss;
* you kill the third and the fourth bosses;
* your friend kills the fifth boss;
* you kill the sixth and the seventh bosses;
* your friend kills the last boss, using one skip point, so the tower is completed using two skip points.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 β€ n β€ 2 β
10^5) β the number of bosses. The second line of the test case contains n integers a_1, a_2, ..., a_n (0 β€ a_i β€ 1), where a_i is the type of the i-th boss.
It is guaranteed that the sum of n does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer: the minimum number of skip points your friend needs to use so you and your friend kill all n bosses in the given order.
Example
Input
6
8
1 0 1 1 0 1 1 1
5
1 1 1 1 0
7
1 1 1 1 0 0 1
6
1 1 1 1 1 1
1
1
1
0
Output
2
2
2
2
1
0
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Sasha likes investigating different math objects, for example, magic squares. But Sasha understands that magic squares have already been studied by hundreds of people, so he sees no sense of studying them further. Instead, he invented his own type of square β a prime square.
A square of size n Γ n is called prime if the following three conditions are held simultaneously:
* all numbers on the square are non-negative integers not exceeding 10^5;
* there are no prime numbers in the square;
* sums of integers in each row and each column are prime numbers.
Sasha has an integer n. He asks you to find any prime square of size n Γ n. Sasha is absolutely sure such squares exist, so just help him!
Input
The first line contains a single integer t (1 β€ t β€ 10) β the number of test cases.
Each of the next t lines contains a single integer n (2 β€ n β€ 100) β the required size of a square.
Output
For each test case print n lines, each containing n integers β the prime square you built. If there are multiple answers, print any.
Example
Input
2
4
2
Output
4 6 8 1
4 9 9 9
4 10 10 65
1 4 4 4
1 1
1 1
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You have n stacks of blocks. The i-th stack contains h_i blocks and it's height is the number of blocks in it. In one move you can take a block from the i-th stack (if there is at least one block) and put it to the i + 1-th stack. Can you make the sequence of heights strictly increasing?
Note that the number of stacks always remains n: stacks don't disappear when they have 0 blocks.
Input
First line contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
The first line of each test case contains a single integer n (1 β€ n β€ 100). The second line of each test case contains n integers h_i (0 β€ h_i β€ 10^9) β starting heights of the stacks.
It's guaranteed that the sum of all n does not exceed 10^4.
Output
For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise.
You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer).
Example
Input
6
2
1 2
2
1 0
3
4 4 4
2
0 0
3
0 1 0
4
1000000000 1000000000 1000000000 1000000000
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case there is no need to make any moves, the sequence of heights is already increasing.
In the second test case we need to move one block from the first stack to the second. Then the heights become 0 1.
In the third test case we could move one block from the first stack to the second and then from the second to the third, which would make the heights 3 4 5.
In the fourth test case we can't make a move, but the sequence is not increasing, so the answer is NO.
In the fifth test case we can only make one move (from the second to the third stack), which would make the heights 0 0 1. Both 0 1 0 and 0 0 1 are not increasing sequences, so the answer is NO.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
The tycoon of a winery empire in Mondstadt, unmatched in every possible way. A thinker in the Knights of Favonius with an exotic appearance.
This time, the brothers are dealing with a strange piece of wood marked with their names. This plank of wood can be represented as a string of n characters. Each character is either a 'D' or a 'K'. You want to make some number of cuts (possibly 0) on this string, partitioning it into several contiguous pieces, each with length at least 1. Both brothers act with dignity, so they want to split the wood as evenly as possible. They want to know the maximum number of pieces you can split the wood into such that the ratios of the number of occurrences of 'D' to the number of occurrences of 'K' in each chunk are the same.
Kaeya, the curious thinker, is interested in the solution for multiple scenarios. He wants to know the answer for every prefix of the given string. Help him to solve this problem!
For a string we define a ratio as a:b where 'D' appears in it a times, and 'K' appears b times. Note that a or b can equal 0, but not both. Ratios a:b and c:d are considered equal if and only if aβ
d = bβ
c.
For example, for the string 'DDD' the ratio will be 3:0, for 'DKD' β 2:1, for 'DKK' β 1:2, and for 'KKKKDD' β 2:4. Note that the ratios of the latter two strings are equal to each other, but they are not equal to the ratios of the first two strings.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 1000). Description of the test cases follows.
The first line of each test case contains an integer n (1 β€ n β€ 5 β
10^5) β the length of the wood.
The second line of each test case contains a string s of length n. Every character of s will be either 'D' or 'K'.
It is guaranteed that the sum of n over all test cases does not exceed 5 β
10^5.
Output
For each test case, output n space separated integers. The i-th of these numbers should equal the answer for the prefix s_{1},s_{2},...,s_{i}.
Example
Input
5
3
DDK
6
DDDDDD
4
DKDK
1
D
9
DKDKDDDDK
Output
1 2 1
1 2 3 4 5 6
1 1 1 2
1
1 1 1 2 1 2 1 1 3
Note
For the first test case, there is no way to partition 'D' or 'DDK' into more than one block with equal ratios of numbers of 'D' and 'K', while you can split 'DD' into 'D' and 'D'.
For the second test case, you can split each prefix of length i into i blocks 'D'.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Goa'uld Apophis captured Jack O'Neill's team again! Jack himself was able to escape, but by that time Apophis's ship had already jumped to hyperspace. But Jack knows on what planet will Apophis land. In order to save his friends, Jack must repeatedly go through stargates to get to this planet.
Overall the galaxy has n planets, indexed with numbers from 1 to n. Jack is on the planet with index 1, and Apophis will land on the planet with index n. Jack can move between some pairs of planets through stargates (he can move in both directions); the transfer takes a positive, and, perhaps, for different pairs of planets unequal number of seconds. Jack begins his journey at time 0.
It can be that other travellers are arriving to the planet where Jack is currently located. In this case, Jack has to wait for exactly 1 second before he can use the stargate. That is, if at time t another traveller arrives to the planet, Jack can only pass through the stargate at time t + 1, unless there are more travellers arriving at time t + 1 to the same planet.
Knowing the information about travel times between the planets, and the times when Jack would not be able to use the stargate on particular planets, determine the minimum time in which he can get to the planet with index n.
Input
The first line contains two space-separated integers: n (2 β€ n β€ 105), the number of planets in the galaxy, and m (0 β€ m β€ 105) β the number of pairs of planets between which Jack can travel using stargates. Then m lines follow, containing three integers each: the i-th line contains numbers of planets ai and bi (1 β€ ai, bi β€ n, ai β bi), which are connected through stargates, and the integer transfer time (in seconds) ci (1 β€ ci β€ 104) between these planets. It is guaranteed that between any pair of planets there is at most one stargate connection.
Then n lines follow: the i-th line contains an integer ki (0 β€ ki β€ 105) that denotes the number of moments of time when other travellers arrive to the planet with index i. Then ki distinct space-separated integers tij (0 β€ tij < 109) follow, sorted in ascending order. An integer tij means that at time tij (in seconds) another traveller arrives to the planet i. It is guaranteed that the sum of all ki does not exceed 105.
Output
Print a single number β the least amount of time Jack needs to get from planet 1 to planet n. If Jack can't get to planet n in any amount of time, print number -1.
Examples
Input
4 6
1 2 2
1 3 3
1 4 8
2 3 4
2 4 5
3 4 3
0
1 3
2 3 4
0
Output
7
Input
3 1
1 2 3
0
1 3
0
Output
-1
Note
In the first sample Jack has three ways to go from planet 1. If he moves to planet 4 at once, he spends 8 seconds. If he transfers to planet 3, he spends 3 seconds, but as other travellers arrive to planet 3 at time 3 and 4, he can travel to planet 4 only at time 5, thus spending 8 seconds in total. But if Jack moves to planet 2, and then β to planet 4, then he spends a total of only 2 + 5 = 7 seconds.
In the second sample one can't get from planet 1 to planet 3 by moving through stargates.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Furlo and Rublo play a game. The table has n piles of coins lying on it, the i-th pile has ai coins. Furlo and Rublo move in turns, Furlo moves first. In one move you are allowed to:
* choose some pile, let's denote the current number of coins in it as x;
* choose some integer y (0 β€ y < x; x1 / 4 β€ y β€ x1 / 2) and decrease the number of coins in this pile to y. In other words, after the described move the pile will have y coins left.
The player who can't make a move, loses.
Your task is to find out, who wins in the given game if both Furlo and Rublo play optimally well.
Input
The first line contains integer n (1 β€ n β€ 77777) β the number of piles. The next line contains n integers a1, a2, ..., an (1 β€ ai β€ 777777777777) β the sizes of piles. The numbers are separated by single spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
If both players play optimally well and Furlo wins, print "Furlo", otherwise print "Rublo". Print the answers without the quotes.
Examples
Input
1
1
Output
Rublo
Input
2
1 2
Output
Rublo
Input
10
1 2 3 4 5 6 7 8 9 10
Output
Furlo
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
The sequence is called ordered if it is non-decreasing or non-increasing. For example, sequnces [3, 1, 1, 0] and [1, 2, 3, 100] are ordered, but the sequence [1, 3, 3, 1] is not. You are given a sequence of numbers. You are to find it's shortest subsequence which is not ordered.
A subsequence is a sequence that can be derived from the given sequence by deleting zero or more elements without changing the order of the remaining elements.
Input
The first line of the input contains one integer n (1 β€ n β€ 105). The second line contains n space-separated integers β the given sequence. All numbers in this sequence do not exceed 106 by absolute value.
Output
If the given sequence does not contain any unordered subsequences, output 0. Otherwise, output the length k of the shortest such subsequence. Then output k integers from the range [1..n] β indexes of the elements of this subsequence. If there are several solutions, output any of them.
Examples
Input
5
67 499 600 42 23
Output
3
1 3 5
Input
3
1 2 3
Output
0
Input
3
2 3 1
Output
3
1 2 3
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Eugeny loves listening to music. He has n songs in his play list. We know that song number i has the duration of ti minutes. Eugeny listens to each song, perhaps more than once. He listens to song number i ci times. Eugeny's play list is organized as follows: first song number 1 plays c1 times, then song number 2 plays c2 times, ..., in the end the song number n plays cn times.
Eugeny took a piece of paper and wrote out m moments of time when he liked a song. Now for each such moment he wants to know the number of the song that played at that moment. The moment x means that Eugeny wants to know which song was playing during the x-th minute of his listening to the play list.
Help Eugeny and calculate the required numbers of songs.
Input
The first line contains two integers n, m (1 β€ n, m β€ 105). The next n lines contain pairs of integers. The i-th line contains integers ci, ti (1 β€ ci, ti β€ 109) β the description of the play list. It is guaranteed that the play list's total duration doesn't exceed 109 <image>.
The next line contains m positive integers v1, v2, ..., vm, that describe the moments Eugeny has written out. It is guaranteed that there isn't such moment of time vi, when the music doesn't play any longer. It is guaranteed that vi < vi + 1 (i < m).
The moment of time vi means that Eugeny wants to know which song was playing during the vi-th munite from the start of listening to the playlist.
Output
Print m integers β the i-th number must equal the number of the song that was playing during the vi-th minute after Eugeny started listening to the play list.
Examples
Input
1 2
2 8
1 16
Output
1
1
Input
4 9
1 2
2 1
1 1
2 2
1 2 3 4 5 6 7 8 9
Output
1
1
2
2
3
4
4
4
4
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
I have an undirected graph consisting of n nodes, numbered 1 through n. Each node has at most two incident edges. For each pair of nodes, there is at most an edge connecting them. No edge connects a node to itself.
I would like to create a new graph in such a way that:
* The new graph consists of the same number of nodes and edges as the old graph.
* The properties in the first paragraph still hold.
* For each two nodes u and v, if there is an edge connecting them in the old graph, there is no edge connecting them in the new graph.
Help me construct the new graph, or tell me if it is impossible.
Input
The first line consists of two space-separated integers: n and m (1 β€ m β€ n β€ 105), denoting the number of nodes and edges, respectively. Then m lines follow. Each of the m lines consists of two space-separated integers u and v (1 β€ u, v β€ n; u β v), denoting an edge between nodes u and v.
Output
If it is not possible to construct a new graph with the mentioned properties, output a single line consisting of -1. Otherwise, output exactly m lines. Each line should contain a description of edge in the same way as used in the input format.
Examples
Input
8 7
1 2
2 3
4 5
5 6
6 8
8 7
7 4
Output
1 4
4 6
1 6
2 7
7 5
8 5
2 8
Input
3 2
1 2
2 3
Output
-1
Input
5 4
1 2
2 3
3 4
4 1
Output
1 3
3 5
5 2
2 4
Note
The old graph of the first example:
<image>
A possible new graph for the first example:
<image>
In the second example, we cannot create any new graph.
The old graph of the third example:
<image>
A possible new graph for the third example:
<image>
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Valera wanted to prepare a Codesecrof round. He's already got one problem and he wants to set a time limit (TL) on it.
Valera has written n correct solutions. For each correct solution, he knows its running time (in seconds). Valera has also wrote m wrong solutions and for each wrong solution he knows its running time (in seconds).
Let's suppose that Valera will set v seconds TL in the problem. Then we can say that a solution passes the system testing if its running time is at most v seconds. We can also say that a solution passes the system testing with some "extra" time if for its running time, a seconds, an inequality 2a β€ v holds.
As a result, Valera decided to set v seconds TL, that the following conditions are met:
1. v is a positive integer;
2. all correct solutions pass the system testing;
3. at least one correct solution passes the system testing with some "extra" time;
4. all wrong solutions do not pass the system testing;
5. value v is minimum among all TLs, for which points 1, 2, 3, 4 hold.
Help Valera and find the most suitable TL or else state that such TL doesn't exist.
Input
The first line contains two integers n, m (1 β€ n, m β€ 100). The second line contains n space-separated positive integers a1, a2, ..., an (1 β€ ai β€ 100) β the running time of each of the n correct solutions in seconds. The third line contains m space-separated positive integers b1, b2, ..., bm (1 β€ bi β€ 100) β the running time of each of m wrong solutions in seconds.
Output
If there is a valid TL value, print it. Otherwise, print -1.
Examples
Input
3 6
4 5 2
8 9 6 10 7 11
Output
5
Input
3 1
3 4 5
6
Output
-1
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Inna loves digit 9 very much. That's why she asked Dima to write a small number consisting of nines. But Dima must have misunderstood her and he wrote a very large number a, consisting of digits from 1 to 9.
Inna wants to slightly alter the number Dima wrote so that in the end the number contained as many digits nine as possible. In one move, Inna can choose two adjacent digits in a number which sum equals 9 and replace them by a single digit 9.
For instance, Inna can alter number 14545181 like this: 14545181 β 1945181 β 194519 β 19919. Also, she can use this method to transform number 14545181 into number 19991. Inna will not transform it into 149591 as she can get numbers 19919 and 19991 which contain more digits nine.
Dima is a programmer so he wants to find out how many distinct numbers containing as many digits nine as possible Inna can get from the written number. Help him with this challenging task.
Input
The first line of the input contains integer a (1 β€ a β€ 10100000). Number a doesn't have any zeroes.
Output
In a single line print a single integer β the answer to the problem. It is guaranteed that the answer to the problem doesn't exceed 263 - 1.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
369727
Output
2
Input
123456789987654321
Output
1
Input
1
Output
1
Note
Notes to the samples
In the first sample Inna can get the following numbers: 369727 β 99727 β 9997, 369727 β 99727 β 9979.
In the second sample, Inna can act like this: 123456789987654321 β 12396789987654321 β 1239678998769321.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
DZY loves Physics, and he enjoys calculating density.
Almost everything has density, even a graph. We define the density of a non-directed graph (nodes and edges of the graph have some values) as follows:
<image> where v is the sum of the values of the nodes, e is the sum of the values of the edges.
Once DZY got a graph G, now he wants to find a connected induced subgraph G' of the graph, such that the density of G' is as large as possible.
An induced subgraph G'(V', E') of a graph G(V, E) is a graph that satisfies:
* <image>;
* edge <image> if and only if <image>, and edge <image>;
* the value of an edge in G' is the same as the value of the corresponding edge in G, so as the value of a node.
Help DZY to find the induced subgraph with maximum density. Note that the induced subgraph you choose must be connected.
<image>
Input
The first line contains two space-separated integers n (1 β€ n β€ 500), <image>. Integer n represents the number of nodes of the graph G, m represents the number of edges.
The second line contains n space-separated integers xi (1 β€ xi β€ 106), where xi represents the value of the i-th node. Consider the graph nodes are numbered from 1 to n.
Each of the next m lines contains three space-separated integers ai, bi, ci (1 β€ ai < bi β€ n; 1 β€ ci β€ 103), denoting an edge between node ai and bi with value ci. The graph won't contain multiple edges.
Output
Output a real number denoting the answer, with an absolute or relative error of at most 10 - 9.
Examples
Input
1 0
1
Output
0.000000000000000
Input
2 1
1 2
1 2 1
Output
3.000000000000000
Input
5 6
13 56 73 98 17
1 2 56
1 3 29
1 4 42
2 3 95
2 4 88
3 4 63
Output
2.965517241379311
Note
In the first sample, you can only choose an empty subgraph, or the subgraph containing only node 1.
In the second sample, choosing the whole graph is optimal.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
After you had helped Fedor to find friends in the Β«Call of Soldiers 3Β» game, he stopped studying completely. Today, the English teacher told him to prepare an essay. Fedor didn't want to prepare the essay, so he asked Alex for help. Alex came to help and wrote the essay for Fedor. But Fedor didn't like the essay at all. Now Fedor is going to change the essay using the synonym dictionary of the English language.
Fedor does not want to change the meaning of the essay. So the only change he would do: change a word from essay to one of its synonyms, basing on a replacement rule from the dictionary. Fedor may perform this operation any number of times.
As a result, Fedor wants to get an essay which contains as little letters Β«RΒ» (the case doesn't matter) as possible. If there are multiple essays with minimum number of Β«RΒ»s he wants to get the one with minimum length (length of essay is the sum of the lengths of all the words in it). Help Fedor get the required essay.
Please note that in this problem the case of letters doesn't matter. For example, if the synonym dictionary says that word cat can be replaced with word DOG, then it is allowed to replace the word Cat with the word doG.
Input
The first line contains a single integer m (1 β€ m β€ 105) β the number of words in the initial essay. The second line contains words of the essay. The words are separated by a single space. It is guaranteed that the total length of the words won't exceed 105 characters.
The next line contains a single integer n (0 β€ n β€ 105) β the number of pairs of words in synonym dictionary. The i-th of the next n lines contains two space-separated non-empty words xi and yi. They mean that word xi can be replaced with word yi (but not vise versa). It is guaranteed that the total length of all pairs of synonyms doesn't exceed 5Β·105 characters.
All the words at input can only consist of uppercase and lowercase letters of the English alphabet.
Output
Print two integers β the minimum number of letters Β«RΒ» in an optimal essay and the minimum length of an optimal essay.
Examples
Input
3
AbRb r Zz
4
xR abRb
aA xr
zz Z
xr y
Output
2 6
Input
2
RuruRu fedya
1
ruruRU fedor
Output
1 10
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You are given a permutation of n numbers p1, p2, ..., pn. We perform k operations of the following type: choose uniformly at random two indices l and r (l β€ r) and reverse the order of the elements pl, pl + 1, ..., pr. Your task is to find the expected value of the number of inversions in the resulting permutation.
Input
The first line of input contains two integers n and k (1 β€ n β€ 100, 1 β€ k β€ 109). The next line contains n integers p1, p2, ..., pn β the given permutation. All pi are different and in range from 1 to n.
The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem G1 (3 points), the constraints 1 β€ n β€ 6, 1 β€ k β€ 4 will hold.
* In subproblem G2 (5 points), the constraints 1 β€ n β€ 30, 1 β€ k β€ 200 will hold.
* In subproblem G3 (16 points), the constraints 1 β€ n β€ 100, 1 β€ k β€ 109 will hold.
Output
Output the answer with absolute or relative error no more than 1e - 9.
Examples
Input
3 1
1 2 3
Output
0.833333333333333
Input
3 4
1 3 2
Output
1.458333333333334
Note
Consider the first sample test. We will randomly pick an interval of the permutation (1, 2, 3) (which has no inversions) and reverse the order of its elements. With probability <image>, the interval will consist of a single element and the permutation will not be altered. With probability <image> we will inverse the first two elements' order and obtain the permutation (2, 1, 3) which has one inversion. With the same probability we might pick the interval consisting of the last two elements which will lead to the permutation (1, 3, 2) with one inversion. Finally, with probability <image> the randomly picked interval will contain all elements, leading to the permutation (3, 2, 1) with 3 inversions. Hence, the expected number of inversions is equal to <image>.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Life in Bertown has become hard. The city has too many roads and the government spends too much to maintain them. There are n junctions and m two way roads, at which one can get from each junction to any other one. The mayor wants to close some roads so that the number of roads left totaled to n - 1 roads and it were still possible to get from each junction to any other one. Besides, the mayor is concerned with the number of dead ends which are the junctions from which only one road goes. There shouldn't be too many or too few junctions. Having discussed the problem, the mayor and his assistants decided that after the roads are closed, the road map should contain exactly k dead ends. Your task is to count the number of different ways of closing the roads at which the following conditions are met:
* There are exactly n - 1 roads left.
* It is possible to get from each junction to any other one.
* There are exactly k dead ends on the resulting map.
Two ways are considered different if there is a road that is closed in the first way, and is open in the second one.
Input
The first line contains three integers n, m and k (3 β€ n β€ 10, n - 1 β€ m β€ nΒ·(n - 1) / 2, 2 β€ k β€ n - 1) which represent the number of junctions, roads and dead ends correspondingly. Then follow m lines each containing two different integers v1 and v2 (1 β€ v1, v2 β€ n, v1 β v2) which represent the number of junctions connected by another road. There can be no more than one road between every pair of junctions. The junctions are numbered with integers from 1 to n. It is guaranteed that it is possible to get from each junction to any other one along the original roads.
Output
Print a single number β the required number of ways.
Examples
Input
3 3 2
1 2
2 3
1 3
Output
3
Input
4 6 2
1 2
2 3
3 4
4 1
1 3
2 4
Output
12
Input
4 6 3
1 2
2 3
3 4
4 1
1 3
2 4
Output
4
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Rikhail Mubinchik believes that the current definition of prime numbers is obsolete as they are too complex and unpredictable. A palindromic number is another matter. It is aesthetically pleasing, and it has a number of remarkable properties. Help Rikhail to convince the scientific community in this!
Let us remind you that a number is called prime if it is integer larger than one, and is not divisible by any positive integer other than itself and one.
Rikhail calls a number a palindromic if it is integer, positive, and its decimal representation without leading zeros is a palindrome, i.e. reads the same from left to right and right to left.
One problem with prime numbers is that there are too many of them. Let's introduce the following notation: Ο(n) β the number of primes no larger than n, rub(n) β the number of palindromic numbers no larger than n. Rikhail wants to prove that there are a lot more primes than palindromic ones.
He asked you to solve the following problem: for a given value of the coefficient A find the maximum n, such that Ο(n) β€ AΒ·rub(n).
Input
The input consists of two positive integers p, q, the numerator and denominator of the fraction that is the value of A (<image>, <image>).
Output
If such maximum number exists, then print it. Otherwise, print "Palindromic tree is better than splay tree" (without the quotes).
Examples
Input
1 1
Output
40
Input
1 42
Output
1
Input
6 4
Output
172
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
A long time ago (probably even in the first book), Nicholas Flamel, a great alchemist and the creator of the Philosopher's Stone, taught Harry Potter three useful spells. The first one allows you to convert a grams of sand into b grams of lead, the second one allows you to convert c grams of lead into d grams of gold and third one allows you to convert e grams of gold into f grams of sand. When Harry told his friends about these spells, Ron Weasley was amazed. After all, if they succeed in turning sand into lead, lead into gold, and then turning part of the gold into sand again and so on, then it will be possible to start with a small amount of sand and get huge amounts of gold! Even an infinite amount of gold! Hermione Granger, by contrast, was skeptical about that idea. She argues that according to the law of conservation of matter getting an infinite amount of matter, even using magic, is impossible. On the contrary, the amount of matter may even decrease during transformation, being converted to magical energy. Though Hermione's theory seems convincing, Ron won't believe her. As far as Ron is concerned, Hermione made up her law of conservation of matter to stop Harry and Ron wasting their time with this nonsense, and to make them go and do homework instead. That's why Ron has already collected a certain amount of sand for the experiments. A quarrel between the friends seems unavoidable...
Help Harry to determine which one of his friends is right, and avoid the quarrel after all. To do this you have to figure out whether it is possible to get the amount of gold greater than any preassigned number from some finite amount of sand.
Input
The first line contains 6 integers a, b, c, d, e, f (0 β€ a, b, c, d, e, f β€ 1000).
Output
Print "Ron", if it is possible to get an infinitely large amount of gold having a certain finite amount of sand (and not having any gold and lead at all), i.e., Ron is right. Otherwise, print "Hermione".
Examples
Input
100 200 250 150 200 250
Output
Ron
Input
100 50 50 200 200 100
Output
Hermione
Input
100 10 200 20 300 30
Output
Hermione
Input
0 0 0 0 0 0
Output
Hermione
Input
1 1 0 1 1 1
Output
Ron
Input
1 0 1 2 1 2
Output
Hermione
Input
100 1 100 1 0 1
Output
Ron
Note
Consider the first sample. Let's start with the 500 grams of sand. Apply the first spell 5 times and turn the sand into 1000 grams of lead. Then apply the second spell 4 times to get 600 grams of gold. Letβs take 400 grams from the resulting amount of gold turn them back into sand. We get 500 grams of sand and 200 grams of gold. If we apply the same operations to 500 grams of sand again, we can get extra 200 grams of gold every time. Thus, you can get 200, 400, 600 etc. grams of gold, i.e., starting with a finite amount of sand (500 grams), you can get the amount of gold which is greater than any preassigned number.
In the forth sample it is impossible to get sand, or lead, or gold, applying the spells.
In the fifth sample an infinitely large amount of gold can be obtained by using only the second spell, which allows you to receive 1 gram of gold out of nothing. Note that if such a second spell is available, then the first and the third one do not affect the answer at all.
The seventh sample is more interesting. We can also start with a zero amount of sand there. With the aid of the third spell you can get sand out of nothing. We get 10000 grams of sand in this manner. Let's get 100 grams of lead using the first spell 100 times. Then make 1 gram of gold from them. We managed to receive 1 gram of gold, starting with a zero amount of sand! Clearly, in this manner you can get an infinitely large amount of gold.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Polycarp has interviewed Oleg and has written the interview down without punctuation marks and spaces to save time. Thus, the interview is now a string s consisting of n lowercase English letters.
There is a filler word ogo in Oleg's speech. All words that can be obtained from ogo by adding go several times to the end of it are also considered to be fillers. For example, the words ogo, ogogo, ogogogo are fillers, but the words go, og, ogog, ogogog and oggo are not fillers.
The fillers have maximal size, for example, for ogogoo speech we can't consider ogo a filler and goo as a normal phrase. We should consider ogogo as a filler here.
To print the interview, Polycarp has to replace each of the fillers with three asterisks. Note that a filler word is replaced with exactly three asterisks regardless of its length.
Polycarp has dealt with this problem in no time. Can you do the same? The clock is ticking!
Input
The first line contains a positive integer n (1 β€ n β€ 100) β the length of the interview.
The second line contains the string s of length n, consisting of lowercase English letters.
Output
Print the interview text after the replacement of each of the fillers with "***". It is allowed for the substring "***" to have several consecutive occurences.
Examples
Input
7
aogogob
Output
a***b
Input
13
ogogmgogogogo
Output
***gmg***
Input
9
ogoogoogo
Output
*********
Note
The first sample contains one filler word ogogo, so the interview for printing is "a***b".
The second sample contains two fillers ogo and ogogogo. Thus, the interview is transformed to "***gmg***".
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
You have n devices that you want to use simultaneously.
The i-th device uses ai units of power per second. This usage is continuous. That is, in λ seconds, the device will use λ·ai units of power. The i-th device currently has bi units of power stored. All devices can store an arbitrary amount of power.
You have a single charger that can plug to any single device. The charger will add p units of power per second to a device. This charging is continuous. That is, if you plug in a device for λ seconds, it will gain λ·p units of power. You can switch which device is charging at any arbitrary unit of time (including real numbers), and the time it takes to switch is negligible.
You are wondering, what is the maximum amount of time you can use the devices until one of them hits 0 units of power.
If you can use the devices indefinitely, print -1. Otherwise, print the maximum amount of time before any one device hits 0 power.
Input
The first line contains two integers, n and p (1 β€ n β€ 100 000, 1 β€ p β€ 109) β the number of devices and the power of the charger.
This is followed by n lines which contain two integers each. Line i contains the integers ai and bi (1 β€ ai, bi β€ 100 000) β the power of the device and the amount of power stored in the device in the beginning.
Output
If you can use the devices indefinitely, print -1. Otherwise, print the maximum amount of time before any one device hits 0 power.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 4.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
2 1
2 2
2 1000
Output
2.0000000000
Input
1 100
1 1
Output
-1
Input
3 5
4 3
5 2
6 1
Output
0.5000000000
Note
In sample test 1, you can charge the first device for the entire time until it hits zero power. The second device has enough power to last this time without being charged.
In sample test 2, you can use the device indefinitely.
In sample test 3, we can charge the third device for 2 / 5 of a second, then switch to charge the second device for a 1 / 10 of a second.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Given a positive integer n, find k integers (not necessary distinct) such that all these integers are strictly greater than 1, and their product is equal to n.
Input
The first line contains two integers n and k (2 β€ n β€ 100000, 1 β€ k β€ 20).
Output
If it's impossible to find the representation of n as a product of k numbers, print -1.
Otherwise, print k integers in any order. Their product must be equal to n. If there are multiple answers, print any of them.
Examples
Input
100000 2
Output
2 50000
Input
100000 20
Output
-1
Input
1024 5
Output
2 64 2 2 2
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Ivan likes to learn different things about numbers, but he is especially interested in really big numbers. Ivan thinks that a positive integer number x is really big if the difference between x and the sum of its digits (in decimal representation) is not less than s. To prove that these numbers may have different special properties, he wants to know how rare (or not rare) they are β in fact, he needs to calculate the quantity of really big numbers that are not greater than n.
Ivan tried to do the calculations himself, but soon realized that it's too difficult for him. So he asked you to help him in calculations.
Input
The first (and the only) line contains two integers n and s (1 β€ n, s β€ 1018).
Output
Print one integer β the quantity of really big numbers that are not greater than n.
Examples
Input
12 1
Output
3
Input
25 20
Output
0
Input
10 9
Output
1
Note
In the first example numbers 10, 11 and 12 are really big.
In the second example there are no really big numbers that are not greater than 25 (in fact, the first really big number is 30: 30 - 3 β₯ 20).
In the third example 10 is the only really big number (10 - 1 β₯ 9).
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Ilya is working for the company that constructs robots. Ilya writes programs for entertainment robots, and his current project is "Bob", a new-generation game robot. Ilya's boss wants to know his progress so far. Especially he is interested if Bob is better at playing different games than the previous model, "Alice".
So now Ilya wants to compare his robots' performance in a simple game called "1-2-3". This game is similar to the "Rock-Paper-Scissors" game: both robots secretly choose a number from the set {1, 2, 3} and say it at the same moment. If both robots choose the same number, then it's a draw and noone gets any points. But if chosen numbers are different, then one of the robots gets a point: 3 beats 2, 2 beats 1 and 1 beats 3.
Both robots' programs make them choose their numbers in such a way that their choice in (i + 1)-th game depends only on the numbers chosen by them in i-th game.
Ilya knows that the robots will play k games, Alice will choose number a in the first game, and Bob will choose b in the first game. He also knows both robots' programs and can tell what each robot will choose depending on their choices in previous game. Ilya doesn't want to wait until robots play all k games, so he asks you to predict the number of points they will have after the final game.
Input
The first line contains three numbers k, a, b (1 β€ k β€ 1018, 1 β€ a, b β€ 3).
Then 3 lines follow, i-th of them containing 3 numbers Ai, 1, Ai, 2, Ai, 3, where Ai, j represents Alice's choice in the game if Alice chose i in previous game and Bob chose j (1 β€ Ai, j β€ 3).
Then 3 lines follow, i-th of them containing 3 numbers Bi, 1, Bi, 2, Bi, 3, where Bi, j represents Bob's choice in the game if Alice chose i in previous game and Bob chose j (1 β€ Bi, j β€ 3).
Output
Print two numbers. First of them has to be equal to the number of points Alice will have, and second of them must be Bob's score after k games.
Examples
Input
10 2 1
1 1 1
1 1 1
1 1 1
2 2 2
2 2 2
2 2 2
Output
1 9
Input
8 1 1
2 2 1
3 3 1
3 1 3
1 1 1
2 1 1
1 2 3
Output
5 2
Input
5 1 1
1 2 2
2 2 2
2 2 2
1 2 2
2 2 2
2 2 2
Output
0 0
Note
In the second example game goes like this:
<image>
The fourth and the seventh game are won by Bob, the first game is draw and the rest are won by Alice.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Let's suppose you have an array a, a stack s (initially empty) and an array b (also initially empty).
You may perform the following operations until both a and s are empty:
* Take the first element of a, push it into s and remove it from a (if a is not empty);
* Take the top element from s, append it to the end of array b and remove it from s (if s is not empty).
You can perform these operations in arbitrary order.
If there exists a way to perform the operations such that array b is sorted in non-descending order in the end, then array a is called stack-sortable.
For example, [3, 1, 2] is stack-sortable, because b will be sorted if we perform the following operations:
1. Remove 3 from a and push it into s;
2. Remove 1 from a and push it into s;
3. Remove 1 from s and append it to the end of b;
4. Remove 2 from a and push it into s;
5. Remove 2 from s and append it to the end of b;
6. Remove 3 from s and append it to the end of b.
After all these operations b = [1, 2, 3], so [3, 1, 2] is stack-sortable. [2, 3, 1] is not stack-sortable.
You are given k first elements of some permutation p of size n (recall that a permutation of size n is an array of size n where each integer from 1 to n occurs exactly once). You have to restore the remaining n - k elements of this permutation so it is stack-sortable. If there are multiple answers, choose the answer such that p is lexicographically maximal (an array q is lexicographically greater than an array p iff there exists some integer k such that for every i < k qi = pi, and qk > pk). You may not swap or change any of first k elements of the permutation.
Print the lexicographically maximal permutation p you can obtain.
If there exists no answer then output -1.
Input
The first line contains two integers n and k (2 β€ n β€ 200000, 1 β€ k < n) β the size of a desired permutation, and the number of elements you are given, respectively.
The second line contains k integers p1, p2, ..., pk (1 β€ pi β€ n) β the first k elements of p. These integers are pairwise distinct.
Output
If it is possible to restore a stack-sortable permutation p of size n such that the first k elements of p are equal to elements given in the input, print lexicographically maximal such permutation.
Otherwise print -1.
Examples
Input
5 3
3 2 1
Output
3 2 1 5 4
Input
5 3
2 3 1
Output
-1
Input
5 1
3
Output
3 2 1 5 4
Input
5 2
3 4
Output
-1
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
Firecrackers scare Nian the monster, but they're wayyyyy too noisy! Maybe fireworks make a nice complement.
Little Tommy is watching a firework show. As circular shapes spread across the sky, a splendid view unfolds on the night of Lunar New Year's eve.
A wonder strikes Tommy. How many regions are formed by the circles on the sky? We consider the sky as a flat plane. A region is a connected part of the plane with positive area, whose bound consists of parts of bounds of the circles and is a curve or several curves without self-intersections, and that does not contain any curve other than its boundaries. Note that exactly one of the regions extends infinitely.
Input
The first line of input contains one integer n (1 β€ n β€ 3), denoting the number of circles.
The following n lines each contains three space-separated integers x, y and r ( - 10 β€ x, y β€ 10, 1 β€ r β€ 10), describing a circle whose center is (x, y) and the radius is r. No two circles have the same x, y and r at the same time.
Output
Print a single integer β the number of regions on the plane.
Examples
Input
3
0 0 1
2 0 1
4 0 1
Output
4
Input
3
0 0 2
3 0 2
6 0 2
Output
6
Input
3
0 0 2
2 0 2
1 1 2
Output
8
Note
For the first example,
<image>
For the second example,
<image>
For the third example,
<image>
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Solve the programming task below in a Python markdown code block.
It is the middle of 2018 and Maria Stepanovna, who lives outside Krasnokamensk (a town in Zabaikalsky region), wants to rent three displays to highlight an important problem.
There are n displays placed along a road, and the i-th of them can display a text with font size s_i only. Maria Stepanovna wants to rent such three displays with indices i < j < k that the font size increases if you move along the road in a particular direction. Namely, the condition s_i < s_j < s_k should be held.
The rent cost is for the i-th display is c_i. Please determine the smallest cost Maria Stepanovna should pay.
Input
The first line contains a single integer n (3 β€ n β€ 3 000) β the number of displays.
The second line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ 10^9) β the font sizes on the displays in the order they stand along the road.
The third line contains n integers c_1, c_2, β¦, c_n (1 β€ c_i β€ 10^8) β the rent costs for each display.
Output
If there are no three displays that satisfy the criteria, print -1. Otherwise print a single integer β the minimum total rent cost of three displays with indices i < j < k such that s_i < s_j < s_k.
Examples
Input
5
2 4 5 4 10
40 30 20 10 40
Output
90
Input
3
100 101 100
2 4 5
Output
-1
Input
10
1 2 3 4 5 6 7 8 9 10
10 13 11 14 15 12 13 13 18 13
Output
33
Note
In the first example you can, for example, choose displays 1, 4 and 5, because s_1 < s_4 < s_5 (2 < 4 < 10), and the rent cost is 40 + 10 + 40 = 90.
In the second example you can't select a valid triple of indices, so the answer is -1.
The input will be give
Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.