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
B. Little Girl and Gametime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe Little Girl loves problems on games very much. Here's one of them.Two players have got a string s, consisting of lowercase English letters. They play a game that is described by the following rules: The players move in turns; In one move the player can remove an arbitrary letter from string s. If the player before his turn can reorder the letters in string s so as to get a palindrome, this player wins. A palindrome is a string that reads the same both ways (from left to right, and vice versa). For example, string "abba" is a palindrome and string "abc" isn't. Determine which player will win, provided that both sides play optimally well — the one who moves first or the one who moves second.InputThe input contains a single line, containing string s (1 ≤ \|s\| ≤ 103). String s consists of lowercase English letters.OutputIn a single line print word "First" if the first player wins (provided that both players play optimally well). Otherwise, print word "Second". Print the words without the quotes.ExamplesInputabaOutputFirstInputabcaOutputSecond	Inputaba	OutputFirst	2 seconds	256 megabytes	['games', 'greedy', '*1300']
A. Lunch Rushtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputHaving written another programming contest, three Rabbits decided to grab some lunch. The coach gave the team exactly k time units for the lunch break.The Rabbits have a list of n restaurants to lunch in: the i-th restaurant is characterized by two integers fi and ti. Value ti shows the time the Rabbits need to lunch in the i-th restaurant. If time ti exceeds the time k that the coach has given for the lunch break, then the Rabbits' joy from lunching in this restaurant will equal fi - (ti - k). Otherwise, the Rabbits get exactly fi units of joy.Your task is to find the value of the maximum joy the Rabbits can get from the lunch, depending on the restaurant. The Rabbits must choose exactly one restaurant to lunch in. Note that the joy value isn't necessarily a positive value. InputThe first line contains two space-separated integers — n (1 ≤ n ≤ 104) and k (1 ≤ k ≤ 109) — the number of restaurants in the Rabbits' list and the time the coach has given them to lunch, correspondingly. Each of the next n lines contains two space-separated integers — fi (1 ≤ fi ≤ 109) and ti (1 ≤ ti ≤ 109) — the characteristics of the i-th restaurant.OutputIn a single line print a single integer — the maximum joy value that the Rabbits will get from the lunch. ExamplesInput2 53 34 5Output4Input4 65 83 62 32 2Output3Input1 51 7Output-1	Input2 53 34 5	Output4	2 seconds	256 megabytes	['implementation', '*900']
B. Convex Shapetime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputConsider an n × m grid. Initially all the cells of the grid are colored white. Lenny has painted some of the cells (at least one) black. We call a painted grid convex if one can walk from any black cell to any another black cell using a path of side-adjacent black cells changing his direction at most once during the path. In the figure below, the left grid is convex while the right one is not convex, because there exist two cells which need more than one time to change direction in their path. You're given a painted grid in the input. Tell Lenny if the grid is convex or not.InputThe first line of the input contains two integers n and m (1 ≤ n, m ≤ 50) — the size of the grid. Each of the next n lines contains m characters "B" or "W". Character "B" denotes a black cell of the grid and "W" denotes a white cell of the grid.It's guaranteed that the grid has at least one black cell.OutputOn the only line of the output print "YES" if the grid is convex, otherwise print "NO". Do not print quotes.ExamplesInput3 4WWBWBWWWWWWBOutputNOInput3 1BBWOutputYES	Input3 4WWBWBWWWWWWB	OutputNO	2 seconds	256 megabytes	['constructive algorithms', 'implementation', '*1700']
A. Lights Outtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLenny is playing a game on a 3 × 3 grid of lights. In the beginning of the game all lights are switched on. Pressing any of the lights will toggle it and all side-adjacent lights. The goal of the game is to switch all the lights off. We consider the toggling as follows: if the light was switched on then it will be switched off, if it was switched off then it will be switched on.Lenny has spent some time playing with the grid and by now he has pressed each light a certain number of times. Given the number of times each light is pressed, you have to print the current state of each light.InputThe input consists of three rows. Each row contains three integers each between 0 to 100 inclusive. The j-th number in the i-th row is the number of times the j-th light of the i-th row of the grid is pressed.OutputPrint three lines, each containing three characters. The j-th character of the i-th line is "1" if and only if the corresponding light is switched on, otherwise it's "0".ExamplesInput1 0 00 0 00 0 1Output001010100Input1 0 18 8 82 0 3Output010011100	Input1 0 00 0 00 0 1	Output001010100	2 seconds	256 megabytes	['implementation', '*900']
E. Mirror Roomtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputImagine an n × m grid with some blocked cells. The top left cell in the grid has coordinates (1, 1) and the bottom right cell has coordinates (n, m). There are k blocked cells in the grid and others are empty. You flash a laser beam from the center of an empty cell (xs, ys) in one of the diagonal directions (i.e. north-east, north-west, south-east or south-west). If the beam hits a blocked cell or the border of the grid it will reflect. The behavior of the beam reflection in different situations is depicted in the figure below. After a while the beam enters an infinite cycle. Count the number of empty cells that the beam goes through at least once. We consider that the beam goes through cell if it goes through its center.InputThe first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 105, 0 ≤ k ≤ 105). Each of the next k lines contains two integers xi and yi (1 ≤ xi ≤ n, 1 ≤ yi ≤ m) indicating the position of the i-th blocked cell. The last line contains xs, ys (1 ≤ xs ≤ n, 1 ≤ ys ≤ m) and the flash direction which is equal to "NE", "NW", "SE" or "SW". These strings denote directions ( - 1, 1), ( - 1, - 1), (1, 1), (1, - 1).It's guaranteed that no two blocked cells have the same coordinates.OutputIn the only line of the output print the number of empty cells that the beam goes through at least once.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.ExamplesInput3 3 01 2 SWOutput6Input7 5 33 34 35 32 1 SEOutput14	Input3 3 01 2 SW	Output6	2 seconds	256 megabytes	['data structures', 'implementation', '*3000']
D. Lovely Matrixtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLenny had an n × m matrix of positive integers. He loved the matrix so much, because each row of the matrix was sorted in non-decreasing order. For the same reason he calls such matrices of integers lovely.One day when Lenny was at school his little brother was playing with Lenny's matrix in his room. He erased some of the entries of the matrix and changed the order of some of its columns. When Lenny got back home he was very upset. Now Lenny wants to recover his matrix.Help him to find an order for the columns of the matrix so that it's possible to fill in the erased entries of the matrix to achieve a lovely matrix again. Note, that you can fill the erased entries of the matrix with any integers.InputThe first line of the input contains two positive integers n and m (1 ≤ n·m ≤ 105). Each of the next n lines contains m space-separated integers representing the matrix. An integer -1 shows an erased entry of the matrix. All other integers (each of them is between 0 and 109 inclusive) represent filled entries.OutputIf there exists no possible reordering of the columns print -1. Otherwise the output should contain m integers p1, p2, ..., pm showing the sought permutation of columns. So, the first column of the lovely matrix will be p1-th column of the initial matrix, the second column of the lovely matrix will be p2-th column of the initial matrix and so on.ExamplesInput3 31 -1 -11 2 12 -1 1Output3 1 2 Input2 31 2 22 5 4Output1 3 2 Input2 31 2 33 2 1Output-1	Input3 31 -1 -11 2 12 -1 1	Output3 1 2	2 seconds	256 megabytes	['dfs and similar', 'graphs', 'greedy', 'sortings', '*2200']
C. The Last Hole!time limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLuyi has n circles on the plane. The i-th circle is centered at (xi, yi). At the time zero circles start to grow simultaneously. In other words, the radius of each circle at time t (t > 0) is equal to t. The circles are drawn as black discs on an infinite white plane. So at each moment the plane consists of several black and white regions. Note that the circles may overlap while growing. We define a hole as a closed, connected white region. For instance, the figure contains two holes shown by red border. During growing some holes may be created and it is easy to see that each created hole will disappear eventually. Luyi asks you to find moment of time such that the last hole disappears. In other words, you should find the first moment such that no hole can be seen after that.InputThe first line of the input contains integer n (1 ≤ n ≤ 100). Each of the next n lines contains two integers xi and yi ( - 104 ≤ xi, yi ≤ 104), indicating the location of i-th circle.It's guaranteed that no two circles are centered at the same point.OutputPrint the moment where the last hole disappears. If there exists no moment in which we can find holes print -1.The answer will be considered correct if the absolute or relative error does not exceed 10 - 4.ExamplesInput30 01 12 2Output-1Input40 00 22 22 0Output1.414214Input40 10 -1-2 04 0Output2.125000	Input30 01 12 2	Output-1	2 seconds	256 megabytes	['brute force', 'geometry', '*2600']
B. Zero Treetime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputA tree is a graph with n vertices and exactly n - 1 edges; this graph should meet the following condition: there exists exactly one shortest (by number of edges) path between any pair of its vertices.A subtree of a tree T is a tree with both vertices and edges as subsets of vertices and edges of T.You're given a tree with n vertices. Consider its vertices numbered with integers from 1 to n. Additionally an integer is written on every vertex of this tree. Initially the integer written on the i-th vertex is equal to vi. In one move you can apply the following operation: Select the subtree of the given tree that includes the vertex with number 1. Increase (or decrease) by one all the integers which are written on the vertices of that subtree. Calculate the minimum number of moves that is required to make all the integers written on the vertices of the given tree equal to zero.InputThe first line of the input contains n (1 ≤ n ≤ 105). Each of the next n - 1 lines contains two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi) indicating there's an edge between vertices ai and bi. It's guaranteed that the input graph is a tree. The last line of the input contains a list of n space-separated integers v1, v2, ..., vn (\|vi\| ≤ 109).OutputPrint the minimum number of operations needed to solve the task.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.ExamplesInput31 21 31 -1 1Output3	Input31 21 31 -1 1	Output3	2 seconds	256 megabytes	['dfs and similar', 'dp', 'greedy', 'trees', '*1800']
A. k-Multiple Free Settime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputA k-multiple free set is a set of integers where there is no pair of integers where one is equal to another integer multiplied by k. That is, there are no two integers x and y (x < y) from the set, such that y = x·k.You're given a set of n distinct positive integers. Your task is to find the size of it's largest k-multiple free subset.InputThe first line of the input contains two integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 109). The next line contains a list of n distinct positive integers a1, a2, ..., an (1 ≤ ai ≤ 109).All the numbers in the lines are separated by single spaces.OutputOn the only line of the output print the size of the largest k-multiple free subset of {a1, a2, ..., an}.ExamplesInput6 22 3 6 5 4 10Output3NoteIn the sample input one of the possible maximum 2-multiple free subsets is {4, 5, 6}.	Input6 22 3 6 5 4 10	Output3	2 seconds	256 megabytes	['binary search', 'greedy', 'sortings', '*1500']
E. Dima and Gametime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputDima and Anya love playing different games. Now Dima has imagined a new game that he wants to play with Anya.Dima writes n pairs of integers on a piece of paper (li, ri) (1 ≤ li < ri ≤ p). Then players take turns. On his turn the player can do the following actions: choose the number of the pair i (1 ≤ i ≤ n), such that ri - li > 2; replace pair number i by pair or by pair . Notation ⌊x⌋ means rounding down to the closest integer. The player who can't make a move loses.Of course, Dima wants Anya, who will move first, to win. That's why Dima should write out such n pairs of integers (li, ri) (1 ≤ li < ri ≤ p), that if both players play optimally well, the first one wins. Count the number of ways in which Dima can do it. Print the remainder after dividing the answer by number 1000000007 (109 + 7).Two ways are considered distinct, if the ordered sequences of the written pairs are distinct.InputThe first line contains two integers n, p (1 ≤ n ≤ 1000, 1 ≤ p ≤ 109). The numbers are separated by a single space.OutputIn a single line print the remainder after dividing the answer to the problem by number 1000000007 (109 + 7).ExamplesInput2 2Output0Input4 4Output520Input100 1000Output269568947	Input2 2	Output0	1 second	256 megabytes	['dp', 'games', '*2600']
D. Dima and Figuretime limit per test3 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputDima loves making pictures on a piece of squared paper. And yet more than that Dima loves the pictures that depict one of his favorite figures. A piece of squared paper of size n × m is represented by a table, consisting of n rows and m columns. All squares are white on blank squared paper. Dima defines a picture as an image on a blank piece of paper, obtained by painting some squares black.The picture portrays one of Dima's favorite figures, if the following conditions hold: The picture contains at least one painted cell; All painted cells form a connected set, that is, you can get from any painted cell to any other one (you can move from one cell to a side-adjacent one); The minimum number of moves needed to go from the painted cell at coordinates (x1, y1) to the painted cell at coordinates (x2, y2), moving only through the colored cells, equals \|x1 - x2\| + \|y1 - y2\|. Now Dima is wondering: how many paintings are on an n × m piece of paper, that depict one of his favorite figures? Count this number modulo 1000000007 (109 + 7).InputThe first line contains two integers n and m — the sizes of the piece of paper (1 ≤ n, m ≤ 150).OutputIn a single line print the remainder after dividing the answer to the problem by number 1000000007 (109 + 7).ExamplesInput2 2Output13Input3 4Output571	Input2 2	Output13	3 seconds	256 megabytes	['dp', '*2400']
E. Dima and Horsestime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputDima came to the horse land. There are n horses living in the land. Each horse in the horse land has several enemies (enmity is a symmetric relationship). The horse land isn't very hostile, so the number of enemies of each horse is at most 3.Right now the horse land is going through an election campaign. So the horses trusted Dima to split them into two parts. At that the horses want the following condition to hold: a horse shouldn't have more than one enemy in its party.Help Dima split the horses into parties. Note that one of the parties can turn out to be empty.InputThe first line contains two integers n, m — the number of horses in the horse land and the number of enemy pairs.Next m lines define the enemy pairs. The i-th line contains integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi), which mean that horse ai is the enemy of horse bi.Consider the horses indexed in some way from 1 to n. It is guaranteed that each horse has at most three enemies. No pair of enemies occurs more than once in the input.OutputPrint a line, consisting of n characters: the i-th character of the line must equal "0", if the horse number i needs to go to the first party, otherwise this character should equal "1".If there isn't a way to divide the horses as required, print -1.ExamplesInput3 31 23 23 1Output100Input2 12 1Output00Input10 61 21 31 42 32 43 4Output0110000000	Input3 31 23 23 1	Output100	2 seconds	256 megabytes	['combinatorics', 'constructive algorithms', 'graphs', '*2200']
D. Dima and Two Sequencestime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLittle Dima has two sequences of points with integer coordinates: sequence (a1, 1), (a2, 2), ..., (an, n) and sequence (b1, 1), (b2, 2), ..., (bn, n).Now Dima wants to count the number of distinct sequences of points of length 2·n that can be assembled from these sequences, such that the x-coordinates of points in the assembled sequence will not decrease. Help him with that. Note that each element of the initial sequences should be used exactly once in the assembled sequence.Dima considers two assembled sequences (p1, q1), (p2, q2), ..., (p2·n, q2·n) and (x1, y1), (x2, y2), ..., (x2·n, y2·n) distinct, if there is such i (1 ≤ i ≤ 2·n), that (pi, qi) ≠ (xi, yi).As the answer can be rather large, print the remainder from dividing the answer by number m.InputThe first line contains integer n (1 ≤ n ≤ 105). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109). The third line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 109). The numbers in the lines are separated by spaces.The last line contains integer m (2 ≤ m ≤ 109 + 7).OutputIn the single line print the remainder after dividing the answer to the problem by number m. ExamplesInput1127Output1Input21 22 311Output2NoteIn the first sample you can get only one sequence: (1, 1), (2, 1). In the second sample you can get such sequences : (1, 1), (2, 2), (2, 1), (3, 2); (1, 1), (2, 1), (2, 2), (3, 2). Thus, the answer is 2.	Input1127	Output1	2 seconds	256 megabytes	['combinatorics', 'math', 'sortings', '*1600']
C. Dima and Staircasetime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputDima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 ≤ a1 ≤ a2 ≤ ... ≤ an). Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen: the bottom of the box touches the top of a stair; the bottom of the box touches the top of a box, thrown earlier. We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.InputThe first line contains integer n (1 ≤ n ≤ 105) — the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 ≤ ai ≤ 109; ai ≤ ai + 1).The next line contains integer m (1 ≤ m ≤ 105) — the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 ≤ wi ≤ n; 1 ≤ hi ≤ 109) — the size of the i-th thrown box.The numbers in the lines are separated by spaces.OutputPrint m integers — for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.ExamplesInput51 2 3 6 641 13 11 14 3Output1346Input31 2 321 13 1Output13Input1151 21 101 101 101 10Output13132333NoteThe first sample are shown on the picture.	Input51 2 3 6 641 13 11 14 3	Output1346	2 seconds	256 megabytes	['data structures', 'implementation', '*1500']
B. Dima and Sequencetime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputDima got into number sequences. Now he's got sequence a1, a2, ..., an, consisting of n positive integers. Also, Dima has got a function f(x), which can be defined with the following recurrence: f(0) = 0; f(2·x) = f(x); f(2·x + 1) = f(x) + 1. Dima wonders, how many pairs of indexes (i, j) (1 ≤ i < j ≤ n) are there, such that f(ai) = f(aj). Help him, count the number of such pairs. InputThe first line contains integer n (1 ≤ n ≤ 105). The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109).The numbers in the lines are separated by single spaces.OutputIn a single line print the answer to the problem.Please, don't use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.ExamplesInput31 2 4Output3Input35 3 1Output1NoteIn the first sample any pair (i, j) will do, so the answer is 3.In the second sample only pair (1, 2) will do.	Input31 2 4	Output3	2 seconds	256 megabytes	['implementation', 'math', '*1400']
A. Dima and Friendstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputDima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.InputThe first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show. The numbers in the lines are separated by a single space.OutputIn a single line print the answer to the problem.ExamplesInput11Output3Input12Output2Input23 5Output3NoteIn the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.In the second sample Dima can show 2 or 4 fingers.	Input11	Output3	2 seconds	256 megabytes	['implementation', 'math', '*1000']
E. Three Horsestime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThere are three horses living in a horse land: one gray, one white and one gray-and-white. The horses are really amusing animals, which is why they adore special cards. Each of those cards must contain two integers, the first one on top, the second one in the bottom of the card. Let's denote a card with a on the top and b in the bottom as (a, b).Each of the three horses can paint the special cards. If you show an (a, b) card to the gray horse, then the horse can paint a new (a + 1, b + 1) card. If you show an (a, b) card, such that a and b are even integers, to the white horse, then the horse can paint a new card. If you show two cards (a, b) and (b, c) to the gray-and-white horse, then he can paint a new (a, c) card.Polycarpus really wants to get n special cards (1, a1), (1, a2), ..., (1, an). For that he is going to the horse land. He can take exactly one (x, y) card to the horse land, such that 1 ≤ x < y ≤ m. How many ways are there to choose the card so that he can perform some actions in the horse land and get the required cards?Polycarpus can get cards from the horses only as a result of the actions that are described above. Polycarpus is allowed to get additional cards besides the cards that he requires.InputThe first line contains two integers n, m (1 ≤ n ≤ 105, 2 ≤ m ≤ 109). The second line contains the sequence of integers a1, a2, ..., an (2 ≤ ai ≤ 109). Note, that the numbers in the sequence can coincide.The numbers in the lines are separated by single spaces.OutputPrint a single integer — the answer to the problem. Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.ExamplesInput1 62Output11Input1 67Output14Input2 1013 7Output36	Input1 62	Output11	2 seconds	256 megabytes	['constructive algorithms', 'math', 'number theory', '*2200']
D. Good Substringstime limit per test2 secondsmemory limit per test512 megabytesinputstandard inputoutputstandard outputYou've got string s, consisting of small English letters. Some of the English letters are good, the rest are bad.A substring s[l...r] (1 ≤ l ≤ r ≤ \|s\|) of string s = s1s2...s\|s\| (where \|s\| is the length of string s) is string slsl + 1...sr.The substring s[l...r] is good, if among the letters sl, sl + 1, ..., sr there are at most k bad ones (look at the sample's explanation to understand it more clear).Your task is to find the number of distinct good substrings of the given string s. Two substrings s[x...y] and s[p...q] are considered distinct if their content is different, i.e. s[x...y] ≠ s[p...q].InputThe first line of the input is the non-empty string s, consisting of small English letters, the string's length is at most 1500 characters.The second line of the input is the string of characters "0" and "1", the length is exactly 26 characters. If the i-th character of this string equals "1", then the i-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on.The third line of the input consists a single integer k (0 ≤ k ≤ \|s\|) — the maximum acceptable number of bad characters in a good substring.OutputPrint a single integer — the number of distinct good substrings of string s.ExamplesInputababab010000000000000000000000001Output5Inputacbacbacaa000000000000000000000000002Output8NoteIn the first example there are following good substrings: "a", "ab", "b", "ba", "bab".In the second example there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb".	Inputababab010000000000000000000000001	Output5	2 seconds	512 megabytes	['data structures', 'strings', '*1800']
C. Secrettime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe Greatest Secret Ever consists of n words, indexed by positive integers from 1 to n. The secret needs dividing between k Keepers (let's index them by positive integers from 1 to k), the i-th Keeper gets a non-empty set of words with numbers from the set Ui = (ui, 1, ui, 2, ..., ui, \|Ui\|). Here and below we'll presuppose that the set elements are written in the increasing order.We'll say that the secret is safe if the following conditions are hold: for any two indexes i, j (1 ≤ i < j ≤ k) the intersection of sets Ui and Uj is an empty set; the union of sets U1, U2, ..., Uk is set (1, 2, ..., n); in each set Ui, its elements ui, 1, ui, 2, ..., ui, \|Ui\| do not form an arithmetic progression (in particular, \|Ui\| ≥ 3 should hold). Let us remind you that the elements of set (u1, u2, ..., us) form an arithmetic progression if there is such number d, that for all i (1 ≤ i < s) fulfills ui + d = ui + 1. For example, the elements of sets (5), (1, 10) and (1, 5, 9) form arithmetic progressions and the elements of sets (1, 2, 4) and (3, 6, 8) don't.Your task is to find any partition of the set of words into subsets U1, U2, ..., Uk so that the secret is safe. Otherwise indicate that there's no such partition.InputThe input consists of a single line which contains two integers n and k (2 ≤ k ≤ n ≤ 106) — the number of words in the secret and the number of the Keepers. The numbers are separated by a single space.OutputIf there is no way to keep the secret safe, print a single integer "-1" (without the quotes). Otherwise, print n integers, the i-th of them representing the number of the Keeper who's got the i-th word of the secret.If there are multiple solutions, print any of them.ExamplesInput11 3Output3 1 2 1 1 2 3 2 2 3 1Input5 2Output-1	Input11 3	Output3 1 2 1 1 2 3 2 2 3 1	2 seconds	256 megabytes	['constructive algorithms', 'implementation', '*1500']
B. Prime Matrixtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not. A matrix is prime if at least one of the two following conditions fulfills: the matrix has a row with prime numbers only; the matrix has a column with prime numbers only; Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.InputThe first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.The numbers in the lines are separated by single spaces.OutputPrint a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.ExamplesInput3 31 2 35 6 14 4 1Output1Input2 34 8 89 2 9Output3Input2 21 34 2Output0NoteIn the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2.	Input3 31 2 35 6 14 4 1	Output1	2 seconds	256 megabytes	['binary search', 'brute force', 'math', 'number theory', '*1300']
A. Beautiful Yeartime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputIt seems like the year of 2013 came only yesterday. Do you know a curious fact? The year of 2013 is the first year after the old 1987 with only distinct digits.Now you are suggested to solve the following problem: given a year number, find the minimum year number which is strictly larger than the given one and has only distinct digits.InputThe single line contains integer y (1000 ≤ y ≤ 9000) — the year number.OutputPrint a single integer — the minimum year number that is strictly larger than y and all it's digits are distinct. It is guaranteed that the answer exists.ExamplesInput1987Output2013Input2013Output2014	Input1987	Output2013	2 seconds	256 megabytes	['brute force', '*800']
B. Multithreadingtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputEmuskald is addicted to Codeforces, and keeps refreshing the main page not to miss any changes in the "recent actions" list. He likes to read thread conversations where each thread consists of multiple messages.Recent actions shows a list of n different threads ordered by the time of the latest message in the thread. When a new message is posted in a thread that thread jumps on the top of the list. No two messages of different threads are ever posted at the same time.Emuskald has just finished reading all his opened threads and refreshes the main page for some more messages to feed his addiction. He notices that no new threads have appeared in the list and at the i-th place in the list there is a thread that was at the ai-th place before the refresh. He doesn't want to waste any time reading old messages so he wants to open only threads with new messages.Help Emuskald find out the number of threads that surely have new messages. A thread x surely has a new message if there is no such sequence of thread updates (posting messages) that both conditions hold: thread x is not updated (it has no new messages); the list order 1, 2, ..., n changes to a1, a2, ..., an. InputThe first line of input contains an integer n, the number of threads (1 ≤ n ≤ 105). The next line contains a list of n space-separated integers a1, a2, ..., an where ai (1 ≤ ai ≤ n) is the old position of the i-th thread in the new list. It is guaranteed that all of the ai are distinct.OutputOutput a single integer — the number of threads that surely contain a new message.ExamplesInput55 2 1 3 4Output2Input31 2 3Output0Input44 3 2 1Output3NoteIn the first test case, threads 2 and 5 are placed before the thread 1, so these threads must contain new messages. Threads 1, 3 and 4 may contain no new messages, if only threads 2 and 5 have new messages.In the second test case, there may be no new messages at all, since the thread order hasn't changed.In the third test case, only thread 1 can contain no new messages.	Input55 2 1 3 4	Output2	2 seconds	256 megabytes	['data structures', 'greedy', 'implementation', '*1400']
A. Fancy Fencetime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputEmuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?InputThe first line of input contains an integer t (0 < t < 180) — the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) — the angle the robot can make corners at measured in degrees.OutputFor each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.ExamplesInput3306090OutputNOYESYESNoteIn the first test case, it is impossible to build the fence, since there is no regular polygon with angle .In the second test case, the fence is a regular triangle, and in the last test case — a square.	Input3306090	OutputNOYESYES	2 seconds	256 megabytes	['geometry', 'implementation', 'math', '*1100']
E. String Theorytime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputEmuskald is an innovative musician and always tries to push the boundaries of music production. Now he has come up with an idea for a revolutionary musical instrument — a rectangular harp.A rectangular harp is a rectangle n × m consisting of n rows and m columns. The rows are numbered 1 to n from top to bottom. Similarly the columns are numbered 1 to m from left to right. String pins are spaced evenly across every side, one per unit. Thus there are n pins on the left and right sides of the harp and m pins on its top and bottom. The harp has exactly n + m different strings, each string connecting two different pins, each on a different side of the harp.Emuskald has ordered his apprentice to construct the first ever rectangular harp. However, he didn't mention that no two strings can cross, otherwise it would be impossible to play the harp. Two strings cross if the segments connecting their pins intersect. To fix the harp, Emuskald can perform operations of two types: pick two different columns and swap their pins on each side of the harp, not changing the pins that connect each string; pick two different rows and swap their pins on each side of the harp, not changing the pins that connect each string; In the following example, he can fix the harp by swapping two columns: Help Emuskald complete his creation and find the permutations how the rows and columns of the harp need to be rearranged, or tell that it is impossible to do so. He can detach and reattach each string to its pins, so the physical layout of the strings doesn't matter.InputThe first line of input contains two space-separated integers numbers n and m (1 ≤ n, m ≤ 105), the height and width of the harp in units. Each of the following n + m lines contains 4 space-separated tokens, describing a single string: two symbols ai, bi and two integer numbers pi, qi. The pair ai, pi describes the first pin, and the pair bi, qi describes the second pin of the string;A pair s, x describes the position of a single pin in a following way: s is equal to one of the symbols "L", "T", "R" or "B" (without quotes), which means that the pin is positioned on the left, top, right or bottom side of the harp accordingly; x is equal to the number of the row, if the pin is on the left or right border of the harp, and to the number of the column, if the pin is on the top or bottom border of the harp. It is guaranteed that no two different strings are connected to the same pin.OutputIf it is possible to rearrange the rows and columns to fix the harp, on the first line output n space-separated integers — the old numbers of rows now placed from top to bottom in the fixed harp. On the second line, output m space-separated integers — the old numbers of columns now placed from left to right in the fixed harp.If it is impossible to rearrange the rows and columns to fix the harp, output "No solution" (without quotes).ExamplesInput3 4L T 1 3L B 2 2L B 3 3T R 1 2T B 2 1T R 4 1B R 4 3Output1 2 3 3 2 1 4 Input3 3L T 1 1T R 3 1R B 3 3B L 1 3L R 2 2T B 2 2OutputNo solution	Input3 4L T 1 3L B 2 2L B 3 3T R 1 2T B 2 1T R 4 1B R 4 3	Output1 2 3 3 2 1 4	2 seconds	256 megabytes	['geometry', 'math', 'strings', '*3100']
D. Maximum Waterfalltime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputEmuskald was hired to design an artificial waterfall according to the latest trends in landscape architecture. A modern artificial waterfall consists of multiple horizontal panels affixed to a wide flat wall. The water flows down the top of the wall from panel to panel until it reaches the bottom of the wall.The wall has height t and has n panels on the wall. Each panel is a horizontal segment at height hi which begins at li and ends at ri. The i-th panel connects the points (li, hi) and (ri, hi) of the plane. The top of the wall can be considered a panel connecting the points ( - 109, t) and (109, t). Similarly, the bottom of the wall can be considered a panel connecting the points ( - 109, 0) and (109, 0). No two panels share a common point.Emuskald knows that for the waterfall to be aesthetically pleasing, it can flow from panel i to panel j () only if the following conditions hold: max(li, lj) < min(ri, rj) (horizontal projections of the panels overlap); hj < hi (panel j is below panel i); there is no such panel k (hj < hk < hi) that the first two conditions hold for the pairs (i, k) and (k, j). Then the flow for is equal to min(ri, rj) - max(li, lj), the length of their horizontal projection overlap.Emuskald has decided that in his waterfall the water will flow in a single path from top to bottom. If water flows to a panel (except the bottom of the wall), the water will fall further to exactly one lower panel. The total amount of water flow in the waterfall is then defined as the minimum horizontal projection overlap between two consecutive panels in the path of the waterfall. Formally: the waterfall consists of a single path of panels ; the flow of the waterfall is the minimum flow in the path . To make a truly great waterfall Emuskald must maximize this water flow, but there are too many panels and he is having a hard time planning his creation. Below is an example of a waterfall Emuskald wants: Help Emuskald maintain his reputation and find the value of the maximum possible water flow.InputThe first line of input contains two space-separated integers n and t (1 ≤ n ≤ 105, 2 ≤ t ≤ 109), the number of the panels excluding the top and the bottom panels, and the height of the wall. Each of the n following lines contain three space-separated integers hi, li and ri (0 < hi < t, - 109 ≤ li < ri ≤ 109), the height, left and right ends of the i-th panel segment.It is guaranteed that no two segments share a common point.OutputOutput a single integer — the maximum possible amount of water flow in the desired waterfall.ExamplesInput5 64 1 63 2 75 9 113 10 151 13 16Output4Input6 54 2 83 1 22 2 32 6 121 0 71 8 11Output2NoteThe first test case corresponds to the picture.	Input5 64 1 63 2 75 9 113 10 151 13 16	Output4	2 seconds	256 megabytes	['data structures', 'dp', 'graphs', 'sortings', '*2600']
C. Flawed Flowtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputEmuskald considers himself a master of flow algorithms. Now he has completed his most ingenious program yet — it calculates the maximum flow in an undirected graph. The graph consists of n vertices and m edges. Vertices are numbered from 1 to n. Vertices 1 and n being the source and the sink respectively.However, his max-flow algorithm seems to have a little flaw — it only finds the flow volume for each edge, but not its direction. Help him find for each edge the direction of the flow through this edges. Note, that the resulting flow should be correct maximum flow.More formally. You are given an undirected graph. For each it's undirected edge (ai, bi) you are given the flow volume ci. You should direct all edges in such way that the following conditions hold: for each vertex v (1 < v < n), sum of ci of incoming edges is equal to the sum of ci of outcoming edges; vertex with number 1 has no incoming edges; the obtained directed graph does not have cycles. InputThe first line of input contains two space-separated integers n and m (2 ≤ n ≤ 2·105, n - 1 ≤ m ≤ 2·105), the number of vertices and edges in the graph. The following m lines contain three space-separated integers ai, bi and ci (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ ci ≤ 104), which means that there is an undirected edge from ai to bi with flow volume ci.It is guaranteed that there are no two edges connecting the same vertices; the given graph is connected; a solution always exists.OutputOutput m lines, each containing one integer di, which should be 0 if the direction of the i-th edge is ai → bi (the flow goes from vertex ai to vertex bi) and should be 1 otherwise. The edges are numbered from 1 to m in the order they are given in the input.If there are several solutions you can print any of them.ExamplesInput3 33 2 101 2 103 1 5Output101Input4 51 2 101 3 102 3 54 2 153 4 5Output00110NoteIn the first test case, 10 flow units pass through path , and 5 flow units pass directly from source to sink: .	Input3 33 2 101 2 103 1 5	Output101	2 seconds	256 megabytes	['constructive algorithms', 'flows', 'graphs', 'greedy', '*2100']
B. Greenhouse Effecttime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputEmuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.InputThe first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number si (1 ≤ si ≤ m), and one real number xi (0 ≤ xi ≤ 109), the species and position of the i-th plant. Each xi will contain no more than 6 digits after the decimal point.It is guaranteed that all xi are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their xi coordinates (xi < xi + 1, 1 ≤ i < n).OutputOutput a single integer — the minimum number of plants to be replanted.ExamplesInput3 22 11 2.01 3.100Output1Input3 31 5.02 5.53 6.0Output0Input6 31 14.2842352 17.9213821 20.3281723 20.8423311 25.7901451 27.204125Output2NoteIn the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.In the second test case, the species are already in the correct order, so no replanting is needed.	Input3 22 11 2.01 3.100	Output1	2 seconds	256 megabytes	['dp', '*1700']
A. Magical Boxestime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputEmuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure: Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.InputThe first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.OutputOutput a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.ExamplesInput20 31 5Output3Input10 4Output1Input21 102 2Output3NotePicture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.In the second test case, we can put all four small boxes into a box with side length 2.	Input20 31 5	Output3	2 seconds	256 megabytes	['greedy', 'math', '*1600']
E. Playlisttime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputManao's friends often send him new songs. He never listens to them right away. Instead, he compiles them into a playlist. When he feels that his mind is open to new music, he opens the playlist and starts to listen to the songs.Of course, there are some songs that Manao doesn't particuarly enjoy. To get more pleasure from the received songs, he invented the following procedure of listening to the playlist: If after listening to some song Manao realizes that he liked it, then he remembers it and starts to listen to the next unlistened song. If after listening to some song Manao realizes that he did not like it, he listens to all the songs he liked up to this point and then begins to listen to the next unlistened song. For example, if Manao has four songs in the playlist, A, B, C, D (in the corresponding order) and he is going to like songs A and C in the end, then the order of listening is the following: Manao listens to A, he likes it, he remembers it. Manao listens to B, he does not like it, so he listens to A, again. Manao listens to C, he likes the song and he remembers it, too. Manao listens to D, but does not enjoy it and re-listens to songs A and C. That is, in the end Manao listens to song A three times, to song C twice and songs B and D once. Note that if Manao once liked a song, he will never dislike it on a subsequent listening.Manao has received n songs: the i-th of them is li seconds long and Manao may like it with a probability of pi percents. The songs could get on Manao's playlist in any order, so Manao wants to know the maximum expected value of the number of seconds after which the listening process will be over, for all possible permutations of the songs in the playlist.InputThe first line contains a single integer n (1 ≤ n ≤ 50000). The i-th of the following n lines contains two integers, separated by a single space — li and pi (15 ≤ li ≤ 1000, 0 ≤ pi ≤ 100) — the length of the i-th song in seconds and the probability that Manao will like the song, in percents.OutputIn a single line print a single real number — the maximum expected listening time over all permutations of songs. The answer will be considered valid if the absolute or relative error does not exceed 10 - 9.ExamplesInput3150 20150 50100 50Output537.500000000Input4300 0300 50240 50360 80Output2121.000000000NoteConsider the first test case. If Manao listens to the songs in the order in which they were originally compiled, the mathematical expectation will be equal to 467.5 seconds. The maximum expected value is obtained by putting the first song at the end of the playlist.Consider the second test case. The song which is 360 seconds long should be listened to first. The song 300 seconds long which Manao will dislike for sure should be put in the end.	Input3150 20150 50100 50	Output537.500000000	1 second	256 megabytes	['math', 'probabilities', 'sortings', '*2100']
D. Wall Barstime limit per test4 secondsmemory limit per test512 megabytesinputstandard inputoutputstandard outputManao is working for a construction company. Recently, an order came to build wall bars in a children's park. Manao was commissioned to develop a plan of construction, which will enable the company to save the most money.After reviewing the formal specifications for the wall bars, Manao discovered a number of controversial requirements and decided to treat them to the company's advantage. His resulting design can be described as follows: Let's introduce some unit of length. The construction center is a pole of height n. At heights 1, 2, ..., n exactly one horizontal bar sticks out from the pole. Each bar sticks in one of four pre-fixed directions. A child can move from one bar to another if the distance between them does not exceed h and they stick in the same direction. If a child is on the ground, he can climb onto any of the bars at height between 1 and h. In Manao's construction a child should be able to reach at least one of the bars at heights n - h + 1, n - h + 2, ..., n if he begins at the ground. The figure to the left shows what a common set of wall bars looks like. The figure to the right shows Manao's construction Manao is wondering how many distinct construction designs that satisfy his requirements exist. As this number can be rather large, print the remainder after dividing it by 1000000009 (109 + 9). Two designs are considered distinct if there is such height i, that the bars on the height i in these designs don't stick out in the same direction.InputA single line contains two space-separated integers, n and h (1 ≤ n ≤ 1000, 1 ≤ h ≤ min(n, 30)).OutputIn a single line print the remainder after dividing the number of designs by 1000000009 (109 + 9).ExamplesInput5 1Output4Input4 2Output148Input4 3Output256Input5 2Output376NoteConsider several designs for h = 2. A design with the first bar sticked out in direction d1, the second — in direction d2 and so on (1 ≤ di ≤ 4) is denoted as string d1d2...dn.Design "1231" (the first three bars are sticked out in different directions, the last one — in the same as first). A child can reach neither the bar at height 3 nor the bar at height 4.Design "414141". A child can reach the bar at height 5. To do this, he should first climb at the first bar, then at the third and then at the fifth one. He can also reach bar at height 6 by the route second → fourth → sixth bars.Design "123333". The child can't reach the upper two bars.Design "323323". The bar at height 6 can be reached by the following route: first → third → fourth → sixth bars.	Input5 1	Output4	4 seconds	512 megabytes	['dp', '*2300']
C. Beautiful Sets of Pointstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputManao has invented a new mathematical term — a beautiful set of points. He calls a set of points on a plane beautiful if it meets the following conditions: The coordinates of each point in the set are integers. For any two points from the set, the distance between them is a non-integer. Consider all points (x, y) which satisfy the inequations: 0 ≤ x ≤ n; 0 ≤ y ≤ m; x + y > 0. Choose their subset of maximum size such that it is also a beautiful set of points.InputThe single line contains two space-separated integers n and m (1 ≤ n, m ≤ 100).OutputIn the first line print a single integer — the size k of the found beautiful set. In each of the next k lines print a pair of space-separated integers — the x- and y- coordinates, respectively, of a point from the set.If there are several optimal solutions, you may print any of them.ExamplesInput2 2Output30 11 22 0Input4 3Output40 32 13 04 2NoteConsider the first sample. The distance between points (0, 1) and (1, 2) equals , between (0, 1) and (2, 0) — , between (1, 2) and (2, 0) — . Thus, these points form a beautiful set. You cannot form a beautiful set with more than three points out of the given points. Note that this is not the only solution.	Input2 2	Output30 11 22 0	1 second	256 megabytes	['constructive algorithms', 'implementation', '*1500']
B. Buttonstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputManao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.InputA single line contains integer n (1 ≤ n ≤ 2000) — the number of buttons the lock has.OutputIn a single line print the number of times Manao has to push a button in the worst-case scenario.ExamplesInput2Output3Input3Output7NoteConsider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.	Input2	Output3	1 second	256 megabytes	['implementation', 'math', '*1000']
A. Gamestime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputManao works on a sports TV. He's spent much time watching the football games of some country. After a while he began to notice different patterns. For example, each team has two sets of uniforms: home uniform and guest uniform. When a team plays a game at home, the players put on the home uniform. When a team plays as a guest on somebody else's stadium, the players put on the guest uniform. The only exception to that rule is: when the home uniform color of the host team matches the guests' uniform, the host team puts on its guest uniform as well. For each team the color of the home and guest uniform is different.There are n teams taking part in the national championship. The championship consists of n·(n - 1) games: each team invites each other team to its stadium. At this point Manao wondered: how many times during the championship is a host team going to put on the guest uniform? Note that the order of the games does not affect this number.You know the colors of the home and guest uniform for each team. For simplicity, the colors are numbered by integers in such a way that no two distinct colors have the same number. Help Manao find the answer to his question.InputThe first line contains an integer n (2 ≤ n ≤ 30). Each of the following n lines contains a pair of distinct space-separated integers hi, ai (1 ≤ hi, ai ≤ 100) — the colors of the i-th team's home and guest uniforms, respectively.OutputIn a single line print the number of games where the host team is going to play in the guest uniform.ExamplesInput31 22 43 4Output1Input4100 4242 1005 42100 5Output5Input21 21 2Output0NoteIn the first test case the championship consists of 6 games. The only game with the event in question is the game between teams 2 and 1 on the stadium of team 2.In the second test sample the host team will have to wear guest uniform in the games between teams: 1 and 2, 2 and 1, 2 and 3, 3 and 4, 4 and 2 (the host team is written first).	Input31 22 43 4	Output1	1 second	256 megabytes	['brute force', '*800']
C. Berland Traffictime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputBerland traffic is very different from traffic in other countries. The capital of Berland consists of n junctions and m roads. Each road connects a pair of junctions. There can be multiple roads between a pair of junctions. For each road we know its capacity: value ci is the maximum number of cars that can drive along a road in any direction per a unit of time. For each road, the cars can drive along it in one of two direction. That it, the cars can't simultaneously move in both directions. A road's traffic is the number of cars that goes along it per a unit of time. For road (ai, bi) this value is negative, if the traffic moves from bi to ai. A road's traffic can be a non-integer number.The capital has two special junctions — the entrance to the city (junction 1) and the exit from the city (junction n). For all other junctions it is true that the traffic is not lost there. That is, for all junctions except for 1 and n the incoming traffic sum equals the outgoing traffic sum.Traffic has an unusual peculiarity in the capital of Berland — for any pair of junctions (x, y) the sum of traffics along any path from x to y doesn't change depending on the choice of the path. Such sum includes traffic along all roads on the path (possible with the "minus" sign, if the traffic along the road is directed against the direction of the road on the path from x to y).Your task is to find the largest traffic that can pass trough the city per one unit of time as well as the corresponding traffic for each road. InputThe first line contains a positive integer n — the number of junctions (2 ≤ n ≤ 100). The second line contains integer m (1 ≤ m ≤ 5000) — the number of roads. Next m lines contain the roads' descriptions. Each road contains a group of three numbers ai, bi, ci, where ai, bi are the numbers of junctions, connected by the given road, and ci (1 ≤ ai, bi ≤ n; ai ≠ bi; 0 ≤ ci ≤ 10000) is the largest permissible traffic along this road.OutputIn the first line print the required largest traffic across the city. Then print m lines, on each line print the speed, at which the traffic moves along the corresponding road. If the direction doesn't match the order of the junctions, given in the input, then print the traffic with the minus sign. Print the numbers with accuracy of at least five digits after the decimal point.If there are many optimal solutions, print any of them.ExamplesInput231 2 21 2 42 1 1000Output6.000002.000002.00000-2.00000Input7111 2 71 2 71 3 71 4 72 3 72 5 73 6 74 7 75 4 75 6 76 7 7Output13.000002.000002.000003.000006.000001.000003.000004.000007.000001.000002.000006.00000	Input231 2 21 2 42 1 1000	Output6.000002.000002.00000-2.00000	2 seconds	256 megabytes	['math', 'matrices', '*2700']
B. Dominoestime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou have a set of dominoes. Each domino is a rectangular tile with a line dividing its face into two square ends. Can you put all dominoes in a line one by one from left to right so that any two dominoes touched with the sides that had the same number of points? You can rotate the dominoes, changing the left and the right side (domino "1-4" turns into "4-1").InputThe first line contains number n (1 ≤ n ≤ 100). Next n lines contains the dominoes. Each of these lines contains two numbers — the number of points (spots) on the left and the right half, correspondingly. The numbers of points (spots) are non-negative integers from 0 to 6.OutputPrint "No solution", if it is impossible to arrange the dominoes in the required manner. If the solution exists, then describe any way to arrange the dominoes. You put the dominoes from left to right. In each of n lines print the index of the domino to put in the corresponding position and then, after a space, character "+" (if you don't need to turn the domino) or "–" (if you need to turn it).ExamplesInput51 22 42 46 42 1Output2 -1 -5 -3 +4 -	Input51 22 42 46 42 1	Output2 -1 -5 -3 +4 -	2 seconds	256 megabytes	['dfs and similar', 'graphs', '*2000']
A. Subtractionstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou've got two numbers. As long as they are both larger than zero, they go through the same operation: subtract the lesser number from the larger one. If they equal substract one number from the another. For example, one operation transforms pair (4,17) to pair (4,13), it transforms (5,5) to (0,5).You've got some number of pairs (ai, bi). How many operations will be performed for each of them?InputThe first line contains the number of pairs n (1 ≤ n ≤ 1000). Then follow n lines, each line contains a pair of positive integers ai, bi (1 ≤ ai, bi ≤ 109).OutputPrint the sought number of operations for each pair on a single line.ExamplesInput24 177 987654321Output8141093479	Input24 177 987654321	Output8141093479	1 second	256 megabytes	['math', 'number theory', '*900']
E. More Queries to Array...time limit per test5 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou've got an array, consisting of n integers: a1, a2, ..., an. Your task is to quickly run the queries of two types: Assign value x to all elements from l to r inclusive. After such query the values of the elements of array al, al + 1, ..., ar become equal to x. Calculate and print sum , where k doesn't exceed 5. As the value of the sum can be rather large, you should print it modulo 1000000007 (109 + 7).InputThe first line contains two integers n and m (1 ≤ n, m ≤ 105), showing, how many numbers are in the array and the number of queries, correspondingly. The second line contains n integers: a1, a2, ..., an (0 ≤ ai ≤ 109) — the initial values of the array elements.Then m queries follow, one per line: The assign query has the following format: "", (1 ≤ l ≤ r ≤ n; 0 ≤ x ≤ 109). The query to calculate the sum has the following format: "", (1 ≤ l ≤ r ≤ n; 0 ≤ k ≤ 5).All numbers in the input are integers.OutputFor each query to calculate the sum print an integer — the required sum modulo 1000000007 (109 + 7).ExamplesInput4 55 10 2 1? 1 2 1= 2 2 0? 2 4 3= 1 4 1? 1 4 5Output25431300Input3 11000000000 1000000000 1000000000? 1 3 0Output999999986	Input4 55 10 2 1? 1 2 1= 2 2 0? 2 4 3= 1 4 1? 1 4 5	Output25431300	5 seconds	256 megabytes	['data structures', 'math', '*2500']
D. BerDonaldstime limit per test5 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputBerDonalds, a well-known fast food restaurant, is going to open a cafe in Bertown. The important thing is to choose the new restaurant's location so that it would be easy to get there. The Bertown road system is represented by n junctions, connected by m bidirectional roads. For each road we know its length. We also know that we can get from any junction to any other one, moving along the roads.Your task is to find such location of the restaurant, that the shortest distance along the roads from the cafe to the farthest junction would be minimum. Note that the restaurant can be located not only on the junction, but at any point of any road.InputThe first line contains two integers n and m () — the number of junctions and the number of roads, correspondingly. Then m lines follow, describing all Bertown roads. Each road is described by three integers ai, bi, wi (1 ≤ ai, bi ≤ n, ai ≠ bi; 1 ≤ wi ≤ 105), where ai and bi are the numbers of the junctions, connected by the i-th road, and wi is the length of the i-th road. It is guaranteed that each road connects two distinct junctions, there is at most one road between any two junctions, and you can get from any junction to any other one.OutputPrint a single real number — the shortest distance from the optimal restaurant location to the farthest junction. The answer will be considered correct, if its absolute or relative error doesn't exceed 10 - 9.ExamplesInput2 11 2 1Output0.50Input3 31 2 12 3 11 3 1Output1.00Input3 21 2 1002 3 1Output50.50	Input2 11 2 1	Output0.50	5 seconds	256 megabytes	['graphs', 'math', 'shortest paths', '*2400']
C. Below the Diagonaltime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou are given a square matrix consisting of n rows and n columns. We assume that the rows are numbered from 1 to n from top to bottom and the columns are numbered from 1 to n from left to right. Some cells (n - 1 cells in total) of the the matrix are filled with ones, the remaining cells are filled with zeros. We can apply the following operations to the matrix: Swap i-th and j-th rows of the matrix; Swap i-th and j-th columns of the matrix. You are asked to transform the matrix into a special form using these operations. In that special form all the ones must be in the cells that lie below the main diagonal. Cell of the matrix, which is located on the intersection of the i-th row and of the j-th column, lies below the main diagonal if i > j.InputThe first line contains an integer n (2 ≤ n ≤ 1000) — the number of rows and columns. Then follow n - 1 lines that contain one's positions, one per line. Each position is described by two integers xk, yk (1 ≤ xk, yk ≤ n), separated by a space. A pair (xk, yk) means that the cell, which is located on the intersection of the xk-th row and of the yk-th column, contains one.It is guaranteed that all positions are distinct.OutputPrint the description of your actions. These actions should transform the matrix to the described special form.In the first line you should print a non-negative integer m (m ≤ 105) — the number of actions. In each of the next m lines print three space-separated integers t, i, j (1 ≤ t ≤ 2, 1 ≤ i, j ≤ n, i ≠ j), where t = 1 if you want to swap rows, t = 2 if you want to swap columns, and i and j denote the numbers of rows or columns respectively.Please note, that you do not need to minimize the number of operations, but their number should not exceed 105. If there are several solutions, you may print any of them.ExamplesInput21 2Output22 1 21 1 2Input33 11 3Output32 2 31 1 31 1 2Input32 13 2Output0	Input21 2	Output22 1 21 1 2	2 seconds	256 megabytes	['constructive algorithms', 'greedy', 'math', '*2100']
B. Queue at the Schooltime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputDuring the break the schoolchildren, boys and girls, formed a queue of n people in the canteen. Initially the children stood in the order they entered the canteen. However, after a while the boys started feeling awkward for standing in front of the girls in the queue and they started letting the girls move forward each second. Let's describe the process more precisely. Let's say that the positions in the queue are sequentially numbered by integers from 1 to n, at that the person in the position number 1 is served first. Then, if at time x a boy stands on the i-th position and a girl stands on the (i + 1)-th position, then at time x + 1 the i-th position will have a girl and the (i + 1)-th position will have a boy. The time is given in seconds.You've got the initial position of the children, at the initial moment of time. Determine the way the queue is going to look after t seconds.InputThe first line contains two integers n and t (1 ≤ n, t ≤ 50), which represent the number of children in the queue and the time after which the queue will transform into the arrangement you need to find. The next line contains string s, which represents the schoolchildren's initial arrangement. If the i-th position in the queue contains a boy, then the i-th character of string s equals "B", otherwise the i-th character equals "G".OutputPrint string a, which describes the arrangement after t seconds. If the i-th position has a boy after the needed time, then the i-th character a must equal "B", otherwise it must equal "G".ExamplesInput5 1BGGBGOutputGBGGBInput5 2BGGBGOutputGGBGBInput4 1GGGBOutputGGGB	Input5 1BGGBG	OutputGBGGB	2 seconds	256 megabytes	['constructive algorithms', 'graph matchings', 'implementation', 'shortest paths', '*800']
A. Stones on the Tabletime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThere are n stones on the table in a row, each of them can be red, green or blue. Count the minimum number of stones to take from the table so that any two neighboring stones had different colors. Stones in a row are considered neighboring if there are no other stones between them.InputThe first line contains integer n (1 ≤ n ≤ 50) — the number of stones on the table. The next line contains string s, which represents the colors of the stones. We'll consider the stones in the row numbered from 1 to n from left to right. Then the i-th character s equals "R", if the i-th stone is red, "G", if it's green and "B", if it's blue.OutputPrint a single integer — the answer to the problem.ExamplesInput3RRGOutput1Input5RRRRROutput4Input4BRBGOutput0	Input3RRG	Output1	2 seconds	256 megabytes	['implementation', '*800']
B. Roadside Trees (Simplified Edition)time limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputSquirrel Liss loves nuts. There are n trees (numbered 1 to n from west to east) along a street and there is a delicious nut on the top of each tree. The height of the tree i is hi. Liss wants to eat all nuts.Now Liss is on the root of the tree with the number 1. In one second Liss can perform one of the following actions: Walk up or down one unit on a tree. Eat a nut on the top of the current tree. Jump to the next tree. In this action the height of Liss doesn't change. More formally, when Liss is at height h of the tree i (1 ≤ i ≤ n - 1), she jumps to height h of the tree i + 1. This action can't be performed if h > hi + 1. Compute the minimal time (in seconds) required to eat all nuts.InputThe first line contains an integer n (1 ≤ n ≤ 105) — the number of trees.Next n lines contains the height of trees: i-th line contains an integer hi (1 ≤ hi ≤ 104) — the height of the tree with the number i.OutputPrint a single integer — the minimal time required to eat all nuts in seconds.ExamplesInput212Output5Input521211Output14	Input212	Output5	2 seconds	256 megabytes	['greedy', 'implementation', '*1000']
A. Colorful Stones (Simplified Edition)time limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThere is a sequence of colorful stones. The color of each stone is one of red, green, or blue. You are given a string s. The i-th (1-based) character of s represents the color of the i-th stone. If the character is "R", "G", or "B", the color of the corresponding stone is red, green, or blue, respectively.Initially Squirrel Liss is standing on the first stone. You perform instructions one or more times.Each instruction is one of the three types: "RED", "GREEN", or "BLUE". After an instruction c, if Liss is standing on a stone whose colors is c, Liss will move one stone forward, else she will not move.You are given a string t. The number of instructions is equal to the length of t, and the i-th character of t represents the i-th instruction.Calculate the final position of Liss (the number of the stone she is going to stand on in the end) after performing all the instructions, and print its 1-based position. It is guaranteed that Liss don't move out of the sequence.InputThe input contains two lines. The first line contains the string s (1 ≤ \|s\| ≤ 50). The second line contains the string t (1 ≤ \|t\| ≤ 50). The characters of each string will be one of "R", "G", or "B". It is guaranteed that Liss don't move out of the sequence.OutputPrint the final 1-based position of Liss in a single line.ExamplesInputRGBRRROutput2InputRRRBGBRBBBBBBRROutput3InputBRRBGBRGRBGRGRRGGBGBGBRGBRGRGGGRBRRRBRBBBGRRRGGBBBBBRBGGRGRGBBBRBGRBRBBBBRBRRRBGBBGBBRRBBGGRBRRBRGRBOutput15	InputRGBRRR	Output2	2 seconds	256 megabytes	['implementation', '*800']
E. Roadside Treestime limit per test5 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputSquirrel Liss loves nuts. Liss asks you to plant some nut trees.There are n positions (numbered 1 to n from west to east) to plant a tree along a street. Trees grow one meter per month. At the beginning of each month you should process one query. The query is one of the following types: Plant a tree of height h at position p. Cut down the x-th existent (not cut) tree from the west (where x is 1-indexed). When we cut the tree it drops down and takes all the available place at the position where it has stood. So no tree can be planted at this position anymore. After processing each query, you should print the length of the longest increasing subsequence. A subset of existent trees is called an increasing subsequence if the height of the trees in the set is strictly increasing from west to east (for example, the westmost tree in the set must be the shortest in the set). The length of the increasing subsequence is the number of trees in it.Note that Liss don't like the trees with the same heights, so it is guaranteed that at any time no two trees have the exactly same heights.InputThe first line contains two integers: n and m (1 ≤ n ≤ 105; 1 ≤ m ≤ 2·105) — the number of positions and the number of queries.Next m lines contains the information of queries by following formats: If the i-th query is type 1, the i-th line contains three integers: 1, pi, and hi (1 ≤ pi ≤ n, 1 ≤ hi ≤ 10), where pi is the position of the new tree and hi is the initial height of the new tree. If the i-th query is type 2, the i-th line contains two integers: 2 and xi (1 ≤ xi ≤ 10), where the xi is the index of the tree we want to cut. The input is guaranteed to be correct, i.e., For type 1 queries, pi will be pairwise distinct. For type 2 queries, xi will be less than or equal to the current number of trees. At any time no two trees have the exactly same heights. In each line integers are separated by single spaces.OutputPrint m integers — the length of the longest increasing subsequence after each query. Separate the numbers by whitespaces.ExamplesInput4 61 1 11 4 41 3 42 21 2 82 3Output123222NoteStates of street after each query you can see on the following animation: If your browser doesn't support animation png, please see the gif version here: http://212.193.37.254/codeforces/images/162/roadtree.gif	Input4 61 1 11 4 41 3 42 21 2 82 3	Output123222	5 seconds	256 megabytes	['data structures', 'dp', '*3000']
D. Colorful Stonestime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThere are two sequences of colorful stones. The color of each stone is one of red, green, or blue. You are given two strings s and t. The i-th (1-based) character of s represents the color of the i-th stone of the first sequence. Similarly, the i-th (1-based) character of t represents the color of the i-th stone of the second sequence. If the character is "R", "G", or "B", the color of the corresponding stone is red, green, or blue, respectively.Initially Squirrel Liss is standing on the first stone of the first sequence and Cat Vasya is standing on the first stone of the second sequence. You can perform the following instructions zero or more times.Each instruction is one of the three types: "RED", "GREEN", or "BLUE". After an instruction c, the animals standing on stones whose colors are c will move one stone forward. For example, if you perform an instruction «RED», the animals standing on red stones will move one stone forward. You are not allowed to perform instructions that lead some animals out of the sequences. In other words, if some animals are standing on the last stones, you can't perform the instructions of the colors of those stones.A pair of positions (position of Liss, position of Vasya) is called a state. A state is called reachable if the state is reachable by performing instructions zero or more times from the initial state (1, 1). Calculate the number of distinct reachable states.InputThe input contains two lines. The first line contains the string s (1 ≤ \|s\| ≤ 106). The second line contains the string t (1 ≤ \|t\| ≤ 106). The characters of each string will be one of "R", "G", or "B".OutputPrint the number of distinct reachable states in a single line.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.ExamplesInputRBRRGGOutput5InputRGBBBRRBRROutput19InputRRRRRRRRRRRRRRRRRROutput8NoteIn the first example, there are five reachable states: (1, 1), (2, 2), (2, 3), (3, 2), and (3, 3). For example, the state (3, 3) is reachable because if you perform instructions "RED", "GREEN", and "BLUE" in this order from the initial state, the state will be (3, 3). The following picture shows how the instructions work in this case.	InputRBRRGG	Output5	2 seconds	256 megabytes	['dp', 'two pointers', '*2500']
C. Choosing Ballstime limit per test5 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThere are n balls. They are arranged in a row. Each ball has a color (for convenience an integer) and an integer value. The color of the i-th ball is ci and the value of the i-th ball is vi.Squirrel Liss chooses some balls and makes a new sequence without changing the relative order of the balls. She wants to maximize the value of this sequence.The value of the sequence is defined as the sum of following values for each ball (where a and b are given constants): If the ball is not in the beginning of the sequence and the color of the ball is same as previous ball's color, add (the value of the ball) × a. Otherwise, add (the value of the ball) × b. You are given q queries. Each query contains two integers ai and bi. For each query find the maximal value of the sequence she can make when a = ai and b = bi.Note that the new sequence can be empty, and the value of an empty sequence is defined as zero.InputThe first line contains two integers n and q (1 ≤ n ≤ 105; 1 ≤ q ≤ 500). The second line contains n integers: v1, v2, ..., vn (\|vi\| ≤ 105). The third line contains n integers: c1, c2, ..., cn (1 ≤ ci ≤ n).The following q lines contain the values of the constants a and b for queries. The i-th of these lines contains two integers ai and bi (\|ai\|, \|bi\| ≤ 105).In each line integers are separated by single spaces.OutputFor each query, output a line containing an integer — the answer to the query. The i-th line contains the answer to the i-th query in the input order.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.ExamplesInput6 31 -2 3 4 0 -11 2 1 2 1 15 1-2 11 0Output2094Input4 1-3 6 -1 21 2 3 11 -1Output5NoteIn the first example, to achieve the maximal value: In the first query, you should select 1st, 3rd, and 4th ball. In the second query, you should select 3rd, 4th, 5th and 6th ball. In the third query, you should select 2nd and 4th ball. Note that there may be other ways to achieve the maximal value.	Input6 31 -2 3 4 0 -11 2 1 2 1 15 1-2 11 0	Output2094	5 seconds	256 megabytes	['dp', '*2000']
B. Good Sequencestime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputSquirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions: The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1). No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q). All elements of the sequence are good integers. Find the length of the longest good sequence.InputThe input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).OutputPrint a single integer — the length of the longest good sequence.ExamplesInput52 3 4 6 9Output4Input91 2 3 5 6 7 8 9 10Output4NoteIn the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4.	Input52 3 4 6 9	Output4	2 seconds	256 megabytes	['dp', 'number theory', '*1500']
A. Escape from Stonestime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputSquirrel Liss lived in a forest peacefully, but unexpected trouble happens. Stones fall from a mountain. Initially Squirrel Liss occupies an interval [0, 1]. Next, n stones will fall and Liss will escape from the stones. The stones are numbered from 1 to n in order.The stones always fall to the center of Liss's interval. When Liss occupies the interval [k - d, k + d] and a stone falls to k, she will escape to the left or to the right. If she escapes to the left, her new interval will be [k - d, k]. If she escapes to the right, her new interval will be [k, k + d].You are given a string s of length n. If the i-th character of s is "l" or "r", when the i-th stone falls Liss will escape to the left or to the right, respectively. Find the sequence of stones' numbers from left to right after all the n stones falls.InputThe input consists of only one line. The only line contains the string s (1 ≤ \|s\| ≤ 106). Each character in s will be either "l" or "r".OutputOutput n lines — on the i-th line you should print the i-th stone's number from the left.ExamplesInputllrlrOutput35421InputrrlllOutput12543InputlrlrrOutput24531NoteIn the first example, the positions of stones 1, 2, 3, 4, 5 will be , respectively. So you should print the sequence: 3, 5, 4, 2, 1.	Inputllrlr	Output35421	2 seconds	256 megabytes	['constructive algorithms', 'data structures', 'implementation', 'two pointers', '*1200']
E. Rhombustime limit per test3 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou've got a table of size n × m. On the intersection of the i-th row (1 ≤ i ≤ n) and the j-th column (1 ≤ j ≤ m) there is a non-negative integer ai, j. Besides, you've got a non-negative integer k.Your task is to find such pair of integers (a, b) that meets these conditions: k ≤ a ≤ n - k + 1; k ≤ b ≤ m - k + 1; let's denote the maximum of the function among all integers x and y, that satisfy the inequalities k ≤ x ≤ n - k + 1 and k ≤ y ≤ m - k + 1, as mval; for the required pair of numbers the following equation must hold f(a, b) = mval. InputThe first line contains three space-separated integers n, m and k (1 ≤ n, m ≤ 1000, ). Next n lines each contains m integers: the j-th number on the i-th line equals ai, j (0 ≤ ai, j ≤ 106).The numbers in the lines are separated by spaces.OutputPrint the required pair of integers a and b. Separate the numbers by a space.If there are multiple correct answers, you are allowed to print any of them.ExamplesInput4 4 21 2 3 41 1 1 12 2 2 24 3 2 1Output3 2Input5 7 38 2 3 4 2 3 33 4 6 2 3 4 68 7 6 8 4 5 71 2 3 2 1 3 24 5 3 2 1 2 1Output3 3	Input4 4 21 2 3 41 1 1 12 2 2 24 3 2 1	Output3 2	3 seconds	256 megabytes	['brute force', 'data structures', 'dp', '*2500']
D. Cycle in Graphtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou've got a undirected graph G, consisting of n nodes. We will consider the nodes of the graph indexed by integers from 1 to n. We know that each node of graph G is connected by edges with at least k other nodes of this graph. Your task is to find in the given graph a simple cycle of length of at least k + 1.A simple cycle of length d (d > 1) in graph G is a sequence of distinct graph nodes v1, v2, ..., vd such, that nodes v1 and vd are connected by an edge of the graph, also for any integer i (1 ≤ i < d) nodes vi and vi + 1 are connected by an edge of the graph.InputThe first line contains three integers n, m, k (3 ≤ n, m ≤ 105; 2 ≤ k ≤ n - 1) — the number of the nodes of the graph, the number of the graph's edges and the lower limit on the degree of the graph node. Next m lines contain pairs of integers. The i-th line contains integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — the indexes of the graph nodes that are connected by the i-th edge. It is guaranteed that the given graph doesn't contain any multiple edges or self-loops. It is guaranteed that each node of the graph is connected by the edges with at least k other nodes of the graph.OutputIn the first line print integer r (r ≥ k + 1) — the length of the found cycle. In the next line print r distinct integers v1, v2, ..., vr (1 ≤ vi ≤ n) — the found simple cycle.It is guaranteed that the answer exists. If there are multiple correct answers, you are allowed to print any of them.ExamplesInput3 3 21 22 33 1Output31 2 3 Input4 6 34 31 21 31 42 32 4Output43 4 1 2	Input3 3 21 22 33 1	Output31 2 3	2 seconds	256 megabytes	['dfs and similar', 'graphs', '*1800']
C. Circle of Numberstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputOne day Vasya came up to the blackboard and wrote out n distinct integers from 1 to n in some order in a circle. Then he drew arcs to join the pairs of integers (a, b) (a ≠ b), that are either each other's immediate neighbors in the circle, or there is number c, such that a and с are immediate neighbors, and b and c are immediate neighbors. As you can easily deduce, in the end Vasya drew 2·n arcs.For example, if the numbers are written in the circle in the order 1, 2, 3, 4, 5 (in the clockwise direction), then the arcs will join pairs of integers (1, 2), (2, 3), (3, 4), (4, 5), (5, 1), (1, 3), (2, 4), (3, 5), (4, 1) and (5, 2).Much time has passed ever since, the numbers we wiped off the blackboard long ago, but recently Vasya has found a piece of paper with 2·n written pairs of integers that were joined with the arcs on the board. Vasya asks you to find the order of numbers in the circle by these pairs.InputThe first line of the input contains a single integer n (5 ≤ n ≤ 105) that shows, how many numbers were written on the board. Next 2·n lines contain pairs of integers ai, bi (1 ≤ ai, bi ≤ n, ai ≠ bi) — the numbers that were connected by the arcs.It is guaranteed that no pair of integers, connected by a arc, occurs in the input more than once. The pairs of numbers and the numbers in the pairs are given in the arbitrary order.OutputIf Vasya made a mistake somewhere and there isn't any way to place numbers from 1 to n on the circle according to the statement, then print a single number "-1" (without the quotes). Otherwise, print any suitable sequence of n distinct integers from 1 to n. If there are multiple solutions, you are allowed to print any of them. Specifically, it doesn't matter which number you write first to describe the sequence of the order. It also doesn't matter whether you write out the numbers in the clockwise or counter-clockwise direction.ExamplesInput51 22 33 44 55 11 32 43 54 15 2Output1 2 3 4 5 Input65 64 35 32 46 13 16 22 51 43 61 24 5Output1 2 4 5 3 6	Input51 22 33 44 55 11 32 43 54 15 2	Output1 2 3 4 5	2 seconds	256 megabytes	['brute force', 'dfs and similar', 'implementation', '*2000']
B. Squarestime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputVasya has found a piece of paper with a coordinate system written on it. There are n distinct squares drawn in this coordinate system. Let's number the squares with integers from 1 to n. It turned out that points with coordinates (0, 0) and (ai, ai) are the opposite corners of the i-th square.Vasya wants to find such integer point (with integer coordinates) of the plane, that belongs to exactly k drawn squares. We'll say that a point belongs to a square, if the point is located either inside the square, or on its boundary. Help Vasya find a point that would meet the described limits.InputThe first line contains two space-separated integers n, k (1 ≤ n, k ≤ 50). The second line contains space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).It is guaranteed that all given squares are distinct.OutputIn a single line print two space-separated integers x and y (0 ≤ x, y ≤ 109) — the coordinates of the point that belongs to exactly k squares. If there are multiple answers, you are allowed to print any of them. If there is no answer, print "-1" (without the quotes).ExamplesInput4 35 1 3 4Output2 1Input3 12 4 1Output4 0Input4 505 1 10 2Output-1	Input4 35 1 3 4	Output2 1	2 seconds	256 megabytes	['greedy', 'implementation', 'sortings', '*900']
A. Beautiful Matrixtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix: Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5). Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5). You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.InputThe input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.OutputPrint a single integer — the minimum number of moves needed to make the matrix beautiful.ExamplesInput0 0 0 0 00 0 0 0 10 0 0 0 00 0 0 0 00 0 0 0 0Output3Input0 0 0 0 00 0 0 0 00 1 0 0 00 0 0 0 00 0 0 0 0Output1	Input0 0 0 0 00 0 0 0 10 0 0 0 00 0 0 0 00 0 0 0 0	Output3	2 seconds	256 megabytes	['implementation', '*800']
B. Roma and Changing Signstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputRoma works in a company that sells TVs. Now he has to prepare a report for the last year.Roma has got a list of the company's incomes. The list is a sequence that consists of n integers. The total income of the company is the sum of all integers in sequence. Roma decided to perform exactly k changes of signs of several numbers in the sequence. He can also change the sign of a number one, two or more times.The operation of changing a number's sign is the operation of multiplying this number by -1.Help Roma perform the changes so as to make the total income of the company (the sum of numbers in the resulting sequence) maximum. Note that Roma should perform exactly k changes.InputThe first line contains two integers n and k (1 ≤ n, k ≤ 105), showing, how many numbers are in the sequence and how many swaps are to be made.The second line contains a non-decreasing sequence, consisting of n integers ai (\|ai\| ≤ 104).The numbers in the lines are separated by single spaces. Please note that the given sequence is sorted in non-decreasing order.OutputIn the single line print the answer to the problem — the maximum total income that we can obtain after exactly k changes.ExamplesInput3 2-1 -1 1Output3Input3 1-1 -1 1Output1NoteIn the first sample we can get sequence [1, 1, 1], thus the total income equals 3.In the second test, the optimal strategy is to get sequence [-1, 1, 1], thus the total income equals 1.	Input3 2-1 -1 1	Output3	2 seconds	256 megabytes	['greedy', '*1200']
A. Roma and Lucky Numberstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputRoma (a popular Russian name that means 'Roman') loves the Little Lvov Elephant's lucky numbers.Let us remind you that lucky numbers are positive integers whose decimal representation only contains lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.Roma's got n positive integers. He wonders, how many of those integers have not more than k lucky digits? Help him, write the program that solves the problem.InputThe first line contains two integers n, k (1 ≤ n, k ≤ 100). The second line contains n integers ai (1 ≤ ai ≤ 109) — the numbers that Roma has. The numbers in the lines are separated by single spaces.OutputIn a single line print a single integer — the answer to the problem.ExamplesInput3 41 2 4Output3Input3 2447 44 77Output2NoteIn the first sample all numbers contain at most four lucky digits, so the answer is 3.In the second sample number 447 doesn't fit in, as it contains more than two lucky digits. All other numbers are fine, so the answer is 2.	Input3 41 2 4	Output3	1 second	256 megabytes	['implementation', '*800']
E. Maxim and Calculatortime limit per test4 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputMaxim has got a calculator. The calculator has two integer cells. Initially, the first cell contains number 1, and the second cell contains number 0. In one move you can perform one of the following operations: Let's assume that at the current time the first cell contains number a, and the second cell contains number b. Write to the second cell number b + 1; Let's assume that at the current time the first cell contains number a, and the second cell contains number b. Write to the first cell number a·b. Maxim is wondering, how many integers x (l ≤ x ≤ r) are there, such that we can write the number x to the first cell of the calculator, having performed at most p moves.InputThe first line contains three integers: l, r, p (2 ≤ l ≤ r ≤ 109, 1 ≤ p ≤ 100). The numbers in the line are separated by single spaces.OutputIn a single line print a single integer — the answer to the problem.ExamplesInput2 10 3Output1Input2 111 100Output106Input2 111 11Output47	Input2 10 3	Output1	4 seconds	256 megabytes	['brute force', 'dp', 'two pointers', '*2800']
D. Maxim and Increasing Subsequencetime limit per test6 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputMaxim loves sequences, especially those that strictly increase. He is wondering, what is the length of the longest increasing subsequence of the given sequence a?Sequence a is given as follows: the length of the sequence equals n × t; (1 ≤ i ≤ n × t), where operation means taking the remainder after dividing number x by number y. Sequence s1, s2, ..., sr of length r is a subsequence of sequence a1, a2, ..., an, if there is such increasing sequence of indexes i1, i2, ..., ir (1 ≤ i1 < i2 < ... < ir ≤ n), that aij = sj. In other words, the subsequence can be obtained from the sequence by crossing out some elements.Sequence s1, s2, ..., sr is increasing, if the following inequality holds: s1 < s2 < ... < sr.Maxim have k variants of the sequence a. Help Maxim to determine for each sequence the length of the longest increasing subsequence.InputThe first line contains four integers k, n, maxb and t (1 ≤ k ≤ 10; 1 ≤ n, maxb ≤ 105; 1 ≤ t ≤ 109; n × maxb ≤ 2·107). Each of the next k lines contain n integers b1, b2, ..., bn (1 ≤ bi ≤ maxb). Note that for each variant of the sequence a the values n, maxb and t coincide, the only arrays bs differ.The numbers in the lines are separated by single spaces.OutputPrint k integers — the answers for the variants of the sequence a. Print the answers in the order the variants follow in the input.ExamplesInput3 3 5 23 2 11 2 32 3 1Output233	Input3 3 5 23 2 11 2 32 3 1	Output233	6 seconds	256 megabytes	['dp', '*2600']
C. Maxim and Matrixtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputMaxim loves to fill in a matrix in a special manner. Here is a pseudocode of filling in a matrix of size (m + 1) × (m + 1):Maxim asks you to count, how many numbers m (1 ≤ m ≤ n) are there, such that the sum of values in the cells in the row number m + 1 of the resulting matrix equals t.Expression (x xor y) means applying the operation of bitwise excluding "OR" to numbers x and y. The given operation exists in all modern programming languages. For example, in languages C++ and Java it is represented by character "^", in Pascal — by "xor".InputA single line contains two integers n and t (1 ≤ n, t ≤ 1012, t ≤ n + 1).Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.OutputIn a single line print a single integer — the answer to the problem. ExamplesInput1 1Output1Input3 2Output1Input3 3Output0Input1000000000000 1048576Output118606527258	Input1 1	Output1	2 seconds	256 megabytes	['constructive algorithms', 'dp', 'math', '*2000']
B. Maxim and Restauranttime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputMaxim has opened his own restaurant! The restaurant has got a huge table, the table's length is p meters.Maxim has got a dinner party tonight, n guests will come to him. Let's index the guests of Maxim's restaurant from 1 to n. Maxim knows the sizes of all guests that are going to come to him. The i-th guest's size (ai) represents the number of meters the guest is going to take up if he sits at the restaurant table.Long before the dinner, the guests line up in a queue in front of the restaurant in some order. Then Maxim lets the guests in, one by one. Maxim stops letting the guests in when there is no place at the restaurant table for another guest in the queue. There is no place at the restaurant table for another guest in the queue, if the sum of sizes of all guests in the restaurant plus the size of this guest from the queue is larger than p. In this case, not to offend the guest who has no place at the table, Maxim doesn't let any other guest in the restaurant, even if one of the following guests in the queue would have fit in at the table.Maxim is now wondering, what is the average number of visitors who have come to the restaurant for all possible n! orders of guests in the queue. Help Maxim, calculate this number.InputThe first line contains integer n (1 ≤ n ≤ 50) — the number of guests in the restaurant. The next line contains integers a1, a2, ..., an (1 ≤ ai ≤ 50) — the guests' sizes in meters. The third line contains integer p (1 ≤ p ≤ 50) — the table's length in meters. The numbers in the lines are separated by single spaces.OutputIn a single line print a real number — the answer to the problem. The answer will be considered correct, if the absolute or relative error doesn't exceed 10 - 4.ExamplesInput31 2 33Output1.3333333333NoteIn the first sample the people will come in the following orders: (1, 2, 3) — there will be two people in the restaurant; (1, 3, 2) — there will be one person in the restaurant; (2, 1, 3) — there will be two people in the restaurant; (2, 3, 1) — there will be one person in the restaurant; (3, 1, 2) — there will be one person in the restaurant; (3, 2, 1) — there will be one person in the restaurant. In total we get (2 + 1 + 2 + 1 + 1 + 1) / 6 = 8 / 6 = 1.(3).	Input31 2 33	Output1.3333333333	2 seconds	256 megabytes	['dp', 'math', 'probabilities', '*1900']
A. Maxim and Discountstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputMaxim always goes to the supermarket on Sundays. Today the supermarket has a special offer of discount systems.There are m types of discounts. We assume that the discounts are indexed from 1 to m. To use the discount number i, the customer takes a special basket, where he puts exactly qi items he buys. Under the terms of the discount system, in addition to the items in the cart the customer can receive at most two items from the supermarket for free. The number of the "free items" (0, 1 or 2) to give is selected by the customer. The only condition imposed on the selected "free items" is as follows: each of them mustn't be more expensive than the cheapest item out of the qi items in the cart.Maxim now needs to buy n items in the shop. Count the minimum sum of money that Maxim needs to buy them, if he use the discount system optimally well.Please assume that the supermarket has enough carts for any actions. Maxim can use the same discount multiple times. Of course, Maxim can buy items without any discounts.InputThe first line contains integer m (1 ≤ m ≤ 105) — the number of discount types. The second line contains m integers: q1, q2, ..., qm (1 ≤ qi ≤ 105). The third line contains integer n (1 ≤ n ≤ 105) — the number of items Maxim needs. The fourth line contains n integers: a1, a2, ..., an (1 ≤ ai ≤ 104) — the items' prices.The numbers in the lines are separated by single spaces.OutputIn a single line print a single integer — the answer to the problem.ExamplesInput12450 50 100 100Output200Input22 3550 50 50 50 50Output150Input1171 1 1 1 1 1 1Output3NoteIn the first sample Maxim needs to buy two items that cost 100 and get a discount for two free items that cost 50. In that case, Maxim is going to pay 200.In the second sample the best strategy for Maxim is to buy 3 items and get 2 items for free using the discount. In that case, Maxim is going to pay 150.	Input12450 50 100 100	Output200	2 seconds	256 megabytes	['greedy', 'sortings', '*1400']
E. Dividing Kingdomtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputA country called Flatland is an infinite two-dimensional plane. Flatland has n cities, each of them is a point on the plane.Flatland is ruled by king Circle IV. Circle IV has 9 sons. He wants to give each of his sons part of Flatland to rule. For that, he wants to draw four distinct straight lines, such that two of them are parallel to the Ox axis, and two others are parallel to the Oy axis. At that, no straight line can go through any city. Thus, Flatland will be divided into 9 parts, and each son will be given exactly one of these parts. Circle IV thought a little, evaluated his sons' obedience and decided that the i-th son should get the part of Flatland that has exactly ai cities.Help Circle find such four straight lines that if we divide Flatland into 9 parts by these lines, the resulting parts can be given to the sons so that son number i got the part of Flatland which contains ai cities.InputThe first line contains integer n (9 ≤ n ≤ 105) — the number of cities in Flatland. Next n lines each contain two space-separated integers: xi, yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th city. No two cities are located at the same point. The last line contains nine space-separated integers: .OutputIf there is no solution, print a single integer -1.Otherwise, print in the first line two distinct real space-separated numbers: x1, x2 — the abscissas of the straight lines that are parallel to the Oy axis. And in the second line print two distinct real space-separated numbers: y1, y2 — the ordinates of the straight lines, parallel to the Ox. If there are multiple solutions, print any of them. When the answer is being checked, a city is considered to lie on a straight line, if the distance between the city and the line doesn't exceed 10 - 6. Two straight lines are considered the same if the distance between them doesn't exceed 10 - 6.ExamplesInput91 11 21 32 12 22 33 13 23 31 1 1 1 1 1 1 1 1Output1.5000000000 2.50000000001.5000000000 2.5000000000Input154 4-1 -31 53 -4-4 4-1 13 -3-4 -5-3 33 24 1-4 2-2 -5-3 4-1 42 1 2 1 2 1 3 2 1Output-3.5000000000 2.00000000003.5000000000 -1.0000000000Input10-2 106 0-16 -6-4 13-4 -2-17 -109 1518 16-5 210 -52 1 1 1 1 1 1 1 1Output-1NoteThe solution for the first sample test is shown below: The solution for the second sample test is shown below: There is no solution for the third sample test.	Input91 11 21 32 12 22 33 13 23 31 1 1 1 1 1 1 1 1	Output1.5000000000 2.50000000001.5000000000 2.5000000000	2 seconds	256 megabytes	['binary search', 'brute force', 'data structures', '*2500']
D. Black and White Treetime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe board has got a painted tree graph, consisting of n nodes. Let us remind you that a non-directed graph is called a tree if it is connected and doesn't contain any cycles.Each node of the graph is painted black or white in such a manner that there aren't two nodes of the same color, connected by an edge. Each edge contains its value written on it as a non-negative integer.A bad boy Vasya came up to the board and wrote number sv near each node v — the sum of values of all edges that are incident to this node. Then Vasya removed the edges and their values from the board.Your task is to restore the original tree by the node colors and numbers sv.InputThe first line of the input contains a single integer n (2 ≤ n ≤ 105) — the number of nodes in the tree. Next n lines contain pairs of space-separated integers ci, si (0 ≤ ci ≤ 1, 0 ≤ si ≤ 109), where ci stands for the color of the i-th vertex (0 is for white, 1 is for black), and si represents the sum of values of the edges that are incident to the i-th vertex of the tree that is painted on the board.OutputPrint the description of n - 1 edges of the tree graph. Each description is a group of three integers vi, ui, wi (1 ≤ vi, ui ≤ n, vi ≠ ui, 0 ≤ wi ≤ 109), where vi and ui — are the numbers of the nodes that are connected by the i-th edge, and wi is its value. Note that the following condition must fulfill cvi ≠ cui.It is guaranteed that for any input data there exists at least one graph that meets these data. If there are multiple solutions, print any of them. You are allowed to print the edges in any order. As you print the numbers, separate them with spaces.ExamplesInput31 31 20 5Output3 1 33 2 2Input61 00 31 80 20 30 0Output2 3 35 3 34 3 21 6 02 1 0	Input31 31 20 5	Output3 1 33 2 2	1 second	256 megabytes	['constructive algorithms', 'dsu', 'graphs', 'greedy', 'trees', '*2100']
C. Balls and Boxestime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputLittle Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on. For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x — the number of the box, where he put the last of the taken out balls.He asks you to help to find the initial arrangement of the balls in the boxes.InputThe first line of the input contains two integers n and x (2 ≤ n ≤ 105, 1 ≤ x ≤ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 ≤ ai ≤ 109, ax ≠ 0) represents the number of balls in the box with index i after Vasya completes all the actions. 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 n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.ExamplesInput4 44 3 1 6Output3 2 5 4 Input5 23 2 0 2 7Output2 1 4 1 6 Input3 32 3 1Output1 2 3	Input4 44 3 1 6	Output3 2 5 4	1 second	256 megabytes	['constructive algorithms', 'greedy', 'implementation', '*1700']
B. Ancient Prophesytime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputA recently found Ancient Prophesy is believed to contain the exact Apocalypse date. The prophesy is a string that only consists of digits and characters "-".We'll say that some date is mentioned in the Prophesy if there is a substring in the Prophesy that is the date's record in the format "dd-mm-yyyy". We'll say that the number of the date's occurrences is the number of such substrings in the Prophesy. For example, the Prophesy "0012-10-2012-10-2012" mentions date 12-10-2012 twice (first time as "0012-10-2012-10-2012", second time as "0012-10-2012-10-2012").The date of the Apocalypse is such correct date that the number of times it is mentioned in the Prophesy is strictly larger than that of any other correct date.A date is correct if the year lies in the range from 2013 to 2015, the month is from 1 to 12, and the number of the day is strictly more than a zero and doesn't exceed the number of days in the current month. Note that a date is written in the format "dd-mm-yyyy", that means that leading zeroes may be added to the numbers of the months or days if needed. In other words, date "1-1-2013" isn't recorded in the format "dd-mm-yyyy", and date "01-01-2013" is recorded in it.Notice, that any year between 2013 and 2015 is not a leap year.InputThe first line contains the Prophesy: a non-empty string that only consists of digits and characters "-". The length of the Prophesy doesn't exceed 105 characters.OutputIn a single line print the date of the Apocalypse. It is guaranteed that such date exists and is unique.ExamplesInput777-444---21-12-2013-12-2013-12-2013---444-777Output13-12-2013	Input777-444---21-12-2013-12-2013-12-2013---444-777	Output13-12-2013	1 second	256 megabytes	['brute force', 'implementation', 'strings', '*1600']
A. Adding Digitstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputVasya has got two number: a and b. However, Vasya finds number a too short. So he decided to repeat the operation of lengthening number a n times.One operation of lengthening a number means adding exactly one digit to the number (in the decimal notation) to the right provided that the resulting number is divisible by Vasya's number b. If it is impossible to obtain the number which is divisible by b, then the lengthening operation cannot be performed.Your task is to help Vasya and print the number he can get after applying the lengthening operation to number a n times.InputThe first line contains three integers: a, b, n (1 ≤ a, b, n ≤ 105).OutputIn a single line print the integer without leading zeros, which Vasya can get when he applies the lengthening operations to number a n times. If no such number exists, then print number -1. If there are multiple possible answers, print any of them.ExamplesInput5 4 5Output524848Input12 11 1Output121Input260 150 10Output-1	Input5 4 5	Output524848	2 seconds	256 megabytes	['implementation', 'math', '*1400']
B. Little Elephant and Magic Squaretime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLittle Elephant loves magic squares very much.A magic square is a 3 × 3 table, each cell contains some positive integer. At that the sums of integers in all rows, columns and diagonals of the table are equal. The figure below shows the magic square, the sum of integers in all its rows, columns and diagonals equals 15. The Little Elephant remembered one magic square. He started writing this square on a piece of paper, but as he wrote, he forgot all three elements of the main diagonal of the magic square. Fortunately, the Little Elephant clearly remembered that all elements of the magic square did not exceed 105. Help the Little Elephant, restore the original magic square, given the Elephant's notes.InputThe first three lines of the input contain the Little Elephant's notes. The first line contains elements of the first row of the magic square. The second line contains the elements of the second row, the third line is for the third row. The main diagonal elements that have been forgotten by the Elephant are represented by zeroes.It is guaranteed that the notes contain exactly three zeroes and they are all located on the main diagonal. It is guaranteed that all positive numbers in the table do not exceed 105.OutputPrint three lines, in each line print three integers — the Little Elephant's magic square. If there are multiple magic squares, you are allowed to print any of them. Note that all numbers you print must be positive and not exceed 105.It is guaranteed that there exists at least one magic square that meets the conditions.ExamplesInput0 1 11 0 11 1 0Output1 1 11 1 11 1 1Input0 3 65 0 54 7 0Output6 3 65 5 54 7 4	Input0 1 11 0 11 1 0	Output1 1 11 1 11 1 1	2 seconds	256 megabytes	['brute force', 'implementation', '*1100']
A. Little Elephant and Chesstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe Little Elephant loves chess very much. One day the Little Elephant and his friend decided to play chess. They've got the chess pieces but the board is a problem. They've got an 8 × 8 checkered board, each square is painted either black or white. The Little Elephant and his friend know that a proper chessboard doesn't have any side-adjacent cells with the same color and the upper left cell is white. To play chess, they want to make the board they have a proper chessboard. For that the friends can choose any row of the board and cyclically shift the cells of the chosen row, that is, put the last (rightmost) square on the first place in the row and shift the others one position to the right. You can run the described operation multiple times (or not run it at all).For example, if the first line of the board looks like that "BBBBBBWW" (the white cells of the line are marked with character "W", the black cells are marked with character "B"), then after one cyclic shift it will look like that "WBBBBBBW".Help the Little Elephant and his friend to find out whether they can use any number of the described operations to turn the board they have into a proper chessboard.InputThe input consists of exactly eight lines. Each line contains exactly eight characters "W" or "B" without any spaces: the j-th character in the i-th line stands for the color of the j-th cell of the i-th row of the elephants' board. Character "W" stands for the white color, character "B" stands for the black color.Consider the rows of the board numbered from 1 to 8 from top to bottom, and the columns — from 1 to 8 from left to right. The given board can initially be a proper chessboard.OutputIn a single line print "YES" (without the quotes), if we can make the board a proper chessboard and "NO" (without the quotes) otherwise.ExamplesInputWBWBWBWBBWBWBWBWBWBWBWBWBWBWBWBWWBWBWBWBWBWBWBWBBWBWBWBWWBWBWBWBOutputYESInputWBWBWBWBWBWBWBWBBBWBWWWBBWBWBWBWBWBWBWBWBWBWBWWWBWBWBWBWBWBWBWBWOutputNONoteIn the first sample you should shift the following lines one position to the right: the 3-rd, the 6-th, the 7-th and the 8-th.In the second sample there is no way you can achieve the goal.	InputWBWBWBWBBWBWBWBWBWBWBWBWBWBWBWBWWBWBWBWBWBWBWBWBBWBWBWBWWBWBWBWB	OutputYES	2 seconds	256 megabytes	['brute force', 'strings', '*1000']
E. Little Elephant and Treetime limit per test4 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe Little Elephant loves trees very much, he especially loves root trees.He's got a tree consisting of n nodes (the nodes are numbered from 1 to n), with root at node number 1. Each node of the tree contains some list of numbers which initially is empty. The Little Elephant wants to apply m operations. On the i-th operation (1 ≤ i ≤ m) he first adds number i to lists of all nodes of a subtree with the root in node number ai, and then he adds number i to lists of all nodes of the subtree with root in node bi.After applying all operations the Little Elephant wants to count for each node i number ci — the number of integers j (1 ≤ j ≤ n; j ≠ i), such that the lists of the i-th and the j-th nodes contain at least one common number.Help the Little Elephant, count numbers ci for him.InputThe first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of the tree nodes and the number of operations. Each of the following n - 1 lines contains two space-separated integers, ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi), that mean that there is an edge between nodes number ui and vi. Each of the following m lines contains two space-separated integers, ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi), that stand for the indexes of the nodes in the i-th operation.It is guaranteed that the given graph is an undirected tree.OutputIn a single line print n space-separated integers — c1, c2, ..., cn.ExamplesInput5 11 21 33 53 42 3Output0 3 3 3 3 Input11 31 22 32 41 55 65 75 86 98 108 112 93 62 8Output0 6 7 6 0 2 0 5 4 5 5	Input5 11 21 33 53 42 3	Output0 3 3 3 3	4 seconds	256 megabytes	['data structures', 'dfs and similar', 'trees', '*2400']
D. Little Elephant and Broken Sortingtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe Little Elephant loves permutations of integers from 1 to n very much. But most of all he loves sorting them. To sort a permutation, the Little Elephant repeatedly swaps some elements. As a result, he must receive a permutation 1, 2, 3, ..., n.This time the Little Elephant has permutation p1, p2, ..., pn. Its sorting program needs to make exactly m moves, during the i-th move it swaps elements that are at that moment located at the ai-th and the bi-th positions. But the Little Elephant's sorting program happened to break down and now on every step it can equiprobably either do nothing or swap the required elements.Now the Little Elephant doesn't even hope that the program will sort the permutation, but he still wonders: if he runs the program and gets some permutation, how much will the result of sorting resemble the sorted one? For that help the Little Elephant find the mathematical expectation of the number of permutation inversions after all moves of the program are completed.We'll call a pair of integers i, j (1 ≤ i < j ≤ n) an inversion in permutatuon p1, p2, ..., pn, if the following inequality holds: pi > pj.InputThe first line contains two integers n and m (1 ≤ n, m ≤ 1000, n > 1) — the permutation size and the number of moves. The second line contains n distinct integers, not exceeding n — the initial permutation. Next m lines each contain two integers: the i-th line contains integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) — the positions of elements that were changed during the i-th move.OutputIn the only line print a single real number — the answer to the problem. The answer will be considered correct if its relative or absolute error does not exceed 10 - 6.ExamplesInput2 11 21 2Output0.500000000Input4 31 3 2 41 22 31 4Output3.000000000	Input2 11 21 2	Output0.500000000	2 seconds	256 megabytes	['dp', 'math', 'probabilities', '*2600']
C. Little Elephant and LCMtime limit per test4 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe Little Elephant loves the LCM (least common multiple) operation of a non-empty set of positive integers. The result of the LCM operation of k positive integers x1, x2, ..., xk is the minimum positive integer that is divisible by each of numbers xi.Let's assume that there is a sequence of integers b1, b2, ..., bn. Let's denote their LCMs as lcm(b1, b2, ..., bn) and the maximum of them as max(b1, b2, ..., bn). The Little Elephant considers a sequence b good, if lcm(b1, b2, ..., bn) = max(b1, b2, ..., bn).The Little Elephant has a sequence of integers a1, a2, ..., an. Help him find the number of good sequences of integers b1, b2, ..., bn, such that for all i (1 ≤ i ≤ n) the following condition fulfills: 1 ≤ bi ≤ ai. As the answer can be rather large, print the remainder from dividing it by 1000000007 (109 + 7).InputThe first line contains a single positive integer n (1 ≤ n ≤ 105) — the number of integers in the sequence a. The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 105) — sequence a.OutputIn the single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).ExamplesInput41 4 3 2Output15Input26 3Output13	Input41 4 3 2	Output15	4 seconds	256 megabytes	['binary search', 'combinatorics', 'dp', 'math', '*2000']
B. Little Elephant and Electionstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThere have recently been elections in the zoo. Overall there were 7 main political parties: one of them is the Little Elephant Political Party, 6 other parties have less catchy names.Political parties find their number in the ballot highly important. Overall there are m possible numbers: 1, 2, ..., m. Each of these 7 parties is going to be assigned in some way to exactly one number, at that, two distinct parties cannot receive the same number.The Little Elephant Political Party members believe in the lucky digits 4 and 7. They want to evaluate their chances in the elections. For that, they need to find out, how many correct assignments are there, such that the number of lucky digits in the Little Elephant Political Party ballot number is strictly larger than the total number of lucky digits in the ballot numbers of 6 other parties. Help the Little Elephant Political Party, calculate this number. As the answer can be rather large, print the remainder from dividing it by 1000000007 (109 + 7).InputA single line contains a single positive integer m (7 ≤ m ≤ 109) — the number of possible numbers in the ballot.OutputIn a single line print a single integer — the answer to the problem modulo 1000000007 (109 + 7).ExamplesInput7Output0Input8Output1440	Input7	Output0	2 seconds	256 megabytes	['brute force', 'combinatorics', 'dp', '*1900']
A. Little Elephant and Bitstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe Little Elephant has an integer a, written in the binary notation. He wants to write this number on a piece of paper.To make sure that the number a fits on the piece of paper, the Little Elephant ought to delete exactly one any digit from number a in the binary record. At that a new number appears. It consists of the remaining binary digits, written in the corresponding order (possible, with leading zeroes).The Little Elephant wants the number he is going to write on the paper to be as large as possible. Help him find the maximum number that he can obtain after deleting exactly one binary digit and print it in the binary notation.InputThe single line contains integer a, written in the binary notation without leading zeroes. This number contains more than 1 and at most 105 digits.OutputIn the single line print the number that is written without leading zeroes in the binary notation — the answer to the problem.ExamplesInput101Output11Input110010Output11010NoteIn the first sample the best strategy is to delete the second digit. That results in number 112 = 310.In the second sample the best strategy is to delete the third or fourth digits — that results in number 110102 = 2610.	Input101	Output11	2 seconds	256 megabytes	['greedy', 'math', '*1100']
E. Greedy Elevatortime limit per test3 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputThe m-floor (m > 1) office of international corporation CodeForces has the advanced elevator control system established. It works as follows.All office floors are sequentially numbered with integers from 1 to m. At time t = 0, the elevator is on the first floor, the elevator is empty and nobody is waiting for the elevator on other floors. Next, at times ti (ti > 0) people come to the elevator. For simplicity, we assume that one person uses the elevator only once during the reported interval. For every person we know three parameters: the time at which the person comes to the elevator, the floor on which the person is initially, and the floor to which he wants to go.The movement of the elevator between the floors is as follows. At time t (t ≥ 0, t is an integer) the elevator is always at some floor. First the elevator releases all people who are in the elevator and want to get to the current floor. Then it lets in all the people waiting for the elevator on this floor. If a person comes to the elevator exactly at time t, then he has enough time to get into it. We can assume that all of these actions (going in or out from the elevator) are made instantly. After that the elevator decides, which way to move and at time (t + 1) the elevator gets to the selected floor.The elevator selects the direction of moving by the following algorithm. If the elevator is empty and at the current time no one is waiting for the elevator on any floor, then the elevator remains at the current floor. Otherwise, let's assume that the elevator is on the floor number x (1 ≤ x ≤ m). Then elevator calculates the directions' "priorities" pup and pdown: pup is the sum of the number of people waiting for the elevator on the floors with numbers greater than x, and the number of people in the elevator, who want to get to the floors with the numbers greater than x; pdown is the sum of the number of people waiting for the elevator on the floors with numbers less than x, and the number of people in the elevator, who want to get to the floors with the numbers less than x. If pup ≥ pdown, then the elevator goes one floor above the current one (that is, from floor x to floor x + 1), otherwise the elevator goes one floor below the current one (that is, from floor x to floor x - 1). Your task is to simulate the work of the elevator and for each person to tell the time when the elevator will get to the floor this person needs. Please note that the elevator is large enough to accommodate all the people at once.InputThe first line contains two space-separated integers: n, m (1 ≤ n ≤ 105, 2 ≤ m ≤ 105) — the number of people and floors in the building, correspondingly.Next n lines each contain three space-separated integers: ti, si, fi (1 ≤ ti ≤ 109, 1 ≤ si, fi ≤ m, si ≠ fi) — the time when the i-th person begins waiting for the elevator, the floor number, where the i-th person was initially located, and the number of the floor, where he wants to go.OutputPrint n lines. In the i-th line print a single number — the moment of time, when the i-th person gets to the floor he needs. The people are numbered in the order, in which they are given in the input. Please don't 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.ExamplesInput3 101 2 73 6 53 4 8Output7118Input2 101 2 57 4 5Output59NoteIn the first sample the elevator worked as follows: t = 1. The elevator is on the floor number 1. The elevator is empty. The floor number 2 has one person waiting. pup = 1 + 0 = 1, pdown = 0 + 0 = 0, pup ≥ pdown. So the elevator goes to the floor number 2. t = 2. The elevator is on the floor number 2. One person enters the elevator, he wants to go to the floor number 7. pup = 0 + 1 = 1, pdown = 0 + 0 = 0, pup ≥ pdown. So the elevator goes to the floor number 3. t = 3. The elevator is on the floor number 3. There is one person in the elevator, he wants to go to floor 7. The floors number 4 and 6 have two people waiting for the elevator. pup = 2 + 1 = 3, pdown = 0 + 0 = 0, pup ≥ pdown. So the elevator goes to the floor number 4. t = 4. The elevator is on the floor number 4. There is one person in the elevator who wants to go to the floor number 7. One person goes into the elevator, he wants to get to the floor number 8. The floor number 6 has one man waiting. pup = 1 + 2 = 3, pdown = 0 + 0 = 0, pup ≥ pdown. So the elevator goes to the floor number 5. t = 5. The elevator is on the floor number 5. There are two people in the elevator, they want to get to the floors number 7 and 8, correspondingly. There is one person waiting for the elevator on the floor number 6. pup = 1 + 2 = 3, pdown = 0 + 0 = 0, pup ≥ pdown. So the elevator goes to the floor number 6. t = 6. The elevator is on the floor number 6. There are two people in the elevator, they want to get to the floors number 7 and 8, correspondingly. One man enters the elevator, he wants to get to the floor number 5. pup = 0 + 2 = 2, pdown = 0 + 1 = 1, pup ≥ pdown. So the elevator goes to the floor number 7. t = 7. The elevator is on the floor number 7. One person leaves the elevator, this person wanted to get to the floor number 7. There are two people in the elevator, they want to get to the floors with numbers 8 and 5, correspondingly. pup = 0 + 1 = 1, pdown = 0 + 1 = 1, pup ≥ pdown. So the elevator goes to the floor number 8. t = 8. The elevator is on the floor number 8. One person leaves the elevator, this person wanted to go to the floor number 8. There is one person in the elevator, he wants to go to the floor number 5. pup = 0 + 0 = 0, pdown = 0 + 1 = 1, pup < pdown. So the elevator goes to the floor number 7. t = 9. The elevator is on the floor number 7. There is one person in the elevator, this person wants to get to the floor number 5. pup = 0 + 0 = 0, pdown = 0 + 1 = 1, pup < pdown. So the elevator goes to the floor number 6. t = 10. The elevator is on the floor number 6. There is one person in the elevator, he wants to get to the floor number 5. pup = 0 + 0 = 0, pdown = 0 + 1 = 1, pup < pdown. So the elevator goes to the floor number 5. t = 11. The elevator is on the floor number 5. One person leaves the elevator, this person initially wanted to get to the floor number 5. The elevator is empty and nobody needs it, so the elevator remains at the floor number 5.	Input3 101 2 73 6 53 4 8	Output7118	3 seconds	256 megabytes	['data structures', 'implementation', '*2200']
D. Sumtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputVasya has found a piece of paper with an array written on it. The array consists of n integers a1, a2, ..., an. Vasya noticed that the following condition holds for the array ai ≤ ai + 1 ≤ 2·ai for any positive integer i (i < n).Vasya wants to add either a "+" or a "-" before each number of array. Thus, Vasya will get an expression consisting of n summands. The value of the resulting expression is the sum of all its elements. The task is to add signs "+" and "-" before each number so that the value of expression s meets the limits 0 ≤ s ≤ a1. Print a sequence of signs "+" and "-", satisfying the given limits. It is guaranteed that the solution for the problem exists.InputThe first line contains integer n (1 ≤ n ≤ 105) — the size of the array. The second line contains space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 109) — the original array. It is guaranteed that the condition ai ≤ ai + 1 ≤ 2·ai fulfills for any positive integer i (i < n).OutputIn a single line print the sequence of n characters "+" and "-", where the i-th character is the sign that is placed in front of number ai. The value of the resulting expression s must fit into the limits 0 ≤ s ≤ a1. If there are multiple solutions, you are allowed to print any of them.ExamplesInput41 2 3 5Output+++-Input33 3 5Output++-	Input41 2 3 5	Output+++-	2 seconds	256 megabytes	['greedy', 'math', '*1900']
C. View Angletime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputFlatland has recently introduced a new type of an eye check for the driver's licence. The check goes like that: there is a plane with mannequins standing on it. You should tell the value of the minimum angle with the vertex at the origin of coordinates and with all mannequins standing inside or on the boarder of this angle. As you spend lots of time "glued to the screen", your vision is impaired. So you have to write a program that will pass the check for you.InputThe first line contains a single integer n (1 ≤ n ≤ 105) — the number of mannequins.Next n lines contain two space-separated integers each: xi, yi (\|xi\|, \|yi\| ≤ 1000) — the coordinates of the i-th mannequin. It is guaranteed that the origin of the coordinates has no mannequin. It is guaranteed that no two mannequins are located in the same point on the plane.OutputPrint a single real number — the value of the sought angle in degrees. The answer will be considered valid if the relative or absolute error doesn't exceed 10 - 6. ExamplesInput22 00 2Output90.0000000000Input32 00 2-2 2Output135.0000000000Input42 00 2-2 00 -2Output270.0000000000Input22 11 2Output36.8698976458NoteSolution for the first sample test is shown below: Solution for the second sample test is shown below: Solution for the third sample test is shown below: Solution for the fourth sample test is shown below:	Input22 00 2	Output90.0000000000	2 seconds	256 megabytes	['brute force', 'geometry', 'math', '*1800']
B. Playing Cubestime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputPetya and Vasya decided to play a little. They found n red cubes and m blue cubes. The game goes like that: the players take turns to choose a cube of some color (red or blue) and put it in a line from left to right (overall the line will have n + m cubes). Petya moves first. Petya's task is to get as many pairs of neighbouring cubes of the same color as possible. Vasya's task is to get as many pairs of neighbouring cubes of different colors as possible. The number of Petya's points in the game is the number of pairs of neighboring cubes of the same color in the line, the number of Vasya's points in the game is the number of neighbouring cubes of the different color in the line. Your task is to calculate the score at the end of the game (Petya's and Vasya's points, correspondingly), if both boys are playing optimally well. To "play optimally well" first of all means to maximize the number of one's points, and second — to minimize the number of the opponent's points.InputThe only line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of red and blue cubes, correspondingly.OutputOn a single line print two space-separated integers — the number of Petya's and Vasya's points correspondingly provided that both players play optimally well.ExamplesInput3 1Output2 1Input2 4Output3 2NoteIn the first test sample the optimal strategy for Petya is to put the blue cube in the line. After that there will be only red cubes left, so by the end of the game the line of cubes from left to right will look as [blue, red, red, red]. So, Petya gets 2 points and Vasya gets 1 point. If Petya would choose the red cube during his first move, then, provided that both boys play optimally well, Petya would get 1 point and Vasya would get 2 points.	Input3 1	Output2 1	2 seconds	256 megabytes	['games', 'greedy', 'implementation', '*1300']
A. Socketstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputVasya has got many devices that work on electricity. He's got n supply-line filters to plug the devices, the i-th supply-line filter has ai sockets.Overall Vasya has got m devices and k electrical sockets in his flat, he can plug the devices or supply-line filters directly. Of course, he can plug the supply-line filter to any other supply-line filter. The device (or the supply-line filter) is considered plugged to electricity if it is either plugged to one of k electrical sockets, or if it is plugged to some supply-line filter that is in turn plugged to electricity. What minimum number of supply-line filters from the given set will Vasya need to plug all the devices he has to electricity? Note that all devices and supply-line filters take one socket for plugging and that he can use one socket to plug either one device or one supply-line filter.InputThe first line contains three integers n, m, k (1 ≤ n, m, k ≤ 50) — the number of supply-line filters, the number of devices and the number of sockets that he can plug to directly, correspondingly. The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 50) — number ai stands for the number of sockets on the i-th supply-line filter.OutputPrint a single number — the minimum number of supply-line filters that is needed to plug all the devices to electricity. If it is impossible to plug all the devices even using all the supply-line filters, print -1.ExamplesInput3 5 33 1 2Output1Input4 7 23 3 2 4Output2Input5 5 11 3 1 2 1Output-1NoteIn the first test case he can plug the first supply-line filter directly to electricity. After he plug it, he get 5 (3 on the supply-line filter and 2 remaining sockets for direct plugging) available sockets to plug. Thus, one filter is enough to plug 5 devices.One of the optimal ways in the second test sample is to plug the second supply-line filter directly and plug the fourth supply-line filter to one of the sockets in the second supply-line filter. Thus, he gets exactly 7 sockets, available to plug: one to plug to the electricity directly, 2 on the second supply-line filter, 4 on the fourth supply-line filter. There's no way he can plug 7 devices if he use one supply-line filter.	Input3 5 33 1 2	Output1	2 seconds	256 megabytes	['greedy', 'implementation', 'sortings', '*1100']
E. Lucky Arraystime limit per test4 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLittle Maxim loves interesting problems. He decided to share one such problem with you. Initially there is an array a, consisting of n zeroes. The elements of the array are indexed, starting from 1. Then follow queries to change array a. Each query is characterized by two integers vi, ti. In the answer to the query we should make the vi-th array element equal ti (avi = ti; 1 ≤ vi ≤ n).Maxim thinks that some pairs of integers (x, y) are good and some are not. Maxim thinks that array a, consisting of n integers, is lucky, if for all integer i, (1 ≤ i ≤ n - 1) the pair of integers (ai, ai + 1) — is good. Note that the order of numbers in the pairs is important, that is, specifically, (1, 2) ≠ (2, 1).After each query to change array a Maxim wants to know, how many ways there are to replace all zeroes in array a with integers from one to three so as to make the resulting array (without zeroes) lucky. Of course, distinct zeroes can be replaced by distinct integers.Maxim told you the sequence of queries and all pairs of integers he considers lucky. Help Maxim, solve this problem for him.InputThe first line contains integers n and m (1 ≤ n, m ≤ 77777) — the number of elements in the array and the number of commands.The next three lines contain matrix w, consisting only of zeroes and ones; the j-th number in the i-th of these lines — wi, j. If wi, j = 1 (1 ≤ i, j ≤ 3), then pair (i, j) is good, otherwise it is not good. Matrix does not have to be symmetric relative to the main diagonal.Next m lines contain pairs of integers vi, ti (1 ≤ vi ≤ n, 0 ≤ ti ≤ 3) — the queries to change the array.OutputPrint m integers — the i-th number should equal to the number of ways to replace all zeroes in array a (changed after the i-th query) by integers from one to three so as to make the resulting array (without zeroes) lucky. Separate the numbers by whitespaces. As the answers can be rather large, print the remainder from dividing them by 777777777.ExamplesInput3 101 1 01 0 01 1 11 11 32 23 02 13 03 12 03 11 0Output3611221336	Input3 101 1 01 0 01 1 11 11 32 23 02 13 03 12 03 11 0	Output3611221336	4 seconds	256 megabytes	['data structures', '*2400']
D. Liars and Sergetime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputThere are n people, sitting in a line at the table. For each person we know that he always tells either the truth or lies.Little Serge asked them: how many of you always tell the truth? Each of the people at the table knows everything (who is an honest person and who is a liar) about all the people at the table. The honest people are going to say the correct answer, the liars are going to say any integer from 1 to n, which is not the correct answer. Every liar chooses his answer, regardless of the other liars, so two distinct liars may give distinct answer.Serge does not know any information about the people besides their answers to his question. He took a piece of paper and wrote n integers a1, a2, ..., an, where ai is the answer of the i-th person in the row. Given this sequence, Serge determined that exactly k people sitting at the table apparently lie.Serge wonders, how many variants of people's answers (sequences of answers a of length n) there are where one can say that exactly k people sitting at the table apparently lie. As there can be rather many described variants of answers, count the remainder of dividing the number of the variants by 777777777.InputThe first line contains two integers n, k, (1 ≤ k ≤ n ≤ 28). It is guaranteed that n — is the power of number 2.OutputPrint a single integer — the answer to the problem modulo 777777777.ExamplesInput1 1Output0Input2 1Output2	Input1 1	Output0	1 second	256 megabytes	['dp', '*2700']
E. Furlo and Rublo and Gametime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputFurlo and Rublo play a game. The table has n piles of coins lying on it, the i-th pile has ai coins. Furlo and Rublo move in turns, Furlo moves first. In one move you are allowed to: choose some pile, let's denote the current number of coins in it as x; choose some integer y (0 ≤ y < x; x1 / 4 ≤ y ≤ x1 / 2) and decrease the number of coins in this pile to y. In other words, after the described move the pile will have y coins left. The player who can't make a move, loses. Your task is to find out, who wins in the given game if both Furlo and Rublo play optimally well.InputThe first line contains integer n (1 ≤ n ≤ 77777) — the number of piles. The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 777777777777) — the sizes of piles. The numbers are separated by single spaces.Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.OutputIf both players play optimally well and Furlo wins, print "Furlo", otherwise print "Rublo". Print the answers without the quotes.ExamplesInput11OutputRubloInput21 2OutputRubloInput101 2 3 4 5 6 7 8 9 10OutputFurlo	Input11	OutputRublo	2 seconds	256 megabytes	['games', 'implementation', 'math', '*2200']
D. Mr. Bender and Squaretime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputMr. Bender has a digital table of size n × n, each cell can be switched on or off. He wants the field to have at least c switched on squares. When this condition is fulfilled, Mr Bender will be happy.We'll consider the table rows numbered from top to bottom from 1 to n, and the columns — numbered from left to right from 1 to n. Initially there is exactly one switched on cell with coordinates (x, y) (x is the row number, y is the column number), and all other cells are switched off. Then each second we switch on the cells that are off but have the side-adjacent cells that are on.For a cell with coordinates (x, y) the side-adjacent cells are cells with coordinates (x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1).In how many seconds will Mr. Bender get happy?InputThe first line contains four space-separated integers n, x, y, c (1 ≤ n, c ≤ 109; 1 ≤ x, y ≤ n; c ≤ n2).OutputIn a single line print a single integer — the answer to the problem.ExamplesInput6 4 3 1Output0Input9 3 8 10Output2NoteInitially the first test has one painted cell, so the answer is 0. In the second test all events will go as is shown on the figure. .	Input6 4 3 1	Output0	2 seconds	256 megabytes	['binary search', 'implementation', 'math', '*1800']
C. Almost Arithmetical Progressiontime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputGena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as: a1 = p, where p is some integer; ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer. Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.InputThe first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).OutputPrint a single integer — the length of the required longest subsequence.ExamplesInput23 5Output2Input410 20 10 30Output3NoteIn the first test the sequence actually is the suitable subsequence. In the second test the following subsequence fits: 10, 20, 10.	Input23 5	Output2	1 second	256 megabytes	['brute force', 'dp', '*1500']
B. Code Parsingtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLittle Vitaly loves different algorithms. Today he has invented a new algorithm just for you. Vitaly's algorithm works with string s, consisting of characters "x" and "y", and uses two following operations at runtime: Find two consecutive characters in the string, such that the first of them equals "y", and the second one equals "x" and swap them. If there are several suitable pairs of characters, we choose the pair of characters that is located closer to the beginning of the string. Find in the string two consecutive characters, such that the first of them equals "x" and the second one equals "y". Remove these characters from the string. If there are several suitable pairs of characters, we choose the pair of characters that is located closer to the beginning of the string. The input for the new algorithm is string s, and the algorithm works as follows: If you can apply at least one of the described operations to the string, go to step 2 of the algorithm. Otherwise, stop executing the algorithm and print the current string. If you can apply operation 1, then apply it. Otherwise, apply operation 2. After you apply the operation, go to step 1 of the algorithm. Now Vitaly wonders, what is going to be printed as the result of the algorithm's work, if the input receives string s.InputThe first line contains a non-empty string s. It is guaranteed that the string only consists of characters "x" and "y". It is guaranteed that the string consists of at most 106 characters. It is guaranteed that as the result of the algorithm's execution won't be an empty string.OutputIn the only line print the string that is printed as the result of the algorithm's work, if the input of the algorithm input receives string s.ExamplesInputxOutputxInputyxyxyOutputyInputxxxxxyOutputxxxxNoteIn the first test the algorithm will end after the first step of the algorithm, as it is impossible to apply any operation. Thus, the string won't change.In the second test the transformation will be like this: string "yxyxy" transforms into string "xyyxy"; string "xyyxy" transforms into string "xyxyy"; string "xyxyy" transforms into string "xxyyy"; string "xxyyy" transforms into string "xyy"; string "xyy" transforms into string "y". As a result, we've got string "y". In the third test case only one transformation will take place: string "xxxxxy" transforms into string "xxxx". Thus, the answer will be string "xxxx".	Inputx	Outputx	2 seconds	256 megabytes	['implementation', '*1200']
A. Greg's Workouttime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputGreg is a beginner bodybuilder. Today the gym coach gave him the training plan. All it had was n integers a1, a2, ..., an. These numbers mean that Greg needs to do exactly n exercises today. Besides, Greg should repeat the i-th in order exercise ai times.Greg now only does three types of exercises: "chest" exercises, "biceps" exercises and "back" exercises. Besides, his training is cyclic, that is, the first exercise he does is a "chest" one, the second one is "biceps", the third one is "back", the fourth one is "chest", the fifth one is "biceps", and so on to the n-th exercise.Now Greg wonders, which muscle will get the most exercise during his training. We know that the exercise Greg repeats the maximum number of times, trains the corresponding muscle the most. Help Greg, determine which muscle will get the most training.InputThe first line contains integer n (1 ≤ n ≤ 20). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 25) — the number of times Greg repeats the exercises.OutputPrint word "chest" (without the quotes), if the chest gets the most exercise, "biceps" (without the quotes), if the biceps gets the most exercise and print "back" (without the quotes) if the back gets the most exercise.It is guaranteed that the input is such that the answer to the problem is unambiguous.ExamplesInput22 8OutputbicepsInput35 1 10OutputbackInput73 3 2 7 9 6 8OutputchestNoteIn the first sample Greg does 2 chest, 8 biceps and zero back exercises, so the biceps gets the most exercises.In the second sample Greg does 5 chest, 1 biceps and 10 back exercises, so the back gets the most exercises.In the third sample Greg does 18 chest, 12 biceps and 8 back exercises, so the chest gets the most exercise.	Input22 8	Outputbiceps	2 seconds	256 megabytes	['implementation', '*800']
E. Dormitorytime limit per test1 secondmemory limit per test256 megabytesinputinput.txtoutputoutput.txtStudent Vasya came to study in Berland State University from the country, so he is living in a dormitory. A semester has n days, and in each of those days his parents send him some food. In the morning of the i-th day he receives ai kilograms of food that can be eaten on that day and on the next one (then the food goes bad and becomes unfit for consumption).Every day Vasya eats v kilograms of food. It is known that Vasya's parents do not allow him to starve, so there always is enough food for Vasya. Vasya has m friends who sometimes live with him. Let's index the friends from 1 to m. Friend number j lives with Vasya from day lj to day rj, inclusive. Also, the j-th friend requires fj kilograms of food per day. Usually Vasya's friends eat in the canteen, but sometimes generous Vasya feeds some of them. Every day Vasya can feed some friends who live with him this day (or may feed nobody).Every time Vasya feeds his friend, he gives him as much food as the friend needs for the day, and Vasya's popularity rating at the University increases by one. Vasya cannot feed the same friend multiple times in one day. In addition, he knows that eating habits must be regular, so he always eats v kilograms of food per day.Vasya wants so choose whom he will feed each day of the semester to make his rating as high as possible. Originally Vasya's rating is 0 because he is a freshman.InputThe first line contains two integers n and v (1 ≤ n, v ≤ 400). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 400), separated by single spaces. Value ai means that in the morning of the i-th day ai kilograms of food come, the food is good for eating on day i and/or on day i + 1 (then the food goes bad). It is guaranteed that if Vasya doesn't feed anyone, there is a way for him to eat so as to consume v kilograms of food every day.The third line contains integer m (1 ≤ m ≤ 400). Each of the following m lines describes one Vasya's friend: the j-th of these lines contains three integers lj, rj, fj (1 ≤ lj ≤ rj ≤ n, 1 ≤ fj ≤ 400), separated by single spaces.OutputIn the first line print the highest rating Vasya can reach. In the next n lines print, which friends Vasya needs to feed on each day. In the i-th of these lines first print the number of friends to feed on the i-th day, and then list the indexes of these friends. Print the friends in these lists in any order. If there are multiple optimal solutions, print any of them.ExamplesInput4 13 2 5 431 3 21 4 13 4 2Output71 21 23 2 1 32 2 3	Input4 13 2 5 431 3 21 4 13 4 2	Output71 21 23 2 1 32 2 3	1 second	256 megabytes	['dp', 'implementation', '*2100']
D. Ratstime limit per test1 secondmemory limit per test256 megabytesinputinput.txtoutputoutput.txtRats have bred to hundreds and hundreds in the basement of the store, owned by Vasily Petrovich. Vasily Petrovich may have not noticed their presence, but they got into the habit of sneaking into the warehouse and stealing food from there. Vasily Petrovich cannot put up with it anymore, he has to destroy the rats in the basement. Since mousetraps are outdated and do not help, and rat poison can poison inattentive people as well as rats, he chose a radical way: to blow up two grenades in the basement (he does not have more).In this problem, we will present the shop basement as a rectangular table of n × m cells. Some of the cells are occupied by walls, and the rest of them are empty. Vasily has been watching the rats and he found out that at a certain time they go to sleep, and all the time they sleep in the same places. He wants to blow up a grenade when this convenient time comes. On the plan of his basement, he marked cells with sleeping rats in them. Naturally, these cells are not occupied by walls.Grenades can only blow up in a cell that is not occupied by a wall. The blast wave from a grenade distributes as follows. We assume that the grenade blast occurs at time 0. During this initial time only the cell where the grenade blew up gets 'clear'. If at time t some cell is clear, then at time t + 1 those side-neighbouring cells which are not occupied by the walls get clear too (some of them could have been cleared before). The blast wave distributes for exactly d seconds, then it dies immediately. An example of a distributing blast wave: Picture 1 shows the situation before the blast, and the following pictures show "clear" cells by time 0,1,2,3 and 4. Thus, the blast wave on the picture distributes for d = 4 seconds. Vasily Petrovich wonders, whether he can choose two cells to blast the grenades so as to clear all cells with sleeping rats. Write the program that finds it out.InputThe first line contains three integers n, m and d, separated by single spaces (4 ≤ n, m ≤ 1000, 1 ≤ d ≤ 8). Next n lines contain the table that represents the basement plan. Each row of the table consists of m characters. Character "X" means that the corresponding cell is occupied by the wall, character "." represents a empty cell, character "R" represents a empty cell with sleeping rats. It is guaranteed that the first and the last row, as well as the first and the last column consist of characters "X". The plan has at least two empty cells. There is at least one cell with sleeping rats.OutputIf it is impossible to blow up all cells with sleeping rats, print a single integer -1. Otherwise, print four space-separated integers r1, c1, r2, c2, that mean that one grenade should go off in cell (r1, c1), and the other one — in cell (r2, c2). Consider the table rows numbered from top to bottom from 1 to n and the table columns — from left to right from 1 to m. As r1 and r2 represent the row numbers, and c1 and c2 represent the column numbers in the table, they should fit the limits: 1 ≤ r1, r2 ≤ n, 1 ≤ c1, c2 ≤ m. It is forbidden to blow a grenade twice in the same cell. The blast waves of the grenades can intersect. It is possible that one grenade blast destroys no rats, and the other one destroys all of them.ExamplesInput4 4 1XXXXXR.XX.RXXXXXOutput2 2 2 3Input9 14 5XXXXXXXXXXXXXXX....R...R...XX..R.........XX....RXR..R..XX..R...X.....XXR.R...X.....XX....XXR.....XX....R..R.R..XXXXXXXXXXXXXXXOutput2 3 6 9Input7 7 1XXXXXXXX.R.R.XX.....XX..X..XX..R..XX....RXXXXXXXXOutput-1	Input4 4 1XXXXXR.XX.RXXXXX	Output2 2 2 3	1 second	256 megabytes	['brute force', 'dfs and similar', 'graphs', 'implementation', 'shortest paths', '*2300']
C. Anagramtime limit per test1 secondmemory limit per test256 megabytesinputinput.txtoutputoutput.txtString x is an anagram of string y, if we can rearrange the letters in string x and get exact string y. For example, strings "DOG" and "GOD" are anagrams, so are strings "BABA" and "AABB", but strings "ABBAC" and "CAABA" are not.You are given two strings s and t of the same length, consisting of uppercase English letters. You need to get the anagram of string t from string s. You are permitted to perform the replacing operation: every operation is replacing some character from the string s by any other character. Get the anagram of string t in the least number of replacing operations. If you can get multiple anagrams of string t in the least number of operations, get the lexicographically minimal one.The lexicographic order of strings is the familiar to us "dictionary" order. Formally, the string p of length n is lexicographically smaller than string q of the same length, if p1 = q1, p2 = q2, ..., pk - 1 = qk - 1, pk < qk for some k (1 ≤ k ≤ n). Here characters in the strings are numbered from 1. The characters of the strings are compared in the alphabetic order.InputThe input consists of two lines. The first line contains string s, the second line contains string t. The strings have the same length (from 1 to 105 characters) and consist of uppercase English letters.OutputIn the first line print z — the minimum number of replacement operations, needed to get an anagram of string t from string s. In the second line print the lexicographically minimum anagram that could be obtained in z operations.ExamplesInputABACBAOutput1ABCInputCDBABCADCABDOutput2ADBADCNoteThe second sample has eight anagrams of string t, that can be obtained from string s by replacing exactly two letters: "ADBADC", "ADDABC", "CDAABD", "CDBAAD", "CDBADA", "CDDABA", "DDAABC", "DDBAAC". These anagrams are listed in the lexicographical order. The lexicographically minimum anagram is "ADBADC".	InputABACBA	Output1ABC	1 second	256 megabytes	['greedy', 'strings', '*1800']
B. Jury Sizetime limit per test1 secondmemory limit per test256 megabytesinputinput.txtoutputoutput.txtIn 2013, the writers of Berland State University should prepare problems for n Olympiads. We will assume that the Olympiads are numbered with consecutive integers from 1 to n. For each Olympiad we know how many members of the jury must be involved in its preparation, as well as the time required to prepare the problems for her. Namely, the Olympiad number i should be prepared by pi people for ti days, the preparation for the Olympiad should be a continuous period of time and end exactly one day before the Olympiad. On the day of the Olympiad the juries who have prepared it, already do not work on it.For example, if the Olympiad is held on December 9th and the preparation takes 7 people and 6 days, all seven members of the jury will work on the problems of the Olympiad from December, 3rd to December, 8th (the jury members won't be working on the problems of this Olympiad on December 9th, that is, some of them can start preparing problems for some other Olympiad). And if the Olympiad is held on November 3rd and requires 5 days of training, the members of the jury will work from October 29th to November 2nd.In order not to overload the jury the following rule was introduced: one member of the jury can not work on the same day on the tasks for different Olympiads. Write a program that determines what the minimum number of people must be part of the jury so that all Olympiads could be prepared in time.InputThe first line contains integer n — the number of Olympiads in 2013 (1 ≤ n ≤ 100). Each of the following n lines contains four integers mi, di, pi and ti — the month and day of the Olympiad (given without leading zeroes), the needed number of the jury members and the time needed to prepare the i-th Olympiad (1 ≤ mi ≤ 12, di ≥ 1, 1 ≤ pi, ti ≤ 100), di doesn't exceed the number of days in month mi. The Olympiads are given in the arbitrary order. Several Olympiads can take place in one day.Use the modern (Gregorian) calendar in the solution. Note that all dates are given in the year 2013. This is not a leap year, so February has 28 days. Please note, the preparation of some Olympiad can start in 2012 year.OutputPrint a single number — the minimum jury size.ExamplesInput25 23 1 23 13 2 3Output2Input312 9 2 112 8 1 312 8 2 2Output3Input11 10 1 13Output1	Input25 23 1 23 13 2 3	Output2	1 second	256 megabytes	['brute force', 'implementation', '*1500']
A. Cards with Numberstime limit per test1 secondmemory limit per test256 megabytesinputinput.txtoutputoutput.txtPetya has got 2n cards, each card contains some integer. The numbers on the cards can be the same. Let's index all cards by consecutive integers from 1 to 2n. We'll denote the number that is written on a card with number i, as ai. In order to play one entertaining game with his friends, Petya needs to split the cards into pairs so that each pair had equal numbers on the cards. Help Petya do that.InputThe first line contains integer n (1 ≤ n ≤ 3·105). The second line contains the sequence of 2n positive integers a1, a2, ..., a2n (1 ≤ ai ≤ 5000) — the numbers that are written on the cards. The numbers on the line are separated by single spaces.OutputIf it is impossible to divide the cards into pairs so that cards in each pair had the same numbers, print on a single line integer -1. But if the required partition exists, then print n pairs of integers, a pair per line — the indices of the cards that form the pairs.Separate the numbers on the lines by spaces. You can print the pairs and the numbers in the pairs in any order. If there are multiple solutions, print any of them.ExamplesInput320 30 10 30 20 10Output4 21 56 3Input11 2Output-1	Input320 30 10 30 20 10	Output4 21 56 3	1 second	256 megabytes	['constructive algorithms', 'sortings', '*1200']
E. Printertime limit per test4 secondsmemory limit per test256 megabytesinputinput.txtoutputoutput.txtLet's consider a network printer that functions like that. It starts working at time 0. In each second it can print one page of a text. At some moments of time the printer receives printing tasks. We know that a printer received n tasks. Let's number the tasks by consecutive integers from 1 to n. Then the task number i is characterised by three integers: ti is the time when the task came, si is the task's volume (in pages) and pi is the task's priority. The priorities of all tasks are distinct.When the printer receives a task, the task goes to the queue and remains there until all pages from this task are printed. The printer chooses a page to print each time when it either stops printing some page or when it is free and receives a new task. Among all tasks that are in the queue at this moment, the printer chooses the task with the highest priority and next second prints an unprinted page from this task. You can assume that a task goes to the queue immediately, that's why if a task has just arrived by time t, the printer can already choose it for printing.You are given full information about all tasks except for one: you don't know this task's priority. However, we know the time when the last page from this task was finished printing. Given this information, find the unknown priority value and determine the moments of time when the printer finished printing each task.InputThe first line contains integer n (1 ≤ n ≤ 50000). Next n lines describe the tasks. The i-th of these lines contains three integers ti, si and pi, separated by single spaces (0 ≤ ti ≤ 109, 1 ≤ si, pi ≤ 109). Exactly one task (let's assume that his number is x) has number -1 written instead of the priority. All priorities are different. The last line contains integer T — the time when the printer finished printing the last page of task x (1 ≤ T ≤ 1015). Numbers ti are not necessarily distinct. The tasks in the input are written in the arbitrary order.OutputIn the first line print integer px — the priority of the task number x (1 ≤ px ≤ 109, remember that all priorities should be distinct). Then print n integers, the i-th of them represents the moment of time when the last page of the task number i finished printing. It is guaranteed that at least one solution exists. If there are multiple solutions, print any of them.ExamplesInput34 3 -10 2 21 3 37Output47 8 4Input33 1 22 3 33 1 -14Output47 6 4NoteLet's consider the first test case. Let's assume that the unknown priority equals 4, then the printer's actions for each second are as follows: the beginning of the 1-st second (time 0). The queue has task 2. The printer prints the first page of this task; the beginning of the 2-nd second (time 1). The queue has tasks 2 and 3. The printer prints the first page of task 3; the beginning of the 3-rd second (time 2). The queue has tasks 2 and 3. The printer prints the second page of task 3; the beginning of the 4-th second (time 3). The queue has tasks 2 and 3. The printer prints the third (last) page of task 3. Thus, by the end of the 4-th second this task will have been printed; the beginning of the 5-th second (time 4). The queue has tasks 2 and 1. The printer prints the first page of task 1; the beginning of the 6-th second (time 5). The queue has tasks 2 and 1. The printer prints the second page of task 1; the beginning of the 7-th second (time 6). The queue has tasks 2 and 1. The printer prints the third (last) page of task 1. Thus, by the end of the 7-th second this task will have been printed; the beginning of the 8-th second (time 7). The queue has task 2. The printer prints the second (last) page of task 2. Thus, by the end of the 8-th second this task will have been printed. In the end, task number 1 will have been printed by the end of the 7-th second, as was required. And tasks 2 and 3 are printed by the end of the of the 8-th and the 4-th second correspondingly.	Input34 3 -10 2 21 3 37	Output47 8 4	4 seconds	256 megabytes	['binary search', 'data structures', 'implementation', 'sortings', '*2200']
D. Table with Letters - 2time limit per test2 secondsmemory limit per test256 megabytesinputinput.txtoutputoutput.txtVasya has recently started to learn English. Now he needs to remember how to write English letters. He isn't sure about some of them, so he decided to train a little.He found a sheet of squared paper and began writing arbitrary English letters there. In the end Vasya wrote n lines containing m characters each. Thus, he got a rectangular n × m table, each cell of the table contained some English letter. Let's number the table rows from top to bottom with integers from 1 to n, and columns — from left to right with integers from 1 to m.After that Vasya looked at the resulting rectangular table and wondered, how many subtables are there, that matches both following conditions: the subtable contains at most k cells with "a" letter; all letters, located in all four corner cells of the subtable, are equal. Formally, a subtable's definition is as follows. It is defined by four integers x1, y1, x2, y2 such that 1 ≤ x1 < x2 ≤ n, 1 ≤ y1 < y2 ≤ m. Then the subtable contains all such cells (x, y) (x is the row number, y is the column number), for which the following inequality holds x1 ≤ x ≤ x2, y1 ≤ y ≤ y2. The corner cells of the table are cells (x1, y1), (x1, y2), (x2, y1), (x2, y2).Vasya is already too tired after he's been writing letters to a piece of paper. That's why he asks you to count the value he is interested in.InputThe first line contains three integers n, m, k (2 ≤ n, m ≤ 400; 0 ≤ k ≤ n·m).Next n lines contain m characters each — the given table. Each character of the table is a lowercase English letter.OutputPrint a single integer — the number of required subtables.ExamplesInput3 4 4aabbbaabbaabOutput2Input4 5 1ababaccacaccacbcbabcOutput1NoteThere are two suitable subtables in the first sample: the first one's upper left corner is cell (2, 2) and lower right corner is cell (3, 3), the second one's upper left corner is cell (2, 1) and lower right corner is cell (3, 4).	Input3 4 4aabbbaabbaab	Output2	2 seconds	256 megabytes	['brute force', 'two pointers', '*2000']
C. Text Editortime limit per test1 secondmemory limit per test256 megabytesinputinput.txtoutputoutput.txtVasya is pressing the keys on the keyboard reluctantly, squeezing out his ideas on the classical epos depicted in Homer's Odysseus... How can he explain to his literature teacher that he isn't going to become a writer? In fact, he is going to become a programmer. So, he would take great pleasure in writing a program, but none — in writing a composition.As Vasya was fishing for a sentence in the dark pond of his imagination, he suddenly wondered: what is the least number of times he should push a key to shift the cursor from one position to another one?Let's describe his question more formally: to type a text, Vasya is using the text editor. He has already written n lines, the i-th line contains ai characters (including spaces). If some line contains k characters, then this line overall contains (k + 1) positions where the cursor can stand: before some character or after all characters (at the end of the line). Thus, the cursor's position is determined by a pair of integers (r, c), where r is the number of the line and c is the cursor's position in the line (the positions are indexed starting from one from the beginning of the line).Vasya doesn't use the mouse to move the cursor. He uses keys "Up", "Down", "Right" and "Left". When he pushes each of these keys, the cursor shifts in the needed direction. Let's assume that before the corresponding key is pressed, the cursor was located in the position (r, c), then Vasya pushed key: "Up": if the cursor was located in the first line (r = 1), then it does not move. Otherwise, it moves to the previous line (with number r - 1), to the same position. At that, if the previous line was short, that is, the cursor couldn't occupy position c there, the cursor moves to the last position of the line with number r - 1; "Down": if the cursor was located in the last line (r = n), then it does not move. Otherwise, it moves to the next line (with number r + 1), to the same position. At that, if the next line was short, that is, the cursor couldn't occupy position c there, the cursor moves to the last position of the line with number r + 1; "Right": if the cursor can move to the right in this line (c < ar + 1), then it moves to the right (to position c + 1). Otherwise, it is located at the end of the line and doesn't move anywhere when Vasya presses the "Right" key; "Left": if the cursor can move to the left in this line (c > 1), then it moves to the left (to position c - 1). Otherwise, it is located at the beginning of the line and doesn't move anywhere when Vasya presses the "Left" key.You've got the number of lines in the text file and the number of characters, written in each line of this file. Find the least number of times Vasya should push the keys, described above, to shift the cursor from position (r1, c1) to position (r2, c2).InputThe first line of the input contains an integer n (1 ≤ n ≤ 100) — the number of lines in the file. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 105), separated by single spaces. The third line contains four integers r1, c1, r2, c2 (1 ≤ r1, r2 ≤ n, 1 ≤ c1 ≤ ar1 + 1, 1 ≤ c2 ≤ ar2 + 1).OutputPrint a single integer — the minimum number of times Vasya should push a key to move the cursor from position (r1, c1) to position (r2, c2).ExamplesInput42 1 6 43 4 4 2Output3Input410 5 6 41 11 4 2Output6Input310 1 101 10 1 1Output3NoteIn the first sample the editor contains four lines. Let's represent the cursor's possible positions in the line as numbers. Letter s represents the cursor's initial position, letter t represents the last one. Then all possible positions of the cursor in the text editor are described by the following table.12312123s5671t345One of the possible answers in the given sample is: "Left", "Down", "Left".	Input42 1 6 43 4 4 2	Output3	1 second	256 megabytes	['data structures', 'dfs and similar', 'graphs', 'greedy', 'shortest paths', '*1600']
B. Physics Practicaltime limit per test1 secondmemory limit per test256 megabytesinputinput.txtoutputoutput.txtOne day Vasya was on a physics practical, performing the task on measuring the capacitance. He followed the teacher's advice and did as much as n measurements, and recorded the results in the notebook. After that he was about to show the results to the teacher, but he remembered that at the last lesson, the teacher had made his friend Petya redo the experiment because the largest and the smallest results differed by more than two times. Vasya is lazy, and he does not want to redo the experiment. He wants to do the task and go home play computer games. So he decided to cheat: before Vasya shows the measurements to the teacher, he will erase some of them, so as to make the largest and the smallest results of the remaining measurements differ in no more than two times. In other words, if the remaining measurements have the smallest result x, and the largest result y, then the inequality y ≤ 2·x must fulfill. Of course, to avoid the teacher's suspicion, Vasya wants to remove as few measurement results as possible from his notes.Help Vasya, find what minimum number of measurement results he will have to erase from his notes so that the largest and the smallest of the remaining results of the measurements differed in no more than two times.InputThe first line contains integer n (2 ≤ n ≤ 105) — the number of measurements Vasya made. The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 5000) — the results of the measurements. The numbers on the second line are separated by single spaces.OutputPrint a single integer — the minimum number of results Vasya will have to remove.ExamplesInput64 5 3 8 3 7Output2Input44 3 2 4Output0NoteIn the first sample you can remove the fourth and the sixth measurement results (values 8 and 7). Then the maximum of the remaining values will be 5, and the minimum one will be 3. Or else, you can remove the third and fifth results (both equal 3). After that the largest remaining result will be 8, and the smallest one will be 4.	Input64 5 3 8 3 7	Output2	1 second	256 megabytes	['binary search', 'dp', 'sortings', 'two pointers', '*1400']
A. Boys and Girlstime limit per test1 secondmemory limit per test256 megabytesinputinput.txtoutputoutput.txtThere are n boys and m girls studying in the class. They should stand in a line so that boys and girls alternated there as much as possible. Let's assume that positions in the line are indexed from left to right by numbers from 1 to n + m. Then the number of integers i (1 ≤ i < n + m) such that positions with indexes i and i + 1 contain children of different genders (position i has a girl and position i + 1 has a boy or vice versa) must be as large as possible. Help the children and tell them how to form the line.InputThe single line of the input contains two integers n and m (1 ≤ n, m ≤ 100), separated by a space.OutputPrint a line of n + m characters. Print on the i-th position of the line character "B", if the i-th position of your arrangement should have a boy and "G", if it should have a girl. Of course, the number of characters "B" should equal n and the number of characters "G" should equal m. If there are multiple optimal solutions, print any of them.ExamplesInput3 3OutputGBGBGBInput4 2OutputBGBGBBNoteIn the first sample another possible answer is BGBGBG. In the second sample answer BBGBGB is also optimal.	Input3 3	OutputGBGBGB	1 second	256 megabytes	['greedy', '*1100']
B. Unsorting Arraytime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLittle Petya likes arrays of integers a lot. Recently his mother has presented him one such array consisting of n elements. Petya is now wondering whether he can swap any two distinct integers in the array so that the array got unsorted. Please note that Petya can not swap equal integers even if they are in distinct positions in the array. Also note that Petya must swap some two integers even if the original array meets all requirements.Array a (the array elements are indexed from 1) consisting of n elements is called sorted if it meets at least one of the following two conditions: a1 ≤ a2 ≤ ... ≤ an; a1 ≥ a2 ≥ ... ≥ an. Help Petya find the two required positions to swap or else say that they do not exist.InputThe first line contains a single integer n (1 ≤ n ≤ 105). The second line contains n non-negative space-separated integers a1, a2, ..., an — the elements of the array that Petya's mother presented him. All integers in the input do not exceed 109.OutputIf there is a pair of positions that make the array unsorted if swapped, then print the numbers of these positions separated by a space. If there are several pairs of positions, print any of them. If such pair does not exist, print -1. The positions in the array are numbered with integers from 1 to n.ExamplesInput11Output-1Input21 2Output-1Input41 2 3 4Output1 2Input31 1 1Output-1NoteIn the first two samples the required pairs obviously don't exist.In the third sample you can swap the first two elements. After that the array will look like this: 2 1 3 4. This array is unsorted.	Input11	Output-1	2 seconds	256 megabytes	['brute force', 'sortings', '*1800']
A. Little Xortime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLittle Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.InputThe first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.OutputPrint a single integer — the required maximal xor of a segment of consecutive elements.ExamplesInput51 2 1 1 2Output3Input31 2 7Output7Input44 2 4 8Output14NoteIn the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.The second sample contains only one optimal segment, which contains exactly one array element (element with index three).	Input51 2 1 1 2	Output3	2 seconds	256 megabytes	['brute force', 'implementation', '*1100']
E. Tree and Tabletime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLittle Petya likes trees a lot. Recently his mother has presented him a tree with 2n nodes. Petya immediately decided to place this tree on a rectangular table consisting of 2 rows and n columns so as to fulfill the following conditions: Each cell of the table corresponds to exactly one tree node and vice versa, each tree node corresponds to exactly one table cell. If two tree nodes are connected by an edge, then the corresponding cells have a common side. Now Petya wonders how many ways are there to place his tree on the table. He calls two placements distinct if there is a tree node which corresponds to distinct table cells in these two placements. Since large numbers can scare Petya, print the answer modulo 1000000007 (109 + 7).InputThe first line contains a single integer n (1 ≤ n ≤ 105). Next (2n - 1) lines contain two integers each ai and bi (1 ≤ ai, bi ≤ 2n; ai ≠ bi) that determine the numbers of the vertices connected by the corresponding edge. Consider the tree vertexes numbered by integers from 1 to 2n. It is guaranteed that the graph given in the input is a tree, that is, a connected acyclic undirected graph.OutputPrint a single integer — the required number of ways to place the tree on the table modulo 1000000007 (109 + 7).ExamplesInput31 32 34 35 16 2Output12Input41 22 33 44 55 66 77 8Output28Input21 23 24 2Output0NoteNote to the first sample (all 12 variants to place the tree on the table are given below):1-3-2 2-3-1 5 4 6 6 4 5\| \| \| \| \| \| \| \| \| \| \| \|5 4 6 6 4 5 1-3-2 2-3-14-3-2 2-3-4 5-1 6 6 1-5 \| \| \| \| \| \| \| \|5-1 6 6 1-5 4-3-2 2-3-41-3-4 4-3-1 5 2-6 6-2 5\| \| \| \| \| \| \| \|5 2-6 6-2 5 1-3-4 4-3-1	Input31 32 34 35 16 2	Output12	2 seconds	256 megabytes	['dfs and similar', 'dp', 'implementation', 'trees', '*3000']
D. Two Setstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLittle Petya likes numbers a lot. Recently his mother has presented him a collection of n non-negative integers. There's only one thing Petya likes more than numbers: playing with little Masha. He immediately decided to give a part of his new collection to her. To make the game even more interesting, Petya decided to give Masha such collection of numbers for which the following conditions fulfill: Let's introduce x1 to denote the xor of all numbers Petya has got left; and let's introduce x2 to denote the xor of all numbers he gave to Masha. Value (x1 + x2) must be as large as possible. If there are multiple ways to divide the collection so that the previous condition fulfilled, then Petya minimizes the value x1. The xor operation is a bitwise excluding "OR", that is denoted as "xor" in the Pascal language and "^" in C/C++/Java.Help Petya divide the collection as described above. If there are multiple suitable ways to divide it, find any of them. Please note that after Petya gives a part of his numbers to Masha, he may have no numbers left. The reverse situation is also possible, when Petya gives nothing to Masha. In both cases we must assume that the xor of an empty set of numbers equals 0.InputThe first line contains integer n (1 ≤ n ≤ 105), showing how many numbers Petya's mother gave him. The second line contains the actual space-separated numbers. They are all integer, non-negative and do not exceed 1018.OutputPrint n space-separated integers, the i-th of them should equal either 1, if Petya keeps the number that follows i-th in his collection, or it should equal 2, if Petya gives the corresponding number to Masha. The numbers are indexed in the order in which they are given in the input.ExamplesInput61 2 3 4 5 6Output2 2 2 2 2 2Input31000000000000 1000000000000 1000000000000Output2 2 2Input81 1 2 2 3 3 4 4Output1 2 1 2 2 2 1 2	Input61 2 3 4 5 6	Output2 2 2 2 2 2	2 seconds	256 megabytes	['bitmasks', 'math', '*2700']
C. Number Transformationtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLittle Petya likes positive integers a lot. Recently his mom has presented him a positive integer a. There's only one thing Petya likes more than numbers: playing with little Masha. It turned out that Masha already has a positive integer b. Petya decided to turn his number a into the number b consecutively performing the operations of the following two types: Subtract 1 from his number. Choose any integer x from 2 to k, inclusive. Then subtract number (a mod x) from his number a. Operation a mod x means taking the remainder from division of number a by number x. Petya performs one operation per second. Each time he chooses an operation to perform during the current move, no matter what kind of operations he has performed by that moment. In particular, this implies that he can perform the same operation any number of times in a row.Now he wonders in what minimum number of seconds he could transform his number a into number b. Please note that numbers x in the operations of the second type are selected anew each time, independently of each other.InputThe only line contains three integers a, b (1 ≤ b ≤ a ≤ 1018) and k (2 ≤ k ≤ 15).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 a single integer — the required minimum number of seconds needed to transform number a into number b.ExamplesInput10 1 4Output6Input6 3 10Output2Input1000000000000000000 1 3Output666666666666666667NoteIn the first sample the sequence of numbers that Petya gets as he tries to obtain number b is as follows: 10 → 8 → 6 → 4 → 3 → 2 → 1.In the second sample one of the possible sequences is as follows: 6 → 4 → 3.	Input10 1 4	Output6	2 seconds	256 megabytes	['dp', 'greedy', 'number theory', '*2000']
B. Playing with Permutationstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLittle Petya likes permutations a lot. Recently his mom has presented him permutation q1, q2, ..., qn of length n.A permutation a of length n is a sequence of integers a1, a2, ..., an (1 ≤ ai ≤ n), all integers there are distinct. There is only one thing Petya likes more than permutations: playing with little Masha. As it turns out, Masha also has a permutation of length n. Petya decided to get the same permutation, whatever the cost may be. For that, he devised a game with the following rules: Before the beginning of the game Petya writes permutation 1, 2, ..., n on the blackboard. After that Petya makes exactly k moves, which are described below. During a move Petya tosses a coin. If the coin shows heads, he performs point 1, if the coin shows tails, he performs point 2. Let's assume that the board contains permutation p1, p2, ..., pn at the given moment. Then Petya removes the written permutation p from the board and writes another one instead: pq1, pq2, ..., pqn. In other words, Petya applies permutation q (which he has got from his mother) to permutation p. All actions are similar to point 1, except that Petya writes permutation t on the board, such that: tqi = pi for all i from 1 to n. In other words, Petya applies a permutation that is inverse to q to permutation p. We know that after the k-th move the board contained Masha's permutation s1, s2, ..., sn. Besides, we know that throughout the game process Masha's permutation never occurred on the board before the k-th move. Note that the game has exactly k moves, that is, throughout the game the coin was tossed exactly k times.Your task is to determine whether the described situation is possible or else state that Petya was mistaken somewhere. See samples and notes to them for a better understanding.InputThe first line contains two integers n and k (1 ≤ n, k ≤ 100). The second line contains n space-separated integers q1, q2, ..., qn (1 ≤ qi ≤ n) — the permutation that Petya's got as a present. The third line contains Masha's permutation s, in the similar format.It is guaranteed that the given sequences q and s are correct permutations.OutputIf the situation that is described in the statement is possible, print "YES" (without the quotes), otherwise print "NO" (without the quotes).ExamplesInput4 12 3 4 11 2 3 4OutputNOInput4 14 3 1 23 4 2 1OutputYESInput4 34 3 1 23 4 2 1OutputYESInput4 24 3 1 22 1 4 3OutputYESInput4 14 3 1 22 1 4 3OutputNONoteIn the first sample Masha's permutation coincides with the permutation that was written on the board before the beginning of the game. Consequently, that violates the condition that Masha's permutation never occurred on the board before k moves were performed.In the second sample the described situation is possible, in case if after we toss a coin, we get tails.In the third sample the possible coin tossing sequence is: heads-tails-tails.In the fourth sample the possible coin tossing sequence is: heads-heads.	Input4 12 3 4 11 2 3 4	OutputNO	2 seconds	256 megabytes	['implementation', 'math', '*1800']

Subsets and Splits