Datasets:

walk-alone
/

codeforces-problems

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 9.24k rows

problem_statement stringlengths 147 8.53k	input stringlengths 1 771	output stringlengths 1 592 ⌀	time_limit stringclasses 32 values	memory_limit stringclasses 21 values	tags stringlengths 6 168
E. Olympic Gamestime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThis problem was deleted from the contest, because it was used previously at another competition.InputOutputExamplesInput1 11 2 100Output6	Input1 11 2 100	Output6	2 seconds	256 megabytes	['math', '*2500']
D. Roman and Numberstime limit per test4 secondsmemory limit per test512 megabytesinputstandard inputoutputstandard outputRoman is a young mathematician, very famous in Uzhland. Unfortunately, Sereja doesn't think so. To make Sereja change his mind, Roman is ready to solve any mathematical problem. After some thought, Sereja asked Roma to find, how many numbers are close to number n, modulo m.Number x is considered close to number n modulo m, if: it can be obtained by rearranging the digits of number n, it doesn't have any leading zeroes, the remainder after dividing number x by m equals 0. Roman is a good mathematician, but the number of such numbers is too huge for him. So he asks you to help him. InputThe first line contains two integers: n (1 ≤ n < 1018) and m (1 ≤ m ≤ 100).OutputIn a single line print a single integer — the number of numbers close to number n modulo m.ExamplesInput104 2Output3Input223 4Output1Input7067678 8Output47NoteIn the first sample the required numbers are: 104, 140, 410.In the second sample the required number is 232.	Input104 2	Output3	4 seconds	512 megabytes	['bitmasks', 'brute force', 'combinatorics', 'dp', 'number theory', '*2000']
C. Teamtime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputNow it's time of Olympiads. Vanya and Egor decided to make his own team to take part in a programming Olympiad. They've been best friends ever since primary school and hopefully, that can somehow help them in teamwork.For each team Olympiad, Vanya takes his play cards with numbers. He takes only the cards containing numbers 1 and 0. The boys are very superstitious. They think that they can do well at the Olympiad if they begin with laying all the cards in a row so that: there wouldn't be a pair of any side-adjacent cards with zeroes in a row; there wouldn't be a group of three consecutive cards containing numbers one. Today Vanya brought n cards with zeroes and m cards with numbers one. The number of cards was so much that the friends do not know how to put all those cards in the described way. Help them find the required arrangement of the cards or else tell the guys that it is impossible to arrange cards in such a way.InputThe first line contains two integers: n (1 ≤ n ≤ 106) — the number of cards containing number 0; m (1 ≤ m ≤ 106) — the number of cards containing number 1.OutputIn a single line print the required sequence of zeroes and ones without any spaces. If such sequence is impossible to obtain, print -1.ExamplesInput1 2Output101Input4 8Output110110110101Input4 10Output11011011011011Input1 5Output-1	Input1 2	Output101	1 second	256 megabytes	['constructive algorithms', 'greedy', 'implementation', '*1400']
B. Sereja and Conteststime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputSereja is a coder and he likes to take part in Codesorfes rounds. However, Uzhland doesn't have good internet connection, so Sereja sometimes skips rounds.Codesorfes has rounds of two types: Div1 (for advanced coders) and Div2 (for beginner coders). Two rounds, Div1 and Div2, can go simultaneously, (Div1 round cannot be held without Div2) in all other cases the rounds don't overlap in time. Each round has a unique identifier — a positive integer. The rounds are sequentially (without gaps) numbered with identifiers by the starting time of the round. The identifiers of rounds that are run simultaneously are different by one, also the identifier of the Div1 round is always greater.Sereja is a beginner coder, so he can take part only in rounds of Div2 type. At the moment he is taking part in a Div2 round, its identifier equals to x. Sereja remembers very well that he has taken part in exactly k rounds before this round. Also, he remembers all identifiers of the rounds he has taken part in and all identifiers of the rounds that went simultaneously with them. Sereja doesn't remember anything about the rounds he missed.Sereja is wondering: what minimum and what maximum number of Div2 rounds could he have missed? Help him find these two numbers.InputThe first line contains two integers: x (1 ≤ x ≤ 4000) — the round Sereja is taking part in today, and k (0 ≤ k < 4000) — the number of rounds he took part in.Next k lines contain the descriptions of the rounds that Sereja took part in before. If Sereja took part in one of two simultaneous rounds, the corresponding line looks like: "1 num2 num1" (where num2 is the identifier of this Div2 round, num1 is the identifier of the Div1 round). It is guaranteed that num1 - num2 = 1. If Sereja took part in a usual Div2 round, then the corresponding line looks like: "2 num" (where num is the identifier of this Div2 round). It is guaranteed that the identifiers of all given rounds are less than x.OutputPrint in a single line two integers — the minimum and the maximum number of rounds that Sereja could have missed.ExamplesInput3 22 12 2Output0 0Input9 31 2 32 81 4 5Output2 3Input10 0Output5 9NoteIn the second sample we have unused identifiers of rounds 1, 6, 7. The minimum number of rounds Sereja could have missed equals to 2. In this case, the round with the identifier 1 will be a usual Div2 round and the round with identifier 6 will be synchronous with the Div1 round. The maximum number of rounds equals 3. In this case all unused identifiers belong to usual Div2 rounds.	Input3 22 12 2	Output0 0	1 second	256 megabytes	['greedy', 'implementation', 'math', '*1200']
A. Vanya and Cardstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputVanya loves playing. He even has a special set of cards to play with. Each card has a single integer. The number on the card can be positive, negative and can even be equal to zero. The only limit is, the number on each card doesn't exceed x in the absolute value.Natasha doesn't like when Vanya spends a long time playing, so she hid all of his cards. Vanya became sad and started looking for the cards but he only found n of them. Vanya loves the balance, so he wants the sum of all numbers on found cards equal to zero. On the other hand, he got very tired of looking for cards. Help the boy and say what is the minimum number of cards does he need to find to make the sum equal to zero?You can assume that initially Vanya had infinitely many cards with each integer number from - x to x. InputThe first line contains two integers: n (1 ≤ n ≤ 1000) — the number of found cards and x (1 ≤ x ≤ 1000) — the maximum absolute value of the number on a card. The second line contains n space-separated integers — the numbers on found cards. It is guaranteed that the numbers do not exceed x in their absolute value.OutputPrint a single number — the answer to the problem.ExamplesInput3 2-1 1 2Output1Input2 3-2 -2Output2NoteIn the first sample, Vanya needs to find a single card with number -2.In the second sample, Vanya needs to find two cards with number 2. He can't find a single card with the required number as the numbers on the lost cards do not exceed 3 in their absolute value.	Input3 2-1 1 2	Output1	1 second	256 megabytes	['implementation', 'math', '*800']
E. Inna and Binary Logictime limit per test3 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputInna is fed up with jokes about female logic. So she started using binary logic instead.Inna has an array of n elements a1[1], a1[2], ..., a1[n]. Girl likes to train in her binary logic, so she does an exercise consisting of n stages: on the first stage Inna writes out all numbers from array a1, on the i-th (i ≥ 2) stage girl writes all elements of array ai, which consists of n - i + 1 integers; the k-th integer of array ai is defined as follows: ai[k] = ai - 1[k] AND ai - 1[k + 1]. Here AND is bit-wise binary logical operation.Dima decided to check Inna's skill. He asks Inna to change array, perform the exercise and say the sum of all elements she wrote out during the current exercise.Help Inna to answer the questions!InputThe first line contains two integers n and m (1 ≤ n, m ≤ 105) — size of array a1 and number of Dima's questions. Next line contains n integers a1[1], a1[2], ..., a1[n] (0 ≤ ai ≤ 105) — initial array elements.Each of next m lines contains two integers — Dima's question description. Each question consists of two integers pi, vi (1 ≤ pi ≤ n; 0 ≤ vi ≤ 105). For this question Inna should make a1[pi] equals vi, and then perform the exercise. Please, note that changes are saved from question to question.OutputFor each question print Inna's answer on a single line.ExamplesInput3 41 1 11 12 23 21 2Output64712	Input3 41 1 11 12 23 21 2	Output64712	3 seconds	256 megabytes	['binary search', 'bitmasks', 'data structures', '*2100']
D. Dima and Bacteriatime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputDima took up the biology of bacteria, as a result of his experiments, he invented k types of bacteria. Overall, there are n bacteria at his laboratory right now, and the number of bacteria of type i equals ci. For convenience, we will assume that all the bacteria are numbered from 1 to n. The bacteria of type ci are numbered from to .With the help of special equipment Dima can move energy from some bacteria into some other one. Of course, the use of such equipment is not free. Dima knows m ways to move energy from some bacteria to another one. The way with number i can be described with integers ui, vi and xi mean that this way allows moving energy from bacteria with number ui to bacteria with number vi or vice versa for xi dollars.Dima's Chef (Inna) calls the type-distribution correct if there is a way (may be non-direct) to move energy from any bacteria of the particular type to any other bacteria of the same type (between any two bacteria of the same type) for zero cost.As for correct type-distribution the cost of moving the energy depends only on the types of bacteria help Inna to determine is the type-distribution correct? If it is, print the matrix d with size k × k. Cell d[i][j] of this matrix must be equal to the minimal possible cost of energy-moving from bacteria with type i to bacteria with type j.InputThe first line contains three integers n, m, k (1 ≤ n ≤ 105; 0 ≤ m ≤ 105; 1 ≤ k ≤ 500). The next line contains k integers c1, c2, ..., ck (1 ≤ ci ≤ n). Each of the next m lines contains three integers ui, vi, xi (1 ≤ ui, vi ≤ 105; 0 ≤ xi ≤ 104). It is guaranteed that .OutputIf Dima's type-distribution is correct, print string «Yes», and then k lines: in the i-th line print integers d[i][1], d[i][2], ..., d[i][k] (d[i][i] = 0). If there is no way to move energy from bacteria i to bacteria j appropriate d[i][j] must equal to -1. If the type-distribution isn't correct print «No».ExamplesInput4 4 21 32 3 03 4 02 4 12 1 2OutputYes0 22 0Input3 1 22 11 2 0OutputYes0 -1-1 0Input3 2 22 11 2 02 3 1OutputYes0 11 0Input3 0 21 2OutputNo	Input4 4 21 32 3 03 4 02 4 12 1 2	OutputYes0 22 0	2 seconds	256 megabytes	['dsu', 'graphs', 'shortest paths', '*2000']
C. Inna and Huge Candy Matrixtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputInna and Dima decided to surprise Sereja. They brought a really huge candy matrix, it's big even for Sereja! Let's number the rows of the giant matrix from 1 to n from top to bottom and the columns — from 1 to m, from left to right. We'll represent the cell on the intersection of the i-th row and j-th column as (i, j). Just as is expected, some cells of the giant candy matrix contain candies. Overall the matrix has p candies: the k-th candy is at cell (xk, yk).The time moved closer to dinner and Inna was already going to eat p of her favourite sweets from the matrix, when suddenly Sereja (for the reason he didn't share with anyone) rotated the matrix x times clockwise by 90 degrees. Then he performed the horizontal rotate of the matrix y times. And then he rotated the matrix z times counterclockwise by 90 degrees. The figure below shows how the rotates of the matrix looks like. Inna got really upset, but Duma suddenly understood two things: the candies didn't get damaged and he remembered which cells contained Inna's favourite sweets before Sereja's strange actions. Help guys to find the new coordinates in the candy matrix after the transformation Sereja made!InputThe first line of the input contains fix integers n, m, x, y, z, p (1 ≤ n, m ≤ 109; 0 ≤ x, y, z ≤ 109; 1 ≤ p ≤ 105).Each of the following p lines contains two integers xk, yk (1 ≤ xk ≤ n; 1 ≤ yk ≤ m) — the initial coordinates of the k-th candy. Two candies can lie on the same cell.OutputFor each of the p candies, print on a single line its space-separated new coordinates.ExamplesInput3 3 3 1 1 91 11 21 32 12 22 33 13 23 3Output1 31 21 12 32 22 13 33 23 1NoteJust for clarity. Horizontal rotating is like a mirroring of the matrix. For matrix:QWER REWQ ASDF -> FDSAZXCV VCXZ	Input3 3 3 1 1 91 11 21 32 12 22 33 13 23 3	Output1 31 21 12 32 22 13 33 23 1	2 seconds	256 megabytes	['implementation', 'math', '*1500']
B. Inna and New Matrix of Candiestime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputInna likes sweets and a game called the "Candy Matrix". Today, she came up with the new game "Candy Matrix 2: Reload".The field for the new game is a rectangle table of size n × m. Each line of the table contains one cell with a dwarf figurine, one cell with a candy, the other cells of the line are empty. The game lasts for several moves. During each move the player should choose all lines of the matrix where dwarf is not on the cell with candy and shout "Let's go!". After that, all the dwarves from the chosen lines start to simultaneously move to the right. During each second, each dwarf goes to the adjacent cell that is located to the right of its current cell. The movement continues until one of the following events occurs: some dwarf in one of the chosen lines is located in the rightmost cell of his row; some dwarf in the chosen lines is located in the cell with the candy. The point of the game is to transport all the dwarves to the candy cells.Inna is fabulous, as she came up with such an interesting game. But what about you? Your task is to play this game optimally well. Specifically, you should say by the given game field what minimum number of moves the player needs to reach the goal of the game.InputThe first line of the input contains two integers n and m (1 ≤ n ≤ 1000; 2 ≤ m ≤ 1000). Next n lines each contain m characters — the game field for the "Candy Martix 2: Reload". Character "" represents an empty cell of the field, character "G" represents a dwarf and character "S" represents a candy. The matrix doesn't contain other characters. It is guaranteed that each line contains exactly one character "G" and one character "S".OutputIn a single line print a single integer — either the minimum number of moves needed to achieve the aim of the game, or -1, if the aim cannot be achieved on the given game field.ExamplesInput3 4GSGSGSOutput2Input1 3SGOutput-1	Input3 4GSG*SG*S	Output2	1 second	256 megabytes	['brute force', 'implementation', 'schedules', '*1200']
A. Inna and Choose Optionstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputThere always is something to choose from! And now, instead of "Noughts and Crosses", Inna choose a very unusual upgrade of this game. The rules of the game are given below:There is one person playing the game. Before the beginning of the game he puts 12 cards in a row on the table. Each card contains a character: "X" or "O". Then the player chooses two positive integers a and b (a·b = 12), after that he makes a table of size a × b from the cards he put on the table as follows: the first b cards form the first row of the table, the second b cards form the second row of the table and so on, the last b cards form the last (number a) row of the table. The player wins if some column of the table contain characters "X" on all cards. Otherwise, the player loses.Inna has already put 12 cards on the table in a row. But unfortunately, she doesn't know what numbers a and b to choose. Help her win the game: print to her all the possible ways of numbers a, b that she can choose and win.InputThe first line of the input contains integer t (1 ≤ t ≤ 100). This value shows the number of sets of test data in the input. Next follows the description of each of the t tests on a separate line.The description of each test is a string consisting of 12 characters, each character is either "X", or "O". The i-th character of the string shows the character that is written on the i-th card from the start.OutputFor each test, print the answer to the test on a single line. The first number in the line must represent the number of distinct ways to choose the pair a, b. Next, print on this line the pairs in the format axb. Print the pairs in the order of increasing first parameter (a). Separate the pairs in the line by whitespaces.ExamplesInput4OXXXOXOOXOOXOXOXOXOXOXOXXXXXXXXXXXXXOOOOOOOOOOOOOutput3 1x12 2x6 4x34 1x12 2x6 3x4 6x26 1x12 2x6 3x4 4x3 6x2 12x10	Input4OXXXOXOOXOOXOXOXOXOXOXOXXXXXXXXXXXXXOOOOOOOOOOOO	Output3 1x12 2x6 4x34 1x12 2x6 3x4 6x26 1x12 2x6 3x4 4x3 6x2 12x10	1 second	256 megabytes	['implementation', '*1000']
A. Pagestime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputUser ainta is making a web site. This time he is going to make a navigation of the pages. In his site, there are n pages numbered by integers from 1 to n. Assume that somebody is on the p-th page now. The navigation will look like this: << p - k p - k + 1 ... p - 1 (p) p + 1 ... p + k - 1 p + k >> When someone clicks the button "<<" he is redirected to page 1, and when someone clicks the button ">>" he is redirected to page n. Of course if someone clicks on a number, he is redirected to the corresponding page.There are some conditions in the navigation: If page 1 is in the navigation, the button "<<" must not be printed. If page n is in the navigation, the button ">>" must not be printed. If the page number is smaller than 1 or greater than n, it must not be printed. You can see some examples of the navigations. Make a program that prints the navigation.InputThe first and the only line contains three integers n, p, k (3 ≤ n ≤ 100; 1 ≤ p ≤ n; 1 ≤ k ≤ n)OutputPrint the proper navigation. Follow the format of the output from the test samples.ExamplesInput17 5 2Output<< 3 4 (5) 6 7 >> Input6 5 2Output<< 3 4 (5) 6 Input6 1 2Output(1) 2 3 >> Input6 2 2Output1 (2) 3 4 >>Input9 6 3Output<< 3 4 5 (6) 7 8 9Input10 6 3Output<< 3 4 5 (6) 7 8 9 >>Input8 5 4Output1 2 3 4 (5) 6 7 8	Input17 5 2	Output<< 3 4 (5) 6 7 >>	1 second	256 megabytes	['implementation']
D. Instant Messangertime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputUser ainta decided to make a new instant messenger called "aintalk". With aintalk, each user can chat with other people. User ainta made the prototype of some functions to implement this thing. login(u): User u logins into aintalk and becomes online. logout(u): User u logouts and becomes offline. add_friend(u, v): User u and user v become friends. It means, u and v can talk with each other. The friendship is bidirectional. del_friend(u, v): Unfriend user u and user v. It means, u and v cannot talk with each other from then. count_online_friends(u): The function returns the number of friends of user u who are online at the moment. Because the messenger is being tested by some users numbered from 1 to n, there is no register method. This means, at the beginning, some users may be online, and some users may have friends.User ainta is going to make these functions, but before making the messenger public, he wants to know whether he is correct. Help ainta verify his code.InputThe first line contains three space-separated integers n, m and q (1 ≤ n ≤ 50000; 1 ≤ m ≤ 150000; 1 ≤ q ≤ 250000) — the number of users, the number of pairs of friends, and the number of queries.The second line contains an integer o (1 ≤ o ≤ n) — the number of online users at the beginning. The third line contains o space-separated integers x1, x2, ..., xo (1 ≤ xi ≤ n) — the ids of the online users. It is guaranteed that these values are distinct.Each of the next m lines contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — the ids of two users who are friends at the beginning. It is guaranteed there are no multiple friendship given in the input. Note that the friendship is bidirectional.Next q lines describe the q queries in the format: "O u" (1 ≤ u ≤ n) : Call online(u). It is guaranteed that user u was offline just before the function call. "F u" (1 ≤ u ≤ n) : Call offline(u). It is guaranteed that user u was online just before the function call. "A u v" (1 ≤ u, v ≤ n; u ≠ v) : Call add_friend(u, v). It is guaranteed that these two users weren't friends just before the function call. "D u v" (1 ≤ u, v ≤ n; u ≠ v) : Call del_friend(u, v). It is guaranteed that these two users were friends just before the function call. "C u" (1 ≤ u ≤ n) : Call count_online_friends(u) and print the result in a single line. OutputFor each count_online_friends(u) query, print the required answer in a single line. ExamplesInput5 2 9141 33 4C 3A 2 5O 1D 1 3A 1 2A 4 2C 2F 4C 2Output121	Input5 2 9141 33 4C 3A 2 5O 1D 1 3A 1 2A 4 2C 2F 4C 2	Output121	2 seconds	256 megabytes	['data structures']
C. Tree and Arraytime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputUser ainta likes trees. This time he is going to make an undirected tree with n vertices numbered by integers from 1 to n. The tree is weighted, so each edge of the tree will have some integer weight.Also he has an array t: t[1], t[2], ..., t[n]. At first all the elements of the array are initialized to 0. Then for each edge connecting vertices u and v (u < v) of the tree with weight c, ainta adds value c to the elements t[u], t[u + 1], ..., t[v - 1], t[v] of array t.Let's assume that d(u, v) is the total weight of edges on the shortest path between vertex u and vertex v. User ainta calls a pair of integers x, y (1 ≤ x < y ≤ n) good if and only if d(x, y) = t[x] + t[x + 1] + ... + t[y - 1] + t[y].User ainta wants to make at least good pairs, but he couldn't make a proper tree. Help ainta to find such a tree.InputThe first line contains a single integer n (5 ≤ n ≤ 105).OutputPrint n - 1 lines containing the description of the edges. The i-th line should contain three space-separated integers ui, vi, ci (1 ≤ ui < vi ≤ n; 1 ≤ ci ≤ 105) — two vertices connected by the edge, and the weight of the edge.Next print lines containing the good pairs. The k-th line should contain two space-separated integers xk and yk (1 ≤ xk < yk ≤ n). Of course, xk, yk must be a good pair. All pairs should be distinct — that is, for all j, k , xj ≠ xk or yj ≠ yk must be satisfied.If there are many correct solutions, print any of them.ExamplesInput7Output1 4 11 2 22 3 53 5 32 6 26 7 34 55 65 7Note⌊x⌋ is the largest integer not greater than x.You can find the definition of a tree by the following link: http://en.wikipedia.org/wiki/Tree_(graph_theory)You can also find the definition of the shortest path by the following link: http://en.wikipedia.org/wiki/Shortest_path_problemThe tree and the array t in the sample output look like this:	Input7	Output1 4 11 2 22 3 53 5 32 6 26 7 34 55 65 7	1 second	256 megabytes	['constructive algorithms']
B. Painting The Walltime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputUser ainta decided to paint a wall. The wall consists of n2 tiles, that are arranged in an n × n table. Some tiles are painted, and the others are not. As he wants to paint it beautifully, he will follow the rules below. Firstly user ainta looks at the wall. If there is at least one painted cell on each row and at least one painted cell on each column, he stops coloring. Otherwise, he goes to step 2. User ainta choose any tile on the wall with uniform probability. If the tile he has chosen is not painted, he paints the tile. Otherwise, he ignores it. Then he takes a rest for one minute even if he doesn't paint the tile. And then ainta goes to step 1. However ainta is worried if it would take too much time to finish this work. So he wants to calculate the expected time needed to paint the wall by the method above. Help him find the expected time. You can assume that choosing and painting any tile consumes no time at all. InputThe first line contains two integers n and m (1 ≤ n ≤ 2·103; 0 ≤ m ≤ min(n2, 2·104)) — the size of the wall and the number of painted cells.Next m lines goes, each contains two integers ri and ci (1 ≤ ri, ci ≤ n) — the position of the painted cell. It is guaranteed that the positions are all distinct. Consider the rows of the table are numbered from 1 to n. Consider the columns of the table are numbered from 1 to n.OutputIn a single line print the expected time to paint the wall in minutes. Your answer will be considered correct if it has at most 10 - 4 absolute or relative error.ExamplesInput5 22 34 1Output11.7669491886Input2 21 11 2Output2.0000000000Input1 11 1Output0.0000000000	Input5 22 34 1	Output11.7669491886	1 second	256 megabytes	['dp', 'probabilities']
A. Cardstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputUser ainta loves to play with cards. He has a cards containing letter "o" and b cards containing letter "x". He arranges the cards in a row, and calculates the score of the deck by the formula below. At first, the score is 0. For each block of contiguous "o"s with length x the score increases by x2. For each block of contiguous "x"s with length y the score decreases by y2. For example, if a = 6, b = 3 and ainta have arranged the cards in the order, that is described by string "ooxoooxxo", the score of the deck equals 22 - 12 + 32 - 22 + 12 = 9. That is because the deck has 5 blocks in total: "oo", "x", "ooo", "xx", "o".User ainta likes big numbers, so he wants to maximize the score with the given cards. Help ainta make the score as big as possible. Note, that he has to arrange all his cards.InputThe first line contains two space-separated integers a and b (0 ≤ a, b ≤ 105; a + b ≥ 1) — the number of "o" cards and the number of "x" cards.OutputIn the first line print a single integer v — the maximum score that ainta can obtain.In the second line print a + b characters describing the deck. If the k-th card of the deck contains "o", the k-th character must be "o". If the k-th card of the deck contains "x", the k-th character must be "x". The number of "o" characters must be equal to a, and the number of "x " characters must be equal to b. If there are many ways to maximize v, print any.Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.ExamplesInput2 3Output-1xoxoxInput4 0Output16ooooInput0 4Output-16xxxx	Input2 3	Output-1xoxox	1 second	256 megabytes	['constructive algorithms', 'implementation']
B. On Corruption and Numberstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputAlexey, a merry Berland entrant, got sick of the gray reality and he zealously wants to go to university. There are a lot of universities nowadays, so Alexey is getting lost in the diversity — he has not yet decided what profession he wants to get. At school, he had bad grades in all subjects, and it's only thanks to wealthy parents that he was able to obtain the graduation certificate.The situation is complicated by the fact that each high education institution has the determined amount of voluntary donations, paid by the new students for admission — ni berubleys. He cannot pay more than ni, because then the difference between the paid amount and ni can be regarded as a bribe!Each rector is wearing the distinctive uniform of his university. Therefore, the uniform's pockets cannot contain coins of denomination more than ri. The rector also does not carry coins of denomination less than li in his pocket — because if everyone pays him with so small coins, they gather a lot of weight and the pocket tears. Therefore, a donation can be paid only by coins of denomination x berubleys, where li ≤ x ≤ ri (Berland uses coins of any positive integer denomination). Alexey can use the coins of different denominations and he can use the coins of the same denomination any number of times. When Alexey was first confronted with such orders, he was puzzled because it turned out that not all universities can accept him! Alexey is very afraid of going into the army (even though he had long wanted to get the green uniform, but his dad says that the army bullies will beat his son and he cannot pay to ensure the boy's safety). So, Alexey wants to know for sure which universities he can enter so that he could quickly choose his alma mater.Thanks to the parents, Alexey is not limited in money and we can assume that he has an unlimited number of coins of each type.In other words, you are given t requests, each of them contains numbers ni, li, ri. For each query you need to answer, whether it is possible to gather the sum of exactly ni berubleys using only coins with an integer denomination from li to ri berubleys. You can use coins of different denominations. Coins of each denomination can be used any number of times.InputThe first line contains the number of universities t, (1 ≤ t ≤ 1000) Each of the next t lines contain three space-separated integers: ni, li, ri (1 ≤ ni, li, ri ≤ 109; li ≤ ri).OutputFor each query print on a single line: either "Yes", if Alexey can enter the university, or "No" otherwise.ExamplesInput25 2 36 4 5OutputYesNoNoteYou can pay the donation to the first university with two coins: one of denomination 2 and one of denomination 3 berubleys. The donation to the second university cannot be paid.	Input25 2 36 4 5	OutputYesNo	1 second	256 megabytes	['constructive algorithms', 'implementation', 'math']
A. On Segment's Own Pointstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputOur old friend Alexey has finally entered the University of City N — the Berland capital. Alexey expected his father to get him a place to live in but his father said it was high time for Alexey to practice some financial independence. So, Alexey is living in a dorm. The dorm has exactly one straight dryer — a 100 centimeter long rope to hang clothes on. The dryer has got a coordinate system installed: the leftmost end of the dryer has coordinate 0, and the opposite end has coordinate 100. Overall, the university has n students. Dean's office allows i-th student to use the segment (li, ri) of the dryer. However, the dean's office actions are contradictory and now one part of the dryer can belong to multiple students!Alexey don't like when someone touch his clothes. That's why he want make it impossible to someone clothes touch his ones. So Alexey wonders: what is the total length of the parts of the dryer that he may use in a such way that clothes of the others (n - 1) students aren't drying there. Help him! Note that Alexey, as the most respected student, has number 1.InputThe first line contains a positive integer n (1 ≤ n ≤ 100). The (i + 1)-th line contains integers li and ri (0 ≤ li < ri ≤ 100) — the endpoints of the corresponding segment for the i-th student.OutputOn a single line print a single number k, equal to the sum of lengths of the parts of the dryer which are inside Alexey's segment and are outside all other segments.ExamplesInput30 52 81 6Output1Input30 101 57 15Output3NoteNote that it's not important are clothes drying on the touching segments (e.g. (0, 1) and (1, 2)) considered to be touching or not because you need to find the length of segments.In the first test sample Alexey may use the only segment (0, 1). In such case his clothes will not touch clothes on the segments (1, 6) and (2, 8). The length of segment (0, 1) is 1.In the second test sample Alexey may dry his clothes on segments (0, 1) and (5, 7). Overall length of these segments is 3.	Input30 52 81 6	Output1	1 second	256 megabytes	['implementation']
E. On Iteration of One Well-Known Functiontime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputOf course, many of you can calculate φ(n) — the number of positive integers that are less than or equal to n, that are coprime with n. But what if we need to calculate φ(φ(...φ(n))), where function φ is taken k times and n is given in the canonical decomposition into prime factors? You are given n and k, calculate the value of φ(φ(...φ(n))). Print the result in the canonical decomposition into prime factors.InputThe first line contains integer m (1 ≤ m ≤ 105) — the number of distinct prime divisors in the canonical representaion of n.Each of the next m lines contains a pair of space-separated integers pi, ai (2 ≤ pi ≤ 106; 1 ≤ ai ≤ 1017) — another prime divisor of number n and its power in the canonical representation. The sum of all ai doesn't exceed 1017. Prime divisors in the input follow in the strictly increasing order.The last line contains integer k (1 ≤ k ≤ 1018).OutputIn the first line, print integer w — the number of distinct prime divisors of number φ(φ(...φ(n))), where function φ is taken k times.Each of the next w lines must contain two space-separated integers qi, bi (bi ≥ 1) — another prime divisor and its power in the canonical representaion of the result. Numbers qi must go in the strictly increasing order.ExamplesInput17 11Output22 13 1Input17 12Output12 1Input12 10000000000000000010000000000000000Output12 90000000000000000NoteYou can read about canonical representation of a positive integer here: http://en.wikipedia.org/wiki/Fundamental_theorem_of_arithmetic.You can read about function φ(n) here: http://en.wikipedia.org/wiki/Euler's_totient_function.	Input17 11	Output22 13 1	1 second	256 megabytes	['math']
D. On Sum of Number of Inversions in Permutationstime limit per test3 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou are given a permutation p. Calculate the total number of inversions in all permutations that lexicographically do not exceed the given one.As this number can be very large, print it modulo 1000000007 (109 + 7).InputThe first line contains a single integer n (1 ≤ n ≤ 106) — the length of the permutation. The second line contains n distinct integers p1, p2, ..., pn (1 ≤ pi ≤ n).OutputPrint a single number — the answer to the problem modulo 1000000007 (109 + 7).ExamplesInput22 1Output1Input32 1 3Output2NotePermutation p of length n is the sequence that consists of n distinct integers, each of them is from 1 to n.An inversion of permutation p1, p2, ..., pn is a pair of indexes (i, j), such that i < j and pi > pj.Permutation a do not exceed permutation b lexicographically, if either a = b or there exists such number i, for which the following logical condition fulfills: AND (ai < bi).	Input22 1	Output1	3 seconds	256 megabytes	['combinatorics', 'math']
C. On Changing Treetime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou are given a rooted tree consisting of n vertices numbered from 1 to n. The root of the tree is a vertex number 1.Initially all vertices contain number 0. Then come q queries, each query has one of the two types: The format of the query: 1 v x k. In response to the query, you need to add to the number at vertex v number x; to the numbers at the descendants of vertex v at distance 1, add x - k; and so on, to the numbers written in the descendants of vertex v at distance i, you need to add x - (i·k). The distance between two vertices is the number of edges in the shortest path between these vertices. The format of the query: 2 v. In reply to the query you should print the number written in vertex v modulo 1000000007 (109 + 7). Process the queries given in the input.InputThe first line contains integer n (1 ≤ n ≤ 3·105) — the number of vertices in the tree. The second line contains n - 1 integers p2, p3, ... pn (1 ≤ pi < i), where pi is the number of the vertex that is the parent of vertex i in the tree.The third line contains integer q (1 ≤ q ≤ 3·105) — the number of queries. Next q lines contain the queries, one per line. The first number in the line is type. It represents the type of the query. If type = 1, then next follow space-separated integers v, x, k (1 ≤ v ≤ n; 0 ≤ x < 109 + 7; 0 ≤ k < 109 + 7). If type = 2, then next follows integer v (1 ≤ v ≤ n) — the vertex where you need to find the value of the number.OutputFor each query of the second type print on a single line the number written in the vertex from the query. Print the number modulo 1000000007 (109 + 7).ExamplesInput31 131 1 2 12 12 2Output21NoteYou can read about a rooted tree here: http://en.wikipedia.org/wiki/Tree_(graph_theory).	Input31 131 1 2 12 12 2	Output21	2 seconds	256 megabytes	['data structures', 'graphs', 'trees']
B. On Sum of Fractionstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLet's assume that v(n) is the largest prime number, that does not exceed n; u(n) is the smallest prime number strictly greater than n. Find .InputThe first line contains integer t (1 ≤ t ≤ 500) — the number of testscases. Each of the following t lines of the input contains integer n (2 ≤ n ≤ 109).OutputPrint t lines: the i-th of them must contain the answer to the i-th test as an irreducible fraction "p/q", where p, q are integers, q > 0.ExamplesInput223Output1/67/30	Input223	Output1/67/30	2 seconds	256 megabytes	['math', 'number theory']
A. On Number of Decompositions into Multiplierstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou are given an integer m as a product of integers a1, a2, ... an . Your task is to find the number of distinct decompositions of number m into the product of n ordered positive integers.Decomposition into n products, given in the input, must also be considered in the answer. As the answer can be very large, print it modulo 1000000007 (109 + 7).InputThe first line contains positive integer n (1 ≤ n ≤ 500). The second line contains space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).OutputIn a single line print a single number k — the number of distinct decompositions of number m into n ordered multipliers modulo 1000000007 (109 + 7).ExamplesInput115Output1Input31 1 2Output3Input25 7Output4NoteIn the second sample, the get a decomposition of number 2, you need any one number out of three to equal 2, and the rest to equal 1.In the third sample, the possible ways of decomposing into ordered multipliers are [7,5], [5,7], [1,35], [35,1].A decomposition of positive integer m into n ordered multipliers is a cortege of positive integers b = {b1, b2, ... bn} such that . Two decompositions b and c are considered different, if there exists index i such that bi ≠ ci.	Input115	Output1	1 second	256 megabytes	['combinatorics', 'math', 'number theory']
E. Lightbulb for Ministertime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe Minister for education is coming! Naturally, nobody wants to perform poorly in front of such a honored guest. However, two hours before the arrival it turned out that one of the classes has a malfunctioning lightbulb — for some reason it doesn't get enough energy. The solution was found quickly: all we've got to do is to change the location of the lightbulb so that it got the maximum amount of energy.Everybody knows that the power of the lightbulb equals , where C is some constant value and ri is the Euclidean distance from the bulb to the i-th generator. Consequently, our task is to minimize . Of course, we know the positions of all generators.The bulb should be on the ceiling of the class. The ceiling of the class is in the form of a strictly convex m-gon (the class itself has the form of a right prism with a strictly convex m-gon at the bottom). Help to find the optimum location for the bulb. Assume that all generators are in the plane of the class ceiling. Consider that the plane of the class ceiling has some Cartesian coordinate system introduced.InputThe first line contains integer n (2 ≤ n ≤ 105) — the number of generators. Each of the next n lines contains a pair of integers xi, yi, representing the coordinates of the i-th generator in the plane of the class ceiling. It's guaranteed that no two generators have the same location.The next line contains integer m (3 ≤ m ≤ 105) — the number of vertexes in the convex polygon that describes the ceiling of the class. Each of the following m lines contains a pair of integers pi, qi, representing the coordinates of the i-th point of the polygon in the clockwise order. It's guaranteed that the polygon is strictly convex.The absolute value of all the coordinates don't exceed 106.OutputPrint a single real number — the minimum value of the sum of squares of distances from the generators to the point of the lightbulb's optimal position. The answer will be considered valid if its absolute or relative error doesn't exceed 10 - 4.ExamplesInput43 23 45 45 243 34 45 34 2Output8.00000000NoteWe'll define a strictly convex polygon as a convex polygon with the following property: no three vertices of the polygon lie on the same line.	Input43 23 45 45 243 34 45 34 2	Output8.00000000	1 second	256 megabytes	['geometry']
D. Physical Education and Bunstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe Physical education teacher at SESC is a sort of mathematician too. His most favorite topic in mathematics is progressions. That is why the teacher wants the students lined up in non-decreasing height form an arithmetic progression.To achieve the goal, the gym teacher ordered a lot of magical buns from the dining room. The magic buns come in two types: when a student eats one magic bun of the first type, his height increases by one, when the student eats one magical bun of the second type, his height decreases by one. The physical education teacher, as expected, cares about the health of his students, so he does not want them to eat a lot of buns. More precisely, he wants the maximum number of buns eaten by some student to be minimum.Help the teacher, get the maximum number of buns that some pupils will have to eat to achieve the goal of the teacher. Also, get one of the possible ways for achieving the objective, namely, the height of the lowest student in the end and the step of the resulting progression.InputThe single line contains integer n (2 ≤ n ≤ 103) — the number of students. The second line contains n space-separated integers — the heights of all students. The height of one student is an integer which absolute value doesn't exceed 104.OutputIn the first line print the maximum number of buns eaten by some student to achieve the teacher's aim. In the second line, print two space-separated integers — the height of the lowest student in the end and the step of the progression. Please, pay attention that the step should be non-negative.If there are multiple possible answers, you can print any of them.ExamplesInput5-3 -4 -2 -3 3Output2-3 1Input52 -3 -1 -4 3Output1-4 2NoteLets look at the first sample. We can proceed in the following manner: don't feed the 1-st student, his height will stay equal to -3; give two buns of the first type to the 2-nd student, his height become equal to -2; give two buns of the first type to the 3-rd student, his height become equal to 0; give two buns of the first type to the 4-th student, his height become equal to -1; give two buns of the second type to the 5-th student, his height become equal to 1. To sum it up, when the students line up in non-decreasing height it will be an arithmetic progression: -3, -2, -1, 0, 1. The height of the lowest student is equal to -3, the step of the progression is equal to 1. The maximum number of buns eaten by one student is equal to 2.	Input5-3 -4 -2 -3 3	Output2-3 1	2 seconds	256 megabytes	['brute force', 'implementation', 'math']
C. Dominoestime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputDuring the break, we decided to relax and play dominoes. Our box with Domino was empty, so we decided to borrow the teacher's dominoes.The teacher responded instantly at our request. He put nm dominoes on the table as an n × 2m rectangle so that each of the n rows contained m dominoes arranged horizontally. Each half of each domino contained number (0 or 1).We were taken aback, and the teacher smiled and said: "Consider some arrangement of dominoes in an n × 2m matrix. Let's count for each column of the matrix the sum of numbers in this column. Then among all such sums find the maximum one. Can you rearrange the dominoes in the matrix in such a way that the maximum sum will be minimum possible? Note that it is prohibited to change the orientation of the dominoes, they all need to stay horizontal, nevertheless dominoes are allowed to rotate by 180 degrees. As a reward I will give you all my dominoes".We got even more taken aback. And while we are wondering what was going on, help us make an optimal matrix of dominoes.InputThe first line contains integers n, m (1 ≤ n, m ≤ 103).In the next lines there is a description of the teachers' matrix. Each of next n lines contains m dominoes. The description of one domino is two integers (0 or 1), written without a space — the digits on the left and right half of the domino.OutputPrint the resulting matrix of dominoes in the format: n lines, each of them contains m space-separated dominoes.If there are multiple optimal solutions, print any of them.ExamplesInput2 301 11 0000 01 11Output11 11 1000 00 01Input4 111100100Output11100100NoteConsider the answer for the first sample. There, the maximum sum among all columns equals 1 (the number of columns is 6, and not 3). Obviously, this maximum can't be less than 1, then such matrix is optimal.Note that the dominoes can be rotated by 180 degrees.	Input2 301 11 0000 01 11	Output11 11 1000 00 01	2 seconds	256 megabytes	['constructive algorithms', 'greedy']
B. Very Beautiful Numbertime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputTeacher thinks that we make a lot of progress. Now we are even allowed to use decimal notation instead of counting sticks. After the test the teacher promised to show us a "very beautiful number". But the problem is, he's left his paper with the number in the teachers' office.The teacher remembers that the "very beautiful number" was strictly positive, didn't contain any leading zeroes, had the length of exactly p decimal digits, and if we move the last digit of the number to the beginning, it grows exactly x times. Besides, the teacher is sure that among all such numbers the "very beautiful number" is minimal possible.The teachers' office isn't near and the teacher isn't young. But we've passed the test and we deserved the right to see the "very beautiful number". Help to restore the justice, find the "very beautiful number" for us!InputThe single line contains integers p, x (1 ≤ p ≤ 106, 1 ≤ x ≤ 9).OutputIf the teacher's made a mistake and such number doesn't exist, then print on a single line "Impossible" (without the quotes). Otherwise, print the "very beautiful number" without leading zeroes.ExamplesInput6 5Output142857Input1 2OutputImpossibleInput6 4Output102564NoteSample 1: 142857·5 = 714285.Sample 2: The number that consists of a single digit cannot stay what it is when multiplied by 2, thus, the answer to the test sample is "Impossible".	Input6 5	Output142857	1 second	256 megabytes	['math']
A. Counting Stickstime limit per test0.5 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputWhen new students come to the Specialized Educational and Scientific Centre (SESC) they need to start many things from the beginning. Sometimes the teachers say (not always unfairly) that we cannot even count. So our teachers decided to teach us arithmetics from the start. And what is the best way to teach students add and subtract? — That's right, using counting sticks! An here's our new task: An expression of counting sticks is an expression of type:[ A sticks][sign +][B sticks][sign =][C sticks] (1 ≤ A, B, C). Sign + consists of two crossed sticks: one vertical and one horizontal. Sign = consists of two horizontal sticks. The expression is arithmetically correct if A + B = C.We've got an expression that looks like A + B = C given by counting sticks. Our task is to shift at most one stick (or we can shift nothing) so that the expression became arithmetically correct. Note that we cannot remove the sticks from the expression, also we cannot shift the sticks from the signs + and =.We really aren't fabulous at arithmetics. Can you help us?InputThe single line contains the initial expression. It is guaranteed that the expression looks like A + B = C, where 1 ≤ A, B, C ≤ 100.OutputIf there isn't a way to shift the stick so the expression becomes correct, print on a single line "Impossible" (without the quotes). If there is a way, print the resulting expression. Follow the format of the output from the test samples. Don't print extra space characters.If there are multiple correct answers, print any of them. For clarifications, you are recommended to see the test samples.ExamplesInput\|\|+\|=\|\|\|\|\|Output\|\|\|+\|=\|\|\|\|Input\|\|\|\|\|+\|\|=\|\|OutputImpossibleInput\|+\|=\|\|\|\|\|\|OutputImpossibleInput\|\|\|\|+\|\|=\|\|\|\|\|\|Output\|\|\|\|+\|\|=\|\|\|\|\|\|NoteIn the first sample we can shift stick from the third group of sticks to the first one.In the second sample we cannot shift vertical stick from + sign to the second group of sticks. So we cannot make a - sign.There is no answer in the third sample because we cannot remove sticks from the expression.In the forth sample the initial expression is already arithmetically correct and that is why we don't have to shift sticks.	Input\|\|+\|=\|\|\|\|\|	Output\|\|\|+\|=\|\|\|\|	0.5 seconds	256 megabytes	['brute force', 'implementation']
D. Three Arraystime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputThere are three arrays a, b and c. Each of them consists of n integers. SmallY wants to find three integers u, v, w (0 ≤ u, v, w ≤ n) such that the following condition holds: each number that appears in the union of a, b and c, appears either in the first u elements of a, or in the first v elements of b, or in the first w elements of c. Of course, SmallY doesn't want to have huge numbers u, v and w, so she wants sum u + v + w to be as small as possible.Please, help her to find the minimal possible sum of u + v + w.InputThe first line contains a single integer n (1 ≤ n ≤ 105). The second line contains n space-separated integers a1, a2, ..., an — array a. The third line contains the description of array b in the same format. The fourth line contains the description of array c in the same format. The following constraint holds: 1 ≤ ai, bi, ci ≤ 109.OutputPrint a single integer — the minimum possible sum of u + v + w.ExamplesInput31 1 1011 2 13 2 1Output5Input51 1 2 2 32 2 4 3 33 3 1 1 1Output5NoteIn the first example you should choose u = 3, v = 0, w = 2. In the second example you should choose u = 1, v = 3, w = 1.	Input31 1 1011 2 13 2 1	Output5	1 second	256 megabytes	['data structures']
C. Yet Another Number Sequencetime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputEveryone knows what the Fibonacci sequence is. This sequence can be defined by the recurrence relation: F1 = 1, F2 = 2, Fi = Fi - 1 + Fi - 2 (i > 2).We'll define a new number sequence Ai(k) by the formula: Ai(k) = Fi × ik (i ≥ 1).In this problem, your task is to calculate the following sum: A1(k) + A2(k) + ... + An(k). The answer can be very large, so print it modulo 1000000007 (109 + 7).InputThe first line contains two space-separated integers n, k (1 ≤ n ≤ 1017; 1 ≤ k ≤ 40).OutputPrint a single integer — the sum of the first n elements of the sequence Ai(k) modulo 1000000007 (109 + 7).ExamplesInput1 1Output1Input4 1Output34Input5 2Output316Input7 4Output73825	Input1 1	Output1	1 second	256 megabytes	['combinatorics', 'math', 'matrices']
B. Tower of Hanoitime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe Tower of Hanoi is a well-known mathematical puzzle. It consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape.The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules: Only one disk can be moved at a time. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack. No disk may be placed on top of a smaller disk. With three disks, the puzzle can be solved in seven moves. The minimum number of moves required to solve a Tower of Hanoi puzzle is 2n - 1, where n is the number of disks. (c) Wikipedia.SmallY's puzzle is very similar to the famous Tower of Hanoi. In the Tower of Hanoi puzzle you need to solve a puzzle in minimum number of moves, in SmallY's puzzle each move costs some money and you need to solve the same puzzle but for minimal cost. At the beginning of SmallY's puzzle all n disks are on the first rod. Moving a disk from rod i to rod j (1 ≤ i, j ≤ 3) costs tij units of money. The goal of the puzzle is to move all the disks to the third rod.In the problem you are given matrix t and an integer n. You need to count the minimal cost of solving SmallY's puzzle, consisting of n disks.InputEach of the first three lines contains three integers — matrix t. The j-th integer in the i-th line is tij (1 ≤ tij ≤ 10000; i ≠ j). The following line contains a single integer n (1 ≤ n ≤ 40) — the number of disks.It is guaranteed that for all i (1 ≤ i ≤ 3), tii = 0.OutputPrint a single integer — the minimum cost of solving SmallY's puzzle.ExamplesInput0 1 11 0 11 1 03Output7Input0 2 21 0 1001 2 03Output19Input0 2 11 0 1001 2 05Output87	Input0 1 11 0 11 1 03	Output7	1 second	256 megabytes	['dp']
A. Blocked Pointstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputImagine you have an infinite 2D plane with Cartesian coordinate system. Some of the integral points are blocked, and others are not. Two integral points A and B on the plane are 4-connected if and only if: the Euclidean distance between A and B is one unit and neither A nor B is blocked; or there is some integral point C, such that A is 4-connected with C, and C is 4-connected with B. Let's assume that the plane doesn't contain blocked points. Consider all the integral points of the plane whose Euclidean distance from the origin is no more than n, we'll name these points special. Chubby Yang wants to get the following property: no special point is 4-connected to some non-special point. To get the property she can pick some integral points of the plane and make them blocked. What is the minimum number of points she needs to pick?InputThe first line contains an integer n (0 ≤ n ≤ 4·107).OutputPrint a single integer — the minimum number of points that should be blocked.ExamplesInput1Output4Input2Output8Input3Output16	Input1	Output4	2 seconds	256 megabytes	['math']
F2. Stock Tradingtime limit per test3 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThis problem consists of three subproblems: for solving subproblem F1 you will receive 8 points, for solving subproblem F2 you will receive 15 points, and for solving subproblem F3 you will receive 10 points.Manao has developed a model to predict the stock price of a company over the next n days and wants to design a profit-maximizing trading algorithm to make use of these predictions. Unfortunately, Manao's trading account has the following restrictions: It only allows owning either zero or one shares of stock at a time; It only allows buying or selling a share of this stock once per day; It allows a maximum of k buy orders over the next n days; For the purposes of this problem, we define a trade to a be the act of buying one share of stock on day i, then holding the stock until some day j > i at which point the share is sold. To restate the above constraints, Manao is permitted to make at most k non-overlapping trades during the course of an n-day trading period for which Manao's model has predictions about the stock price.Even though these restrictions limit the amount of profit Manao can make compared to what would be achievable with an unlimited number of trades or the ability to hold more than one share at a time, Manao still has the potential to make a lot of money because Manao's model perfectly predicts the daily price of the stock. For example, using this model, Manao could wait until the price is low, then buy one share and hold until the price reaches a high value, then sell for a profit, and repeat this process up to k times until n days have passed.Nevertheless, Manao is not satisfied by having a merely good trading algorithm, and wants to develop an optimal strategy for trading subject to these constraints. Help Manao achieve this goal by writing a program that will determine when to buy and sell stock to achieve the greatest possible profit during the n-day trading period subject to the above constraints.InputThe first line contains two integers n and k, separated by a single space, with . The i-th of the following n lines contains a single integer pi (0 ≤ pi ≤ 1012), where pi represents the price at which someone can either buy or sell one share of stock on day i.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 F1 (8 points), n will be between 1 and 3000, inclusive. In subproblem F2 (15 points), n will be between 1 and 100000, inclusive. In subproblem F3 (10 points), n will be between 1 and 4000000, inclusive. OutputFor this problem, the program will only report the amount of the optimal profit, rather than a list of trades that can achieve this profit.Therefore, the program should print one line containing a single integer, the maximum profit Manao can achieve over the next n days with the constraints of starting with no shares on the first day of trading, always owning either zero or one shares of stock, and buying at most k shares over the course of the n-day trading period.ExamplesInput10 22739879719Output15Input10 52739879719Output21NoteIn the first example, the best trade overall is to buy at a price of 1 on day 9 and sell at a price of 9 on day 10 and the second best trade overall is to buy at a price of 2 on day 1 and sell at a price of 9 on day 4. Since these two trades do not overlap, both can be made and the profit is the sum of the profits of the two trades. Thus the trade strategy looks like this: 2 \| 7 \| 3 \| 9 \| 8 \| 7 \| 9 \| 7 \| 1 \| 9buy \| \| \| sell \| \| \| \| \| buy \| sellThe total profit is then (9 - 2) + (9 - 1) = 15.In the second example, even though Manao is allowed up to 5 trades there are only 4 profitable trades available. Making a fifth trade would cost Manao money so he only makes the following 4: 2 \| 7 \| 3 \| 9 \| 8 \| 7 \| 9 \| 7 \| 1 \| 9buy \| sell \| buy \| sell \| \| buy \| sell \| \| buy \| sellThe total profit is then (7 - 2) + (9 - 3) + (9 - 7) + (9 - 1) = 21.	Input10 22739879719	Output15	3 seconds	256 megabytes	['greedy']
F1. Stock Tradingtime limit per test3 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThis problem consists of three subproblems: for solving subproblem F1 you will receive 8 points, for solving subproblem F2 you will receive 15 points, and for solving subproblem F3 you will receive 10 points.Manao has developed a model to predict the stock price of a company over the next n days and wants to design a profit-maximizing trading algorithm to make use of these predictions. Unfortunately, Manao's trading account has the following restrictions: It only allows owning either zero or one shares of stock at a time; It only allows buying or selling a share of this stock once per day; It allows a maximum of k buy orders over the next n days; For the purposes of this problem, we define a trade to a be the act of buying one share of stock on day i, then holding the stock until some day j > i at which point the share is sold. To restate the above constraints, Manao is permitted to make at most k non-overlapping trades during the course of an n-day trading period for which Manao's model has predictions about the stock price.Even though these restrictions limit the amount of profit Manao can make compared to what would be achievable with an unlimited number of trades or the ability to hold more than one share at a time, Manao still has the potential to make a lot of money because Manao's model perfectly predicts the daily price of the stock. For example, using this model, Manao could wait until the price is low, then buy one share and hold until the price reaches a high value, then sell for a profit, and repeat this process up to k times until n days have passed.Nevertheless, Manao is not satisfied by having a merely good trading algorithm, and wants to develop an optimal strategy for trading subject to these constraints. Help Manao achieve this goal by writing a program that will determine when to buy and sell stock to achieve the greatest possible profit during the n-day trading period subject to the above constraints.InputThe first line contains two integers n and k, separated by a single space, with . The i-th of the following n lines contains a single integer pi (0 ≤ pi ≤ 1012), where pi represents the price at which someone can either buy or sell one share of stock on day i.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 F1 (8 points), n will be between 1 and 3000, inclusive. In subproblem F2 (15 points), n will be between 1 and 100000, inclusive. In subproblem F3 (10 points), n will be between 1 and 4000000, inclusive. OutputFor this problem, the program will only report the amount of the optimal profit, rather than a list of trades that can achieve this profit.Therefore, the program should print one line containing a single integer, the maximum profit Manao can achieve over the next n days with the constraints of starting with no shares on the first day of trading, always owning either zero or one shares of stock, and buying at most k shares over the course of the n-day trading period.ExamplesInput10 22739879719Output15Input10 52739879719Output21NoteIn the first example, the best trade overall is to buy at a price of 1 on day 9 and sell at a price of 9 on day 10 and the second best trade overall is to buy at a price of 2 on day 1 and sell at a price of 9 on day 4. Since these two trades do not overlap, both can be made and the profit is the sum of the profits of the two trades. Thus the trade strategy looks like this: 2 \| 7 \| 3 \| 9 \| 8 \| 7 \| 9 \| 7 \| 1 \| 9buy \| \| \| sell \| \| \| \| \| buy \| sellThe total profit is then (9 - 2) + (9 - 1) = 15.In the second example, even though Manao is allowed up to 5 trades there are only 4 profitable trades available. Making a fifth trade would cost Manao money so he only makes the following 4: 2 \| 7 \| 3 \| 9 \| 8 \| 7 \| 9 \| 7 \| 1 \| 9buy \| sell \| buy \| sell \| \| buy \| sell \| \| buy \| sellThe total profit is then (7 - 2) + (9 - 3) + (9 - 7) + (9 - 1) = 21.	Input10 22739879719	Output15	3 seconds	256 megabytes	['dp']
D2. Supercollidertime limit per test3 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThis problem consists of two subproblems: for solving subproblem D1 you will receive 3 points, and for solving subproblem D2 you will receive 16 points.Manao is the chief architect involved in planning a new supercollider. He has to identify a plot of land where the largest possible supercollider can be built. The supercollider he is building requires four-way orthogonal collisions of particles traveling at the same speed, so it will consist of four accelerating chambers and be shaped like a plus sign (i.e., +). Each of the four accelerating chambers must be the same length and must be aligned with the Earth's magnetic field (parallel or orthogonal) to minimize interference.The accelerating chambers need to be laid down across long flat stretches of land to keep costs under control. Thus, Manao has already commissioned a topographical study that has identified all possible maximal length tracts of land available for building accelerating chambers that are either parallel or orthogonal to the Earth's magnetic field. To build the largest possible supercollider, Manao must identify the largest symmetric plus shape from among these candidate tracts. That is, he must find the two tracts of land that form an axis-aligned plus shape with the largest distance from the center of the plus to the tip of the shortest of the four arms of the plus. Note that the collider need not use the entire length of the tracts identified (see the example in the notes).InputThe first line of the input will contain two single-space-separated integers n, the number of north-south tracts and m, the number of west-east tracts.Each of the n lines following the first describes a north-south tract. Each such tract is described by three single-space-separated integers xi, yi, li representing the vertical line segment from (xi, yi) to (xi, yi + li).Similarly, after the n lines describing north-south tracts follow m similar lines describing the west-east tracts. Each such tract is described by three single-space-separated integers xi, yi, li representing the horizontal line segment from (xi, yi) to (xi + li, yi).All xi and yi are between -100000000 and 100000000, inclusive. All li are between 1 and 100000000, inclusive. No pair of horizontal segments will touch or intersect, and no pair of vertical segments will touch or intersect.The problem consists of two 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 D1 (3 points), n and m will be between 1 and 1000, inclusive. In subproblem D2 (16 points), n and m will be between 1 and 50000, inclusive. OutputPrint one line containing a single integer, the size of the largest supercollider that can be built on one north-south tract and one west-east tract. The size of the supercollider is defined to be the length of one of the four accelerating chambers. In other words, the size of the resulting supercollider is defined to be the distance from the intersection of the two line segments to the closest endpoint of either of the two segments. If no pair of north-south and west-east tracts intersects, it is not possible to build a supercollider and the program should report a maximum size of zero.ExamplesInput1 24 0 91 1 81 2 7Output2NoteConsider the example. There is one vertical line segment from (4, 0) to (4, 9) and two horizontal line segments: from (1, 1) to (9, 1) and from (1, 2) to (8, 2). The largest plus shape that can be found among these segments is formed from the only vertical segment and the second of horizontal segments, and is centered at (4, 2). The program should output 2 because the closest end point of those segments to the center is (4, 0), which is distance 2 from the center point of (4, 2). The collider will be formed by the line segments from (2, 2) to (6, 2) and from (4, 0) to (4, 4).	Input1 24 0 91 1 81 2 7	Output2	3 seconds	256 megabytes	['data structures']
D1. Supercollidertime limit per test3 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThis problem consists of two subproblems: for solving subproblem D1 you will receive 3 points, and for solving subproblem D2 you will receive 16 points.Manao is the chief architect involved in planning a new supercollider. He has to identify a plot of land where the largest possible supercollider can be built. The supercollider he is building requires four-way orthogonal collisions of particles traveling at the same speed, so it will consist of four accelerating chambers and be shaped like a plus sign (i.e., +). Each of the four accelerating chambers must be the same length and must be aligned with the Earth's magnetic field (parallel or orthogonal) to minimize interference.The accelerating chambers need to be laid down across long flat stretches of land to keep costs under control. Thus, Manao has already commissioned a topographical study that has identified all possible maximal length tracts of land available for building accelerating chambers that are either parallel or orthogonal to the Earth's magnetic field. To build the largest possible supercollider, Manao must identify the largest symmetric plus shape from among these candidate tracts. That is, he must find the two tracts of land that form an axis-aligned plus shape with the largest distance from the center of the plus to the tip of the shortest of the four arms of the plus. Note that the collider need not use the entire length of the tracts identified (see the example in the notes).InputThe first line of the input will contain two single-space-separated integers n, the number of north-south tracts and m, the number of west-east tracts.Each of the n lines following the first describes a north-south tract. Each such tract is described by three single-space-separated integers xi, yi, li representing the vertical line segment from (xi, yi) to (xi, yi + li).Similarly, after the n lines describing north-south tracts follow m similar lines describing the west-east tracts. Each such tract is described by three single-space-separated integers xi, yi, li representing the horizontal line segment from (xi, yi) to (xi + li, yi).All xi and yi are between -100000000 and 100000000, inclusive. All li are between 1 and 100000000, inclusive. No pair of horizontal segments will touch or intersect, and no pair of vertical segments will touch or intersect.The problem consists of two 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 D1 (3 points), n and m will be between 1 and 1000, inclusive. In subproblem D2 (16 points), n and m will be between 1 and 50000, inclusive. OutputPrint one line containing a single integer, the size of the largest supercollider that can be built on one north-south tract and one west-east tract. The size of the supercollider is defined to be the length of one of the four accelerating chambers. In other words, the size of the resulting supercollider is defined to be the distance from the intersection of the two line segments to the closest endpoint of either of the two segments. If no pair of north-south and west-east tracts intersects, it is not possible to build a supercollider and the program should report a maximum size of zero.ExamplesInput1 24 0 91 1 81 2 7Output2NoteConsider the example. There is one vertical line segment from (4, 0) to (4, 9) and two horizontal line segments: from (1, 1) to (9, 1) and from (1, 2) to (8, 2). The largest plus shape that can be found among these segments is formed from the only vertical segment and the second of horizontal segments, and is centered at (4, 2). The program should output 2 because the closest end point of those segments to the center is (4, 0), which is distance 2 from the center point of (4, 2). The collider will be formed by the line segments from (2, 2) to (6, 2) and from (4, 0) to (4, 4).	Input1 24 0 91 1 81 2 7	Output2	3 seconds	256 megabytes	['brute force']
C2. The Tournamenttime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThis problem consists of three subproblems: for solving subproblem C1 you will receive 4 points, for solving subproblem C2 you will receive 4 points, and for solving subproblem C3 you will receive 8 points.Manao decided to pursue a fighter's career. He decided to begin with an ongoing tournament. Before Manao joined, there were n contestants in the tournament, numbered from 1 to n. Each of them had already obtained some amount of tournament points, namely the i-th fighter had pi points.Manao is going to engage in a single fight against each contestant. Each of Manao's fights ends in either a win or a loss. A win grants Manao one point, and a loss grants Manao's opponent one point. For each i, Manao estimated the amount of effort ei he needs to invest to win against the i-th contestant. Losing a fight costs no effort.After Manao finishes all of his fights, the ranklist will be determined, with 1 being the best rank and n + 1 being the worst. The contestants will be ranked in descending order of their tournament points. The contestants with the same number of points as Manao will be ranked better than him if they won the match against him and worse otherwise. The exact mechanism of breaking ties for other fighters is not relevant here.Manao's objective is to have rank k or better. Determine the minimum total amount of effort he needs to invest in order to fulfill this goal, if it is possible.InputThe first line contains a pair of integers n and k (1 ≤ k ≤ n + 1). The i-th of the following n lines contains two integers separated by a single space — pi and ei (0 ≤ pi, ei ≤ 200000).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 C1 (4 points), the constraint 1 ≤ n ≤ 15 will hold. In subproblem C2 (4 points), the constraint 1 ≤ n ≤ 100 will hold. In subproblem C3 (8 points), the constraint 1 ≤ n ≤ 200000 will hold. OutputPrint a single number in a single line — the minimum amount of effort Manao needs to use to rank in the top k. If no amount of effort can earn Manao such a rank, output number -1.ExamplesInput3 21 11 42 2Output3Input2 13 24 0Output-1Input5 22 102 101 13 13 1Output12NoteConsider the first test case. At the time when Manao joins the tournament, there are three fighters. The first of them has 1 tournament point and the victory against him requires 1 unit of effort. The second contestant also has 1 tournament point, but Manao needs 4 units of effort to defeat him. The third contestant has 2 points and victory against him costs Manao 2 units of effort. Manao's goal is top be in top 2. The optimal decision is to win against fighters 1 and 3, after which Manao, fighter 2, and fighter 3 will all have 2 points. Manao will rank better than fighter 3 and worse than fighter 2, thus finishing in second place.Consider the second test case. Even if Manao wins against both opponents, he will still rank third.	Input3 21 11 42 2	Output3	2 seconds	256 megabytes	['greedy']
C1. The Tournamenttime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThis problem consists of three subproblems: for solving subproblem C1 you will receive 4 points, for solving subproblem C2 you will receive 4 points, and for solving subproblem C3 you will receive 8 points.Manao decided to pursue a fighter's career. He decided to begin with an ongoing tournament. Before Manao joined, there were n contestants in the tournament, numbered from 1 to n. Each of them had already obtained some amount of tournament points, namely the i-th fighter had pi points.Manao is going to engage in a single fight against each contestant. Each of Manao's fights ends in either a win or a loss. A win grants Manao one point, and a loss grants Manao's opponent one point. For each i, Manao estimated the amount of effort ei he needs to invest to win against the i-th contestant. Losing a fight costs no effort.After Manao finishes all of his fights, the ranklist will be determined, with 1 being the best rank and n + 1 being the worst. The contestants will be ranked in descending order of their tournament points. The contestants with the same number of points as Manao will be ranked better than him if they won the match against him and worse otherwise. The exact mechanism of breaking ties for other fighters is not relevant here.Manao's objective is to have rank k or better. Determine the minimum total amount of effort he needs to invest in order to fulfill this goal, if it is possible.InputThe first line contains a pair of integers n and k (1 ≤ k ≤ n + 1). The i-th of the following n lines contains two integers separated by a single space — pi and ei (0 ≤ pi, ei ≤ 200000).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 C1 (4 points), the constraint 1 ≤ n ≤ 15 will hold. In subproblem C2 (4 points), the constraint 1 ≤ n ≤ 100 will hold. In subproblem C3 (8 points), the constraint 1 ≤ n ≤ 200000 will hold. OutputPrint a single number in a single line — the minimum amount of effort Manao needs to use to rank in the top k. If no amount of effort can earn Manao such a rank, output number -1.ExamplesInput3 21 11 42 2Output3Input2 13 24 0Output-1Input5 22 102 101 13 13 1Output12NoteConsider the first test case. At the time when Manao joins the tournament, there are three fighters. The first of them has 1 tournament point and the victory against him requires 1 unit of effort. The second contestant also has 1 tournament point, but Manao needs 4 units of effort to defeat him. The third contestant has 2 points and victory against him costs Manao 2 units of effort. Manao's goal is top be in top 2. The optimal decision is to win against fighters 1 and 3, after which Manao, fighter 2, and fighter 3 will all have 2 points. Manao will rank better than fighter 3 and worse than fighter 2, thus finishing in second place.Consider the second test case. Even if Manao wins against both opponents, he will still rank third.	Input3 21 11 42 2	Output3	2 seconds	256 megabytes	['brute force']
B. Word Foldingtime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou will receive 5 points for solving this problem.Manao has invented a new operation on strings that is called folding. Each fold happens between a pair of consecutive letters and places the second part of the string above first part, running in the opposite direction and aligned to the position of the fold. Using this operation, Manao converts the string into a structure that has one more level than there were fold operations performed. See the following examples for clarity.We will denote the positions of folds with '\|' characters. For example, the word "ABRACADABRA" written as "AB\|RACA\|DAB\|RA" indicates that it has been folded three times: first, between the leftmost pair of 'B' and 'R' letters; second, between 'A' and 'D'; and third, between the rightmost pair of 'B' and 'R' letters. Here are several examples of folded strings:"ABCDEF\|GHIJK" \| "A\|BCDEFGHIJK" \| "AB\|RACA\|DAB\|RA" \| "X\|XXXXX\|X\|X\|XXXXXX" \| \| \| XXXXXX KJIHG \| KJIHGFEDCB \| AR \| X ABCDEF \| A \| DAB \| X \| \| ACAR \| XXXXX \| \| AB \| XOne last example for "ABCD\|EFGH\|IJ\|K": KIJHGFEABCDManao noticed that each folded string can be viewed as several piles of letters. For instance, in the previous example, there are four piles, which can be read as "AHI", "BGJK", "CF", and "DE" from bottom to top. Manao wonders what is the highest pile of identical letters he can build using fold operations on a given word. Note that the pile should not contain gaps and should start at the bottom level. For example, in the rightmost of the four examples above, none of the piles would be considered valid since each of them has gaps, starts above the bottom level, or both.InputThe input will consist of one line containing a single string of n characters with 1 ≤ n ≤ 1000 and no spaces. All characters of the string will be uppercase letters.This problem doesn't have subproblems. You will get 5 points for the correct submission.OutputPrint a single integer — the size of the largest pile composed of identical characters that can be seen in a valid result of folding operations on the given string.ExamplesInputABRACADABRAOutput3InputABBBCBDBOutput3InputABOutput1NoteConsider the first example. Manao can create a pile of three 'A's using the folding "AB\|RACAD\|ABRA", which results in the following structure: ABRADACAR ABIn the second example, Manao can create a pile of three 'B's using the following folding: "AB\|BB\|CBDB". CBDBBBABAnother way for Manao to create a pile of three 'B's with "ABBBCBDB" is the following folding: "AB\|B\|BCBDB". BCBDB BABIn the third example, there are no folds performed and the string is just written in one line.	InputABRACADABRA	Output3	1 second	256 megabytes	['brute force']
A. Genetic Engineeringtime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou will receive 3 points for solving this problem.Manao is designing the genetic code for a new type of algae to efficiently produce fuel. Specifically, Manao is focusing on a stretch of DNA that encodes one protein. The stretch of DNA is represented by a string containing only the characters 'A', 'T', 'G' and 'C'.Manao has determined that if the stretch of DNA contains a maximal sequence of consecutive identical nucleotides that is of even length, then the protein will be nonfunctional. For example, consider a protein described by DNA string "GTTAAAG". It contains four maximal sequences of consecutive identical nucleotides: "G", "TT", "AAA", and "G". The protein is nonfunctional because sequence "TT" has even length.Manao is trying to obtain a functional protein from the protein he currently has. Manao can insert additional nucleotides into the DNA stretch. Each additional nucleotide is a character from the set {'A', 'T', 'G', 'C'}. Manao wants to determine the minimum number of insertions necessary to make the DNA encode a functional protein.InputThe input consists of a single line, containing a string s of length n (1 ≤ n ≤ 100). Each character of s will be from the set {'A', 'T', 'G', 'C'}.This problem doesn't have subproblems. You will get 3 points for the correct submission.OutputThe program should print on one line a single integer representing the minimum number of 'A', 'T', 'G', 'C' characters that are required to be inserted into the input string in order to make all runs of identical characters have odd length.ExamplesInputGTTAAAGOutput1InputAACCAACCAAAACOutput5NoteIn the first example, it is sufficient to insert a single nucleotide of any type between the two 'T's in the sequence to restore the functionality of the protein.	InputGTTAAAG	Output1	1 second	256 megabytes	['implementation', 'two pointers']
D. Inna and Sweet Matrixtime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputInna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if \|i - p\| + \|j - q\| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.Help Inna to minimize the penalty in the game.InputThe first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).OutputIn the first line print an integer — Inna's minimum penalty in the game.In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.ExamplesInput4 4 4Output8(1,1) (2,1) (2,2)(1,1) (1,2)(1,1) (2,1)(1,1)NoteNote to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.	Input4 4 4	Output8(1,1) (2,1) (2,2)(1,1) (1,2)(1,1) (2,1)(1,1)	1 second	256 megabytes	['constructive algorithms']
C. Inna and Candy Boxestime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputInna loves sweets very much. She has n closed present boxes lines up in a row in front of her. Each of these boxes contains either a candy (Dima's work) or nothing (Sereja's work). Let's assume that the boxes are numbered from 1 to n, from left to right.As the boxes are closed, Inna doesn't know which boxes contain candies and which boxes contain nothing. Inna chose number k and asked w questions to Dima to find that out. Each question is characterised by two integers li, ri (1 ≤ li ≤ ri ≤ n; r - l + 1 is divisible by k), the i-th question is: "Dima, is that true that among the boxes with numbers from li to ri, inclusive, the candies lie only in boxes with numbers li + k - 1, li + 2k - 1, li + 3k - 1, ..., ri?"Dima hates to say "no" to Inna. That's why he wonders, what number of actions he will have to make for each question to make the answer to the question positive. In one action, Dima can either secretly take the candy from any box or put a candy to any box (Dima has infinitely many candies). Help Dima count the number of actions for each Inna's question.Please note that Dima doesn't change the array during Inna's questions. That's why when you calculate the number of operations for the current question, please assume that the sequence of boxes didn't change.InputThe first line of the input contains three integers n, k and w (1 ≤ k ≤ min(n, 10), 1 ≤ n, w ≤ 105). The second line contains n characters. If the i-th box contains a candy, the i-th character of the line equals 1, otherwise it equals 0.Each of the following w lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n) — the description of the i-th question. It is guaranteed that ri - li + 1 is divisible by k.OutputFor each question, print a single number on a single line — the minimum number of operations Dima needs to make the answer to the question positive.ExamplesInput10 3 310101000111 31 64 9Output132NoteFor the first question, you need to take a candy from the first box to make the answer positive. So the answer is 1.For the second question, you need to take a candy from the first box, take a candy from the fifth box and put a candy to the sixth box. The answer is 3.For the third question, you need to take a candy from the fifth box and put it to the sixth box. The answer is 2.	Input10 3 310101000111 31 64 9	Output132	1 second	256 megabytes	['data structures']
B. Inna, Dima and Songtime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputInna is a great piano player and Dima is a modest guitar player. Dima has recently written a song and they want to play it together. Of course, Sereja wants to listen to the song very much. A song is a sequence of notes. Dima and Inna want to play each note at the same time. At that, they can play the i-th note at volume v (1 ≤ v ≤ ai; v is an integer) both on the piano and the guitar. They should retain harmony, so the total volume with which the i-th note was played on the guitar and the piano must equal bi. If Dima and Inna cannot play a note by the described rules, they skip it and Sereja's joy drops by 1. But if Inna and Dima play the i-th note at volumes xi and yi (xi + yi = bi) correspondingly, Sereja's joy rises by xi·yi. Sereja has just returned home from the university and his current joy is 0. Help Dima and Inna play the song so as to maximize Sereja's total joy after listening to the whole song!InputThe first line of the input contains integer n (1 ≤ n ≤ 105) — the number of notes in the song. The second line contains n integers ai (1 ≤ ai ≤ 106). The third line contains n integers bi (1 ≤ bi ≤ 106).OutputIn a single line print an integer — the maximum possible joy Sereja feels after he listens to a song.ExamplesInput31 1 22 2 3Output4Input125Output-1NoteIn the first sample, Dima and Inna play the first two notes at volume 1 (1 + 1 = 2, the condition holds), they should play the last note at volumes 1 and 2. Sereja's total joy equals: 1·1 + 1·1 + 1·2 = 4.In the second sample, there is no such pair (x, y), that 1 ≤ x, y ≤ 2, x + y = 5, so Dima and Inna skip a note. Sereja's total joy equals -1.	Input31 1 22 2 3	Output4	1 second	256 megabytes	['implementation']
A. Inna and Alarm Clocktime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputInna loves sleeping very much, so she needs n alarm clocks in total to wake up. Let's suppose that Inna's room is a 100 × 100 square with the lower left corner at point (0, 0) and with the upper right corner at point (100, 100). Then the alarm clocks are points with integer coordinates in this square.The morning has come. All n alarm clocks in Inna's room are ringing, so Inna wants to turn them off. For that Inna has come up with an amusing game: First Inna chooses a type of segments that she will use throughout the game. The segments can be either vertical or horizontal. Then Inna makes multiple moves. In a single move, Inna can paint a segment of any length on the plane, she chooses its type at the beginning of the game (either vertical or horizontal), then all alarm clocks that are on this segment switch off. The game ends when all the alarm clocks are switched off. Inna is very sleepy, so she wants to get through the alarm clocks as soon as possible. Help her, find the minimum number of moves in the game that she needs to turn off all the alarm clocks!InputThe first line of the input contains integer n (1 ≤ n ≤ 105) — the number of the alarm clocks. The next n lines describe the clocks: the i-th line contains two integers xi, yi — the coordinates of the i-th alarm clock (0 ≤ xi, yi ≤ 100).Note that a single point in the room can contain any number of alarm clocks and the alarm clocks can lie on the sides of the square that represents the room.OutputIn a single line print a single integer — the minimum number of segments Inna will have to draw if she acts optimally.ExamplesInput40 00 10 21 0Output2Input40 00 11 01 1Output2Input41 11 22 33 3Output3NoteIn the first sample, Inna first chooses type "vertical segments", and then she makes segments with ends at : (0, 0), (0, 2); and, for example, (1, 0), (1, 1). If she paints horizontal segments, she will need at least 3 segments.In the third sample it is important to note that Inna doesn't have the right to change the type of the segments during the game. That's why she will need 3 horizontal or 3 vertical segments to end the game.	Input40 00 10 21 0	Output2	1 second	256 megabytes	['implementation']
B. Fox and Crosstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputFox Ciel has a board with n rows and n columns. So, the board consists of n × n cells. Each cell contains either a symbol '.', or a symbol '#'.A cross on the board is a connected set of exactly five cells of the board that looks like a cross. The picture below shows how it looks.Ciel wants to draw several (may be zero) crosses on the board. Each cross must cover exactly five cells with symbols '#', and any cell with symbol '#' must belong to some cross. No two crosses can share a cell.Please, tell Ciel if she can draw the crosses in the described way.InputThe first line contains an integer n (3 ≤ n ≤ 100) — the size of the board.Each of the next n lines describes one row of the board. The i-th line describes the i-th row of the board and consists of n characters. Each character is either a symbol '.', or a symbol '#'.OutputOutput a single line with "YES" if Ciel can draw the crosses in the described way. Otherwise output a single line with "NO".ExamplesInput5.#...####..####...#......OutputYESInput4################OutputNOInput6.#....####...####..#.##.######.#..#.OutputYESInput6.#..#.######.####..####.######.#..#.OutputNOInput3.........OutputYESNoteIn example 1, you can draw two crosses. The picture below shows what they look like.In example 2, the board contains 16 cells with '#', but each cross contains 5. Since 16 is not a multiple of 5, so it's impossible to cover all.	Input5.#...####..####...#......	OutputYES	1 second	256 megabytes	['greedy', 'implementation', '*1100']
A. Fox and Number Gametime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputFox 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.InputThe first line contains an integer n (2 ≤ n ≤ 100). Then the second line contains n integers: x1, x2, ..., xn (1 ≤ xi ≤ 100).OutputOutput a single integer — the required minimal sum.ExamplesInput21 2Output2Input32 4 6Output6Input212 18Output12Input545 12 27 30 18Output15NoteIn 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.	Input21 2	Output2	1 second	256 megabytes	['greedy', 'math', '*1000']
E. Fox and Meteor Showertime limit per test6 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThere is a meteor shower on the sky and there are n meteors. The sky can be viewed as a 2D Euclid Plane and the meteor is point on this plane. Fox Ciel looks at the sky. She finds out that the orbit of each meteor is a straight line, and each meteor has a constant velocity. Now Ciel wants to know: what is the maximum number of meteors such that any pair met at the same position at a certain time? Note that the time is not limited and can be also negative. The meteors will never collide when they appear at the same position at the same time.InputThe first line contains an integer n (1 ≤ n ≤ 1000). Each of the next n lines contains six integers: t1, x1, y1, t2, x2, y2 — the description of a meteor's orbit: at time t1, the current meteor is located at the point (x1, y1) and at time t2, the meteor is located at point (x2, y2) ( - 106 ≤ t1, x1, y1, t2, x2, y2 ≤ 106; t1 ≠ t2). There will be no two meteors are always in the same position for any time.OutputPrint a single integer — the maximum number of meteors such that any pair met at the same position at a certain time.ExamplesInput20 0 1 1 0 20 1 0 1 2 0Output2Input3-1 -1 0 3 3 00 2 -1 -1 3 -2-2 0 -1 6 0 3Output3Input40 0 0 1 0 10 0 1 1 1 10 1 1 1 1 00 1 0 1 0 0Output1Input10 0 0 1 0 0Output1NoteIn example 1, meteor 1 and 2 meet in t=-1 at (0, 0).In example 2, meteor 1 and 2 meet in t=1 at (1, 0), meteor 1 and 3 meet in t=0 at (0, 0) and meteor 2 and 3 meet in t=2 at (0, 1).In example 3, no two meteor meet.In example 4, there is only 1 meteor, and its velocity is zero.If your browser doesn't support animation png, please see the gif version here: http://assets.codeforces.com/images/388e/example1.gifhttp://assets.codeforces.com/images/388e/example2.gifhttp://assets.codeforces.com/images/388e/example3.gifhttp://assets.codeforces.com/images/388e/example4.gif	Input20 0 1 1 0 20 1 0 1 2 0	Output2	6 seconds	256 megabytes	['geometry', '*3100']
D. Fox and Perfect Setstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputFox Ciel studies number theory.She thinks a non-empty set S contains non-negative integers is perfect if and only if for any (a can be equal to b), . Where operation xor means exclusive or operation (http://en.wikipedia.org/wiki/Exclusive_or).Please calculate the number of perfect sets consisting of integers not greater than k. The answer can be very large, so print it modulo 1000000007 (109 + 7).InputThe first line contains an integer k (0 ≤ k ≤ 109).OutputPrint a single integer — the number of required sets modulo 1000000007 (109 + 7).ExamplesInput1Output2Input2Output3Input3Output5Input4Output6NoteIn example 1, there are 2 such sets: {0} and {0, 1}. Note that {1} is not a perfect set since 1 xor 1 = 0 and {1} doesn't contain zero.In example 4, there are 6 such sets: {0}, {0, 1}, {0, 2}, {0, 3}, {0, 4} and {0, 1, 2, 3}.	Input1	Output2	1 second	256 megabytes	['math', '*2700']
C. Fox and Card Gametime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputFox Ciel is playing a card game with her friend Fox Jiro. There are n piles of cards on the table. And there is a positive integer on each card.The players take turns and Ciel takes the first turn. In Ciel's turn she takes a card from the top of any non-empty pile, and in Jiro's turn he takes a card from the bottom of any non-empty pile. Each player wants to maximize the total sum of the cards he took. The game ends when all piles become empty.Suppose Ciel and Jiro play optimally, what is the score of the game?InputThe first line contain an integer n (1 ≤ n ≤ 100). Each of the next n lines contains a description of the pile: the first integer in the line is si (1 ≤ si ≤ 100) — the number of cards in the i-th pile; then follow si positive integers c1, c2, ..., ck, ..., csi (1 ≤ ck ≤ 1000) — the sequence of the numbers on the cards listed from top of the current pile to bottom of the pile.OutputPrint two integers: the sum of Ciel's cards and the sum of Jiro's cards if they play optimally.ExamplesInput21 1002 1 10Output101 10Input19 2 8 6 5 9 4 7 1 3Output30 15Input33 1 3 23 5 4 62 8 7Output18 18Input33 1000 1000 10006 1000 1000 1000 1000 1000 10005 1000 1000 1000 1000 1000Output7000 7000NoteIn the first example, Ciel will take the cards with number 100 and 1, Jiro will take the card with number 10.In the second example, Ciel will take cards with numbers 2, 8, 6, 5, 9 and Jiro will take cards with numbers 4, 7, 1, 3.	Input21 1002 1 10	Output101 10	1 second	256 megabytes	['games', 'greedy', 'sortings', '*2000']
B. Fox and Minimal pathtime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputFox Ciel wants to write a task for a programming contest. The task is: "You are given a simple undirected graph with n vertexes. Each its edge has unit length. You should calculate the number of shortest paths between vertex 1 and vertex 2."Same with some writers, she wants to make an example with some certain output: for example, her birthday or the number of her boyfriend. Can you help her to make a test case with answer equal exactly to k?InputThe first line contains a single integer k (1 ≤ k ≤ 109).OutputYou should output a graph G with n vertexes (2 ≤ n ≤ 1000). There must be exactly k shortest paths between vertex 1 and vertex 2 of the graph.The first line must contain an integer n. Then adjacency matrix G with n rows and n columns must follow. Each element of the matrix must be 'N' or 'Y'. If Gij is 'Y', then graph G has a edge connecting vertex i and vertex j. Consider the graph vertexes are numbered from 1 to n.The graph must be undirected and simple: Gii = 'N' and Gij = Gji must hold. And there must be at least one path between vertex 1 and vertex 2. It's guaranteed that the answer exists. If there multiple correct answers, you can output any of them. ExamplesInput2Output4NNYYNNYYYYNNYYNNInput9Output8NNYYYNNNNNNNNYYYYNNNNYYYYNNNNYYYYNNNNYYYNYYYYNNNNYYYYNNNNYYYYNNNInput1Output2NYYNNoteIn first example, there are 2 shortest paths: 1-3-2 and 1-4-2.In second example, there are 9 shortest paths: 1-3-6-2, 1-3-7-2, 1-3-8-2, 1-4-6-2, 1-4-7-2, 1-4-8-2, 1-5-6-2, 1-5-7-2, 1-5-8-2.	Input2	Output4NNYYNNYYYYNNYYNN	1 second	256 megabytes	['bitmasks', 'constructive algorithms', 'graphs', 'implementation', 'math', '*1900']
A. Fox and Box Accumulationtime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputFox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box). Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?InputThe first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).OutputOutput a single integer — the minimal possible number of piles.ExamplesInput30 0 10Output2Input50 1 2 3 4Output1Input40 0 0 0Output4Input90 1 0 2 0 1 1 2 10Output3NoteIn example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).	Input30 0 10	Output2	1 second	256 megabytes	['greedy', 'sortings', '*1400']
E. George and Cardstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputGeorge is a cat, so he loves playing very much.Vitaly put n cards in a row in front of George. Each card has one integer written on it. All cards had distinct numbers written on them. Let's number the cards from the left to the right with integers from 1 to n. Then the i-th card from the left contains number pi (1 ≤ pi ≤ n). Vitaly wants the row to have exactly k cards left. He also wants the i-th card from left to have number bi written on it. Vitaly gave a task to George, to get the required sequence of cards using the remove operation n - k times.In one remove operation George can choose w (1 ≤ w; w is not greater than the current number of cards in the row) contiguous cards (contiguous subsegment of cards). Let's denote the numbers written on these card as x1, x2, ..., xw (from the left to the right). After that, George can remove the card xi, such that xi ≤ xj for each j (1 ≤ j ≤ w). After the described operation George gets w pieces of sausage.George wondered: what maximum number of pieces of sausage will he get in total if he reaches his goal and acts optimally well? Help George, find an answer to his question!InputThe first line contains integers n and k (1 ≤ k ≤ n ≤ 106) — the initial and the final number of cards.The second line contains n distinct space-separated integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the initial row of cards. The third line contains k space-separated integers b1, b2, ..., bk — the row of cards that you need to get. It is guaranteed that it's possible to obtain the given row by using the remove operation for n - k times.OutputPrint a single integer — the maximum number of pieces of sausage that George can get if he acts optimally well.ExamplesInput3 22 1 31 3Output1Input10 51 2 3 4 5 6 7 8 9 102 4 6 8 10Output30	Input3 22 1 31 3	Output1	2 seconds	256 megabytes	['binary search', 'data structures', '*2200']
D. George and Interesting Graphtime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputGeorge loves graphs. Most of all, he loves interesting graphs. We will assume that a directed graph is interesting, if it meets the following criteria: The graph doesn't contain any multiple arcs; There is vertex v (we'll call her the center), such that for any vertex of graph u, the graph contains arcs (u, v) and (v, u). Please note that the graph also contains loop (v, v). The outdegree of all vertexes except for the center equals two and the indegree of all vertexes except for the center equals two. The outdegree of vertex u is the number of arcs that go out of u, the indegree of vertex u is the number of arcs that go in u. Please note that the graph can contain loops. However, not everything's that simple. George got a directed graph of n vertices and m arcs as a present. The graph didn't have any multiple arcs. As George loves interesting graphs, he wants to slightly alter the presented graph and transform it into an interesting one. In one alteration he can either remove an arbitrary existing arc from the graph or add an arbitrary arc to the graph. George wonders: what is the minimum number of changes that he needs to obtain an interesting graph from the graph he's got as a present? Help George and find the answer to the question.InputThe first line contains two space-separated integers n and m (2 ≤ n ≤ 500, 1 ≤ m ≤ 1000) — the number of vertices and arcs in the presented graph.Each of the next m lines contains two space-separated integers ai, bi (1 ≤ ai, bi ≤ n) — the descriptions of the graph's arcs. Pair (ai, bi) means that the graph contains an arc from vertex number ai to vertex number bi. It is guaranteed that the presented graph doesn't contain multiple arcs.Assume that the grah vertices are numbered 1 through n.OutputPrint a single integer — the answer to George's question.ExamplesInput3 71 12 23 11 33 22 33 3Output0Input3 61 12 23 13 22 33 3Output1Input3 12 2Output6NoteFor more information about directed graphs, please visit: http://en.wikipedia.org/wiki/Directed_graphIn the first sample the graph already is interesting, its center is vertex 3.	Input3 71 12 23 11 33 22 33 3	Output0	1 second	256 megabytes	['graph matchings', '*2200']
C. George and Numbertime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputGeorge is a cat, so he really likes to play. Most of all he likes to play with his array of positive integers b. During the game, George modifies the array by using special changes. Let's mark George's current array as b1, b2, ..., b\|b\| (record \|b\| denotes the current length of the array). Then one change is a sequence of actions: Choose two distinct indexes i and j (1 ≤ i, j ≤ \|b\|; i ≠ j), such that bi ≥ bj. Get number v = concat(bi, bj), where concat(x, y) is a number obtained by adding number y to the end of the decimal record of number x. For example, concat(500, 10) = 50010, concat(2, 2) = 22. Add number v to the end of the array. The length of the array will increase by one. Remove from the array numbers with indexes i and j. The length of the array will decrease by two, and elements of the array will become re-numbered from 1 to current length of the array. George played for a long time with his array b and received from array b an array consisting of exactly one number p. Now George wants to know: what is the maximum number of elements array b could contain originally? Help him find this number. Note that originally the array could contain only positive integers.InputThe first line of the input contains a single integer p (1 ≤ p < 10100000). It is guaranteed that number p doesn't contain any leading zeroes.OutputPrint an integer — the maximum number of elements array b could contain originally.ExamplesInput9555Output4Input10000000005Output2Input800101Output3Input45Output1Input1000000000000001223300003342220044555Output17Input19992000Output1Input310200Output2NoteLet's consider the test examples: Originally array b can be equal to {5, 9, 5, 5}. The sequence of George's changes could have been: {5, 9, 5, 5} → {5, 5, 95} → {95, 55} → {9555}. Originally array b could be equal to {1000000000, 5}. Please note that the array b cannot contain zeros. Originally array b could be equal to {800, 10, 1}. Originally array b could be equal to {45}. It cannot be equal to {4, 5}, because George can get only array {54} from this array in one operation. Note that the numbers can be very large.	Input9555	Output4	1 second	256 megabytes	['greedy', 'implementation', '*1700']
B. George and Roundtime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputGeorge decided to prepare a Codesecrof round, so he has prepared m problems for the round. Let's number the problems with integers 1 through m. George estimates the i-th problem's complexity by integer bi.To make the round good, he needs to put at least n problems there. Besides, he needs to have at least one problem with complexity exactly a1, at least one with complexity exactly a2, ..., and at least one with complexity exactly an. Of course, the round can also have problems with other complexities.George has a poor imagination. It's easier for him to make some already prepared problem simpler than to come up with a new one and prepare it. George is magnificent at simplifying problems. He can simplify any already prepared problem with complexity c to any positive integer complexity d (c ≥ d), by changing limits on the input data.However, nothing is so simple. George understood that even if he simplifies some problems, he can run out of problems for a good round. That's why he decided to find out the minimum number of problems he needs to come up with in addition to the m he's prepared in order to make a good round. Note that George can come up with a new problem of any complexity.InputThe first line contains two integers n and m (1 ≤ n, m ≤ 3000) — the minimal number of problems in a good round and the number of problems George's prepared. The second line contains space-separated integers a1, a2, ..., an (1 ≤ a1 < a2 < ... < an ≤ 106) — the requirements for the complexity of the problems in a good round. The third line contains space-separated integers b1, b2, ..., bm (1 ≤ b1 ≤ b2... ≤ bm ≤ 106) — the complexities of the problems prepared by George. OutputPrint a single integer — the answer to the problem.ExamplesInput3 51 2 31 2 2 3 3Output0Input3 51 2 31 1 1 1 1Output2Input3 12 3 41Output3NoteIn the first sample the set of the prepared problems meets the requirements for a good round.In the second sample, it is enough to come up with and prepare two problems with complexities 2 and 3 to get a good round.In the third sample it is very easy to get a good round if come up with and prepare extra problems with complexities: 2, 3, 4.	Input3 51 2 31 2 2 3 3	Output0	1 second	256 megabytes	['brute force', 'greedy', 'two pointers', '*1200']
A. George and Sleeptime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputGeorge woke up and saw the current time s on the digital clock. Besides, George knows that he has slept for time t. Help George! Write a program that will, given time s and t, determine the time p when George went to bed. Note that George could have gone to bed yesterday relatively to the current time (see the second test sample). InputThe first line contains current time s as a string in the format "hh:mm". The second line contains time t in the format "hh:mm" — the duration of George's sleep. It is guaranteed that the input contains the correct time in the 24-hour format, that is, 00 ≤ hh ≤ 23, 00 ≤ mm ≤ 59.OutputIn the single line print time p — the time George went to bed in the format similar to the format of the time in the input.ExamplesInput05:5005:44Output00:06Input00:0001:00Output23:00Input00:0100:00Output00:01NoteIn the first sample George went to bed at "00:06". Note that you should print the time only in the format "00:06". That's why answers "0:06", "00:6" and others will be considered incorrect. In the second sample, George went to bed yesterday.In the third sample, George didn't do to bed at all.	Input05:5005:44	Output00:06	1 second	256 megabytes	['implementation', '*900']
D. Game with Pointstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou are playing the following game. There are n points on a plane. They are the vertices of a regular n-polygon. Points are labeled with integer numbers from 1 to n. Each pair of distinct points is connected by a diagonal, which is colored in one of 26 colors. Points are denoted by lowercase English letters. There are three stones positioned on three distinct vertices. All stones are the same. With one move you can move the stone to another free vertex along some diagonal. The color of this diagonal must be the same as the color of the diagonal, connecting another two stones. Your goal is to move stones in such way that the only vertices occupied by stones are 1, 2 and 3. You must achieve such position using minimal number of moves. Write a program which plays this game in an optimal way.InputIn the first line there is one integer n (3 ≤ n ≤ 70) — the number of points. In the second line there are three space-separated integer from 1 to n — numbers of vertices, where stones are initially located.Each of the following n lines contains n symbols — the matrix denoting the colors of the diagonals. Colors are denoted by lowercase English letters. The symbol j of line i denotes the color of diagonal between points i and j. Matrix is symmetric, so j-th symbol of i-th line is equal to i-th symbol of j-th line. Main diagonal is filled with '' symbols because there is no diagonal, connecting point to itself.OutputIf there is no way to put stones on vertices 1, 2 and 3, print -1 on a single line. Otherwise, on the first line print minimal required number of moves and in the next lines print the description of each move, one move per line. To describe a move print two integers. The point from which to remove the stone, and the point to which move the stone. If there are several optimal solutions, print any of them.ExamplesInput42 3 4abaaabbababbOutput14 1Input42 3 4abcaabbabcbb*Output-1NoteIn the first example we can move stone from point 4 to point 1 because this points are connected by the diagonal of color 'a' and the diagonal connection point 2 and 3, where the other stones are located, are connected by the diagonal of the same color. After that stones will be on the points 1, 2 and 3.	Input42 3 4abaaabbababb	Output14 1	2 seconds	256 megabytes	['dp', 'graphs', 'implementation', 'shortest paths', '*2100']
C. Diverse Substringstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputString diversity is the number of symbols that occur in the string at least once. Diversity of s will be denoted by d(s). For example , d("aaa")=1, d("abacaba")=3.Given a string s, consisting of lowercase Latin letters. Consider all its substrings. Obviously, any substring diversity is a number from 1 to d(s). Find statistics about substrings diversity: for each k from 1 to d(s), find how many substrings of s has a diversity of exactly k.InputThe input consists of a single line containing s. It contains only lowercase Latin letters, the length of s is from 1 to 3·105.OutputPrint to the first line the value d(s). Print sequence t1, t2, ..., td(s) to the following lines, where ti is the number of substrings of s having diversity of exactly i.ExamplesInputabcaOutput3433InputaabacaabbadOutput41419285NoteConsider the first example.We denote by s(i, j) a substring of "abca" with the indices in the segment [i, j]. s(1, 1) = "a", d("a") = 1 s(2, 2) = "b", d("b") = 1 s(3, 3) = "c", d("c") = 1 s(4, 4) = "a", d("a") = 1 s(1, 2) = "ab", d("ab") = 2 s(2, 3) = "bc", d("bc") = 2 s(3, 4) = "ca", d("ca") = 2 s(1, 3) = "abc", d("abc") = 3 s(2, 4) = "bca", d("bca") = 3 s(1, 4) = "abca", d("abca") = 3 Total number of substring with diversity 1 is 4, with diversity 2 equals 3, 3 diversity is 3.	Inputabca	Output3433	1 second	256 megabytes	['dp', 'strings', 'two pointers', '*2000']
B. Fly, freebies, fly!time limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputEveryone loves a freebie. Especially students.It is well-known that if in the night before exam a student opens window, opens the student's record-book and shouts loudly three times "Fly, freebie, fly!" — then flown freebie helps him to pass the upcoming exam.In the night before the exam on mathematical analysis n students living in dormitory shouted treasured words. The i-th student made a sacrament at the time ti, where ti is the number of seconds elapsed since the beginning of the night.It is known that the freebie is a capricious and willful lady. That night the freebie was near dormitory only for T seconds. Therefore, if for two students their sacrament times differ for more than T, then the freebie didn't visit at least one of them.Since all students are optimists, they really want to know what is the maximal number of students visited by the freebie can be.InputThe first line of the input contains integer n (1 ≤ n ≤ 100), where n — the number of students shouted "Fly, freebie, fly!" The second line contains n positive integers ti (1 ≤ ti ≤ 1000).The last line contains integer T (1 ≤ T ≤ 1000) — the time interval during which the freebie was near the dormitory.OutputPrint a single integer — the largest number of people who will pass exam tomorrow because of the freebie visit.ExamplesInput64 1 7 8 3 81Output3	Input64 1 7 8 3 81	Output3	1 second	256 megabytes	['binary search', 'brute force', 'implementation', '*1400']
A. Second-Price Auctiontime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputIn this problem we consider a special type of an auction, which is called the second-price auction. As in regular auction n bidders place a bid which is price a bidder ready to pay. The auction is closed, that is, each bidder secretly informs the organizer of the auction price he is willing to pay. After that, the auction winner is the participant who offered the highest price. However, he pay not the price he offers, but the highest price among the offers of other participants (hence the name: the second-price auction).Write a program that reads prices offered by bidders and finds the winner and the price he will pay. Consider that all of the offered prices are different.InputThe first line of the input contains n (2 ≤ n ≤ 1000) — number of bidders. The second line contains n distinct integer numbers p1, p2, ... pn, separated by single spaces (1 ≤ pi ≤ 10000), where pi stands for the price offered by the i-th bidder.OutputThe single output line should contain two integers: index of the winner and the price he will pay. Indices are 1-based.ExamplesInput25 7Output2 5Input310 2 8Output1 8Input63 8 2 9 4 14Output6 9	Input25 7	Output2 5	1 second	256 megabytes	['implementation', '*800']
E. Bear in the Fieldtime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputOur bear's forest has a checkered field. The checkered field is an n × n table, the rows are numbered from 1 to n from top to bottom, the columns are numbered from 1 to n from left to right. Let's denote a cell of the field on the intersection of row x and column y by record (x, y). Each cell of the field contains growing raspberry, at that, the cell (x, y) of the field contains x + y raspberry bushes.The bear came out to walk across the field. At the beginning of the walk his speed is (dx, dy). Then the bear spends exactly t seconds on the field. Each second the following takes place: Let's suppose that at the current moment the bear is in cell (x, y). First the bear eats the raspberry from all the bushes he has in the current cell. After the bear eats the raspberry from k bushes, he increases each component of his speed by k. In other words, if before eating the k bushes of raspberry his speed was (dx, dy), then after eating the berry his speed equals (dx + k, dy + k). Let's denote the current speed of the bear (dx, dy) (it was increased after the previous step). Then the bear moves from cell (x, y) to cell (((x + dx - 1) mod n) + 1, ((y + dy - 1) mod n) + 1). Then one additional raspberry bush grows in each cell of the field. You task is to predict the bear's actions. Find the cell he ends up in if he starts from cell (sx, sy). Assume that each bush has infinitely much raspberry and the bear will never eat all of it.InputThe first line of the input contains six space-separated integers: n, sx, sy, dx, dy, t (1 ≤ n ≤ 109; 1 ≤ sx, sy ≤ n; - 100 ≤ dx, dy ≤ 100; 0 ≤ t ≤ 1018).OutputPrint two integers — the coordinates of the cell the bear will end up in after t seconds.ExamplesInput5 1 2 0 1 2Output3 1Input1 1 1 -1 -1 2Output1 1NoteOperation a mod b means taking the remainder after dividing a by b. Note that the result of the operation is always non-negative. For example, ( - 1) mod 3 = 2.In the first sample before the first move the speed vector will equal (3,4) and the bear will get to cell (4,1). Before the second move the speed vector will equal (9,10) and he bear will get to cell (3,1). Don't forget that at the second move, the number of berry bushes increased by 1.In the second sample before the first move the speed vector will equal (1,1) and the bear will get to cell (1,1). Before the second move, the speed vector will equal (4,4) and the bear will get to cell (1,1). Don't forget that at the second move, the number of berry bushes increased by 1.	Input5 1 2 0 1 2	Output3 1	1 second	256 megabytes	['math', 'matrices', '*2300']
D. Bear and Floodlighttime limit per test4 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputOne day a bear lived on the Oxy axis. He was afraid of the dark, so he couldn't move at night along the plane points that aren't lit. One day the bear wanted to have a night walk from his house at point (l, 0) to his friend's house at point (r, 0), along the segment of length (r - l). Of course, if he wants to make this walk, he needs each point of the segment to be lit. That's why the bear called his friend (and yes, in the middle of the night) asking for a very delicate favor.The Oxy axis contains n floodlights. Floodlight i is at point (xi, yi) and can light any angle of the plane as large as ai degree with vertex at point (xi, yi). The bear asked his friend to turn the floodlights so that he (the bear) could go as far away from his house as possible during the walking along the segment. His kind friend agreed to fulfill his request. And while he is at it, the bear wonders: what is the furthest he can go away from his house? Hep him and find this distance.Consider that the plane has no obstacles and no other light sources besides the floodlights. The bear's friend cannot turn the floodlights during the bear's walk. Assume that after all the floodlights are turned in the correct direction, the bear goes for a walk and his friend goes to bed.InputThe first line contains three space-separated integers n, l, r (1 ≤ n ≤ 20; - 105 ≤ l ≤ r ≤ 105). The i-th of the next n lines contain three space-separated integers xi, yi, ai ( - 1000 ≤ xi ≤ 1000; 1 ≤ yi ≤ 1000; 1 ≤ ai ≤ 90) — the floodlights' description. Note that two floodlights can be at the same point of the plane.OutputPrint a single real number — the answer to the problem. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.ExamplesInput2 3 53 1 455 1 45Output2.000000000Input1 0 11 1 30Output0.732050808Input1 0 11 1 45Output1.000000000Input1 0 20 2 90Output2.000000000NoteIn the first sample, one of the possible solutions is: In the second sample, a single solution is: In the third sample, a single solution is:	Input2 3 53 1 455 1 45	Output2.000000000	4 seconds	256 megabytes	['bitmasks', 'dp', 'geometry', '*2200']
C. Bear and Prime Numberstime limit per test2 secondsmemory limit per test512 megabytesinputstandard inputoutputstandard outputRecently, the bear started studying data structures and faced the following problem.You are given a sequence of integers x1, x2, ..., xn of length n and m queries, each of them is characterized by two integers li, ri. Let's introduce f(p) to represent the number of such indexes k, that xk is divisible by p. The answer to the query li, ri is the sum: , where S(li, ri) is a set of prime numbers from segment [li, ri] (both borders are included in the segment).Help the bear cope with the problem.InputThe first line contains integer n (1 ≤ n ≤ 106). The second line contains n integers x1, x2, ..., xn (2 ≤ xi ≤ 107). The numbers are not necessarily distinct.The third line contains integer m (1 ≤ m ≤ 50000). Each of the following m lines contains a pair of space-separated integers, li and ri (2 ≤ li ≤ ri ≤ 2·109) — the numbers that characterize the current query.OutputPrint m integers — the answers to the queries on the order the queries appear in the input.ExamplesInput65 5 7 10 14 1532 113 124 4Output970Input72 3 5 7 11 4 828 102 123Output07NoteConsider the first sample. Overall, the first sample has 3 queries. The first query l = 2, r = 11 comes. You need to count f(2) + f(3) + f(5) + f(7) + f(11) = 2 + 1 + 4 + 2 + 0 = 9. The second query comes l = 3, r = 12. You need to count f(3) + f(5) + f(7) + f(11) = 1 + 4 + 2 + 0 = 7. The third query comes l = 4, r = 4. As this interval has no prime numbers, then the sum equals 0.	Input65 5 7 10 14 1532 113 124 4	Output970	2 seconds	512 megabytes	['binary search', 'brute force', 'data structures', 'dp', 'implementation', 'math', 'number theory', '*1700']
B. Bear and Stringstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe bear has a string s = s1s2... s\|s\| (record \|s\| is the string's length), consisting of lowercase English letters. The bear wants to count the number of such pairs of indices i, j (1 ≤ i ≤ j ≤ \|s\|), that string x(i, j) = sisi + 1... sj contains at least one string "bear" as a substring.String x(i, j) contains string "bear", if there is such index k (i ≤ k ≤ j - 3), that sk = b, sk + 1 = e, sk + 2 = a, sk + 3 = r.Help the bear cope with the given problem.InputThe first line contains a non-empty string s (1 ≤ \|s\| ≤ 5000). It is guaranteed that the string only consists of lowercase English letters.OutputPrint a single number — the answer to the problem.ExamplesInputbearbtearOutput6InputbearaabearcOutput20NoteIn the first sample, the following pairs (i, j) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9).In the second sample, the following pairs (i, j) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (2, 10), (2, 11), (3, 10), (3, 11), (4, 10), (4, 11), (5, 10), (5, 11), (6, 10), (6, 11), (7, 10), (7, 11).	Inputbearbtear	Output6	1 second	256 megabytes	['brute force', 'greedy', 'implementation', 'math', 'strings', '*1200']
A. Bear and Raspberrytime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe bear decided to store some raspberry for the winter. He cunningly found out the price for a barrel of honey in kilos of raspberry for each of the following n days. According to the bear's data, on the i-th (1 ≤ i ≤ n) day, the price for one barrel of honey is going to is xi kilos of raspberry.Unfortunately, the bear has neither a honey barrel, nor the raspberry. At the same time, the bear's got a friend who is ready to lend him a barrel of honey for exactly one day for c kilograms of raspberry. That's why the bear came up with a smart plan. He wants to choose some day d (1 ≤ d < n), lent a barrel of honey and immediately (on day d) sell it according to a daily exchange rate. The next day (d + 1) the bear wants to buy a new barrel of honey according to a daily exchange rate (as he's got some raspberry left from selling the previous barrel) and immediately (on day d + 1) give his friend the borrowed barrel of honey as well as c kilograms of raspberry for renting the barrel.The bear wants to execute his plan at most once and then hibernate. What maximum number of kilograms of raspberry can he earn? Note that if at some point of the plan the bear runs out of the raspberry, then he won't execute such a plan.InputThe first line contains two space-separated integers, n and c (2 ≤ n ≤ 100, 0 ≤ c ≤ 100), — the number of days and the number of kilos of raspberry that the bear should give for borrowing the barrel.The second line contains n space-separated integers x1, x2, ..., xn (0 ≤ xi ≤ 100), the price of a honey barrel on day i.OutputPrint a single integer — the answer to the problem.ExamplesInput5 15 10 7 3 20Output3Input6 2100 1 10 40 10 40Output97Input3 01 2 3Output0NoteIn the first sample the bear will lend a honey barrel at day 3 and then sell it for 7. Then the bear will buy a barrel for 3 and return it to the friend. So, the profit is (7 - 3 - 1) = 3.In the second sample bear will lend a honey barrel at day 1 and then sell it for 100. Then the bear buy the barrel for 1 at the day 2. So, the profit is (100 - 1 - 2) = 97.	Input5 15 10 7 3 20	Output3	1 second	256 megabytes	['brute force', 'greedy', 'implementation', '*1000']
B. Multitaskingtime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputIahub wants to enhance his multitasking abilities. In order to do this, he wants to sort n arrays simultaneously, each array consisting of m integers.Iahub can choose a pair of distinct indices i and j (1 ≤ i, j ≤ m, i ≠ j). Then in each array the values at positions i and j are swapped only if the value at position i is strictly greater than the value at position j.Iahub wants to find an array of pairs of distinct indices that, chosen in order, sort all of the n arrays in ascending or descending order (the particular order is given in input). The size of the array can be at most (at most pairs). Help Iahub, find any suitable array.InputThe first line contains three integers n (1 ≤ n ≤ 1000), m (1 ≤ m ≤ 100) and k. Integer k is 0 if the arrays must be sorted in ascending order, and 1 if the arrays must be sorted in descending order. Each line i of the next n lines contains m integers separated by a space, representing the i-th array. For each element x of the array i, 1 ≤ x ≤ 106 holds.OutputOn the first line of the output print an integer p, the size of the array (p can be at most ). Each of the next p lines must contain two distinct integers i and j (1 ≤ i, j ≤ m, i ≠ j), representing the chosen indices.If there are multiple correct answers, you can print any.ExamplesInput2 5 01 3 2 5 41 4 3 2 5Output32 42 34 5Input3 2 11 22 33 4Output12 1NoteConsider the first sample. After the first operation, the arrays become [1, 3, 2, 5, 4] and [1, 2, 3, 4, 5]. After the second operation, the arrays become [1, 2, 3, 5, 4] and [1, 2, 3, 4, 5]. After the third operation they become [1, 2, 3, 4, 5] and [1, 2, 3, 4, 5].	Input2 5 01 3 2 5 41 4 3 2 5	Output32 42 34 5	1 second	256 megabytes	['greedy', 'implementation', 'sortings', 'two pointers', '*1500']
A. Codertime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputIahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Coders can be placed on an n × n chessboard, so that no Coder attacks any other Coder.InputThe first line contains an integer n (1 ≤ n ≤ 1000).OutputOn the first line print an integer, the maximum number of Coders that can be placed on the chessboard.On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'.If there are multiple correct answers, you can print any.ExamplesInput2Output2C..C	Input2	Output2C..C	1 second	256 megabytes	['implementation', '*800']
E. Vowelstime limit per test4 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputIahubina is tired of so many complicated languages, so she decided to invent a new, simple language. She already made a dictionary consisting of n 3-words. A 3-word is a sequence of exactly 3 lowercase letters of the first 24 letters of the English alphabet (a to x). She decided that some of the letters are vowels, and all the others are consonants. The whole language is based on a simple rule: any word that contains at least one vowel is correct.Iahubina forgot which letters are the vowels, and wants to find some possible correct sets of vowels. She asks Iahub questions. In each question, she will give Iahub a set of letters considered vowels (in this question). For each question she wants to know how many words of the dictionary are correct, considering the given set of vowels.Iahubina wants to know the xor of the squared answers to all the possible questions. There are 224 different questions, they are all subsets of the set of the first 24 letters of the English alphabet. Help Iahub find that number.InputThe first line contains one integer, n (1 ≤ n ≤ 104). Each of the next n lines contains a 3-word consisting of 3 lowercase letters. There will be no two identical 3-words.OutputPrint one number, the xor of the squared answers to the queries.ExamplesInput5abcaaaadabcddefOutput0	Input5abcaaaadabcddef	Output0	4 seconds	256 megabytes	['combinatorics', 'divide and conquer', 'dp', '*2700']
D. Antimattertime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputIahub accidentally discovered a secret lab. He found there n devices ordered in a line, numbered from 1 to n from left to right. Each device i (1 ≤ i ≤ n) can create either ai units of matter or ai units of antimatter. Iahub wants to choose some contiguous subarray of devices in the lab, specify the production mode for each of them (produce matter or antimatter) and finally take a photo of it. However he will be successful only if the amounts of matter and antimatter produced in the selected subarray will be the same (otherwise there would be overflowing matter or antimatter in the photo). You are requested to compute the number of different ways Iahub can successful take a photo. A photo is different than another if it represents another subarray, or if at least one device of the subarray is set to produce matter in one of the photos and antimatter in the other one.InputThe first line contains an integer n (1 ≤ n ≤ 1000). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1000).The sum a1 + a2 + ... + an will be less than or equal to 10000.OutputOutput a single integer, the number of ways Iahub can take a photo, modulo 1000000007 (109 + 7).ExamplesInput41 1 1 1Output12NoteThe possible photos are [1+, 2-], [1-, 2+], [2+, 3-], [2-, 3+], [3+, 4-], [3-, 4+], [1+, 2+, 3-, 4-], [1+, 2-, 3+, 4-], [1+, 2-, 3-, 4+], [1-, 2+, 3+, 4-], [1-, 2+, 3-, 4+] and [1-, 2-, 3+, 4+], where "i+" means that the i-th element produces matter, and "i-" means that the i-th element produces antimatter.	Input41 1 1 1	Output12	1 second	256 megabytes	['dp', '*2300']
C. Propagating treetime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputIahub likes trees very much. Recently he discovered an interesting tree named propagating tree. The tree consists of n nodes numbered from 1 to n, each node i having an initial value ai. The root of the tree is node 1.This tree has a special property: when a value val is added to a value of node i, the value -val is added to values of all the children of node i. Note that when you add value -val to a child of node i, you also add -(-val) to all children of the child of node i and so on. Look an example explanation to understand better how it works.This tree supports two types of queries: "1 x val" — val is added to the value of node x; "2 x" — print the current value of node x. In order to help Iahub understand the tree better, you must answer m queries of the preceding type.InputThe first line contains two integers n and m (1 ≤ n, m ≤ 200000). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1000). Each of the next n–1 lines contains two integers vi and ui (1 ≤ vi, ui ≤ n), meaning that there is an edge between nodes vi and ui.Each of the next m lines contains a query in the format described above. It is guaranteed that the following constraints hold for all queries: 1 ≤ x ≤ n, 1 ≤ val ≤ 1000.OutputFor each query of type two (print the value of node x) you must print the answer to the query on a separate line. The queries must be answered in the order given in the input.ExamplesInput5 51 2 1 1 21 21 32 42 51 2 31 1 22 12 22 4Output330NoteThe values of the nodes are [1, 2, 1, 1, 2] at the beginning.Then value 3 is added to node 2. It propagates and value -3 is added to it's sons, node 4 and node 5. Then it cannot propagate any more. So the values of the nodes are [1, 5, 1, - 2, - 1].Then value 2 is added to node 1. It propagates and value -2 is added to it's sons, node 2 and node 3. From node 2 it propagates again, adding value 2 to it's sons, node 4 and node 5. Node 3 has no sons, so it cannot propagate from there. The values of the nodes are [3, 3, - 1, 0, 1].You can see all the definitions about the tree at the following link: http://en.wikipedia.org/wiki/Tree_(graph_theory)	Input5 51 2 1 1 21 21 32 42 51 2 31 1 22 12 22 4	Output330	2 seconds	256 megabytes	['data structures', 'dfs and similar', 'trees', '*2000']
B. Volcanoestime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputIahub got lost in a very big desert. The desert can be represented as a n × n square matrix, where each cell is a zone of the desert. The cell (i, j) represents the cell at row i and column j (1 ≤ i, j ≤ n). Iahub can go from one cell (i, j) only down or right, that is to cells (i + 1, j) or (i, j + 1). Also, there are m cells that are occupied by volcanoes, which Iahub cannot enter. Iahub is initially at cell (1, 1) and he needs to travel to cell (n, n). Knowing that Iahub needs 1 second to travel from one cell to another, find the minimum time in which he can arrive in cell (n, n).InputThe first line contains two integers n (1 ≤ n ≤ 109) and m (1 ≤ m ≤ 105). Each of the next m lines contains a pair of integers, x and y (1 ≤ x, y ≤ n), representing the coordinates of the volcanoes.Consider matrix rows are numbered from 1 to n from top to bottom, and matrix columns are numbered from 1 to n from left to right. There is no volcano in cell (1, 1). No two volcanoes occupy the same location. OutputPrint one integer, the minimum time in which Iahub can arrive at cell (n, n). If no solution exists (there is no path to the final cell), print -1.ExamplesInput4 21 31 4Output6Input7 81 62 63 53 64 35 15 25 3Output12Input2 21 22 1Output-1NoteConsider the first sample. A possible road is: (1, 1) → (1, 2) → (2, 2) → (2, 3) → (3, 3) → (3, 4) → (4, 4).	Input4 21 31 4	Output6	1 second	256 megabytes	['binary search', 'implementation', 'sortings', 'two pointers', '*2500']
A. Milking cowstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputIahub helps his grandfather at the farm. Today he must milk the cows. There are n cows sitting in a row, numbered from 1 to n from left to right. Each cow is either facing to the left or facing to the right. When Iahub milks a cow, all the cows that see the current cow get scared and lose one unit of the quantity of milk that they can give. A cow facing left sees all the cows with lower indices than her index, and a cow facing right sees all the cows with higher indices than her index. A cow that got scared once can get scared again (and lose one more unit of milk). A cow that has been milked once cannot get scared and lose any more milk. You can assume that a cow never loses all the milk she can give (a cow gives an infinitely amount of milk).Iahub can decide the order in which he milks the cows. But he must milk each cow exactly once. Iahub wants to lose as little milk as possible. Print the minimum amount of milk that is lost.InputThe first line contains an integer n (1 ≤ n ≤ 200000). The second line contains n integers a1, a2, ..., an, where ai is 0 if the cow number i is facing left, and 1 if it is facing right.OutputPrint a single integer, the minimum amount of lost milk.Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.ExamplesInput40 0 1 0Output1Input51 0 1 0 1Output3NoteIn the first sample Iahub milks the cows in the following order: cow 3, cow 4, cow 2, cow 1. When he milks cow 3, cow 4 loses 1 unit of milk. After that, no more milk is lost.	Input40 0 1 0	Output1	1 second	256 megabytes	['data structures', 'greedy', '*1600']
E. Ksenia and Combinatoricstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputKsenia has her winter exams. Today she is learning combinatorics. Here's one of the problems she needs to learn to solve.How many distinct trees are there consisting of n vertices, each with the following properties: the tree is marked, that is, the vertices of the tree are numbered from 1 to n; each vertex of the tree is connected with at most three other vertices, and at the same moment the vertex with number 1 is connected with at most two other vertices; the size of the tree's maximum matching equals k. Two trees are considered distinct if there are such two vertices u and v, that in one tree they are connected by an edge and in the other tree they are not.Help Ksenia solve the problem for the given n and k. As the answer to the problem can be very huge you should output it modulo 1000000007 (109 + 7).InputThe first line contains two integers n, k (1 ≤ n, k ≤ 50).OutputPrint a single integer — the answer to the problem modulo 1000000007 (109 + 7).ExamplesInput1 1Output0Input2 1Output1Input3 1Output3Input4 2Output12NoteIf you aren't familiar with matchings, please, read the following link: http://en.wikipedia.org/wiki/Matching_(graph_theory).	Input1 1	Output0	1 second	256 megabytes	['combinatorics', 'dp', '*2600']
D. Ksenia and Pawnstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputKsenia has a chessboard of size n × m. Each cell of the chessboard contains one of the characters: "<", ">", "^", "v", "#". The cells that contain character "#" are blocked. We know that all chessboard cells that touch the border are blocked.Ksenia is playing with two pawns on this chessboard. Initially, she puts the pawns on the chessboard. One cell of the chessboard can contain two pawns if and only if the cell is blocked. In other cases two pawns can not stand in one cell. The game begins when Ksenia put pawns on the board. In one move, Ksenia moves each pawn to a side adjacent cell in the direction of arrows painted on the cell on which the corresponding pawn sits (if the pawn sits on "#", it does not move). Assume that Ksenia moves pawns simultaneously (see the second test case). Of course, Ksenia plays for points. How can one calculate the points per game? Very simply! Let's count how many movements the first pawn made and how many movements the second pawn made, sum these two numbers — it will be the resulting score of the game. Ksenia wonders: what is the maximum number of points she can earn (for that, she should place the pawns optimally well early in the game). Help her and find that number. InputThe first line contains two integers, n and m (1 ≤ n, m ≤ 2000) — the sizes of the board. Each of the following n lines contains m characters – the board's description. Each character is one of the characters: "<", ">", "^", "v", "#".It is guaranteed that the border cells of the table are blocked cells (with character "#").OutputIf Ksenia can get infinitely many points, print -1. Otherwise, print the maximum number of points she can get.ExamplesInput1 1#Output0Input3 4#####>^#####Output3Input3 4#####><#####Output-1Input7 5#######v####v#########^####^#######Output4Input7 5#######v####v####<####^####^#######Output5	Input1 1#	Output0	2 seconds	256 megabytes	['dfs and similar', 'graphs', 'implementation', 'trees', '*2200']
C. Arithmetic Progressiontime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputEverybody knows what an arithmetic progression is. Let us remind you just in case that an arithmetic progression is such sequence of numbers a1, a2, ..., an of length n, that the following condition fulfills: a2 - a1 = a3 - a2 = a4 - a3 = ... = ai + 1 - ai = ... = an - an - 1.For example, sequences [1, 5], [10], [5, 4, 3] are arithmetic progressions and sequences [1, 3, 2], [1, 2, 4] are not.Alexander has n cards containing integers. Arthur wants to give Alexander exactly one more card with a number so that he could use the resulting n + 1 cards to make an arithmetic progression (Alexander has to use all of his cards).Arthur has already bought a card but he hasn't written a number on it. Help him, print all integers that you can write on a card so that the described condition fulfilled.InputThe first line contains integer n (1 ≤ n ≤ 105) — the number of cards. The next line contains the sequence of integers — the numbers on Alexander's cards. The numbers are positive integers, each of them doesn't exceed 108.OutputIf Arthur can write infinitely many distinct integers on the card, print on a single line -1.Otherwise, print on the first line the number of integers that suit you. In the second line, print the numbers in the increasing order. Note that the numbers in the answer can exceed 108 or even be negative (see test samples).ExamplesInput34 1 7Output2-2 10Input110Output-1Input41 3 5 9Output17Input44 3 4 5Output0Input22 4Output30 3 6	Input34 1 7	Output2-2 10	1 second	256 megabytes	['implementation', 'sortings', '*1700']
B. Number Busterstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputArthur and Alexander are number busters. Today they've got a competition. Arthur took a group of four integers a, b, w, x (0 ≤ b < w, 0 < x < w) and Alexander took integer с. Arthur and Alexander use distinct approaches to number bustings. Alexander is just a regular guy. Each second, he subtracts one from his number. In other words, he performs the assignment: c = c - 1. Arthur is a sophisticated guy. Each second Arthur performs a complex operation, described as follows: if b ≥ x, perform the assignment b = b - x, if b < x, then perform two consecutive assignments a = a - 1; b = w - (x - b).You've got numbers a, b, w, x, c. Determine when Alexander gets ahead of Arthur if both guys start performing the operations at the same time. Assume that Alexander got ahead of Arthur if c ≤ a.InputThe first line contains integers a, b, w, x, c (1 ≤ a ≤ 2·109, 1 ≤ w ≤ 1000, 0 ≤ b < w, 0 < x < w, 1 ≤ c ≤ 2·109).OutputPrint a single integer — the minimum time in seconds Alexander needs to get ahead of Arthur. You can prove that the described situation always occurs within the problem's limits.ExamplesInput4 2 3 1 6Output2Input4 2 3 1 7Output4Input1 2 3 2 6Output13Input1 1 2 1 1Output0	Input4 2 3 1 6	Output2	1 second	256 megabytes	['binary search', 'math', '*2000']
A. Ksenia and Pan Scalestime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputKsenia has ordinary pan scales and several weights of an equal mass. Ksenia has already put some weights on the scales, while other weights are untouched. Ksenia is now wondering whether it is possible to put all the remaining weights on the scales so that the scales were in equilibrium. The scales is in equilibrium if the total sum of weights on the left pan is equal to the total sum of weights on the right pan.InputThe first line has a non-empty sequence of characters describing the scales. In this sequence, an uppercase English letter indicates a weight, and the symbol "\|" indicates the delimiter (the character occurs in the sequence exactly once). All weights that are recorded in the sequence before the delimiter are initially on the left pan of the scale. All weights that are recorded in the sequence after the delimiter are initially on the right pan of the scale. The second line contains a non-empty sequence containing uppercase English letters. Each letter indicates a weight which is not used yet. It is guaranteed that all the English letters in the input data are different. It is guaranteed that the input does not contain any extra characters.OutputIf you cannot put all the weights on the scales so that the scales were in equilibrium, print string "Impossible". Otherwise, print the description of the resulting scales, copy the format of the input.If there are multiple answers, print any of them.ExamplesInputAC\|TLOutputAC\|TLInput\|ABCXYZOutputXYZ\|ABCInputW\|TFOutputImpossibleInputABC\|DOutputImpossible	InputAC\|TL	OutputAC\|TL	1 second	256 megabytes	['greedy', 'implementation', '*1100']
B. Sereja and Stairstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputSereja loves integer sequences very much. He especially likes stairs.Sequence a1, a2, ..., a\|a\| (\|a\| is the length of the sequence) is stairs if there is such index i (1 ≤ i ≤ \|a\|), that the following condition is met: a1 < a2 < ... < ai - 1 < ai > ai + 1 > ... > a\|a\| - 1 > a\|a\|.For example, sequences [1, 2, 3, 2] and [4, 2] are stairs and sequence [3, 1, 2] isn't.Sereja has m cards with numbers. He wants to put some cards on the table in a row to get a stair sequence. What maximum number of cards can he put on the table?InputThe first line contains integer m (1 ≤ m ≤ 105) — the number of Sereja's cards. The second line contains m integers bi (1 ≤ bi ≤ 5000) — the numbers on the Sereja's cards.OutputIn the first line print the number of cards you can put on the table. In the second line print the resulting stairs.ExamplesInput51 2 3 4 5Output55 4 3 2 1Input61 1 2 2 3 3Output51 2 3 2 1	Input51 2 3 4 5	Output55 4 3 2 1	1 second	256 megabytes	['greedy', 'implementation', 'sortings', '*1100']
A. Sereja and Dimatime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputSereja and Dima play a game. The rules of the game are very simple. The players have n cards in a row. Each card contains a number, all numbers on the cards are distinct. The players take turns, Sereja moves first. During his turn a player can take one card: either the leftmost card in a row, or the rightmost one. The game ends when there is no more cards. The player who has the maximum sum of numbers on his cards by the end of the game, wins.Sereja and Dima are being greedy. Each of them chooses the card with the larger number during his move.Inna is a friend of Sereja and Dima. She knows which strategy the guys are using, so she wants to determine the final score, given the initial state of the game. Help her.InputThe first line contains integer n (1 ≤ n ≤ 1000) — the number of cards on the table. The second line contains space-separated numbers on the cards from left to right. The numbers on the cards are distinct integers from 1 to 1000.OutputOn a single line, print two integers. The first number is the number of Sereja's points at the end of the game, the second number is the number of Dima's points at the end of the game.ExamplesInput44 1 2 10Output12 5Input71 2 3 4 5 6 7Output16 12NoteIn the first sample Sereja will take cards with numbers 10 and 2, so Sereja's sum is 12. Dima will take cards with numbers 4 and 1, so Dima's sum is 5.	Input44 1 2 10	Output12 5	1 second	256 megabytes	['greedy', 'implementation', 'two pointers', '*800']
E. Sereja and Dividingtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLet's assume that we have a sequence of doubles a1, a2, ..., a\|a\| and a double variable x. You are allowed to perform the following two-staged operation: choose an index of the sequence element i (1 ≤ i ≤ \|a\|); consecutively perform assignments: . Let's use function g(a, x) to represent the largest value that can be obtained from variable x, using the described operation any number of times and sequence a.Sereja has sequence b1, b2, ..., b\|b\|. Help Sereja calculate sum: . Record [bi, bi + 1, ..., bj] represents a sequence containing the elements in brackets in the given order. To avoid problems with precision, please, print the required sum divided by \|b\|2.InputThe first line contains integer \|b\| (1 ≤ \|b\| ≤ 3·105) — the length of sequence b. The second line contains \|b\| integers b1, b2, ..., b\|b\| (1 ≤ bi ≤ 105).OutputIn a single line print a real number — the required sum divided by \|b\|2. Your answer will be considered correct if its absolute or relative error won't exceed 10 - 6.ExamplesInput51 2 3 4 1Output1.238750000000000	Input51 2 3 4 1	Output1.238750000000000	2 seconds	256 megabytes	['data structures', '*2600']
D. Sereja and Cinematime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe cinema theater hall in Sereja's city is n seats lined up in front of one large screen. There are slots for personal possessions to the left and to the right of each seat. Any two adjacent seats have exactly one shared slot. The figure below shows the arrangement of seats and slots for n = 4. Today it's the premiere of a movie called "Dry Hard". The tickets for all the seats have been sold. There is a very strict controller at the entrance to the theater, so all n people will come into the hall one by one. As soon as a person enters a cinema hall, he immediately (momentarily) takes his seat and occupies all empty slots to the left and to the right from him. If there are no empty slots, the man gets really upset and leaves.People are not very constant, so it's hard to predict the order in which the viewers will enter the hall. For some seats, Sereja knows the number of the viewer (his number in the entering queue of the viewers) that will come and take this seat. For others, it can be any order. Being a programmer and a mathematician, Sereja wonders: how many ways are there for the people to enter the hall, such that nobody gets upset? As the number can be quite large, print it modulo 1000000007 (109 + 7).InputThe first line contains integer n (1 ≤ n ≤ 105). The second line contains n integers, the i-th integer shows either the index of the person (index in the entering queue) with the ticket for the i-th seat or a 0, if his index is not known. It is guaranteed that all positive numbers in the second line are distinct.You can assume that the index of the person who enters the cinema hall is a unique integer from 1 to n. The person who has index 1 comes first to the hall, the person who has index 2 comes second and so on.OutputIn a single line print the remainder after dividing the answer by number 1000000007 (109 + 7).ExamplesInput110 0 0 0 0 0 0 0 0 0 0Output1024Input60 3 1 0 0 0Output3	Input110 0 0 0 0 0 0 0 0 0 0	Output1024	1 second	256 megabytes	['combinatorics', 'math', '*2500']
C. Sereja and Bracketstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputSereja has a bracket sequence s1, s2, ..., sn, or, in other words, a string s of length n, consisting of characters "(" and ")".Sereja needs to answer m queries, each of them is described by two integers li, ri (1 ≤ li ≤ ri ≤ n). The answer to the i-th query is the length of the maximum correct bracket subsequence of sequence sli, sli + 1, ..., sri. Help Sereja answer all queries.You can find the definitions for a subsequence and a correct bracket sequence in the notes.InputThe first line contains a sequence of characters s1, s2, ..., sn (1 ≤ n ≤ 106) without any spaces. Each character is either a "(" or a ")". The second line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains a pair of integers. The i-th line contains integers li, ri (1 ≤ li ≤ ri ≤ n) — the description of the i-th query.OutputPrint the answer to each question on a single line. Print the answers in the order they go in the input.ExamplesInput())(())(())(71 12 31 21 128 125 112 10Output00210466NoteA subsequence of length \|x\| of string s = s1s2... s\|s\| (where \|s\| is the length of string s) is string x = sk1sk2... sk\|x\| (1 ≤ k1 < k2 < ... < k\|x\| ≤ \|s\|).A correct bracket sequence is a bracket sequence that can be transformed into a correct aryphmetic expression by inserting characters "1" and "+" between the characters of the string. For example, bracket sequences "()()", "(())" are correct (the resulting expressions "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.For the third query required sequence will be «()».For the fourth query required sequence will be «()(())(())».	Input())(())(())(71 12 31 21 128 125 112 10	Output00210466	1 second	256 megabytes	['data structures', 'schedules', '*2000']
B. Sereja and Treetime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputSereja adores trees. Today he came up with a revolutionary new type of binary root trees.His new tree consists of n levels, each vertex is indexed by two integers: the number of the level and the number of the vertex on the current level. The tree root is at level 1, its index is (1, 1). Here is a pseudo code of tree construction.//the global data are integer arrays cnt[], left[][], right[][]cnt[1] = 1;fill arrays left[][], right[][] with values -1;for(level = 1; level < n; level = level + 1){ cnt[level + 1] = 0; for(position = 1; position <= cnt[level]; position = position + 1){ if(the value of position is a power of two){ // that is, 1, 2, 4, 8... left[level][position] = cnt[level + 1] + 1; right[level][position] = cnt[level + 1] + 2; cnt[level + 1] = cnt[level + 1] + 2; }else{ right[level][position] = cnt[level + 1] + 1; cnt[level + 1] = cnt[level + 1] + 1; } }}After the pseudo code is run, cell cnt[level] contains the number of vertices on level level. Cell left[level][position] contains the number of the vertex on the level level + 1, which is the left child of the vertex with index (level, position), or it contains -1, if the vertex doesn't have a left child. Similarly, cell right[level][position] is responsible for the right child. You can see how the tree with n = 4 looks like in the notes.Serja loves to make things complicated, so he first made a tree and then added an empty set A(level, position) for each vertex. Then Sereja executes m operations. Each operation is of one of the two following types: The format of the operation is "1 t l r x". For all vertices level, position (level = t; l ≤ position ≤ r) add value x to set A(level, position). The format of the operation is "2 t v". For vertex level, position (level = t, position = v), find the union of all sets of vertices that are in the subtree of vertex (level, position). Print the size of the union of these sets. Help Sereja execute the operations. In this problem a set contains only distinct values like std::set in C++.InputThe first line contains integers n and m (1 ≤ n, m ≤ 7000). Next m lines contain the descriptions of the operations. The operation of the first type is given by five integers: 1 t l r x (1 ≤ t ≤ n; 1 ≤ l ≤ r ≤ cnt[t]; 1 ≤ x ≤ 106). The operation of the second type is given by three integers: 2 t v (1 ≤ t ≤ n; 1 ≤ v ≤ cnt[t]).OutputFor each operation of the second type, print the answer on a single line.ExamplesInput4 51 4 4 7 11 3 1 2 22 1 12 4 12 3 3Output201NoteYou can find the definitions that are used while working with root trees by this link: http://en.wikipedia.org/wiki/Tree_(graph_theory)You can see an example of a constructed tree at n = 4 below.	Input4 51 4 4 7 11 3 1 2 22 1 12 4 12 3 3	Output201	2 seconds	256 megabytes	['graphs', 'implementation', '*2400']
A. Sereja and Prefixestime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputSereja loves number sequences very much. That's why he decided to make himself a new one following a certain algorithm.Sereja takes a blank piece of paper. Then he starts writing out the sequence in m stages. Each time he either adds a new number to the end of the sequence or takes l first elements of the current sequence and adds them c times to the end. More formally, if we represent the current sequence as a1, a2, ..., an, then after we apply the described operation, the sequence transforms into a1, a2, ..., an[, a1, a2, ..., al] (the block in the square brackets must be repeated c times). A day has passed and Sereja has completed the sequence. He wonders what are the values of some of its elements. Help Sereja.InputThe first line contains integer m (1 ≤ m ≤ 105) — the number of stages to build a sequence. Next m lines contain the description of the stages in the order they follow. The first number in the line is a type of stage (1 or 2). Type 1 means adding one number to the end of the sequence, in this case the line contains integer xi (1 ≤ xi ≤ 105) — the number to add. Type 2 means copying a prefix of length li to the end ci times, in this case the line further contains two integers li, ci (1 ≤ li ≤ 105, 1 ≤ ci ≤ 104), li is the length of the prefix, ci is the number of copyings. It is guaranteed that the length of prefix li is never larger than the current length of the sequence.The next line contains integer n (1 ≤ n ≤ 105) — the number of elements Sereja is interested in. The next line contains the numbers of elements of the final sequence Sereja is interested in. The numbers are given in the strictly increasing order. It is guaranteed that all numbers are strictly larger than zero and do not exceed the length of the resulting sequence. Consider the elements of the final sequence numbered starting from 1 from the beginning to the end of the sequence.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.OutputPrint the elements that Sereja is interested in, in the order in which their numbers occur in the input. ExamplesInput61 11 22 2 11 32 5 21 4161 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16Output1 2 1 2 3 1 2 1 2 3 1 2 1 2 3 4	Input61 11 22 2 11 32 5 21 4161 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	Output1 2 1 2 3 1 2 1 2 3 1 2 1 2 3 4	1 second	256 megabytes	['binary search', 'brute force', '*1600']
G. New Year Cactustime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputJack and Jill are tired of the New Year tree, now they've got a New Year cactus at home! A cactus is a connected undirected graph where any two simple cycles have at most one common vertex. In other words, this graph doesn't have any edges that lie on more than one simple cycle.On the 31st of December they are going to decorate the cactus by hanging toys to its vertices. At most one toy is going to hang on each vertex — it's either the toy Jack hung or the toy Jill hung. It's possible for a vertex to have no toys.Jack and Jill has been arguing, so they don't want any edge to connect two vertices where one vertex has Jack's toy and the other vertex has Jill's toy.Jack has decided to hang a toys. What maximum number of toys b can Jill hang if they both cooperate to maximize this value? Your task is to write a program that finds the sought b for all a from 0 to the number of vertices on the New Year Cactus.InputThe first line contains two integers n and m (1 ≤ n ≤ 2500, n - 1 ≤ m) — the number of vertices and the number of edges, correspondingly. The next m lines contain two integers a, b each (1 ≤ a, b ≤ n, a ≠ b) that mean that there is an edge connecting vertices a и b. Any pair of vertices has at most one edge between them.OutputThe first line must contain space-separated ba (for all 0 ≤ a ≤ n) where ba equals the maximum number of Jill's toys on the cactus considering that it has a Jack's toys. Numbers ba go in the order of increasing a.ExamplesInput1 0Output1 0 Input16 201 23 45 66 77 89 1010 1111 1213 1415 161 59 1314 1010 66 215 1111 77 316 128 4Output16 13 12 12 10 8 8 7 6 4 4 3 3 1 0 0 0 NoteThe cactus from the second example is:	Input1 0	Output1 0	2 seconds	256 megabytes	['dp', '*3100']
F. New Year Treetime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou are a programmer and you have a New Year Tree (not the traditional fur tree, though) — a tree of four vertices: one vertex of degree three (has number 1), connected with three leaves (their numbers are from 2 to 4).On the New Year, programmers usually have fun. You decided to have fun as well by adding vertices to the tree. One adding operation looks as follows: First we choose some leaf of the tree with number v. Let's mark the number of vertices on the tree at this moment by variable n, then two vertexes are added to the tree, their numbers are n + 1 and n + 2, also you get new edges, one between vertices v and n + 1 and one between vertices v and n + 2. Your task is not just to model the process of adding vertices to the tree, but after each adding operation print the diameter of the current tree. Come on, let's solve the New Year problem!InputThe first line contains integer q (1 ≤ q ≤ 5·105) — the number of operations. Each of the next q lines contains integer vi (1 ≤ vi ≤ n) — the operation of adding leaves to vertex vi. Variable n represents the number of vertices in the current tree.It is guaranteed that all given operations are correct.OutputPrint q integers — the diameter of the current tree after each operation.ExamplesInput523485Output34456	Input523485	Output34456	2 seconds	256 megabytes	['data structures', 'divide and conquer', 'trees', '*2400']
E. New Year Tree Decorationstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputDue to atheistic Soviet past, Christmas wasn't officially celebrated in Russia for most of the twentieth century. As a result, the Russian traditions for Christmas and New Year mixed into one event celebrated on the New Year but including the tree, a Santa-like 'Grandfather Frost', presents and huge family reunions and dinner parties all over the country. Bying a Tree at the New Year and installing it in the house is a tradition. Usually the whole family decorates the tree on the New Year Eve. We hope that Codeforces is a big and loving family, so in this problem we are going to decorate a tree as well.So, our decoration consists of n pieces, each piece is a piece of colored paper, its border is a closed polyline of a special shape. The pieces go one by one as is shown on the picture. The i-th piece is a polyline that goes through points: (0, 0), (0, y0), (1, y1), (2, y2), ..., (k, yk), (k, 0). The width of each piece equals k. The figure to the left shows the decoration, the figure to the right shows the individual pieces it consists of. The piece number 1 (shown red on the figure) is the outer piece (we see it completely), piece number 2 (shown yellow) follows it (we don't see it completely as it is partially closed by the first piece) and so on. The programmers are quite curious guys, so the moment we hung a decoration on the New Year tree we started to wonder: what area of each piece can people see?InputThe first line contains two integers, n and k (1 ≤ n, k ≤ 300). Each of the following n lines contains k + 1 integers — the description of the polyline. If the i-th line contains ontegers yi, 0, yi, 1, ..., yi, k, that means that the polyline of the i-th piece goes through points (0, 0), (0, yi, 0), (1, yi, 1), (2, yi, 2), ..., (k, yi, k), (k, 0) (1 ≤ yi, j ≤ 1000).OutputPrint n real numbers — for each polyline, the area of its visible part.The answer will be considered correct if its relative or absolute error do not exceed 10 - 4. ExamplesInput2 22 1 21 2 1Output3.0000000000000.500000000000Input1 11 1Output1.000000000000Input4 12 77 25 56 4Output4.5000000000001.2500000000000.0500000000000.016666666667	Input2 22 1 21 2 1	Output3.0000000000000.500000000000	1 second	256 megabytes	['geometry', 'schedules', 'sortings', '*2500']
D. New Year Lettertime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputMany countries have such a New Year or Christmas tradition as writing a letter to Santa including a wish list for presents. Vasya is an ordinary programmer boy. Like all ordinary boys, he is going to write the letter to Santa on the New Year Eve (we Russians actually expect Santa for the New Year, not for Christmas). Vasya has come up with an algorithm he will follow while writing a letter. First he chooses two strings, s1 anf s2, consisting of uppercase English letters. Then the boy makes string sk, using a recurrent equation sn = sn - 2 + sn - 1, operation '+' means a concatenation (that is, the sequential record) of strings in the given order. Then Vasya writes down string sk on a piece of paper, puts it in the envelope and sends in to Santa. Vasya is absolutely sure that Santa will bring him the best present if the resulting string sk has exactly x occurrences of substring AC (the short-cut reminds him оf accepted problems). Besides, Vasya decided that string s1 should have length n, and string s2 should have length m. Vasya hasn't decided anything else.At the moment Vasya's got urgent New Year business, so he asks you to choose two strings for him, s1 and s2 in the required manner. Help Vasya.InputThe first line contains four integers k, x, n, m (3 ≤ k ≤ 50; 0 ≤ x ≤ 109; 1 ≤ n, m ≤ 100).OutputIn the first line print string s1, consisting of n uppercase English letters. In the second line print string s2, consisting of m uppercase English letters. If there are multiple valid strings, print any of them.If the required pair of strings doesn't exist, print "Happy new year!" without the quotes.ExamplesInput3 2 2 2OutputACACInput3 3 2 2OutputHappy new year!Input3 0 2 2OutputAAAAInput4 3 2 1OutputHappy new year!Input4 2 2 1OutputHappy new year!	Input3 2 2 2	OutputACAC	1 second	256 megabytes	['bitmasks', 'brute force', 'dp', '*2000']
C. New Year Ratings Changetime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputOne very well-known internet resource site (let's call it X) has come up with a New Year adventure. Specifically, they decided to give ratings to all visitors.There are n users on the site, for each user we know the rating value he wants to get as a New Year Present. We know that user i wants to get at least ai rating units as a present.The X site is administered by very creative and thrifty people. On the one hand, they want to give distinct ratings and on the other hand, the total sum of the ratings in the present must be as small as possible.Help site X cope with the challenging task of rating distribution. Find the optimal distribution.InputThe first line contains integer n (1 ≤ n ≤ 3·105) — the number of users on the site. The next line contains integer sequence a1, a2, ..., an (1 ≤ ai ≤ 109).OutputPrint a sequence of integers b1, b2, ..., bn. Number bi means that user i gets bi of rating as a present. The printed sequence must meet the problem conditions. If there are multiple optimal solutions, print any of them.ExamplesInput35 1 1Output5 1 2Input11000000000Output1000000000	Input35 1 1	Output5 1 2	1 second	256 megabytes	['greedy', 'sortings', '*1400']
B. New Year Presenttime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe New Year is coming! That's why many people today are busy preparing New Year presents. Vasily the Programmer is no exception.Vasily knows that the best present is (no, it's not a contest) money. He's put n empty wallets from left to right in a row and decided how much money to put in what wallet. Vasily decided to put ai coins to the i-th wallet from the left.Vasily is a very busy man, so the money are sorted into the bags by his robot. Initially, the robot stands by the leftmost wallet in the row. The robot can follow instructions of three types: go to the wallet that is to the left of the current one (if such wallet exists), go to the wallet that is to the right of the current one (if such wallet exists), put a coin to the current wallet. Due to some technical malfunctions the robot cannot follow two "put a coin" instructions in a row.Vasily doesn't want to wait for long, so he wants to write a program for the robot that contains at most 106 operations (not necessarily minimum in length) the robot can use to put coins into the wallets. Help him.InputThe first line contains integer n (2 ≤ n ≤ 300) — the number of wallets. The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 300).It is guaranteed that at least one ai is positive.OutputPrint the sequence that consists of k (1 ≤ k ≤ 106) characters, each of them equals: "L", "R" or "P". Each character of the sequence is an instruction to the robot. Character "L" orders to move to the left, character "R" orders to move to the right, character "P" orders the robot to put a coin in the wallet. The robot is not allowed to go beyond the wallet line. In other words, you cannot give instructions "L" if the robot is at wallet 1, or "R" at wallet n.As a result of the performed operations, the i-th wallet from the left must contain exactly ai coins. If there are multiple answers, you can print any of them.ExamplesInput21 2OutputPRPLRPInput40 2 0 2OutputRPRRPLLPLRRRP	Input21 2	OutputPRPLRP	1 second	256 megabytes	['constructive algorithms', 'implementation', '*1200']
A. New Year Candlestime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputVasily the Programmer loves romance, so this year he decided to illuminate his room with candles.Vasily has a candles.When Vasily lights up a new candle, it first burns for an hour and then it goes out. Vasily is smart, so he can make b went out candles into a new candle. As a result, this new candle can be used like any other new candle.Now Vasily wonders: for how many hours can his candles light up the room if he acts optimally well? Help him find this number.InputThe single line contains two integers, a and b (1 ≤ a ≤ 1000; 2 ≤ b ≤ 1000).OutputPrint a single integer — the number of hours Vasily can light up the room for.ExamplesInput4 2Output7Input6 3Output8NoteConsider the first sample. For the first four hours Vasily lights up new candles, then he uses four burned out candles to make two new ones and lights them up. When these candles go out (stop burning), Vasily can make another candle. Overall, Vasily can light up the room for 7 hours.	Input4 2	Output7	1 second	256 megabytes	['implementation', '*1000']
B. Semifinalstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputTwo semifinals have just been in the running tournament. Each semifinal had n participants. There are n participants advancing to the finals, they are chosen as follows: from each semifinal, we choose k people (0 ≤ 2k ≤ n) who showed the best result in their semifinals and all other places in the finals go to the people who haven't ranked in the top k in their semifinal but got to the n - 2k of the best among the others.The tournament organizers hasn't yet determined the k value, so the participants want to know who else has any chance to get to the finals and who can go home.InputThe first line contains a single integer n (1 ≤ n ≤ 105) — the number of participants in each semifinal.Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109) — the results of the i-th participant (the number of milliseconds he needs to cover the semifinals distance) of the first and second semifinals, correspondingly. All results are distinct. Sequences a1, a2, ..., an and b1, b2, ..., bn are sorted in ascending order, i.e. in the order the participants finished in the corresponding semifinal.OutputPrint two strings consisting of n characters, each equals either "0" or "1". The first line should correspond to the participants of the first semifinal, the second line should correspond to the participants of the second semifinal. The i-th character in the j-th line should equal "1" if the i-th participant of the j-th semifinal has any chances to advance to the finals, otherwise it should equal a "0".ExamplesInput49840 99209860 99809930 1002010040 10090Output11101100Input49900 98509940 993010000 1002010060 10110Output11001100NoteConsider the first sample. Each semifinal has 4 participants. The results of the first semifinal are 9840, 9860, 9930, 10040. The results of the second semifinal are 9920, 9980, 10020, 10090. If k = 0, the finalists are determined by the time only, so players 9840, 9860, 9920 and 9930 advance to the finals. If k = 1, the winners from both semifinals move to the finals (with results 9840 and 9920), and the other places are determined by the time (these places go to the sportsmen who run the distance in 9860 and 9930 milliseconds). If k = 2, then first and second places advance from each seminfial, these are participants with results 9840, 9860, 9920 and 9980 milliseconds.	Input49840 99209860 99809930 1002010040 10090	Output11101100	1 second	256 megabytes	['implementation', 'sortings', '*1300']
A. Playing with Dicetime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputTwo players are playing a game. First each of them writes an integer from 1 to 6, and then a dice is thrown. The player whose written number got closer to the number on the dice wins. If both payers have the same difference, it's a draw.The first player wrote number a, the second player wrote number b. How many ways to throw a dice are there, at which the first player wins, or there is a draw, or the second player wins?InputThe single line contains two integers a and b (1 ≤ a, b ≤ 6) — the numbers written on the paper by the first and second player, correspondingly.OutputPrint three integers: the number of ways to throw the dice at which the first player wins, the game ends with a draw or the second player wins, correspondingly.ExamplesInput2 5Output3 0 3Input2 4Output2 1 3NoteThe dice is a standard cube-shaped six-sided object with each side containing a number from 1 to 6, and where all numbers on all sides are distinct.You can assume that number a is closer to number x than number b, if \|a - x\| < \|b - x\|.	Input2 5	Output3 0 3	1 second	256 megabytes	['brute force', '*800']
E. Cookie Clickertime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputKostya is playing the computer game Cookie Clicker. The goal of this game is to gather cookies. You can get cookies using different buildings: you can just click a special field on the screen and get the cookies for the clicks, you can buy a cookie factory, an alchemy lab, a time machine and it all will bring lots and lots of cookies.At the beginning of the game (time 0), Kostya has 0 cookies and no buildings. He has n available buildings to choose from: the i-th building is worth ci cookies and when it's built it brings vi cookies at the end of each second. Also, to make the game more interesting to play, Kostya decided to add a limit: at each moment of time, he can use only one building. Of course, he can change the active building each second at his discretion.It's important that Kostya is playing a version of the game where he can buy new buildings and change active building only at time moments that are multiples of one second. Kostya can buy new building and use it at the same time. If Kostya starts to use a building at the time moment t, he can get the first profit from it only at the time moment t + 1.Kostya wants to earn at least s cookies as quickly as possible. Determine the number of seconds he needs to do that.InputThe first line contains two integers n and s (1 ≤ n ≤ 2·105, 1 ≤ s ≤ 1016) — the number of buildings in the game and the number of cookies Kostya wants to earn.Each of the next n lines contains two integers vi and ci (1 ≤ vi ≤ 108, 0 ≤ ci ≤ 108) — the number of cookies the i-th building brings per second and the building's price.OutputOutput the only integer — the minimum number of seconds Kostya needs to earn at least s cookies. It is guaranteed that he can do it.ExamplesInput3 91 02 35 4Output6Input3 61 02 25 4Output5Input3 131 02 26 5Output7Input1 100000000000000001 0Output10000000000000000	Input3 91 02 35 4	Output6	2 seconds	256 megabytes	['dp', 'geometry', '*2800']
D. Developing Gametime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputPavel is going to make a game of his dream. However, he knows that he can't make it on his own so he founded a development company and hired n workers of staff. Now he wants to pick n workers from the staff who will be directly responsible for developing a game.Each worker has a certain skill level vi. Besides, each worker doesn't want to work with the one whose skill is very different. In other words, the i-th worker won't work with those whose skill is less than li, and with those whose skill is more than ri.Pavel understands that the game of his dream isn't too hard to develop, so the worker with any skill will be equally useful. That's why he wants to pick a team of the maximum possible size. Help him pick such team.InputThe first line contains a single integer n (1 ≤ n ≤ 105) — the number of workers Pavel hired.Each of the following n lines contains three space-separated integers li, vi, ri (1 ≤ li ≤ vi ≤ ri ≤ 3·105) — the minimum skill value of the workers that the i-th worker can work with, the i-th worker's skill and the maximum skill value of the workers that the i-th worker can work with.OutputIn the first line print a single integer m — the number of workers Pavel must pick for developing the game.In the next line print m space-separated integers — the numbers of the workers in any order.If there are multiple optimal solutions, print any of them.ExamplesInput42 8 91 4 73 6 85 8 10Output31 3 4Input63 5 161 6 114 8 127 9 162 10 148 13 15Output41 2 3 5	Input42 8 91 4 73 6 85 8 10	Output31 3 4	2 seconds	256 megabytes	['data structures', '*2400']
C. Captains Modetime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputKostya is a progamer specializing in the discipline of Dota 2. Valve Corporation, the developer of this game, has recently released a new patch which turned the balance of the game upside down. Kostya, as the captain of the team, realizes that the greatest responsibility lies on him, so he wants to resort to the analysis of innovations patch from the mathematical point of view to choose the best heroes for his team in every game.A Dota 2 match involves two teams, each of them must choose some heroes that the players of the team are going to play for, and it is forbidden to choose the same hero several times, even in different teams. In large electronic sports competitions where Kostya's team is going to participate, the matches are held in the Captains Mode. In this mode the captains select the heroes by making one of two possible actions in a certain, predetermined order: pick or ban. To pick a hero for the team. After the captain picks, the picked hero goes to his team (later one of a team members will play it) and can no longer be selected by any of the teams. To ban a hero. After the ban the hero is not sent to any of the teams, but it still can no longer be selected by any of the teams. The team captain may miss a pick or a ban. If he misses a pick, a random hero is added to his team from those that were available at that moment, and if he misses a ban, no hero is banned, as if there was no ban.Kostya has already identified the strength of all the heroes based on the new patch fixes. Of course, Kostya knows the order of picks and bans. The strength of a team is the sum of the strengths of the team's heroes and both teams that participate in the match seek to maximize the difference in strengths in their favor. Help Kostya determine what team, the first one or the second one, has advantage in the match, and how large the advantage is.InputThe first line contains a single integer n (2 ≤ n ≤ 100) — the number of heroes in Dota 2.The second line contains n integers s1, s2, ..., sn (1 ≤ si ≤ 106) — the strengths of all the heroes.The third line contains a single integer m (2 ≤ m ≤ min(n, 20)) — the number of actions the captains of the team must perform.Next m lines look like "action team", where action is the needed action: a pick (represented as a "p") or a ban (represented as a "b"), and team is the number of the team that needs to perform the action (number 1 or 2).It is guaranteed that each team makes at least one pick. Besides, each team has the same number of picks and the same number of bans.OutputPrint a single integer — the difference between the strength of the first team and the strength of the second team if the captains of both teams will act optimally well.ExamplesInput22 12p 1p 2Output1Input66 4 5 4 5 54b 2p 1b 1p 2Output0Input41 2 3 44p 2b 2p 1b 1Output-2	Input22 12p 1p 2	Output1	2 seconds	256 megabytes	['bitmasks', 'dp', 'games', '*2200']
B. Preparing for the Contesttime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputSoon there will be held the world's largest programming contest, but the testing system still has m bugs. The contest organizer, a well-known university, has no choice but to attract university students to fix all the bugs. The university has n students able to perform such work. The students realize that they are the only hope of the organizers, so they don't want to work for free: the i-th student wants to get ci 'passes' in his subjects (regardless of the volume of his work).Bugs, like students, are not the same: every bug is characterized by complexity aj, and every student has the level of his abilities bi. Student i can fix a bug j only if the level of his abilities is not less than the complexity of the bug: bi ≥ aj, and he does it in one day. Otherwise, the bug will have to be fixed by another student. Of course, no student can work on a few bugs in one day. All bugs are not dependent on each other, so they can be corrected in any order, and different students can work simultaneously.The university wants to fix all the bugs as quickly as possible, but giving the students the total of not more than s passes. Determine which students to use for that and come up with the schedule of work saying which student should fix which bug.InputThe first line contains three space-separated integers: n, m and s (1 ≤ n, m ≤ 105, 0 ≤ s ≤ 109) — the number of students, the number of bugs in the system and the maximum number of passes the university is ready to give the students.The next line contains m space-separated integers a1, a2, ..., am (1 ≤ ai ≤ 109) — the bugs' complexities.The next line contains n space-separated integers b1, b2, ..., bn (1 ≤ bi ≤ 109) — the levels of the students' abilities.The next line contains n space-separated integers c1, c2, ..., cn (0 ≤ ci ≤ 109) — the numbers of the passes the students want to get for their help.OutputIf the university can't correct all bugs print "NO".Otherwise, on the first line print "YES", and on the next line print m space-separated integers: the i-th of these numbers should equal the number of the student who corrects the i-th bug in the optimal answer. The bugs should be corrected as quickly as possible (you must spend the minimum number of days), and the total given passes mustn't exceed s. If there are multiple optimal answers, you can output any of them.ExamplesInput3 4 91 3 1 22 1 34 3 6OutputYES2 3 2 3Input3 4 102 3 1 22 1 34 3 6OutputYES1 3 1 3Input3 4 92 3 1 22 1 34 3 6OutputYES3 3 2 3Input3 4 51 3 1 22 1 35 3 6OutputNONoteConsider the first sample.The third student (with level 3) must fix the 2nd and 4th bugs (complexities 3 and 2 correspondingly) and the second student (with level 1) must fix the 1st and 3rd bugs (their complexity also equals 1). Fixing each bug takes one day for each student, so it takes 2 days to fix all bugs (the students can work in parallel).The second student wants 3 passes for his assistance, the third student wants 6 passes. It meets the university's capabilities as it is ready to give at most 9 passes.	Input3 4 91 3 1 22 1 34 3 6	OutputYES2 3 2 3	2 seconds	256 megabytes	['binary search', 'data structures', 'greedy', 'sortings', '*1900']
A. Mazetime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputPavel loves grid mazes. A grid maze is an n × m rectangle maze where each cell is either empty, or is a wall. You can go from one cell to another only if both cells are empty and have a common side.Pavel drew a grid maze with all empty cells forming a connected area. That is, you can go from any empty cell to any other one. Pavel doesn't like it when his maze has too little walls. He wants to turn exactly k empty cells into walls so that all the remaining cells still formed a connected area. Help him.InputThe first line contains three integers n, m, k (1 ≤ n, m ≤ 500, 0 ≤ k < s), where n and m are the maze's height and width, correspondingly, k is the number of walls Pavel wants to add and letter s represents the number of empty cells in the original maze.Each of the next n lines contains m characters. They describe the original maze. If a character on a line equals ".", then the corresponding cell is empty and if the character equals "#", then the cell is a wall.OutputPrint n lines containing m characters each: the new maze that fits Pavel's requirements. Mark the empty cells that you transformed into walls as "X", the other cells must be left without changes (that is, "." and "#").It is guaranteed that a solution exists. If there are multiple solutions you can output any of them.ExamplesInput3 4 2#..#..#.#...Output#.X#X.#.#...Input5 4 5#...#.#..#.....#.#.#Output#XXX#X#.X#.....#.#.#	Input3 4 2#..#..#.#...	Output#.X#X.#.#...	2 seconds	256 megabytes	['dfs and similar', '*1600']
B. I.O.U.time limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputImagine that there is a group of three friends: A, B and С. A owes B 20 rubles and B owes C 20 rubles. The total sum of the debts is 40 rubles. You can see that the debts are not organized in a very optimal manner. Let's rearrange them like that: assume that A owes C 20 rubles and B doesn't owe anything to anybody. The debts still mean the same but the total sum of the debts now equals 20 rubles.This task is a generalisation of a described example. Imagine that your group of friends has n people and you know the debts between the people. Optimize the given debts without changing their meaning. In other words, finally for each friend the difference between the total money he should give and the total money he should take must be the same. Print the minimum sum of all debts in the optimal rearrangement of the debts. See the notes to the test samples to better understand the problem.InputThe first line contains two integers n and m (1 ≤ n ≤ 100; 0 ≤ m ≤ 104). The next m lines contain the debts. The i-th line contains three integers ai, bi, ci (1 ≤ ai, bi ≤ n; ai ≠ bi; 1 ≤ ci ≤ 100), which mean that person ai owes person bi ci rubles.Assume that the people are numbered by integers from 1 to n.It is guaranteed that the same pair of people occurs at most once in the input. The input doesn't simultaneously contain pair of people (x, y) and pair of people (y, x).OutputPrint a single integer — the minimum sum of debts in the optimal rearrangement.ExamplesInput5 31 2 102 3 12 4 1Output10Input3 0Output0Input4 31 2 12 3 13 1 1Output0NoteIn the first sample, you can assume that person number 1 owes 8 rubles to person number 2, 1 ruble to person number 3 and 1 ruble to person number 4. He doesn't owe anybody else anything. In the end, the total debt equals 10.In the second sample, there are no debts.In the third sample, you can annul all the debts.	Input5 31 2 102 3 12 4 1	Output10	1 second	256 megabytes	['implementation', '*1300']
A. Levertime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou have a description of a lever as string s. We'll represent the string length as record \|s\|, then the lever looks as a horizontal bar with weights of length \|s\| - 1 with exactly one pivot. We will assume that the bar is a segment on the Ox axis between points 0 and \|s\| - 1.The decoding of the lever description is given below. If the i-th character of the string equals "^", that means that at coordinate i there is the pivot under the bar. If the i-th character of the string equals "=", that means that at coordinate i there is nothing lying on the bar. If the i-th character of the string equals digit c (1-9), that means that at coordinate i there is a weight of mass c on the bar. Your task is, given the lever description, print if it will be in balance or not. Assume that the bar doesn't weight anything. Assume that the bar initially is in balance then all weights are simultaneously put on it. After that the bar either tilts to the left, or tilts to the right, or is in balance.InputThe first line contains the lever description as a non-empty string s (3 ≤ \|s\| ≤ 106), consisting of digits (1-9) and characters "^" and "=". It is guaranteed that the line contains exactly one character "^". It is guaranteed that the pivot of the lever isn't located in any end of the lever bar.To solve the problem you may need 64-bit integer numbers. Please, do not forget to use them in your programs.OutputPrint "left" if the given lever tilts to the left, "right" if it tilts to the right and "balance", if it is in balance.ExamplesInput=^==OutputbalanceInput9===^==1OutputleftInput2==^7==OutputrightInput41^52==OutputbalanceNoteAs you solve the problem, you may find the following link useful to better understand how a lever functions: http://en.wikipedia.org/wiki/Lever.The pictures to the examples:	Input=^==	Outputbalance	1 second	256 megabytes	['implementation', 'math', '*900']
E. Red and Black Treetime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou have a weighted tree, consisting of n vertices. Each vertex is either painted black or is painted red. A red and black tree is called beautiful, if for any its vertex we can find a black vertex at distance at most x.The distance between two nodes is the shortest path between them.You have a red and black tree. Your task is to make it beautiful in the minimum number of color swap operations. In one color swap operation, you can choose two vertices of different colors and paint each of them the other color. In other words, if you choose a red vertex p and a black vertex q, then in one operation you are allowed to paint p black and paint q red.Print the minimum number of required actions.InputThe first line contains two integers n and x (2 ≤ n ≤ 500; 1 ≤ x ≤ 109). The next line contains n integers, each of them is either a zero or one. If the i-th number equals 1, then vertex i of the tree is black, otherwise vertex i is red. Next n - 1 lines contain the tree edges. The j-th line contains integers uj vj wj (1 ≤ uj, vj ≤ n; uj ≠ vj; 1 ≤ wj ≤ 109) which means that the tree has an edge of weight wj between vertices vj and uj.Assume that the tree vertices are numbered from 1 to n.OutputPrint a single integer — the minimum number of required swap operations.If it is impossible to get a beautiful tree at any number of operations, print -1.ExamplesInput3 21 0 01 2 22 3 2Output1Input4 20 1 0 01 2 22 3 23 4 2Output-1	Input3 21 0 01 2 22 3 2	Output1	1 second	256 megabytes	['dp', 'implementation', 'math', '*3000']

Subsets and Splits