Problem ID stringlengths 2 6 | Problem Description stringlengths 0 7.52k | Rating float64 800 3.5k | math bool 2 classes | greedy bool 2 classes | implementation bool 2 classes | dp bool 2 classes | data structures bool 2 classes | constructive algorithms bool 2 classes | brute force bool 2 classes | binary search bool 2 classes | sortings bool 2 classes | graphs bool 2 classes | __index_level_0__ int64 3 9.98k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
260D | The 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 _s__v_ 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 _s__v_. Input The first line of the input contains a single integer _n_ (2u2009β€u2009_n_u2009β€u2009105) β the number of nodes in the tree. Next _n_ lines contain pairs of space-separated integers _c__i_, _s__i_ (0u2009β€u2009_c__i_u2009β€u20091, 0u2009β€u2009_s__i_u2009β€u2009109), where _c__i_ stands for the color of the _i_-th vertex (0 is for white, 1 is for black), and _s__i_ 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. Output Print the description of _n_u2009-u20091 edges of the tree graph. Each description is a group of three integers _v__i_, _u__i_, _w__i_ (1u2009β€u2009_v__i_,u2009_u__i_u2009β€u2009_n_, _v__i_u2009β u2009_u__i_, 0u2009β€u2009_w__i_u2009β€u2009109), where _v__i_ and _u__i_ β are the numbers of the nodes that are connected by the _i_-th edge, and _w__i_ is its value. Note that the following condition must fulfill _c__v__i_u2009β u2009_c__u__i_. 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. Examples Output 2 3 3 5 3 3 4 3 2 1 6 0 2 1 0 | 2,100 | false | true | false | false | false | true | false | false | false | true | 8,792 |
316A1 | Special Agent Smart Beaver works in a secret research department of ABBYY. He's been working there for a long time and is satisfied with his job, as it allows him to eat out in the best restaurants and order the most expensive and exotic wood types there. The content special agent has got an important task: to get the latest research by British scientists on the English Language. These developments are encoded and stored in a large safe. The Beaver's teeth are strong enough, so the authorities assured that upon arriving at the place the beaver won't have any problems with opening the safe. And he finishes his aspen sprig and leaves for this important task. Of course, the Beaver arrived at the location without any problems, but alas. He can't open the safe with his strong and big teeth. At this point, the Smart Beaver get a call from the headquarters and learns that opening the safe with the teeth is not necessary, as a reliable source has sent the following information: the safe code consists of digits and has no leading zeroes. There also is a special hint, which can be used to open the safe. The hint is string _s_ with the following structure: if _s__i_ = "?", then the digit that goes _i_-th in the safe code can be anything (between 0 to 9, inclusively); if _s__i_ is a digit (between 0 to 9, inclusively), then it means that there is digit _s__i_ on position _i_ in code; if the string contains letters from "A" to "J", then all positions with the same letters must contain the same digits and the positions with distinct letters must contain distinct digits. The length of the safe code coincides with the length of the hint. For example, hint "?JGJ9" has such matching safe code variants: "51919", "55959", "12329", "93539" and so on, and has wrong variants such as: "56669", "00111", "03539" and "13666". After receiving such information, the authorities change the plan and ask the special agents to work quietly and gently and not to try to open the safe by mechanical means, and try to find the password using the given hint. At a special agent school the Smart Beaver was the fastest in his platoon finding codes for such safes, but now he is not in that shape: the years take their toll ... Help him to determine the number of possible variants of the code to the safe, matching the given hint. After receiving this information, and knowing his own speed of entering codes, the Smart Beaver will be able to determine whether he will have time for tonight's show "Beavers are on the trail" on his favorite TV channel, or he should work for a sleepless night... Input The first line contains string _s_ β the hint to the safe code. String _s_ consists of the following characters: ?, 0-9, A-J. It is guaranteed that the first character of string _s_ doesn't equal to character 0. The input limits for scoring 30 points are (subproblem A1): 1u2009β€u2009_s_u2009β€u20095. The input limits for scoring 100 points are (subproblems A1+A2): 1u2009β€u2009_s_u2009β€u2009105. Here _s_ means the length of string _s_. | 1,100 | false | true | false | false | false | false | false | false | false | false | 8,583 |
1659B | You are given a binary string of length $$$n$$$. You have exactly $$$k$$$ moves. In one move, you must select a single bit. The state of all bits except that bit will get flipped ($$$0$$$ becomes $$$1$$$, $$$1$$$ becomes $$$0$$$). You need to output the lexicographically largest string that you can get after using all $$$k$$$ moves. Also, output the number of times you will select each bit. If there are multiple ways to do this, you may output any of them. A binary string $$$a$$$ is lexicographically larger than a binary string $$$b$$$ of the same length, if and only if the following holds: in the first position where $$$a$$$ and $$$b$$$ differ, the string $$$a$$$ contains a $$$1$$$, and the string $$$b$$$ contains a $$$0$$$. Input The first line contains a single integer $$$t$$$ ($$$1 le t le 1000$$$) xa0β the number of test cases. Each test case has two lines. The first line has two integers $$$n$$$ and $$$k$$$ ($$$1 leq n leq 2 cdot 10^5$$$; $$$0 leq k leq 10^9$$$). The second line has a binary string of length $$$n$$$, each character is either $$$0$$$ or $$$1$$$. The sum of $$$n$$$ over all test cases does not exceed $$$2 cdot 10^5$$$. Output For each test case, output two lines. The first line should contain the lexicographically largest string you can obtain. The second line should contain $$$n$$$ integers $$$f_1, f_2, ldots, f_n$$$, where $$$f_i$$$ is the number of times the $$$i$$$-th bit is selected. The sum of all the integers must be equal to $$$k$$$. Example Input 6 6 3 100001 6 4 100011 6 0 000000 6 1 111001 6 11 101100 6 12 001110 Output 111110 1 0 0 2 0 0 111110 0 1 1 1 0 1 000000 0 0 0 0 0 0 100110 1 0 0 0 0 0 111111 1 2 1 3 0 4 111110 1 1 4 2 0 4 Note Here is the explanation for the first testcase. Each step shows how the binary string changes in a move. Choose bit $$$1$$$: $$$color{red}{underline{1}00001} ightarrow color{red}{underline{1}}color{blue}{11110}$$$. Choose bit $$$4$$$: $$$color{red}{111underline{1}10} ightarrow color{blue}{000}color{red}{underline{1}}color{blue}{01}$$$. Choose bit $$$4$$$: $$$color{red}{000underline{1}01} ightarrow color{blue}{111}color{red}{underline{1}}color{blue}{10}$$$. The final string is $$$111110$$$ and this is the lexicographically largest string we can get. | 1,300 | false | true | false | false | false | true | false | false | false | false | 2,331 |
103C | After all the events in Orlando we all know, Sasha and Roma decided to find out who is still the team's biggest loser. Thankfully, Masha found somewhere a revolver with a rotating cylinder of _n_ bullet slots able to contain exactly _k_ bullets, now the boys have a chance to resolve the problem once and for all. Sasha selects any _k_ out of _n_ slots he wishes and puts bullets there. Roma spins the cylinder so that every of _n_ possible cylinder's shifts is equiprobable. Then the game starts, the players take turns, Sasha starts: he puts the gun to his head and shoots. If there was no bullet in front of the trigger, the cylinder shifts by one position and the weapon is given to Roma for make the same move. The game continues until someone is shot, the survivor is the winner. Sasha does not want to lose, so he must choose slots for bullets in such a way as to minimize the probability of its own loss. Of all the possible variant he wants to select the lexicographically minimal one, where an empty slot is lexicographically less than a charged one. More formally, the cylinder of _n_ bullet slots able to contain _k_ bullets can be represented as a string of _n_ characters. Exactly _k_ of them are "X" (charged slots) and the others are "." (uncharged slots). Let us describe the process of a shot. Suppose that the trigger is in front of the first character of the string (the first slot). If a shot doesn't kill anyone and the cylinder shifts, then the string shifts left. So the first character becomes the last one, the second character becomes the first one, and so on. But the trigger doesn't move. It will be in front of the first character of the resulting string. Among all the strings that give the minimal probability of loss, Sasha choose the lexicographically minimal one. According to this very string, he charges the gun. You have to help Sasha to charge the gun. For that, each _x__i_ query must be answered: is there a bullet in the positions _x__i_? Input The first line contains three integers _n_, _k_ and _p_ (1u2009β€u2009_n_u2009β€u20091018,u20090u2009β€u2009_k_u2009β€u2009_n_,u20091u2009β€u2009_p_u2009β€u20091000) β the number of slots in the cylinder, the number of bullets and the number of queries. Then follow _p_ lines; they are the queries. Each line contains one integer _x__i_ (1u2009β€u2009_x__i_u2009β€u2009_n_) the number of slot to describe. Please do not use the %lld specificator to read or write 64-bit numbers in Π‘++. It is preferred to use cin, cout streams or the %I64d specificator. Note The lexicographical comparison of is performed by the < operator in modern programming languages. The _a_ string is lexicographically less that the _b_ string, if there exists such _i_ (1u2009β€u2009_i_u2009β€u2009_n_), that _a__i_u2009<u2009_b__i_, and for any _j_ (1u2009β€u2009_j_u2009<u2009_i_) _a__j_u2009=u2009_b__j_. | 1,900 | false | true | false | false | false | true | false | false | false | false | 9,470 |
1420A | For god's sake, you're boxes with legs! It is literally your only purpose! Walking onto buttons! How can you not do the one thing you were designed for?Oh, that's funny, is it? Oh it's funny? Because we've been at this for twelve hours and you haven't solved it either, so I don't know why you're laughing. You've got one hour! Solve it! Wheatley decided to try to make a test chamber. He made a nice test chamber, but there was only one detail absentxa0β cubes. For completing the chamber Wheatley needs $$$n$$$ cubes. $$$i$$$-th cube has a volume $$$a_i$$$. Wheatley has to place cubes in such a way that they would be sorted in a non-decreasing order by their volume. Formally, for each $$$i>1$$$, $$$a_{i-1} le a_i$$$ must hold. To achieve his goal, Wheatley can exchange two neighbouring cubes. It means that for any $$$i>1$$$ you can exchange cubes on positions $$$i-1$$$ and $$$i$$$. But there is a problem: Wheatley is very impatient. If Wheatley needs more than $$$frac{n cdot (n-1)}{2}-1$$$ exchange operations, he won't do this boring work. Wheatly wants to know: can cubes be sorted under this conditions? Input Each test contains multiple test cases. The first line contains one positive integer $$$t$$$ ($$$1 le t le 1000$$$), denoting the number of test cases. Description of the test cases follows. The first line of each test case contains one positive integer $$$n$$$ ($$$2 le n le 5 cdot 10^4$$$)xa0β number of cubes. The second line contains $$$n$$$ positive integers $$$a_i$$$ ($$$1 le a_i le 10^9$$$)xa0β volumes of cubes. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$. Output For each test case, print a word in a single line: "YES" (without quotation marks) if the cubes can be sorted and "NO" (without quotation marks) otherwise. Example Input 3 5 5 3 2 1 4 6 2 2 2 2 2 2 2 2 1 Note In the first test case it is possible to sort all the cubes in $$$7$$$ exchanges. In the second test case the cubes are already sorted. In the third test case we can make $$$0$$$ exchanges, but the cubes are not sorted yet, so the answer is "NO". | 900 | true | false | false | false | false | false | false | false | true | false | 3,580 |
911B | It's New Year's Eve soon, so Ivan decided it's high time he started setting the table. Ivan has bought two cakes and cut them into pieces: the first cake has been cut into _a_ pieces, and the second one β into _b_ pieces. Ivan knows that there will be _n_ people at the celebration (including himself), so Ivan has set _n_ plates for the cakes. Now he is thinking about how to distribute the cakes between the plates. Ivan wants to do it in such a way that all following conditions are met: 1. Each piece of each cake is put on some plate; 2. Each plate contains at least one piece of cake; 3. No plate contains pieces of both cakes. To make his guests happy, Ivan wants to distribute the cakes in such a way that the minimum number of pieces on the plate is maximized. Formally, Ivan wants to know the maximum possible number _x_ such that he can distribute the cakes according to the aforementioned conditions, and each plate will contain at least _x_ pieces of cake. Help Ivan to calculate this number _x_! Input The first line contains three integers _n_, _a_ and _b_ (1u2009β€u2009_a_,u2009_b_u2009β€u2009100, 2u2009β€u2009_n_u2009β€u2009_a_u2009+u2009_b_) β the number of plates, the number of pieces of the first cake, and the number of pieces of the second cake, respectively. Output Print the maximum possible number _x_ such that Ivan can distribute the cake in such a way that each plate will contain at least _x_ pieces of cake. Note In the first example there is only one way to distribute cakes to plates, all of them will have 1 cake on it. In the second example you can have two plates with 3 and 4 pieces of the first cake and two plates both with 5 pieces of the second cake. Minimal number of pieces is 3. | 1,200 | false | false | true | false | false | false | true | true | false | false | 6,102 |
1918B | You are given two permutations $$$a$$$ and $$$b$$$ of length $$$n$$$. A permutation is an array of $$$n$$$ elements from $$$1$$$ to $$$n$$$ where all elements are distinct. For example, an array [$$$2,1,3$$$] is a permutation, but [$$$0,1$$$] and [$$$1,3,1$$$] aren't. You can (as many times as you want) choose two indices $$$i$$$ and $$$j$$$, then swap $$$a_i$$$ with $$$a_j$$$ and $$$b_i$$$ with $$$b_j$$$ simultaneously. You hate inversions, so you want to minimize the total number of inversions in both permutations. An inversion in a permutation $$$p$$$ is a pair of indices $$$(i, j)$$$ such that $$$i < j$$$ and $$$p_i > p_j$$$. For example, if $$$p=[3,1,4,2,5]$$$ then there are $$$3$$$ inversions in it (the pairs of indices are $$$(1,2)$$$, $$$(1,4)$$$ and $$$(3,4)$$$). Input The first line contains an integer $$$t$$$ ($$$1 leq t leq 20,000$$$)xa0β the number of test cases. Each test case consists of three lines. The first line contains an integer $$$n$$$ ($$$1 leq n leq 2cdot10^5$$$)xa0β the length of the permutations $$$a$$$ and $$$b$$$. The second line contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$1 leq a_i leq n$$$)xa0β permutation $$$a$$$. The third line contains $$$b$$$ in a similar format. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$2cdot10^5$$$. Output For each test case, output two permutations $$$a'$$$ and $$$b'$$$ (in the same format as in the input)xa0β the permutations after all operations. The total number of inversions in $$$a'$$$ and $$$b'$$$ should be the minimum possible among all pairs of permutations that can be obtained using operations from the statement. If there are multiple solutions, print any of them. Example Input 3 5 1 2 3 4 5 5 4 3 2 1 3 3 1 2 3 1 2 6 2 5 6 1 3 4 1 5 3 6 2 4 Output 3 2 5 1 4 3 4 1 5 2 1 2 3 1 2 3 2 3 4 6 5 1 1 2 4 3 5 6 Note In the first test case, the minimum possible number of inversions is $$$10$$$. In the second test case, we can sort both permutations at the same time. For this, the following operations can be done: Swap the elements in the positions $$$1$$$ and $$$3$$$ in both permutations. After the operation, $$$a =$$$ [$$$2,1,3$$$], $$$b =$$$ [$$$2,1,3$$$]. Swap the elements in the positions $$$1$$$ and $$$2$$$. After the operations, $$$a$$$ and $$$b$$$ are sorted. In the third test case, the minimum possible number of inversions is $$$7$$$. | 900 | false | true | true | false | true | true | false | false | true | false | 787 |
991C | After passing a test, Vasya got himself a box of $$$n$$$ candies. He decided to eat an equal amount of candies each morning until there are no more candies. However, Petya also noticed the box and decided to get some candies for himself. This means the process of eating candies is the following: in the beginning Vasya chooses a single integer $$$k$$$, same for all days. After that, in the morning he eats $$$k$$$ candies from the box (if there are less than $$$k$$$ candies in the box, he eats them all), then in the evening Petya eats $$$10%$$$ of the candies remaining in the box. If there are still candies left in the box, the process repeatsxa0β next day Vasya eats $$$k$$$ candies again, and Petyaxa0β $$$10%$$$ of the candies left in a box, and so on. If the amount of candies in the box is not divisible by $$$10$$$, Petya rounds the amount he takes from the box down. For example, if there were $$$97$$$ candies in the box, Petya would eat only $$$9$$$ of them. In particular, if there are less than $$$10$$$ candies in a box, Petya won't eat any at all. Your task is to find out the minimal amount of $$$k$$$ that can be chosen by Vasya so that he would eat at least half of the $$$n$$$ candies he initially got. Note that the number $$$k$$$ must be integer. Note In the sample, the amount of candies, with $$$k=3$$$, would change in the following way (Vasya eats first): $$$68 o 65 o 59 o 56 o 51 o 48 o 44 o 41 o 37 o 34 o 31 o 28 o 26 o 23 o 21 o 18 o 17 o 14 o 13 o 10 o 9 o 6 o 6 o 3 o 3 o 0$$$. In total, Vasya would eat $$$39$$$ candies, while Petyaxa0β $$$29$$$. | 1,500 | false | false | true | false | false | false | false | true | false | false | 5,743 |
1870H | Problem - 1870H - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags data structures graphs greedy trees *3500 No tag edit access β Contest materials ") Editorial") β the number of vertices in the graph, the number of edges, and the number of queries. The next $$$m$$$ lines contain the edges of the graph, one edge per line. The $$$i$$$-th line contains three integers $$$u_i$$$, $$$v_i$$$, and $$$c_i$$$ ($$$1 leq u_i, v_i leq n, u_i e v_i, 1 leq c_i leq 10^6$$$) β the endpoints of the $$$i$$$-th edge (from $$$u_i$$$ to $$$v_i$$$) and its weight ($$$c_i$$$). The next $$$q$$$ lines contain the queries, one query per line. The $$$i$$$-th line contains $$$+;v_i$$$, if it is a query of the first type, and $$$-;v_i$$$, if it is a query of the second type ($$$1 leq v_i leq n$$$). Output Output $$$q$$$ numbers. The $$$i$$$-th number is the cost of the graph after the first $$$i$$$ queries. Examples Input 4 5 6 1 2 1 2 3 5 3 2 3 4 1 8 2 1 4 + 1 - 1 + 3 + 1 + 4 + 2 Output 15 -1 14 12 4 0 Input 10 14 10 8 6 4 2 5 1 3 5 4 1 6 3 1 3 7 7 2 1 6 1 3 4 10 1 4 6 5 5 4 1 5 8 10 10 9 1 9 5 1 9 7 6 + 7 + 8 - 7 + 10 + 2 - 10 + 5 - 2 - 5 + 3 Output 28 24 29 19 18 24 18 19 29 20 Note In the first test: After the first query, it is most profitable to select the edges with numbers $$$3, 4, 5$$$, their total cost is $$$15$$$. After the second query, there are no highlighted vertices, which means that there are no suitable sets of edges, the cost of the graph is $$$-1$$$. After the third query, it is most profitable to select the edges with numbers $$$1, 2, 5$$$, their total cost is $$$14$$$. After the fourth query, it is most profitable to select the edges with numbers $$$4$$$ and $$$5$$$, their total cost is $$$12$$$. After the fifth query, it is most profitable to select only edge number $$$5$$$, its cost is $$$4$$$. After the sixth query, all vertices are highlighted and there is no need to select any edges, the cost of the graph is $$$0$$$. | 3,500 | false | true | false | false | true | false | false | false | false | true | 1,052 |
1905E | In this sad world full of imperfections, ugly segment trees exist. A segment tree is a tree where each node represents a segment and has its number. A segment tree for an array of $$$n$$$ elements can be built in a recursive manner. Let's say function $$$operatorname{build}(v,l,r)$$$ builds the segment tree rooted in the node with number $$$v$$$ and it corresponds to the segment $$$[l,r]$$$. Now let's define $$$operatorname{build}(v,l,r)$$$: If $$$l=r$$$, this node $$$v$$$ is a leaf so we stop adding more edges Else, we add the edges $$$(v, 2v)$$$ and $$$(v, 2v+1)$$$. Let $$$m=lfloor frac{l+r}{2} floor$$$. Then we call $$$operatorname{build}(2v,l,m)$$$ and $$$operatorname{build}(2v+1,m+1,r)$$$. So, the whole tree is built by calling $$$operatorname{build}(1,1,n)$$$. Now Ibti will construct a segment tree for an array with $$$n$$$ elements. He wants to find the sum of $$$operatorname{lca}^dagger(S)$$$, where $$$S$$$ is a non-empty subset of leaves. Notice that there are exactly $$$2^n - 1$$$ possible subsets. Since this sum can be very large, output it modulo $$$998,244,353$$$. $$$^daggeroperatorname{lca}(S)$$$ is the number of the least common ancestor for the nodes that are in $$$S$$$. Input Each test consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 le t le 10^3$$$)xa0β the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$2 le n le 10^{18}$$$)xa0β the length of the array for which the segment tree is built. Output For each test case, output a single integer β the required sum modulo $$$998,244,353$$$. Note In the first test case: Let's look at all subsets of leaves. $$$operatorname{lca}({2})=2$$$; $$$operatorname{lca}({3})=3$$$; $$$operatorname{lca}({2,3})=1$$$. Thus, the answer is $$$2+3+1=6$$$. In the second test case: Let's look at all subsets of leaves. $$$operatorname{lca}({4})=4$$$; $$$operatorname{lca}({5})=5$$$; $$$operatorname{lca}({3})=3$$$; $$$operatorname{lca}({4,5})=2$$$; $$$operatorname{lca}({4,3})=1$$$; $$$operatorname{lca}({5,3})=1$$$; $$$operatorname{lca}({4,5,3})=1$$$; Thus, the answer is $$$4+5+3+2+1+1+1=17$$$. | 2,400 | true | false | false | true | false | false | false | false | false | false | 879 |
1272B | Recently you have bought a snow walking robot and brought it home. Suppose your home is a cell $$$(0, 0)$$$ on an infinite grid. You also have the sequence of instructions of this robot. It is written as the string $$$s$$$ consisting of characters 'L', 'R', 'U' and 'D'. If the robot is in the cell $$$(x, y)$$$ right now, he can move to one of the adjacent cells (depending on the current instruction). If the current instruction is 'L', then the robot can move to the left to $$$(x - 1, y)$$$; if the current instruction is 'R', then the robot can move to the right to $$$(x + 1, y)$$$; if the current instruction is 'U', then the robot can move to the top to $$$(x, y + 1)$$$; if the current instruction is 'D', then the robot can move to the bottom to $$$(x, y - 1)$$$. You've noticed the warning on the last page of the manual: if the robot visits some cell (except $$$(0, 0)$$$) twice then it breaks. So the sequence of instructions is valid if the robot starts in the cell $$$(0, 0)$$$, performs the given instructions, visits no cell other than $$$(0, 0)$$$ two or more times and ends the path in the cell $$$(0, 0)$$$. Also cell $$$(0, 0)$$$ should be visited at most two times: at the beginning and at the end (if the path is empty then it is visited only once). For example, the following sequences of instructions are considered valid: "UD", "RL", "UUURULLDDDDLDDRRUU", and the following are considered invalid: "U" (the endpoint is not $$$(0, 0)$$$) and "UUDD" (the cell $$$(0, 1)$$$ is visited twice). The initial sequence of instructions, however, might be not valid. You don't want your robot to break so you decided to reprogram it in the following way: you will remove some (possibly, all or none) instructions from the initial sequence of instructions, then rearrange the remaining instructions as you wish and turn on your robot to move. Your task is to remove as few instructions from the initial sequence as possible and rearrange the remaining ones so that the sequence is valid. Report the valid sequence of the maximum length you can obtain. Note that you can choose any order of remaining instructions (you don't need to minimize the number of swaps or any other similar metric). You have to answer $$$q$$$ independent test cases. Input The first line of the input contains one integer $$$q$$$ ($$$1 le q le 2 cdot 10^4$$$) β the number of test cases. The next $$$q$$$ lines contain test cases. The $$$i$$$-th test case is given as the string $$$s$$$ consisting of at least $$$1$$$ and no more than $$$10^5$$$ characters 'L', 'R', 'U' and 'D' β the initial sequence of instructions. It is guaranteed that the sum of $$$s$$$ (where $$$s$$$ is the length of $$$s$$$) does not exceed $$$10^5$$$ over all test cases ($$$sum s le 10^5$$$). Output For each test case print the answer on it. In the first line print the maximum number of remaining instructions. In the second line print the valid sequence of remaining instructions $$$t$$$ the robot has to perform. The moves are performed from left to right in the order of the printed sequence. If there are several answers, you can print any. If the answer is $$$0$$$, you are allowed to print an empty line (but you can don't print it). | 1,200 | false | true | true | false | false | true | false | false | false | false | 4,328 |
607E | Genos has been given _n_ distinct lines on the Cartesian plane. Let be a list of intersection points of these lines. A single point might appear multiple times in this list if it is the intersection of multiple pairs of lines. The order of the list does not matter. Given a query point (_p_,u2009_q_), let be the corresponding list of distances of all points in to the query point. Distance here refers to euclidean distance. As a refresher, the euclidean distance between two points (_x_1,u2009_y_1) and (_x_2,u2009_y_2) is . Genos is given a point (_p_,u2009_q_) and a positive integer _m_. He is asked to find the sum of the _m_ smallest elements in . Duplicate elements in are treated as separate elements. Genos is intimidated by Div1 E problems so he asked for your help. Input The first line of the input contains a single integer _n_ (2u2009β€u2009_n_u2009β€u200950u2009000)xa0β the number of lines. The second line contains three integers _x_, _y_ and _m_ (_x_,u2009_y_u2009β€u20091u2009000u2009000, )xa0β the encoded coordinates of the query point and the integer _m_ from the statement above. The query point (_p_,u2009_q_) is obtained as . In other words, divide _x_ and _y_ by 1000 to get the actual query point. denotes the length of the list and it is guaranteed that . Each of the next _n_ lines contains two integers _a__i_ and _b__i_ (_a__i_,u2009_b__i_u2009β€u20091u2009000u2009000)xa0β the parameters for a line of the form: . It is guaranteed that no two lines are the same, that is (_a__i_,u2009_b__i_)u2009β u2009(_a__j_,u2009_b__j_) if _i_u2009β u2009_j_. Output Print a single real number, the sum of _m_ smallest elements of . Your answer will be considered correct if its absolute or relative error does not exceed 10u2009-u20096. To clarify, let's assume that your answer is _a_ and the answer of the jury is _b_. The checker program will consider your answer correct if . Examples Input 4 1000 1000 3 1000 0 -1000 0 0 5000 0 -5000 Input 2 -1000000 -1000000 1 1000000 -1000000 999999 1000000 Output 2000001000.999999500 Input 3 -1000 1000 3 1000 0 -1000 2000 2000 -1000 Input 5 -303667 189976 10 -638 116487 -581 44337 1231 -756844 1427 -44097 8271 -838417 Note In the first sample, the three closest points have distances and . In the second sample, the two lines _y_u2009=u20091000_x_u2009-u20091000 and intersect at (2000000,u20091999999000). This point has a distance of from (u2009-u20091000,u2009u2009-u20091000). In the third sample, the three lines all intersect at the point (1,u20091). This intersection point is present three times in since it is the intersection of three pairs of lines. Since the distance between the intersection point and the query point is 2, the answer is three times that or 6. | 3,300 | false | false | false | false | false | false | false | true | false | false | 7,415 |
1874F | Problem - 1874F - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags dp *3500 No tag edit access β Contest materials ") Editorial") $$$ such that $$$l leq r leq m_l$$$, the subarray $$$ | 3,500 | false | false | false | true | false | false | false | false | false | false | 1,031 |
593A | Andrew often reads articles in his favorite magazine 2Char. The main feature of these articles is that each of them uses at most two distinct letters. Andrew decided to send an article to the magazine, but as he hasn't written any article, he just decided to take a random one from magazine 26Char. However, before sending it to the magazine 2Char, he needs to adapt the text to the format of the journal. To do so, he removes some words from the chosen article, in such a way that the remaining text can be written using no more than two distinct letters. Since the payment depends from the number of non-space characters in the article, Andrew wants to keep the words with the maximum total length. Input The first line of the input contains number _n_ (1u2009β€u2009_n_u2009β€u2009100)xa0β the number of words in the article chosen by Andrew. Following are _n_ lines, each of them contains one word. All the words consist only of small English letters and their total length doesn't exceed 1000. The words are not guaranteed to be distinct, in this case you are allowed to use a word in the article as many times as it appears in the input. Output Print a single integerxa0β the maximum possible total length of words in Andrew's article. Examples Input 5 a a bcbcb cdecdecdecdecdecde aaaa Note In the first sample the optimal way to choose words is {'abb', 'aaa', 'bbb'}. In the second sample the word 'cdecdecdecdecdecde' consists of three distinct letters, and thus cannot be used in the article. The optimal answer is {'a', 'a', 'aaaa'}. | 1,200 | false | false | true | false | false | false | true | false | false | false | 7,477 |
995B | Allen is hosting a formal dinner party. $$$2n$$$ people come to the event in $$$n$$$ pairs (couples). After a night of fun, Allen wants to line everyone up for a final picture. The $$$2n$$$ people line up, but Allen doesn't like the ordering. Allen prefers if each pair occupies adjacent positions in the line, as this makes the picture more aesthetic. Help Allen find the minimum number of swaps of adjacent positions he must perform to make it so that each couple occupies adjacent positions in the line. Input The first line contains a single integer $$$n$$$ ($$$1 le n le 100$$$), the number of pairs of people. The second line contains $$$2n$$$ integers $$$a_1, a_2, dots, a_{2n}$$$. For each $$$i$$$ with $$$1 le i le n$$$, $$$i$$$ appears exactly twice. If $$$a_j = a_k = i$$$, that means that the $$$j$$$-th and $$$k$$$-th people in the line form a couple. Output Output a single integer, representing the minimum number of adjacent swaps needed to line the people up so that each pair occupies adjacent positions. Note In the first sample case, we can transform $$$1 1 2 3 3 2 4 4 ightarrow 1 1 2 3 2 3 4 4 ightarrow 1 1 2 2 3 3 4 4$$$ in two steps. Note that the sequence $$$1 1 2 3 3 2 4 4 ightarrow 1 1 3 2 3 2 4 4 ightarrow 1 1 3 3 2 2 4 4$$$ also works in the same number of steps. The second sample case already satisfies the constraints; therefore we need $$$0$$$ swaps. | 1,400 | true | true | true | false | false | false | false | false | false | false | 5,725 |
1114E | This is an interactive problem! An arithmetic progression or arithmetic sequence is a sequence of integers such that the subtraction of element with its previous element ($$$x_i - x_{i - 1}$$$, where $$$i ge 2$$$) is constantxa0β such difference is called a common difference of the sequence. That is, an arithmetic progression is a sequence of form $$$x_i = x_1 + (i - 1) d$$$, where $$$d$$$ is a common difference of the sequence. There is a secret list of $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$. It is guaranteed that all elements $$$a_1, a_2, ldots, a_n$$$ are between $$$0$$$ and $$$10^9$$$, inclusive. This list is special: if sorted in increasing order, it will form an arithmetic progression with positive common difference ($$$d > 0$$$). For example, the list $$$[14, 24, 9, 19]$$$ satisfies this requirement, after sorting it makes a list $$$[9, 14, 19, 24]$$$, which can be produced as $$$x_n = 9 + 5 cdot (n - 1)$$$. Also you are also given a device, which has a quite discharged battery, thus you can only use it to perform at most $$$60$$$ queries of following two types: Given a value $$$i$$$ ($$$1 le i le n$$$), the device will show the value of the $$$a_i$$$. Given a value $$$x$$$ ($$$0 le x le 10^9$$$), the device will return $$$1$$$ if an element with a value strictly greater than $$$x$$$ exists, and it will return $$$0$$$ otherwise. Your can use this special device for at most $$$60$$$ queries. Could you please find out the smallest element and the common difference of the sequence? That is, values $$$x_1$$$ and $$$d$$$ in the definition of the arithmetic progression. Note that the array $$$a$$$ is not sorted. Interaction The interaction starts with a single integer $$$n$$$ ($$$2 le n le 10^6$$$), the size of the list of integers. Then you can make queries of two types: "? i" ($$$1 le i le n$$$)xa0β to get the value of $$$a_i$$$. "> x" ($$$0 le x le 10^9$$$)xa0β to check whether there exists an element greater than $$$x$$$ After the query read its result $$$r$$$ as an integer. For the first query type, the $$$r$$$ satisfies $$$0 le r le 10^9$$$. For the second query type, the $$$r$$$ is either $$$0$$$ or $$$1$$$. In case you make more than $$$60$$$ queries or violated the number range in the queries, you will get a $$$r = -1$$$. If you terminate after receiving the -1, you will get the "Wrong answer" verdict. Otherwise you can get an arbitrary verdict because your solution will continue to read from a closed stream. When you find out what the smallest element $$$x_1$$$ and common difference $$$d$$$, print "! $$$x_1$$$ $$$d$$$" And quit after that. This query is not counted towards the $$$60$$$ queries limit. After printing any query do not forget to output end of line and flush the output. Otherwise you will get Idleness limit exceeded. To do this, use: fflush(stdout) or cout.flush() in C++; System.out.flush() in Java; flush(output) in Pascal; stdout.flush() in Python; see documentation for other languages. Hacks For hack, use the following format: The first line should contain an integer $$$n$$$ ($$$2 le n le 10^6$$$)xa0β the list's size. The second line contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$0 le a_i le 10^9$$$)xa0β the elements of the list. Also, after the sorting the list must form an arithmetic progression with positive common difference. Note Note that the example interaction contains extra empty lines so that it's easier to read. The real interaction doesn't contain any empty lines and you shouldn't print any extra empty lines as well. The list in the example test is $$$[14, 24, 9, 19]$$$. | 2,200 | false | false | false | false | false | false | false | true | false | false | 5,130 |
1905C | Given is a string $$$s$$$ of length $$$n$$$. In one operation you can select the lexicographically largest$$$^dagger$$$ subsequence of string $$$s$$$ and cyclic shift it to the right$$$^ddagger$$$. Your task is to calculate the minimum number of operations it would take for $$$s$$$ to become sorted, or report that it never reaches a sorted state. $$$^dagger$$$A string $$$a$$$ is lexicographically smaller than a string $$$b$$$ if and only if one of the following holds: $$$a$$$ is a prefix of $$$b$$$, but $$$a e b$$$; In the first position where $$$a$$$ and $$$b$$$ differ, the string $$$a$$$ has a letter that appears earlier in the alphabet than the corresponding letter in $$$b$$$. $$$^ddagger$$$By cyclic shifting the string $$$t_1t_2ldots t_m$$$ to the right, we get the string $$$t_mt_1ldots t_{m-1}$$$. Input Each test consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 le t le 10^4$$$)xa0β the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 le n le 2 cdot 10^5$$$)xa0β the length of the string $$$s$$$. The second line of each test case contains a single string $$$s$$$ of length $$$n$$$, consisting of lowercase English letters. It is guaranteed that sum of $$$n$$$ over all test cases does not exceed $$$2 cdot 10^5$$$. Output For each test case, output a single integer β the minimum number of operations required to make $$$s$$$ sorted, or $$$-1$$$ if it's impossible. Example Input 6 5 aaabc 3 acb 3 bac 4 zbca 15 czddeneeeemigec 13 cdefmopqsvxzz Note In the first test case, the string $$$s$$$ is already sorted, so we need no operations. In the second test case, doing one operation, we will select cb and cyclic shift it. The string $$$s$$$ is now abc which is sorted. In the third test case, $$$s$$$ cannot be sorted. In the fourth test case we will perform the following operations: The lexicographically largest subsequence is zca. Then $$$s$$$ becomes abzc. The lexicographically largest subsequence is zc. Then $$$s$$$ becomes abcz. The string becomes sorted. Thus, we need $$$2$$$ operations. | 1,400 | false | true | false | false | false | false | false | false | false | false | 881 |
222A | Problem - 222A - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags brute force implementation *1200 No tag edit access β Contest materials ") ") . The second line contains _n_ space-separated integers: _a_1,u2009_a_2,u2009...,u2009_a__n_ (1u2009β€u2009_a__i_u2009β€u2009105) β the sequence that the shooshuns found. Output Print the minimum number of operations, required for all numbers on the blackboard to become the same. If it is impossible to achieve, print -1. Examples Input 3 2 3 1 1 Output 1 Input 3 1 3 1 1 Output -1 Note In the first test case after the first operation the blackboard will have sequence | 1,200 | false | false | true | false | false | false | true | false | false | false | 8,952 |
1901E | You are given a tree consisting of $$$n$$$ vertices. A number is written on each vertex; the number on vertex $$$i$$$ is equal to $$$a_i$$$. You can perform the following operation any number of times (possibly zero): choose a vertex which has at most $$$1$$$ incident edge and remove this vertex from the tree. Note that you can delete all vertices. After all operations are done, you're compressing the tree. The compression process is done as follows. While there is a vertex having exactly $$$2$$$ incident edges in the tree, perform the following operation: delete this vertex, connect its neighbors with an edge. It can be shown that if there are multiple ways to choose a vertex to delete during the compression process, the resulting tree is still the same. Your task is to calculate the maximum possible sum of numbers written on vertices after applying the aforementioned operation any number of times, and then compressing the tree. Input The first line contains a single integer $$$t$$$ ($$$1 le t le 10^4$$$)xa0β the number of test cases. The first line of each test case contains a single integer $$$n$$$ ($$$2 le n le 5 cdot 10^5$$$)xa0β the number of vertices. The second line contains $$$n$$$ integers $$$a_1, a_2, dots, a_n$$$ ($$$-10^9 le a_i le 10^9$$$). Each of the next $$$n - 1$$$ lines describes an edge of the tree. Edge $$$i$$$ is denoted by two integers $$$v_i$$$ and $$$u_i$$$, the labels of vertices it connects ($$$1 le v_i, u_i le n$$$, $$$v_i e u_i$$$). These edges form a tree. Additional constraint on the input: the sum of $$$n$$$ over all test cases doesn't exceed $$$5 cdot 10^5$$$. Output For each test case, print a single integerxa0β the maximum possible sum of numbers written on vertices after applying the aforementioned operation any number of times, and then compressing the tree. Example Input 3 4 1 -2 2 1 1 2 3 2 2 4 2 -2 -5 2 1 7 -2 4 -2 3 3 2 -1 1 2 2 3 3 4 3 5 4 6 4 7 | 2,200 | false | true | false | true | false | false | false | false | true | true | 905 |
83E | On an IT lesson Valera studied data compression. The teacher told about a new method, which we shall now describe to you. Let {_a_1,u2009_a_2,u2009...,u2009_a__n_} be the given sequence of lines needed to be compressed. Here and below we shall assume that all lines are of the same length and consist only of the digits 0 and 1. Let's define the compression function: _f_(empty sequence)u2009=u2009empty string _f_(_s_)u2009=u2009_s_. _f_(_s_1,u2009_s_2)u2009=u2009 the smallest in length string, which has one of the prefixes equal to _s_1 and one of the suffixes equal to _s_2. For example, _f_(001,u2009011)u2009=u20090011, _f_(111,u2009011)u2009=u2009111011. _f_(_a_1,u2009_a_2,u2009...,u2009_a__n_)u2009=u2009_f_(_f_(_a_1,u2009_a_2,u2009_a__n_u2009-u20091),u2009_a__n_). For example, _f_(000,u2009000,u2009111)u2009=u2009_f_(_f_(000,u2009000),u2009111)u2009=u2009_f_(000,u2009111)u2009=u2009000111. Valera faces a real challenge: he should divide the given sequence {_a_1,u2009_a_2,u2009...,u2009_a__n_} into two subsequences {_b_1,u2009_b_2,u2009...,u2009_b__k_} and {_c_1,u2009_c_2,u2009...,u2009_c__m_}, _m_u2009+u2009_k_u2009=u2009_n_, so that the value of _S_u2009=u2009_f_(_b_1,u2009_b_2,u2009...,u2009_b__k_)u2009+u2009_f_(_c_1,u2009_c_2,u2009...,u2009_c__m_) took the minimum possible value. Here _p_ denotes the length of the string _p_. Note that it is not allowed to change the relative order of lines in the subsequences. It is allowed to make one of the subsequences empty. Each string from the initial sequence should belong to exactly one subsequence. Elements of subsequences _b_ and _c_ don't have to be consecutive in the original sequence _a_, i. e. elements of _b_ and _c_ can alternate in _a_ (see samples 2 and 3). Help Valera to find the minimum possible value of _S_. Input The first line of input data contains an integer _n_ β the number of strings (1u2009β€u2009_n_u2009β€u20092Β·105). Then on _n_ lines follow elements of the sequence β strings whose lengths are from 1 to 20 characters, consisting only of digits 0 and 1. The _i_u2009+u20091-th input line contains the _i_-th element of the sequence. Elements of the sequence are separated only by a newline. It is guaranteed that all lines have the same length. | 2,800 | false | false | false | true | false | false | false | false | false | false | 9,549 |
1613E | There is a grid, consisting of $$$n$$$ rows and $$$m$$$ columns. Each cell of the grid is either free or blocked. One of the free cells contains a lab. All the cells beyond the borders of the grid are also blocked. A crazy robot has escaped from this lab. It is currently in some free cell of the grid. You can send one of the following commands to the robot: "move right", "move down", "move left" or "move up". Each command means moving to a neighbouring cell in the corresponding direction. However, as the robot is crazy, it will do anything except following the command. Upon receiving a command, it will choose a direction such that it differs from the one in command and the cell in that direction is not blocked. If there is such a direction, then it will move to a neighbouring cell in that direction. Otherwise, it will do nothing. We want to get the robot to the lab to get it fixed. For each free cell, determine if the robot can be forced to reach the lab starting in this cell. That is, after each step of the robot a command can be sent to a robot such that no matter what different directions the robot chooses, it will end up in a lab. Input The first line contains a single integer $$$t$$$ ($$$1 le t le 1000$$$)xa0β the number of testcases. The first line of each testcase contains two integers $$$n$$$ and $$$m$$$ ($$$1 le n, m le 10^6$$$; $$$n cdot m le 10^6$$$)xa0β the number of rows and the number of columns in the grid. The $$$i$$$-th of the next $$$n$$$ lines provides a description of the $$$i$$$-th row of the grid. It consists of $$$m$$$ elements of one of three types: '.'xa0β the cell is free; '#'xa0β the cell is blocked; 'L'xa0β the cell contains a lab. The grid contains exactly one lab. The sum of $$$n cdot m$$$ over all testcases doesn't exceed $$$10^6$$$. Output For each testcase find the free cells that the robot can be forced to reach the lab from. Given the grid, replace the free cells (marked with a dot) with a plus sign ('+') for the cells that the robot can be forced to reach the lab from. Print the resulting grid. Example Input 4 3 3 ... .L. ... 4 5 #.... ..##L ...#. ..... 1 1 L 1 9 ....L..#. Output ... .L. ... #++++ ..##L ...#+ ...++ L ++++L++#. Note In the first testcase there is no free cell that the robot can be forced to reach the lab from. Consider a corner cell. Given any direction, it will move to a neighbouring border grid that's not a corner. Now consider a non-corner free cell. No matter what direction you send to the robot, it can choose a different direction such that it ends up in a corner. In the last testcase, you can keep sending the command that is opposite to the direction to the lab and the robot will have no choice other than move towards the lab. | 2,000 | false | false | false | false | false | false | false | false | false | true | 2,572 |
630F | Problem - 630F - Codeforces =============== xa0 ]( "Experimental Educational Round: VolBIT Formulas Blitz") β the number of potential employees that sent resumes. Output Output one integer β the number of different variants of group composition. Examples Input 7 Output 29 | 1,300 | true | false | false | false | false | false | false | false | false | false | 7,299 |
658A | Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order. There will be _n_ problems. The _i_-th problem has initial score _p__i_ and it takes exactly _t__i_ minutes to solve it. Problems are sorted by difficultyxa0β it's guaranteed that _p__i_u2009<u2009_p__i_u2009+u20091 and _t__i_u2009<u2009_t__i_u2009+u20091. A constant _c_ is given too, representing the speed of loosing points. Then, submitting the _i_-th problem at time _x_ (_x_ minutes after the start of the contest) gives _max_(0,u2009 _p__i_u2009-u2009_c_Β·_x_) points. Limak is going to solve problems in order 1,u20092,u2009...,u2009_n_ (sorted increasingly by _p__i_). Radewoosh is going to solve them in order _n_,u2009_n_u2009-u20091,u2009...,u20091 (sorted decreasingly by _p__i_). Your task is to predict the outcomexa0β print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie. You may assume that the duration of the competition is greater or equal than the sum of all _t__i_. That means both Limak and Radewoosh will accept all _n_ problems. Input The first line contains two integers _n_ and _c_ (1u2009β€u2009_n_u2009β€u200950,u20091u2009β€u2009_c_u2009β€u20091000)xa0β the number of problems and the constant representing the speed of loosing points. The second line contains _n_ integers _p_1,u2009_p_2,u2009...,u2009_p__n_ (1u2009β€u2009_p__i_u2009β€u20091000,u2009_p__i_u2009<u2009_p__i_u2009+u20091)xa0β initial scores. The third line contains _n_ integers _t_1,u2009_t_2,u2009...,u2009_t__n_ (1u2009β€u2009_t__i_u2009β€u20091000,u2009_t__i_u2009<u2009_t__i_u2009+u20091) where _t__i_ denotes the number of minutes one needs to solve the _i_-th problem. Output Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points. Examples Input 3 2 50 85 250 10 15 25 Input 3 6 50 85 250 10 15 25 Input 8 1 10 20 30 40 50 60 70 80 8 10 58 63 71 72 75 76 Note In the first sample, there are 3 problems. Limak solves them as follows: 1. Limak spends 10 minutes on the 1-st problem and he gets 50u2009-u2009_c_Β·10u2009=u200950u2009-u20092Β·10u2009=u200930 points. 2. Limak spends 15 minutes on the 2-nd problem so he submits it 10u2009+u200915u2009=u200925 minutes after the start of the contest. For the 2-nd problem he gets 85u2009-u20092Β·25u2009=u200935 points. 3. He spends 25 minutes on the 3-rd problem so he submits it 10u2009+u200915u2009+u200925u2009=u200950 minutes after the start. For this problem he gets 250u2009-u20092Β·50u2009=u2009150 points. So, Limak got 30u2009+u200935u2009+u2009150u2009=u2009215 points. Radewoosh solves problem in the reversed order: 1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250u2009-u20092Β·25u2009=u2009200 points. 2. He spends 15 minutes on the 2-nd problem so he submits it 25u2009+u200915u2009=u200940 minutes after the start. He gets 85u2009-u20092Β·40u2009=u20095 points for this problem. 3. He spends 10 minutes on the 1-st problem so he submits it 25u2009+u200915u2009+u200910u2009=u200950 minutes after the start. He gets _max_(0,u200950u2009-u20092Β·50)u2009=u2009_max_(0,u2009u2009-u200950)u2009=u20090 points. Radewoosh got 200u2009+u20095u2009+u20090u2009=u2009205 points in total. Limak has 215 points so Limak wins. In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250u2009-u20096Β·25u2009=u2009100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway. In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2u2009+u20092u2009=u20094. | 800 | false | false | true | false | false | false | false | false | false | false | 7,190 |
1829A | Problem - 1829A - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags implementation strings *800 No tag edit access β Contest materials ") Editorial") xa0β the number of test cases. Each test case is one line and contains the string $$$s$$$, consisting of exactly $$$10$$$ lowercase Latin characters. Output For each test case, output a single integerxa0β the number of indices where string $$$s$$$ differs. Example Input 5 coolforsez cadafurcie codeforces paiuforces forcescode Output 4 5 0 4 9 | 800 | false | false | true | false | false | false | false | false | false | false | 1,314 |
1830C | You are given an integer $$$n$$$ and $$$k$$$ intervals. The $$$i$$$-th interval is $$$[l_i,r_i]$$$ where $$$1 leq l_i leq r_i leq n$$$. Let us call a regular bracket sequence$$$^{dagger,ddagger}$$$ of length $$$n$$$ hyperregular if for each $$$i$$$ such that $$$1 leq i leq k$$$, the substring $$$overline{s_{l_i} s_{l_{i}+1} ldots s_{r_i}}$$$ is also a regular bracket sequence. Your task is to count the number of hyperregular bracket sequences. Since this number can be really large, you are only required to find it modulo $$$998,244,353$$$. $$$^dagger$$$ A bracket sequence is a string containing only the characters "(" and ")". $$$^ddagger$$$ A bracket sequence is called regular if one can turn it into a valid math expression by adding characters + and 1. For example, sequences (())(), (), (()(())) and the empty string are regular, while )(, ((), and (()))( are not. Input Each test contains multiple test cases. The first line of input contains a single integer $$$t$$$ ($$$1 le t le 10^5$$$)xa0β the number of test cases. The description of test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ ($$$1 le n le 3 cdot 10^5$$$, $$$0 le k le 3 cdot 10^5$$$) β the length of the hyperregular bracket sequences and the number of intervals respectively. The following $$$k$$$ lines of each test case contains two integers $$$l_i$$$ and $$$r_i$$$ ($$$1 le l le r le n$$$). It is guaranteed that the sum of $$$n$$$ across all test cases does not exceed $$$3 cdot 10^5$$$ and the sum of $$$k$$$ across all test cases does not exceed $$$3 cdot 10^5$$$. Output For each test case, output the number of hyperregular bracket sequences modulo $$$998,244,353$$$. Example Input 7 6 0 5 0 8 1 1 3 10 2 3 4 6 9 1000 3 100 701 200 801 300 901 28 5 1 12 3 20 11 14 4 9 18 19 4 3 1 4 1 4 1 4 Output 5 0 0 4 839415253 140 2 Note For the first testcase, the $$$5$$$ hyperregular bracket strings of length $$$6$$$ are: ((())), (()()), (())(), ()(()) and ()()(). For the second testcase, there are no regular bracket strings of length $$$5$$$, and consequently, there are no hyperregular bracket strings of length $$$5$$$. For the third testcase, there are no hyperregular bracket strings of length $$$8$$$ for which the substring $$$[1 ldots 3]$$$ is a regular bracket string. For the fourth testcase, there $$$4$$$ hyperregular bracket strings are: ((())(())), ((())()()), ()()((())) and ()()(()()) | 2,400 | true | true | false | false | false | false | false | false | true | false | 1,304 |
688B | Problem - 688B - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags constructive algorithms math *1000 No tag edit access β Contest materials , so she tries to see a lot of big palindrome numbers with even length (like a 2-digit 11 or 6-digit 122221), so maybe she could see something in them. Now Pari asks you to write a program that gets a huge integer _n_ from the input and tells what is the _n_-th even-length positive palindrome number? Input The only line of the input contains a single integer _n_ (1u2009β€u2009_n_u2009β€u200910100u2009000). Output Print the _n_-th even-length palindrome number. Examples Input 1 Output 11 Input 10 Output 1001 Note The first 10 even-length palindrome numbers are 11,u200922,u200933,u2009... ,u200988,u200999 and 1001. | 1,000 | true | false | false | false | false | true | false | false | false | false | 7,070 |
575F | Bananistan is a beautiful banana republic. Beautiful women in beautiful dresses. Beautiful statues of beautiful warlords. Beautiful stars in beautiful nights. In Bananistan people play this crazy game β Bulbo. Thereβs an array of bulbs and player at the position, which represents one of the bulbs. The distance between two neighboring bulbs is 1. Before each turn player can change his position with cost _pos__new_u2009-u2009_pos__old_. After that, a contiguous set of bulbs lights-up and player pays the cost thatβs equal to the distance to the closest shining bulb. Then, all bulbs go dark again. The goal is to minimize your summed cost. I tell you, Bananistanians are spending their nights playing with bulbs. Banana day is approaching, and you are hired to play the most beautiful Bulbo game ever. A huge array of bulbs is installed, and you know your initial position and all the light-ups in advance. You need to play the ideal game and impress Bananistanians, and their families. Input The first line contains number of turns _n_ and initial position _x_. Next _n_ lines contain two numbers _l__start_ and _l__end_, which represent that all bulbs from interval [_l__start_,u2009_l__end_] are shining this turn. 1u2009β€u2009_n_u2009β€u20095000 1u2009β€u2009_x_u2009β€u2009109 1u2009β€u2009_l__start_u2009β€u2009_l__end_u2009β€u2009109 Output Output should contain a single number which represents the best result (minimum cost) that could be obtained by playing this Bulbo game. Examples Input 5 4 2 7 9 16 8 10 9 17 1 6 Note Before 1. turn move to position 5 Before 2. turn move to position 9 Before 5. turn move to position 8 | 2,100 | false | true | false | true | false | false | false | false | false | false | 7,547 |
1208D | An array of integers $$$p_{1},p_{2}, ldots,p_{n}$$$ is called a permutation if it contains each number from $$$1$$$ to $$$n$$$ exactly once. For example, the following arrays are permutations: $$$[3,1,2], [1], [1,2,3,4,5]$$$ and $$$[4,3,1,2]$$$. The following arrays are not permutations: $$$[2], [1,1], [2,3,4]$$$. There is a hidden permutation of length $$$n$$$. For each index $$$i$$$, you are given $$$s_{i}$$$, which equals to the sum of all $$$p_{j}$$$ such that $$$j < i$$$ and $$$p_{j} < p_{i}$$$. In other words, $$$s_i$$$ is the sum of elements before the $$$i$$$-th element that are smaller than the $$$i$$$-th element. Your task is to restore the permutation. Input The first line contains a single integer $$$n$$$ ($$$1 le n le 2 cdot 10^{5}$$$)xa0β the size of the permutation. The second line contains $$$n$$$ integers $$$s_{1}, s_{2}, ldots, s_{n}$$$ ($$$0 le s_{i} le frac{n(n-1)}{2}$$$). It is guaranteed that the array $$$s$$$ corresponds to a valid permutation of length $$$n$$$. Output Print $$$n$$$ integers $$$p_{1}, p_{2}, ldots, p_{n}$$$ β the elements of the restored permutation. We can show that the answer is always unique. Note In the first example for each $$$i$$$ there is no index $$$j$$$ satisfying both conditions, hence $$$s_i$$$ are always $$$0$$$. In the second example for $$$i = 2$$$ it happens that $$$j = 1$$$ satisfies the conditions, so $$$s_2 = p_1$$$. In the third example for $$$i = 2, 3, 4$$$ only $$$j = 1$$$ satisfies the conditions, so $$$s_2 = s_3 = s_4 = 1$$$. For $$$i = 5$$$ all $$$j = 1, 2, 3, 4$$$ are possible, so $$$s_5 = p_1 + p_2 + p_3 + p_4 = 10$$$. | 1,900 | false | true | true | false | true | false | false | true | false | false | 4,651 |
1338A | You have an array $$$a$$$ of length $$$n$$$. For every positive integer $$$x$$$ you are going to perform the following operation during the $$$x$$$-th second: Select some distinct indices $$$i_{1}, i_{2}, ldots, i_{k}$$$ which are between $$$1$$$ and $$$n$$$ inclusive, and add $$$2^{x-1}$$$ to each corresponding position of $$$a$$$. Formally, $$$a_{i_{j}} := a_{i_{j}} + 2^{x-1}$$$ for $$$j = 1, 2, ldots, k$$$. Note that you are allowed to not select any indices at all. You have to make $$$a$$$ nondecreasing as fast as possible. Find the smallest number $$$T$$$ such that you can make the array nondecreasing after at most $$$T$$$ seconds. Array $$$a$$$ is nondecreasing if and only if $$$a_{1} le a_{2} le ldots le a_{n}$$$. You have to answer $$$t$$$ independent test cases. Input The first line contains a single integer $$$t$$$ ($$$1 le t le 10^{4}$$$)xa0β the number of test cases. The first line of each test case contains single integer $$$n$$$ ($$$1 le n le 10^{5}$$$)xa0β the length of array $$$a$$$. It is guaranteed that the sum of values of $$$n$$$ over all test cases in the input does not exceed $$$10^{5}$$$. The second line of each test case contains $$$n$$$ integers $$$a_{1}, a_{2}, ldots, a_{n}$$$ ($$$-10^{9} le a_{i} le 10^{9}$$$). Output For each test case, print the minimum number of seconds in which you can make $$$a$$$ nondecreasing. Example Input 3 4 1 7 6 5 5 1 2 3 4 5 2 0 -4 Note In the first test case, if you select indices $$$3, 4$$$ at the $$$1$$$-st second and $$$4$$$ at the $$$2$$$-nd second, then $$$a$$$ will become $$$[1, 7, 7, 8]$$$. There are some other possible ways to make $$$a$$$ nondecreasing in $$$2$$$ seconds, but you can't do it faster. In the second test case, $$$a$$$ is already nondecreasing, so answer is $$$0$$$. In the third test case, if you do nothing at first $$$2$$$ seconds and select index $$$2$$$ at the $$$3$$$-rd second, $$$a$$$ will become $$$[0, 0]$$$. | 1,500 | true | true | false | false | false | false | false | false | false | false | 4,014 |
763D | Little Timofey has a big treexa0β an undirected connected graph with _n_ vertices and no simple cycles. He likes to walk along it. His tree is flat so when he walks along it he sees it entirely. Quite naturally, when he stands on a vertex, he sees the tree as a rooted tree with the root in this vertex. Timofey assumes that the more non-isomorphic subtrees are there in the tree, the more beautiful the tree is. A subtree of a vertex is a subgraph containing this vertex and all its descendants. You should tell Timofey the vertex in which he should stand to see the most beautiful rooted tree. Subtrees of vertices _u_ and _v_ are isomorphic if the number of children of _u_ equals the number of children of _v_, and their children can be arranged in such a way that the subtree of the first son of _u_ is isomorphic to the subtree of the first son of _v_, the subtree of the second son of _u_ is isomorphic to the subtree of the second son of _v_, and so on. In particular, subtrees consisting of single vertex are isomorphic to each other. Input First line contains single integer _n_ (1u2009β€u2009_n_u2009β€u2009105)xa0β number of vertices in the tree. Each of the next _n_u2009-u20091 lines contains two integers _u__i_ and _v__i_ (1u2009β€u2009_u__i_,u2009_v__i_u2009β€u2009105, _u__i_u2009β u2009_v__i_), denoting the vertices the _i_-th edge connects. It is guaranteed that the given graph is a tree. Output Print single integerxa0β the index of the vertex in which Timofey should stand. If there are many answers, you can print any of them. Examples Input 10 1 7 1 8 9 4 5 1 9 2 3 5 10 6 10 9 5 10 Note In the first example we can stand in the vertex 1 or in the vertex 3 so that every subtree is non-isomorphic. If we stand in the vertex 2, then subtrees of vertices 1 and 3 are isomorphic. In the second example, if we stand in the vertex 1, then only subtrees of vertices 4 and 5 are isomorphic. In the third example, if we stand in the vertex 1, then subtrees of vertices 2, 3, 4, 6, 7 and 8 are isomorphic. If we stand in the vertex 2, than only subtrees of vertices 3, 4, 6, 7 and 8 are isomorphic. If we stand in the vertex 5, then subtrees of vertices 2, 3, 4, 6, 7 and 8 are isomorphic, and subtrees of vertices 1 and 9 are isomorphic as well: 1 9 / / 7 8 4 2 | 2,900 | false | false | false | false | true | false | false | false | false | true | 6,734 |
1452B | You are asked to watch your nephew who likes to play with toy blocks in a strange way. He has $$$n$$$ boxes and the $$$i$$$-th box has $$$a_i$$$ blocks. His game consists of two steps: 1. he chooses an arbitrary box $$$i$$$; 2. he tries to move all blocks from the $$$i$$$-th box to other boxes. If he can make the same number of blocks in each of $$$n - 1$$$ other boxes then he will be happy, otherwise, will be sad. Note that your nephew can only move the blocks from the chosen box to the other boxes; he cannot move blocks from the other boxes. You don't want to make your nephew sad, so you decided to put several extra blocks into some boxes in such a way that no matter which box $$$i$$$ he chooses he won't be sad. What is the minimum number of extra blocks you need to put? Input The first line contains a single integer $$$t$$$ ($$$1 le t le 1000$$$)xa0β the number of test cases. The first line of each test case contains the integer $$$n$$$ ($$$2 le n le 10^5$$$)xa0β the number of boxes. The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, dots, a_n$$$ ($$$0 le a_i le 10^9$$$)xa0β the number of blocks in each box. It's guaranteed that the sum of $$$n$$$ over test cases doesn't exceed $$$10^5$$$. Output For each test case, print a single integerxa0β the minimum number of blocks you need to put. It can be proved that the answer always exists, i.xa0e. the number of blocks is finite. Example Input 3 3 3 2 2 4 2 2 3 2 3 0 3 0 Note In the first test case, you can, for example, put one extra block into the first box and make $$$a = [4, 2, 2]$$$. If your nephew chooses the box with $$$4$$$ blocks, then we will move two blocks to the second box and two blocks to the third box. If he chooses the box with $$$2$$$ blocks then he will move these two blocks to the other box with $$$2$$$ blocks. In the second test case, you don't need to put any extra blocks, since no matter which box your nephew chooses, he can always make other boxes equal. In the third test case, you should put $$$3$$$ extra blocks. For example, you can put $$$2$$$ blocks in the first box and $$$1$$$ block in the third box. You'll get array $$$a = [2, 3, 1]$$$. | 1,400 | true | true | false | false | false | false | false | true | true | false | 3,420 |
791A | Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob. Right now, Limak and Bob weigh _a_ and _b_ respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight. Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year. After how many full years will Limak become strictly larger (strictly heavier) than Bob? Input The only line of the input contains two integers _a_ and _b_ (1u2009β€u2009_a_u2009β€u2009_b_u2009β€u200910)xa0β the weight of Limak and the weight of Bob respectively. Output Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob. Note In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4Β·3u2009=u200912 and 7Β·2u2009=u200914 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2. In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights. In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then. | 800 | false | false | true | false | false | false | false | false | false | false | 6,614 |
1994D | Vanya has a graph with $$$n$$$ vertices (numbered from $$$1$$$ to $$$n$$$) and an array $$$a$$$ of $$$n$$$ integers; initially, there are no edges in the graph. Vanya got bored, and to have fun, he decided to perform $$$n - 1$$$ operations. Operation number $$$x$$$ (operations are numbered in order starting from $$$1$$$) is as follows: Choose $$$2$$$ different numbers $$$1 leq u,v leq n$$$, such that $$$a_u - a_v$$$ is divisible by $$$x$$$. Add an undirected edge between vertices $$$u$$$ and $$$v$$$ to the graph. Help Vanya get a connected$$$^{ ext{β}}$$$ graph using the $$$n - 1$$$ operations, or determine that it is impossible. $$$^{ ext{β}}$$$A graph is called connected if it is possible to reach any vertex from any other by moving along the edges. Input Each test consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 le t le 10^{3}$$$)xa0β the number of test cases. Then follows the description of the test cases. The first line of each test case contains the number $$$n$$$ ($$$1 leq n leq 2000$$$)xa0β the number of vertices in the graph. The second line of each test case contains $$$n$$$ numbers $$$a_1, a_2, cdots a_n$$$ ($$$1 leq a_i leq 10^9$$$). It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$2000$$$. Output For each test case, if there is no solution, then output "No" (without quotes). Otherwise, output "Yes" (without quotes), and then output $$$n - 1$$$ lines, where in the $$$i$$$-th line, output the numbers $$$u$$$ and $$$v$$$ that need to be chosen for operation $$$i$$$. You can output each letter in any case (for example, the strings "yEs", "yes", "Yes", and "YES" will be recognized as a positive answer). Example Input 8 2 1 4 4 99 7 1 13 5 10 2 31 44 73 5 87 6 81 44 32 5 62 35 33 79 16 5 6 51 31 69 42 5 52 63 25 21 5 12 33 40 3 11 31 43 37 8 50 5 12 22 Output YES 2 1 YES 4 1 2 1 3 2 YES 5 1 4 1 3 1 2 1 YES 4 1 3 1 2 1 5 4 YES 3 1 5 1 2 1 4 2 YES 4 1 5 1 2 1 3 2 YES 2 1 5 2 3 1 4 3 YES 9 1 12 9 11 1 10 1 6 1 7 6 2 1 8 2 5 2 3 1 4 1 Note Let's consider the second test case. First operation $$$(x = 1)$$$: we can connect vertices $$$4$$$ and $$$1$$$, since $$$a_4 - a_1 = 13 - 99 = -86 = 86$$$, and $$$86$$$ is divisible by $$$1$$$. Second operation $$$(x = 2)$$$: we can connect vertices $$$2$$$ and $$$1$$$, since $$$a_2 - a_1 = 7 - 99 = -92 = 92$$$, and $$$92$$$ is divisible by $$$2$$$. Third operation $$$(x = 3)$$$: we can connect vertices $$$3$$$ and $$$2$$$, since $$$a_3 - a_2 = 1 - 7 = -6 = 6$$$, and $$$6$$$ is divisible by $$$3$$$. From the picture, it can be seen that a connected graph is obtained. | 1,900 | true | true | false | false | false | true | false | false | false | true | 302 |
898A | Problem - 898A - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags implementation math *800 No tag edit access β Contest materials ") Editorial") xa0β number that Vasya has. Output Print result of rounding _n_. Pay attention that in some cases answer isn't unique. In that case print any correct answer. Examples Input 5 Output 0 Input 113 Output 110 Input 1000000000 Output 1000000000 Input 5432359 Output 5432360 Note In the first example _n_u2009=u20095. Nearest integers, that ends up with zero are 0 and 10. Any of these answers is correct, so you can print 0 or 10. | 800 | true | false | true | false | false | false | false | false | false | false | 6,158 |
1500D | Kostya is extremely busy: he is renovating his house! He needs to hand wallpaper, assemble furniture throw away trash. Kostya is buying tiles for bathroom today. He is standing in front of a large square stand with tiles in a shop. The stand is a square of $$$n imes n$$$ cells, each cell of which contains a small tile with color $$$c_{i,,j}$$$. The shop sells tiles in packs: more specifically, you can only buy a subsquare of the initial square. A subsquare is any square part of the stand, i.xa0e. any set $$$S(i_0, j_0, k) = {c_{i,,j} i_0 le i < i_0 + k, j_0 le j < j_0 + k}$$$ with $$$1 le i_0, j_0 le n - k + 1$$$. Kostya still does not know how many tiles he needs, so he considers the subsquares of all possible sizes. He doesn't want his bathroom to be too colorful. Help Kostya to count for each $$$k le n$$$ the number of subsquares of size $$$k imes k$$$ that have at most $$$q$$$ different colors of tiles. Two subsquares are considered different if their location on the stand is different. Input The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 le n le 1500$$$, $$$1 le q le 10$$$)xa0β the size of the stand and the limit on the number of distinct colors in a subsquare. Each of the next $$$n$$$ lines contains $$$n$$$ integers $$$c_{i,,j}$$$ ($$$1 le c_{i,,j} le n^2$$$): the $$$j$$$-th integer in the $$$i$$$-th line is the color of the tile in the cell $$$(i,,j)$$$. Output For each $$$k$$$ from $$$1$$$ to $$$n$$$ print a single integerxa0β the number of subsquares of size $$$k imes k$$$ with no more than $$$q$$$ different colors. Examples Input 3 4 1 2 3 4 5 6 7 8 9 Input 4 8 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 Note In the first example all colors are distinct. Kostya doesn't want the subsquare have more than $$$4$$$ colors, so he can buy any subsquare of size $$$1 imes 1$$$ or $$$2 imes 2$$$, but he can't buy a subsquare of size $$$3 imes 3$$$. In the second example there are colors that appear multiple times. Because $$$q = 8$$$, Kostya can buy any subsquare of size $$$1 imes 1$$$ and $$$2 imes 2$$$, and any subsquare $$$3 imes 3$$$, because of such subsquare has $$$7$$$ different colors. He can't buy the whole stand $$$4 imes 4$$$, because there are $$$9$$$ colors. | 2,900 | false | false | false | false | true | false | false | false | true | false | 3,165 |
1464F | You are given a tree. We will consider simple paths on it. Let's denote path between vertices $$$a$$$ and $$$b$$$ as $$$(a, b)$$$. Let $$$d$$$-neighborhood of a path be a set of vertices of the tree located at a distance $$$leq d$$$ from at least one vertex of the path (for example, $$$0$$$-neighborhood of a path is a path itself). Let $$$P$$$ be a multiset of the tree paths. Initially, it is empty. You are asked to maintain the following queries: $$$1$$$ $$$u$$$ $$$v$$$xa0β add path $$$(u, v)$$$ into $$$P$$$ ($$$1 leq u, v leq n$$$). $$$2$$$ $$$u$$$ $$$v$$$xa0β delete path $$$(u, v)$$$ from $$$P$$$ ($$$1 leq u, v leq n$$$). Notice that $$$(u, v)$$$ equals to $$$(v, u)$$$. For example, if $$$P = {(1, 2), (1, 2)}$$$, than after query $$$2$$$ $$$2$$$ $$$1$$$, $$$P = {(1, 2)}$$$. $$$3$$$ $$$d$$$xa0β if intersection of all $$$d$$$-neighborhoods of paths from $$$P$$$ is not empty output "Yes", otherwise output "No" ($$$0 leq d leq n - 1$$$). Input The first line contains two integers $$$n$$$ and $$$q$$$xa0β the number of vertices in the tree and the number of queries, accordingly ($$$1 leq n leq 2 cdot 10^5$$$, $$$2 leq q leq 2 cdot 10^5$$$). Each of the following $$$n - 1$$$ lines contains two integers $$$x_i$$$ and $$$y_i$$$xa0β indices of vertices connected by $$$i$$$-th edge ($$$1 le x_i, y_i le n$$$). The following $$$q$$$ lines contain queries in the format described in the statement. It's guaranteed that: for a query $$$2$$$ $$$u$$$ $$$v$$$, path $$$(u, v)$$$ (or $$$(v, u)$$$) is present in $$$P$$$, for a query $$$3$$$ $$$d$$$, $$$P eq varnothing$$$, there is at least one query of the third type. Output For each query of the third type output answer on a new line. Examples Input 1 4 1 1 1 1 1 1 2 1 1 3 0 Input 5 3 1 2 1 3 3 4 4 5 1 1 2 1 5 5 3 1 Input 10 6 1 2 2 3 3 4 4 7 7 10 2 5 5 6 6 8 8 9 1 9 9 1 9 8 1 8 5 3 0 3 1 3 2 | 3,500 | false | false | false | false | true | false | false | false | false | false | 3,367 |
1083D | The Fair Nut has found an array $$$a$$$ of $$$n$$$ integers. We call subarray $$$l ldots r$$$ a sequence of consecutive elements of an array with indexes from $$$l$$$ to $$$r$$$, i.e. $$$a_l, a_{l+1}, a_{l+2}, ldots, a_{r-1}, a_{r}$$$. No one knows the reason, but he calls a pair of subsegments good if and only if the following conditions are satisfied: 1. These subsegments should not be nested. That is, each of the subsegments should contain an element (as an index) that does not belong to another subsegment. 2. Subsegments intersect and each element that belongs to the intersection belongs each of segments only once. For example $$$a=[1, 2, 3, 5, 5]$$$. Pairs $$$(1 ldots 3; 2 ldots 5)$$$ and $$$(1 ldots 2; 2 ldots 3)$$$)xa0β are good, but $$$(1 dots 3; 2 ldots 3)$$$ and $$$(3 ldots 4; 4 ldots 5)$$$xa0β are not (subsegment $$$1 ldots 3$$$ contains subsegment $$$2 ldots 3$$$, integer $$$5$$$ belongs both segments, but occurs twice in subsegment $$$4 ldots 5$$$). Help the Fair Nut to find out the number of pairs of good subsegments! The answer can be rather big so print it modulo $$$10^9+7$$$. Input The first line contains a single integer $$$n$$$ ($$$1 le n le 10^5$$$)xa0β the length of array $$$a$$$. The second line contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$-10^9 le a_i le 10^9$$$)xa0β the array elements. Note In the first example, there is only one pair of good subsegments: $$$(1 ldots 2, 2 ldots 3)$$$. In the second example, there are four pairs of good subsegments: $$$(1 ldots 2, 2 ldots 3)$$$ $$$(2 ldots 3, 3 ldots 4)$$$ $$$(2 ldots 3, 3 ldots 5)$$$ $$$(3 ldots 4, 4 ldots 5)$$$ | 3,500 | false | false | true | false | true | false | false | false | false | false | 5,305 |
958B1 | The Resistance is trying to take control over all planets in a particular solar system. This solar system is shaped like a tree. More precisely, some planets are connected by bidirectional hyperspace tunnels in such a way that there is a path between every pair of the planets, but removing any tunnel would disconnect some of them. The Resistance already has measures in place that will, when the time is right, enable them to control every planet that is not remote. A planet is considered to be remote if it is connected to the rest of the planets only via a single hyperspace tunnel. How much work is there left to be done: that is, how many remote planets are there? Input The first line of the input contains an integer _N_ (2u2009β€u2009_N_u2009β€u20091000) β the number of planets in the galaxy. The next _N_u2009-u20091 lines describe the hyperspace tunnels between the planets. Each of the _N_u2009-u20091 lines contains two space-separated integers _u_ and _v_ (1u2009β€u2009_u_,u2009_v_u2009β€u2009_N_) indicating that there is a bidirectional hyperspace tunnel between the planets _u_ and _v_. It is guaranteed that every two planets are connected by a path of tunnels, and that each tunnel connects a different pair of planets. Output A single integer denoting the number of remote planets. Note In the first example, only planets 2, 3 and 5 are connected by a single tunnel. In the second example, the remote planets are 2 and 3. Note that this problem has only two versions β easy and medium. | 1,000 | false | false | true | false | false | false | false | false | false | false | 5,890 |
599D | Problem - 599D - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags brute force math *1900 No tag edit access β Contest materials ") xa0β the number of squares inside the tables Spongebob is interested in. Output First print a single integer _k_xa0β the number of tables with exactly _x_ distinct squares inside. Then print _k_ pairs of integers describing the tables. Print the pairs in the order of increasing _n_, and in case of equalityxa0β in the order of increasing _m_. Examples Input 26 Output 6 1 26 2 9 3 5 5 3 9 2 26 1 Input 2 Output 2 1 2 2 1 Input 8 Output 4 1 8 2 3 3 2 8 1 Note In a 1u2009Γu20092 table there are 2 1u2009Γu20091 squares. So, 2 distinct squares in total. In a 2u2009Γu20093 table there are 6 1u2009Γu20091 squares and 2 2u2009Γu20092 squares. That is equal to 8 squares in total. | 1,900 | true | false | false | false | false | false | true | false | false | false | 7,448 |
1759D | Inflation has occurred in Berlandia, so the store needs to change the price of goods. The current price of good $$$n$$$ is given. It is allowed to increase the price of the good by $$$k$$$ times, with $$$1 le k le m$$$, k is an integer. Output the roundest possible new price of the good. That is, the one that has the maximum number of zeros at the end. For example, the number 481000 is more round than the number 1000010 (three zeros at the end of 481000 and only one at the end of 1000010). If there are several possible variants, output the one in which the new price is maximal. If it is impossible to get a rounder price, output $$$n cdot m$$$ (that is, the maximum possible price). Input The first line contains a single integer $$$t$$$ ($$$1 le t le 10^4$$$)xa0βthe number of test cases in the test. Each test case consists of one line. This line contains two integers: $$$n$$$ and $$$m$$$ ($$$1 le n, m le 10^9$$$). Where $$$n$$$ is the old price of the good, and the number $$$m$$$ means that you can increase the price $$$n$$$ no more than $$$m$$$ times. Output For each test case, output on a separate line the roundest integer of the form $$$n cdot k$$$ ($$$1 le k le m$$$, $$$k$$$xa0β an integer). If there are several possible variants, output the one in which the new price (value $$$n cdot k$$$) is maximal. If it is impossible to get a more rounded price, output $$$n cdot m$$$ (that is, the maximum possible price). Example Input 10 6 11 5 43 13 5 4 16 10050 12345 2 6 4 30 25 10 2 81 1 7 Output 60 200 65 60 120600000 10 100 200 100 7 Note In the first case $$$n = 6$$$, $$$m = 11$$$. We cannot get a number with two zeros or more at the end, because we need to increase the price $$$50$$$ times, but $$$50 > m = 11$$$. The maximum price multiple of $$$10$$$ would be $$$6 cdot 10 = 60$$$. In the second case $$$n = 5$$$, $$$m = 43$$$. The maximum price multiple of $$$100$$$ would be $$$5 cdot 40 = 200$$$. In the third case, $$$n = 13$$$, $$$m = 5$$$. All possible new prices will not end in $$$0$$$, then you should output $$$n cdot m = 65$$$. In the fourth case, you should increase the price $$$15$$$ times. In the fifth case, increase the price $$$12000$$$ times. | 1,400 | false | false | false | false | false | false | true | false | false | false | 1,759 |
1700B | During a daily walk Alina noticed a long number written on the ground. Now Alina wants to find some positive number of same length without leading zeroes, such that the sum of these two numbers is a palindrome. Recall that a number is called a palindrome, if it reads the same right to left and left to right. For example, numbers $$$121, 66, 98989$$$ are palindromes, and $$$103, 239, 1241$$$ are not palindromes. Alina understands that a valid number always exist. Help her find one! Input The first line of input data contains an integer $$$t$$$ ($$$1 leq t leq 100$$$) β the number of test cases. Next, descriptions of $$$t$$$ test cases follow. The first line of each test case contains a single integer $$$n$$$ ($$$2 leq n leq 100,000$$$) β the length of the number that is written on the ground. The second line of contains the positive $$$n$$$-digit integer without leading zeroes β the number itself. It is guaranteed that the sum of the values $$$n$$$ over all test cases does not exceed $$$100,000$$$. Output For each of $$$t$$$ test cases print an answer β a positive $$$n$$$-digit integer without leading zeros, such that the sum of the input integer and this number is a palindrome. We can show that at least one number satisfying the constraints exists. If there are multiple solutions, you can output any of them. Note In the first test case $$$99 + 32 = 131$$$ is a palindrome. Note that another answer is $$$12$$$, because $$$99 + 12 = 111$$$ is also a palindrome. In the second test case $$$1023 + 8646 = 9669$$$. In the third test case $$$385 + 604 = 989$$$. | 1,100 | true | false | true | false | false | true | false | false | false | false | 2,081 |
1617D1 | This is an interactive problem. The only difference between the easy and hard version is the limit on number of questions. There are $$$n$$$ players labelled from $$$1$$$ to $$$n$$$. It is guaranteed that $$$n$$$ is a multiple of $$$3$$$. Among them, there are $$$k$$$ impostors and $$$n-k$$$ crewmates. The number of impostors, $$$k$$$, is not given to you. It is guaranteed that $$$frac{n}{3} < k < frac{2n}{3}$$$. In each question, you can choose three distinct integers $$$a$$$, $$$b$$$, $$$c$$$ ($$$1 le a, b, c le n$$$) and ask: "Among the players labelled $$$a$$$, $$$b$$$ and $$$c$$$, are there more impostors or more crewmates?" You will be given the integer $$$0$$$ if there are more impostors than crewmates, and $$$1$$$ otherwise. Find the number of impostors $$$k$$$ and the indices of players that are impostors after asking at most $$$2n$$$ questions. The jury is adaptive, which means the indices of impostors may not be fixed beforehand and can depend on your questions. It is guaranteed that there is at least one set of impostors which fulfills the constraints and the answers to your questions at any time. Input Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 le t le 100$$$). Description of the test cases follows. The first and only line of each test case contains a single integer $$$n$$$ ($$$6 le n < 10^4$$$, $$$n$$$ is a multiple of $$$3$$$) β the number of players. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$2 cdot 10^4$$$. Interaction For each test case, the interaction starts with reading $$$n$$$. Then you are allowed to make at most $$$2n$$$ questions in the following way: "? a b c" ($$$1 le a, b, c le n$$$, $$$a$$$, $$$b$$$ and $$$c$$$ are pairwise distinct). After each one, you should read an integer $$$r$$$, which is equal to $$$0$$$ if there are more impostors than crewmates among players labelled $$$a$$$, $$$b$$$ and $$$c$$$, and equal to $$$1$$$ otherwise. Answer $$$-1$$$ instead of $$$0$$$ or $$$1$$$ means that you made an invalid query or exceeded the number of queries. Exit immediately after receiving $$$-1$$$ and you will see Wrong answer verdict. Otherwise you can get an arbitrary verdict because your solution will continue to read from a closed stream. When you have found the indices of all impostors, print a single line "! " (without quotes), followed by the number of impostors $$$k$$$, followed by $$$k$$$ integers representing the indices of the impostors. Please note that you must print all this information on the same line. After printing the answer, your program must then continue to solve the remaining test cases, or exit if all test cases have been solved. After printing the queries and answers do not forget to output end of line and flush the output buffer. Otherwise, you will get the Idleness limit exceeded verdict. To do flush use: fflush(stdout) or cout.flush() in C++; System.out.flush() in Java; flush(output) in Pascal; stdout.flush() in Python; Read documentation for other languages. Hacks You cannot make hacks in this problem. Example Output ? 1 2 3 ? 3 4 5 ! 3 4 1 2 ? 7 1 9 ! 4 2 3 6 8 Note Explanation for example interaction (note that this example only exists to demonstrate the interaction procedure and does not provide any hint for the solution): For the first test case: Question "? 1 2 3" returns $$$0$$$, so there are more impostors than crewmates among players $$$1$$$, $$$2$$$ and $$$3$$$. Question "? 3 4 5" returns $$$1$$$, so there are more crewmates than impostors among players $$$3$$$, $$$4$$$ and $$$5$$$. Outputting "! 3 4 1 2" means that one has found all the impostors, by some miracle. There are $$$k = 3$$$ impostors. The players who are impostors are players $$$4$$$, $$$1$$$ and $$$2$$$. For the second test case: Question "? 7 1 9" returns $$$1$$$, so there are more crewmates than impostors among players $$$7$$$, $$$1$$$ and $$$9$$$. Outputting "! 4 2 3 6 8" means that one has found all the impostors, by some miracle. There are $$$k = 4$$$ impostors. The players who are impostors are players $$$2$$$, $$$3$$$, $$$6$$$ and $$$8$$$. | 1,800 | false | false | true | false | false | true | false | false | false | false | 2,545 |
1970F2 | This afternoon, you decided to enjoy the first days of Spring by taking a walk outside. As you come near the Quidditch field, you hear screams. Once again, there is a conflict about the score: the two teams are convinced that they won the game! To prevent this problem from happening one more time, you decide to get involved in the refereeing of the matches. Now, you will stay in the stadium to watch the game and count the score. At the end of the game, you will decide the winner. Today, two teams are competing: the red Gryffindor (R) and the blue Ravenclaw (B) team. Each team is composed of $$$P$$$ players ($$$1 leq P leq 10$$$). The field is a rectangle of $$$N$$$ lines and $$$M$$$ columns ($$$3 leq N, M leq 99$$$, $$$N$$$ and $$$M$$$ are odd). All the positions are integers, and several entities are allowed to be at the same position in the field. At the beginning of the game, the field contains goals for the two teams (each team can own between one and five goals), the players, and exactly one Quaffle. In this version of the problem, one Bludger can be present. An other type of ball will be available in the harder version of the problem. A game is composed of $$$T$$$ steps ($$$0 leq T leq 10000$$$). At each step, one entity on the field (a player or a ball) performs one action. All entities can move. A player can also catch a ball or throw the Quaffle that it is carrying. To catch a ball, a player must be located on the same cell as it. The Quaffle does not perform any action while it is being carried; it only follows the movements of the player. If a player carrying the Quaffle decides to throw it, the Quaffle is simply put at the current position of the player. If a player is on the same cell as a Bludger (either after a movement from the player or the Bludger), the player is eliminated. If the player is eliminated while it is carrying the Quaffle, the Quaffle remains on the cell containing both the player and the Bludger after the move. It is guaranteed that this never occurs while the player is in a cell containing a goal. To win a point, a player must leave the Quaffle at a goal of the other team. When it does, the team of the player wins one point, and the Quaffle instantly moves to the middle of the field (the cell at the $$$(M+1)/2$$$-th column of the $$$(N+1)/2$$$-th line of the field, starting from 1). There is no goal in the middle of the field. If a player puts the ball in its own goal, the other team wins the point. Input On the first line, the integers $$$N$$$ and $$$M$$$. The description of the field follows: $$$N$$$ lines of $$$M$$$ pairs of characters separated by spaces. Each pair of characters represents a position on the field. It can be either: .. to represent an empty cell R0, ..., R9, B0, ..., B9 to represent a player. The first character is the team of the player, and the second is the number of the player in the team. Each pair of characters is unique, but it is not guaranteed that all the pairs appear in the grid. RG or BG to represent a goal. The blue team tries to put the ball in a red goal (RG) while the red team tries to put the ball in a blue goal (BG). .Q to represent the Quaffle, which is the ball that the players use to score goals. .B to represent a Bludger. The next line contains $$$T$$$, the number of steps that compose the game. $$$T$$$ lines follow, each describing one action. It contains several pieces of information separated by a space. First, a pair of characters representing the entity that must perform the action. Second, the description of the action: U, D, L, R indicate that the entity moves on the grid. It can move to the top of the grid (U), to the bottom (D), to the left (L), or to the right (R). Each entity moves by only one cell at a time. C indicates that the player catches the ball (only a player can catch a ball). Then, there is a space followed by a pair of characters: the description of the ball caught by the player. This information is needed since several balls can be in the same cell. T indicates that the player throws the Quaffle that it is carrying. All the actions performed by the entities are guaranteed to be valid: the players stay in the field, don't catch a ball if they are not in the same cell, don't release the Quaffle if they are not carrying it, ... Output You must output the description of the main events of the game, one event per line. More precisely: Each time a team scores, you must print t RED GOAL or t BLUE GOAL, depending on the team who scored, where t is the current time (the position of the action in the list of actions, starting from 0). In the case where a player scores in the wrong goal (a red player scores in the red goal, or a blue player scores in the blue goal), you must print the name of the team who wins one point, that is, the other team. Each time a player is eliminated, you must print t p ELIMINATED, where t is the current time and p is the player who is eliminated. The format to print the player is the same as in the input. The events must be printed in ascending order of t. If several players are eliminated at the same time, the events must be written in alphabetical order: B0, ..., B9, R0, ... R9. At the end of the game, you must print the final score as: FINAL SCORE: r b, where r is the score of the red team and b is the score of the blue team. Examples Input 3 5 .. .. R0 .. .. RG .. .Q .. BG .. .. B0 .. .. 12 R0 D R0 C .Q R0 R R0 T R0 D B0 R B0 U B0 C .Q B0 L B0 L B0 L B0 T Output 11 BLUE GOAL FINAL SCORE: 0 1 Input 3 5 .. .. R0 .. .. RG .. .Q .. BG .. .. B0 .. .. 5 R0 D R0 C .Q R0 L R0 L R0 T Output 4 BLUE GOAL FINAL SCORE: 0 1 Input 5 5 .. .. .. .. .. .. .. .. .. .. RG R0 .Q B0 BG .. .. .. .. .. .. .. .B .. .. 5 .B L .B U .B U B0 L B0 L Output 2 R0 ELIMINATED 4 B0 ELIMINATED FINAL SCORE: 0 0 Note In the first example, the red player takes the Quaffle, move it and throw it. The blue player catches the ball, goes to the red goal and scores. In the second example, the red player takes the ball and scores in the goal of their own team: the blue team wins a point. In the third example, the Bludger goes at the position of R0: R0 is eliminated. Then, B0 moves to the position of the Bludger: B0 is eliminated too. You can find one more example in the easy version of the problem | 2,300 | false | false | true | false | false | false | false | false | false | false | 470 |
675E | Vasya commutes by train every day. There are _n_ train stations in the city, and at the _i_-th station it's possible to buy only tickets to stations from _i_u2009+u20091 to _a__i_ inclusive. No tickets are sold at the last station. Let Ο_i_,u2009_j_ be the minimum number of tickets one needs to buy in order to get from stations _i_ to station _j_. As Vasya is fond of different useless statistic he asks you to compute the sum of all values Ο_i_,u2009_j_ among all pairs 1u2009β€u2009_i_u2009<u2009_j_u2009β€u2009_n_. Input The first line of the input contains a single integer _n_ (2u2009β€u2009_n_u2009β€u2009100u2009000)xa0β the number of stations. The second line contains _n_u2009-u20091 integer _a__i_ (_i_u2009+u20091u2009β€u2009_a__i_u2009β€u2009_n_), the _i_-th of them means that at the _i_-th station one may buy tickets to each station from _i_u2009+u20091 to _a__i_ inclusive. Output Print the sum of Ο_i_,u2009_j_ among all pairs of 1u2009β€u2009_i_u2009<u2009_j_u2009β€u2009_n_. Note In the first sample it's possible to get from any station to any other (with greater index) using only one ticket. The total number of pairs is 6, so the answer is also 6. Consider the second sample: Ο1,u20092u2009=u20091 Ο1,u20093u2009=u20092 Ο1,u20094u2009=u20093 Ο1,u20095u2009=u20093 Ο2,u20093u2009=u20091 Ο2,u20094u2009=u20092 Ο2,u20095u2009=u20092 Ο3,u20094u2009=u20091 Ο3,u20095u2009=u20091 Ο4,u20095u2009=u20091 Thus the answer equals 1u2009+u20092u2009+u20093u2009+u20093u2009+u20091u2009+u20092u2009+u20092u2009+u20091u2009+u20091u2009+u20091u2009=u200917. | 2,300 | false | true | false | true | true | false | false | false | false | false | 7,127 |
529B | Many years have passed, and _n_ friends met at a party again. Technologies have leaped forward since the last meeting, cameras with timer appeared and now it is not obligatory for one of the friends to stand with a camera, and, thus, being absent on the photo. Simply speaking, the process of photographing can be described as follows. Each friend occupies a rectangle of pixels on the photo: the _i_-th of them in a standing state occupies a _w__i_ pixels wide and a _h__i_ pixels high rectangle. But also, each person can lie down for the photo, and then he will occupy a _h__i_ pixels wide and a _w__i_ pixels high rectangle. The total photo will have size _W_u2009Γu2009_H_, where _W_ is the total width of all the people rectangles, and _H_ is the maximum of the heights. The friends want to determine what minimum area the group photo can they obtain if no more than _n_u2009/u20092 of them can lie on the ground (it would be strange if more than _n_u2009/u20092 gentlemen lie on the ground together, isn't it?..) Help them to achieve this goal. Input The first line contains integer _n_ (1u2009β€u2009_n_u2009β€u20091000) β the number of friends. The next _n_ lines have two integers _w__i_,u2009_h__i_ (1u2009β€u2009_w__i_,u2009_h__i_u2009β€u20091000) each, representing the size of the rectangle, corresponding to the _i_-th friend. Output Print a single integer equal to the minimum possible area of the photo containing all friends if no more than _n_u2009/u20092 of them can lie on the ground. | 1,900 | false | true | false | false | false | false | true | false | true | false | 7,717 |
891B | Problem - 891B - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags constructive algorithms greedy *2000 No tag edit access β Contest materials the sums of elements on that positions in _a_ and _b_ are different, i.xa0e. Input The first line contains one integer _n_ (1u2009β€u2009_n_u2009β€u200922)xa0β the size of the array. The second line contains _n_ space-separated distinct integers _a_1,u2009_a_2,u2009...,u2009_a__n_ (0u2009β€u2009_a__i_u2009β€u2009109)xa0β the elements of the array. Output If there is no such array _b_, print -1. Otherwise in the only line print _n_ space-separated integers _b_1,u2009_b_2,u2009...,u2009_b__n_. Note that _b_ must be a permutation of _a_. If there are multiple answers, print any of them. Examples Input 2 1 2 Output 2 1 Input 4 1000 100 10 1 Output 100 1 1000 10 Note An array _x_ is a permutation of _y_, if we can shuffle elements of _y_ such that it will coincide with _x_. Note that the empty subset and the subset containing all indices are not counted. | 2,000 | false | true | false | false | false | true | false | false | false | false | 6,187 |
761E | Dasha decided to have a rest after solving the problem. She had been ready to start her favourite activity β origami, but remembered the puzzle that she could not solve. The tree is a non-oriented connected graph without cycles. In particular, there always are _n_u2009-u20091 edges in a tree with _n_ vertices. The puzzle is to position the vertices at the points of the Cartesian plane with integral coordinates, so that the segments between the vertices connected by edges are parallel to the coordinate axes. Also, the intersection of segments is allowed only at their ends. Distinct vertices should be placed at different points. Help Dasha to find any suitable way to position the tree vertices on the plane. It is guaranteed that if it is possible to position the tree vertices on the plane without violating the condition which is given above, then you can do it by using points with integral coordinates which don't exceed 1018 in absolute value. Input The first line contains single integer _n_ (1u2009β€u2009_n_u2009β€u200930) β the number of vertices in the tree. Each of next _n_u2009-u20091 lines contains two integers _u__i_, _v__i_ (1u2009β€u2009_u__i_,u2009_v__i_u2009β€u2009_n_) that mean that the _i_-th edge of the tree connects vertices _u__i_ and _v__i_. It is guaranteed that the described graph is a tree. Output If the puzzle doesn't have a solution then in the only line print "NO". Otherwise, the first line should contain "YES". The next _n_ lines should contain the pair of integers _x__i_, _y__i_ (_x__i_,u2009_y__i_u2009β€u20091018) β the coordinates of the point which corresponds to the _i_-th vertex of the tree. If there are several solutions, print any of them. Examples Output YES 0 0 1 0 0 1 2 0 1 -1 -1 1 0 2 Note In the first sample one of the possible positions of tree is: | 2,000 | false | true | false | false | false | true | false | false | false | true | 6,745 |
1572A | You are given a book with $$$n$$$ chapters. Each chapter has a specified list of other chapters that need to be understood in order to understand this chapter. To understand a chapter, you must read it after you understand every chapter on its required list. Currently you don't understand any of the chapters. You are going to read the book from the beginning till the end repeatedly until you understand the whole book. Note that if you read a chapter at a moment when you don't understand some of the required chapters, you don't understand this chapter. Determine how many times you will read the book to understand every chapter, or determine that you will never understand every chapter no matter how many times you read the book. Input Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 le t le 2cdot10^4$$$). The first line of each test case contains a single integer $$$n$$$ ($$$1 le n le 2cdot10^5$$$) β number of chapters. Then $$$n$$$ lines follow. The $$$i$$$-th line begins with an integer $$$k_i$$$ ($$$0 le k_i le n-1$$$) β number of chapters required to understand the $$$i$$$-th chapter. Then $$$k_i$$$ integers $$$a_{i,1}, a_{i,2}, dots, a_{i, k_i}$$$ ($$$1 le a_{i, j} le n, a_{i, j} e i, a_{i, j} e a_{i, l}$$$ for $$$j e l$$$) follow β the chapters required to understand the $$$i$$$-th chapter. It is guaranteed that the sum of $$$n$$$ and sum of $$$k_i$$$ over all testcases do not exceed $$$2cdot10^5$$$. Output For each test case, if the entire book can be understood, print how many times you will read it, otherwise print $$$-1$$$. Example Input 5 4 1 2 0 2 1 4 1 2 5 1 5 1 1 1 2 1 3 1 4 5 0 0 2 1 2 1 2 2 2 1 4 2 2 3 0 0 2 3 2 5 1 2 1 3 1 4 1 5 0 Note In the first example, we will understand chapters $$${2, 4}$$$ in the first reading and chapters $$${1, 3}$$$ in the second reading of the book. In the second example, every chapter requires the understanding of some other chapter, so it is impossible to understand the book. In the third example, every chapter requires only chapters that appear earlier in the book, so we can understand everything in one go. In the fourth example, we will understand chapters $$${2, 3, 4}$$$ in the first reading and chapter $$$1$$$ in the second reading of the book. In the fifth example, we will understand one chapter in every reading from $$$5$$$ to $$$1$$$. | 1,800 | false | false | true | true | true | false | true | true | true | true | 2,782 |
1975E | You are given a tree of $$$n$$$ vertices numbered from $$$1$$$ to $$$n$$$. Initially, all vertices are colored white or black. You are asked to perform $$$q$$$ queries: "u"xa0β toggle the color of vertex $$$u$$$ (if it was white, change it to black and vice versa). After each query, you should answer whether all the black vertices form a chain. That is, there exist two black vertices such that the simple path between them passes through all the black vertices and only the black vertices. Specifically, if there is only one black vertex, they form a chain. If there are no black vertices, they do not form a chain. Input Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1leq tleq 10^4$$$). The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$q$$$ ($$$1leq n,qleq 2cdot 10^5$$$). The second line of each test case contains $$$n$$$ integers $$$c_1,c_2,ldots,c_n$$$ ($$$c_i in { mathtt{0}, mathtt{1} }$$$)xa0β the initial color of the vertices. $$$c_i$$$ denotes the color of vertex $$$i$$$ where $$$mathtt{0}$$$ denotes the color white, and $$$mathtt{1}$$$ denotes the color black. Then $$$n - 1$$$ lines follow, each line contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 le x_i,y_i le n$$$), indicating an edge between vertices $$$x_i$$$ and $$$y_i$$$. It is guaranteed that these edges form a tree. The following $$$q$$$ lines each contain an integer $$$u_i$$$ ($$$1 le u_i le n$$$), indicating the color of vertex $$$u_i$$$ needs to be toggled. It is guaranteed that the sum of $$$n$$$ and $$$q$$$ over all test cases respectively does not exceed $$$2cdot 10^5$$$. Output For each query, output "Yes" if the black vertices form a chain, and output "No" otherwise. You can output "Yes" and "No" in any case (for example, strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive response). Examples Input 2 2 1 1 0 1 2 1 5 4 1 0 0 0 0 1 2 1 3 1 5 3 4 4 3 2 5 Input 4 5 3 1 1 1 1 1 3 5 2 5 3 4 1 5 1 1 1 4 4 0 0 0 0 1 2 2 3 1 4 1 2 3 2 1 1 1 1 1 1 0 1 Output Yes No Yes Yes Yes Yes No No Yes Note In the second test case, the color of the vertices are as follows: The initial tree: The first query toggles the color of vertex $$$4$$$: The second query toggles the color of vertex $$$3$$$: The third query toggles the color of vertex $$$2$$$: The fourth query toggles the color of vertex $$$5$$$: | 2,100 | false | false | true | false | true | false | false | true | false | false | 438 |
1073E | You are given two integers $$$l$$$ and $$$r$$$ ($$$l le r$$$). Your task is to calculate the sum of numbers from $$$l$$$ to $$$r$$$ (including $$$l$$$ and $$$r$$$) such that each number contains at most $$$k$$$ different digits, and print this sum modulo $$$998244353$$$. For example, if $$$k = 1$$$ then you have to calculate all numbers from $$$l$$$ to $$$r$$$ such that each number is formed using only one digit. For $$$l = 10, r = 50$$$ the answer is $$$11 + 22 + 33 + 44 = 110$$$. Input The only line of the input contains three integers $$$l$$$, $$$r$$$ and $$$k$$$ ($$$1 le l le r < 10^{18}, 1 le k le 10$$$) β the borders of the segment and the maximum number of different digits. Output Print one integer β the sum of numbers from $$$l$$$ to $$$r$$$ such that each number contains at most $$$k$$$ different digits, modulo $$$998244353$$$. Note For the first example the answer is just the sum of numbers from $$$l$$$ to $$$r$$$ which equals to $$$frac{50 cdot 51}{2} - frac{9 cdot 10}{2} = 1230$$$. This example also explained in the problem statement but for $$$k = 1$$$. For the second example the answer is just the sum of numbers from $$$l$$$ to $$$r$$$ which equals to $$$frac{2345 cdot 2346}{2} = 2750685$$$. For the third example the answer is $$$101 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 121 + 122 + 131 + 133 + 141 + 144 + 151 = 2189$$$. | 2,300 | true | false | false | true | false | false | false | false | false | false | 5,349 |
1831B | You are given two arrays $$$a$$$ and $$$b$$$ both of length $$$n$$$. You will merge$$$^dagger$$$ these arrays forming another array $$$c$$$ of length $$$2 cdot n$$$. You have to find the maximum length of a subarray consisting of equal values across all arrays $$$c$$$ that could be obtained. $$$^dagger$$$ A merge of two arrays results in an array $$$c$$$ composed by successively taking the first element of either array (as long as that array is nonempty) and removing it. After this step, the element is appended to the back of $$$c$$$. We repeat this operation as long as we can (i.e. at least one array is nonempty). Input Each test contains multiple test cases. The first line of input contains a single integer $$$t$$$ ($$$1 le t le 10^4$$$)xa0β the number of test cases. The description of test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 le n le 2 cdot 10^5$$$)xa0β the length of the array $$$a$$$ and $$$b$$$. The second line of each test case contains $$$n$$$ integers $$$a_1,a_2,ldots,a_n$$$ ($$$1 le a_i le 2 cdot n$$$)xa0β the elements of array $$$a$$$. The third line of each test case contains $$$n$$$ integers $$$b_1,b_2,ldots,b_n$$$ ($$$1 le b_i le 2 cdot n$$$)xa0β the elements of array $$$b$$$. It is guaranteed that the sum of $$$n$$$ across all test cases does not exceed $$$2 cdot 10^5$$$. Output For each test case, output the maximum length of a subarray consisting of equal values across all merges. Example Input 4 1 2 2 3 1 2 3 4 5 6 2 1 2 2 1 5 1 2 2 2 2 2 1 1 1 1 Note In the first test case, we can only make $$$c=[2,2]$$$, thus the answer is $$$2$$$. In the second test case, since all values are distinct, the answer must be $$$1$$$. In the third test case, the arrays $$$c$$$ we can make are $$$[1,2,1,2]$$$, $$$[1,2,2,1]$$$, $$$[2,1,1,2]$$$, $$$[2,1,2,1]$$$. We can see that the answer is $$$2$$$ when we choose $$$c=[1,2,2,1]$$$. | 1,000 | false | true | false | false | false | true | false | false | false | false | 1,299 |
1510D | Diana loves playing with numbers. She's got $$$n$$$ cards with positive integer numbers $$$a_i$$$ written on them. She spends her free time multiplying the numbers on the cards. She picks a non-empty subset of the cards and multiplies all the numbers $$$a_i$$$ written on them. Diana is happy when the product of the numbers ends with her favorite digit $$$d$$$. Now she is curious what cards she should pick so that the product of the numbers on them is the largest possible and the last decimal digit of the product is $$$d$$$. Please, help her. Output On the first line, print the number of chosen cards $$$k$$$ ($$$1le kle n$$$). On the next line, print the numbers written on the chosen cards in any order. If it is impossible to choose a subset of cards with the product that ends with the digit $$$d$$$, print the single line with $$$-1$$$. Note In the first example, $$$1 imes 2 imes 4 imes 11 imes 13 = 1144$$$, which is the largest product that ends with the digit 4. The same set of cards without the number 1 is also a valid answer, as well as a set of 8, 11, and 13 with or without 1 that also has the product of 1144. In the second example, all the numbers on the cards are even and their product cannot end with an odd digit 1. In the third example, the only possible products are 1, 3, 5, 9, 15, and 45, none of which end with the digit 7. In the fourth example, $$$9 imes 11 imes 17 = 1683$$$, which ends with the digit 3. In the fifth example, $$$2 imes 2 imes 2 imes 2 = 16$$$, which ends with the digit 6. | 2,100 | true | false | false | true | false | false | false | false | false | false | 3,124 |
1929A | Sasha decided to give his girlfriend an array $$$a_1, a_2, ldots, a_n$$$. He found out that his girlfriend evaluates the beauty of the array as the sum of the values $$$(a_i - a_{i - 1})$$$ for all integers $$$i$$$ from $$$2$$$ to $$$n$$$. Help Sasha and tell him the maximum beauty of the array $$$a$$$ that he can obtain, if he can rearrange its elements in any way. Input Each test consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 le t le 500$$$) β the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$2 leq n leq 100$$$) β the length of the array $$$a$$$. The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$1 leq a_i leq 10^9$$$) β the elements of the array $$$a$$$. Output For each test case, output a single integer β the maximum beauty of the array $$$a$$$ that can be obtained. Example Input 5 3 2 1 3 3 69 69 69 5 100 54 80 43 90 4 3 4 3 3 2 2 1 Note In the first test case, the elements of the array $$$a$$$ can be rearranged to make $$$a = [1, 2, 3]$$$. Then its beauty will be equal to $$$(a_2 - a_1) + (a_3 - a_2) = (2 - 1) + (3 - 2) = 2$$$. In the second test case, there is no need to rearrange the elements of the array $$$a$$$. Then its beauty will be equal to $$$0$$$. | 800 | true | true | false | false | false | true | false | false | true | false | 717 |
1430G | You are given a directed acyclic graph (a directed graph that does not contain cycles) of $$$n$$$ vertices and $$$m$$$ arcs. The $$$i$$$-th arc leads from the vertex $$$x_i$$$ to the vertex $$$y_i$$$ and has the weight $$$w_i$$$. Your task is to select an integer $$$a_v$$$ for each vertex $$$v$$$, and then write a number $$$b_i$$$ on each arcs $$$i$$$ such that $$$b_i = a_{x_i} - a_{y_i}$$$. You must select the numbers so that: all $$$b_i$$$ are positive; the value of the expression $$$sum limits_{i = 1}^{m} w_i b_i$$$ is the lowest possible. It can be shown that for any directed acyclic graph with non-negative $$$w_i$$$, such a way to choose numbers exists. Input The first line contains two integers $$$n$$$ and $$$m$$$ ($$$2 le n le 18$$$; $$$0 le m le dfrac{n(n - 1)}{2}$$$). Then $$$m$$$ lines follow, the $$$i$$$-th of them contains three integers $$$x_i$$$, $$$y_i$$$ and $$$w_i$$$ ($$$1 le x_i, y_i le n$$$, $$$1 le w_i le 10^5$$$, $$$x_i e y_i$$$) β the description of the $$$i$$$-th arc. It is guaranteed that the lines describe $$$m$$$ arcs of a directed acyclic graph without multiple arcs between the same pair of vertices. Output Print $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_n$$$ ($$$0 le a_v le 10^9$$$), which must be written on the vertices so that all $$$b_i$$$ are positive, and the value of the expression $$$sum limits_{i = 1}^{m} w_i b_i$$$ is the lowest possible. If there are several answers, print any of them. It can be shown that the answer always exists, and at least one of the optimal answers satisfies the constraints $$$0 le a_v le 10^9$$$. Examples Input 5 4 1 2 1 2 3 1 1 3 6 4 5 8 Input 5 5 1 2 1 2 3 1 3 4 1 1 5 1 5 4 10 | 2,600 | true | false | false | true | false | false | false | false | false | true | 3,510 |
1109A | Sasha likes programming. Once, during a very long contest, Sasha decided that he was a bit tired and needed to relax. So he did. But since Sasha isn't an ordinary guy, he prefers to relax unusually. During leisure time Sasha likes to upsolve unsolved problems because upsolving is very useful. Therefore, Sasha decided to upsolve the following problem: You have an array $$$a$$$ with $$$n$$$ integers. You need to count the number of funny pairs $$$(l, r)$$$ $$$(l leq r)$$$. To check if a pair $$$(l, r)$$$ is a funny pair, take $$$mid = frac{l + r - 1}{2}$$$, then if $$$r - l + 1$$$ is an even number and $$$a_l oplus a_{l+1} oplus ldots oplus a_{mid} = a_{mid + 1} oplus a_{mid + 2} oplus ldots oplus a_r$$$, then the pair is funny. In other words, $$$oplus$$$ of elements of the left half of the subarray from $$$l$$$ to $$$r$$$ should be equal to $$$oplus$$$ of elements of the right half. Note that $$$oplus$$$ denotes the xa0β the size of the array. The second line contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$0 le a_i < 2^{20}$$$)xa0β array itself. Output Print one integerxa0β the number of funny pairs. You should consider only pairs where $$$r - l + 1$$$ is even number. Note Be as cool as Sasha, upsolve problems! In the first example, the only funny pair is $$$(2, 5)$$$, as $$$2 oplus 3 = 4 oplus 5 = 1$$$. In the second example, funny pairs are $$$(2, 3)$$$, $$$(1, 4)$$$, and $$$(3, 6)$$$. In the third example, there are no funny pairs. | 1,600 | false | false | true | true | false | false | false | false | false | false | 5,155 |
1525F | Monocarp plays a computer game called "Goblins and Gnomes". In this game, he manages a large underground city of gnomes and defends it from hordes of goblins. The city consists of $$$n$$$ halls and $$$m$$$ one-directional tunnels connecting them. The structure of tunnels has the following property: if a goblin leaves any hall, he cannot return to that hall. The city will be attacked by $$$k$$$ waves of goblins; during the $$$i$$$-th wave, $$$i$$$ goblins attack the city. Monocarp's goal is to pass all $$$k$$$ waves. The $$$i$$$-th wave goes as follows: firstly, $$$i$$$ goblins appear in some halls of the city and pillage them; at most one goblin appears in each hall. Then, goblins start moving along the tunnels, pillaging all the halls in their path. Goblins are very greedy and cunning, so they choose their paths so that no two goblins pass through the same hall. Among all possible attack plans, they choose a plan which allows them to pillage the maximum number of halls. After goblins are done pillaging, they leave the city. If all halls are pillaged during the wave β Monocarp loses the game. Otherwise, the city is restored. If some hall is pillaged during a wave, goblins are still interested in pillaging it during the next waves. Before each wave, Monocarp can spend some time preparing to it. Monocarp doesn't have any strict time limits on his preparations (he decides when to call each wave by himself), but the longer he prepares for a wave, the fewer points he gets for passing it. If Monocarp prepares for the $$$i$$$-th wave for $$$t_i$$$ minutes, then he gets $$$max(0, x_i - t_i cdot y_i)$$$ points for passing it (obviously, if he doesn't lose in the process). While preparing for a wave, Monocarp can block tunnels. He can spend one minute to either block all tunnels leading from some hall or block all tunnels leading to some hall. If Monocarp blocks a tunnel while preparing for a wave, it stays blocked during the next waves as well. Help Monocarp to defend against all $$$k$$$ waves of goblins and get the maximum possible amount of points! Input The first line contains three integers $$$n$$$, $$$m$$$ and $$$k$$$ ($$$2 le n le 50$$$; $$$0 le m le frac{n(n - 1)}{2}$$$; $$$1 le k le n - 1$$$)xa0β the number of halls in the city, the number of tunnels and the number of goblin waves, correspondely. Next $$$m$$$ lines describe tunnels. The $$$i$$$-th line contains two integers $$$u_i$$$ and $$$v_i$$$ ($$$1 le u_i, v_i le n$$$; $$$u_i e v_i$$$). It means that the tunnel goes from hall $$$u_i$$$ to hall $$$v_i$$$. The structure of tunnels has the following property: if a goblin leaves any hall, he cannot return to that hall. There is at most one tunnel between each pair of halls. Next $$$k$$$ lines describe the scoring system. The $$$i$$$-th line contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$1 le x_i le 10^9$$$; $$$1 le y_i le 10^9$$$). If Monocarp prepares for the $$$i$$$-th wave for $$$t_i$$$ minutes, then he gets $$$max(0, x_i - t_i cdot y_i)$$$ points for passing it. Output Print the optimal Monocarp's strategy in the following format: At first, print one integer $$$a$$$ ($$$k le a le 2n + k$$$)xa0β the number of actions Monocarp will perform. Next, print actions themselves in the order Monocarp performs them. The $$$i$$$-th action is described by a single integer $$$b_i$$$ ($$$-n le b_i le n$$$) using the following format: if $$$b_i > 0$$$ then Monocarp blocks all tunnels going out from the hall $$$b_i$$$; if $$$b_i < 0$$$ then Monocarp blocks all tunnels going into the hall $$$b_i$$$; if $$$b_i = 0$$$ then Monocarp calls the next goblin wave. You can't repeat the same block action $$$b_i$$$ several times. Monocarp must survive all waves he calls (goblins shouldn't be able to pillage all halls). Monocarp should call exactly $$$k$$$ waves and earn the maximum possible number of points in total. If there are several optimal strategiesxa0β print any of them. Examples Input 5 4 4 1 2 2 3 4 3 5 3 100 1 200 5 10 10 100 1 Input 5 4 4 1 2 2 3 4 3 5 3 100 100 200 5 10 10 100 1 Input 5 10 1 1 2 1 3 1 4 1 5 5 2 5 3 5 4 4 2 4 3 2 3 100 100 Note In the first example, Monocarp, firstly, block all tunnels going in hall $$$2$$$, secondlyxa0β all tunnels going in hall $$$3$$$, and after that calls all waves. He spent two minutes to prepare to wave $$$1$$$, so he gets $$$98$$$ points for it. He didn't prepare after that, that's why he gets maximum scores for each of next waves ($$$200$$$, $$$10$$$ and $$$100$$$). In total, Monocarp earns $$$408$$$ points. In the second example, Monocarp calls for the first wave immediately and gets $$$100$$$ points. Before the second wave he blocks all tunnels going in hall $$$3$$$. He spent one minute preparing to the wave, so he gets $$$195$$$ points. Monocarp didn't prepare for the third wave, so he gets $$$10$$$ points by surviving it. Before the fourth wave he blocks all tunnels going out from hall $$$1$$$. He spent one minute, so he gets $$$99$$$ points for the fourth wave. In total, Monocarp earns $$$404$$$ points. In the third example, it doesn't matter how many minutes Monocarp will spend before the wave, since he won't get any points for it. That's why he decides to block all tunnels in the city, spending $$$5$$$ minutes. He survived the wave though without getting any points. | 2,800 | false | false | false | true | false | false | true | false | false | false | 3,037 |
1490G | Polycarp was dismantling his attic and found an old floppy drive on it. A round disc was inserted into the drive with $$$n$$$ integers written on it. Polycarp wrote the numbers from the disk into the $$$a$$$ array. It turned out that the drive works according to the following algorithm: the drive takes one positive number $$$x$$$ as input and puts a pointer to the first element of the $$$a$$$ array; after that, the drive starts rotating the disk, every second moving the pointer to the next element, counting the sum of all the elements that have been under the pointer. Since the disk is round, in the $$$a$$$ array, the last element is again followed by the first one; as soon as the sum is at least $$$x$$$, the drive will shut down. Polycarp wants to learn more about the operation of the drive, but he has absolutely no free time. So he asked you $$$m$$$ questions. To answer the $$$i$$$-th of them, you need to find how many seconds the drive will work if you give it $$$x_i$$$ as input. Please note that in some cases the drive can work infinitely. For example, if $$$n=3, m=3$$$, $$$a=[1, -3, 4]$$$ and $$$x=[1, 5, 2]$$$, then the answers to the questions are as follows: the answer to the first query is $$$0$$$ because the drive initially points to the first item and the initial sum is $$$1$$$. the answer to the second query is $$$6$$$, the drive will spin the disk completely twice and the amount becomes $$$1+(-3)+4+1+(-3)+4+1=5$$$. the answer to the third query is $$$2$$$, the amount is $$$1+(-3)+4=2$$$. Input The first line contains one integer $$$t$$$ ($$$1 le t le 10^4$$$)xa0β the number of test cases. Then $$$t$$$ test cases follow. The first line of each test case consists of two positive integers $$$n$$$, $$$m$$$ ($$$1 le n, m le 2 cdot 10^5$$$)xa0β the number of numbers on the disk and the number of asked questions. The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$-10^9 le a_i le 10^9$$$). The third line of each test case contains $$$m$$$ positive integers $$$x_1, x_2, ldots, x_m$$$ ($$$1 le x le 10^9$$$). It is guaranteed that the sums of $$$n$$$ and $$$m$$$ over all test cases do not exceed $$$2 cdot 10^5$$$. Output Print $$$m$$$ numbers on a separate line for each test case. The $$$i$$$-th number is: $$$-1$$$ if the drive will run infinitely; the number of seconds the drive will run, otherwise. Example Input 3 3 3 1 -3 4 1 5 2 2 2 -2 0 1 2 2 2 0 1 1 2 | 1,900 | true | false | false | false | true | false | false | true | false | false | 3,223 |
780D | Innokenty is a president of a new football league in Byteland. The first task he should do is to assign short names to all clubs to be shown on TV next to the score. Of course, the short names should be distinct, and Innokenty wants that all short names consist of three letters. Each club's full name consist of two words: the team's name and the hometown's name, for example, "DINAMO BYTECITY". Innokenty doesn't want to assign strange short names, so he wants to choose such short names for each club that: 1. the short name is the same as three first letters of the team's name, for example, for the mentioned club it is "DIN", 2. or, the first two letters of the short name should be the same as the first two letters of the team's name, while the third letter is the same as the first letter in the hometown's name. For the mentioned club it is "DIB". Apart from this, there is a rule that if for some club _x_ the second option of short name is chosen, then there should be no club, for which the first option is chosen which is the same as the first option for the club _x_. For example, if the above mentioned club has short name "DIB", then no club for which the first option is chosen can have short name equal to "DIN". However, it is possible that some club have short name "DIN", where "DI" are the first two letters of the team's name, and "N" is the first letter of hometown's name. Of course, no two teams can have the same short name. Help Innokenty to choose a short name for each of the teams. If this is impossible, report that. If there are multiple answer, any of them will suit Innokenty. If for some team the two options of short name are equal, then Innokenty will formally think that only one of these options is chosen. Input The first line contains a single integer _n_ (1u2009β€u2009_n_u2009β€u20091000)xa0β the number of clubs in the league. Each of the next _n_ lines contains two wordsxa0β the team's name and the hometown's name for some club. Both team's name and hometown's name consist of uppercase English letters and have length at least 3 and at most 20. Output It it is not possible to choose short names and satisfy all constraints, print a single line "NO". Otherwise, in the first line print "YES". Then print _n_ lines, in each line print the chosen short name for the corresponding club. Print the clubs in the same order as they appeared in input. If there are multiple answers, print any of them. Note In the first sample Innokenty can choose first option for both clubs. In the second example it is not possible to choose short names, because it is not possible that one club has first option, and the other has second option if the first options are equal for both clubs. In the third example Innokenty can choose the second options for the first two clubs, and the first option for the third club. In the fourth example note that it is possible that the chosen short name for some club _x_ is the same as the first option of another club _y_ if the first options of _x_ and _y_ are different. | 1,900 | false | true | true | false | false | false | false | false | false | true | 6,645 |
71C | There are _n_ knights sitting at the Round Table at an equal distance from each other. Each of them is either in a good or in a bad mood. Merlin, the wizard predicted to King Arthur that the next month will turn out to be particularly fortunate if the regular polygon can be found. On all vertices of the polygon knights in a good mood should be located. Otherwise, the next month will bring misfortunes. A convex polygon is regular if all its sides have same length and all his angles are equal. In this problem we consider only regular polygons with at least 3 vertices, i. e. only nondegenerated. On a picture below some examples of such polygons are present. Green points mean knights in a good mood. Red points mean ones in a bad mood. King Arthur knows the knights' moods. Help him find out if the next month will be fortunate or not. Input The first line contains number _n_, which is the number of knights at the round table (3u2009β€u2009_n_u2009β€u2009105). The second line contains space-separated moods of all the _n_ knights in the order of passing them around the table. "1" means that the knight is in a good mood an "0" means that he is in a bad mood. Output Print "YES" without the quotes if the following month will turn out to be lucky. Otherwise, print "NO". | 1,600 | true | false | false | true | false | false | false | false | false | false | 9,614 |
1867A | green_gold_dog has an array $$$a$$$ of length $$$n$$$, and he wants to find a permutation $$$b$$$ of length $$$n$$$ such that the number of distinct numbers in the element-wise difference between array $$$a$$$ and permutation $$$b$$$ is maximized. A permutation of length $$$n$$$ is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in any order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation (as $$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation (as $$$n=3$$$, but $$$4$$$ appears in the array). The element-wise difference between two arrays $$$a$$$ and $$$b$$$ of length $$$n$$$ is an array $$$c$$$ of length $$$n$$$, where $$$c_i$$$ = $$$a_i - b_i$$$ ($$$1 leq i leq n$$$). Input Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 le t le 4 cdot 10^4$$$). The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 le n le 4 cdot 10^4$$$). The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$1 le a_i le 10^9$$$). It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$4 cdot 10^4$$$. Output For each test case, output $$$n$$$ numbers - a suitable permutation $$$b$$$. If there are multiple solutions, print any of them. Note In the first set of input data, the element-wise difference of the arrays is [99999]. Here, there is one distinct number, and it is obvious that in an array of length one, there cannot be more than one different element. In the second set of input data, the element-wise difference of the arrays is [-1, 0]. Here, there are two distinct numbers, and it is obvious that in an array of length two, there cannot be more than two different elements. In the third set of input data, the element-wise difference of the arrays is [9, 0, 1]. Here, there are three distinct numbers, and it is obvious that in an array of length three, there cannot be more than three different elements. | 800 | false | false | false | false | false | true | false | false | true | false | 1,075 |
2027D2 | This is the hard version of this problem. The only difference is that you need to also output the number of optimal sequences in this version. You must solve both versions to be able to hack. You're given an array $$$a$$$ of length $$$n$$$, and an array $$$b$$$ of length $$$m$$$ ($$$b_i > b_{i+1}$$$ for all $$$1 le i < m$$$). Initially, the value of $$$k$$$ is $$$1$$$. Your aim is to make the array $$$a$$$ empty by performing one of these two operations repeatedly: Type $$$1$$$xa0β If the value of $$$k$$$ is less than $$$m$$$ and the array $$$a$$$ is not empty, you can increase the value of $$$k$$$ by $$$1$$$. This does not incur any cost. Type $$$2$$$xa0β You remove a non-empty prefix of array $$$a$$$, such that its sum does not exceed $$$b_k$$$. This incurs a cost of $$$m - k$$$. You need to minimize the total cost of the operations to make array $$$a$$$ empty. If it's impossible to do this through any sequence of operations, output $$$-1$$$. Otherwise, output the minimum total cost of the operations, and the number of sequences of operations which yield this minimum cost modulo $$$10^9 + 7$$$. Two sequences of operations are considered different if you choose a different type of operation at any step, or the size of the removed prefix is different at any step. Input Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 le t le 1000$$$). The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$1 le n, m le 3 cdot 10^5$$$, $$$boldsymbol{1 le n cdot m le 3 cdot 10^5}$$$). The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$1 le a_i le 10^9$$$). The third line of each test case contains $$$m$$$ integers $$$b_1, b_2, ldots, b_m$$$ ($$$1 le b_i le 10^9$$$). It is also guaranteed that $$$b_i > b_{i+1}$$$ for all $$$1 le i < m$$$. It is guaranteed that the sum of $$$boldsymbol{n cdot m}$$$ over all test cases does not exceed $$$3 cdot 10^5$$$. Output For each test case, if it's possible to make $$$a$$$ empty, then output two integers. The first should be the minimum total cost of the operations, and the second should be the number of sequences of operations which achieve this minimum cost, modulo $$$10^9 + 7$$$. If there is no possible sequence of operations which makes $$$a$$$ empty, then output a single integer $$$-1$$$. Example Input 5 4 2 9 3 4 3 11 7 1 2 20 19 18 10 2 2 5 2 1 10 3 2 9 9 6 17 9 10 11 2 2 2 2 2 2 2 2 2 2 20 18 16 14 12 10 8 6 4 2 1 1 6 10 32 16 8 4 2 1 Output 1 3 -1 2 11 10 42 4 1 Note In the first test case, there are $$$3$$$ optimal sequences of operations which yield a total cost of $$$1$$$: All $$$3$$$ sequences begin with a type $$$2$$$ operation, removing the prefix $$$[9]$$$ to make $$$a = [3, 4, 3]$$$, incurring a cost of $$$1$$$. Then, we perform a type $$$1$$$ operation to increase the value of $$$k$$$ by $$$1$$$. All subsequent operations now incur a cost of $$$0$$$. One sequence continues by removing the prefixes $$$[3, 4]$$$ then $$$[3]$$$. Another sequence continues by removing the prefixes $$$[3]$$$ then $$$[4, 3]$$$. Another sequence continues by removing the prefixes $$$[3]$$$ then $$$[4]$$$ then $$$[3]$$$. In the second test case, it's impossible to remove any prefix of the array since $$$a_1 > b_1$$$, so array $$$a$$$ cannot be made empty by any sequence of operations. | 2,200 | false | true | true | true | true | false | false | true | false | false | 106 |
1614D2 | This is the hard version of the problem. The only difference is maximum value of $$$a_i$$$. Once in Kostomuksha Divan found an array $$$a$$$ consisting of positive integers. Now he wants to reorder the elements of $$$a$$$ to maximize the value of the following function: $$$$$$sum_{i=1}^n operatorname{gcd}(a_1, , a_2, , dots, , a_i),$$$$$$ where $$$operatorname{gcd}(x_1, x_2, ldots, x_k)$$$ denotes the = x$$$ for any integer $$$x$$$. Reordering elements of an array means changing the order of elements in the array arbitrary, or leaving the initial order. Of course, Divan can solve this problem. However, he found it interesting, so he decided to share it with you. Input The first line contains a single integer $$$n$$$ ($$$1 leq n leq 10^5$$$) β the size of the array $$$a$$$. The second line contains $$$n$$$ integers $$$a_{1}, , a_{2}, , dots, , a_{n}$$$ ($$$1 le a_{i} le 2 cdot 10^7$$$) β the array $$$a$$$. Note In the first example, it's optimal to rearrange the elements of the given array in the following order: $$$[6, , 2, , 2, , 2, , 3, , 1]$$$: $$$$$$operatorname{gcd}(a_1) + operatorname{gcd}(a_1, , a_2) + operatorname{gcd}(a_1, , a_2, , a_3) + operatorname{gcd}(a_1, , a_2, , a_3, , a_4) + operatorname{gcd}(a_1, , a_2, , a_3, , a_4, , a_5) + operatorname{gcd}(a_1, , a_2, , a_3, , a_4, , a_5, , a_6) = 6 + 2 + 2 + 2 + 1 + 1 = 14.$$$$$$ It can be shown that it is impossible to get a better answer. In the second example, it's optimal to rearrange the elements of a given array in the following order: $$$[100, , 10, , 10, , 5, , 1, , 3, , 3, , 7, , 42, , 54]$$$. | 2,300 | false | false | false | true | false | false | false | false | false | false | 2,566 |
369C | The city Valera lives in is going to hold elections to the city Parliament. The city has _n_ districts and _n_u2009-u20091 bidirectional roads. We know that from any district there is a path along the roads to any other district. Let's enumerate all districts in some way by integers from 1 to _n_, inclusive. Furthermore, for each road the residents decided if it is the problem road or not. A problem road is a road that needs to be repaired. There are _n_ candidates running the elections. Let's enumerate all candidates in some way by integers from 1 to _n_, inclusive. If the candidate number _i_ will be elected in the city Parliament, he will perform exactly one promise β to repair all problem roads on the way from the _i_-th district to the district 1, where the city Parliament is located. Help Valera and determine the subset of candidates such that if all candidates from the subset will be elected to the city Parliament, all problem roads in the city will be repaired. If there are several such subsets, you should choose the subset consisting of the minimum number of candidates. Input The first line contains a single integer _n_ (2u2009β€u2009_n_u2009β€u2009105) β the number of districts in the city. Then _n_u2009-u20091 lines follow. Each line contains the description of a city road as three positive integers _x__i_, _y__i_, _t__i_ (1u2009β€u2009_x__i_,u2009_y__i_u2009β€u2009_n_, 1u2009β€u2009_t__i_u2009β€u20092) β the districts connected by the _i_-th bidirectional road and the road type. If _t__i_ equals to one, then the _i_-th road isn't the problem road; if _t__i_ equals to two, then the _i_-th road is the problem road. It's guaranteed that the graph structure of the city is a tree. Output In the first line print a single non-negative number _k_ β the minimum size of the required subset of candidates. Then on the second line print _k_ space-separated integers _a_1,u2009_a_2,u2009... _a__k_ β the numbers of the candidates that form the required subset. If there are multiple solutions, you are allowed to print any of them. Examples Input 5 1 2 2 2 3 2 3 4 2 4 5 2 Input 5 1 2 1 2 3 2 2 4 1 4 5 1 Input 5 1 2 2 1 3 2 1 4 2 1 5 2 | 1,600 | false | false | false | false | false | false | false | false | false | true | 8,356 |
29D | Connected undirected graph without cycles is called a tree. Trees is a class of graphs which is interesting not only for people, but for ants too. An ant stands at the root of some tree. He sees that there are _n_ vertexes in the tree, and they are connected by _n_u2009-u20091 edges so that there is a path between any pair of vertexes. A leaf is a distinct from root vertex, which is connected with exactly one other vertex. The ant wants to visit every vertex in the tree and return to the root, passing every edge twice. In addition, he wants to visit the leaves in a specific order. You are to find some possible route of the ant. Input The first line contains integer _n_ (3u2009β€u2009_n_u2009β€u2009300) β amount of vertexes in the tree. Next _n_u2009-u20091 lines describe edges. Each edge is described with two integers β indexes of vertexes which it connects. Each edge can be passed in any direction. Vertexes are numbered starting from 1. The root of the tree has number 1. The last line contains _k_ integers, where _k_ is amount of leaves in the tree. These numbers describe the order in which the leaves should be visited. It is guaranteed that each leaf appears in this order exactly once. Output If the required route doesn't exist, output -1. Otherwise, output 2_n_u2009-u20091 numbers, describing the route. Every time the ant comes to a vertex, output it's index. Examples Input 6 1 2 1 3 2 4 4 5 4 6 5 6 3 Output 1 2 4 5 4 6 4 2 1 3 1 Input 6 1 2 1 3 2 4 4 5 4 6 5 3 6 | 2,000 | false | false | false | false | false | true | false | false | false | false | 9,850 |
761A | Problem - 761A - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags brute force constructive algorithms implementation math *1000 No tag edit access β Contest materials ") , for which values that Dasha has found are correct. Input In the only line you are given two integers _a_, _b_ (0u2009β€u2009_a_,u2009_b_u2009β€u2009100) β the number of even and odd steps, accordingly. Output In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise. Examples Input 2 3 Output YES Input 3 1 Output NO Note In the first example one of suitable intervals is from 1 to 5. The interval contains two even stepsxa0β 2 and 4, and three odd: 1, 3 and 5. | 1,000 | true | false | true | false | false | true | true | false | false | false | 6,749 |
494B | Problem - 494B - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags dp strings *2000 No tag edit access β Contest materials . As the number of ways can be rather large print it modulo 109u2009+u20097. Input Input consists of two lines containing strings _s_ and _t_ (1u2009β€u2009_s_,u2009_t_u2009β€u2009105). Each string consists of lowercase Latin letters. Output Print the answer in a single line. Examples Input ababa aba Output 5 Input welcometoroundtwohundredandeightytwo d Output 274201 Input ddd d Output 12 | 2,000 | false | false | false | true | false | false | false | false | false | false | 7,857 |
1769D2 | Π ΡΡΠΎΠΉ Π²Π΅ΡΡΠΈΠΈ Π·Π°Π΄Π°ΡΠΈ ΠΈΠ³ΡΠΎΠΊΠΈ Π½Π°ΡΠΈΠ½Π°ΡΡ ΠΈΠ³ΡΠ°ΡΡ Π½Π΅ ΡΠΎΠ»ΡΠΊΠΎ Π½Π° ΠΏΠΎΠ±Π΅Π΄Ρ, Π½ΠΎ ΠΈ Π½Π° ΠΎΠΏΡΠΈΠΌΠΈΠ·Π°ΡΠΈΡ ΡΠ΅Π·ΡΠ»ΡΡΠ°ΡΠ° ΠΈΠ³ΡΡ Π΄Π»Ρ Π½ΠΈΡ
. ΠΠ²ΠΎΠ΄ΠΈΡΡΡ ΠΏΠΎΠ½ΡΡΠΈΠ΅ Π²Π΅Π»ΠΈΡΠΈΠ½Ρ Π²Π°ΠΆΠ½ΠΎΡΡΠΈ ΠΏΠ΅ΡΠ²ΠΎΠ³ΠΎ Ρ
ΠΎΠ΄Π°, ΠΈ Π½ΡΠΆΠ½ΠΎ Π½Π°ΠΉΡΠΈ $$$13$$$ ΡΠ°ΡΠΊΠ»Π°Π΄ΠΎΠ² Ρ ΡΠ°Π·Π»ΠΈΡΠ½ΡΠΌΠΈ Π·Π½Π°ΡΠ΅Π½ΠΈΡΠΌΠΈ ΡΡΠΎΠΉ Π²Π΅Π»ΠΈΡΠΈΠ½Ρ. ΠΠ»ΠΈΡΠ° ΠΈ ΠΠΎΠ± ΡΠ΅ΡΠΈΠ»ΠΈ ΡΡΠ³ΡΠ°ΡΡ Π² ΠΊΠ°ΡΡΠΎΡΠ½ΡΡ ΠΈΠ³ΡΡ Β«ΠΠ΅Π²ΡΡΠΊΠ°Β». ΠΠΎΠΆΠ°Π»ΡΠΉΡΡΠ°, Π²Π½ΠΈΠΌΠ°ΡΠ΅Π»ΡΠ½ΠΎ ΠΏΡΠΎΡΠΈΡΠ°ΠΉΡΠ΅ ΡΡΠ»ΠΎΠ²ΠΈΠ΅ Π·Π°Π΄Π°ΡΠΈ, ΠΏΠΎΡΠΊΠΎΠ»ΡΠΊΡ ΠΏΡΠ°Π²ΠΈΠ»Π° ΠΌΠΎΠ³ΡΡ ΠΎΡΠ»ΠΈΡΠ°ΡΡΡΡ ΠΎΡ ΠΈΠ·Π²Π΅ΡΡΠ½ΡΡ
Π²Π°ΠΌ. ΠΠ»Ρ ΠΈΠ³ΡΡ Π½ΡΠΆΠ½Π° ΡΡΠ°Π½Π΄Π°ΡΡΠ½Π°Ρ ΠΊΠΎΠ»ΠΎΠ΄Π° ΠΈΠ· $$$36$$$ ΠΊΠ°ΡΡxa0β ΠΏΠΎ Π΄Π΅Π²ΡΡΡ ΠΊΠ°ΡΡ (ΠΎΡ ΡΠ΅ΡΡΡΡΠΊΠΈ Π΄ΠΎ ΡΡΠ·Π°) ΠΊΠ°ΠΆΠ΄ΠΎΠΉ ΠΈΠ· ΡΠ΅ΡΡΡΡΡ
ΠΌΠ°ΡΡΠ΅ΠΉ (ΡΡΠ΅ΡΡ, Π±ΡΠ±Π½Ρ, ΠΏΠΈΠΊΠΈ ΠΈ ΡΠ΅ΡΠ²ΠΈ). ΠΠ°ΡΡΡ ΠΏΠΎ Π΄ΠΎΡΡΠΎΠΈΠ½ΡΡΠ²Ρ ΠΎΡ ΠΌΠ»Π°Π΄ΡΠ΅ΠΉ ΠΊ ΡΡΠ°ΡΡΠ΅ΠΉ ΠΈΠ΄ΡΡ ΡΠ»Π΅Π΄ΡΡΡΠΈΠΌ ΠΎΠ±ΡΠ°Π·ΠΎΠΌ: ΡΠ΅ΡΡΡΡΠΊΠ°, ΡΠ΅ΠΌΡΡΠΊΠ°, Π²ΠΎΡΡΠΌΡΡΠΊΠ°, Π΄Π΅Π²ΡΡΠΊΠ°, Π΄Π΅ΡΡΡΠΊΠ°, Π²Π°Π»Π΅Ρ, Π΄Π°ΠΌΠ°, ΠΊΠΎΡΠΎΠ»Ρ, ΡΡΠ·. ΠΠ΅ΡΠ΅Π΄ ΠΈΠ³ΡΠΎΠΉ ΠΊΠΎΠ»ΠΎΠ΄Π° ΠΏΠ΅ΡΠ΅ΠΌΠ΅ΡΠΈΠ²Π°Π΅ΡΡΡ, ΠΈ ΠΊΠ°ΠΆΠ΄ΠΎΠΌΡ ΠΈΠ³ΡΠΎΠΊΡ ΡΠ°Π·Π΄Π°ΡΡΡΡ ΠΏΠΎ $$$18$$$ ΠΊΠ°ΡΡ. ΠΠ°ΡΡΡ Π½ΡΠΆΠ½ΠΎ Π²ΡΠΊΠ»Π°Π΄ΡΠ²Π°ΡΡ ΠΈΠ· ΡΡΠΊΠΈ Π½Π° ΡΡΠΎΠ» ΠΏΠΎ ΠΎΠΏΡΠ΅Π΄Π΅Π»ΡΠ½Π½ΡΠΌ ΠΏΡΠ°Π²ΠΈΠ»Π°ΠΌ. ΠΡΠΈΠ³ΡΡΠ²Π°Π΅Ρ ΠΈΠ³ΡΠΎΠΊ, ΠΊΠΎΡΠΎΡΡΠΉ ΠΏΠ΅ΡΠ²ΡΠΌ Π²ΡΠ»ΠΎΠΆΠΈΡ Π²ΡΠ΅ ΠΊΠ°ΡΡΡ ΠΈΠ· ΡΠ²ΠΎΠ΅ΠΉ ΡΡΠΊΠΈ. ΠΠ³ΡΠΎΠΊΠΈ Ρ
ΠΎΠ΄ΡΡ ΠΏΠΎ ΠΎΡΠ΅ΡΠ΅Π΄ΠΈ. Π₯ΠΎΠ΄ ΠΈΠ³ΡΠΎΠΊΠ° ΠΈΠΌΠ΅Π΅Ρ ΠΎΠ΄ΠΈΠ½ ΠΈΠ· ΡΠ»Π΅Π΄ΡΡΡΠΈΡ
Π²ΠΈΠ΄ΠΎΠ²: Π²ΡΠ»ΠΎΠΆΠΈΡΡ Π½Π° ΡΡΠΎΠ» ΠΈΠ· ΡΠ²ΠΎΠ΅ΠΉ ΡΡΠΊΠΈ Π΄Π΅Π²ΡΡΠΊΡ Π»ΡΠ±ΠΎΠΉ ΠΌΠ°ΡΡΠΈ; Π²ΡΠ»ΠΎΠΆΠΈΡΡ Π½Π° ΡΡΠΎΠ» ΡΠ΅ΡΡΡΡΠΊΡ, ΡΠ΅ΠΌΡΡΠΊΡ ΠΈΠ»ΠΈ Π²ΠΎΡΡΠΌΡΡΠΊΡ Π»ΡΠ±ΠΎΠΉ ΠΌΠ°ΡΡΠΈ, Π΅ΡΠ»ΠΈ Π½Π° ΡΡΠΎΠ»Π΅ ΡΠΆΠ΅ Π»Π΅ΠΆΠΈΡ ΠΊΠ°ΡΡΠ° ΡΠΎΠΉ ΠΆΠ΅ ΠΌΠ°ΡΡΠΈ Π΄ΠΎΡΡΠΎΠΈΠ½ΡΡΠ²ΠΎΠΌ Π½Π° Π΅Π΄ΠΈΠ½ΠΈΡΡ Π²ΡΡΠ΅; Π²ΡΠ»ΠΎΠΆΠΈΡΡ Π½Π° ΡΡΠΎΠ» Π΄Π΅ΡΡΡΠΊΡ, Π²Π°Π»Π΅ΡΠ°, Π΄Π°ΠΌΡ, ΠΊΠΎΡΠΎΠ»Ρ ΠΈΠ»ΠΈ ΡΡΠ·Π° Π»ΡΠ±ΠΎΠΉ ΠΌΠ°ΡΡΠΈ, Π΅ΡΠ»ΠΈ Π½Π° ΡΡΠΎΠ»Π΅ ΡΠΆΠ΅ Π»Π΅ΠΆΠΈΡ ΠΊΠ°ΡΡΠ° ΡΠΎΠΉ ΠΆΠ΅ ΠΌΠ°ΡΡΠΈ Π΄ΠΎΡΡΠΎΠΈΠ½ΡΡΠ²ΠΎΠΌ Π½Π° Π΅Π΄ΠΈΠ½ΠΈΡΡ Π½ΠΈΠΆΠ΅. ΠΠ°ΠΏΡΠΈΠΌΠ΅Ρ, Π΄Π΅Π²ΡΡΠΊΡ ΠΏΠΈΠΊ ΠΌΠΎΠΆΠ½ΠΎ Π²ΡΠ»ΠΎΠΆΠΈΡΡ Π½Π° ΡΡΠΎΠ» Π² Π»ΡΠ±ΠΎΠΉ ΠΌΠΎΠΌΠ΅Π½Ρ, Π΄Π»Ρ Π²ΡΠΊΠ»Π°Π΄ΡΠ²Π°Π½ΠΈΡ ΡΠ΅ΠΌΡΡΠΊΠΈ ΡΡΠ΅Ρ Π½Π΅ΠΎΠ±Ρ
ΠΎΠ΄ΠΈΠΌΠΎ Π½Π°Π»ΠΈΡΠΈΠ΅ Π½Π° ΡΡΠΎΠ»Π΅ Π²ΠΎΡΡΠΌΡΡΠΊΠΈ ΡΡΠ΅Ρ, Π° Π΄Π»Ρ Π²ΡΠΊΠ»Π°Π΄ΡΠ²Π°Π½ΠΈΡ ΡΡΠ·Π° ΡΠ΅ΡΠ²Π΅ΠΉ Π½Π΅ΠΎΠ±Ρ
ΠΎΠ΄ΠΈΠΌΠΎ Π½Π°Π»ΠΈΡΠΈΠ΅ Π½Π° ΡΡΠΎΠ»Π΅ ΠΊΠΎΡΠΎΠ»Ρ ΡΠ΅ΡΠ²Π΅ΠΉ. ΠΡΠ»ΠΈ ΠΈΠ³ΡΠΎΠΊ Π½Π΅ ΠΌΠΎΠΆΠ΅Ρ Π²ΡΠ»ΠΎΠΆΠΈΡΡ Π½Π° ΡΡΠΎΠ» Π½ΠΈ ΠΎΠ΄Π½Ρ ΠΊΠ°ΡΡΡ ΠΈΠ· ΡΠ²ΠΎΠ΅ΠΉ ΡΡΠΊΠΈ, ΡΠΎ Ρ
ΠΎΠ΄ ΠΏΠ΅ΡΠ΅Ρ
ΠΎΠ΄ΠΈΡ ΠΊ ΡΠΎΠΏΠ΅ΡΠ½ΠΈΠΊΡ. ΠΠ±ΡΠ°ΡΠΈΡΠ΅ Π²Π½ΠΈΠΌΠ°Π½ΠΈΠ΅: Π½Π΅Π»ΡΠ·Ρ ΠΏΡΠΎΠΏΡΡΡΠΈΡΡ Ρ
ΠΎΠ΄ ΠΏΡΠΎΡΡΠΎ ΡΠ°ΠΊxa0β Π²ΡΠ΅Π³Π΄Π° Π½Π΅ΠΎΠ±Ρ
ΠΎΠ΄ΠΈΠΌΠΎ Π²ΡΠ»ΠΎΠΆΠΈΡΡ ΠΊΠ°ΡΡΡ Π½Π° ΡΡΠΎΠ» ΠΊΠΎΡΡΠ΅ΠΊΡΠ½ΡΠΌ ΠΎΠ±ΡΠ°Π·ΠΎΠΌ, Π΅ΡΠ»ΠΈ ΡΡΠΎ Π²ΠΎΠ·ΠΌΠΎΠΆΠ½ΠΎ. ΠΠΎΠΌΠΈΠΌΠΎ ΡΠΎΠ³ΠΎ, ΡΡΠΎ ΠΊΠ°ΠΆΠ΄ΡΠΉ ΠΈΠ³ΡΠΎΠΊ ΡΡΡΠ΅ΠΌΠΈΡΡΡ ΠΈΠ·Π±Π°Π²ΠΈΡΡΡΡ ΠΎΡ ΠΊΠ°ΡΡ Π² ΡΠ²ΠΎΠ΅ΠΉ ΡΡΠΊΠ΅, ΠΠ»ΠΈΡΠ° ΠΈ ΠΠΎΠ± ΡΠ°ΠΊΠΆΠ΅ Ρ
ΠΎΡΡΡ, ΡΡΠΎΠ±Ρ Π² ΠΊΠΎΠ½ΡΠ΅ ΠΈΠ³ΡΡ Π² ΡΡΠΊΠ΅ Ρ ΠΈΡ
ΡΠΎΠΏΠ΅ΡΠ½ΠΈΠΊΠ° ΠΊΠ°ΡΡ ΠΎΡΡΠ°Π»ΠΎΡΡ ΠΊΠ°ΠΊ ΠΌΠΎΠΆΠ½ΠΎ Π±ΠΎΠ»ΡΡΠ΅, Π° Π² ΠΈΡ
ΡΡΠΊΠ΅xa0β ΠΊΠ°ΠΊ ΠΌΠΎΠΆΠ½ΠΎ ΠΌΠ΅Π½ΡΡΠ΅. ΠΠ°ΠΏΠΎΠΌΠ½ΠΈΠΌ, ΡΡΠΎ ΠΈΠ³ΡΠ° Π·Π°ΠΊΠ°Π½ΡΠΈΠ²Π°Π΅ΡΡΡ, ΠΊΠ°ΠΊ ΡΠΎΠ»ΡΠΊΠΎ ΠΎΠ΄ΠΈΠ½ ΠΈΠ· ΠΈΠ³ΡΠΎΠΊΠΎΠ² Π²ΡΠΊΠ»Π°Π΄ΡΠ²Π°Π΅Ρ Π½Π° ΡΡΠΎΠ» ΠΏΠΎΡΠ»Π΅Π΄Π½ΡΡ ΠΊΠ°ΡΡΡ ΠΈΠ· ΡΠ²ΠΎΠ΅ΠΉ ΡΡΠΊΠΈ. Π Π΅Π·ΡΠ»ΡΡΠ°ΡΠΎΠΌ ΠΈΠ³ΡΡ Π½Π°Π·ΠΎΠ²ΡΠΌ ΡΠΎΠ²ΠΎΠΊΡΠΏΠ½ΠΎΡΡΡ ΠΈΠ· ΠΈΠ½ΡΠΎΡΠΌΠ°ΡΠΈΠΈ ΠΎ ΡΠΎΠΌ, ΠΊΡΠΎ ΠΈΠ· Π΄Π²ΡΡ
ΠΈΠ³ΡΠΎΠΊΠΎΠ² Π²ΡΠΈΠ³ΡΠ°Π΅Ρ ΠΏΡΠΈ ΠΎΠΏΡΠΈΠΌΠ°Π»ΡΠ½ΠΎΠΉ ΠΈΠ³ΡΠ΅, Π° ΡΠ°ΠΊΠΆΠ΅ ΠΎ ΡΠΎΠΌ, ΡΠΊΠΎΠ»ΡΠΊΠΎ ΠΊΠ°ΡΡ ΠΎΡΡΠ°Π½Π΅ΡΡΡ Π² ΡΡΠΊΠ΅ Ρ ΠΏΡΠΎΠΈΠ³ΡΠ°Π²ΡΠ΅Π³ΠΎ. ΠΡΡΡΡ ΠΠ»ΠΈΡΠ° ΠΈ ΠΠΎΠ± ΡΠΆΠ΅ Π²Π·ΡΠ»ΠΈ Π² ΡΡΠΊΠΈ ΡΠ²ΠΎΠΈ $$$18$$$ ΠΊΠ°ΡΡ ΠΊΠ°ΠΆΠ΄ΡΠΉ, Π½ΠΎ Π΅ΡΡ Π½Π΅ ΡΠ΅ΡΠΈΠ»ΠΈ, ΠΊΡΠΎ ΠΈΠ· Π½ΠΈΡ
Π±ΡΠ΄Π΅Ρ Ρ
ΠΎΠ΄ΠΈΡΡ ΠΏΠ΅ΡΠ²ΡΠΌ. ΠΠ΅Π»ΠΈΡΠΈΠ½ΠΎΠΉ Π²Π°ΠΆΠ½ΠΎΡΡΠΈ ΠΏΠ΅ΡΠ²ΠΎΠ³ΠΎ Ρ
ΠΎΠ΄Π° Π΄Π»Ρ Π΄Π°Π½Π½ΠΎΠ³ΠΎ ΡΠ°ΡΠΊΠ»Π°Π΄Π° Π½Π°Π·ΠΎΠ²ΡΠΌ Π°Π±ΡΠΎΠ»ΡΡΠ½ΡΡ ΡΠ°Π·Π½ΠΎΡΡΡ ΠΌΠ΅ΠΆΠ΄Ρ ΡΠ΅Π·ΡΠ»ΡΡΠ°ΡΠ°ΠΌΠΈ ΠΈΠ³ΡΡ Π² ΡΠ»ΡΡΠ°Π΅, Π΅ΡΠ»ΠΈ ΠΏΠ΅ΡΠ²ΠΎΠΉ Π±ΡΠ΄Π΅Ρ Ρ
ΠΎΠ΄ΠΈΡΡ ΠΠ»ΠΈΡΠ°, ΠΈ Π² ΡΠ»ΡΡΠ°Π΅, Π΅ΡΠ»ΠΈ ΠΏΠ΅ΡΠ²ΡΠΌ Π±ΡΠ΄Π΅Ρ Ρ
ΠΎΠ΄ΠΈΡΡ ΠΠΎΠ±. ΠΠ°ΠΏΡΠΈΠΌΠ΅Ρ, Π΅ΡΠ»ΠΈ Π² ΠΎΠ±ΠΎΠΈΡ
ΡΠ»ΡΡΠ°ΡΡ
Π²ΡΠΈΠ³ΡΠ°Π΅Ρ ΠΠΎΠ±, Π½ΠΎ Π² ΠΎΠ΄Π½ΠΎΠΌ ΡΠ»ΡΡΠ°Π΅ Ρ ΠΠ»ΠΈΡΡ ΠΎΡΡΠ°Π½Π΅ΡΡΡ $$$6$$$ ΠΊΠ°ΡΡ Π² ΡΡΠΊΠ΅ Π² ΠΊΠΎΠ½ΡΠ΅ ΠΈΠ³ΡΡ, Π° Π²ΠΎ Π²ΡΠΎΡΠΎΠΌxa0β Π²ΡΠ΅Π³ΠΎ $$$2$$$, ΡΠΎ Π²Π΅Π»ΠΈΡΠΈΠ½Π° Π²Π°ΠΆΠ½ΠΎΡΡΠΈ ΠΏΠ΅ΡΠ²ΠΎΠ³ΠΎ Ρ
ΠΎΠ΄Π° ΡΠ°Π²Π½Π° $$$4$$$. ΠΡΠ»ΠΈ ΠΆΠ΅ Π² ΠΎΠ΄Π½ΠΎΠΌ ΡΠ»ΡΡΠ°Π΅ Π²ΡΠΈΠ³ΡΠ°Π΅Ρ ΠΠ»ΠΈΡΠ° ΠΈ Ρ ΠΠΎΠ±Π° ΠΎΡΡΠ°Π½Π΅ΡΡΡ $$$5$$$ ΠΊΠ°ΡΡ Π² ΡΡΠΊΠ΅, Π° Π²ΠΎ Π²ΡΠΎΡΠΎΠΌ ΡΠ»ΡΡΠ°Π΅ Π²ΡΠΈΠ³ΡΠ°Π΅Ρ ΠΠΎΠ± ΠΈ Ρ ΠΠ»ΠΈΡΡ ΠΎΡΡΠ°Π½Π΅ΡΡΡ $$$3$$$ ΠΊΠ°ΡΡΡ Π² ΡΡΠΊΠ΅, ΡΠΎ Π²Π΅Π»ΠΈΡΠΈΠ½Π° Π²Π°ΠΆΠ½ΠΎΡΡΠΈ ΠΏΠ΅ΡΠ²ΠΎΠ³ΠΎ Ρ
ΠΎΠ΄Π° ΡΠ°Π²Π½Π° $$$8$$$. Π Π΅Π±ΡΡΠ° Ρ
ΠΎΡΡΡ ΡΠ·Π½Π°ΡΡ, Π½Π°ΡΠΊΠΎΠ»ΡΠΊΠΎ ΡΠ°Π·Π½ΠΎΠΉ Π±ΡΠ²Π°Π΅Ρ Π²Π΅Π»ΠΈΡΠΈΠ½Π° Π²Π°ΠΆΠ½ΠΎΡΡΠΈ ΠΏΠ΅ΡΠ²ΠΎΠ³ΠΎ Ρ
ΠΎΠ΄Π° Π΄Π»Ρ ΡΠ°Π·Π½ΡΡ
ΡΠ°ΡΠΊΠ»Π°Π΄ΠΎΠ². ΠΠΎ Π·Π°Π΄Π°Π½Π½ΠΎΠΌΡ ΡΠΈΡΠ»Ρ $$$k le 13$$$ ΠΏΠΎΠΌΠΎΠ³ΠΈΡΠ΅ ΠΈΠΌ Π½Π°ΠΉΡΠΈ ΡΠ°ΠΊΠΈΠ΅ $$$k$$$ ΡΠ°ΡΠΊΠ»Π°Π΄ΠΎΠ², ΡΡΠΎ Π²Π΅Π»ΠΈΡΠΈΠ½Ρ Π²Π°ΠΆΠ½ΠΎΡΡΠΈ ΠΏΠ΅ΡΠ²ΠΎΠ³ΠΎ Ρ
ΠΎΠ΄Π° Π΄Π»Ρ Π²ΡΠ΅Ρ
Π½ΠΈΡ
xa0β ΡΠ°Π·Π»ΠΈΡΠ½ΡΠ΅ ΡΠ΅Π»ΡΠ΅ ΡΠΈΡΠ»Π°. ΠΡΡ
ΠΎΠ΄Π½ΡΠ΅ Π΄Π°Π½Π½ΡΠ΅ ΠΡΠ²Π΅Π΄ΠΈΡΠ΅ $$$k$$$ ΠΏΠ°Ρ ΡΡΡΠΎΠΊ. ΠΠ°ΠΆΠ΄Π°Ρ ΠΏΠ°ΡΠ° ΡΡΡΠΎΠΊ Π΄ΠΎΠ»ΠΆΠ½Π° ΡΠΎΠΎΡΠ²Π΅ΡΡΡΠ²ΠΎΠ²Π°ΡΡ Π½Π΅ΠΊΠΎΡΠΎΡΠΎΠΌΡ ΡΠ°ΡΠΊΠ»Π°Π΄Ρ. ΠΠ΅Π»ΠΈΡΠΈΠ½Ρ Π²Π°ΠΆΠ½ΠΎΡΡΠΈ ΠΏΠ΅ΡΠ²ΠΎΠ³ΠΎ Ρ
ΠΎΠ΄Π° Π΄Π»Ρ Π²ΡΠ΅Ρ
Π²ΡΠ²Π΅Π΄Π΅Π½Π½ΡΡ
ΡΠ°ΡΠΊΠ»Π°Π΄ΠΎΠ² Π΄ΠΎΠ»ΠΆΠ½Ρ Π±ΡΡΡ ΡΠ°Π·Π»ΠΈΡΠ½ΡΠΌΠΈ ΡΠ΅Π»ΡΠΌΠΈ ΡΠΈΡΠ»Π°ΠΌΠΈ. Π ΠΏΠ΅ΡΠ²ΠΎΠΉ ΡΡΡΠΎΠΊΠ΅ ΠΊΠ°ΠΆΠ΄ΠΎΠΉ ΠΏΠ°ΡΡ Π²ΡΠ²Π΅Π΄ΠΈΡΠ΅ $$$18$$$ ΡΡΡΠΎΠΊ Π΄Π»ΠΈΠ½Ρ $$$2$$$ ΡΠ΅ΡΠ΅Π· ΠΏΡΠΎΠ±Π΅Π», ΠΎΠΏΠΈΡΡΠ²Π°ΡΡΠΈΡ
ΠΊΠ°ΡΡΡ ΠΠ»ΠΈΡΡ Π² Π»ΡΠ±ΠΎΠΌ ΠΏΠΎΡΡΠ΄ΠΊΠ΅. ΠΠ΅ΡΠ²ΡΠΉ ΡΠΈΠΌΠ²ΠΎΠ» ΡΡΡΠΎΠΊΠΈ Π΄ΠΎΠ»ΠΆΠ΅Π½ ΠΎΠ±ΠΎΠ·Π½Π°ΡΠ°ΡΡ Π΄ΠΎΡΡΠΎΠΈΠ½ΡΡΠ²ΠΎ ΠΊΠ°ΡΡΡxa0β ΡΠΈΠΌΠ²ΠΎΠ» ΠΈΠ· Π½Π°Π±ΠΎΡΠ° 6, 7, 8, 9, T, J, Q, K, A, ΠΎΠ±ΠΎΠ·Π½Π°ΡΠ°ΡΡΠΈΠΉ ΡΠ΅ΡΡΡΡΠΊΡ, ΡΠ΅ΠΌΡΡΠΊΡ, Π²ΠΎΡΡΠΌΡΡΠΊΡ, Π΄Π΅Π²ΡΡΠΊΡ, Π΄Π΅ΡΡΡΠΊΡ, Π²Π°Π»Π΅ΡΠ°, Π΄Π°ΠΌΡ, ΠΊΠΎΡΠΎΠ»Ρ ΠΈ ΡΡΠ·Π° ΡΠΎΠΎΡΠ²Π΅ΡΡΡΠ²Π΅Π½Π½ΠΎ. ΠΡΠΎΡΠΎΠΉ ΡΠΈΠΌΠ²ΠΎΠ» ΡΡΡΠΎΠΊΠΈ Π΄ΠΎΠ»ΠΆΠ΅Π½ ΠΎΠ±ΠΎΠ·Π½Π°ΡΠ°ΡΡ ΠΌΠ°ΡΡΡ ΠΊΠ°ΡΡΡxa0β ΡΠΈΠΌΠ²ΠΎΠ» ΠΈΠ· Π½Π°Π±ΠΎΡΠ° C, D, S, H, ΠΎΠ±ΠΎΠ·Π½Π°ΡΠ°ΡΡΠΈΠΉ ΡΡΠ΅ΡΡ, Π±ΡΠ±Π½Ρ, ΠΏΠΈΠΊΠΈ ΠΈ ΡΠ΅ΡΠ²ΠΈ ΡΠΎΠΎΡΠ²Π΅ΡΡΡΠ²Π΅Π½Π½ΠΎ. ΠΠΎ Π²ΡΠΎΡΠΎΠΉ ΡΡΡΠΎΠΊΠ΅ Π²ΡΠ²Π΅Π΄ΠΈΡΠ΅ $$$18$$$ ΡΡΡΠΎΠΊ Π΄Π»ΠΈΠ½Ρ $$$2$$$ ΡΠ΅ΡΠ΅Π· ΠΏΡΠΎΠ±Π΅Π», ΠΎΠΏΠΈΡΡΠ²Π°ΡΡΠΈΡ
ΠΊΠ°ΡΡΡ ΠΠΎΠ±Π° Π² ΡΠΎΠΌ ΠΆΠ΅ ΡΠΎΡΠΌΠ°ΡΠ΅. ΠΠ°ΠΆΠ΄Π°Ρ ΠΈΠ· $$$36$$$ Π²ΠΎΠ·ΠΌΠΎΠΆΠ½ΡΡ
ΠΊΠ°ΡΡ Π΄ΠΎΠ»ΠΆΠ½Π° Π½Π°Ρ
ΠΎΠ΄ΠΈΡΡΡΡ Π² ΡΡΠΊΠ΅ ΠΎΠ΄Π½ΠΎΠ³ΠΎ ΠΈΠ· Π΄Π²ΡΡ
ΠΈΠ³ΡΠΎΠΊΠΎΠ² Π² Π΅Π΄ΠΈΠ½ΡΡΠ²Π΅Π½Π½ΠΎΠΌ ΡΠΊΠ·Π΅ΠΌΠΏΠ»ΡΡΠ΅. ΠΡΠΈΠΌΠ΅ΡΠ°Π½ΠΈΠ΅ Π ΠΏΠ΅ΡΠ²ΠΎΠΌ Π²ΡΠ²Π΅Π΄Π΅Π½Π½ΠΎΠΌ ΡΠ°ΡΠΊΠ»Π°Π΄Π΅ Π²ΡΠ΅ Π΄Π΅Π²ΡΡΠΊΠΈ Π½Π°Ρ
ΠΎΠ΄ΡΡΡΡ Π² ΡΡΠΊΠ΅ Ρ ΠΠ»ΠΈΡΡ. ΠΠ°ΠΆΠ΅ Π΅ΡΠ»ΠΈ ΠΠΎΠ± Π±ΡΠ΄Π΅Ρ Ρ
ΠΎΠ΄ΠΈΡΡ ΠΏΠ΅ΡΠ²ΡΠΌ, Π΅ΠΌΡ Π²ΡΡ ΡΠ°Π²Π½ΠΎ ΠΏΡΠΈΠ΄ΡΡΡΡ ΠΏΡΠΎΠΏΡΡΡΠΈΡΡ ΠΏΠ΅ΡΠ²ΡΠΉ ΠΆΠ΅ ΡΠ²ΠΎΠΉ Ρ
ΠΎΠ΄. Π‘Π»Π΅Π΄ΠΎΠ²Π°ΡΠ΅Π»ΡΠ½ΠΎ, ΠΏΠ΅ΡΠ²ΡΠΉ Ρ
ΠΎΠ΄ ΠΏΡΠΈ ΡΠ°ΠΊΠΎΠΌ ΡΠ°ΡΠΊΠ»Π°Π΄Π΅ ΠΈΠΌΠ΅Π΅Ρ Π²Π°ΠΆΠ½ΠΎΡΡΡ $$$0$$$. ΠΠΎ Π²ΡΠΎΡΠΎΠΌ Π²ΡΠ²Π΅Π΄Π΅Π½Π½ΠΎΠΌ ΡΠ°ΡΠΊΠ»Π°Π΄Π΅ Π²Π½Π΅ Π·Π°Π²ΠΈΡΠΈΠΌΠΎΡΡΠΈ ΠΎΡ ΡΠΎΠ³ΠΎ, ΡΡΠΈΠΌ Π±ΡΠ΄Π΅Ρ ΠΏΠ΅ΡΠ²ΡΠΉ Ρ
ΠΎΠ΄, Π²ΡΠΈΠ³ΡΠ°Π΅Ρ ΠΠ»ΠΈΡΠ°. ΠΠ΄Π½Π°ΠΊΠΎ Π΅ΡΠ»ΠΈ ΠΠ»ΠΈΡΠ° Π±ΡΠ΄Π΅Ρ Ρ
ΠΎΠ΄ΠΈΡΡ ΠΏΠ΅ΡΠ²ΠΎΠΉ, ΡΠΎ Ρ ΠΠΎΠ±Π° Π² ΠΊΠΎΠ½ΡΠ΅ ΠΈΠ³ΡΡ Π² ΡΡΠΊΠ΅ ΠΎΡΡΠ°Π½Π΅ΡΡΡ ΠΎΠ΄Π½Π° ΠΊΠ°ΡΡΠ°, Π° Π΅ΡΠ»ΠΈ ΠΆΠ΅ ΠΎΠ½Π° Π±ΡΠ΄Π΅Ρ Ρ
ΠΎΠ΄ΠΈΡΡ Π²ΡΠΎΡΠΎΠΉ, ΡΠΎ Ρ ΠΠΎΠ±Π° ΠΎΡΡΠ°Π½Π΅ΡΡΡ ΠΏΡΡΡ ΠΊΠ°ΡΡ. Π‘ΠΎΠΎΡΠ²Π΅ΡΡΡΠ²Π΅Π½Π½ΠΎ, Π²Π΅Π»ΠΈΡΠΈΠ½Π° Π²Π°ΠΆΠ½ΠΎΡΡΠΈ ΠΏΠ΅ΡΠ²ΠΎΠ³ΠΎ Ρ
ΠΎΠ΄Π° ΠΏΡΠΈ ΡΠ°ΠΊΠΎΠΌ ΡΠ°ΡΠΊΠ»Π°Π΄Π΅ ΡΠ°Π²Π½Π° $$$4$$$. | 2,200 | false | false | false | false | false | false | true | false | false | false | 1,679 |
1266E | Bob is playing a game of Spaceship Solitaire. The goal of this game is to build a spaceship. In order to do this, he first needs to accumulate enough resources for the construction. There are $$$n$$$ types of resources, numbered $$$1$$$ through $$$n$$$. Bob needs at least $$$a_i$$$ pieces of the $$$i$$$-th resource to build the spaceship. The number $$$a_i$$$ is called the goal for resource $$$i$$$. Each resource takes $$$1$$$ turn to produce and in each turn only one resource can be produced. However, there are certain milestones that speed up production. Every milestone is a triple $$$(s_j, t_j, u_j)$$$, meaning that as soon as Bob has $$$t_j$$$ units of the resource $$$s_j$$$, he receives one unit of the resource $$$u_j$$$ for free, without him needing to spend a turn. It is possible that getting this free resource allows Bob to claim reward for another milestone. This way, he can obtain a large number of resources in a single turn. The game is constructed in such a way that there are never two milestones that have the same $$$s_j$$$ and $$$t_j$$$, that is, the award for reaching $$$t_j$$$ units of resource $$$s_j$$$ is at most one additional resource. A bonus is never awarded for $$$0$$$ of any resource, neither for reaching the goal $$$a_i$$$ nor for going past the goal β formally, for every milestone $$$0 < t_j < a_{s_j}$$$. A bonus for reaching certain amount of a resource can be the resource itself, that is, $$$s_j = u_j$$$. Initially there are no milestones. You are to process $$$q$$$ updates, each of which adds, removes or modifies a milestone. After every update, output the minimum number of turns needed to finish the game, that is, to accumulate at least $$$a_i$$$ of $$$i$$$-th resource for each $$$i in [1, n]$$$. Input The first line contains a single integer $$$n$$$ ($$$1 leq n leq 2 cdot 10^5$$$)xa0β the number of types of resources. The second line contains $$$n$$$ space separated integers $$$a_1, a_2, dots, a_n$$$ ($$$1 leq a_i leq 10^9$$$), the $$$i$$$-th of which is the goal for the $$$i$$$-th resource. The third line contains a single integer $$$q$$$ ($$$1 leq q leq 10^5$$$)xa0β the number of updates to the game milestones. Then $$$q$$$ lines follow, the $$$j$$$-th of which contains three space separated integers $$$s_j$$$, $$$t_j$$$, $$$u_j$$$ ($$$1 leq s_j leq n$$$, $$$1 leq t_j < a_{s_j}$$$, $$$0 leq u_j leq n$$$). For each triple, perform the following actions: First, if there is already a milestone for obtaining $$$t_j$$$ units of resource $$$s_j$$$, it is removed. If $$$u_j = 0$$$, no new milestone is added. If $$$u_j eq 0$$$, add the following milestone: "For reaching $$$t_j$$$ units of resource $$$s_j$$$, gain one free piece of $$$u_j$$$." Output the minimum number of turns needed to win the game. Output Output $$$q$$$ lines, each consisting of a single integer, the $$$i$$$-th represents the answer after the $$$i$$$-th update. Example Input 2 2 3 5 2 1 1 2 2 1 1 1 1 2 1 2 2 2 0 Note After the first update, the optimal strategy is as follows. First produce $$$2$$$ once, which gives a free resource $$$1$$$. Then, produce $$$2$$$ twice and $$$1$$$ once, for a total of four turns. After the second update, the optimal strategy is to produce $$$2$$$ three times β the first two times a single unit of resource $$$1$$$ is also granted. After the third update, the game is won as follows. First produce $$$2$$$ once. This gives a free unit of $$$1$$$. This gives additional bonus of resource $$$1$$$. After the first turn, the number of resources is thus $$$[2, 1]$$$. Next, produce resource $$$2$$$ again, which gives another unit of $$$1$$$. After this, produce one more unit of $$$2$$$. The final count of resources is $$$[3, 3]$$$, and three turns are needed to reach this situation. Notice that we have more of resource $$$1$$$ than its goal, which is of no use. | 2,100 | false | true | true | false | true | false | false | false | false | false | 4,367 |
1648A | Egor has a table of size $$$n imes m$$$, with lines numbered from $$$1$$$ to $$$n$$$ and columns numbered from $$$1$$$ to $$$m$$$. Each cell has a color that can be presented as an integer from $$$1$$$ to $$$10^5$$$. Let us denote the cell that lies in the intersection of the $$$r$$$-th row and the $$$c$$$-th column as $$$(r, c)$$$. We define the manhattan distance between two cells $$$(r_1, c_1)$$$ and $$$(r_2, c_2)$$$ as the length of a shortest path between them where each consecutive cells in the path must have a common side. The path can go through cells of any color. For example, in the table $$$3 imes 4$$$ the manhattan distance between $$$(1, 2)$$$ and $$$(3, 3)$$$ is $$$3$$$, one of the shortest paths is the following: $$$(1, 2) o (2, 2) o (2, 3) o (3, 3)$$$. Egor decided to calculate the sum of manhattan distances between each pair of cells of the same color. Help him to calculate this sum. Input The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 leq n le m$$$, $$$n cdot m leq 100,000$$$)xa0β number of rows and columns in the table. Each of next $$$n$$$ lines describes a row of the table. The $$$i$$$-th line contains $$$m$$$ integers $$$c_{i1}, c_{i2}, ldots, c_{im}$$$ ($$$1 le c_{ij} le 100,000$$$)xa0β colors of cells in the $$$i$$$-th row. Output Print one integerxa0β the the sum of manhattan distances between each pair of cells of the same color. Examples Input 3 4 1 1 2 2 2 1 1 2 2 2 1 1 Input 4 4 1 1 2 3 2 1 1 2 3 1 2 1 1 1 2 1 Note In the first sample there are three pairs of cells of same color: in cells $$$(1, 1)$$$ and $$$(2, 3)$$$, in cells $$$(1, 2)$$$ and $$$(2, 2)$$$, in cells $$$(1, 3)$$$ and $$$(2, 1)$$$. The manhattan distances between them are $$$3$$$, $$$1$$$ and $$$3$$$, the sum is $$$7$$$. | 1,400 | true | false | false | false | true | false | false | false | true | false | 2,383 |
1657F | You are given a tree consisting of $$$n$$$ vertices, and $$$q$$$ triples $$$(x_i, y_i, s_i)$$$, where $$$x_i$$$ and $$$y_i$$$ are integers from $$$1$$$ to $$$n$$$, and $$$s_i$$$ is a string with length equal to the number of vertices on the simple path from $$$x_i$$$ to $$$y_i$$$. You want to write a lowercase Latin letter on each vertex in such a way that, for each of $$$q$$$ given triples, at least one of the following conditions holds: if you write out the letters on the vertices on the simple path from $$$x_i$$$ to $$$y_i$$$ in the order they appear on this path, you get the string $$$s_i$$$; if you write out the letters on the vertices on the simple path from $$$y_i$$$ to $$$x_i$$$ in the order they appear on this path, you get the string $$$s_i$$$. Find any possible way to write a letter on each vertex to meet these constraints, or report that it is impossible. Input The first line contains two integers $$$n$$$ and $$$q$$$ ($$$2 le n le 4 cdot 10^5$$$; $$$1 le q le 4 cdot 10^5$$$) β the number of vertices in the tree and the number of triples, respectively. Then $$$n - 1$$$ lines follow; the $$$i$$$-th of them contains two integers $$$u_i$$$ and $$$v_i$$$ ($$$1 le u_i, v_i le n$$$; $$$u_i e v_i$$$) β the endpoints of the $$$i$$$-th edge. These edges form a tree. Then $$$q$$$ lines follow; the $$$j$$$-th of them contains two integers $$$x_j$$$ and $$$y_j$$$, and a string $$$s_j$$$ consisting of lowercase Latin letters. The length of $$$s_j$$$ is equal to the number of vertices on the simple path between $$$x_j$$$ and $$$y_j$$$. Additional constraint on the input: $$$sum limits_{j=1}^{q} s_j le 4 cdot 10^5$$$. Output If there is no way to meet the conditions on all triples, print NO. Otherwise, print YES in the first line, and a string of $$$n$$$ lowercase Latin letters in the second line; the $$$i$$$-th character of the string should be the letter you write on the $$$i$$$-th vertex. If there are multiple answers, print any of them. Examples Input 3 2 2 3 2 1 2 1 ab 2 3 bc Input 3 2 2 3 2 1 2 1 ab 2 3 cd Input 10 10 1 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 1 10 1 2 ab 1 3 ab 1 4 ab 1 5 ab 1 6 ab 1 7 ab 1 8 ab 1 9 ab 1 10 ab 10 2 aba Input 10 10 1 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 1 10 1 2 ab 1 3 ab 1 4 aa 1 5 ab 1 6 ab 1 7 ab 1 8 ab 1 9 ab 1 10 ab 10 2 aba | 2,600 | false | false | false | false | false | false | false | false | false | true | 2,340 |
2013E | Since Mansur is tired of making legends, there will be no legends for this task. You are given an array of positive integer numbers $$$a_1, a_2, ldots, a_n$$$. The elements of the array can be rearranged in any order. You need to find the smallest possible value of the expression $$$$$$gcd(a_1) + gcd(a_1, a_2) + ldots + gcd(a_1, a_2, ldots, a_n),$$$$$$ where $$$gcd(a_1, a_2, ldots, a_n)$$$ denotes the . The description of the test cases follows. The first line of each test case contains a single number $$$n$$$ ($$$1 le n le 10^5$$$)xa0β the size of the array. The second line of each test case contains $$$n$$$ numbers $$$a_1, a_2, ldots, a_n$$$ ($$$1 le a_i le 10^5$$$)xa0β the initial array. The sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$. The sum of $$$max(a_1, a_2, ldots, a_n)$$$ over all test cases does not exceed $$$10^5$$$. Output For each test case, output a single number on a separate linexa0β the answer to the problem. Example Input 5 3 4 2 2 2 6 3 3 10 15 6 5 6 42 12 52 20 4 42 154 231 66 Note In the first test case, the elements can be rearranged as follows: $$$[2, 4, 2]$$$. Then the answer will be $$$gcd(2) + gcd(2, 4) + gcd(2, 4, 2) = 2 + 2 + 2 = 6$$$. In the third test case, the elements can be rearranged as follows: $$$[6, 10, 15]$$$. Then the answer will be $$$gcd(6) + gcd(6, 10) + gcd(6, 10, 15) = 6 + 2 + 1 = 9$$$. | 2,200 | true | true | false | true | false | false | true | false | false | false | 174 |
453C | Twilight Sparkle learnt that the evil Nightmare Moon would return during the upcoming Summer Sun Celebration after one thousand years of imprisonment on the moon. She tried to warn her mentor Princess Celestia, but the princess ignored her and sent her to Ponyville to check on the preparations for the celebration. Twilight Sparkle wanted to track the path of Nightmare Moon. Unfortunately, she didn't know the exact path. What she knew is the parity of the number of times that each place Nightmare Moon visited. Can you help Twilight Sparkle to restore any path that is consistent with this information? Ponyville can be represented as an undirected graph (vertices are places, edges are roads between places) without self-loops and multi-edges. The path can start and end at any place (also it can be empty). Each place can be visited multiple times. The path must not visit more than 4_n_ places. Input The first line contains two integers _n_ and _m_ (2u2009β€u2009_n_u2009β€u2009105;xa00u2009β€u2009_m_u2009β€u2009105) β the number of places and the number of roads in Ponyville. Each of the following _m_ lines contains two integers _u__i_,u2009_v__i_ (1u2009β€u2009_u__i_,u2009_v__i_u2009β€u2009_n_;xa0_u__i_u2009β u2009_v__i_), these integers describe a road between places _u__i_ and _v__i_. The next line contains _n_ integers: _x_1,u2009_x_2,u2009...,u2009_x__n_ (0u2009β€u2009_x__i_u2009β€u20091) β the parity of the number of times that each place must be visited. If _x__i_u2009=u20090, then the _i_-th place must be visited even number of times, else it must be visited odd number of times. Output Output the number of visited places _k_ in the first line (0u2009β€u2009_k_u2009β€u20094_n_). Then output _k_ integers β the numbers of places in the order of path. If _x__i_u2009=u20090, then the _i_-th place must appear in the path even number of times, else _i_-th place must appear in the path odd number of times. Note, that given road system has no self-loops, therefore any two neighbouring places in the path must be distinct. If there is no required path, output -1. If there multiple possible paths, you can output any of them. Examples Input 5 7 1 2 1 3 1 4 1 5 3 4 3 5 4 5 0 1 0 1 0 Output 10 2 1 3 4 5 4 5 4 3 1 | 2,200 | false | false | false | false | false | true | false | false | false | true | 8,024 |
2021E3 | This is the extreme version of the problem. In the three versions, the constraints on $$$n$$$ and $$$m$$$ are different. You can make hacks only if all the versions of the problem are solved. Pak Chanek is setting up internet connections for the village of Khuntien. The village can be represented as a connected simple graph with $$$n$$$ houses and $$$m$$$ internet cables connecting house $$$u_i$$$ and house $$$v_i$$$, each with a latency of $$$w_i$$$. There are $$$p$$$ houses that require internet. Pak Chanek can install servers in at most $$$k$$$ of the houses. The houses that need internet will then be connected to one of the servers. However, since each cable has its latency, the latency experienced by house $$$s_i$$$ requiring internet will be the maximum latency of the cables between that house and the server it is connected to. For each $$$k = 1,2,ldots,n$$$, help Pak Chanek determine the minimum total latency that can be achieved for all the houses requiring internet. Input Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 le t le 10^4$$$). The description of the test cases follows. The first line of each test case contains 3 integers $$$n$$$, $$$m$$$, $$$p$$$ ($$$2 le n le 2 cdot 10^5$$$; $$$n-1 le m le 2 cdot 10^5$$$; $$$1 le p le n$$$)xa0β the number of houses, the number of cables, and the number of houses that need internet. The second line of each test case contains $$$p$$$ integers $$$s_1, s_2, ldots, s_p$$$ ($$$1 le s_i le n$$$)xa0β the houses that need internet. It is guaranteed that all elements of $$$s$$$ are distinct. The $$$i$$$-th of the next $$$m$$$ lines of each test case contains three integers $$$u_i$$$, $$$v_i$$$, and $$$w_i$$$ ($$$1 le u_i < v_i le n$$$; $$$1 le w_i le 10^9$$$)xa0β the internet cable connecting house $$$u_i$$$ and house $$$v_i$$$ with latency of $$$w_i$$$. It is guaranteed that the given edges form a connected simple graph. It is guaranteed that the sum of $$$n$$$ and the sum of $$$m$$$ do not exceed $$$2 cdot 10^5$$$. Output For each test case, output $$$n$$$ integers: the minimum total latency that can be achieved for all the houses requiring internet for each $$$k = 1,2,ldots,n$$$. Example Input 2 9 8 5 2 5 6 8 9 1 2 1 1 3 2 3 4 10 4 5 3 4 6 5 1 7 10 7 8 4 7 9 2 3 3 2 3 1 1 2 1 2 3 3 1 3 2 Output 34 19 9 4 0 0 0 0 0 2 0 0 Note In the first test case for $$$k=3$$$, a possible optimal solution is to install servers at vertices $$$2$$$, $$$6$$$ and $$$8$$$ and obtain the following latency: $$$ ext{latency}(2) = 0$$$ $$$ ext{latency}(5) = max(3, 5) = 5$$$ $$$ ext{latency}(6) = 0$$$ $$$ ext{latency}(8) = 0$$$ $$$ ext{latency}(9) = max(2, 4) = 4$$$ So the total latency is $$$9$$$. | 2,800 | true | true | false | true | true | false | false | false | false | true | 139 |
1914A | Monocarp is participating in a programming contest, which features $$$26$$$ problems, named from 'A' to 'Z'. The problems are sorted by difficulty. Moreover, it's known that Monocarp can solve problem 'A' in $$$1$$$ minute, problem 'B' in $$$2$$$ minutes, ..., problem 'Z' in $$$26$$$ minutes. After the contest, you discovered his contest logxa0β a string, consisting of uppercase Latin letters, such that the $$$i$$$-th letter tells which problem Monocarp was solving during the $$$i$$$-th minute of the contest. If Monocarp had spent enough time in total on a problem to solve it, he solved it. Note that Monocarp could have been thinking about a problem after solving it. Given Monocarp's contest log, calculate the number of problems he solved during the contest. Input The first line contains a single integer $$$t$$$ ($$$1 le t le 100$$$)xa0β the number of testcases. The first line of each testcase contains a single integer $$$n$$$ ($$$1 le n le 500$$$)xa0β the duration of the contest, in minutes. The second line contains a string of length exactly $$$n$$$, consisting only of uppercase Latin letters,xa0β Monocarp's contest log. Output For each testcase, print a single integerxa0β the number of problems Monocarp solved during the contest. Example Input 3 6 ACBCBC 7 AAAAFPC 22 FEADBBDFFEDFFFDHHHADCC | 800 | false | false | true | false | false | false | false | false | false | false | 819 |
56D | There is a string _s_, consisting of capital Latin letters. Let's denote its current length as _s_. During one move it is allowed to apply one of the following operations to it: INSERT _pos_ _ch_ β insert a letter _ch_ in the string _s_ in the position _pos_ (1u2009β€u2009_pos_u2009β€u2009_s_u2009+u20091,u2009_A_u2009β€u2009_ch_u2009β€u2009_Z_). The letter _ch_ becomes the _pos_-th symbol of the string _s_, at that the letters shift aside and the length of the string increases by 1. DELETE _pos_ β delete a character number _pos_ (1u2009β€u2009_pos_u2009β€u2009_s_) from the string _s_. At that the letters shift together and the length of the string decreases by 1. REPLACE _pos_ _ch_ β the letter in the position _pos_ of the line _s_ is replaced by _ch_ (1u2009β€u2009_pos_u2009β€u2009_s_,u2009_A_u2009β€u2009_ch_u2009β€u2009_Z_). At that the length of the string does not change. Your task is to find in which minimal number of moves one can get a _t_ string from an _s_ string. You should also find the sequence of actions leading to the required results. Input The first line contains _s_, the second line contains _t_. The lines consist only of capital Latin letters, their lengths are positive numbers from 1 to 1000. Output In the first line print the number of moves _k_ in the given sequence of operations. The number should be the minimal possible one. Then print _k_ lines containing one operation each. Print the operations in the format, described above. If there are several solutions, print any of them. Examples Output 2 INSERT 3 B INSERT 4 B Output 10 REPLACE 1 W REPLACE 2 R REPLACE 3 O REPLACE 4 N REPLACE 5 G REPLACE 6 A INSERT 7 N INSERT 8 S INSERT 9 W REPLACE 11 R | 2,100 | false | false | false | true | false | false | false | false | false | false | 9,692 |
1811F | Vlad found a flowerbed with graphs in his yard and decided to take one for himself. Later he found out that in addition to the usual graphs, $$$k$$$-flowers also grew on that flowerbed. A graph is called a $$$k$$$-flower if it consists of a simple cycle of length $$$k$$$, through each vertex of which passes its own simple cycle of length $$$k$$$ and these cycles do not intersect at the vertices. For example, $$$3$$$-flower looks like this: Note that $$$1$$$-flower and $$$2$$$-flower do not exist, since at least $$$3$$$ vertices are needed to form a cycle. Vlad really liked the structure of the $$$k$$$-flowers and now he wants to find out if he was lucky to take one of them from the flowerbed. Input The first line of input contains the single integer $$$t$$$ ($$$1 le t le 10^4$$$)xa0β the number of test cases in the test. The descriptions of the cases follow. An empty string is written before each case. The first line of each case contains two integers $$$n$$$ and $$$m$$$ ($$$2 le n le 2 cdot 10^5$$$, $$$1 le m le min(2 cdot 10^5, frac{n cdot (n-1)}{2})$$$) β the number of vertices and edges in the graph, respectively. The next $$$m$$$ lines contain two integers each $$$u$$$ and $$$v$$$ ($$$1 le u, v le n$$$, $$$u e v$$$) β numbers of vertices connected by an edge. It is guaranteed that the graph does not contain multiple edges and self-loops. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$2 cdot 10^5$$$. It is also guaranteed for the sum of $$$m$$$ over all test cases. Output Output $$$t$$$ lines, each of which is the answer to the corresponding test case. As an answer, output "YES" if Vlad's graph is a $$$k$$$-flower for some $$$k$$$, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer). Examples Input 5 9 12 1 2 3 1 2 3 1 6 4 1 6 4 3 8 3 5 5 8 9 7 2 9 7 2 8 12 1 2 3 1 2 3 1 6 4 1 6 4 3 8 3 5 5 8 8 7 2 8 7 2 4 3 1 2 4 2 3 1 6 8 6 3 6 4 5 3 5 2 3 2 3 1 2 1 2 4 5 7 2 4 2 5 3 4 3 5 4 1 4 5 1 5 Input 4 2 1 1 2 8 9 1 2 8 4 8 2 6 4 6 5 4 7 3 2 3 7 2 5 9 12 2 9 2 8 6 9 6 8 6 5 6 1 9 8 9 3 9 1 8 3 8 7 5 7 3 3 1 2 1 3 2 3 | 2,100 | false | false | true | false | false | false | false | false | false | true | 1,400 |
1832D1 | The only difference between easy and hard versions is the maximum values of $$$n$$$ and $$$q$$$. You are given an array, consisting of $$$n$$$ integers. Initially, all elements are red. You can apply the following operation to the array multiple times. During the $$$i$$$-th operation, you select an element of the array; then: if the element is red, it increases by $$$i$$$ and becomes blue; if the element is blue, it decreases by $$$i$$$ and becomes red. The operations are numbered from $$$1$$$, i.u2009e. during the first operation some element is changed by $$$1$$$ and so on. You are asked $$$q$$$ queries of the following form: given an integer $$$k$$$, what can the largest minimum in the array be if you apply exactly $$$k$$$ operations to it? Note that the operations don't affect the array between queries, all queries are asked on the initial array $$$a$$$. Input The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 le n, q le 1000$$$)xa0β the number of elements in the array and the number of queries. The second line contains $$$n$$$ integers $$$a_1, a_2, dots, a_n$$$ ($$$1 le a_i le 10^9$$$). The third line contains $$$q$$$ integers $$$k_1, k_2, dots, k_q$$$ ($$$1 le k_j le 10^9$$$). Output For each query, print a single integerxa0β the largest minimum that the array can have after you apply exactly $$$k$$$ operations to it. Examples Input 4 10 5 2 8 4 1 2 3 4 5 6 7 8 9 10 Output 3 4 5 6 7 8 8 10 8 12 Input 5 10 5 2 8 4 4 1 2 3 4 5 6 7 8 9 10 Output 3 4 5 6 7 8 9 8 11 8 | 2,100 | true | true | true | false | false | false | false | true | false | false | 1,295 |
1637C | Andrew has $$$n$$$ piles with stones. The $$$i$$$-th pile contains $$$a_i$$$ stones. He wants to make his table clean so he decided to put every stone either to the $$$1$$$-st or the $$$n$$$-th pile. Andrew can perform the following operation any number of times: choose $$$3$$$ indices $$$1 le i < j < k le n$$$, such that the $$$j$$$-th pile contains at least $$$2$$$ stones, then he takes $$$2$$$ stones from the pile $$$j$$$ and puts one stone into pile $$$i$$$ and one stone into pile $$$k$$$. Tell Andrew what is the minimum number of operations needed to move all the stones to piles $$$1$$$ and $$$n$$$, or determine if it's impossible. Input The input contains several test cases. The first line contains one integer $$$t$$$ ($$$1 leq t leq 10,000$$$)xa0β the number of test cases. The first line for each test case contains one integer $$$n$$$ ($$$3 leq n leq 10^5$$$)xa0β the length of the array. The second line contains a sequence of integers $$$a_1, a_2, ldots, a_n$$$ ($$$1 leq a_i leq 10^9$$$)xa0β the array elements. It is guaranteed that the sum of the values $$$n$$$ over all test cases does not exceed $$$10^5$$$. Output For each test case print the minimum number of operations needed to move stones to piles $$$1$$$ and $$$n$$$, or print $$$-1$$$ if it's impossible. Example Input 4 5 1 2 2 3 6 3 1 3 1 3 1 2 1 4 3 1 1 2 Note In the first test case, it is optimal to do the following: 1. Select $$$(i, j, k) = (1, 2, 5)$$$. The array becomes equal to $$$[2, 0, 2, 3, 7]$$$. 2. Select $$$(i, j, k) = (1, 3, 4)$$$. The array becomes equal to $$$[3, 0, 0, 4, 7]$$$. 3. Twice select $$$(i, j, k) = (1, 4, 5)$$$. The array becomes equal to $$$[5, 0, 0, 0, 9]$$$. This array satisfy the statement, because every stone is moved to piles $$$1$$$ and $$$5$$$. There are $$$4$$$ operations in total. In the second test case, it's impossible to put all stones into piles with numbers $$$1$$$ and $$$3$$$: 1. At the beginning there's only one possible operation with $$$(i, j, k) = (1, 2, 3)$$$. The array becomes equal to $$$[2, 1, 2]$$$. 2. Now there is no possible operation and the array doesn't satisfy the statement, so the answer is $$$-1$$$. In the third test case, it's optimal to do the following: 1. Select $$$(i, j, k) = (1, 2, 3)$$$. The array becomes equal to $$$[2, 0, 2]$$$. This array satisfies the statement, because every stone is moved to piles $$$1$$$ and $$$3$$$. The is $$$1$$$ operation in total. In the fourth test case, it's impossible to do any operation, and the array doesn't satisfy the statement, so the answer is $$$-1$$$. | 1,200 | false | true | true | false | false | false | false | false | false | false | 2,432 |
948A | Bob is a farmer. He has a large pasture with many sheep. Recently, he has lost some of them due to wolf attacks. He thus decided to place some shepherd dogs in such a way that all his sheep are protected. The pasture is a rectangle consisting of _R_u2009Γu2009_C_ cells. Each cell is either empty, contains a sheep, a wolf or a dog. Sheep and dogs always stay in place, but wolves can roam freely around the pasture, by repeatedly moving to the left, right, up or down to a neighboring cell. When a wolf enters a cell with a sheep, it consumes it. However, no wolf can enter a cell with a dog. Initially there are no dogs. Place dogs onto the pasture in such a way that no wolf can reach any sheep, or determine that it is impossible. Note that since you have many dogs, you do not need to minimize their number. Input First line contains two integers _R_ (1u2009β€u2009_R_u2009β€u2009500) and _C_ (1u2009β€u2009_C_u2009β€u2009500), denoting the number of rows and the numbers of columns respectively. Each of the following _R_ lines is a string consisting of exactly _C_ characters, representing one row of the pasture. Here, 'S' means a sheep, 'W' a wolf and '.' an empty cell. Output If it is impossible to protect all sheep, output a single line with the word "No". Otherwise, output a line with the word "Yes". Then print _R_ lines, representing the pasture after placing dogs. Again, 'S' means a sheep, 'W' a wolf, 'D' is a dog and '.' an empty space. You are not allowed to move, remove or add a sheep or a wolf. If there are multiple solutions, you may print any of them. You don't have to minimize the number of dogs. Examples Input 6 6 ..S... ..S.W. .S.... ..W... ...W.. ...... Output Yes ..SD.. ..SDW. .SD... .DW... DD.W.. ...... Input 5 5 .S... ...S. S.... ...S. .S... Output Yes .S... ...S. S.D.. ...S. .S... Note In the first example, we can split the pasture into two halves, one containing wolves and one containing sheep. Note that the sheep at (2,1) is safe, as wolves cannot move diagonally. In the second example, there are no empty spots to put dogs that would guard the lone sheep. In the third example, there are no wolves, so the task is very easy. We put a dog in the center to observe the peacefulness of the meadow, but the solution would be correct even without him. | 900 | false | false | true | false | false | false | true | false | false | true | 5,925 |
1513F | Problem - 1513F - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags brute force constructive algorithms data structures sortings *2500 No tag edit access β Contest materials ") Editorial") , and you are required to minimize the value $$$$$$sum_{i}a_{i}-b_{i}.$$$$$$ Find the minimum possible value of this sum. Input The first line contains a single integer $$$n$$$ ($$$1 le n le 2 cdot 10^5$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$1 le a_i le {10^9}$$$). The third line contains $$$n$$$ integers $$$b_1, b_2, ldots, b_n$$$ ($$$1 le b_i le {10^9}$$$). Output Output the minimum value of $$$sum_{i}a_{i}-b_{i}$$$. Examples Input 5 5 4 3 2 1 1 2 3 4 5 Output 4 Input 2 1 3 4 2 Output 2 Note In the first example, we can swap the first and fifth element in array $$$b$$$, so that it becomes $$$ | 2,500 | false | false | false | false | true | true | true | false | true | false | 3,097 |
615A | Problem - 615A - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags implementation *800 No tag edit access β Contest materials ") editorial") xa0β the number of buttons and the number of bulbs respectively. Each of the next _n_ lines contains _x__i_ (0u2009β€u2009_x__i_u2009β€u2009_m_)xa0β the number of bulbs that are turned on by the _i_-th button, and then _x__i_ numbers _y__ij_ (1u2009β€u2009_y__ij_u2009β€u2009_m_)xa0β the numbers of these bulbs. Output If it's possible to turn on all _m_ bulbs print "YES", otherwise print "NO". Examples Input 3 4 2 1 4 3 1 3 1 1 2 Output YES Input 3 3 1 1 1 2 1 1 Output NO Note In the first sample you can press each button once and turn on all the bulbs. In the 2 sample it is impossible to turn on the 3-rd lamp. | 800 | false | false | true | false | false | false | false | false | false | false | 7,380 |
750D | One tradition of welcoming the New Year is launching fireworks into the sky. Usually a launched firework flies vertically upward for some period of time, then explodes, splitting into several parts flying in different directions. Sometimes those parts also explode after some period of time, splitting into even more parts, and so on. Limak, who lives in an infinite grid, has a single firework. The behaviour of the firework is described with a recursion depth _n_ and a duration for each level of recursion _t_1,u2009_t_2,u2009...,u2009_t__n_. Once Limak launches the firework in some cell, the firework starts moving upward. After covering _t_1 cells (including the starting cell), it explodes and splits into two parts, each moving in the direction changed by 45 degrees (see the pictures below for clarification). So, one part moves in the top-left direction, while the other one moves in the top-right direction. Each part explodes again after covering _t_2 cells, splitting into two parts moving in directions again changed by 45 degrees. The process continues till the _n_-th level of recursion, when all 2_n_u2009-u20091 existing parts explode and disappear without creating new parts. After a few levels of recursion, it's possible that some parts will be at the same place and at the same timexa0β it is allowed and such parts do not crash. Before launching the firework, Limak must make sure that nobody stands in cells which will be visited at least once by the firework. Can you count the number of those cells? Input The first line of the input contains a single integer _n_ (1u2009β€u2009_n_u2009β€u200930)xa0β the total depth of the recursion. The second line contains _n_ integers _t_1,u2009_t_2,u2009...,u2009_t__n_ (1u2009β€u2009_t__i_u2009β€u20095). On the _i_-th level each of 2_i_u2009-u20091 parts will cover _t__i_ cells before exploding. Note For the first sample, the drawings below show the situation after each level of recursion. Limak launched the firework from the bottom-most red cell. It covered _t_1u2009=u20094 cells (marked red), exploded and divided into two parts (their further movement is marked green). All explosions are marked with an 'X' character. On the last drawing, there are 4 red, 4 green, 8 orange and 23 pink cells. So, the total number of visited cells is 4u2009+u20094u2009+u20098u2009+u200923u2009=u200939. For the second sample, the drawings below show the situation after levels 4, 5 and 6. The middle drawing shows directions of all parts that will move in the next level. | 1,900 | false | false | true | true | true | false | true | false | false | false | 6,790 |
888G | Problem - 888G - Codeforces =============== xa0 β the number of vertices in the graph. The second line contains _n_ integers _a_1, _a_2, ..., _a__n_ (0u2009β€u2009_a__i_u2009<u2009230) β the numbers assigned to the vertices. Output Print one number β the weight of the minimum spanning tree in the graph. Examples Input 5 1 2 3 4 5 Output 8 Input 4 1 2 3 4 Output 8 | 2,300 | false | false | false | false | true | true | false | false | false | false | 6,190 |
1706A | You have a sequence $$$a_1, a_2, ldots, a_n$$$ of length $$$n$$$, consisting of integers between $$$1$$$ and $$$m$$$. You also have a string $$$s$$$, consisting of $$$m$$$ characters B. You are going to perform the following $$$n$$$ operations. At the $$$i$$$-th ($$$1 le i le n$$$) operation, you replace either the $$$a_i$$$-th or the $$$(m + 1 - a_i)$$$-th character of $$$s$$$ with A. You can replace the character at any position multiple times through the operations. Find the lexicographically smallest string you can get after these operations. A string $$$x$$$ is lexicographically smaller than a string $$$y$$$ of the same length if and only if in the first position where $$$x$$$ and $$$y$$$ differ, the string $$$x$$$ has a letter that appears earlier in the alphabet than the corresponding letter in $$$y$$$. Input The first line contains the number of test cases $$$t$$$ ($$$1 le t le 2000$$$). The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$1 le n, m le 50$$$)xa0β the length of the sequence $$$a$$$ and the length of the string $$$s$$$ respectively. The second line contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$1 le a_i le m$$$)xa0β the sequence $$$a$$$. Output For each test case, print a string of length $$$m$$$xa0β the lexicographically smallest string you can get. Each character of the string should be either capital English letter A or capital English letter B. Example Input 6 4 5 1 1 3 1 1 5 2 4 1 1 1 1 1 2 4 1 3 2 7 7 5 4 5 5 5 3 5 Output ABABA BABBB A AABB ABABBBB ABABA Note In the first test case, the sequence $$$a = [1, 1, 3, 1]$$$. One of the possible solutions is the following. At the $$$1$$$-st operation, you can replace the $$$1$$$-st character of $$$s$$$ with A. After it, $$$s$$$ becomes ABBBB. At the $$$2$$$-nd operation, you can replace the $$$5$$$-th character of $$$s$$$ with A (since $$$m+1-a_2=5$$$). After it, $$$s$$$ becomes ABBBA. At the $$$3$$$-rd operation, you can replace the $$$3$$$-rd character of $$$s$$$ with A. After it, $$$s$$$ becomes ABABA. At the $$$4$$$-th operation, you can replace the $$$1$$$-st character of $$$s$$$ with A. After it, $$$s$$$ remains equal to ABABA. The resulting string is ABABA. It is impossible to produce a lexicographically smaller string. In the second test case, you are going to perform only one operation. You can replace either the $$$2$$$-nd character or $$$4$$$-th character of $$$s$$$ with A. You can get strings BABBB and BBBAB after the operation. The string BABBB is the lexicographically smallest among these strings. In the third test case, the only string you can get is A. In the fourth test case, you can replace the $$$1$$$-st and $$$2$$$-nd characters of $$$s$$$ with A to get AABB. In the fifth test case, you can replace the $$$1$$$-st and $$$3$$$-rd characters of $$$s$$$ with A to get ABABBBB. | 800 | false | true | false | false | false | true | false | false | false | false | 2,040 |
621E | There are _b_ blocks of digits. Each one consisting of the same _n_ digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12. Wet Shark then takes this number modulo _x_. Please, tell him how many ways he can choose one digit from each block so that he gets exactly _k_ as the final result. As this number may be too large, print it modulo 109u2009+u20097. Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5. Input The first line of the input contains four space-separated integers, _n_, _b_, _k_ and _x_ (2u2009β€u2009_n_u2009β€u200950u2009000,u20091u2009β€u2009_b_u2009β€u2009109,u20090u2009β€u2009_k_u2009<u2009_x_u2009β€u2009100,u2009_x_u2009β₯u20092)xa0β the number of digits in one block, the number of blocks, interesting remainder modulo _x_ and modulo _x_ itself. The next line contains _n_ space separated integers _a__i_ (1u2009β€u2009_a__i_u2009β€u20099), that give the digits contained in each block. Output Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals _k_ modulo _x_. Examples Input 12 1 5 10 3 5 6 7 8 9 5 1 1 1 1 5 Note In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2. In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6. | 2,000 | false | false | false | true | false | false | false | false | false | false | 7,347 |
1740B | Pak Chanek has $$$n$$$ two-dimensional slices of cheese. The $$$i$$$-th slice of cheese can be represented as a rectangle of dimensions $$$a_i imes b_i$$$. We want to arrange them on the two-dimensional plane such that: Each edge of each cheese is parallel to either the x-axis or the y-axis. The bottom edge of each cheese is a segment of the x-axis. No two slices of cheese overlap, but their sides can touch. They form one connected shape. Note that we can arrange them in any order (the leftmost slice of cheese is not necessarily the first slice of cheese). Also note that we can rotate each slice of cheese in any way as long as all conditions still hold. Find the minimum possible perimeter of the constructed shape. Input Each test contains multiple test cases. The first line contains an integer $$$t$$$ ($$$1 leq t leq 2 cdot 10^4$$$) β the number of test cases. The following lines contain the description of each test case. The first line of each test case contains an integer $$$n$$$ ($$$1 leq n leq 2 cdot 10^5$$$) β the number of slices of cheese Pak Chanek has. The $$$i$$$-th of the next $$$n$$$ lines of each test case contains two integers $$$a_i$$$ and $$$b_i$$$ ($$$1 leq a_i,b_i leq 10^9$$$) β the dimensions of the $$$i$$$-th slice of cheese. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$2 cdot 10^5$$$. Output For each test case, output a line containing an integer representing the minimum possible perimeter of the constructed shape. Example Input 3 4 4 1 4 5 1 1 2 3 3 2 4 2 6 2 3 1 2 65 Note In the first test case, a way of getting the minimum possible perimeter is to arrange the slices of cheese as follows. We can calculate that the perimeter of the constructed shape is $$$2+5+1+1+1+1+3+1+5+1+2+3=26$$$. It can be shown that we cannot get a smaller perimeter. Consider the following invalid arrangement. Even though the perimeter of the shape above is $$$24$$$, it does not satisfy all conditions of the problem. The bottom edge of the $$$1 imes 1$$$ slice of cheese is not a segment of the x-axis. In the second test case, a way of getting the minimum possible perimeter is to arrange the slices of cheese as follows. We can calculate that the perimeter of the constructed shape is $$$2+2+2+3+2+3+2+2+2+4=24$$$. It can be shown that we cannot get a smaller perimeter. | 800 | false | true | false | false | false | false | false | false | true | false | 1,846 |
1252L | There are $$$N$$$ cities in the country of Numbata, numbered from $$$1$$$ to $$$N$$$. Currently, there is no road connecting them. Therefore, each of these $$$N$$$ cities proposes a road candidate to be constructed. City $$$i$$$ likes to connect with city $$$A_i$$$, so city $$$i$$$ proposes to add a direct bidirectional road connecting city $$$i$$$ and city $$$A_i$$$. It is guaranteed that no two cities like to connect with each other. In other words, there is no pair of integers $$$i$$$ and $$$j$$$ where $$$A_i = j$$$ and $$$A_j = i$$$. It is also guaranteed that any pair of cities are connected by a sequence of road proposals. In other words, if all proposed roads are constructed, then any pair of cities are connected by a sequence of constructed road. City $$$i$$$ also prefers the road to be constructed using a specific material. Each material can be represented by an integer (for example, $$$0$$$ for asphalt, $$$1$$$ for wood, etc.). The material that can be used for the road connecting city $$$i$$$ and city $$$A_i$$$ is represented by an array $$$B_i$$$ containing $$$M_i$$$ integers: $$$[(B_i)_1, (B_i)_2, dots, (B_i)_{M_i}]$$$. This means that the road connecting city $$$i$$$ and city $$$A_i$$$ can be constructed with either of the material in $$$B_i$$$. There are $$$K$$$ workers to construct the roads. Each worker is only familiar with one material, thus can only construct a road with a specific material. In particular, the $$$i^{th}$$$ worker can only construct a road with material $$$C_i$$$. Each worker can only construct at most one road. You want to assign each worker to construct a road such that any pair of cities are connected by a sequence of constructed road. Input Input begins with a line containing two integers: $$$N$$$ $$$K$$$ ($$$3 le N le 2000$$$; $$$1 le K le 2000$$$) representing the number of cities and the number of workers, respectively. The next $$$N$$$ lines each contains several integers: $$$A_i$$$ $$$M_i$$$ $$$(B_i)_1$$$, $$$(B_i)_2$$$, $$$cdots$$$, $$$(B_i)_{M_i}$$$ ($$$1 le A_i le N$$$; $$$A_i e i$$$; $$$1 le M_i le 10,000$$$; $$$0 le (B_i)_1 < (B_i)_2 < dots < (B_i)_{M_i} le 10^9$$$) representing the bidirectional road that city $$$i$$$ likes to construct. It is guaranteed that the sum of $$$M_i$$$ does not exceed $$$10,000$$$. It is also guaranteed that no two cities like to connect with each other and any pair of cities are connected by a sequence of road proposals. The next line contains $$$K$$$ integers: $$$C_i$$$ ($$$0 le C_i le 10^9$$$) representing the material that is familiarized by the workers. Output If it is not possible to assign each worker to construct a road such that any pair of cities are connected by a sequence of constructed road, simply output -1 in a line. Otherwise, for each worker in the same order as input, output in a line two integers (separated by a single space): $$$u$$$ and $$$v$$$ in any order. This means that the worker constructs a direct bidirectional road connecting city $$$u$$$ and $$$v$$$. If the worker does not construct any road, output "0 0" (without quotes) instead. Each pair of cities can only be assigned to at most one worker. You may output any assignment as long as any pair of cities are connected by a sequence of constructed road. Note Explanation for the sample input/output #1 We can assign the workers to construct the following roads: The first worker constructs a road connecting city $$$1$$$ and city $$$2$$$. The second worker constructs a road connecting city $$$2$$$ and city $$$3$$$. The third worker constructs a road connecting city $$$3$$$ and city $$$4$$$. The fourth worker does not construct any road. The fifth worker constructs a road connecting city $$$4$$$ and city $$$2$$$. Therefore, any pair of cities are now connected by a sequence of constructed road. Explanation for the sample input/output #2 There is no worker that can construct a road connecting city $$$1$$$, thus city $$$1$$$ is certainly isolated. | 2,300 | false | false | false | false | false | false | false | false | false | true | 4,423 |
1905F | You are given a permutation$$$^{dagger}$$$ $$$p$$$ of length $$$n$$$. We call index $$$x$$$ good if for all $$$y < x$$$ it holds that $$$p_y < p_x$$$ and for all $$$y > x$$$ it holds that $$$p_y > p_x$$$. We call $$$f(p)$$$ the number of good indices in $$$p$$$. You can perform the following operation: pick $$$2$$$ distinct indices $$$i$$$ and $$$j$$$ and swap elements $$$p_i$$$ and $$$p_j$$$. Find the maximum value of $$$f(p)$$$ after applying the aforementioned operation exactly once. $$$^{dagger}$$$A permutation of length $$$n$$$ is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array), and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array). Input Each test consists of multiple test cases. The first line of contains a single integer $$$t$$$ ($$$1 le t le 2 cdot 10^4$$$)xa0β the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$2 le n le 2 cdot 10^5$$$)xa0β the length of the permutation $$$p$$$. The second line of each test case contain $$$n$$$ distinct integers $$$p_1, p_2, ldots, p_n$$$ ($$$1 le p_i le n$$$) β the elements of the permutation $$$p$$$. It is guaranteed that sum of $$$n$$$ over all test cases does not exceed $$$2 cdot 10^5$$$. Output For each test case, output a single integer β the maximum value of $$$f(p)$$$ after performing the operation exactly once. Example Input 5 5 1 2 3 4 5 5 2 1 3 4 5 7 2 1 5 3 7 6 4 6 2 3 5 4 1 6 7 7 6 5 4 3 2 1 Note In the first test case, $$$p = [1,2,3,4,5]$$$ and $$$f(p)=5$$$ which is already maximum possible. But must perform the operation anyway. We can get $$$f(p)=3$$$ by choosing $$$i=1$$$ and $$$j=2$$$ which makes $$$p = [2,1,3,4,5]$$$. In the second test case, we can transform $$$p$$$ into $$$[1,2,3,4,5]$$$ by choosing $$$i=1$$$ and $$$j=2$$$. Thus $$$f(p)=5$$$. | 2,600 | false | false | false | false | true | false | true | false | false | false | 878 |
1687F | Problem - 1687F - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags fft math *3500 No tag edit access β Contest materials and $$$s$$$ ($$$0 leq s < n$$$). Output Print one line with $$$n$$$ intergers. The $$$i$$$-th integers represents the answer of $$$k=i-1$$$, modulo $$$998244353$$$. Examples Input 2 0 Output 1 0 Input 4 1 Output 0 3 6 0 Input 8 3 Output 0 0 0 35 770 980 70 0 Note Let $$$f(p)=sumlimits_{i=1}^{n-1} | 3,500 | true | false | false | false | false | false | false | false | false | false | 2,152 |
903G | In this problem you will have to deal with a very special network. The network consists of two parts: part _A_ and part _B_. Each part consists of _n_ vertices; _i_-th vertex of part _A_ is denoted as _A__i_, and _i_-th vertex of part _B_ is denoted as _B__i_. For each index _i_ (1u2009β€u2009_i_u2009<u2009_n_) there is a directed edge from vertex _A__i_ to vertex _A__i_u2009+u20091, and from _B__i_ to _B__i_u2009+u20091, respectively. Capacities of these edges are given in the input. Also there might be several directed edges going from part _A_ to part _B_ (but never from _B_ to _A_). You have to calculate the . Take a look at the example and the notes to understand the structure of the network better. Input The first line contains three integer numbers _n_, _m_ and _q_ (2u2009β€u2009_n_,u2009_m_u2009β€u20092Β·105, 0u2009β€u2009_q_u2009β€u20092Β·105) β the number of vertices in each part, the number of edges going from _A_ to _B_ and the number of changes, respectively. Then _n_u2009-u20091 lines follow, _i_-th line contains two integers _x__i_ and _y__i_ denoting that the edge from _A__i_ to _A__i_u2009+u20091 has capacity _x__i_ and the edge from _B__i_ to _B__i_u2009+u20091 has capacity _y__i_ (1u2009β€u2009_x__i_,u2009_y__i_u2009β€u2009109). Then _m_ lines follow, describing the edges from _A_ to _B_. Each line contains three integers _x_, _y_ and _z_ denoting an edge from _A__x_ to _B__y_ with capacity _z_ (1u2009β€u2009_x_,u2009_y_u2009β€u2009_n_, 1u2009β€u2009_z_u2009β€u2009109). There might be multiple edges from _A__x_ to _B__y_. And then _q_ lines follow, describing a sequence of changes to the network. _i_-th line contains two integers _v__i_ and _w__i_, denoting that the capacity of the edge from _A__v__i_ to _A__v__i_u2009+u20091 is set to _w__i_ (1u2009β€u2009_v__i_u2009<u2009_n_, 1u2009β€u2009_w__i_u2009β€u2009109). Output Firstly, print the maximum flow value in the original network. Then print _q_ integers, _i_-th of them must be equal to the maximum flow value after _i_-th change. Example Input 4 3 2 1 2 3 4 5 6 2 2 7 1 4 8 4 3 9 1 100 2 100 Note This is the original network in the example: | 2,700 | false | false | false | false | true | false | false | false | false | true | 6,128 |
1970B2 | The only difference between this and the hard version is that $$$a_{1} = 0$$$. After some recent attacks on Hogwarts Castle by the Death Eaters, the Order of the Phoenix has decided to station $$$n$$$ members in Hogsmead Village. The houses will be situated on a picturesque $$$n imes n$$$ square field. Each wizard will have their own house, and every house will belong to some wizard. Each house will take up the space of one square. However, as you might know wizards are very superstitious. During the weekends, each wizard $$$i$$$ will want to visit the house that is exactly $$$a_{i}$$$ $$$(0 leq a_{i} leq n)$$$ away from their own house. The roads in the village are built horizontally and vertically, so the distance between points $$$(x_{i}, y_{i})$$$ and $$$(x_{j}, y_{j})$$$ on the $$$n imes n$$$ field is $$$ x_{i} - x_{j} + y_{i} - y_{j}$$$. The wizards know and trust each other, so one wizard can visit another wizard's house when the second wizard is away. The houses to be built will be big enough for all $$$n$$$ wizards to simultaneously visit any house. Apart from that, each wizard is mandated to have a view of the Hogwarts Castle in the north and the Forbidden Forest in the south, so the house of no other wizard should block the view. In terms of the village, it means that in each column of the $$$n imes n$$$ field, there can be at most one house, i.e. if the $$$i$$$-th house has coordinates $$$(x_{i}, y_{i})$$$, then $$$x_{i} eq x_{j}$$$ for all $$$i eq j$$$. The Order of the Phoenix doesn't yet know if it is possible to place $$$n$$$ houses in such a way that will satisfy the visit and view requirements of all $$$n$$$ wizards, so they are asking for your help in designing such a plan. If it is possible to have a correct placement, where for the $$$i$$$-th wizard there is a house that is $$$a_{i}$$$ away from it and the house of the $$$i$$$-th wizard is the only house in their column, output YES, the position of houses for each wizard, and to the house of which wizard should each wizard go during the weekends. If it is impossible to have a correct placement, output NO. Input The first line contains $$$n$$$ ($$$2 leq n leq 2cdot 10^{5}$$$), the number of houses to be built. The second line contains $$$n$$$ integers $$$a_{1}, ldots, a_{n}$$$ $$$(0 leq a_{i} leq n)$$$, $$$a_{1} = 0$$$. Output If there exists such a placement, output YES on the first line; otherwise, output NO. If the answer is YES, output $$$n + 1$$$ more lines describing the placement. The next $$$n$$$ lines should contain the positions of the houses $$$1 leq x_{i}, y_{i} leq n$$$ for each wizard. The $$$i$$$-th element of the last line should contain the index of the wizard, the house of which is exactly $$$a_{i}$$$ away from the house of the $$$i$$$-th wizard. If there are multiple such wizards, you can output any. If there are multiple house placement configurations, you can output any. Examples Output YES 4 4 1 3 2 4 3 1 1 1 1 3 Output YES 1 1 2 1 4 1 3 1 1 1 1 3 Note For the sample, the house of the 1st wizard is located at $$$(4, 4)$$$, of the 2nd at $$$(1, 3)$$$, of the 3rd at $$$(2, 4)$$$, of the 4th at $$$(3, 1)$$$. The distance from the house of the 1st wizard to the house of the 1st wizard is $$$4 - 4 + 4 - 4 = 0$$$. The distance from the house of the 2nd wizard to the house of the 1st wizard is $$$1 - 4 + 3 - 4 = 4$$$. The distance from the house of the 3rd wizard to the house of the 1st wizard is $$$2 - 4 + 4 - 4 = 2$$$. The distance from the house of the 4th wizard to the house of the 3rd wizard is $$$3 - 2 + 1 - 4 = 4$$$. The view and the distance conditions are satisfied for all houses, so the placement is correct. | 2,100 | false | false | false | false | false | true | false | false | false | false | 482 |
1510I | The popular improv website Interpretation Impetus hosts regular improv contests and maintains a rating of the best performers. However, since improv can often go horribly wrong, the website is notorious for declaring improv contests unrated. It now holds a wager before each improv contest where the participants try to predict whether it will be rated or unrated, and they are now more popular than the improv itself. Izzy and $$$n$$$ other participants take part in each wager. First, they each make their prediction, expressed as 1 ("rated") or 0 ("unrated"). Izzy always goes last, so she knows the predictions of the other participants when making her own. Then, the actual competition takes place and it is declared either rated or unrated. You need to write a program that will interactively play as Izzy. There will be $$$m$$$ wagers held in 2021, and Izzy's goal is to have at most $$$1.3cdot b + 100$$$ wrong predictions after all those wagers, where $$$b$$$ is the smallest number of wrong predictions that any other wager participant will have after all those wagers. The number $$$b$$$ is not known in advance. Izzy also knows nothing about the other participantsxa0β they might somehow always guess correctly, or their predictions might be correlated. Izzy's predictions, though, do not affect the predictions of the other participants and the decision on the contest being rated or notxa0β in other words, in each test case, your program always receives the same inputs, no matter what it outputs. Interaction First, a solution must read two integers $$$n$$$ ($$$1 le n le 1000$$$) and $$$m$$$ ($$$1 le m le 10,000$$$). Then, the solution must process $$$m$$$ wagers. For each of them, the solution must first read a string consisting of $$$n$$$ 0s and 1s, in which the $$$i$$$-th character denotes the guess of the $$$i$$$-th participant. Then, the solution must print Izzy's guess as 0 or 1. Don't forget to flush the output after printing it! Then, the solution must read the actual outcome, also as 0 or 1, and then proceed to the next wager, if this wasn't the last one. Your solution will be considered correct if it makes at most $$$1.3cdot b + 100$$$ mistakes, where $$$b$$$ is the smallest number of mistakes made by any other participant. Note that if a solution outputs anything except 0 or 1 for a wager, it will be considered incorrect even if it made no other mistakes. There are 200 test cases in this problem. Note In the example, the participants made 1, 2, and 3 mistakes respectively, therefore $$$b=1$$$ (the smallest of these numbers). Izzy made 3 mistakes, which were not more than $$$1.3cdot b + 100=101.3$$$, so these outputs are good enough to pass this test case (as are any other valid outputs). | 2,700 | true | true | false | false | false | false | false | false | false | false | 3,119 |
1703B | In an ICPC contest, balloons are distributed as follows: Whenever a team solves a problem, that team gets a balloon. The first team to solve a problem gets an additional balloon. A contest has 26 problems, labelled $$$ extsf{A}$$$, $$$ extsf{B}$$$, $$$ extsf{C}$$$, ..., $$$ extsf{Z}$$$. You are given the order of solved problems in the contest, denoted as a string $$$s$$$, where the $$$i$$$-th character indicates that the problem $$$s_i$$$ has been solved by some team. No team will solve the same problem twice. Determine the total number of balloons that the teams received. Note that some problems may be solved by none of the teams. Input The first line of the input contains an integer $$$t$$$ ($$$1 leq t leq 100$$$)xa0β the number of testcases. The first line of each test case contains an integer $$$n$$$ ($$$1 leq n leq 50$$$)xa0β the length of the string. The second line of each test case contains a string $$$s$$$ of length $$$n$$$ consisting of uppercase English letters, denoting the order of solved problems. Output For each test case, output a single integerxa0β the total number of balloons that the teams received. Example Input 6 3 ABA 1 A 3 ORZ 5 BAAAA 4 BKPT 10 CODEFORCES Note In the first test case, $$$5$$$ balloons are given out: Problem $$$ extsf{A}$$$ is solved. That team receives $$$2$$$ balloons: one because they solved the problem, an an additional one because they are the first team to solve problem $$$ extsf{A}$$$. Problem $$$ extsf{B}$$$ is solved. That team receives $$$2$$$ balloons: one because they solved the problem, an an additional one because they are the first team to solve problem $$$ extsf{B}$$$. Problem $$$ extsf{A}$$$ is solved. That team receives only $$$1$$$ balloon, because they solved the problem. Note that they don't get an additional balloon because they are not the first team to solve problem $$$ extsf{A}$$$. The total number of balloons given out is $$$2+2+1=5$$$. In the second test case, there is only one problem solved. The team who solved it receives $$$2$$$ balloons: one because they solved the problem, an an additional one because they are the first team to solve problem $$$ extsf{A}$$$. | 800 | false | false | true | false | true | false | false | false | false | false | 2,061 |
1610F | Lee was planning to get closer to Mashtali's heart to proceed with his evil plan(which we're not aware of, yet), so he decided to beautify Mashtali's graph. But he made several rules for himself. And also he was too busy with his plans that he didn't have time for such minor tasks, so he asked you for help. Mashtali's graph is an undirected weighted graph with $$$n$$$ vertices and $$$m$$$ edges with weights equal to either $$$1$$$ or $$$2$$$. Lee wants to direct the edges of Mashtali's graph so that it will be as beautiful as possible. Lee thinks that the beauty of a directed weighted graph is equal to the number of its Oddysey vertices. A vertex $$$v$$$ is an Oddysey vertex if $$$d^+(v) - d^-(v) = 1$$$, where $$$d^+(v)$$$ is the sum of weights of the outgoing from $$$v$$$ edges, and $$$d^-(v)$$$ is the sum of the weights of the incoming to $$$v$$$ edges. Find the largest possible beauty of a graph that Lee can achieve by directing the edges of Mashtali's graph. In addition, find any way to achieve it. Note that you have to orient each edge. Input The first line contains two integers $$$n$$$ and $$$m$$$ $$$(1 le n le 10^5;; 1 le m le 10^5)$$$xa0β the numbers of vertices and edges in the graph. The $$$i$$$-th line of the following $$$m$$$ lines contains three integers $$$u_i$$$, $$$v_i$$$ and $$$w_i$$$ $$$( 1 le u_i , v_i le n;; u_i eq v_i;; bf{w_i in {1, 2}} )$$$xa0β the endpoints of the $$$i$$$-th edge and its weight. Note that the graph doesn't have to be connected, and it might contain multiple edges. Output In the first line print a single integerxa0β the maximum beauty of the graph Lee can achieve. In the second line print a string of length $$$m$$$ consisting of $$$1$$$s and $$$2$$$sxa0β directions of the edges. If you decide to direct the $$$i$$$-th edge from vertex $$$u_i$$$ to vertex $$$v_i$$$, $$$i$$$-th character of the string should be $$$1$$$. Otherwise, it should be $$$2$$$. Examples Input 6 7 1 2 1 1 3 2 2 3 2 1 4 1 4 5 1 2 5 2 2 6 2 Input 6 7 1 2 2 1 3 2 2 3 2 1 4 2 4 5 2 2 5 2 2 6 2 Input 6 7 1 2 1 1 3 1 2 3 1 1 4 1 4 5 1 2 5 1 2 6 1 Note Explanation for the first sample: vertices $$$2$$$ and $$$5$$$ are Oddyseys. Explanation for the third sample: vertices $$$1$$$ and $$$6$$$ are Oddyseys. | 3,000 | false | false | false | false | false | true | false | false | false | true | 2,595 |
1104B | Problem - 1104B - Codeforces =============== xa0 ]( --- Finished β Virtual participation Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ICPC mode for virtual contests. If you've seen these problems, a virtual contest is not for you - solve these problems in the archive. If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive. Never use someone else's code, read the tutorials or communicate with other person during a virtual contest. β Problem tags data structures implementation math *1200 No tag edit access β Contest materials , where $$$s$$$ means the length of a string $$$s$$$. Output If the first player wins, print "Yes". If the second player wins, print "No". Examples Input abacaba Output No Input iiq Output Yes Input abba Output No Note In the first example the first player is unable to make a turn, so he loses. In the second example first player turns the string into "q", then second player is unable to move, so he loses. | 1,200 | true | false | true | false | true | false | false | false | false | false | 5,181 |
1106B | Lunar New Year is approaching, and Bob is planning to go for a famous restaurant β "Alice's". The restaurant "Alice's" serves $$$n$$$ kinds of food. The cost for the $$$i$$$-th kind is always $$$c_i$$$. Initially, the restaurant has enough ingredients for serving exactly $$$a_i$$$ dishes of the $$$i$$$-th kind. In the New Year's Eve, $$$m$$$ customers will visit Alice's one after another and the $$$j$$$-th customer will order $$$d_j$$$ dishes of the $$$t_j$$$-th kind of food. The $$$(i + 1)$$$-st customer will only come after the $$$i$$$-th customer is completely served. Suppose there are $$$r_i$$$ dishes of the $$$i$$$-th kind remaining (initially $$$r_i = a_i$$$). When a customer orders $$$1$$$ dish of the $$$i$$$-th kind, the following principles will be processed. 1. If $$$r_i > 0$$$, the customer will be served exactly $$$1$$$ dish of the $$$i$$$-th kind. The cost for the dish is $$$c_i$$$. Meanwhile, $$$r_i$$$ will be reduced by $$$1$$$. 2. Otherwise, the customer will be served $$$1$$$ dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by $$$1$$$. 3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is $$$0$$$. If the customer doesn't leave after the $$$d_j$$$ dishes are served, the cost for the customer will be the sum of the cost for these $$$d_j$$$ dishes. Please determine the total cost for each of the $$$m$$$ customers. Input The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 leq n, m leq 10^5$$$), representing the number of different kinds of food and the number of customers, respectively. The second line contains $$$n$$$ positive integers $$$a_1, a_2, ldots, a_n$$$ ($$$1 leq a_i leq 10^7$$$), where $$$a_i$$$ denotes the initial remain of the $$$i$$$-th kind of dishes. The third line contains $$$n$$$ positive integers $$$c_1, c_2, ldots, c_n$$$ ($$$1 leq c_i leq 10^6$$$), where $$$c_i$$$ denotes the cost of one dish of the $$$i$$$-th kind. The following $$$m$$$ lines describe the orders of the $$$m$$$ customers respectively. The $$$j$$$-th line contains two positive integers $$$t_j$$$ and $$$d_j$$$ ($$$1 leq t_j leq n$$$, $$$1 leq d_j leq 10^7$$$), representing the kind of food and the number of dishes the $$$j$$$-th customer orders, respectively. Output Print $$$m$$$ lines. In the $$$j$$$-th line print the cost for the $$$j$$$-th customer. Examples Input 8 5 8 6 2 1 4 5 7 5 6 3 3 2 6 2 3 2 2 8 1 4 4 7 3 4 6 10 Input 6 6 6 6 6 6 6 6 6 66 666 6666 66666 666666 1 6 2 6 3 6 4 6 5 6 6 66 Output 36 396 3996 39996 399996 0 Input 6 6 6 6 6 6 6 6 6 66 666 6666 66666 666666 1 6 2 13 3 6 4 11 5 6 6 6 Output 36 11058 99996 4333326 0 0 Note In the first sample, $$$5$$$ customers will be served as follows. 1. Customer $$$1$$$ will be served $$$6$$$ dishes of the $$$2$$$-nd kind, $$$1$$$ dish of the $$$4$$$-th kind, and $$$1$$$ dish of the $$$6$$$-th kind. The cost is $$$6 cdot 3 + 1 cdot 2 + 1 cdot 2 = 22$$$. The remain of the $$$8$$$ kinds of food will be $$${8, 0, 2, 0, 4, 4, 7, 5}$$$. 2. Customer $$$2$$$ will be served $$$4$$$ dishes of the $$$1$$$-st kind. The cost is $$$4 cdot 6 = 24$$$. The remain will be $$${4, 0, 2, 0, 4, 4, 7, 5}$$$. 3. Customer $$$3$$$ will be served $$$4$$$ dishes of the $$$6$$$-th kind, $$$3$$$ dishes of the $$$8$$$-th kind. The cost is $$$4 cdot 2 + 3 cdot 2 = 14$$$. The remain will be $$${4, 0, 2, 0, 4, 0, 7, 2}$$$. 4. Customer $$$4$$$ will be served $$$2$$$ dishes of the $$$3$$$-rd kind, $$$2$$$ dishes of the $$$8$$$-th kind. The cost is $$$2 cdot 3 + 2 cdot 2 = 10$$$. The remain will be $$${4, 0, 0, 0, 4, 0, 7, 0}$$$. 5. Customer $$$5$$$ will be served $$$7$$$ dishes of the $$$7$$$-th kind, $$$3$$$ dishes of the $$$1$$$-st kind. The cost is $$$7 cdot 3 + 3 cdot 6 = 39$$$. The remain will be $$${1, 0, 0, 0, 4, 0, 0, 0}$$$. In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served $$$6$$$ dishes of the second kind, so the cost is $$$66 cdot 6 = 396$$$. In the third sample, some customers may not be served what they order. For example, the second customer is served $$$6$$$ dishes of the second kind, $$$6$$$ of the third and $$$1$$$ of the fourth, so the cost is $$$66 cdot 6 + 666 cdot 6 + 6666 cdot 1 = 11058$$$. | 1,500 | false | false | true | false | true | false | false | false | false | false | 5,174 |
1056C | Don't you tell me what you think that I can be If you say that Arkady is a bit old-fashioned playing checkers, you won't be right. There is also a modern computer game Arkady and his friends are keen on. We won't discuss its rules, the only feature important to this problem is that each player has to pick a distinct hero in the beginning of the game. There are $$$2$$$ teams each having $$$n$$$ players and $$$2n$$$ heroes to distribute between the teams. The teams take turns picking heroes: at first, the first team chooses a hero in its team, after that the second team chooses a hero and so on. Note that after a hero is chosen it becomes unavailable to both teams. The friends estimate the power of the $$$i$$$-th of the heroes as $$$p_i$$$. Each team wants to maximize the total power of its heroes. However, there is one exception: there are $$$m$$$ pairs of heroes that are especially strong against each other, so when any team chooses a hero from such a pair, the other team must choose the other one on its turn. Each hero is in at most one such pair. This is an interactive problem. You are to write a program that will optimally choose the heroes for one team, while the jury's program will play for the other team. Note that the jury's program may behave inefficiently, in this case you have to take the opportunity and still maximize the total power of your team. Formally, if you ever have chance to reach the total power of $$$q$$$ or greater regardless of jury's program choices, you must get $$$q$$$ or greater to pass a test. Input The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 le n le 10^3$$$, $$$0 le m le n$$$)xa0β the number of players in one team and the number of special pairs of heroes. The second line contains $$$2n$$$ integers $$$p_1, p_2, ldots, p_{2n}$$$ ($$$1 le p_i le 10^3$$$)xa0β the powers of the heroes. Each of the next $$$m$$$ lines contains two integer $$$a$$$ and $$$b$$$ ($$$1 le a, b le 2n$$$, $$$a e b$$$)xa0β a pair of heroes that are especially strong against each other. It is guaranteed that each hero appears at most once in this list. The next line contains a single integer $$$t$$$ ($$$1 le t le 2$$$)xa0β the team you are to play for. If $$$t = 1$$$, the first turn is yours, otherwise you have the second turn. Hacks In order to hack, use the format described above with one additional line. In this line output $$$2n$$$ distinct integers from $$$1$$$ to $$$2n$$$xa0β the priority order for the jury's team. The jury's team will on each turn select the first possible hero from this list. Here possible means that it is not yet taken and does not contradict the rules about special pair of heroes. Interaction When it is your turn, print a single integer $$$x$$$ ($$$1 le x le 2n$$$)xa0β the index of the hero chosen by you. Note that you can't choose a hero previously chosen by either you of the other player, and you must follow the rules about special pairs of heroes. When it is the other team's turn, read a line containing a single integer $$$x$$$ ($$$1 le x le 2n$$$)xa0β the index of the hero chosen by the other team. It is guaranteed that this index is not chosen before and that the other team also follows the rules about special pairs of heroes. After the last turn you should terminate without printing anything. After printing your choice do not forget to output end of line and flush the output. Otherwise you will get Idleness limit exceeded. To do this, use: fflush(stdout) or cout.flush() in C++; System.out.flush() in Java; flush(output) in Pascal; stdout.flush() in Python; see documentation for other languages. Jury's answer $$$-1$$$ instead of a valid choice means that you made an invalid turn. Exit immediately after receiving $$$-1$$$ and you will see Wrong answer verdict. Otherwise you can get an arbitrary verdict because your solution will continue to read from a closed stream. Examples Input 3 1 1 2 3 4 5 6 2 6 1 2 4 1 Input 3 1 1 2 3 4 5 6 1 5 2 6 1 3 Note In the first example the first turn is yours. In example, you choose $$$6$$$, the other team is forced to reply with $$$2$$$. You choose $$$5$$$, the other team chooses $$$4$$$. Finally, you choose $$$3$$$ and the other team choose $$$1$$$. In the second example you have the second turn. The other team chooses $$$6$$$, you choose $$$5$$$, forcing the other team to choose $$$1$$$. Now you choose $$$4$$$, the other team chooses $$$3$$$ and you choose $$$2$$$. | 1,700 | false | true | true | false | false | false | false | false | true | false | 5,430 |
1450A | A string $$$b$$$ is a subsequence of a string $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx". You are given a string $$$a$$$. Your task is to reorder the characters of $$$a$$$ so that "trygub" is not a subsequence of the resulting string. In other words, you should find a string $$$b$$$ which is a permutation of symbols of the string $$$a$$$ and "trygub" is not a subsequence of $$$b$$$. We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it. Input The first line contains a single integer $$$t$$$ ($$$1le tle 100$$$) β the number of test cases. The first line of each test case contains a single integer $$$n$$$ ($$$1le nle 200$$$) β the length of $$$a$$$. The next line contains the string $$$a$$$ of length $$$n$$$, consisting of lowercase English letters. Output For each test case, output a string $$$b$$$ of length $$$n$$$ which is a permutation of characters of the string $$$a$$$, and such that "trygub" is not a subsequence of it. If there exist multiple possible strings $$$b$$$, you can print any. Example Input 3 11 antontrygub 15 bestcoordinator 19 trywatchinggurabruh Output bugyrtnotna bestcoordinator bruhtrywatchinggura Note In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence. In the second test case, we did not change the order of characters because it is not needed. In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub". | 800 | false | false | false | false | false | true | false | false | true | false | 3,438 |
1906K | You are playing a deck-building game with your friend. There are $$$N$$$ cards, numbered from $$$1$$$ to $$$N$$$. Card $$$i$$$ has the value of $$$A_i$$$. You want to build two decks; one for you and one for your friend. A card cannot be inside both decks, and it is allowed to not use all $$$N$$$ cards. It is also allowed for a deck to be empty, i.e. does not contain any cards. The power of a deck is represented as the bitwise XOR of the value of the cards in the deck. The power of an empty deck is $$$0$$$. The game is balanced if both decks have the same power. Determine the number of ways to build two decks such that the game is balanced. Two ways are considered different if one of the decks contains at least one different card. Since the answer can be very large, calculate the answer modulo $$$998,244,353$$$. Input The first line consists of an integer $$$N$$$ ($$$2 le N le 100,000$$$). The following line consists of $$$N$$$ integers $$$A_i$$$ ($$$1 le A_i le 100,000$$$). Output Output an integer representing the number of ways to build two decks such that the game is balanced. Output the answer modulo $$$998,244,353$$$. Note Explanation for the sample input/output #1 Denote $$$S$$$ and $$$T$$$ as the set of cards in your deck and your friend's deck, respectively. There are $$$9$$$ ways to build the decks such that the game is balanced. $$$S = {}$$$ and $$$T = {}$$$. Both decks have the power of $$$0$$$. $$$S = {2, 3, 4}$$$ and $$$T = {}$$$. Both decks have the power of $$$0$$$. $$$S = {}$$$ and $$$T = {2, 3, 4}$$$. Both decks have the power of $$$0$$$. $$$S = {2, 4}$$$ and $$$T = {3}$$$. Both decks have the power of $$$4$$$. $$$S = {3}$$$ and $$$T = {2, 4}$$$. Both decks have the power of $$$4$$$. $$$S = {2, 3}$$$ and $$$T = {4}$$$. Both decks have the power of $$$8$$$. $$$S = {4}$$$ and $$$T = {2, 3}$$$. Both decks have the power of $$$8$$$. $$$S = {3, 4}$$$ and $$$T = {2}$$$. Both decks have the power of $$$12$$$. $$$S = {2}$$$ and $$$T = {3, 4}$$$. Both decks have the power of $$$12$$$. Explanation for the sample input/output #2 The only way to make the game balanced is to have both decks empty. Explanation for the sample input/output #3 There are $$$5$$$ ways to build the decks such that the game is balanced. $$$S = {}$$$ and $$$T = {}$$$. Both decks have the power of $$$0$$$. $$$S = {1, 2}$$$ and $$$T = {}$$$. Both decks have the power of $$$0$$$. $$$S = {}$$$ and $$$T = {1, 2}$$$. Both decks have the power of $$$0$$$. $$$S = {1}$$$ and $$$T = {2}$$$. Both decks have the power of $$$1$$$. $$$S = {2}$$$ and $$$T = {1}$$$. Both decks have the power of $$$1$$$. | 2,500 | true | false | false | false | false | false | false | false | false | false | 867 |
1616G | You are given a directed acyclic graph with $$$n$$$ vertices and $$$m$$$ edges. For all edges $$$a o b$$$ in the graph, $$$a < b$$$ holds. You need to find the number of pairs of vertices $$$x$$$, $$$y$$$, such that $$$x > y$$$ and after adding the edge $$$x o y$$$ to the graph, it has a Hamiltonian path. Input The first line of input contains one integer $$$t$$$ ($$$1 leq t leq 5$$$): the number of test cases. The next lines contains the descriptions of the test cases. In the first line you are given two integers $$$n$$$ and $$$m$$$ ($$$1 leq n leq 150,000$$$, $$$0 leq m leq min(150,000, frac{n(n-1)}{2})$$$): the number of vertices and edges in the graph. Each of the next $$$m$$$ lines contains two integers $$$a$$$, $$$b$$$ ($$$1 leq a < b leq n$$$), specifying an edge $$$a o b$$$ in the graph. No edge $$$a o b$$$ appears more than once. Output For each test case, print one integer: the number of pairs of vertices $$$x$$$, $$$y$$$, $$$x > y$$$, such that after adding the edge $$$x o y$$$ to the graph, it has a Hamiltonian path. Example Input 3 3 2 1 2 2 3 4 3 1 2 3 4 1 4 4 4 1 3 1 4 2 3 3 4 Note In the first example, any edge $$$x o y$$$ such that $$$x > y$$$ is valid, because there already is a path $$$1 o 2 o 3$$$. In the second example only the edge $$$4 o 1$$$ is valid. There is a path $$$3 o 4 o 1 o 2$$$ if this edge is added. In the third example you can add edges $$$2 o 1$$$, $$$3 o 1$$$, $$$4 o 1$$$, $$$4 o 2$$$. | 3,500 | false | false | false | true | false | false | false | false | false | true | 2,550 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.