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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
690F2 | Heidi got tired of deciphering the prophecy hidden in the Tree of Life and decided to go back to her headquarters, rest a little and try there. Of course, she cannot uproot the Tree and take it with her, so she made a drawing of the Tree on a piece of paper. On second thought, she made more identical drawings so as to have _n_ in total (where _n_ is the number of vertices of the Tree of Life) β who knows what might happen? Indeed, on her way back Heidi was ambushed by a group of zombies. While she managed to fend them off, they have damaged her drawings in a peculiar way: from the _i_-th copy, the vertex numbered _i_ was removed, along with all adjacent edges. In each picture, the zombies have also erased all the vertex numbers and relabeled the remaining _n_u2009-u20091 vertices arbitrarily using numbers 1 to _n_ (fortunately, each vertex still has a distinct number). What's more, the drawings have been arbitrarily shuffled/reordered. Now Heidi wants to recover the Tree of Life from her descriptions of all the drawings (as lists of edges). Input The first line of the input contains _Z_u2009β€u200920 β the number of test cases. _Z_ descriptions of single test cases follow. In each test case, the first line of input contains numbers _n_ (2u2009β€u2009_n_u2009β€u2009100) and _k_ (where _k_ is the number of drawings; we have _k_u2009=u2009_n_). In the following lines, the descriptions of the _k_ drawings are given. The description of the _i_-th drawing is a line containing _m__i_ β the number of edges in this drawing, followed by _m__i_ lines describing edges, each of which contains two space-separated integers β- the numbers of the two vertices connected by the edge. Output If Heidi's drawings cannot possibly come from a single tree, you should output the word NO. Otherwise, output one line containing the word YES and _n_u2009-u20091 lines describing any tree that Heidi's drawings could have come from. For every edge you should output the numbers of the vertices that it connects, separated with a single space. If there are many solutions, print any of them. Example Input 1 5 5 2 4 1 2 1 1 3 1 3 4 1 4 3 2 1 3 3 1 3 2 4 1 3 2 1 3 2 4 2 | 2,700 | false | false | false | false | false | true | false | false | false | false | 7,049 |
1671F | Problem - 1671F - 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 combinatorics dp fft math *2700 No tag edit access β Contest materials $$$ such that $$$i < j$$$ and $$$p_i > p_j$$$) and exactly $$$x$$$ indices $$$i$$$ such that $$$p_i > p_{i+1}$$$. Yep, that's the whole problem. Good luck! Input The first line contains one integer $$$t$$$ ($$$1 le t le 3 cdot 10^4$$$) β the number of test cases. Each test case consists of one line which contains three integers $$$n$$$, $$$k$$$ and $$$x$$$ ($$$1 le n le 998244352$$$; $$$1 le k le 11$$$; $$$1 le x le 11$$$). Output For each test case, print one integer β the answer to the problem, taken modulo $$$998244353$$$. Example Input 5 10 6 4 7 3 1 163316 11 7 136373 11 1 325902 11 11 Output 465 12 986128624 7636394 57118194 | 2,700 | true | false | false | true | false | false | true | false | false | false | 2,246 |
1446E | A patient has been infected with an unknown disease. His body can be seen as an infinite grid of triangular cells which looks as follows: Two cells are neighboring if they share a side. Therefore, each cell ($$$x$$$, $$$y$$$) has exactly three neighbors: ($$$x+1$$$, $$$y$$$) ($$$x-1$$$, $$$y$$$) ($$$x+1$$$, $$$y-1$$$) if $$$x$$$ is even and ($$$x-1$$$, $$$y+1$$$) otherwise. Initially some cells are infected, all the others are healthy. The process of recovery begins. Each second, for exactly one cell (even though there might be multiple cells that could change its state) one of the following happens: A healthy cell with at least $$$2$$$ infected neighbors also becomes infected. An infected cell with at least $$$2$$$ healthy neighbors also becomes healthy. If no such cell exists, the process of recovery stops. Patient is considered recovered if the process of recovery has stopped and all the cells are healthy. We're interested in a worst-case scenario: is it possible that the patient never recovers, or if it's not possible, what is the maximum possible duration of the recovery process? Input The first line contains one integer $$$n$$$ $$$(1 leq n leq 250000)$$$ xa0β the number of infected cells. The $$$i$$$-th of the next $$$n$$$ lines contains two space-separated integers $$$x_i$$$ and $$$y_i$$$ $$$(0 leq x_i, y_i < 500)$$$, meaning that cell $$$(x_i, y_i)$$$ is infected. All cells $$$(x_i, y_i)$$$ are distinct, and all other cells are considered healthy. Output If it is possible that the organism never fully recovers from the disease, print SICK. Otherwise, you should print RECOVERED and in the next line an integer $$$k$$$ xa0β the longest possible recovery period, modulo $$$998244353$$$. Note For the first testcase, the following drawings describe the longest possible recovery process. It can be proven that there are no recovery periods of length $$$5$$$ or longer, and the organism always recovers in this testcase. $$$hspace{40pt} downarrow$$$ $$$hspace{40pt} downarrow$$$ $$$hspace{40pt} downarrow$$$ $$$hspace{40pt} downarrow$$$ $$$hspace{15pt}$$$ RECOVERED For the second testcase, it is possible for the cells $$$(2, 0)$$$, $$$(2, 1)$$$, $$$(0, 1)$$$ to become infected. After that, no cell can change its state, so the answer is SICK, as not all of the cells are healthy. | 3,500 | false | false | false | false | false | true | false | false | false | false | 3,442 |
1619E | Dmitry has an array of $$$n$$$ non-negative integers $$$a_1, a_2, dots, a_n$$$. In one operation, Dmitry can choose any index $$$j$$$ ($$$1 le j le n$$$) and increase the value of the element $$$a_j$$$ by $$$1$$$. He can choose the same index $$$j$$$ multiple times. For each $$$i$$$ from $$$0$$$ to $$$n$$$, determine whether Dmitry can make the $$$mathrm{MEX}$$$ of the array equal to exactly $$$i$$$. If it is possible, then determine the minimum number of operations to do it. The $$$mathrm{MEX}$$$ of the array is equal to the minimum non-negative integer that is not in the array. For example, the $$$mathrm{MEX}$$$ of the array $$$[3, 1, 0]$$$ is equal to $$$2$$$, and the array $$$[3, 3, 1, 4]$$$ is equal to $$$0$$$. Input The first line of input data contains a single integer $$$t$$$ ($$$1 le t le 10^4$$$)xa0β the number of test cases in the input. The descriptions of the test cases follow. The first line of the description of each test case contains a single integer $$$n$$$ ($$$1 le n le 2 cdot 10^5$$$)xa0β the length of the array $$$a$$$. The second line of the description of each test case contains $$$n$$$ integers $$$a_1, a_2, dots, a_n$$$ ($$$0 le a_i le n$$$)xa0β elements of the array $$$a$$$. It is guaranteed that the sum of the values $$$n$$$ over all test cases in the test does not exceed $$$2cdot10^5$$$. Output For each test case, output $$$n + 1$$$ integerxa0β $$$i$$$-th number is equal to the minimum number of operations for which you can make the array $$$mathrm{MEX}$$$ equal to $$$i$$$ ($$$0 le i le n$$$), or -1 if this cannot be done. Example Input 5 3 0 1 3 7 0 1 2 3 4 3 2 4 3 0 0 0 7 4 6 2 3 5 0 5 5 4 0 1 0 4 Output 1 1 0 -1 1 1 2 2 1 0 2 6 3 0 1 4 3 1 0 -1 -1 -1 -1 -1 -1 2 1 0 2 -1 -1 Note In the first set of example inputs, $$$n=3$$$: to get $$$mathrm{MEX}=0$$$, it is enough to perform one increment: $$$a_1$$$++; to get $$$mathrm{MEX}=1$$$, it is enough to perform one increment: $$$a_2$$$++; $$$mathrm{MEX}=2$$$ for a given array, so there is no need to perform increments; it is impossible to get $$$mathrm{MEX}=3$$$ by performing increments. | 1,700 | true | true | true | true | true | true | false | false | true | false | 2,531 |
465B | Over time, Alexey's mail box got littered with too many letters. Some of them are read, while others are unread. Alexey's mail program can either show a list of all letters or show the content of a single letter. As soon as the program shows the content of an unread letter, it becomes read letter (if the program shows the content of a read letter nothing happens). In one click he can do any of the following operations: Move from the list of letters to the content of any single letter. Return to the list of letters from single letter viewing mode. In single letter viewing mode, move to the next or to the previous letter in the list. You cannot move from the first letter to the previous one or from the last letter to the next one. The program cannot delete the letters from the list or rearrange them. Alexey wants to read all the unread letters and go watch football. Now he is viewing the list of all letters and for each letter he can see if it is read or unread. What minimum number of operations does Alexey need to perform to read all unread letters? Input The first line contains a single integer _n_ (1u2009β€u2009_n_u2009β€u20091000) β the number of letters in the mailbox. The second line contains _n_ space-separated integers (zeros and ones) β the state of the letter list. The _i_-th number equals either 1, if the _i_-th number is unread, or 0, if the _i_-th letter is read. Output Print a single number β the minimum number of operations needed to make all the letters read. Note In the first sample Alexey needs three operations to cope with the task: open the second letter, move to the third one, move to the fourth one. In the second sample the action plan: open the first letter, move to the second letter, return to the list, open the fifth letter. In the third sample all letters are already read. | 1,000 | false | false | true | false | false | false | false | false | false | false | 7,978 |
1209F | Koala Land consists of $$$m$$$ bidirectional roads connecting $$$n$$$ cities. The roads are numbered from $$$1$$$ to $$$m$$$ by order in input. It is guaranteed, that one can reach any city from every other city. Koala starts traveling from city $$$1$$$. Whenever he travels on a road, he writes its number down in his notebook. He doesn't put spaces between the numbers, so they all get concatenated into a single number. Before embarking on his trip, Koala is curious about the resulting number for all possible destinations. For each possible destination, what is the smallest number he could have written for it? Since these numbers may be quite large, print their remainders modulo $$$10^9+7$$$. Please note, that you need to compute the remainder of the minimum possible number, not the minimum possible remainder. Input The first line contains two integers $$$n$$$ and $$$m$$$ ($$$2 le n le 10^5, n - 1 le m le 10^5$$$), the number of cities and the number of roads, respectively. The $$$i$$$-th of the following $$$m$$$ lines contains integers $$$x_i$$$ and $$$y_i$$$ ($$$1 le x_i, y_i le n$$$, $$$x_i e y_i$$$), representing a bidirectional road between cities $$$x_i$$$ and $$$y_i$$$. It is guaranteed, that for any pair of cities there is at most one road connecting them, and that one can reach any city from every other city. Output Print $$$n - 1$$$ integers, the answer for every city except for the first city. The $$$i$$$-th integer should be equal to the smallest number he could have written for destination $$$i+1$$$. Since this number may be large, output its remainder modulo $$$10^9+7$$$. Examples Input 11 10 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 Output 1 12 123 1234 12345 123456 1234567 12345678 123456789 345678826 Input 12 19 1 2 2 3 2 4 2 5 2 6 2 7 2 8 2 9 2 10 3 11 11 12 1 3 1 4 1 5 1 6 1 7 1 8 1 9 1 10 Output 1 12 13 14 15 16 17 18 19 1210 121011 Input 12 14 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 1 3 1 4 1 10 Output 1 12 13 134 1345 13456 1498 149 14 1410 141011 | 2,600 | false | false | false | false | true | false | false | false | false | true | 4,640 |
1819B | Anton plays his favorite game "Defense of The Ancients 2" for his favorite heroxa0β The Butcher. Now he wants to make his own dinner. To do this he will take a rectangle of height $$$h$$$ and width $$$w$$$, then make a vertical or horizontal cut so that both resulting parts have integer sides. After that, he will put one of the parts in the box and cut the other again, and so on. More formally, a rectangle of size $$$h imes w$$$ can be cut into two parts of sizes $$$x imes w$$$ and $$$(h - x) imes w$$$, where $$$x$$$ is an integer from $$$1$$$ to $$$(h - 1)$$$, or into two parts of sizes $$$h imes y$$$ and $$$h imes (w - y)$$$, where $$$y$$$ is an integer from $$$1$$$ to $$$(w - 1)$$$. He will repeat this operation $$$n - 1$$$ times, and then put the remaining rectangle into the box too. Thus, the box will contain $$$n$$$ rectangles, of which $$$n - 1$$$ rectangles were put in the box as a result of the cuts, and the $$$n$$$-th rectangle is the one that the Butcher has left after all $$$n - 1$$$ cuts. Unfortunately, Butcher forgot the numbers $$$h$$$ and $$$w$$$, but he still has $$$n$$$ rectangles mixed in random order. Note that Butcher didn't rotate the rectangles, but only shuffled them. Now he wants to know all possible pairs $$$(h, w)$$$ from which this set of rectangles can be obtained. And you have to help him do it! It is guaranteed that there exists at least one pair $$$(h, w)$$$ from which this set of rectangles can be obtained. 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 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 number of rectangles obtained. The $$$i$$$-th of the next $$$n$$$ lines contains two integers $$$a_i$$$ and $$$b_i$$$ ($$$1 le a_i, b_i le 10^6$$$)xa0β the height and width of the $$$i$$$-th rectangle. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$2 cdot 10^5$$$. Output For each test case, on the first line output a single integer $$$m$$$xa0β the number of pairs $$$(h, w)$$$ denoting the sizes of rectangles from which the given rectangles can be obtained. Two rectangles are considered different if they have different heights or widths. On each of the following $$$m$$$ lines print output integers $$$h_i$$$ and $$$w_i$$$xa0β the height and width of the rectangle from which the given rectangles can be obtained. You can output the rectangles in any order. Note In the first test case, Butcher could only have a rectangle of size $$$4 imes 5$$$. Then the cuts could look like this (first the green cut was made, then the red one): In the second test case, Butcher could have either a rectangle of $$$1 imes 3$$$ or $$$3 imes 1$$$. The cuts would have looked like this (first the green cut was made, then the red cut): In the third test case, Butcher did not make any cuts, so the rectangle is $$$10 imes 10$$$. | 1,900 | false | true | true | false | false | false | false | false | true | false | 1,364 |
1811D | The girl Umka loves to travel and participate in math olympiads. One day she was flying by plane to the next olympiad and out of boredom explored a huge checkered sheet of paper. Denote the $$$n$$$-th Fibonacci number as $$$F_n = begin{cases} 1, & n = 0; 1, & n = 1; F_{n-2} + F_{n-1}, & n ge 2. end{cases}$$$ A checkered rectangle with a height of $$$F_n$$$ and a width of $$$F_{n+1}$$$ is called a Fibonacci rectangle of order $$$n$$$. Umka has a Fibonacci rectangle of order $$$n$$$. Someone colored a cell in it at the intersection of the row $$$x$$$ and the column $$$y$$$. It is necessary to cut this rectangle exactly into $$$n+1$$$ squares in such way that the painted cell was in a square with a side of $$$1$$$; there was at most one pair of squares with equal sides; the side of each square was equal to a Fibonacci number. Will Umka be able to cut this rectangle in that way? Input The first line contains an integer $$$t$$$ ($$$1 le t le 2 cdot 10^5$$$)xa0β number of test cases. For each test case the integers $$$n$$$, $$$x$$$, $$$y$$$ are given ($$$1 le n le 44$$$, $$$1 le x le F_n$$$, $$$1 le y le F_{n+1}$$$)xa0β the order of the Fibonacci rectangle and the coordinates of the colored cell. Output For each test case, print "YES" if the answer is positive, and "NO" otherwise. You can print "YES" and "NO" in any case (for example, the strings "yEs", "yes" and "Yes" will be recognized as a positive answer). Example Input 12 1 1 1 2 1 2 3 1 4 3 3 2 4 4 6 4 3 3 5 6 5 5 4 12 5 2 12 4 2 1 1 1 2 44 758465880 1277583853 Output YES NO YES YES YES NO YES NO NO YES YES NO Note The first, third and fourth test cases. | 1,600 | true | false | true | false | false | true | false | false | false | false | 1,402 |
296A | Problem - 296A - 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 greedy math *1100 No tag edit access β Contest materials β the number of elements in the array. The second line contains _n_ integers _a_1,u2009_a_2,u2009...,u2009_a__n_ (1u2009β€u2009_a__i_u2009β€u20091000) β the array elements. Output In the single line print "YES" (without the quotes) if Yaroslav can obtain the array he needs, and "NO" (without the quotes) otherwise. Examples Input 1 1 Output YES Input 3 1 1 2 Output YES Input 4 7 7 7 7 Output NO Note In the first sample the initial array fits well. In the second sample Yaroslav can get array: 1, 2, 1. He can swap the last and the second last elements to obtain it. In the third sample Yarosav can't get the array he needs. | 1,100 | true | true | false | false | false | false | false | false | false | false | 8,646 |
1696G | Suppose you are given a 1-indexed sequence $$$a$$$ of non-negative integers, whose length is $$$n$$$, and two integers $$$x$$$, $$$y$$$. In consecutive $$$t$$$ seconds ($$$t$$$ can be any positive real number), you can do one of the following operations: Select $$$1le i<n$$$, decrease $$$a_i$$$ by $$$xcdot t$$$, and decrease $$$a_{i+1}$$$ by $$$ycdot t$$$. Select $$$1le i<n$$$, decrease $$$a_i$$$ by $$$ycdot t$$$, and decrease $$$a_{i+1}$$$ by $$$xcdot t$$$. Define the minimum amount of time (it might be a real number) required to make all elements in the sequence less than or equal to $$$0$$$ as $$$f(a)$$$. For example, when $$$x=1$$$, $$$y=2$$$, it takes $$$3$$$ seconds to deal with the array $$$[3,1,1,3]$$$. We can: In the first $$$1.5$$$ seconds do the second operation with $$$i=1$$$. In the next $$$1.5$$$ seconds do the first operation with $$$i=3$$$. We can prove that it's not possible to make all elements less than or equal to $$$0$$$ in less than $$$3$$$ seconds, so $$$f([3,1,1,3])=3$$$. Now you are given a 1-indexed sequence $$$b$$$ of positive integers, whose length is $$$n$$$. You are also given positive integers $$$x$$$, $$$y$$$. Process $$$q$$$ queries of the following two types: 1 k v: change $$$b_k$$$ to $$$v$$$. 2 l r: print $$$f([b_l,b_{l+1},dots,b_r])$$$. Input The first line of input contains two integers $$$n$$$ and $$$q$$$ ($$$2le nle 2cdot 10^5$$$, $$$1le qle 2cdot 10^5$$$). The second line of input contains two integers $$$x$$$ and $$$y$$$ ($$$1le x,yle 10^6$$$). The third line of input contains $$$n$$$ integers $$$b_1,b_2,ldots,b_n$$$ ($$$1le b_ile 10^6$$$). This is followed by $$$q$$$ lines. Each of these $$$q$$$ lines contains three integers. The first integer $$$op$$$ is either $$$1$$$ or $$$2$$$. If it is $$$1$$$, it is followed by two integers $$$k$$$, $$$v$$$ ($$$1le kle n$$$, $$$1le vle 10^6$$$). It means that you should change $$$b_k$$$ to $$$v$$$. If it is $$$2$$$, it is followed by two integers $$$l$$$, $$$r$$$ ($$$1le l<rle n$$$). It means that you should print $$$f([b_l,b_{l+1},dots,b_r])$$$. Output For each query of type $$$2$$$, print one real number β the answer to the query. Your answer is considered correct if its absolute error or relative error does not exceed $$$10^{-9}$$$. Example Input 4 3 1 2 3 1 1 4 2 1 4 1 1 1 2 1 3 Output 3.500000000000000 1.000000000000000 Note Let's analyse the sample. In the first query, we are asked to compute $$$f([3,1,1,4])$$$. The answer is $$$3.5$$$. One optimal sequence of operations is: In the first $$$1.5$$$ seconds do the second operation with $$$i=1$$$. In the next $$$2$$$ seconds do the first operation with $$$i=3$$$. In the third query, we are asked to compute $$$f([1,1,1])$$$. The answer is $$$1$$$. One optimal sequence of operations is: In the first $$$0.5$$$ seconds do the second operation with $$$i=1$$$. In the next $$$0.5$$$ seconds do the first operation with $$$i=2$$$. | 3,300 | true | false | false | false | true | false | true | false | false | false | 2,102 |
1296D | There are $$$n$$$ monsters standing in a row numbered from $$$1$$$ to $$$n$$$. The $$$i$$$-th monster has $$$h_i$$$ health points (hp). You have your attack power equal to $$$a$$$ hp and your opponent has his attack power equal to $$$b$$$ hp. You and your opponent are fighting these monsters. Firstly, you and your opponent go to the first monster and fight it till his death, then you and your opponent go the second monster and fight it till his death, and so on. A monster is considered dead if its hp is less than or equal to $$$0$$$. The fight with a monster happens in turns. 1. You hit the monster by $$$a$$$ hp. If it is dead after your hit, you gain one point and you both proceed to the next monster. 2. Your opponent hits the monster by $$$b$$$ hp. If it is dead after his hit, nobody gains a point and you both proceed to the next monster. You have some secret technique to force your opponent to skip his turn. You can use this technique at most $$$k$$$ times in total (for example, if there are two monsters and $$$k=4$$$, then you can use the technique $$$2$$$ times on the first monster and $$$1$$$ time on the second monster, but not $$$2$$$ times on the first monster and $$$3$$$ times on the second monster). Your task is to determine the maximum number of points you can gain if you use the secret technique optimally. Input The first line of the input contains four integers $$$n, a, b$$$ and $$$k$$$ ($$$1 le n le 2 cdot 10^5, 1 le a, b, k le 10^9$$$) β the number of monsters, your attack power, the opponent's attack power and the number of times you can use the secret technique. The second line of the input contains $$$n$$$ integers $$$h_1, h_2, dots, h_n$$$ ($$$1 le h_i le 10^9$$$), where $$$h_i$$$ is the health points of the $$$i$$$-th monster. Output Print one integer β the maximum number of points you can gain if you use the secret technique optimally. Examples Input 6 2 3 3 7 10 50 12 1 8 Input 7 4 2 1 1 3 5 4 2 7 6 | 1,500 | false | true | false | false | false | false | false | false | true | false | 4,214 |
767A | According to an old legeng, a long time ago Ankh-Morpork residents did something wrong to miss Fortune, and she cursed them. She said that at some time _n_ snacks of distinct sizes will fall on the city, and the residents should build a Snacktower of them by placing snacks one on another. Of course, big snacks should be at the bottom of the tower, while small snacks should be at the top. Years passed, and once different snacks started to fall onto the city, and the residents began to build the Snacktower. However, they faced some troubles. Each day exactly one snack fell onto the city, but their order was strange. So, at some days the residents weren't able to put the new stack on the top of the Snacktower: they had to wait until all the bigger snacks fell. Of course, in order to not to anger miss Fortune again, the residents placed each snack on the top of the tower immediately as they could do it. Write a program that models the behavior of Ankh-Morpork residents. Input The first line contains single integer _n_ (1u2009β€u2009_n_u2009β€u2009100u2009000)xa0β the total number of snacks. The second line contains _n_ integers, the _i_-th of them equals the size of the snack which fell on the _i_-th day. Sizes are distinct integers from 1 to _n_. Output Print _n_ lines. On the _i_-th of them print the sizes of the snacks which the residents placed on the top of the Snacktower on the _i_-th day in the order they will do that. If no snack is placed on some day, leave the corresponding line empty. Note In the example a snack of size 3 fell on the first day, and the residents immediately placed it. On the second day a snack of size 1 fell, and the residents weren't able to place it because they were missing the snack of size 2. On the third day a snack of size 2 fell, and the residents immediately placed it. Right after that they placed the snack of size 1 which had fallen before. | 1,100 | false | false | true | false | true | false | false | false | false | false | 6,718 |
813E | As you might remember from our previous rounds, Vova really likes computer games. Now he is playing a strategy game known as Rage of Empires. In the game Vova can hire _n_ different warriors; _i_th warrior has the type _a__i_. Vova wants to create a balanced army hiring some subset of warriors. An army is called balanced if for each type of warrior present in the game there are not more than _k_ warriors of this type in the army. Of course, Vova wants his army to be as large as possible. To make things more complicated, Vova has to consider _q_ different plans of creating his army. _i_th plan allows him to hire only warriors whose numbers are not less than _l__i_ and not greater than _r__i_. Help Vova to determine the largest size of a balanced army for each plan. Be aware that the plans are given in a modified way. See input section for details. Input The first line contains two integers _n_ and _k_ (1u2009β€u2009_n_,u2009_k_u2009β€u2009100000). The second line contains _n_ integers _a_1, _a_2, ... _a__n_ (1u2009β€u2009_a__i_u2009β€u2009100000). The third line contains one integer _q_ (1u2009β€u2009_q_u2009β€u2009100000). Then _q_ lines follow. _i_th line contains two numbers _x__i_ and _y__i_ which represent _i_th plan (1u2009β€u2009_x__i_,u2009_y__i_u2009β€u2009_n_). You have to keep track of the answer to the last plan (let's call it _last_). In the beginning _last_u2009=u20090. Then to restore values of _l__i_ and _r__i_ for the _i_th plan, you have to do the following: 1. _l__i_u2009=u2009((_x__i_u2009+u2009_last_)xa0_mod_xa0_n_)u2009+u20091; 2. _r__i_u2009=u2009((_y__i_u2009+u2009_last_)xa0_mod_xa0_n_)u2009+u20091; 3. If _l__i_u2009>u2009_r__i_, swap _l__i_ and _r__i_. Output Print _q_ numbers. _i_th number must be equal to the maximum size of a balanced army when considering _i_th plan. Example Input 6 2 1 1 1 2 2 2 5 1 6 4 3 1 1 2 6 2 6 Note In the first example the real plans are: 1. 1xa02 2. 1xa06 3. 6xa06 4. 2xa04 5. 4xa06 | 2,200 | false | false | false | false | true | false | false | true | false | false | 6,507 |
400D | Dima took up the biology of bacteria, as a result of his experiments, he invented _k_ types of bacteria. Overall, there are _n_ bacteria at his laboratory right now, and the number of bacteria of type _i_ equals _c__i_. For convenience, we will assume that all the bacteria are numbered from 1 to _n_. The bacteria of type _c__i_ are numbered from to . With the help of special equipment Dima can move energy from some bacteria into some other one. Of course, the use of such equipment is not free. Dima knows _m_ ways to move energy from some bacteria to another one. The way with number _i_ can be described with integers _u__i_, _v__i_ and _x__i_ mean that this way allows moving energy from bacteria with number _u__i_ to bacteria with number _v__i_ or vice versa for _x__i_ dollars. Dima's Chef (Inna) calls the type-distribution correct if there is a way (may be non-direct) to move energy from any bacteria of the particular type to any other bacteria of the same type (between any two bacteria of the same type) for zero cost. As for correct type-distribution the cost of moving the energy depends only on the types of bacteria help Inna to determine is the type-distribution correct? If it is, print the matrix _d_ with size _k_u2009Γu2009_k_. Cell _d_[_i_][_j_] of this matrix must be equal to the minimal possible cost of energy-moving from bacteria with type _i_ to bacteria with type _j_. Input The first line contains three integers _n_,u2009_m_,u2009_k_ (1u2009β€u2009_n_u2009β€u2009105;xa00u2009β€u2009_m_u2009β€u2009105;xa01u2009β€u2009_k_u2009β€u2009500). The next line contains _k_ integers _c_1,u2009_c_2,u2009...,u2009_c__k_ (1u2009β€u2009_c__i_u2009β€u2009_n_). Each of the next _m_ lines contains three integers _u__i_,u2009_v__i_,u2009_x__i_ (1u2009β€u2009_u__i_,u2009_v__i_u2009β€u2009105;xa00u2009β€u2009_x__i_u2009β€u2009104). It is guaranteed that . Output If Dima's type-distribution is correct, print string Β«YesΒ», and then _k_ lines: in the _i_-th line print integers _d_[_i_][1],u2009_d_[_i_][2],u2009...,u2009_d_[_i_][_k_] (_d_[_i_][_i_]u2009=u20090). If there is no way to move energy from bacteria _i_ to bacteria _j_ appropriate _d_[_i_][_j_] must equal to -1. If the type-distribution isn't correct print Β«NoΒ». Examples Input 4 4 2 1 3 2 3 0 3 4 0 2 4 1 2 1 2 | 2,000 | false | false | false | false | false | false | false | false | false | true | 8,224 |
1768B | You are given a permutation$$$^dagger$$$ $$$p$$$ of length $$$n$$$ and a positive integer $$$k le n$$$. In one operation, you: Choose $$$k$$$ distinct elements $$$p_{i_1}, p_{i_2}, ldots, p_{i_k}$$$. Remove them and then add them sorted in increasing order to the end of the permutation. For example, if $$$p = [2,5,1,3,4]$$$ and $$$k = 2$$$ and you choose $$$5$$$ and $$$3$$$ as the elements for the operation, then $$$[2, color{red}{5}, 1, color{red}{3}, 4] ightarrow [2, 1, 4, color{red}{3},color{red}{5}]$$$. Find the minimum number of operations needed to sort the permutation in increasing order. It can be proven that it is always possible to do so. $$$^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 The first line 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 two integers $$$n$$$ and $$$k$$$ ($$$2 le n le 10^5$$$, $$$1 le k le n$$$). The second line of each test case contains $$$n$$$ integers $$$p_1,p_2,ldots, p_n$$$ ($$$1 le p_i le n$$$). It is guaranteed that $$$p$$$ is a permutation. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$. Output For each test case output a single integerxa0β the minimum number of operations needed to sort the permutation. It can be proven that it is always possible to do so. Example Input 4 3 2 1 2 3 3 1 3 1 2 4 2 1 3 2 4 4 2 2 3 1 4 Note In the first test case, the permutation is already sorted. In the second test case, you can choose element $$$3$$$, and the permutation will become sorted as follows: $$$[color{red}{3}, 1, 2] ightarrow [1, 2, color{red}{3}]$$$. In the third test case, you can choose elements $$$3$$$ and $$$4$$$, and the permutation will become sorted as follows: $$$[1, color{red}{3}, 2, color{red}{4}] ightarrow [1, 2, color{red}{3},color{red}{4}]$$$. In the fourth test case, it can be shown that it is impossible to sort the permutation in $$$1$$$ operation. However, if you choose elements $$$2$$$ and $$$1$$$ in the first operation, and choose elements $$$3$$$ and $$$4$$$ in the second operation, the permutation will become sorted as follows: $$$[color{red}{2}, 3, color{red}{1}, 4] ightarrow [color{blue}{3}, color{blue}{4}, color{red}{1}, color{red}{2}] ightarrow [1,2, color{blue}{3}, color{blue}{4}]$$$. | 900 | true | true | false | false | false | false | false | false | false | false | 1,690 |
63B | In a strategic computer game "Settlers II" one has to build defense structures to expand and protect the territory. Let's take one of these buildings. At the moment the defense structure accommodates exactly _n_ soldiers. Within this task we can assume that the number of soldiers in the defense structure won't either increase or decrease. Every soldier has a rank β some natural number from 1 to _k_. 1 stands for a private and _k_ stands for a general. The higher the rank of the soldier is, the better he fights. Therefore, the player profits from having the soldiers of the highest possible rank. To increase the ranks of soldiers they need to train. But the soldiers won't train for free, and each training session requires one golden coin. On each training session all the _n_ soldiers are present. At the end of each training session the soldiers' ranks increase as follows. First all the soldiers are divided into groups with the same rank, so that the least possible number of groups is formed. Then, within each of the groups where the soldiers below the rank _k_ are present, exactly one soldier increases his rank by one. You know the ranks of all _n_ soldiers at the moment. Determine the number of golden coins that are needed to increase the ranks of all the soldiers to the rank _k_. Input The first line contains two integers _n_ and _k_ (1u2009β€u2009_n_,u2009_k_u2009β€u2009100). They represent the number of soldiers and the number of different ranks correspondingly. The second line contains _n_ numbers in the non-decreasing order. The _i_-th of them, _a__i_, represents the rank of the _i_-th soldier in the defense building (1u2009β€u2009_i_u2009β€u2009_n_, 1u2009β€u2009_a__i_u2009β€u2009_k_). Output Print a single integer β the number of golden coins needed to raise all the soldiers to the maximal rank. Note In the first example the ranks will be raised in the following manner: 1 2 2 3 u2009βu2009 2 2 3 4 u2009βu2009 2 3 4 4 u2009βu2009 3 4 4 4 u2009βu2009 4 4 4 4 Thus totals to 4 training sessions that require 4 golden coins. | 1,200 | false | false | true | false | false | false | false | false | false | false | 9,659 |
128C | In this task Anna and Maria play the following game. Initially they have a checkered piece of paper with a painted _n_u2009Γu2009_m_ rectangle (only the border, no filling). Anna and Maria move in turns and Anna starts. During each move one should paint inside the last-painted rectangle a new lesser rectangle (along the grid lines). The new rectangle should have no common points with the previous one. Note that when we paint a rectangle, we always paint only the border, the rectangles aren't filled. Nobody wins the game β Anna and Maria simply play until they have done _k_ moves in total. Count the number of different ways to play this game. Input The first and only line contains three integers: _n_,u2009_m_,u2009_k_ (1u2009β€u2009_n_,u2009_m_,u2009_k_u2009β€u20091000). Output Print the single number β the number of the ways to play the game. As this number can be very big, print the value modulo 1000000007 (109u2009+u20097). Note Two ways to play the game are considered different if the final pictures are different. In other words, if one way contains a rectangle that is not contained in the other way. In the first sample Anna, who performs her first and only move, has only one possible action plan β insert a 1u2009Γu20091 square inside the given 3u2009Γu20093 square. In the second sample Anna has as much as 9 variants: 4 ways to paint a 1u2009Γu20091 square, 2 ways to insert a 1u2009Γu20092 rectangle vertically, 2 more ways to insert it horizontally and one more way is to insert a 2u2009Γu20092 square. | 2,000 | false | false | false | true | false | false | false | false | false | false | 9,368 |
1667E | Consider every tree (connected undirected acyclic graph) with $$$n$$$ vertices ($$$n$$$ is odd, vertices numbered from $$$1$$$ to $$$n$$$), and for each $$$2 le i le n$$$ the $$$i$$$-th vertex is adjacent to exactly one vertex with a smaller index. For each $$$i$$$ ($$$1 le i le n$$$) calculate the number of trees for which the $$$i$$$-th vertex will be the centroid. The answer can be huge, output it modulo $$$998,244,353$$$. A vertex is called a centroid if its removal splits the tree into subtrees with at most $$$(n-1)/2$$$ vertices each. Input The first line contains an odd integer $$$n$$$ ($$$3 le n < 2 cdot 10^5$$$, $$$n$$$ is odd) β the number of the vertices in the tree. Output Print $$$n$$$ integers in a single line, the $$$i$$$-th integer is the answer for the $$$i$$$-th vertex (modulo $$$998,244,353$$$). Examples Output 276 276 132 36 0 0 0 Note Example $$$1$$$: there are two possible trees: with edges $$$(1-2)$$$, and $$$(1-3)$$$ β here the centroid is $$$1$$$; and with edges $$$(1-2)$$$, and $$$(2-3)$$$ β here the centroid is $$$2$$$. So the answer is $$$1, 1, 0$$$. Example $$$2$$$: there are $$$24$$$ possible trees, for example with edges $$$(1-2)$$$, $$$(2-3)$$$, $$$(3-4)$$$, and $$$(4-5)$$$. Here the centroid is $$$3$$$. | 3,000 | true | false | false | true | false | false | false | false | false | false | 2,269 |
1617D2 | 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 $$$n+6$$$ 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$$$)xa0β 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 $$$n+6$$$ 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. 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$$$. | 2,400 | true | false | true | false | false | true | false | false | false | false | 2,544 |
1990D | You are given an array $$$a$$$ of size $$$n$$$. There is an $$$n imes n$$$ grid. In the $$$i$$$-th row, the first $$$a_i$$$ cells are black and the other cells are white. In other words, note $$$(i,j)$$$ as the cell in the $$$i$$$-th row and $$$j$$$-th column, cells $$$(i,1), (i,2), ldots, (i,a_i)$$$ are black, and cells $$$(i,a_i+1), ldots, (i,n)$$$ are white. You can do the following operations any number of times in any order: Dye a $$$2 imes 2$$$ subgrid white; Dye a whole row white. Note you can not dye a whole column white. Find the minimum number of operations to dye all cells white. Input The first line contains an integer $$$t$$$ ($$$1 leq t leq 10^4$$$)xa0β the number of test cases. For each test case: The first line contains an integer $$$n$$$ ($$$1 leq n leq 2 cdot 10^5$$$)xa0β the size of the array $$$a$$$. The second line contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$0 leq a_i leq n$$$). It's guaranteed that the sum of $$$n$$$ over all test cases will not exceed $$$2 cdot 10^5$$$. Output For each test case, output a single integerxa0β the minimum number of operations to dye all cells white. Example Input 10 1 0 4 2 4 4 2 4 3 2 1 0 3 0 3 0 3 0 1 3 3 3 1 0 4 3 1 0 3 4 0 2 2 2 6 1 3 4 2 0 4 8 2 2 5 2 3 4 2 4 Output 0 3 2 1 2 2 3 2 4 6 Note In the first test case, you don't need to do any operation. In the second test case, you can do: Dye $$$(1,1), (1,2), (2,1)$$$, and $$$(2,2)$$$ white; Dye $$$(2,3), (2,4), (3,3)$$$, and $$$(3,4)$$$ white; Dye $$$(3,1), (3,2), (4,1)$$$, and $$$(4,2)$$$ white. It can be proven $$$3$$$ is the minimum number of operations. In the third test case, you can do: Dye the first row white; Dye $$$(2,1), (2,2), (3,1)$$$, and $$$(3,2)$$$ white. It can be proven $$$2$$$ is the minimum number of operations. | 1,800 | false | true | true | true | false | false | true | false | false | false | 332 |
724G | You are given an undirected graph, constisting of _n_ vertices and _m_ edges. Each edge of the graph has some non-negative integer written on it. Let's call a triple (_u_,u2009_v_,u2009_s_) interesting, if 1u2009β€u2009_u_u2009<u2009_v_u2009β€u2009_n_ and there is a path (possibly non-simple, i.e. it can visit the same vertices and edges multiple times) between vertices _u_ and _v_ such that xor of all numbers written on the edges of this path is equal to _s_. When we compute the value s for some path, each edge is counted in xor as many times, as it appear on this path. It's not hard to prove that there are finite number of such triples. Calculate the sum over modulo 109u2009+u20097 of the values of _s_ over all interesting triples. Input The first line of the input contains two integers _n_ andxa0_m_ (1u2009β€u2009_n_u2009β€u2009100u2009000, 0u2009β€u2009_m_u2009β€u2009200u2009000)xa0β numbers of vertices and edges in the given graph. The follow _m_ lines contain three integers _u__i_, _v__i_ andxa0_t__i_ (1u2009β€u2009_u__i_,u2009_v__i_u2009β€u2009_n_, 0u2009β€u2009_t__i_u2009β€u20091018, _u__i_u2009β u2009_v__i_)xa0β vertices connected by the edge and integer written on it. It is guaranteed that graph doesn't contain self-loops and multiple edges. Output Print the single integer, equal to the described sum over modulo 109u2009+u20097. Examples Input 4 4 1 2 1 1 3 2 2 3 3 3 4 1 Input 4 4 1 2 1 2 3 2 3 4 4 4 1 8 Input 8 6 1 2 2 2 3 1 2 4 4 4 5 5 4 6 3 7 8 5 Note In the first example the are 6 interesting triples: 1. (1,u20092,u20091) 2. (1,u20093,u20092) 3. (1,u20094,u20093) 4. (2,u20093,u20093) 5. (2,u20094,u20092) 6. (3,u20094,u20091) The sum is equal to 1u2009+u20092u2009+u20093u2009+u20093u2009+u20092u2009+u20091u2009=u200912. In the second example the are 12 interesting triples: 1. (1,u20092,u20091) 2. (2,u20093,u20092) 3. (1,u20093,u20093) 4. (3,u20094,u20094) 5. (2,u20094,u20096) 6. (1,u20094,u20097) 7. (1,u20094,u20098) 8. (2,u20094,u20099) 9. (3,u20094,u200911) 10. (1,u20093,u200912) 11. (2,u20093,u200913) 12. (1,u20092,u200914) The sum is equal to 1u2009+u20092u2009+u20093u2009+u20094u2009+u20096u2009+u20097u2009+u20098u2009+u20099u2009+u200911u2009+u200912u2009+u200913u2009+u200914u2009=u200990. | 2,600 | true | false | false | false | false | false | false | false | false | true | 6,908 |
115D | Let's define an unambiguous arithmetic expression (UAE) as follows. All non-negative integers are UAE's. Integers may have leading zeroes (for example, 0000 and 0010 are considered valid integers). If _X_ and _Y_ are two UAE's, then "(_X_)u2009+u2009(_Y_)", "(_X_)u2009-u2009(_Y_)", "(_X_)u2009*u2009(_Y_)", and "(_X_)u2009/u2009(_Y_)" (all without the double quotes) are UAE's. If _X_ is an UAE, then "u2009-u2009(_X_)" and "u2009+u2009(_X_)" (both without the double quotes) are UAE's.You are given a string consisting only of digits ("0" - "9") and characters "-", "+", "*", and "/". Your task is to compute the number of different possible unambiguous arithmetic expressions such that if all brackets (characters "(" and ")") of that unambiguous arithmetic expression are removed, it becomes the input string. Since the answer may be very large, print it modulo 1000003 (106u2009+u20093). Input The first line is a non-empty string consisting of digits ('0'-'9') and characters '-', '+', '*', and/or '/'. Its length will not exceed 2000. The line doesn't contain any spaces. Output Print a single integer representing the number of different unambiguous arithmetic expressions modulo 1000003 (106u2009+u20093) such that if all its brackets are removed, it becomes equal to the input string (character-by-character). Examples Input 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1 Note For the first example, the two possible unambiguous arithmetic expressions are: ((1)u2009+u2009(2))u2009*u2009(3) (1)u2009+u2009((2)u2009*u2009(3)) For the second example, the three possible unambiguous arithmetic expressions are: (03)u2009+u2009((u2009-u2009(30))u2009+u2009(40)) (03)u2009+u2009(u2009-u2009((30)u2009+u2009(40))) ((03)u2009+u2009(u2009-u2009(30)))u2009+u2009(40) | 2,600 | false | false | false | true | false | false | false | false | false | false | 9,425 |
1473F | Problem - 1473F - 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 flows math *2700 No tag edit access β Contest materials . The second line contains $$$n$$$ integers $$$a_1, a_2, dots, a_n$$$ ($$$1 le a_i le 100$$$). The third line contains $$$n$$$ integers $$$b_1, b_2, dots, b_n$$$ ($$$-10^5 le b_i le 10^5$$$). Output Print one integer β the maximum cost of a strange set. Examples Input 9 4 7 3 4 5 6 7 8 13 -2 3 -19 5 -6 7 -8 9 1 Output 16 Input 2 42 42 -37 13 Output 0 Input 2 42 42 13 -37 Output 13 Note The strange set with the maximum cost in the first example is $$${1, 2, 4, 8, 9}$$$. The strange set with the maximum cost in the second example is empty. | 2,700 | true | false | false | false | false | false | false | false | false | false | 3,312 |
1004C | Since Sonya is interested in robotics too, she decided to construct robots that will read and recognize numbers. Sonya has drawn $$$n$$$ numbers in a row, $$$a_i$$$ is located in the $$$i$$$-th position. She also has put a robot at each end of the row (to the left of the first number and to the right of the last number). Sonya will give a number to each robot (they can be either same or different) and run them. When a robot is running, it is moving toward to another robot, reading numbers in the row. When a robot is reading a number that is equal to the number that was given to that robot, it will turn off and stay in the same position. Sonya does not want robots to break, so she will give such numbers that robots will stop before they meet. That is, the girl wants them to stop at different positions so that the first robot is to the left of the second one. For example, if the numbers $$$[1, 5, 4, 1, 3]$$$ are written, and Sonya gives the number $$$1$$$ to the first robot and the number $$$4$$$ to the second one, the first robot will stop in the $$$1$$$-st position while the second one in the $$$3$$$-rd position. In that case, robots will not meet each other. As a result, robots will not be broken. But if Sonya gives the number $$$4$$$ to the first robot and the number $$$5$$$ to the second one, they will meet since the first robot will stop in the $$$3$$$-rd position while the second one is in the $$$2$$$-nd position. Sonya understands that it does not make sense to give a number that is not written in the row because a robot will not find this number and will meet the other robot. Sonya is now interested in finding the number of different pairs that she can give to robots so that they will not meet. In other words, she wants to know the number of pairs ($$$p$$$, $$$q$$$), where she will give $$$p$$$ to the first robot and $$$q$$$ to the second one. Pairs ($$$p_i$$$, $$$q_i$$$) and ($$$p_j$$$, $$$q_j$$$) are different if $$$p_i eq p_j$$$ or $$$q_i eq q_j$$$. Unfortunately, Sonya is busy fixing robots that broke after a failed launch. That is why she is asking you to find the number of pairs that she can give to robots so that they will not meet. Input The first line contains a single integer $$$n$$$ ($$$1leq nleq 10^5$$$)xa0β the number of numbers in a row. The second line contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$1leq a_ileq 10^5$$$)xa0β the numbers in a row. Note In the first example, Sonya can give pairs ($$$1$$$, $$$1$$$), ($$$1$$$, $$$3$$$), ($$$1$$$, $$$4$$$), ($$$1$$$, $$$5$$$), ($$$4$$$, $$$1$$$), ($$$4$$$, $$$3$$$), ($$$5$$$, $$$1$$$), ($$$5$$$, $$$3$$$), and ($$$5$$$, $$$4$$$). In the second example, Sonya can give pairs ($$$1$$$, $$$1$$$), ($$$1$$$, $$$2$$$), ($$$1$$$, $$$3$$$), ($$$2$$$, $$$1$$$), ($$$2$$$, $$$2$$$), ($$$2$$$, $$$3$$$), and ($$$3$$$, $$$2$$$). | 1,400 | false | false | true | false | false | true | false | false | false | false | 5,666 |
281B | Problem - 281B - 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 two pointers *1700 No tag edit access β Contest materials that the value is as minimal as possible. If there are multiple "nearest" fractions, choose the one with the minimum denominator. If there are multiple "nearest" fractions with the minimum denominator, choose the one with the minimum numerator. Input A single line contains three integers _x_,u2009_y_,u2009_n_ (1u2009β€u2009_x_,u2009_y_,u2009_n_u2009β€u2009105). Output Print the required fraction in the format "_a_/_b_" (without quotes). Examples Input 3 7 6 Output 2/5 Input 7 2 4 Output 7/2 | 1,700 | false | false | true | false | false | false | true | false | false | false | 8,709 |
1042C | Problem - 1042C - 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 math *1700 No tag edit access β Contest materials ") , write the value of $$$a_i cdot a_j$$$ into the $$$j$$$-th cell and remove the number from the $$$i$$$-th cell; 2. Choose some position $$$i$$$ and remove the number from the $$$i$$$-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning). The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations. Your task is to perform exactly $$$n - 1$$$ operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print. Input The first line contains a single integer $$$n$$$ ($$$2 le n le 2 cdot 10^5$$$) β the number of elements in the array. The second line contains $$$n$$$ integers $$$a_1, a_2, dots, a_n$$$ ($$$-10^9 le a_i le 10^9$$$) β the elements of the array. Output Print $$$n - 1$$$ lines. The $$$k$$$-th line should contain one of the two possible operations. The operation of the first type should look like this: $$$1~ i_k~ j_k$$$, where $$$1$$$ is the type of operation, $$$i_k$$$ and $$$j_k$$$ are the positions of the chosen elements. The operation of the second type should look like this: $$$2~ i_k$$$, where $$$2$$$ is the type of operation, $$$i_k$$$ is the position of the chosen element. Note that there should be no more than one such operation. If there are multiple possible sequences of operations leading to the maximum number β print any of them. Examples Input 5 5 -2 0 1 -3 Output 2 3 1 1 2 1 2 4 1 4 5 Input 5 5 2 0 4 0 Output 1 3 5 2 5 1 1 2 1 2 4 Input 2 2 -1 Output 2 2 Input 4 0 -10 0 0 Output 1 1 2 1 2 3 1 3 4 Input 4 0 0 0 0 Output 1 1 2 1 2 3 1 3 4 Note Let X be the removed number in the array. Let's take a look at all the examples: The first example has, for example, the following sequence of transformations of the array: $$$ | 1,700 | true | true | false | false | false | true | false | false | false | false | 5,487 |
1272A | Three friends are going to meet each other. Initially, the first friend stays at the position $$$x = a$$$, the second friend stays at the position $$$x = b$$$ and the third friend stays at the position $$$x = c$$$ on the coordinate axis $$$Ox$$$. In one minute each friend independently from other friends can change the position $$$x$$$ by $$$1$$$ to the left or by $$$1$$$ to the right (i.e. set $$$x := x - 1$$$ or $$$x := x + 1$$$) or even don't change it. Let's introduce the total pairwise distance β the sum of distances between each pair of friends. Let $$$a'$$$, $$$b'$$$ and $$$c'$$$ be the final positions of the first, the second and the third friend, correspondingly. Then the total pairwise distance is $$$a' - b' + a' - c' + b' - c'$$$, where $$$x$$$ is the absolute value of $$$x$$$. Friends are interested in the minimum total pairwise distance they can reach if they will move optimally. Each friend will move no more than once. So, more formally, they want to know the minimum total pairwise distance they can reach after one minute. You have to answer $$$q$$$ independent test cases. Input The first line of the input contains one integer $$$q$$$ ($$$1 le q le 1000$$$) β the number of test cases. The next $$$q$$$ lines describe test cases. The $$$i$$$-th test case is given as three integers $$$a, b$$$ and $$$c$$$ ($$$1 le a, b, c le 10^9$$$) β initial positions of the first, second and third friend correspondingly. The positions of friends can be equal. Output For each test case print the answer on it β the minimum total pairwise distance (the minimum sum of distances between each pair of friends) if friends change their positions optimally. Each friend will move no more than once. So, more formally, you have to find the minimum total pairwise distance they can reach after one minute. Example Input 8 3 3 4 10 20 30 5 5 5 2 4 3 1 1000000000 1000000000 1 1000000000 999999999 3 2 5 3 2 6 Output 0 36 0 0 1999999994 1999999994 2 4 | 900 | true | true | false | false | false | false | true | false | true | false | 4,329 |
1907B | Polycarp has a problem β his laptop keyboard is broken. Now, when he presses the 'b' key, it acts like an unusual backspace: it deletes the last (rightmost) lowercase letter in the typed string. If there are no lowercase letters in the typed string, then the press is completely ignored. Similarly, when he presses the 'B' key, it deletes the last (rightmost) uppercase letter in the typed string. If there are no uppercase letters in the typed string, then the press is completely ignored. In both cases, the letters 'b' and 'B' are not added to the typed string when these keys are pressed. Consider an example where the sequence of key presses was "ARaBbbitBaby". In this case, the typed string will change as follows: "" $$$xrightarrow{ exttt{A}}$$$ "A" $$$xrightarrow{ exttt{R}}$$$ "AR" $$$xrightarrow{ exttt{a}}$$$ "ARa" $$$xrightarrow{ exttt{B}}$$$ "Aa" $$$xrightarrow{ exttt{b}}$$$ "A" $$$xrightarrow{ exttt{b}}$$$ "A" $$$xrightarrow{ exttt{i}}$$$ "Ai" $$$xrightarrow{ exttt{t}}$$$ "Ait" $$$xrightarrow{ exttt{B}}$$$ "it" $$$xrightarrow{ exttt{a}}$$$ "ita" $$$xrightarrow{ exttt{b}}$$$ "it" $$$xrightarrow{ exttt{y}}$$$ "ity". Given a sequence of pressed keys, output the typed string after processing all key presses. Input The first line of the input data contains an integer $$$t$$$ ($$$1 le t le 1000$$$), the number of test cases in the test. The following contains $$$t$$$ non-empty lines, which consist of lowercase and uppercase letters of the Latin alphabet. It is guaranteed that each line contains at least one letter and the sum of the lengths of the lines does not exceed $$$10^6$$$. Output For each test case, output the result of processing the key presses on a separate line. If the typed string is empty, then output an empty line. | 1,000 | false | false | true | false | true | false | false | false | false | false | 863 |
1491C | There is a trampoline park with $$$n$$$ trampolines in a line. The $$$i$$$-th of which has strength $$$S_i$$$. Pekora can jump on trampolines in multiple passes. She starts the pass by jumping on any trampoline of her choice. If at the moment Pekora jumps on trampoline $$$i$$$, the trampoline will launch her to position $$$i + S_i$$$, and $$$S_i$$$ will become equal to $$$max(S_i-1,1)$$$. In other words, $$$S_i$$$ will decrease by $$$1$$$, except of the case $$$S_i=1$$$, when $$$S_i$$$ will remain equal to $$$1$$$. If there is no trampoline in position $$$i + S_i$$$, then this pass is over. Otherwise, Pekora will continue the pass by jumping from the trampoline at position $$$i + S_i$$$ by the same rule as above. Pekora can't stop jumping during the pass until she lands at the position larger than $$$n$$$ (in which there is no trampoline). Poor Pekora! Pekora is a naughty rabbit and wants to ruin the trampoline park by reducing all $$$S_i$$$ to $$$1$$$. What is the minimum number of passes she needs to reduce all $$$S_i$$$ to $$$1$$$? Input The first line contains a single integer $$$t$$$ ($$$1 le t le 500$$$) β the number of test cases. The first line of each test case contains a single integer $$$n$$$ ($$$1 leq n leq 5000$$$) β the number of trampolines. The second line of each test case contains $$$n$$$ integers $$$S_1, S_2, dots, S_n$$$ ($$$1 le S_i le 10^9$$$), where $$$S_i$$$ is the strength of the $$$i$$$-th trampoline. It's guaranteed that the sum of $$$n$$$ over all test cases doesn't exceed $$$5000$$$. Output For each test case, output a single integer β the minimum number of passes Pekora needs to do to reduce all $$$S_i$$$ to $$$1$$$. Example Input 3 7 1 4 2 2 2 2 2 2 2 3 5 1 1 1 1 1 Note For the first test case, here is an optimal series of passes Pekora can take. (The bolded numbers are the positions that Pekora jumps into during these passes.) $$$[1,4, extbf{2},2, extbf{2},2, extbf{2}]$$$ $$$[1, extbf{4},1,2,1, extbf{2},1]$$$ $$$[1, extbf{3},1,2, extbf{1}, extbf{1}, extbf{1}]$$$ $$$[1, extbf{2},1, extbf{2},1, extbf{1}, extbf{1}]$$$ For the second test case, the optimal series of passes is show below. $$$[ extbf{2},3]$$$ $$$[1, extbf{3}]$$$ $$$[1, extbf{2}]$$$ For the third test case, all $$$S_i$$$ are already equal to $$$1$$$. | 1,700 | false | true | true | true | true | false | true | false | false | false | 3,220 |
1744D | You are given an array of positive integers $$$a_1, a_2, ldots, a_n$$$. Make the product of all the numbers in the array (that is, $$$a_1 cdot a_2 cdot ldots cdot a_n$$$) divisible by $$$2^n$$$. You can perform the following operation as many times as you like: select an arbitrary index $$$i$$$ ($$$1 leq i leq n$$$) and replace the value $$$a_i$$$ with $$$a_i=a_i cdot i$$$. You cannot apply the operation repeatedly to a single index. In other words, all selected values of $$$i$$$ must be different. Find the smallest number of operations you need to perform to make the product of all the elements in the array divisible by $$$2^n$$$. Note that such a set of operations does not always exist. Input The first line of the input contains a single integer $$$t$$$ $$$(1 leq t leq 10^4$$$) β the number test cases. Then the descriptions of the input data sets follow. The first line of each test case contains a single integer $$$n$$$ ($$$1 leq n leq 2 cdot 10^5$$$) β the length of array $$$a$$$. The second line of each test case contains exactly $$$n$$$ integers: $$$a_1, a_2, ldots, a_n$$$ ($$$1 leq a_i leq 10^9$$$). It is guaranteed that the sum of $$$n$$$ values over all test cases in a test does not exceed $$$2 cdot 10^5$$$. Output For each test case, print the least number of operations to make the product of all numbers in the array divisible by $$$2^n$$$. If the answer does not exist, print -1. Example Input 6 1 2 2 3 2 3 10 6 11 4 13 17 1 1 5 1 1 12 1 1 6 20 7 14 18 3 5 Note In the first test case, the product of all elements is initially $$$2$$$, so no operations needed. In the second test case, the product of elements initially equals $$$6$$$. We can apply the operation for $$$i = 2$$$, and then $$$a_2$$$ becomes $$$2cdot2=4$$$, and the product of numbers becomes $$$3cdot4=12$$$, and this product of numbers is divided by $$$2^n=2^2=4$$$. In the fourth test case, even if we apply all possible operations, we still cannot make the product of numbers divisible by $$$2^n$$$ xa0β it will be $$$(13cdot1)cdot(17cdot2)cdot(1cdot3)cdot(1cdot4)=5304$$$, which does not divide by $$$2^n=2^4=16$$$. In the fifth test case, we can apply operations for $$$i = 2$$$ and $$$i = 4$$$. | 1,200 | true | true | false | false | false | false | false | false | true | false | 1,814 |
1415D | Arkady owns a non-decreasing array $$$a_1, a_2, ldots, a_n$$$. You are jealous of its beauty and want to destroy this property. You have a so-called XOR-gun that you can use one or more times. In one step you can select two consecutive elements of the array, let's say $$$x$$$ and $$$y$$$, remove them from the array and insert the integer $$$x oplus y$$$ on their place, where $$$oplus$$$ denotes the xa0β the initial length of the array. The second line contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$1 le a_i le 10^9$$$)xa0β the elements of the array. It is guaranteed that $$$a_i le a_{i + 1}$$$ for all $$$1 le i < n$$$. Output Print a single integerxa0β the minimum number of steps needed. If there is no solution, print $$$-1$$$. Note In the first example you can select $$$2$$$ and $$$5$$$ and the array becomes $$$[7, 6, 8]$$$. In the second example you can only obtain arrays $$$[1, 1]$$$, $$$[3, 3]$$$ and $$$[0]$$$ which are all non-decreasing. In the third example you can select $$$1$$$ and $$$2$$$ and the array becomes $$$[3, 4, 6, 20]$$$. Then you can, for example, select $$$3$$$ and $$$4$$$ and the array becomes $$$[7, 6, 20]$$$, which is no longer non-decreasing. | 2,000 | false | false | false | false | false | true | true | false | false | false | 3,605 |
2037F | You have obtained the new limited event character Xilonen. You decide to use her in combat. There are $$$n$$$ enemies in a line. The $$$i$$$'th enemy from the left has health $$$h_i$$$ and is currently at position $$$x_i$$$. Xilonen has an attack damage of $$$m$$$, and you are ready to defeat the enemies with her. Xilonen has a powerful "ground stomp" attack. Before you perform any attacks, you select an integer $$$p$$$ and position Xilonen there ($$$p$$$ can be any integer position, including a position with an enemy currently). Afterwards, for each attack, she deals $$$m$$$ damage to an enemy at position $$$p$$$ (if there are any), $$$m-1$$$ damage to enemies at positions $$$p-1$$$ and $$$p+1$$$, $$$m-2$$$ damage to enemies at positions $$$p-2$$$ and $$$p+2$$$, and so on. Enemies that are at least a distance of $$$m$$$ away from Xilonen take no damage from attacks. Formally, if there is an enemy at position $$$x$$$, she will deal $$$max(0,m - p - x)$$$ damage to that enemy each hit. Note that you may not choose a different $$$p$$$ for different attacks. Over all possible $$$p$$$, output the minimum number of attacks Xilonen must perform to defeat at least $$$k$$$ enemies. If it is impossible to find a $$$p$$$ such that eventually at least $$$k$$$ enemies will be defeated, output $$$-1$$$ instead. Note that an enemy is considered to be defeated if its health reaches $$$0$$$ or below. Input The first line contains an integer $$$t$$$ ($$$1 leq t leq 10^4$$$)xa0β the number of test cases. The first line of each test case contains three integers $$$n$$$, $$$m$$$, and $$$k$$$ ($$$1 leq k leq n leq 10^5$$$, $$$1 leq m leq 10^9$$$). The following line contains $$$n$$$ integers $$$h_1, h_2, ..., h_n$$$ ($$$1 leq h_i leq 10^9$$$). The last line of each testcase contains $$$n$$$ integers $$$x_1, x_2, ..., x_n$$$ ($$$1leq x_i leq 10^9$$$, $$$x_i < x_{i+1}$$$ for all $$$1 leq i < n$$$) It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$. Output For each test case, output an integer on a new line, the minimum number of attacks that must be performed to defeat at least $$$k$$$ enemies. If it is impossible to find a $$$p$$$ such that eventually at least $$$k$$$ enemies will be defeated, output $$$-1$$$ instead. Example Input 6 5 5 3 7 7 7 7 7 1 2 3 4 5 9 5 9 2 4 6 8 10 8 6 4 2 1 2 3 4 5 6 7 8 9 2 10 2 1 1 1 20 2 10 1 69696969 420420420 1 20 2 10 2 10 15 1 19 2 2 2 1000000000 1 1 3 Output 2 2 -1 6969697 15 1000000000 Note In the first testcase, it is optimal to select $$$p=2$$$. Each attack, the first enemy takes $$$5-2-1=4$$$ damage, the second enemy takes $$$5$$$ damage, the third enemy takes $$$4$$$ damage, the fourth enemy takes $$$3$$$ damage, and the fifth enemy takes $$$2$$$ damage. After $$$2$$$ attacks, the first three enemies will be defeated. It can be shown that it is impossible to defeat $$$3$$$ enemies in less than $$$2$$$ attacks, no matter which $$$p$$$ is selected. In the second testcase, we must kill all $$$9$$$ enemies. By selecting $$$p=5$$$, all nine enemies will be defeated in $$$2$$$ attacks. In the third testcase, we must kill both enemies. However, it can be shown that no $$$p$$$ selected will damage both enemies at the same time, so the answer is $$$-1$$$. In the fourth testcase, selecting $$$p=1$$$ will enable us to defeat the first enemy in $$$6969697$$$ attacks. In the fifth testcase, selecting $$$p=10$$$ will make each enemy take $$$1$$$ damage per attack. Both enemies will be defeated in $$$15$$$ attacks. | 2,100 | true | false | false | false | true | false | false | true | true | false | 40 |
1163B1 | This problem is same as the next one, but has smaller constraints. Shiro's just moved to the new house. She wants to invite all friends of her to the house so they can play monopoly. However, her house is too small, so she can only invite one friend at a time. For each of the $$$n$$$ days since the day Shiro moved to the new house, there will be exactly one cat coming to the Shiro's house. The cat coming in the $$$i$$$-th day has a ribbon with color $$$u_i$$$. Shiro wants to know the largest number $$$x$$$, such that if we consider the streak of the first $$$x$$$ days, it is possible to remove exactly one day from this streak so that every ribbon color that has appeared among the remaining $$$x - 1$$$ will have the same number of occurrences. For example, consider the following sequence of $$$u_i$$$: $$$[2, 2, 1, 1, 5, 4, 4, 5]$$$. Then $$$x = 7$$$ makes a streak, since if we remove the leftmost $$$u_i = 5$$$, each ribbon color will appear exactly twice in the prefix of $$$x - 1$$$ days. Note that $$$x = 8$$$ doesn't form a streak, since you must remove exactly one day. Since Shiro is just a cat, she is not very good at counting and needs your help finding the longest streak. Input The first line contains a single integer $$$n$$$ ($$$1 leq n leq 10^5$$$)xa0β the total number of days. The second line contains $$$n$$$ integers $$$u_1, u_2, ldots, u_n$$$ ($$$1 leq u_i leq 10$$$)xa0β the colors of the ribbons the cats wear. Note In the first example, we can choose the longest streak of $$$13$$$ days, since upon removing the last day out of the streak, all of the remaining colors $$$1$$$, $$$2$$$, $$$3$$$, and $$$4$$$ will have the same number of occurrences of $$$3$$$. Note that the streak can also be $$$10$$$ days (by removing the $$$10$$$-th day from this streak) but we are interested in the longest streak. In the fourth example, if we take the streak of the first $$$6$$$ days, we can remove the third day from this streak then all of the remaining colors $$$1$$$, $$$2$$$, $$$3$$$, $$$4$$$ and $$$5$$$ will occur exactly once. | 1,500 | false | false | true | false | true | false | false | false | false | false | 4,903 |
1883G1 | This is the easy version of the problem. The only difference is that in this version $$$m = 1$$$. You are given two arrays of integers $$$a_1, a_2, ldots, a_n$$$ and $$$b_1, b_2, ldots, b_n$$$. Before applying any operations, you can reorder the elements of each array as you wish. Then, in one operation, you will perform both of the following actions, if the arrays are not empty: Choose any element from array $$$a$$$ and remove it (all remaining elements are shifted to a new array $$$a$$$), Choose any element from array $$$b$$$ and remove it (all remaining elements are shifted to a new array $$$b$$$). Let $$$k$$$ be the final size of both arrays. You need to find the minimum number of operations required to satisfy $$$a_i < b_i$$$ for all $$$1 leq i leq k$$$. This problem was too easy, so the problem author decided to make it more challenging. You are also given a positive integer $$$m$$$. Now, you need to find the sum of answers to the problem for $$$m$$$ pairs of arrays $$$(c[i], b)$$$, where $$$1 leq i leq m$$$. Array $$$c[i]$$$ is obtained from $$$a$$$ as follows: $$$c[i]_1 = i$$$, $$$c[i]_j = a_j$$$, for $$$2 leq j leq n$$$. Input Each test consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 leq t leq 10^4$$$) - the number of sets of input data. This is followed by their description. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 leq n leq 10^5$$$, $$$m = 1$$$) - the size of arrays $$$a$$$ and $$$b$$$ and the constraints on the value of element $$$a_1$$$. The second line of each test case contains $$$n - 1$$$ integers $$$a_2, ldots, a_n$$$ ($$$1 leq a_i leq 10^9$$$). The third line of each test case contains $$$n$$$ integers $$$b_1, b_2, ldots, b_n$$$ ($$$1 leq b_i leq 10^9$$$). It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$. Output For each test case, output the total number of minimum operations for all pairs of arrays $$$(c_i, b)$$$. Example Input 4 2 1 1 3 2 4 1 5 1 5 3 8 3 3 8 1 4 3 3 2 2 1 1 1 1 1 1 3 3 3 3 9 1 9 2 8 3 7 4 6 5 1 2 3 2 1 4 5 6 5 Note In the first test case for the pair of arrays $$$([1, 1], [3, 2])$$$, the answer is $$$0$$$. No operations or reordering of elements are needed. | 1,400 | false | true | false | false | false | false | false | true | false | false | 985 |
878C | Recently a tournament in _k_ kinds of sports has begun in Berland. Vasya wants to make money on the bets. The scheme of the tournament is very mysterious and not fully disclosed. Competitions are held back to back, each of them involves two sportsmen who have not left the tournament yet. Each match can be held in any of the _k_ kinds of sport. Loser leaves the tournament. The last remaining sportsman becomes the winner. Apart of this, the scheme can be arbitrary, it is not disclosed in advance. Vasya knows powers of sportsmen in each kind of sport. He believes that the sportsmen with higher power always wins. The tournament is held every year, and each year one new participant joins it. In the first tournament, only one sportsman has participated, in the second there were two sportsmen, and so on. Vasya has been watching the tournament for the last _n_ years. Help him to find the number of possible winners for each of the _n_ tournaments. Input The first line contains two integers _n_ and _k_ (1u2009β€u2009_n_u2009β€u20095Β·104, 1u2009β€u2009_k_u2009β€u200910) β the number of tournaments and the number of kinds of sport, respectively. Each of the next _n_ lines contains _k_ integers _s__i_1,u2009_s__i_2,u2009...,u2009_s__ik_ (1u2009β€u2009_s__ij_u2009β€u2009109), where _s__ij_ is the power of the _i_-th sportsman in the _j_-th kind of sport. The sportsman with higher powers always wins. It's guaranteed that for any kind of sport all of these powers are distinct. Output For each of the _n_ tournaments output the number of contenders who can win. Note In the first sample: In the first tournament there is only one sportsman, and he is the winner. In the second tournament, there are two sportsmen, and everyone can defeat another, depending on kind of sports. In the third tournament, the third sportsman in the strongest in both kinds of sports, so he is the winner regardless of the scheme. | 2,700 | false | false | false | false | true | false | false | false | false | true | 6,232 |
989C | As the boat drifts down the river, a wood full of blossoms shows up on the riverfront."I've been here once," Mino exclaims with delight, "it's breathtakingly amazing." "What is it like?" "Look, Kanno, you've got your paintbrush, and I've got my words. Have a try, shall we?" There are four kinds of flowers in the wood, Amaranths, Begonias, Centaureas and Dianthuses. The wood can be represented by a rectangular grid of $$$n$$$ rows and $$$m$$$ columns. In each cell of the grid, there is exactly one type of flowers. According to Mino, the numbers of connected components formed by each kind of flowers are $$$a$$$, $$$b$$$, $$$c$$$ and $$$d$$$ respectively. Two cells are considered in the same connected component if and only if a path exists between them that moves between cells sharing common edges and passes only through cells containing the same flowers. You are to help Kanno depict such a grid of flowers, with $$$n$$$ and $$$m$$$ arbitrarily chosen under the constraints given below. It can be shown that at least one solution exists under the constraints of this problem. Note that you can choose arbitrary $$$n$$$ and $$$m$$$ under the constraints below, they are not given in the input. Input The first and only line of input contains four space-separated integers $$$a$$$, $$$b$$$, $$$c$$$ and $$$d$$$ ($$$1 leq a, b, c, d leq 100$$$)xa0β the required number of connected components of Amaranths, Begonias, Centaureas and Dianthuses, respectively. Output In the first line, output two space-separated integers $$$n$$$ and $$$m$$$ ($$$1 leq n, m leq 50$$$)xa0β the number of rows and the number of columns in the grid respectively. Then output $$$n$$$ lines each consisting of $$$m$$$ consecutive English letters, representing one row of the grid. Each letter should be among 'A', 'B', 'C' and 'D', representing Amaranths, Begonias, Centaureas and Dianthuses, respectively. In case there are multiple solutions, print any. You can output each letter in either case (upper or lower). Examples Output 4 7 DDDDDDD DABACAD DBABACD DDDDDDD Output 4 50 CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC ABABABABABABABABABABABABABABABABABABABABABABABABAB BABABABABABABABABABABABABABABABABABABABABABABABABA DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD Output 7 7 DDDDDDD DDDBDBD DDCDCDD DBDADBD DDCDCDD DBDBDDD DDDDDDD Note In the first example, each cell of Amaranths, Begonias and Centaureas forms a connected component, while all the Dianthuses form one. | 1,800 | false | false | false | false | false | true | false | false | false | true | 5,755 |
1286E | Note For convenience, we will call "suspicious" those subsegments for which the corresponding lines are prefixes of $$$S$$$, that is, those whose suspiciousness may not be zero. As a result of decryption in the first example, after all requests, the string $$$S$$$ is equal to "abacaba", and all $$$w_i = 1$$$, that is, the suspiciousness of all suspicious sub-segments is simply equal to $$$1$$$. Let's see how the answer is obtained after each request: 1. $$$S$$$ = "a", the array $$$W$$$ has a single subsegment β $$$[1, 1]$$$, and the corresponding substring is "a", that is, the entire string $$$S$$$, thus it is a prefix of $$$S$$$, and the suspiciousness of the subsegment is $$$1$$$. 2. $$$S$$$ = "ab", suspicious subsegments: $$$[1, 1]$$$ and $$$[1, 2]$$$, total $$$2$$$. 3. $$$S$$$ = "aba", suspicious subsegments: $$$[1, 1]$$$, $$$[1, 2]$$$, $$$[1, 3]$$$ and $$$[3, 3]$$$, total $$$4$$$. 4. $$$S$$$ = "abac", suspicious subsegments: $$$[1, 1]$$$, $$$[1, 2]$$$, $$$[1, 3]$$$, $$$[1, 4]$$$ and $$$[3, 3]$$$, total $$$5$$$. 5. $$$S$$$ = "abaca", suspicious subsegments: $$$[1, 1]$$$, $$$[1, 2]$$$, $$$[1, 3]$$$, $$$[1, 4]$$$ , $$$[1, 5]$$$, $$$[3, 3]$$$ and $$$[5, 5]$$$, total $$$7$$$. 6. $$$S$$$ = "abacab", suspicious subsegments: $$$[1, 1]$$$, $$$[1, 2]$$$, $$$[1, 3]$$$, $$$[1, 4]$$$ , $$$[1, 5]$$$, $$$[1, 6]$$$, $$$[3, 3]$$$, $$$[5, 5]$$$ and $$$[5, 6]$$$, total $$$9$$$. 7. $$$S$$$ = "abacaba", suspicious subsegments: $$$[1, 1]$$$, $$$[1, 2]$$$, $$$[1, 3]$$$, $$$[1, 4]$$$ , $$$[1, 5]$$$, $$$[1, 6]$$$, $$$[1, 7]$$$, $$$[3, 3]$$$, $$$[5, 5]$$$, $$$[5, 6]$$$, $$$[5, 7]$$$ and $$$[7, 7]$$$, total $$$12$$$. In the second example, after all requests $$$S$$$ = "aaba", $$$W = [2, 0, 2, 0]$$$. 1. $$$S$$$ = "a", suspicious subsegments: $$$[1, 1]$$$ (suspiciousness $$$2$$$), totaling $$$2$$$. 2. $$$S$$$ = "aa", suspicious subsegments: $$$[1, 1]$$$ ($$$2$$$), $$$[1, 2]$$$ ($$$0$$$), $$$[2, 2]$$$ ( $$$0$$$), totaling $$$2$$$. 3. $$$S$$$ = "aab", suspicious subsegments: $$$[1, 1]$$$ ($$$2$$$), $$$[1, 2]$$$ ($$$0$$$), $$$[1, 3]$$$ ( $$$0$$$), $$$[2, 2]$$$ ($$$0$$$), totaling $$$2$$$. 4. $$$S$$$ = "aaba", suspicious subsegments: $$$[1, 1]$$$ ($$$2$$$), $$$[1, 2]$$$ ($$$0$$$), $$$[1, 3]$$$ ( $$$0$$$), $$$[1, 4]$$$ ($$$0$$$), $$$[2, 2]$$$ ($$$0$$$), $$$[4, 4]$$$ ($$$0$$$), totaling $$$2$$$. In the third example, from the condition after all requests $$$S$$$ = "abcde", $$$W = [7, 2, 10, 1, 7]$$$. 1. $$$S$$$ = "a", suspicious subsegments: $$$[1, 1]$$$ ($$$7$$$), totaling $$$7$$$. 2. $$$S$$$ = "ab", suspicious subsegments: $$$[1, 1]$$$ ($$$7$$$), $$$[1, 2]$$$ ($$$2$$$), totaling $$$9$$$. 3. $$$S$$$ = "abc", suspicious subsegments: $$$[1, 1]$$$ ($$$7$$$), $$$[1, 2]$$$ ($$$2$$$), $$$[1, 3]$$$ ( $$$2$$$), totaling $$$11$$$. 4. $$$S$$$ = "abcd", suspicious subsegments: $$$[1, 1]$$$ ($$$7$$$), $$$[1, 2]$$$ ($$$2$$$), $$$[1, 3]$$$ ( $$$2$$$), $$$[1, 4]$$$ ($$$1$$$), totaling $$$12$$$. 5. $$$S$$$ = "abcde", suspicious subsegments: $$$[1, 1]$$$ ($$$7$$$), $$$[1, 2]$$$ ($$$2$$$), $$$[1, 3]$$$ ( $$$2$$$), $$$[1, 4]$$$ ($$$1$$$), $$$[1, 5]$$$ ($$$1$$$), totaling $$$13$$$. | 3,200 | false | false | false | false | true | false | false | false | false | false | 4,256 |
967B | Arkady wants to water his only flower. Unfortunately, he has a very poor watering system that was designed for $$$n$$$ flowers and so it looks like a pipe with $$$n$$$ holes. Arkady can only use the water that flows from the first hole. Arkady can block some of the holes, and then pour $$$A$$$ liters of water into the pipe. After that, the water will flow out from the non-blocked holes proportionally to their sizes $$$s_1, s_2, ldots, s_n$$$. In other words, if the sum of sizes of non-blocked holes is $$$S$$$, and the $$$i$$$-th hole is not blocked, $$$frac{s_i cdot A}{S}$$$ liters of water will flow out of it. What is the minimum number of holes Arkady should block to make at least $$$B$$$ liters of water flow out of the first hole? Input The first line contains three integers $$$n$$$, $$$A$$$, $$$B$$$ ($$$1 le n le 100,000$$$, $$$1 le B le A le 10^4$$$)xa0β the number of holes, the volume of water Arkady will pour into the system, and the volume he wants to get out of the first hole. The second line contains $$$n$$$ integers $$$s_1, s_2, ldots, s_n$$$ ($$$1 le s_i le 10^4$$$)xa0β the sizes of the holes. Output Print a single integerxa0β the number of holes Arkady should block. Note In the first example Arkady should block at least one hole. After that, $$$frac{10 cdot 2}{6} approx 3.333$$$ liters of water will flow out of the first hole, and that suits Arkady. In the second example even without blocking any hole, $$$frac{80 cdot 3}{10} = 24$$$ liters will flow out of the first hole, that is not less than $$$20$$$. In the third example Arkady has to block all holes except the first to make all water flow out of the first hole. | 1,000 | true | false | false | false | false | false | false | false | true | false | 5,836 |
701B | Vasya has the square chessboard of size _n_u2009Γu2009_n_ and _m_ rooks. Initially the chessboard is empty. Vasya will consequently put the rooks on the board one after another. The cell of the field is under rook's attack, if there is at least one rook located in the same row or in the same column with this cell. If there is a rook located in the cell, this cell is also under attack. You are given the positions of the board where Vasya will put rooks. For each rook you have to determine the number of cells which are not under attack after Vasya puts it on the board. Input The first line of the input contains two integers _n_ and _m_ (1u2009β€u2009_n_u2009β€u2009100u2009000, 1u2009β€u2009_m_u2009β€u2009_min_(100u2009000,u2009_n_2))xa0β the size of the board and the number of rooks. Each of the next _m_ lines contains integers _x__i_ and _y__i_ (1u2009β€u2009_x__i_,u2009_y__i_u2009β€u2009_n_)xa0β the number of the row and the number of the column where Vasya will put the _i_-th rook. Vasya puts rooks on the board in the order they appear in the input. It is guaranteed that any cell will contain no more than one rook. Output Print _m_ integer, the _i_-th of them should be equal to the number of cells that are not under attack after first _i_ rooks are put. Note On the picture below show the state of the board after put each of the three rooks. The cells which painted with grey color is not under the attack. | 1,200 | true | false | false | false | true | false | false | false | false | false | 7,019 |
1251D | You are the head of a large enterprise. $$$n$$$ people work at you, and $$$n$$$ is odd (i.u2009e. $$$n$$$ is not divisible by $$$2$$$). You have to distribute salaries to your employees. Initially, you have $$$s$$$ dollars for it, and the $$$i$$$-th employee should get a salary from $$$l_i$$$ to $$$r_i$$$ dollars. You have to distribute salaries in such a way that the median salary is maximum possible. To find the median of a sequence of odd length, you have to sort it and take the element in the middle position after sorting. For example: the median of the sequence $$$[5, 1, 10, 17, 6]$$$ is $$$6$$$, the median of the sequence $$$[1, 2, 1]$$$ is $$$1$$$. It is guaranteed that you have enough money to pay the minimum salary, i.e $$$l_1 + l_2 + dots + l_n le s$$$. Note that you don't have to spend all your $$$s$$$ dollars on salaries. You have to answer $$$t$$$ test cases. Input The first line contains one integer $$$t$$$ ($$$1 le t le 2 cdot 10^5$$$) β the number of test cases. The first line of each query contains two integers $$$n$$$ and $$$s$$$ ($$$1 le n < 2 cdot 10^5$$$, $$$1 le s le 2 cdot 10^{14}$$$) β the number of employees and the amount of money you have. The value $$$n$$$ is not divisible by $$$2$$$. The following $$$n$$$ lines of each query contain the information about employees. The $$$i$$$-th line contains two integers $$$l_i$$$ and $$$r_i$$$ ($$$1 le l_i le r_i le 10^9$$$). It is guaranteed that the sum of all $$$n$$$ over all queries does not exceed $$$2 cdot 10^5$$$. It is also guaranteed that you have enough money to pay the minimum salary to each employee, i.u2009e. $$$sumlimits_{i=1}^{n} l_i le s$$$. Output For each test case print one integer β the maximum median salary that you can obtain. Example Input 3 3 26 10 12 1 4 10 11 1 1337 1 1000000000 5 26 4 4 2 4 6 8 5 6 2 7 Note In the first test case, you can distribute salaries as follows: $$$sal_1 = 12, sal_2 = 2, sal_3 = 11$$$ ($$$sal_i$$$ is the salary of the $$$i$$$-th employee). Then the median salary is $$$11$$$. In the second test case, you have to pay $$$1337$$$ dollars to the only employee. In the third test case, you can distribute salaries as follows: $$$sal_1 = 4, sal_2 = 3, sal_3 = 6, sal_4 = 6, sal_5 = 7$$$. Then the median salary is $$$6$$$. | 1,900 | false | true | false | false | false | false | false | true | true | false | 4,438 |
1872D | You are given $$$3$$$ integersxa0β $$$n$$$, $$$x$$$, $$$y$$$. Let's call the score of a permutation$$$^dagger$$$ $$$p_1, ldots, p_n$$$ the following value: $$$$$$(p_{1 cdot x} + p_{2 cdot x} + ldots + p_{lfloor frac{n}{x} floor cdot x}) - (p_{1 cdot y} + p_{2 cdot y} + ldots + p_{lfloor frac{n}{y} floor cdot y})$$$$$$ In other words, the score of a permutation is the sum of $$$p_i$$$ for all indices $$$i$$$ divisible by $$$x$$$, minus the sum of $$$p_i$$$ for all indices $$$i$$$ divisible by $$$y$$$. You need to find the maximum possible score among all permutations of length $$$n$$$. For example, if $$$n = 7$$$, $$$x = 2$$$, $$$y = 3$$$, the maximum score is achieved by the permutation $$$[2,color{red}{underline{color{black}{6}}},color{blue}{underline{color{black}{1}}},color{red}{underline{color{black}{7}}},5,color{blue}{underline{color{red}{underline{color{black}{4}}}}},3]$$$ and is equal to $$$(6 + 7 + 4) - (1 + 4) = 17 - 5 = 12$$$. $$$^dagger$$$ 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 (the number $$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$, but the array contains $$$4$$$). Input The first line of input contains an integer $$$t$$$ ($$$1 le t le 10^4$$$)xa0β the number of test cases. Then follows the description of each test case. The only line of each test case description contains $$$3$$$ integers $$$n$$$, $$$x$$$, $$$y$$$ ($$$1 le n le 10^9$$$, $$$1 le x, y le n$$$). Output For each test case, output a single integerxa0β the maximum score among all permutations of length $$$n$$$. Example Input 8 7 2 3 12 6 3 9 1 9 2 2 2 100 20 50 24 4 6 1000000000 5575 25450 4 4 1 Output 12 -3 44 0 393 87 179179179436104 -6 Note The first test case is explained in the problem statement above. In the second test case, one of the optimal permutations will be $$$[12,11,color{blue}{underline{color{black}{2}}},4,8,color{blue}{underline{color{red}{underline{color{black}{9}}}}},10,6,color{blue}{underline{color{black}{1}}},5,3,color{blue}{underline{color{red}{underline{color{black}{7}}}}}]$$$. The score of this permutation is $$$(9 + 7) - (2 + 9 + 1 + 7) = -3$$$. It can be shown that a score greater than $$$-3$$$ can not be achieved. Note that the answer to the problem can be negative. In the third test case, the score of the permutation will be $$$(p_1 + p_2 + ldots + p_9) - p_9$$$. One of the optimal permutations for this case is $$$[9, 8, 7, 6, 5, 4, 3, 2, 1]$$$, and its score is $$$44$$$. It can be shown that a score greater than $$$44$$$ can not be achieved. In the fourth test case, $$$x = y$$$, so the score of any permutation will be $$$0$$$. | 1,200 | true | false | false | false | false | false | false | false | false | false | 1,048 |
472C | A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull. Let's try to make a new task. Firstly we will use the following task. There are _n_ people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are _n_ people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation _p_? More formally, if we denote the handle of the _i_-th person as _h__i_, then the following condition must hold: . Input The first line contains an integer _n_ (1u2009β€u2009_n_u2009β€u2009105) β the number of people. The next _n_ lines each contains two strings. The _i_-th line contains strings _f__i_ and _s__i_ (1u2009β€u2009_f__i_,u2009_s__i_u2009β€u200950) β the first name and last name of the _i_-th person. Each string consists only of lowercase English letters. All of the given 2_n_ strings will be distinct. The next line contains _n_ distinct integers: _p_1,u2009_p_2,u2009...,u2009_p__n_ (1u2009β€u2009_p__i_u2009β€u2009_n_). Output If it is possible, output "YES", otherwise output "NO". Examples Input 3 gennady korotkevich petr mitrichev gaoyuan chen 1 2 3 Input 3 gennady korotkevich petr mitrichev gaoyuan chen 3 1 2 Input 2 galileo galilei nicolaus copernicus 2 1 Input 10 rean schwarzer fei claussell alisa reinford eliot craig laura arseid jusis albarea machias regnitz sara valestin emma millstein gaius worzel 1 2 3 4 5 6 7 8 9 10 Input 10 rean schwarzer fei claussell alisa reinford eliot craig laura arseid jusis albarea machias regnitz sara valestin emma millstein gaius worzel 2 4 9 6 5 7 1 3 8 10 Note In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last. In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright. | 1,400 | false | true | false | false | false | false | false | false | false | false | 7,945 |
1870C | Enter Register HOME TOP CATALOG CONTESTS GYM PROBLEMSET GROUPS RATING EDU API CALENDAR HELP RAYAN CodeTON Round 6 (Div. 1 + Div. 2, Rated, Prizes!) 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 binary search data structures dp implementation math two pointers *1300 No tag edit access β Contest materials Announcement Tutorial PROBLEMS SUBMIT STATUS STANDINGS CUSTOM TEST C. Colorful Table time limit per test1 second memory limit per test256 megabytes You are given two integers $$$n$$$ and $$$k$$$. You are also given an array of integers $$$a_1, a_2, ldots, a_n$$$ of size $$$n$$$. It is known that for all $$$1 leq i leq n$$$, $$$1 leq a_i leq k$$$. Define a two-dimensional array $$$b$$$ of size $$$n imes n$$$ as follows: $$$b_{i, j} = min(a_i, a_j)$$$. Represent array $$$b$$$ as a square, where the upper left cell is $$$b_{1, 1}$$$, rows are numbered from top to bottom from $$$1$$$ to $$$n$$$, and columns are numbered from left to right from $$$1$$$ to $$$n$$$. Let the color of a cell be the number written in it (for a cell with coordinates $$$(i, j)$$$, this is $$$b_{i, j}$$$). For each color from $$$1$$$ to $$$k$$$, find the smallest rectangle in the array $$$b$$$ containing all cells of this color. Output the sum of width and height of this rectangle. Input The first line contains a single integer $$$t$$$ ($$$1 leq t leq 10^4$$$) β the number of test cases. Then follows the description of the test cases. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ ($$$1 leq n, k leq 10^5$$$) β the size of array $$$a$$$ and the number of colors. The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$1 leq a_i leq k$$$) β the array $$$a$$$. It is guaranteed that the sum of the values of $$$n$$$ and $$$k$$$ over all test cases does not exceed $$$10^5$$$. Output For each test case, output $$$k$$$ numbers: the sums of width and height of the smallest rectangle containing all cells of a color, for each color from $$$1$$$ to $$$k$$$. Example input 5 2 1 1 1 2 2 1 2 3 5 3 2 4 4 2 1 2 1 2 5 3 1 2 3 2 1 output 4 4 2 0 6 6 2 0 8 6 10 6 2 Note In the first test case, the entire array $$$b$$$ consists of color $$$1$$$, so the smallest rectangle for color $$$1$$$ has a size of $$$2 imes 2$$$, and the sum of its sides is $$$4$$$. In the second test case, the array $$$b$$$ looks like this: 1 1 1 2 One of the corner cells has color $$$2$$$, and the other three cells have color $$$1$$$. Therefore, the smallest rectangle for color $$$1$$$ has a size of $$$2 imes 2$$$, and for color $$$2$$$ it is $$$1 imes 1$$$. In the last test case, the array $$$b$$$ looks like this: 1 1 1 1 1 1 2 2 2 1 1 2 3 2 1 1 2 2 2 1 1 1 1 1 1 Codeforces (c) | 1,300 | true | false | true | true | true | false | false | true | false | false | 1,057 |
279B | Problem - 279B - 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 binary search brute force implementation two pointers *1400 No tag edit access β Contest materials ") ") Π Π°Π·Π±ΠΎΡ ΠΠ°Π΄Π°Ρ") β the number of books and the number of free minutes Valera's got. The second line contains a sequence of _n_ integers _a_1,u2009_a_2,u2009...,u2009_a__n_ (1u2009β€u2009_a__i_u2009β€u2009104), where number _a__i_ shows the number of minutes that the boy needs to read the _i_-th book. Output Print a single integer β the maximum number of books Valera can read. Examples Input 4 5 3 1 2 1 Output 3 Input 3 3 2 2 3 Output 1 | 1,400 | false | false | true | false | false | false | true | true | false | false | 8,719 |
236A | Problem - 236A - 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 strings *800 No tag edit access β Contest materials . After that they talked very often and eventually they became a couple in the network. But yesterday, he came to see "her" in the real world and found out "she" is actually a very strong man! Our hero is very sad and he is too tired to love again now. So he came up with a way to recognize users' genders by their user names. This is his method: if the number of distinct characters in one's user name is odd, then he is a male, otherwise she is a female. You are given the string that denotes the user name, please help our hero to determine the gender of this user by his method. Input The first line contains a non-empty string, that contains only lowercase English letters β the user name. This string contains at most 100 letters. Output If it is a female by our hero's method, print "CHAT WITH HER!" (without the quotes), otherwise, print "IGNORE HIM!" (without the quotes). Examples Input wjmzbmr Output CHAT WITH HER! Input xiaodao Output IGNORE HIM! Input sevenkplus Output CHAT WITH HER! Note For the first example. There are 6 distinct characters in "wjmzbmr". These characters are: "w", "j", "m", "z", "b", "r". So wjmzbmr is a female and you should print "CHAT WITH HER!". | 800 | false | false | true | false | false | false | true | false | false | false | 8,891 |
1795A | There are two towers consisting of blocks of two colors: red and blue. Both towers are represented by strings of characters B and/or R denoting the order of blocks in them from the bottom to the top, where B corresponds to a blue block, and R corresponds to a red block. These two towers are represented by strings BRBB and RBR. You can perform the following operation any number of times: choose a tower with at least two blocks, and move its top block to the top of the other tower. The pair of towers is beautiful if no pair of touching blocks has the same color; i.u2009e. no red block stands on top of another red block, and no blue block stands on top of another blue block. You have to check if it is possible to perform any number of operations (possibly zero) to make the pair of towers beautiful. Input The first line contains one integer $$$t$$$ ($$$1 le t le 1000$$$)xa0β the number of test cases. Each test case consists of three lines: the first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 le n, m le 20$$$)xa0β the number of blocks in the first tower and the number of blocks in the second tower, respectively; the second line contains $$$s$$$xa0β a string of exactly $$$n$$$ characters B and/or R, denoting the first tower; the third line contains $$$t$$$xa0β a string of exactly $$$m$$$ characters B and/or R, denoting the second tower. Output For each test case, print YES if it is possible to perform several (possibly zero) operations in such a way that the pair of towers becomes beautiful; otherwise print NO. You may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer). Example Input 4 4 3 BRBB RBR 4 7 BRBR RRBRBRB 3 4 RBR BRBR 5 4 BRBRR BRBR Note In the first test case, you can move the top block from the first tower to the second tower (see the third picture). In the second test case, you can move the top block from the second tower to the first tower $$$6$$$ times. In the third test case, the pair of towers is already beautiful. | 800 | false | false | true | false | false | false | true | false | false | false | 1,509 |
435D | You are given an _n_u2009Γu2009_m_ grid, some of its nodes are black, the others are white. Moreover, it's not an ordinary grid β each unit square of the grid has painted diagonals. The figure below is an example of such grid of size 3u2009Γu20095. Four nodes of this grid are black, the other 11 nodes are white. Your task is to count the number of such triangles on the given grid that: the corners match the white nodes, and the area is positive; all sides go along the grid lines (horizontal, vertical or diagonal); no side contains black nodes. Input The first line contains two integers _n_ and _m_ (2u2009β€u2009_n_,u2009_m_u2009β€u2009400). Each of the following _n_ lines contain _m_ characters (zeros and ones) β the description of the grid. If the _j_-th character in the _i_-th line equals zero, then the node on the _i_-th horizontal line and on the _j_-th vertical line is painted white. Otherwise, the node is painted black. The horizontal lines are numbered starting from one from top to bottom, the vertical lines are numbered starting from one from left to right. Output Print a single integer β the number of required triangles. Note The figure below shows red and blue triangles. They are the examples of the required triangles in the first sample. One of the invalid triangles is painted green. It is invalid because not all sides go along the grid lines. | 2,000 | false | true | false | true | false | false | true | false | false | false | 8,099 |
1772G | Monocarp is playing chess on one popular website. He has $$$n$$$ opponents he can play with. The $$$i$$$-th opponent has rating equal to $$$a_i$$$. Monocarp's initial rating is $$$x$$$. Monocarp wants to raise his rating to the value $$$y$$$ ($$$y > x$$$). When Monocarp is playing against one of the opponents, he will win if his current rating is bigger or equal to the opponent's rating. If Monocarp wins, his rating is increased by $$$1$$$, otherwise it is decreased by $$$1$$$. The rating of his opponent does not change. Monocarp wants to gain rating $$$y$$$ playing as few games as possible. But he can't just grind it, playing against weak opponents. The website has a rule that you should play against all opponents as evenly as possible. Speaking formally, if Monocarp wants to play against an opponent $$$i$$$, there should be no other opponent $$$j$$$ such that Monocarp has played more games against $$$i$$$ than against $$$j$$$. Calculate the minimum possible number of games Monocarp needs to gain rating $$$y$$$ or say it's impossible. Note that ratings of Monocarp's opponents don't change, while Monocarp's rating does change. 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 three integers $$$n$$$, $$$x$$$ and $$$y$$$ ($$$1 le n le 2 cdot 10^5$$$; $$$1 le x < y le 10^{12}$$$)xa0β the number of Monocarp's opponents, his initial and desired ratings. The second line contains $$$n$$$ integers $$$a_1, a_2, dots, a_n$$$ ($$$1 le a_i le 10^{12}$$$)xa0β ratings of Monocarp's opponents. Additional constraint on the input: the total sum of $$$n$$$ over all $$$t$$$ test cases doesn't exceed $$$2 cdot 10^5$$$. Output For each test case, print a single integerxa0β the minimum number of games Monocarp needs to play to gain rating $$$y$$$, or $$$-1$$$ if it's impossible. Example Input 3 7 2 10 3 1 9 2 5 20 8 7 1 10 3 1 9 2 5 20 8 5 10 12 100 1 200 11 300 Note In the first test case, Monocarp can use the following strategy: 1. Monocarp plays against the $$$2$$$-nd opponent to increase rating ($$$2 o 3$$$); 2. Monocarp plays against the $$$1$$$-st opponent to increase rating ($$$3 o 4$$$); 3. Monocarp plays against the $$$4$$$-th opponent to increase rating ($$$4 o 5$$$); 4. Monocarp plays against the $$$5$$$-th opponent to increase rating ($$$5 o 6$$$); 5. Now Monocarp have to play with remaining three opponents. So, he will lose $$$3$$$ times and get rating $$$3$$$ ($$$6 o 5 o 4 o 3$$$); 6. After that, Monocarp will repeat steps 1-5 again. After $$$14$$$ games, he has played twice with each opponent and get final rating $$$4$$$. 7. Monocarp plays against the $$$1$$$-st opponent to increase rating ($$$4 o 5$$$); 8. Monocarp plays against the $$$2$$$-nd opponent to increase rating ($$$5 o 6$$$); 9. Monocarp plays against the $$$4$$$-th opponent to increase rating ($$$6 o 7$$$); 10. Monocarp plays against the $$$5$$$-th opponent to increase rating ($$$7 o 8$$$); 11. Monocarp plays against the $$$7$$$-th opponent to increase rating ($$$8 o 9$$$); 12. Monocarp plays against the $$$3$$$-rd opponent to increase rating ($$$9 o 10$$$); In total, Monocarp, played twice against the $$$6$$$-th opponent and three times against other opponents and got rating $$$10$$$ in $$$14 + 6 = 20$$$ games. In the second test case, it can be proven that whichever games Monocarp plays, he can't get his rating higher than $$$4$$$. | 2,200 | true | true | true | false | false | false | false | true | true | false | 1,657 |
1250N | Polycarpus has a complex electronic device. The core of this device is a circuit board. The board has $$$10^9$$$ contact points which are numbered from $$$1$$$ to $$$10^9$$$. Also there are $$$n$$$ wires numbered from $$$1$$$ to $$$n$$$, each connecting two distinct contact points on the board. An electric signal can pass between wires $$$A$$$ and $$$B$$$ if: either both wires share the same contact point; or there is a sequence of wires starting with $$$A$$$ and ending with $$$B$$$, and each pair of adjacent wires in the sequence share a contact point. The picture shows a circuit board with $$$5$$$ wires. Contact points with numbers $$$2, 5, 7, 8, 10, 13$$$ are used. Here an electrical signal can pass from wire $$$2$$$ to wire $$$3$$$, but not to wire $$$1$$$. Currently the circuit board is broken. Polycarpus thinks that the board could be fixed if the wires were re-soldered so that a signal could pass between any pair of wires. It takes $$$1$$$ minute for Polycarpus to re-solder an end of a wire. I.e. it takes one minute to change one of the two contact points for a wire. Any contact point from range $$$[1, 10^9]$$$ can be used as a new contact point. A wire's ends must always be soldered to distinct contact points. Both wire's ends can be re-solded, but that will require two actions and will take $$$2$$$ minutes in total. Find the minimum amount of time Polycarpus needs to re-solder wires so that a signal can pass between any pair of wires. Also output an optimal sequence of wire re-soldering. Input The input contains one or several test cases. The first input line contains a single integer $$$t$$$ β number of test cases. Then, $$$t$$$ test cases follow. The first line of each test case contains a single integer $$$n$$$ ($$$1 le n le 10^5$$$) β the number of wires. The following $$$n$$$ lines describe wires, each line containing two space-separated integers $$$x_i, y_i$$$ ($$$1 le x_i, y_i le 10^9$$$, $$$x_i eq y_i$$$) β contact points connected by the $$$i$$$-th wire. A couple of contact points can be connected with more than one wire. Sum of values of $$$n$$$ across all test cases does not exceed $$$10^5$$$. Output For each test case first print one line with a single integer $$$k$$$ β the minimum number of minutes needed to re-solder wires so that a signal can pass between any pair of wires. In the following $$$k$$$ lines print the description of re-solderings. Each re-soldering should be described by three integers $$$w_j, a_j, b_j$$$ ($$$1 le w_j le n$$$, $$$1 le a_j, b_j le 10^9$$$). Such triple means that during the $$$j$$$-th re-soldering an end of the $$$w_j$$$-th wire, which was soldered to contact point $$$a_j$$$, becomes soldered to contact point $$$b_j$$$ instead. After each re-soldering of a wire it must connect two distinct contact points. If there are multiple optimal re-solderings, print any of them. Example Input 2 1 4 7 4 1 2 2 3 4 5 5 6 | 2,000 | false | true | false | false | false | false | false | false | false | true | 4,442 |
913F | There is a chess tournament in All-Right-City. _n_ players were invited to take part in the competition. The tournament is held by the following rules: 1. Initially, each player plays one game with every other player. There are no ties; 2. After that, the organizers build a complete directed graph with players as vertices. For every pair of players there is exactly one directed edge between them: the winner of their game is the startpoint of this edge and the loser is the endpoint; 3. After that, the organizers build a condensation of this graph. The condensation of this graph is an acyclic complete graph, therefore it has the only Hamiltonian path which consists of strongly connected components of initial graph _A_1u2009βu2009_A_2u2009βu2009...u2009βu2009_A__k_. 4. The players from the first component _A_1 are placed on the first places, the players from the component _A_2 are placed on the next places, and so on. 5. To determine exact place of each player in a strongly connected component, all the procedures from 1 to 5 are repeated recursively inside each component, i.e. for every _i_u2009=u20091,u20092,u2009...,u2009_k_ players from the component _A__i_ play games with each other again, and so on; 6. If a component consists of a single player, then he has no more rivals, his place is already determined and the process stops. The players are enumerated with integers from 1 to _n_. The enumeration was made using results of a previous tournament. It is known that player _i_ wins player _j_ (_i_u2009<u2009_j_) with probability _p_. You need to help to organize the tournament. Find the expected value of total number of games played by all the players. It can be shown that the answer can be represented as , where _P_ and _Q_ are coprime integers and . Print the value of _P_Β·_Q_u2009-u20091 modulo 998244353. If you are not familiar with any of the terms above, you can read about them xa0β the number of players. The second line contains two integers _a_ and _b_ (1u2009β€u2009_a_u2009<u2009_b_u2009β€u2009100)xa0β the numerator and the denominator of fraction . Output In the only line print the expected value of total number of games played by all the players. Print the answer using the format above. Note In the first example the expected value is 4. In the second example the expected value is . In the third example the expected value is . | 2,800 | true | false | false | true | false | false | false | false | false | true | 6,086 |
285A | Problem - 285A - 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 greedy implementation *1100 No tag edit access β Contest materials ") Tutorial") , that _p__i_u2009>u2009_p__i_u2009+u20091. You have numbers _n_ and _k_. Your task is to print the permutation of length _n_ with decreasing coefficient _k_. Input The single line contains two space-separated integers: _n_,u2009_k_ (1u2009β€u2009_n_u2009β€u2009105,u20090u2009β€u2009_k_u2009<u2009_n_) β the permutation length and the decreasing coefficient. Output In a single line print _n_ space-separated integers: _p_1,u2009_p_2,u2009...,u2009_p__n_ β the permutation of length _n_ with decreasing coefficient _k_. If there are several permutations that meet this condition, print any of them. It is guaranteed that the permutation with the sought parameters exists. Examples Input 5 2 Output 1 5 2 4 3 Input 3 0 Output 1 2 3 Input 3 2 Output 3 2 1 | 1,100 | false | true | true | false | false | false | false | false | false | false | 8,696 |
1216E2 | The only difference between the easy and the hard versions is the maximum value of $$$k$$$. You are given an infinite sequence of form "112123123412345$$$dots$$$" which consist of blocks of all consecutive positive integers written one after another. The first block consists of all numbers from $$$1$$$ to $$$1$$$, the second one β from $$$1$$$ to $$$2$$$, the third one β from $$$1$$$ to $$$3$$$, $$$dots$$$, the $$$i$$$-th block consists of all numbers from $$$1$$$ to $$$i$$$. So the first $$$56$$$ elements of the sequence are "11212312341234512345612345671234567812345678912345678910". Elements of the sequence are numbered from one. For example, the $$$1$$$-st element of the sequence is $$$1$$$, the $$$3$$$-rd element of the sequence is $$$2$$$, the $$$20$$$-th element of the sequence is $$$5$$$, the $$$38$$$-th element is $$$2$$$, the $$$56$$$-th element of the sequence is $$$0$$$. Your task is to answer $$$q$$$ independent queries. In the $$$i$$$-th query you are given one integer $$$k_i$$$. Calculate the digit at the position $$$k_i$$$ of the sequence. Input The first line of the input contains one integer $$$q$$$ ($$$1 le q le 500$$$) β the number of queries. The $$$i$$$-th of the following $$$q$$$ lines contains one integer $$$k_i$$$ $$$(1 le k_i le 10^{18})$$$ β the description of the corresponding query. Output Print $$$q$$$ lines. In the $$$i$$$-th line print one digit $$$x_i$$$ $$$(0 le x_i le 9)$$$ β the answer to the query $$$i$$$, i.e. $$$x_i$$$ should be equal to the element at the position $$$k_i$$$ of the sequence. Examples Input 4 2132 506 999999999999999999 1000000000000000000 Note Answers on queries from the first example are described in the problem statement. | 2,200 | true | false | false | false | false | false | false | true | false | false | 4,592 |
1805E | You are given a tree (a connected graph without cycles). Each vertex of the tree contains an integer. Let's define the $$$mathrm{MAD}$$$ (maximum double) parameter of the tree as the maximum integer that occurs in the vertices of the tree at least $$$2$$$ times. If no number occurs in the tree more than once, then we assume $$$mathrm{MAD}=0$$$. Note that if you remove an edge from the tree, it splits into two trees. Let's compute the $$$mathrm{MAD}$$$ parameters of the two trees and take the maximum of the two values. Let the result be the value of the deleted edge. For each edge, find its value. Note that we don't actually delete any edges from the tree, the values are to be found independently. Input The first line contains one integer $$$n$$$ ($$$2 le n le 10^5$$$)xa0β the number of vertices in the tree. Each of the next $$$n - 1$$$ lines contains two integers $$$u$$$ and $$$v$$$ ($$$1 le u, v le n$$$)xa0β the ends of an edge of the tree. It's guaranteed that the given edges form a valid tree. The last line contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$1 le a_i le 10^9$$$)xa0β the numbers in the vertices. Output For each edge in the input order, print one numberxa0β the maximum of the $$$mathrm{MAD}$$$ parameters of the two trees obtained after removing the given edge from the initial tree. Examples Input 5 1 2 2 3 2 4 1 5 2 1 3 2 1 Input 6 1 2 1 3 1 4 4 5 4 6 1 2 3 1 4 5 Note In the first example, after removing edge $$$(1, 2)$$$ no number repeats $$$2$$$ times in any of the resulting subtrees, so the answer is $$$max(0, 0)=0$$$. After removing edge $$$(2, 3)$$$, in the bigger subtree, $$$1$$$ is repeated twice, and $$$2$$$ is repeated twice, so the $$$mathrm{MAD}$$$ of this tree is $$$2$$$. After removing edge $$$(2, 4)$$$, in the bigger subtree, only the number $$$1$$$ is repeated, and in the second subtree, only one number appears, so the answer is $$$1$$$. In the second example, if edge $$$1 leftrightarrow 4$$$ is not removed, then one of the subtrees will have two $$$1$$$, so the answerxa0β $$$1$$$. And if edge $$$1 leftrightarrow 4$$$ is deleted, both subtrees have no repeating values, so the answer is $$$0$$$. | 2,300 | false | false | false | true | true | false | true | false | false | false | 1,445 |
149A | What joy! Petya's parents went on a business trip for the whole year and the playful kid is left all by himself. Petya got absolutely happy. He jumped on the bed and threw pillows all day long, until... Today Petya opened the cupboard and found a scary note there. His parents had left him with duties: he should water their favourite flower all year, each day, in the morning, in the afternoon and in the evening. "Wait a second!" β thought Petya. He know for a fact that if he fulfills the parents' task in the _i_-th (1u2009β€u2009_i_u2009β€u200912) month of the year, then the flower will grow by _a__i_ centimeters, and if he doesn't water the flower in the _i_-th month, then the flower won't grow this month. Petya also knows that try as he might, his parents won't believe that he has been watering the flower if it grows strictly less than by _k_ centimeters. Help Petya choose the minimum number of months when he will water the flower, given that the flower should grow no less than by _k_ centimeters. Input The first line contains exactly one integer _k_ (0u2009β€u2009_k_u2009β€u2009100). The next line contains twelve space-separated integers: the _i_-th (1u2009β€u2009_i_u2009β€u200912) number in the line represents _a__i_ (0u2009β€u2009_a__i_u2009β€u2009100). Output Print the only integer β the minimum number of months when Petya has to water the flower so that the flower grows no less than by _k_ centimeters. If the flower can't grow by _k_ centimeters in a year, print -1. Examples Input 5 1 1 1 1 2 2 3 2 2 1 1 1 Input 0 0 0 0 0 0 0 0 1 1 2 3 0 Input 11 1 1 4 1 1 5 1 1 4 1 1 1 Note Let's consider the first sample test. There it is enough to water the flower during the seventh and the ninth month. Then the flower grows by exactly five centimeters. In the second sample Petya's parents will believe him even if the flower doesn't grow at all (_k_u2009=u20090). So, it is possible for Petya not to water the flower at all. | 900 | false | true | true | false | false | false | false | false | true | false | 9,281 |
1056E | One of Arkady's friends works at a huge radio telescope. A few decades ago the telescope has sent a signal $$$s$$$ towards a faraway galaxy. Recently they've received a response $$$t$$$ which they believe to be a response from aliens! The scientists now want to check if the signal $$$t$$$ is similar to $$$s$$$. The original signal $$$s$$$ was a sequence of zeros and ones (everyone knows that binary code is the universe-wide language). The returned signal $$$t$$$, however, does not look as easy as $$$s$$$, but the scientists don't give up! They represented $$$t$$$ as a sequence of English letters and say that $$$t$$$ is similar to $$$s$$$ if you can replace all zeros in $$$s$$$ with some string $$$r_0$$$ and all ones in $$$s$$$ with some other string $$$r_1$$$ and obtain $$$t$$$. The strings $$$r_0$$$ and $$$r_1$$$ must be different and non-empty. Please help Arkady's friend and find the number of possible replacements for zeros and ones (the number of pairs of strings $$$r_0$$$ and $$$r_1$$$) that transform $$$s$$$ to $$$t$$$. Input The first line contains a string $$$s$$$ ($$$2 le s le 10^5$$$) consisting of zeros and onesxa0β the original signal. The second line contains a string $$$t$$$ ($$$1 le t le 10^6$$$) consisting of lowercase English letters onlyxa0β the received signal. It is guaranteed, that the string $$$s$$$ contains at least one '0' and at least one '1'. Output Print a single integerxa0β the number of pairs of strings $$$r_0$$$ and $$$r_1$$$ that transform $$$s$$$ to $$$t$$$. In case there are no such pairs, print $$$0$$$. Note In the first example, the possible pairs $$$(r_0, r_1)$$$ are as follows: "a", "aaaaa" "aa", "aaaa" "aaaa", "aa" "aaaaa", "a" The pair "aaa", "aaa" is not allowed, since $$$r_0$$$ and $$$r_1$$$ must be different. In the second example, the following pairs are possible: "ko", "kokotlin" "koko", "tlin | 2,100 | false | false | false | false | true | false | true | false | false | false | 5,428 |
52C | You are given circular array _a_0,u2009_a_1,u2009...,u2009_a__n_u2009-u20091. There are two types of operations with it: _inc_(_lf_,u2009_rg_,u2009_v_) β this operation increases each element on the segment [_lf_,u2009_rg_] (inclusively) by _v_; _rmq_(_lf_,u2009_rg_) β this operation returns minimal value on the segment [_lf_,u2009_rg_] (inclusively). Assume segments to be circular, so if _n_u2009=u20095 and _lf_u2009=u20093,u2009_rg_u2009=u20091, it means the index sequence: 3,u20094,u20090,u20091. Write program to process given sequence of operations. Input The first line contains integer _n_ (1u2009β€u2009_n_u2009β€u2009200000). The next line contains initial state of the array: _a_0,u2009_a_1,u2009...,u2009_a__n_u2009-u20091 (u2009-u2009106u2009β€u2009_a__i_u2009β€u2009106), _a__i_ are integer. The third line contains integer _m_ (0u2009β€u2009_m_u2009β€u2009200000), _m_ β the number of operartons. Next _m_ lines contain one operation each. If line contains two integer _lf_,u2009_rg_ (0u2009β€u2009_lf_,u2009_rg_u2009β€u2009_n_u2009-u20091) it means _rmq_ operation, it contains three integers _lf_,u2009_rg_,u2009_v_ (0u2009β€u2009_lf_,u2009_rg_u2009β€u2009_n_u2009-u20091;u2009-u2009106u2009β€u2009_v_u2009β€u2009106) β _inc_ operation. Output For each _rmq_ operation write result for it. Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d). Examples Input 4 1 2 3 4 4 3 0 3 0 -1 0 1 2 1 | 2,200 | false | false | false | false | true | false | false | false | false | false | 9,711 |
1869A | Enter Register HOME TOP CATALOG CONTESTS GYM PROBLEMSET GROUPS RATING EDU API CALENDAR HELP RAYAN Codeforces Round 896 (Div. 2) 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 *900 No tag edit access β Contest materials Announcement (en) Tutorial (en) PROBLEMS SUBMIT STATUS STANDINGS CUSTOM TEST A. Make It Zero time limit per test1 second memory limit per test256 megabytes During Zhongkao examination, Reycloer met an interesting problem, but he cannot come up with a solution immediately. Time is running out! Please help him. Initially, you are given an array $$$a$$$ consisting of $$$n ge 2$$$ integers, and you want to change all elements in it to $$$0$$$. In one operation, you select two indices $$$l$$$ and $$$r$$$ ($$$1le lle rle n$$$) and do the following: Let $$$s=a_loplus a_{l+1}oplus ldots oplus a_r$$$, where $$$oplus$$$ denotes the bitwise XOR operation; Then, for all $$$lle ile r$$$, replace $$$a_i$$$ with $$$s$$$. You can use the operation above in any order at most $$$8$$$ times in total. Find a sequence of operations, such that after performing the operations in order, all elements in $$$a$$$ are equal to $$$0$$$. It can be proven that the solution always exists. Input The first line of input contains a single integer $$$t$$$ ($$$1le tle 500$$$) β the number of test cases. The description of test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$2le nle 100$$$) β the length of the array $$$a$$$. The second line of each test case contains $$$n$$$ integers $$$a_1,a_2,ldots,a_n$$$ ($$$0le a_ile 100$$$) β the elements of the array $$$a$$$. Output For each test case, in the first line output a single integer $$$k$$$ ($$$0le kle 8$$$) β the number of operations you use. Then print $$$k$$$ lines, in the $$$i$$$-th line output two integers $$$l_i$$$ and $$$r_i$$$ ($$$1le l_ile r_ile n$$$) representing that you select $$$l_i$$$ and $$$r_i$$$ in the $$$i$$$-th operation. Note that you do not have to minimize $$$k$$$. If there are multiple solutions, you may output any of them. Example input 6 4 1 2 3 0 8 3 1 4 1 5 9 2 6 6 1 5 4 1 4 7 5 0 0 0 0 0 7 1 1 9 9 0 1 8 3 100 100 0 output 1 1 4 2 4 7 1 8 6 1 2 3 4 5 6 1 3 4 6 1 6 0 4 1 2 6 7 3 4 6 7 1 1 2 Note In the first test case, since $$$1oplus2oplus3oplus0=0$$$, after performing the operation on segment $$$[1,4]$$$, all the elements in the array are equal to $$$0$$$. In the second test case, after the first operation, the array becomes equal to $$$[3,1,4,15,15,15,15,6]$$$, after the second operation, the array becomes equal to $$$[0,0,0,0,0,0,0,0]$$$. In the third test case: Operation $$$a$$$ before $$$a$$$ after $$$1$$$ $$$[underline{1,5},4,1,4,7]$$$ $$$ ightarrow$$$ $$$[4,4,4,1,4,7]$$$ $$$2$$$ $$$[4,4,underline{4,1},4,7]$$$ $$$ ightarrow$$$ $$$[4,4,5,5,4,7]$$$ $$$3$$$ $$$[4,4,5,5,underline{4,7}]$$$ $$$ ightarrow$$$ $$$[4,4,5,5,3,3]$$$ $$$4$$$ $$$[underline{4,4,5},5,3,3]$$$ $$$ ightarrow$$$ $$$[5,5,5,5,3,3]$$$ $$$5$$$ $$$[5,5,5,underline{5,3,3}]$$$ $$$ ightarrow$$$ $$$[5,5,5,5,5,5]$$$ $$$6$$$ $$$[underline{5,5,5,5,5,5}]$$$ $$$ ightarrow$$$ $$$[0,0,0,0,0,0]$$$ In the fourth test case, the initial array contains only $$$0$$$, so we do not need to perform any operations with it. Codeforces (c) | 900 | false | false | false | false | false | true | false | false | false | false | 1,061 |
1556H | William really likes puzzle kits. For one of his birthdays, his friends gifted him a complete undirected edge-weighted graph consisting of $$$n$$$ vertices. He wants to build a spanning tree of this graph, such that for the first $$$k$$$ vertices the following condition is satisfied: the degree of a vertex with index $$$i$$$ does not exceed $$$d_i$$$. Vertices from $$$k + 1$$$ to $$$n$$$ may have any degree. William wants you to find the minimum weight of a spanning tree that satisfies all the conditions. A spanning tree is a subset of edges of a graph that forms a tree on all $$$n$$$ vertices of the graph. The weight of a spanning tree is defined as the sum of weights of all the edges included in a spanning tree. Input The first line of input contains two integers $$$n$$$, $$$k$$$ ($$$2 leq n leq 50$$$, $$$1 leq k leq min(n - 1, 5)$$$). The second line contains $$$k$$$ integers $$$d_1, d_2, ldots, d_k$$$ ($$$1 leq d_i leq n$$$). The $$$i$$$-th of the next $$$n - 1$$$ lines contains $$$n - i$$$ integers $$$w_{i,i+1}, w_{i,i+2}, ldots, w_{i,n}$$$ ($$$1 leq w_{i,j} leq 100$$$): weights of edges $$$(i,i+1),(i,i+2),ldots,(i,n)$$$. Output Print one integer: the minimum weight of a spanning tree under given degree constraints for the first $$$k$$$ vertices. Example Input 10 5 5 3 4 2 1 29 49 33 12 55 15 32 62 37 61 26 15 58 15 22 8 58 37 16 9 39 20 14 58 10 15 40 3 19 55 53 13 37 44 52 23 59 58 4 69 80 29 89 28 48 | 3,300 | true | true | false | false | false | false | false | false | false | true | 2,848 |
415A | Mashmokh works in a factory. At the end of each day he must turn off all of the lights. The lights on the factory are indexed from 1 to _n_. There are _n_ buttons in Mashmokh's room indexed from 1 to _n_ as well. If Mashmokh pushes button with index _i_, then each light with index not less than _i_ that is still turned on turns off. Mashmokh is not very clever. So instead of pushing the first button he pushes some of the buttons randomly each night. He pushed _m_ distinct buttons _b_1,u2009_b_2,u2009...,u2009_b__m_ (the buttons were pushed consecutively in the given order) this night. Now he wants to know for each light the index of the button that turned this light off. Please note that the index of button _b__i_ is actually _b__i_, not _i_. Please, help Mashmokh, print these indices. Input The first line of the input contains two space-separated integers _n_ and _m_ (1u2009β€u2009_n_,u2009_m_u2009β€u2009100), the number of the factory lights and the pushed buttons respectively. The next line contains _m_ distinct space-separated integers _b_1,u2009_b_2,u2009...,u2009_b__m_xa0(1u2009β€u2009_b__i_u2009β€u2009_n_). It is guaranteed that all lights will be turned off after pushing all buttons. Output Output _n_ space-separated integers where the _i_-th number is index of the button that turns the _i_-th light off. Note In the first sample, after pressing button number 4, lights 4 and 5 are turned off and lights 1, 2 and 3 are still on. Then after pressing button number 3, light number 3 is turned off as well. Pressing button number 1 turns off lights number 1 and 2 as well so pressing button number 2 in the end has no effect. Thus button number 4 turned lights 4 and 5 off, button number 3 turned light 3 off and button number 1 turned light 1 and 2 off. | 900 | false | false | true | false | false | false | false | false | false | false | 8,164 |
1045G | In the last mission, MDCS has successfully shipped $$$N$$$ AI robots to Mars. Before they start exploring, system initialization is required so they are arranged in a line. Every robot can be described with three numbers: position ($$$x_i$$$), radius of sight ($$$r_i$$$) and IQ ($$$q_i$$$). Since they are intelligent robots, some of them will talk if they see each other. Radius of sight is inclusive, so robot can see other all robots in range $$$[x_i - r_i, x_i + r_i]$$$. But they don't walk to talk with anybody, but only with robots who have similar IQ. By similar IQ we mean that their absolute difference isn't more than $$$K$$$. Help us and calculate how many pairs of robots are going to talk with each other, so we can timely update their software and avoid any potential quarrel. Input The first line contains two integers, numbers $$$N (1 leq N leq 10^5) $$$ and $$$K (0 leq K leq 20)$$$. Next $$$N$$$ lines contain three numbers each $$$x_i, r_i, q_i (0 leq x_i,r_i,q_i leq 10^9)$$$ β position, radius of sight and IQ of every robot respectively. Output Output contains only one number β solution to the problem. Example Input 3 2 3 6 1 7 3 10 10 5 8 Note The first robot can see the second, but not vice versa. The first robot can't even see the third. The second and the third robot can see each other and their IQs don't differ more than 2 so only one conversation will happen. | 2,200 | false | false | false | false | true | false | false | false | false | false | 5,464 |
1761F2 | This is the hard version of the problem. The only difference between the two versions is the constraint on $$$n$$$. You can make hacks only if all versions of the problem are solved. Let's call an array $$$a$$$ of odd length $$$2m+1$$$ (with $$$m ge 1$$$) bad, if element $$$a_{m+1}$$$ is equal to the median of this array. In other words, the array is bad if, after sorting it, the element at $$$m+1$$$-st position remains the same. Let's call a permutation $$$p$$$ of integers from $$$1$$$ to $$$n$$$ anti-median, if every its subarray of odd length $$$ge 3$$$ is not bad. You are already given values of some elements of the permutation. Find the number of ways to set unknown values to obtain an anti-median permutation. As this number can be very large, find it modulo $$$10^9+7$$$. Input The first line 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$$$ $$$(2 le n le 10^6)$$$ xa0β the length of the permutation. The second line of each test case contains $$$n$$$ integers $$$p_1, p_2, ldots, p_n$$$ ($$$1 le p_i le n$$$, or $$$p_i = -1$$$) xa0β the elements of the permutation. If $$$p_i eq -1$$$, it's given, else it's unknown. It's guaranteed that if for some $$$i eq j$$$ holds $$$p_i eq -1, p_j eq -1$$$, then $$$p_i eq p_j$$$. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^6$$$. Note In the first test case, both $$$[1, 2]$$$ and $$$[2, 1]$$$ are anti-median. In the second test case, permutations $$$[1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2]$$$ are anti-median. The remaining two permutations, $$$[1, 2, 3]$$$, $$$[3, 2, 1]$$$, are bad arrays on their own, as their median, $$$2$$$, is in their middle. In the third test case, $$$[1, 2, 3, 4]$$$ isn't anti-median, as it contains bad subarray $$$[1, 2, 3]$$$. In the fourth test case, the only anti-median array you can get is $$$[5, 6, 3, 4, 1, 2]$$$. | 3,500 | true | false | false | true | false | false | false | false | false | false | 1,742 |
1817D | There is a toy machine with toys arranged in two rows of $$$n$$$ cells each ($$$n$$$ is odd). Initial state for $$$n=9$$$. Initially, $$$n-2$$$ toys are placed in the non-corner cells of the top row. The bottom row is initially empty, and its leftmost, rightmost, and central cells are blocked. There are $$$4$$$ buttons to control the toy machine: left, right, up, and down marked by the letters L, R, U, and D correspondingly. When pressing L, R, U, or D, all the toys will be moved simultaneously in the corresponding direction and will only stop if they push into another toy, the wall or a blocked cell. Your goal is to move the $$$k$$$-th toy into the leftmost cell of the top row. The toys are numbered from $$$1$$$ to $$$n-2$$$ from left to right. Given $$$n$$$ and $$$k$$$, find a solution that uses at most $$$1,000,000$$$ button presses. To test out the toy machine, a xa0β the number of cells in a row, and the index of the toy that has to be moved to the leftmost cell of the top row. Output On a single line, output a description of the button presses as a string of at most $$$1,000,000$$$ characters. The string should only contain the characters L, R, U, and D. The $$$i$$$-th character in the string is the $$$i$$$-th button that is pressed. After all the button presses are performed, the $$$k$$$-th toy should be in the leftmost cell of the top row. If there are multiple solutions, print any. The number of button presses does not have to be minimized. Note In the first example, there will be $$$5-2 = 3$$$ toys. The first toy needs to end up in the leftmost cell of the top row. The moves RDL will achieve this, see the picture for a better understanding. Another possible solution would be to do one button press L. Visualization of the moves for the first example. | 2,700 | false | false | true | false | false | true | false | false | false | false | 1,370 |
1354F | Polycarp plays a computer game. In this game, the players summon armies of magical minions, which then fight each other. Polycarp can summon $$$n$$$ different minions. The initial power level of the $$$i$$$-th minion is $$$a_i$$$, and when it is summoned, all previously summoned minions' power levels are increased by $$$b_i$$$. The minions can be summoned in any order. Unfortunately, Polycarp cannot have more than $$$k$$$ minions under his control. To get rid of unwanted minions after summoning them, he may destroy them. Each minion can be summoned (and destroyed) only once. Polycarp's goal is to summon the strongest possible army. Formally, he wants to maximize the sum of power levels of all minions under his control (those which are summoned and not destroyed). Help Polycarp to make up a plan of actions to summon the strongest possible army! Input The first line contains one integer $$$T$$$ ($$$1 le T le 75$$$) β the number of test cases. Each test case begins with a line containing two integers $$$n$$$ and $$$k$$$ ($$$1 le k le n le 75$$$) β the number of minions availible for summoning, and the maximum number of minions that can be controlled by Polycarp, respectively. Then $$$n$$$ lines follow, the $$$i$$$-th line contains $$$2$$$ integers $$$a_i$$$ and $$$b_i$$$ ($$$1 le a_i le 10^5$$$, $$$0 le b_i le 10^5$$$) β the parameters of the $$$i$$$-th minion. Output For each test case print the optimal sequence of actions as follows: Firstly, print $$$m$$$ β the number of actions which Polycarp has to perform ($$$0 le m le 2n$$$). Then print $$$m$$$ integers $$$o_1$$$, $$$o_2$$$, ..., $$$o_m$$$, where $$$o_i$$$ denotes the $$$i$$$-th action as follows: if the $$$i$$$-th action is to summon the minion $$$x$$$, then $$$o_i = x$$$, and if the $$$i$$$-th action is to destroy the minion $$$x$$$, then $$$o_i = -x$$$. Each minion can be summoned at most once and cannot be destroyed before being summoned (and, obviously, cannot be destroyed more than once). The number of minions in Polycarp's army should be not greater than $$$k$$$ after every action. If there are multiple optimal sequences, print any of them. Example Input 3 5 2 5 3 7 0 5 0 4 0 10 0 2 1 10 100 50 10 5 5 1 5 2 4 3 3 4 2 5 1 Output 4 2 1 -1 5 1 2 5 5 4 3 2 1 Note Consider the example test. In the first test case, Polycarp can summon the minion $$$2$$$ with power level $$$7$$$, then summon the minion $$$1$$$, which will increase the power level of the previous minion by $$$3$$$, then destroy the minion $$$1$$$, and finally, summon the minion $$$5$$$. After this, Polycarp will have two minions with power levels of $$$10$$$. In the second test case, Polycarp can control only one minion, so he should choose the strongest of them and summon it. In the third test case, Polycarp is able to summon and control all five minions. | 2,500 | false | true | false | true | false | true | false | false | true | false | 3,933 |
1800D | Dmitry has a string $$$s$$$, consisting of lowercase Latin letters. Dmitry decided to remove two consecutive characters from the string $$$s$$$ and you are wondering how many different strings can be obtained after such an operation. For example, Dmitry has a string "aaabcc". You can get the following different strings: "abcc"(by deleting the first two or second and third characters), "aacc"(by deleting the third and fourth characters),"aaac"(by deleting the fourth and the fifth character) and "aaab" (by deleting the last two). Input The first line of input data contains a single integer $$$t$$$ ($$$1 le t le 10^4$$$)xa0β number of test cases. The descriptions of the test cases follow. The first line of the description of each test case contains an integer $$$n$$$ ($$$3 le n le 2 cdot 10^5$$$). The second line of the description of each test case contains a string $$$s$$$ of length $$$n$$$ consisting of lowercase Latin letters. It is guaranteed that the sum of $$$n$$$ for all test cases does not exceed $$$2 cdot 10^5$$$. Output For each test case print one integer β the number of distinct strings that can be obtained by removing two consecutive letters. Example Input 7 6 aaabcc 10 aaaaaaaaaa 6 abcdef 7 abacaba 6 cccfff 4 abba 5 ababa Note The first example is explained in the statement. In the third example, the following strings are obtained: "cdef", "adef", "abef", "abcf", "abcd". In the seventh example, any deletion will result in the string "aba". | 1,200 | false | true | false | false | true | false | false | false | false | false | 1,471 |
1706C | Qpwoeirut has taken up architecture and ambitiously decided to remodel his city. Qpwoeirut's city can be described as a row of $$$n$$$ buildings, the $$$i$$$-th ($$$1 le i le n$$$) of which is $$$h_i$$$ floors high. You can assume that the height of every floor in this problem is equal. Therefore, building $$$i$$$ is taller than the building $$$j$$$ if and only if the number of floors $$$h_i$$$ in building $$$i$$$ is larger than the number of floors $$$h_j$$$ in building $$$j$$$. Building $$$i$$$ is cool if it is taller than both building $$$i-1$$$ and building $$$i+1$$$ (and both of them exist). Note that neither the $$$1$$$-st nor the $$$n$$$-th building can be cool. To remodel the city, Qpwoeirut needs to maximize the number of cool buildings. To do this, Qpwoeirut can build additional floors on top of any of the buildings to make them taller. Note that he cannot remove already existing floors. Since building new floors is expensive, Qpwoeirut wants to minimize the number of floors he builds. Find the minimum number of floors Qpwoeirut needs to build in order to maximize the number of cool buildings. 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 the single integer $$$n$$$ ($$$3 le n le 10^5$$$)xa0β the number of buildings in Qpwoeirut's city. The second line of each test case contains $$$n$$$ integers $$$h_1, h_2, ldots, h_n$$$ ($$$1 le h_i le 10^9$$$)xa0β the number of floors in each of the buildings of the city. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$2 cdot 10^5$$$. Note In the first test case, it is optimal for Qpwoeirut to make the second building cool by building $$$2$$$ additional floors on top of it, making it taller than both of its adjacent buildings. The final heights of buildings will be $$$[2, underline{3}, 2]$$$. In the second test case, the number of cool buildings is already maximized, so Qpwoeirut does not need to do anything. In the third test case, it is optimal for Qpwoeirut to make the third and fifth buildings cool by building $$$2$$$ additional floors onto the third building and $$$1$$$ additional floor onto the fifth building. The final heights of buildings will be $$$[3, 1, underline{6}, 5, underline{6}, 2]$$$. It can be shown that it is impossible to make more than $$$2$$$ of the buildings cool, or to make $$$2$$$ buildings cool using fewer than $$$3$$$ additional floors. In the fourth test case, Qpwoeirut can either make the second building cool, or he can make the third building cool. Either way, he will be building $$$3$$$ additional floors and maximizing the number of cool buildings. The final heights of buildings will be $$$[4, 2, underline{4}, 3, 5, 3, 6, 1]$$$ or $$$[4, underline{5}, 1, 3, 5, 3, 6, 1]$$$. | 1,400 | false | true | true | true | false | false | false | false | false | false | 2,038 |
1136E | In this task, Nastya asked us to write a formal statement. An array $$$a$$$ of length $$$n$$$ and an array $$$k$$$ of length $$$n-1$$$ are given. Two types of queries should be processed: increase $$$a_i$$$ by $$$x$$$. Then if $$$a_{i+1} < a_i + k_i$$$, $$$a_{i+1}$$$ becomes exactly $$$a_i + k_i$$$; again, if $$$a_{i+2} < a_{i+1} + k_{i+1}$$$, $$$a_{i+2}$$$ becomes exactly $$$a_{i+1} + k_{i+1}$$$, and so far for $$$a_{i+3}$$$, ..., $$$a_n$$$; print the sum of the contiguous subarray from the $$$l$$$-th element to the $$$r$$$-th element of the array $$$a$$$. It's guaranteed that initially $$$a_i + k_i leq a_{i+1}$$$ for all $$$1 leq i leq n-1$$$. Input The first line contains a single integer $$$n$$$ ($$$2 leq n leq 10^{5}$$$)xa0β the number of elements in the array $$$a$$$. The second line contains $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$ ($$$-10^{9} leq a_i leq 10^{9}$$$)xa0β the elements of the array $$$a$$$. The third line contains $$$n-1$$$ integers $$$k_1, k_2, ldots, k_{n-1}$$$ ($$$-10^{6} leq k_i leq 10^{6}$$$)xa0β the elements of the array $$$k$$$. The fourth line contains a single integer $$$q$$$ ($$$1 leq q leq 10^{5}$$$)xa0β the number of queries. Each of the following $$$q$$$ lines contains a query of one of two types: if the query has the first type, the corresponding line contains the character '+' (without quotes), and then there are two integers $$$i$$$ and $$$x$$$ ($$$1 leq i leq n$$$, $$$0 leq x leq 10^{6}$$$), it means that integer $$$x$$$ is added to the $$$i$$$-th element of the array $$$a$$$ as described in the statement. if the query has the second type, the corresponding line contains the character 's' (without quotes) and then there are two integers $$$l$$$ and $$$r$$$ ($$$1 leq l leq r leq n$$$). Output For each query of the second type print a single integer in a new linexa0β the sum of the corresponding subarray. Examples Input 3 1 2 3 1 -1 5 s 2 3 + 1 2 s 1 2 + 3 1 s 2 3 Input 3 3 6 7 3 1 3 + 1 3 + 2 4 s 1 3 Note In the first example: after the first change $$$a = [3, 4, 3]$$$; after the second change $$$a = [3, 4, 4]$$$. In the second example: after the first change $$$a = [6, 9, 10]$$$; after the second change $$$a = [6, 13, 14]$$$. | 2,200 | false | false | false | false | true | false | false | true | false | false | 5,043 |
1620D | One day, early in the morning, you decided to buy yourself a bag of chips in the nearby store. The store has chips of $$$n$$$ different flavors. A bag of the $$$i$$$-th flavor costs $$$a_i$$$ burles. The store may run out of some flavors, so you'll decide which one to buy after arriving there. But there are two major flaws in this plan: 1. you have only coins of $$$1$$$, $$$2$$$ and $$$3$$$ burles; 2. since it's morning, the store will ask you to pay in exact change, i.xa0e. if you choose the $$$i$$$-th flavor, you'll have to pay exactly $$$a_i$$$ burles. Coins are heavy, so you'd like to take the least possible number of coins in total. That's why you are wondering: what is the minimum total number of coins you should take with you, so you can buy a bag of chips of any flavor in exact change? 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 single integer $$$n$$$ ($$$1 le n le 100$$$)xa0β the number of flavors in the store. The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, dots, a_n$$$ ($$$1 le a_i le 10^9$$$)xa0β the cost of one bag of each flavor. Output For each test case, print one integerxa0β the minimum number of coins you need to buy one bag of any flavor you'll choose in exact change. Example Input 4 1 1337 3 10 8 10 5 1 2 3 4 5 3 7 77 777 Note In the first test case, you should, for example, take with you $$$445$$$ coins of value $$$3$$$ and $$$1$$$ coin of value $$$2$$$. So, $$$1337 = 445 cdot 3 + 1 cdot 2$$$. In the second test case, you should, for example, take $$$2$$$ coins of value $$$3$$$ and $$$2$$$ coins of value $$$2$$$. So you can pay either exactly $$$8 = 2 cdot 3 + 1 cdot 2$$$ or $$$10 = 2 cdot 3 + 2 cdot 2$$$. In the third test case, it's enough to take $$$1$$$ coin of value $$$3$$$ and $$$2$$$ coins of value $$$1$$$. | 2,000 | false | true | false | false | false | true | true | false | false | false | 2,524 |
1466D | You've probably heard about the twelve labors of Heracles, but do you have any idea about the thirteenth? It is commonly assumed it took him a dozen years to complete the twelve feats, so on average, a year to accomplish every one of them. As time flows faster these days, you have minutes rather than months to solve this task. But will you manage? In this problem, you are given a tree with $$$n$$$ weighted vertices. A tree is a connected graph with $$$n - 1$$$ edges. Let us define its $$$k$$$-coloring as an assignment of $$$k$$$ colors to the edges so that each edge has exactly one color assigned to it. Note that you don't have to use all $$$k$$$ colors. A subgraph of color $$$x$$$ consists of these edges from the original tree, which are assigned color $$$x$$$, and only those vertices that are adjacent to at least one such edge. So there are no vertices of degree $$$0$$$ in such a subgraph. The value of a connected component is the sum of weights of its vertices. Let us define the value of a subgraph as a maximum of values of its connected components. We will assume that the value of an empty subgraph equals $$$0$$$. There is also a value of a $$$k$$$-coloring, which equals the sum of values of subgraphs of all $$$k$$$ colors. Given a tree, for each $$$k$$$ from $$$1$$$ to $$$n - 1$$$ calculate the maximal value of a $$$k$$$-coloring. Input In the first line of input, there is a single integer $$$t$$$ ($$$1 leq t leq 10^5$$$) denoting the number of test cases. Then $$$t$$$ test cases follow. First line of each test case contains a single integer $$$n$$$ ($$$2 leq n leq 10^5$$$). The second line consists of $$$n$$$ integers $$$w_1, w_2, dots, w_n$$$ ($$$0 leq w_i leq 10^9$$$), $$$w_i$$$ equals the weight of $$$i$$$-th vertex. In each of the following $$$n - 1$$$ lines, there are two integers $$$u$$$, $$$v$$$ ($$$1 leq u,v leq n$$$) describing an edge between vertices $$$u$$$ and $$$v$$$. It is guaranteed that these edges form a tree. The sum of $$$n$$$ in all test cases will not exceed $$$2 cdot 10^5$$$. Output For every test case, your program should print one line containing $$$n - 1$$$ integers separated with a single space. The $$$i$$$-th number in a line should be the maximal value of a $$$i$$$-coloring of the tree. Example Input 4 4 3 5 4 6 2 1 3 1 4 3 2 21 32 2 1 6 20 13 17 13 13 11 2 1 3 1 4 1 5 1 6 1 4 10 6 6 6 1 2 2 3 4 1 Output 18 22 25 53 87 107 127 147 167 28 38 44 Note The optimal $$$k$$$-colorings from the first test case are the following: In the $$$1$$$-coloring all edges are given the same color. The subgraph of color $$$1$$$ contains all the edges and vertices from the original graph. Hence, its value equals $$$3 + 5 + 4 + 6 = 18$$$. In an optimal $$$2$$$-coloring edges $$$(2, 1)$$$ and $$$(3,1)$$$ are assigned color $$$1$$$. Edge $$$(4, 3)$$$ is of color $$$2$$$. Hence the subgraph of color $$$1$$$ consists of a single connected component (vertices $$$1, 2, 3$$$) and its value equals $$$3 + 5 + 4 = 12$$$. The subgraph of color $$$2$$$ contains two vertices and one edge. Its value equals $$$4 + 6 = 10$$$. In an optimal $$$3$$$-coloring all edges are assigned distinct colors. Hence subgraphs of each color consist of a single edge. They values are as follows: $$$3 + 4 = 7$$$, $$$4 + 6 = 10$$$, $$$3 + 5 = 8$$$. | 1,500 | false | true | false | false | true | false | false | false | true | false | 3,363 |
1690G | There are $$$n$$$ of independent carriages on the rails. The carriages are numbered from left to right from $$$1$$$ to $$$n$$$. The carriages are not connected to each other. The carriages move to the left, so that the carriage with number $$$1$$$ moves ahead of all of them. The $$$i$$$-th carriage has its own engine, which can accelerate the carriage to $$$a_i$$$ km/h, but the carriage cannot go faster than the carriage in front of it. See example for explanation. All carriages start moving to the left at the same time, and they naturally form trains. We will call trainsxa0β consecutive moving carriages having the same speed. For example, we have $$$n=5$$$ carriages and array $$$a = [10, 13, 5, 2, 6]$$$. Then the final speeds of the carriages will be $$$[10, 10, 5, 2, 2]$$$. Respectively, $$$3$$$ of the train will be formed. There are also messages saying that some engine has been corrupted: message "k d" means that the speed of the $$$k$$$-th carriage has decreased by $$$d$$$ (that is, there has been a change in the maximum speed of the carriage $$$a_k = a_k - d$$$). Messages arrive sequentially, the processing of the next message takes into account the changes from all previous messages. After each message determine the number of formed trains. Input The first line of input data contains a single integer $$$t$$$ ($$$1 le t le 10^4$$$)xa0βthe number of input test cases. This is followed by descriptions of the test cases. The first line of each test case is empty. The second line of the test case contains two integers $$$n$$$ and $$$m$$$ ($$$1 le n,m le 10^5$$$)xa0βthe number of carriages and the number of messages to slow down the carriage, respectively. The third line contains $$$n$$$ integers: $$$a_1, a_2, dots, a_n$$$ ($$$0 le a_i le 10^9$$$)xa0β the number $$$a_i$$$ means that the carriage with number $$$i$$$ can reach a speed of $$$a_i$$$ km/h. The next $$$m$$$ lines contain two integers $$$k_j$$$ and $$$d_j$$$ ($$$1 le k_j le n$$$, $$$0 le d_j le a_{k_j}$$$)xa0βthis is the message that the speed of the carriage with number $$$k_j$$$ has decreased by $$$d_j$$$. In other words, there has been a change in its maximum speed $$$a_{k_j} = a_{k_j} - d_j$$$. Note that at any time the speed of each carriage is non-negative. In other words, $$$a_i ge s_i$$$, where $$$s_i$$$xa0βis the sum of such $$$d_j$$$ that $$$k_j=i$$$. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$. Similarly, it is guaranteed that the sum of $$$m$$$ over all test cases does not exceed $$$10^5$$$. Output Print $$$t$$$ lines. On each line print the answer for the corresponding test case. For each test case print $$$m$$$ numbers: the number of trains formed after each message. Example Input 3 4 2 6 2 3 7 3 2 4 7 5 4 10 13 5 2 6 2 4 5 2 1 5 3 2 13 4 769 514 336 173 181 373 519 338 985 709 729 702 168 12 581 6 222 7 233 5 117 Output 3 4 4 4 2 3 5 6 6 5 Note For the first test case: Initially array $$$a = [6, 2, 3, 7]$$$. After the first message, the array $$$a = [6, 2, 1, 7]$$$. Accordingly, the speeds of the carriages are $$$[6, 2, 1, 1]$$$ and will form $$$3$$$ of the train. After the second message the array $$$a = [6, 2, 1, 0]$$$. Accordingly, the speeds of the carriages are $$$[6, 2, 1, 0]$$$, and $$$4$$$ of the train will be formed. For the second test case: Initially, the array $$$a = [10, 13, 5, 2, 6]$$$. After the first message, the array $$$a = [10, 9, 5, 2, 6]$$$. Accordingly, the speeds of the carriages are equal: $$$[10, 9, 5, 2, 2]$$$, and $$$4$$$ of the train will be formed. After the second message the array $$$a = [10, 9, 5, 2, 4]$$$. Accordingly, the speeds of the carriages are $$$[10, 9, 5, 2, 2]$$$, and $$$4$$$ of the train will be formed. After the third message the array $$$a = [5, 9, 5, 2, 4]$$$. Accordingly, the speeds of the carriages are $$$[5, 5, 5, 2, 2]$$$, and $$$2$$$ of the train will be formed. After the fourth message the array $$$a = [5, 9, 3, 2, 4]$$$. Accordingly, the speeds of the carriages are $$$[5, 5, 3, 2, 2]$$$, and $$$3$$$ of the train will be formed. | 2,000 | false | true | false | false | true | false | false | true | true | false | 2,137 |
1889C2 | The only differences between the two versions of this problem are the constraint on $$$k$$$, the time limit and the memory limit. You can make hacks only if all versions of the problem are solved. Doremy lives in a rainy country consisting of $$$n$$$ cities numbered from $$$1$$$ to $$$n$$$. The weather broadcast predicted the distribution of rain in the next $$$m$$$ days. In the $$$i$$$-th day, it will rain in the cities in the interval $$$[l_i, r_i]$$$. A city is called dry if it will never rain in that city in the next $$$m$$$ days. It turns out that Doremy has a special power. She can choose $$$k$$$ days, and during these days it will not rain. Doremy wants to calculate the maximum number of dry cities after using the special power. Input The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1le tle 10^4$$$)xa0β the number of test cases. The description of the test cases follows. The first line contains three integers $$$n$$$, $$$m$$$ and $$$k$$$ ($$$1le nle 2cdot 10^5$$$, $$$2 le m le 2cdot 10^5$$$, $$$2 le k le min(10, m)$$$)xa0β the number of cities, the number of days, and the number of days of rain that Doremy can prevent. Then, $$$m$$$ lines follow. The $$$i$$$-th line contains two integers $$$l_i$$$, $$$r_i$$$ ($$$1le l_ile r_ile n$$$)xa0β the rain coverage on day $$$i$$$. It is guaranteed that the sum of $$$n$$$ and the sum of $$$m$$$ over all test cases do not exceed $$$2cdot 10^5$$$. Output For each test case, output one integerxa0β the maximum number of dry cities. Example Input 6 2 3 2 1 2 1 2 1 1 5 3 2 1 3 2 4 3 5 10 6 4 1 5 6 10 2 2 3 7 5 8 1 4 100 6 5 1 100 1 100 1 100 1 100 1 100 1 100 1000 2 2 1 1 1 1 20 5 3 9 20 3 3 10 11 11 13 6 18 Note In the first test case, if Doremy prevents rain $$$1,2$$$, then city $$$2$$$ will be dry; rain $$$2,3$$$, then no city will be dry; rain $$$1,3$$$, then no city will be dry; So there is at most $$$1$$$ dry city. In the second test case, if Doremy prevents rain $$$1,2$$$, then city $$$1,2$$$ will be dry; rain $$$2,3$$$, then city $$$4,5$$$ will be dry; rain $$$1,3$$$, then city $$$1,5$$$ will be dry. So there are at most $$$2$$$ dry cities. In the third test case, it is optimal to prevent rain $$$1,2,4,5$$$. In the forth test case, there is always a day of rain that wets all the cities and cannot be prevented. | 2,600 | false | false | false | true | true | false | false | false | false | false | 963 |
474A | Problem - 474A - 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 *900 No tag edit access β Contest materials ") Editorial") . We have a sequence of characters he has typed and we want to find the original message. Input First line of the input contains one letter describing direction of shifting ('L' or 'R' respectively for left or right). Second line contains a sequence of characters written by Mole. The size of this sequence will be no more than 100. Sequence contains only symbols that appear on Mole's keyboard. It doesn't contain spaces as there is no space on Mole's keyboard. It is guaranteed that even though Mole hands are moved, he is still pressing buttons on keyboard and not hitting outside it. Output Print a line that contains the original message. Examples Input R s;;upimrrfod;pbr Output allyouneedislove | 900 | false | false | true | false | false | false | false | false | false | false | 7,940 |
1089K | King Kog got annoyed of the usual laxity of his knightsxa0β they can break into his hall without prior notice! Thus, the King decided to build a reception with a queue where each knight chooses in advance the time when he will come and how long the visit will take. The knights are served in the order of the recorded time, but each knight has to wait until the visits of all the knights before him are finished. Princess Keabeanie wants to see her father. However, she does not want to interrupt the knights so she joins the queue. Unfortunately, the knights change their minds very oftenxa0β they can join the queue or cancel their visits. Please help the princess to understand how long she will have to wait until she sees her father if she enters the queue at the specified moments of time given the records at the reception. Input The first line of the input contains a single integer $$$q$$$ ($$$1 leq q leq 3 cdot 10^5$$$)xa0β the number of events. An event can be of three types: join, cancel, or query. Join "+ $$$t$$$ $$$d$$$" ($$$1 leq t, d leq 10^6$$$)xa0β a new knight joins the queue, where $$$t$$$ is the time when the knight will come and $$$d$$$ is the duration of the visit. Cancel "- $$$i$$$" ($$$1 leq i leq q$$$)xa0β the knight cancels the visit, where $$$i$$$ is the number (counted starting from one) of the corresponding join event in the list of all events. Query "? $$$t$$$" ($$$1 leq t leq 10^6$$$)xa0β Keabeanie asks how long she will wait if she comes at the time $$$t$$$. It is guaranteed that after each event there are no two knights with the same entrance time in the queue. Cancel events refer to the previous joins that were not cancelled yet. Keabeanie can come at the same time as some knight, but Keabeanie is very polite and she will wait for the knight to pass. Output For each query write a separate line with the amount of time Keabeanie will have to wait. Example Input 19 ? 3 + 2 2 ? 3 ? 4 + 5 2 ? 5 ? 6 + 1 2 ? 2 ? 3 ? 4 ? 5 ? 6 ? 7 ? 9 - 8 ? 2 ? 3 ? 6 Output 0 1 0 2 1 3 2 1 2 1 0 0 2 1 1 | 2,400 | false | false | false | false | true | false | false | false | false | false | 5,275 |
1266H | There is a directed graph on $$$n$$$ vertices numbered $$$1$$$ through $$$n$$$ where each vertex (except $$$n$$$) has two outgoing arcs, red and blue. At any point in time, exactly one of the arcs is active for each vertex. Initially, all blue arcs are active and there is a token located at vertex $$$1$$$. In one second, the vertex with token first switches its active arcs β the inactive arc becomes active and vice versa. Then, the token is moved along the active arc. When the token reaches the vertex $$$n$$$, it stops. It is guaranteed that $$$n$$$ is reachable via arcs from every vertex. You are given $$$q$$$ queries. Each query contains a state of the graph β a pair $$$(v, s)$$$ of the following form: $$$v$$$ is the vertex where the token is currently located; $$$s$$$ is a string consisting of $$$n - 1$$$ characters. The $$$i$$$-th character corresponds to the color of the active edge leading from the $$$i$$$-th vertex (the character is 'R' if red arc is active, otherwise the character is 'B'). For each query, determine whether the given state is reachable from the initial state and the first time this configuration appears. Note that the two operations (change active arc and traverse it) are atomic β a state is not considered reached if it appears after changing the active arc but before traversing it. Input The first line contains a single integer $$$n$$$ ($$$2 leq n leq 58$$$)xa0β the number of vertices. $$$n-1$$$ lines follow, $$$i$$$-th of contains two space separated integers $$$b_i$$$ and $$$r_i$$$ ($$$1 leq b_i, r_i leq n$$$) representing a blue arc $$$(i, b_i)$$$ and red arc $$$(i, r_i)$$$, respectively. It is guaranteed that vertex $$$n$$$ is reachable from every vertex. The next line contains a single integer $$$q$$$ ($$$1 leq q leq 5000$$$)xa0β the number of queries. Then $$$q$$$ lines with queries follow. The $$$j$$$-th of these lines contains an integer $$$v$$$ ($$$1 leq v < n$$$) and a string $$$s$$$ of length $$$n-1$$$ consiting only of characters 'R' and 'B'. The $$$i$$$-th of these characters is 'R' if the red arc going from $$$i$$$ is active and 'B' otherwise. Output Output $$$q$$$ lines, each containing answer to a single query. If the state in the $$$i$$$-th query is unreachable, output the integer $$$-1$$$. Otherwise, output $$$t_i$$$ β the first time when the state appears (measured in seconds, starting from the initial state of the graph which appears in time $$$0$$$). Example Input 6 2 1 5 5 2 1 6 3 4 3 21 1 BBBBB 1 RBBBB 2 BBBBB 5 BRBBB 3 BRBBR 1 BRRBR 1 RRRBR 2 BRRBR 5 BBRBR 4 BBRBB 3 BBRRB 2 BBBRB 5 BRBRB 3 BRBRR 1 BRRRR 1 RRRRR 2 BRRRR 5 BBRRR 4 BBRRB 2 BRBBB 4 BRBBR Output 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 -1 -1 Note The graph in the first example is depticed in the figure below. The first $$$19$$$ queries denote the journey of the token. On the $$$19$$$-th move the token would reach the vertex $$$6$$$. The last two queries show states that are unreachable. | 3,400 | true | false | false | true | false | false | false | false | false | true | 4,364 |
1218C | You, the mighty Blackout, are standing in the upper-left $$$(0,0)$$$ corner of $$$N$$$x$$$M$$$ matrix. You must move either right or down each second. There are $$$K$$$ transformers jumping around the matrix in the following way. Each transformer starts jumping from position $$$(x,y)$$$, at time $$$t$$$, and jumps to the next position each second. The $$$x$$$-axes grows downwards, and $$$y$$$-axes grows to the right. The order of jumping positions is defined as $$${(x,y),(x+d,y-d),(x+d,y),(x,y+d)}$$$, and is periodic. Before time $$$t$$$ transformer is not in the matrix. You want to arrive to the bottom-right corner $$$(N-1,M-1)$$$, while slaying transformers and losing the least possible amount of energy. When you meet the transformer (or more of them) in the matrix field, you must kill them all, and you lose the sum of the energy amounts required to kill each transformer. After the transformer is killed, he of course stops jumping, falls into the abyss and leaves the matrix world. Output minimum possible amount of energy wasted. Input In the first line, integers $$$N$$$,$$$M$$$ ($$$1 leq N, M leq 500$$$), representing size of the matrix, and $$$K$$$ ($$$0 leq K leq 5*10^5$$$) , the number of jumping transformers. In next $$$K$$$ lines, for each transformer, numbers $$$x$$$, $$$y$$$, $$$d$$$ ($$$d geq 1$$$), $$$t$$$ ($$$0 leq t leq N+M-2$$$), and $$$e$$$ ($$$0 leq e leq 10^9$$$), representing starting coordinates of transformer, jumping positions distance in pattern described above, time when transformer starts jumping, and energy required to kill it. It is guaranteed that all 4 of jumping points of the transformers are within matrix coordinates Output Print single integer, the minimum possible amount of energy wasted, for Blackout to arrive at bottom-right corner. Example Input 3 3 5 0 1 1 0 7 1 1 1 0 10 1 1 1 1 2 1 1 1 2 2 0 1 1 2 3 Note If Blackout takes the path from (0, 0) to (2, 0), and then from (2, 0) to (2, 2) he will need to kill the first and third transformer for a total energy cost of 9. There exists no path with less energy value. | 2,600 | false | false | false | true | false | false | false | false | false | false | 4,582 |
2041J | Image generated by ChatGPT 4o. Mayaw works in a renowned Epah (aboriginal Taiwanese millet wine; Epah is the Pangcah term for aboriginal Taiwanese millet wine, named in the language of the Pangcah people, the largest Indigenous group in Taiwan) bar in the Fata'an Village. To showcase the depth of its collections, the bar has a two-row wine rack where each row can fit exactly $$$n$$$ bottles. There are already $$$n$$$ bottles placed on the back row of the rack, where the $$$i$$$-th bottle from left has height $$$a_i$$$. The owner of the bar has another $$$n$$$ bottles with distinct heights $$$b_1, ldots, b_n$$$ that he would like Mayaw to put on the first row. To ensure that all bottles on the rack are visible, the owner requires that each bottle on the back row should not be blocked by the one put in front of it. That is, if a bottle of height $$$h$$$ is put on the $$$i$$$-th spot (from left) in the first row, then $$$h$$$ must be less than $$$a_i$$$. However, not all such arrangements are good for the owner. To pay tributes to the Maxi Mountain nearby, he additionally demands that the bottles in the front row should display a mountain-like shape. In particular, the heights of the bottles, when listing from left to right, should form a sequence that is first (non-strictly) increasing and then (non-strictly) decreasing. Unfortunately, sometimes it is impossible to achieve owner's requirements. That is why Mayaw is also allowed to slightly reduce a bottle's height by removing its cap that has a height of $$$1$$$. In other words, after the removal of the cap, the height of the bottle decreases by exactly $$$1$$$. Of course, exposing the Epah inside the bottle to the open air is detrimental to its quality, and therefore it is desirable to remove as few bottle caps as possible. Can you help Mayaw determine the minimum number of caps needed to be removed so that he can arrange the bottles in a way that satisfies the owner's requirements? Note that the positions of the bottles in the back row are fixed and Mayaw is not allowed to modify them. Input The first line contains an integer $$$n$$$ which represents the number of bottles in each row. The second line contains $$$n$$$ integers $$$a_1, ldots, a_n$$$, the height of the bottles in the back row. The third line contains $$$n$$$ distinct integers $$$b_1, ldots, b_n$$$, the height of the bottles in the front row. $$$1 leq n leq 5 imes 10^5$$$ $$$1 leq a_i, b_i leq 10^9$$$ All $$$b_i$$$'s are distinct. Output Output the minimum number of bottle caps needed to be removed so that Mayaw can arrange the bottles in the desired way. If it is impossible to achieve that (regardless of the number of caps removed), output -1 instead. | 2,700 | false | true | false | true | true | false | false | false | false | false | 4 |
213E | Rubik is very keen on number permutations. A permutation _a_ with length _n_ is a sequence, consisting of _n_ different numbers from 1 to _n_. Element number _i_ (1u2009β€u2009_i_u2009β€u2009_n_) of this permutation will be denoted as _a__i_. Furik decided to make a present to Rubik and came up with a new problem on permutations. Furik tells Rubik two number permutations: permutation _a_ with length _n_ and permutation _b_ with length _m_. Rubik must give an answer to the problem: how many distinct integers _d_ exist, such that sequence _c_ (_c_1u2009=u2009_a_1u2009+u2009_d_,u2009_c_2u2009=u2009_a_2u2009+u2009_d_,u2009...,u2009_c__n_u2009=u2009_a__n_u2009+u2009_d_) of length _n_ is a subsequence of _b_. Sequence _a_ is a subsequence of sequence _b_, if there are such indices _i_1,u2009_i_2,u2009...,u2009_i__n_ (1u2009β€u2009_i_1u2009<u2009_i_2u2009<u2009...u2009<u2009_i__n_u2009β€u2009_m_), that _a_1u2009=u2009_b__i_1, _a_2u2009=u2009_b__i_2, ..., _a__n_u2009=u2009_b__i__n_, where _n_ is the length of sequence _a_, and _m_ is the length of sequence _b_. You are given permutations _a_ and _b_, help Rubik solve the given problem. Input The first line contains two integers _n_ and _m_ (1u2009β€u2009_n_u2009β€u2009_m_u2009β€u2009200000) β the sizes of the given permutations. The second line contains _n_ distinct integers β permutation _a_, the third line contains _m_ distinct integers β permutation _b_. Numbers on the lines are separated by spaces. | 2,700 | false | false | false | false | true | false | false | false | false | false | 8,984 |
131A | Problem - 131A - 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 *1000 No tag edit access β Contest materials ") ") ") ") | 1,000 | false | false | true | false | false | false | false | false | false | false | 9,353 |
1675G | Nastya baked $$$m$$$ pancakes and spread them on $$$n$$$ dishes. The dishes are in a row and numbered from left to right. She put $$$a_i$$$ pancakes on the dish with the index $$$i$$$. Seeing the dishes, Vlad decided to bring order to the stacks and move some pancakes. In one move, he can shift one pancake from any dish to the closest one, that is, select the dish $$$i$$$ ($$$a_i > 0$$$) and do one of the following: if $$$i > 1$$$, put the pancake on a dish with the previous index, after this move $$$a_i = a_i - 1$$$ and $$$a_{i - 1} = a_{i - 1} + 1$$$; if $$$i < n$$$, put the pancake on a dish with the following index, after this move $$$a_i = a_i - 1$$$ and $$$a_{i + 1} = a_{i + 1} + 1$$$. Vlad wants to make the array $$$a$$$non-increasing, after moving as few pancakes as possible. Help him find the minimum number of moves needed for this. The array $$$a=[a_1, a_2,dots,a_n]$$$ is called non-increasing if $$$a_i ge a_{i+1}$$$ for all $$$i$$$ from $$$1$$$ to $$$n-1$$$. Input The first line of the input contains two numbers $$$n$$$ and $$$m$$$ ($$$1 le n, m le 250$$$) β the number of dishes and the number of pancakes, respectively. The second line contains $$$n$$$ numbers $$$a_i$$$ ($$$0 le a_i le m$$$), the sum of all $$$a_i$$$ is equal to $$$m$$$. Output Print a single number: the minimum number of moves required to make the array $$$a$$$ non-increasing. Examples Input 10 1 0 0 0 0 0 0 0 0 0 1 Note In the first example, you first need to move the pancake from the dish $$$1$$$, after which $$$a = [4, 4, 2, 3, 3, 3]$$$. After that, you need to move the pancake from the dish $$$2$$$ to the dish $$$3$$$ and the array will become non-growing $$$a = [4, 3, 3, 3, 3, 3]$$$. | 2,300 | false | false | false | true | false | false | false | false | false | false | 2,216 |
1899C | A subarray is a continuous part of array. Yarik recently found an array $$$a$$$ of $$$n$$$ elements and became very interested in finding the maximum sum of a non empty subarray. However, Yarik doesn't like consecutive integers with the same parity, so the subarray he chooses must have alternating parities for adjacent elements. For example, $$$[1, 2, 3]$$$ is acceptable, but $$$[1, 2, 4]$$$ is not, as $$$2$$$ and $$$4$$$ are both even and adjacent. You need to help Yarik by finding the maximum sum of such a subarray. Input The first line contains an integer $$$t$$$ $$$(1 le t le 10^4)$$$xa0β number of test cases. Each test case is described as follows. The first line of each test case contains an integer $$$n$$$ $$$(1 le n le 2 cdot 10^5)$$$xa0β length of the array. The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, dots, a_n$$$ $$$(-10^3 le a_i le 10^3)$$$xa0β elements of the array. It is guaranteed that the sum of $$$n$$$ for all test cases does not exceed $$$2 cdot 10^5$$$. Output For each test case, output a single integerxa0β the answer to the problem. Example Input 7 5 1 2 3 4 5 4 9 9 8 8 6 -1 4 -1 0 5 -4 4 -1 2 4 -3 1 -1000 3 101 -99 101 20 -10 5 -8 10 6 -10 7 9 -2 -6 7 2 -4 6 -1 7 -6 -7 4 1 Output 15 17 8 4 -1000 101 10 | 1,100 | false | true | false | true | false | false | false | false | false | false | 920 |
1548C | Three little pigs from all over the world are meeting for a convention! Every minute, a triple of 3 new pigs arrives on the convention floor. After the $$$n$$$-th minute, the convention ends. The big bad wolf has learned about this convention, and he has an attack plan. At some minute in the convention, he will arrive and eat exactly $$$x$$$ pigs. Then he will get away. The wolf wants Gregor to help him figure out the number of possible attack plans that involve eating exactly $$$x$$$ pigs for various values of $$$x$$$ ($$$1 le x le 3n$$$). Two attack plans are considered different, if they occur at different times or if the sets of little pigs to eat are different. Note that all queries are independent, that is, the wolf does not eat the little pigs, he only makes plans! Input The first line of input contains two integers $$$n$$$ and $$$q$$$ ($$$1 le n le 10^6$$$, $$$1 le q le 2cdot 10^5$$$), the number of minutes the convention lasts and the number of queries the wolf asks. Each of the next $$$q$$$ lines contains a single integer $$$x_i$$$ ($$$1 le x_i le 3n$$$), the number of pigs the wolf will eat in the $$$i$$$-th query. Output You should print $$$q$$$ lines, with line $$$i$$$ representing the number of attack plans if the wolf wants to eat $$$x_i$$$ pigs. Since each query answer can be large, output each answer modulo $$$10^9+7$$$. Note In the example test, $$$n=2$$$. Thus, there are $$$3$$$ pigs at minute $$$1$$$, and $$$6$$$ pigs at minute $$$2$$$. There are three queries: $$$x=1$$$, $$$x=5$$$, and $$$x=6$$$. If the wolf wants to eat $$$1$$$ pig, he can do so in $$$3+6=9$$$ possible attack plans, depending on whether he arrives at minute $$$1$$$ or $$$2$$$. If the wolf wants to eat $$$5$$$ pigs, the wolf cannot arrive at minute $$$1$$$, since there aren't enough pigs at that time. Therefore, the wolf has to arrive at minute $$$2$$$, and there are $$$6$$$ possible attack plans. If the wolf wants to eat $$$6$$$ pigs, his only plan is to arrive at the end of the convention and devour everybody. Remember to output your answers modulo $$$10^9+7$$$! | 2,500 | true | false | false | true | false | false | false | false | false | false | 2,904 |
1607G | A known chef has prepared $$$n$$$ dishes: the $$$i$$$-th dish consists of $$$a_i$$$ grams of fish and $$$b_i$$$ grams of meat. The banquet organizers estimate the balance of $$$n$$$ dishes as follows. The balance is equal to the absolute value of the difference between the total mass of fish and the total mass of meat. Technically, the balance equals to $$$leftsumlimits_{i=1}^n a_i - sumlimits_{i=1}^n b_i ight$$$. The smaller the balance, the better. In order to improve the balance, a taster was invited. He will eat exactly $$$m$$$ grams of food from each dish. For each dish, the taster determines separately how much fish and how much meat he will eat. The only condition is that he should eat exactly $$$m$$$ grams of each dish in total. Determine how much of what type of food the taster should eat from each dish so that the value of the balance is as minimal as possible. If there are several correct answers, you may choose any of them. Input The first line of input data contains an integer $$$t$$$ ($$$1 leq t leq 10^4$$$)xa0β the number of the test cases. Each test case's description is preceded by a blank line. Next comes a line that contains integers $$$n$$$ and $$$m$$$ ($$$1 leq n leq 2 cdot 10^5$$$; $$$0 leq m leq 10^6$$$). The next $$$n$$$ lines describe dishes, the $$$i$$$-th of them contains a pair of integers $$$a_i$$$ and $$$b_i$$$ ($$$0 leq a_i, b_i le 10^6$$$)xa0β the masses of fish and meat in the $$$i$$$-th dish. It is guaranteed that it is possible to eat $$$m$$$ grams of food from each dish. In other words, $$$m leq a_i+b_i$$$ for all $$$i$$$ from $$$1$$$ to $$$n$$$ inclusive. The sum of all $$$n$$$ values over all test cases in the test does not exceed $$$2 cdot 10^5$$$. Output For each test case, print on the first line the minimal balance value that can be achieved by eating exactly $$$m$$$ grams of food from each dish. Then print $$$n$$$ lines that describe a way to do this: the $$$i$$$-th line should contain two integers $$$x_i$$$ and $$$y_i$$$ ($$$0 leq x_i leq a_i$$$; $$$0 leq y_i leq b_i$$$; $$$x_i+y_i=m$$$), where $$$x_i$$$ is how many grams of fish taster should eat from the $$$i$$$-th meal and $$$y_i$$$ is how many grams of meat. If there are several ways to achieve a minimal balance, find any of them. Example Input 8 1 5 3 4 1 6 3 4 2 2 1 3 4 2 2 4 1 3 1 7 3 6 1 7 1 8 1 9 3 6 1 8 1 9 30 10 3 4 3 1 3 2 4 1 5 4 0 7 6 4 0 8 4 1 5 3 Output 0 2 3 1 3 3 0 1 1 1 1 2 1 3 0 4 3 0 6 0 6 0 6 7 1 5 1 5 6 0 0 3 1 3 1 3 1 0 0 4 2 2 0 4 3 1 1 3 | 2,200 | false | true | false | false | false | false | false | false | false | false | 2,617 |
1710B | You are the owner of a harvesting field which can be modeled as an infinite line, whose positions are identified by integers. It will rain for the next $$$n$$$ days. On the $$$i$$$-th day, the rain will be centered at position $$$x_i$$$ and it will have intensity $$$p_i$$$. Due to these rains, some rainfall will accumulate; let $$$a_j$$$ be the amount of rainfall accumulated at integer position $$$j$$$. Initially $$$a_j$$$ is $$$0$$$, and it will increase by $$$max(0,p_i-x_i-j)$$$ after the $$$i$$$-th day's rain. A flood will hit your field if, at any moment, there is a position $$$j$$$ with accumulated rainfall $$$a_j>m$$$. You can use a magical spell to erase exactly one day's rain, i.e., setting $$$p_i=0$$$. For each $$$i$$$ from $$$1$$$ to $$$n$$$, check whether in case of erasing the $$$i$$$-th day's rain there is no flood. Input Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 leq t leq 10^4$$$). The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$1 leq n leq 2 cdot 10^5$$$, $$$1 leq m leq 10^9$$$) β the number of rainy days and the maximal accumulated rainfall with no flood occurring. Then $$$n$$$ lines follow. The $$$i$$$-th of these lines contains two integers $$$x_i$$$ and $$$p_i$$$ ($$$1 leq x_i,p_i leq 10^9$$$) β the position and intensity of the $$$i$$$-th day's rain. The sum of $$$n$$$ over all test cases does not exceed $$$2 cdot 10^5$$$. Output For each test case, output a binary string $$$s$$$ length of $$$n$$$. The $$$i$$$-th character of $$$s$$$ is 1 if after erasing the $$$i$$$-th day's rain there is no flood, while it is 0, if after erasing the $$$i$$$-th day's rain the flood still happens. Example Input 4 3 6 1 5 5 5 3 4 2 3 1 3 5 2 2 5 1 6 10 6 6 12 4 5 1 6 12 5 5 5 9 7 8 3 Note In the first test case, if we do not use the spell, the accumulated rainfall distribution will be like this: If we erase the third day's rain, the flood is avoided and the accumulated rainfall distribution looks like this: In the second test case, since initially the flood will not happen, we can erase any day's rain. In the third test case, there is no way to avoid the flood. | 2,100 | true | true | true | false | true | false | true | true | false | false | 2,019 |
1767C | You are given an integer $$$n$$$. You have to calculate the number of binary (consisting of characters 0 and/or 1) strings $$$s$$$ meeting the following constraints. For every pair of integers $$$(i, j)$$$ such that $$$1 le i le j le n$$$, an integer $$$a_{i,j}$$$ is given. It imposes the following constraint on the string $$$s_i s_{i+1} s_{i+2} dots s_j$$$: if $$$a_{i,j} = 1$$$, all characters in $$$s_i s_{i+1} s_{i+2} dots s_j$$$ should be the same; if $$$a_{i,j} = 2$$$, there should be at least two different characters in $$$s_i s_{i+1} s_{i+2} dots s_j$$$; if $$$a_{i,j} = 0$$$, there are no additional constraints on the string $$$s_i s_{i+1} s_{i+2} dots s_j$$$. Count the number of binary strings $$$s$$$ of length $$$n$$$ meeting the aforementioned constraints. Since the answer can be large, print it modulo $$$998244353$$$. Input The first line contains one integer $$$n$$$ ($$$2 le n le 100$$$). Then $$$n$$$ lines follow. The $$$i$$$-th of them contains $$$n-i+1$$$ integers $$$a_{i,i}, a_{i,i+1}, a_{i,i+2}, dots, a_{i,n}$$$ ($$$0 le a_{i,j} le 2$$$). Output Print one integer β the number of strings meeting the constraints, taken modulo $$$998244353$$$. Note In the first example, the strings meeting the constraints are 001, 010, 011, 100, 101, 110. In the second example, the strings meeting the constraints are 001, 110. | 2,100 | false | false | false | true | true | false | false | false | false | false | 1,695 |
843D | You are given a weighted directed graph, consisting of _n_ vertices and _m_ edges. You should answer _q_ queries of two types: 1 vxa0β find the length of shortest path from vertex 1 to vertex _v_. 2 c _l_1 _l_2 ... _l__c_xa0β add 1 to weights of edges with indices _l_1,u2009_l_2,u2009...,u2009_l__c_. Input The first line of input data contains integers _n_, _m_, _q_ (1u2009β€u2009_n_,u2009_m_u2009β€u2009105, 1u2009β€u2009_q_u2009β€u20092000)xa0β the number of vertices and edges in the graph, and the number of requests correspondingly. Next _m_ lines of input data contain the descriptions of edges: _i_-th of them contains description of edge with index _i_xa0β three integers _a__i_, _b__i_, _c__i_ (1u2009β€u2009_a__i_,u2009_b__i_u2009β€u2009_n_, 0u2009β€u2009_c__i_u2009β€u2009109)xa0β the beginning and the end of edge, and its initial weight correspondingly. Next _q_ lines of input data contain the description of edges in the format described above (1u2009β€u2009_v_u2009β€u2009_n_, 1u2009β€u2009_l__j_u2009β€u2009_m_). It's guaranteed that inside single query all _l__j_ are distinct. Also, it's guaranteed that a total number of edges in all requests of the second type does not exceed 106. Output For each query of first type print the length of the shortest path from 1 to _v_ in a separate line. Print -1, if such path does not exists. Examples Input 3 2 9 1 2 0 2 3 0 2 1 2 1 3 1 2 2 1 1 1 3 1 2 2 2 1 2 1 3 1 2 Input 5 4 9 2 3 1 2 4 1 3 4 1 1 2 0 1 5 1 4 2 1 2 2 1 2 1 4 2 2 1 3 1 4 2 1 4 1 4 Note The description of changes of the graph in the first sample case: The description of changes of the graph in the second sample case: | 3,400 | false | false | false | false | false | false | false | false | false | true | 6,388 |
1710C | You are given a positive integer $$$n$$$. Since $$$n$$$ may be very large, you are given its binary representation. You should compute the number of triples $$$(a,b,c)$$$ with $$$0 leq a,b,c leq n$$$ such that $$$a oplus b$$$, $$$b oplus c$$$, and $$$a oplus c$$$ are the sides of a non-degenerate triangle. Here, $$$oplus$$$ denotes the without leading zeros. For example, the string 10 is the binary representation of the number $$$2$$$, while the string 1010 represents the number $$$10$$$. Output Print one integer β the number of triples $$$(a,b,c)$$$ satisfying the conditions described in the statement modulo $$$998,244,353$$$. Note In the first test case, $$$101_2=5$$$. The triple $$$(a, b, c) = (0, 3, 5)$$$ is valid because $$$(aoplus b, boplus c, coplus a) = (3, 6, 5)$$$ are the sides of a non-degenerate triangle. The triple $$$(a, b, c) = (1, 2, 4)$$$ is valid because $$$(aoplus b, boplus c, coplus a) = (3, 6, 5)$$$ are the sides of a non-degenerate triangle. The $$$6$$$ permutations of each of these two triples are all the valid triples, thus the answer is $$$12$$$. In the third test case, $$$11,011,111,101,010,010_2=114,514$$$. The full answer (before taking the modulo) is $$$1,466,408,118,808,164$$$. | 2,500 | true | true | false | true | false | true | true | false | false | false | 2,018 |
1028A | Problem - 1028A - 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 β the number of rows and the number of columns in the table. The $$$i$$$-th of the next $$$n$$$ lines contains a string of $$$m$$$ characters $$$s_{i1} s_{i2} ldots s_{im}$$$ ($$$s_{ij}$$$ is 'W' for white cells and 'B' for black cells), describing the $$$i$$$-th row of the table. Output Output two integers $$$r$$$ and $$$c$$$ ($$$1 le r le n$$$, $$$1 le c le m$$$) separated by a space β the row and column numbers of the center of the black square. Examples Input 5 6 WWBBBW WWBBBW WWBBBW WWWWWW WWWWWW Output 2 4 Input 3 3 WWW BWW WWW Output 2 1 | 800 | false | false | true | false | false | false | false | false | false | false | 5,569 |
59E | In Ancient Berland there were _n_ cities and _m_ two-way roads of equal length. The cities are numbered with integers from 1 to _n_ inclusively. According to an ancient superstition, if a traveller visits three cities _a__i_, _b__i_, _c__i_ in row, without visiting other cities between them, a great disaster awaits him. Overall there are _k_ such city triplets. Each triplet is ordered, which means that, for example, you are allowed to visit the cities in the following order: _a__i_, _c__i_, _b__i_. Vasya wants to get from the city 1 to the city _n_ and not fulfil the superstition. Find out which minimal number of roads he should take. Also you are required to find one of his possible path routes. Input The first line contains three integers _n_, _m_, _k_ (2u2009β€u2009_n_u2009β€u20093000,u20091u2009β€u2009_m_u2009β€u200920000,u20090u2009β€u2009_k_u2009β€u2009105) which are the number of cities, the number of roads and the number of the forbidden triplets correspondingly. Then follow _m_ lines each containing two integers _x__i_, _y__i_ (1u2009β€u2009_x__i_,u2009_y__i_u2009β€u2009_n_) which are the road descriptions. The road is described by the numbers of the cities it joins. No road joins a city with itself, there cannot be more than one road between a pair of cities. Then follow _k_ lines each containing three integers _a__i_, _b__i_, _c__i_ (1u2009β€u2009_a__i_,u2009_b__i_,u2009_c__i_u2009β€u2009_n_) which are the forbidden triplets. Each ordered triplet is listed mo more than one time. All three cities in each triplet are distinct. City _n_ can be unreachable from city 1 by roads. Output If there are no path from 1 to _n_ print -1. Otherwise on the first line print the number of roads _d_ along the shortest path from the city 1 to the city _n_. On the second line print _d_u2009+u20091 numbers β any of the possible shortest paths for Vasya. The path should start in the city 1 and end in the city _n_. Examples Input 4 4 1 1 2 2 3 3 4 1 3 1 4 3 Input 4 4 2 1 2 2 3 3 4 1 3 1 2 3 1 3 4 | 2,000 | false | false | false | false | false | false | false | false | false | true | 9,676 |
900B | Problem - 900B - 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 math number theory *1300 No tag edit access β Contest materials . Announcement.") . Editorial.") . Output Print position of the first occurrence of digit _c_ into the fraction. Positions are numbered from 1 after decimal point. It there is no such position, print -1. Examples Input 1 2 0 Output 2 Input 2 3 7 Output -1 Note The fraction in the first example has the following decimal notation: . The first zero stands on second position. The fraction in the second example has the following decimal notation: . There is no digit 7 in decimal notation of the fraction. | 1,300 | true | false | false | false | false | false | false | false | false | false | 6,145 |
1548D1 | This is the easy version of the problem. The only difference from the hard version is that in this version all coordinates are even. There are $$$n$$$ fence-posts at distinct coordinates on a plane. It is guaranteed that no three fence posts lie on the same line. There are an infinite number of cows on the plane, one at every point with integer coordinates. Gregor is a member of the Illuminati, and wants to build a triangular fence, connecting $$$3$$$ distinct existing fence posts. A cow strictly inside the fence is said to be enclosed. If there are an odd number of enclosed cows and the area of the fence is an integer, the fence is said to be interesting. Find the number of interesting fences. Input The first line contains the integer $$$n$$$ ($$$3 le n le 6000$$$), the number of fence posts which Gregor can choose to form the vertices of a fence. Each of the next $$$n$$$ line contains two integers $$$x$$$ and $$$y$$$ ($$$0 le x,y le 10^7$$$, $$$x$$$ and $$$y$$$ are even), where $$$(x,y)$$$ is the coordinate of a fence post. All fence posts lie at distinct coordinates. No three fence posts are on the same line. Output Print a single integer, the number of interesting fences. Two fences are considered different if they are constructed with a different set of three fence posts. Examples Input 5 0 0 2 16 30 14 4 6 2 10 Note In the first example, there is only $$$1$$$ fence. That fence is interesting since its area is $$$4$$$ and there is $$$1$$$ enclosed cow, marked in red. In the second example, there are $$$3$$$ interesting fences. $$$(0,0)$$$ β $$$(30,14)$$$ β $$$(2,10)$$$ $$$(2,16)$$$ β $$$(30,14)$$$ β $$$(2,10)$$$ $$$(30,14)$$$ β $$$(4,6)$$$ β $$$(2,10)$$$ | 2,300 | true | false | false | false | false | false | false | false | false | false | 2,903 |
1918A | A brick is a strip of size $$$1 imes k$$$, placed horizontally or vertically, where $$$k$$$ can be an arbitrary number that is at least $$$2$$$ ($$$k ge 2$$$). A brick wall of size $$$n imes m$$$ is such a way to place several bricks inside a rectangle $$$n imes m$$$, that all bricks lie either horizontally or vertically in the cells, do not cross the border of the rectangle, and that each cell of the $$$n imes m$$$ rectangle belongs to exactly one brick. Here $$$n$$$ is the height of the rectangle $$$n imes m$$$ and $$$m$$$ is the width. Note that there can be bricks with different values of k in the same brick wall. The wall stability is the difference between the number of horizontal bricks and the number of vertical bricks. Note that if you used $$$0$$$ horizontal bricks and $$$2$$$ vertical ones, then the stability will be $$$-2$$$, not $$$2$$$. What is the maximal possible stability of a wall of size $$$n imes m$$$? It is guaranteed that under restrictions in the statement at least one $$$n imes m$$$ wall exists. Input The first line of the input contains one integer $$$t$$$ ($$$1 le t le 10,000$$$), the number of test cases. The only line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 le n,,m le 10^4$$$). Output For each test case, print one integer, the maximum stability of a wall of size $$$n imes m$$$. Example Input 5 2 2 7 8 16 9 3 5 10000 10000 Note In the 1st test case, the maximum stability of $$$2$$$ is obtained by placing two horizontal bricks $$$1 imes 2$$$ one on top of the other. In the 2nd test case, one can get the maximum stability of $$$28$$$ by placing $$$4$$$ horizontal bricks $$$1 imes 2$$$ in each of the $$$7$$$ rows. | 800 | true | true | true | false | false | true | false | false | false | false | 788 |
492E | Vanya decided to walk in the field of size _n_u2009Γu2009_n_ cells. The field contains _m_ apple trees, the _i_-th apple tree is at the cell with coordinates (_x__i_,u2009_y__i_). Vanya moves towards vector (_dx_,u2009_dy_). That means that if Vanya is now at the cell (_x_,u2009_y_), then in a second he will be at cell . The following condition is satisfied for the vector: , where is the largest integer that divides both _a_ and _b_. Vanya ends his path when he reaches the square he has already visited. Vanya wonders, from what square of the field he should start his path to see as many apple trees as possible. Input The first line contains integers _n_,u2009_m_,u2009_dx_,u2009_dy_(1u2009β€u2009_n_u2009β€u2009106, 1u2009β€u2009_m_u2009β€u2009105, 1u2009β€u2009_dx_,u2009_dy_u2009β€u2009_n_) β the size of the field, the number of apple trees and the vector of Vanya's movement. Next _m_ lines contain integers _x__i_,u2009_y__i_ (0u2009β€u2009_x__i_,u2009_y__i_u2009β€u2009_n_u2009-u20091) β the coordinates of apples. One cell may contain multiple apple trees. Output Print two space-separated numbers β the coordinates of the cell from which you should start your path. If there are several answers you are allowed to print any of them. Examples Input 5 5 2 3 0 0 1 2 1 3 2 4 3 1 Note In the first sample Vanya's path will look like: (1,u20093)u2009-u2009(3,u20091)u2009-u2009(0,u20094)u2009-u2009(2,u20092)u2009-u2009(4,u20090)u2009-u2009(1,u20093) In the second sample: (0,u20090)u2009-u2009(1,u20091)u2009-u2009(0,u20090) | 2,000 | true | false | false | false | false | false | false | false | false | false | 7,864 |
2035E | Man, this Genshin boss is so hard. Good thing they have a top-up of $$$6$$$ coins for only $$$ $4.99$$$. I should be careful and spend no more than I need to, lest my mom catches me... You are fighting a monster with $$$z$$$ health using a weapon with $$$d$$$ damage. Initially, $$$d=0$$$. You can perform the following operations. Increase $$$d$$$xa0β the damage of your weapon by $$$1$$$, costing $$$x$$$ coins. Attack the monster, dealing $$$d$$$ damage and costing $$$y$$$ coins. You cannot perform the first operation for more than $$$k$$$ times in a row. Find the minimum number of coins needed to defeat the monster by dealing at least $$$z$$$ damage. Input The first line contains a single integer $$$t$$$ ($$$1le tle 100$$$)xa0β the number of test cases. The only line of each test case contains 4 integers $$$x$$$, $$$y$$$, $$$z$$$, and $$$k$$$ ($$$1leq x, y, z, kleq 10^8$$$)xa0β the first operation's cost, the second operation's cost, the monster's health, and the limitation on the first operation. Output For each test case, output the minimum number of coins needed to defeat the monster. Example Input 4 2 3 5 5 10 20 40 5 1 60 100 10 60 1 100 10 Note In the first test case, $$$x = 2$$$, $$$y = 3$$$, $$$z = 5$$$, and $$$k = 5$$$. Here's a strategy that achieves the lowest possible cost of $$$12$$$ coins: Increase damage by $$$1$$$, costing $$$2$$$ coins. Increase damage by $$$1$$$, costing $$$2$$$ coins. Increase damage by $$$1$$$, costing $$$2$$$ coins. Attack the monster, dealing $$$3$$$ damage, costing $$$3$$$ coins. Attack the monster, dealing $$$3$$$ damage, costing $$$3$$$ coins. You deal a total of $$$3 + 3 = 6$$$ damage, defeating the monster who has $$$5$$$ health. The total number of coins you use is $$$2 + 2 + 2 + 3 + 3 = 12$$$ coins. In the second test case, $$$x = 10$$$, $$$y = 20$$$, $$$z = 40$$$, and $$$k = 5$$$. Here's a strategy that achieves the lowest possible cost of $$$190$$$ coins: Increase damage by $$$5$$$, costing $$$5cdot x$$$ = $$$50$$$ coins. Attack the monster once, dealing $$$5$$$ damage, costing $$$20$$$ coins. Increase damage by $$$2$$$, costing $$$2cdot x$$$ = $$$20$$$ coins. Attack the monster $$$5$$$ times, dealing $$$5cdot 7 = 35$$$ damage, costing $$$5cdot y$$$ = $$$100$$$ coins. You deal a total of $$$5 + 35 = 40$$$ damage, defeating the monster who has exactly $$$40$$$ health. The total number of coins you use is $$$50 + 20 + 20 + 100 = 190$$$ coins. | 2,300 | true | true | true | false | false | true | true | true | false | false | 57 |
1732A | You are given an array $$$a$$$ consisting of $$$n$$$ integers $$$a_1, a_2, ldots, a_n$$$. Friends asked you to make the $$$, where $$$gcd(x, y)$$$ denotes the GCD of integers $$$x$$$ and $$$y$$$. The cost of such an operation is $$$n - i + 1$$$. You need to find the minimum total cost of operations we need to perform so that the GCD of the all array numbers becomes equal to $$$1$$$. Input Each test consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 leq t leq 5,000$$$) β the number of test cases. The description of test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 leq n leq 20$$$) β the length of the array. 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. Output For each test case, output a single integer β the minimum total cost of operations that will need to be performed so that the GCD of all numbers in the array becomes equal to $$$1$$$. We can show that it's always possible to do so. Note In the first test case, the GCD of the entire array is already equal to $$$1$$$, so there is no need to perform operations. In the second test case, select $$$i = 1$$$. After this operation, $$$a_1 = gcd(2, 1) = 1$$$. The cost of this operation is $$$1$$$. In the third test case, you can select $$$i = 1$$$, after that the array $$$a$$$ will be equal to $$$[1, 4]$$$. The GCD of this array is $$$1$$$, and the total cost is $$$2$$$. In the fourth test case, you can select $$$i = 2$$$, after that the array $$$a$$$ will be equal to $$$[3, 2, 9]$$$. The GCD of this array is $$$1$$$, and the total cost is $$$2$$$. In the sixth test case, you can select $$$i = 4$$$ and $$$i = 5$$$, after that the array $$$a$$$ will be equal to $$$[120, 60, 80, 4, 5]$$$. The GCD of this array is $$$1$$$, and the total cost is $$$3$$$. | 1,000 | true | false | true | false | false | true | true | false | false | false | 1,899 |
1322A | A bracketed sequence is called correct (regular) if by inserting "+" and "1" you can get a well-formed mathematical expression from it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not. The teacher gave Dmitry's class a very strange taskxa0β she asked every student to come up with a sequence of arbitrary length, consisting only of opening and closing brackets. After that all the students took turns naming the sequences they had invented. When Dima's turn came, he suddenly realized that all his classmates got the correct bracketed sequence, and whether he got the correct bracketed sequence, he did not know. Dima suspects now that he simply missed the word "correct" in the task statement, so now he wants to save the situation by modifying his sequence slightly. More precisely, he can the arbitrary number of times (possibly zero) perform the reorder operation. The reorder operation consists of choosing an arbitrary consecutive subsegment (substring) of the sequence and then reordering all the characters in it in an arbitrary way. Such operation takes l nanoseconds, where l is the length of the subsegment being reordered. It's easy to see that reorder operation doesn't change the number of opening and closing brackets. For example for "))((" he can choose the substring ")(" and do reorder ")()(" (this operation will take 2 nanoseconds). Since Dima will soon have to answer, he wants to make his sequence correct as fast as possible. Help him to do this, or determine that it's impossible. Input The first line contains a single integer n (1β€nβ€106)xa0β the length of Dima's sequence. The second line contains string of length n, consisting of characters "(" and ")" only. Note In the first example we can firstly reorder the segment from first to the fourth character, replacing it with "()()", the whole sequence will be "()()())(". And then reorder the segment from the seventh to eighth character, replacing it with "()". In the end the sequence will be "()()()()", while the total time spent is 4+2=6 nanoseconds. | 1,300 | false | true | false | false | false | false | false | false | false | false | 4,107 |
808F | Problem - 808F - Codeforces =============== xa0 ]( "52010") . Then _n_ lines follow, each of these lines contains three numbers that represent the corresponding card: _p__i_, _c__i_ and _l__i_ (1u2009β€u2009_p__i_u2009β€u20091000, 1u2009β€u2009_c__i_u2009β€u2009100000, 1u2009β€u2009_l__i_u2009β€u2009_n_). Output If Vova won't be able to build a deck with required power, print u2009-u20091. Otherwise print the minimum level Vova has to reach in order to build a deck. Examples Input 5 8 5 5 1 1 5 4 4 6 3 1 12 4 3 12 1 Output 4 Input 3 7 4 4 1 5 8 2 5 3 3 Output 2 | 2,400 | false | false | false | false | false | false | false | true | false | true | 6,530 |
717H | Welcome to the world of Pokermon, yellow little mouse-like creatures, who absolutely love playing poker! Yeah, rightβ¦ In the ensuing Pokermon League, there are _n_ registered Pokermon trainers, and _t_ existing trainer teams each of which belongs to one of two conferences. Since there is a lot of jealousy between trainers, there are _e_ pairs of trainers who hate each other. Their hate is mutual, there are no identical pairs among these, and no trainer hates himself (the world of Pokermon is a joyful place!). Each trainer has a wish-list of length _l__i_ of teams heβd like to join. Your task is to divide players into teams and the teams into two conferences, so that: each trainer belongs to exactly one team; no team is in both conferences; total hate between conferences is at least _e_u2009/u20092; every trainer is in a team from his wish-list. Total hate between conferences is calculated as the number of pairs of trainers from teams from different conferences who hate each other. Input The first line of the input contains two integer _n_ (4u2009β€u2009_n_u2009β€u200950u2009000) and _e_ (2u2009β€u2009_e_u2009β€u2009100u2009000)xa0β the total number of Pokermon trainers and the number of pairs of trainers who hate each other. Pokermon trainers are numbered from 1 to _n_. Next _e_ lines contain two integers _a_ and _b_ (1u2009β€u2009_a_,u2009_b_u2009β€u2009_n_) indicating that Pokermon trainers _a_ and _b_ hate each other. Next 2_n_ lines are in a following format. Starting with Pokermon trainer 1, for each trainer in consecutive order: first number _l__i_ (16u2009β€u2009_l__i_u2009β€u200920)xa0β a size of Pokermon trainers wish list, then _l__i_ positive integers _t__i_,u2009_j_ (1u2009β€u2009_t__i_,u2009_j_u2009β€u2009_T_), providing the teams the _i_-th trainer would like to be on. Each trainers wish list will contain each team no more than once. Teams on the wish lists are numbered in such a way that the set of all teams that appear on at least 1 wish list is set of consecutive positive integers {1,u20092,u20093,u2009β¦,u2009_T_}. Here _T_ might be up to 1u2009000u2009000. Output Print two lines. The first line should contain _n_ numbers, specifying for each trainer the team he is in. The second line should contain _T_ numbers, specifying the conference for each team (1 or 2). Example Input 4 3 1 2 2 3 4 1 16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 16 15 16 2 3 4 5 6 7 8 9 10 11 12 13 14 15 17 18 16 2 3 4 5 6 7 8 9 10 11 12 13 14 15 18 19 16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 16 19 Output 16 15 19 14 2 2 2 1 1 1 2 1 1 2 1 1 1 2 2 1 1 1 1 | 2,400 | true | false | false | false | false | false | false | false | false | false | 6,945 |
1583G | El Psy Kongroo. Omkar is watching Steins;Gate. In Steins;Gate, Okabe Rintarou needs to complete $$$n$$$ tasks ($$$1 leq n leq 2 cdot 10^5$$$). Unfortunately, he doesn't know when he needs to complete the tasks. Initially, the time is $$$0$$$. Time travel will now happen according to the following rules: For each $$$k = 1, 2, ldots, n$$$, Okabe will realize at time $$$b_k$$$ that he was supposed to complete the $$$k$$$-th task at time $$$a_k$$$ ($$$a_k < b_k$$$). When he realizes this, if $$$k$$$-th task was already completed at time $$$a_k$$$, Okabe keeps the usual flow of time. Otherwise, he time travels to time $$$a_k$$$ then immediately completes the task. If Okabe time travels to time $$$a_k$$$, all tasks completed after this time will become incomplete again. That is, for every $$$j$$$, if $$$a_j>a_k$$$, the $$$j$$$-th task will become incomplete, if it was complete (if it was incomplete, nothing will change). Okabe has bad memory, so he can time travel to time $$$a_k$$$ only immediately after getting to time $$$b_k$$$ and learning that he was supposed to complete the $$$k$$$-th task at time $$$a_k$$$. That is, even if Okabe already had to perform $$$k$$$-th task before, he wouldn't remember it before stumbling on the info about this task at time $$$b_k$$$ again. Please refer to the notes for an example of time travelling. There is a certain set $$$s$$$ of tasks such that the first moment that all of the tasks in $$$s$$$ are simultaneously completed (regardless of whether any other tasks are currently completed), a funny scene will take place. Omkar loves this scene and wants to know how many times Okabe will time travel before this scene takes place. Find this number modulo $$$10^9 + 7$$$. It can be proven that eventually all $$$n$$$ tasks will be completed and so the answer always exists. Input The first line contains an integer $$$n$$$ ($$$1 leq n leq 2 cdot 10^5$$$) xa0β the number of tasks that Okabe needs to complete. $$$n$$$ lines follow. The $$$k$$$-th of these lines contain two integers $$$a_k$$$ and $$$b_k$$$ ($$$1 leq a_k < b_k leq 2n$$$) xa0β the time at which Okabe needs to complete the $$$k$$$-th task and the time that he realizes this respectively. All $$$2n$$$ of these times are distinct (so every time from $$$1$$$ to $$$2n$$$ inclusive appears exactly once in the input). The next line contains a single integer $$$t$$$ ($$$1 leq t leq n$$$) xa0β the size of the set $$$s$$$ of tasks that lead to the funny scene. The last line contains $$$t$$$ integers $$$s_1, s_2, ldots, s_t$$$ xa0β ($$$1 leq s_k leq n$$$, the numbers $$$s_1, s_2, ldots, s_t$$$ are distinct) xa0β the set $$$s$$$ of tasks. Output Output a single integer xa0β the number of times that Okabe time travels until all tasks in the set $$$s$$$ are simultaneously completed, modulo $$$10^9 + 7$$$. Examples Input 6 10 12 3 7 4 6 2 9 5 8 1 11 3 2 4 6 Input 16 31 32 3 26 17 19 4 24 1 28 15 21 12 16 18 29 20 23 7 8 11 14 9 22 6 30 5 10 25 27 2 13 6 3 8 2 5 12 11 Note For the first sample, all tasks need to be completed in order for the funny scene to occur. Initially, the time is $$$0$$$. Nothing happens until time $$$3$$$, when Okabe realizes that he should have done the $$$2$$$-nd task at time $$$2$$$. He then time travels to time $$$2$$$ and completes the task. As the task is done now, he does not time travel again when the time is again $$$3$$$. However, at time $$$4$$$, he travels to time $$$1$$$ to complete the $$$1$$$-st task. This undoes the $$$2$$$-nd task. This means that the $$$2$$$-nd task is not currently completed, meaning that the funny scene will not occur at this point even though the $$$1$$$-st task is currently completed and Okabe had previously completed the $$$2$$$-nd task. Once it is again time $$$3$$$ he travels back to time $$$2$$$ once more and does the $$$2$$$-nd task again. Now all tasks are complete, with Okabe having time travelled $$$3$$$ times. The second sample has the same tasks for Okabe to complete. However, this time the funny scene only needs the first task to be completed in order to occur. From reading the above sample you can see that this occurs once Okabe has time travelled $$$2$$$ times. | 3,000 | true | false | false | false | true | false | false | false | false | false | 2,711 |
1536B | I, Fischl, Prinzessin der Verurteilung, descend upon this land by the call of fate an β Oh, you are also a traveler from another world? Very well, I grant you permission to travel with me. It is no surprise Fischl speaks with a strange choice of words. However, this time, not even Oz, her raven friend, can interpret her expressions! Maybe you can help us understand what this young princess is saying? You are given a string of $$$n$$$ lowercase Latin letters, the word that Fischl just spoke. You think that the MEX of this string may help you find the meaning behind this message. The MEX of the string is defined as the shortest string that doesn't appear as a contiguous substring in the input. If multiple strings exist, the lexicographically smallest one is considered the MEX. Note that the empty substring does NOT count as a valid MEX. 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$$$. A string $$$a$$$ is a substring of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end. Find out what the MEX of the string is! Input Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 leq t leq 1000$$$). Description of the test cases follows. The first line of each test case contains an integer $$$n$$$ ($$$1 leq n leq 1000$$$)xa0β the length of the word. The second line for each test case contains a single string of $$$n$$$ lowercase Latin letters. The sum of $$$n$$$ over all test cases will not exceed $$$1000$$$. | 1,200 | false | false | false | false | false | true | true | false | false | false | 2,967 |
1879B | You are given a board of size $$$n imes n$$$ ($$$n$$$ rows and $$$n$$$ colums) and two arrays of positive integers $$$a$$$ and $$$b$$$ of size $$$n$$$. Your task is to place the chips on this board so that the following condition is satisfied for every cell $$$(i, j)$$$: there exists at least one chip in the same column or in the same row as the cell $$$(i, j)$$$. I.u2009e. there exists a cell $$$(x, y)$$$ such that there is a chip in that cell, and either $$$x = i$$$ or $$$y = j$$$ (or both). The cost of putting a chip in the cell $$$(i, j)$$$ is equal to $$$a_i + b_j$$$. For example, for $$$n=3$$$, $$$a=[1, 4, 1]$$$ and $$$b=[3, 2, 2]$$$. One of the possible chip placements is as follows: White squares are empty The total cost of that placement is $$$(1+3) + (1+2) + (1+2) = 10$$$. Calculate the minimum possible total cost of putting chips according to the rules above. 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$$$ ($$$1 le n le 3 cdot 10^5$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, dots, a_n$$$ ($$$1 le a_i le 10^9$$$). The third line contains $$$n$$$ integers $$$b_1, b_2, dots, b_n$$$ ($$$1 le b_i le 10^9$$$). The sum of $$$n$$$ over all test cases doesn't exceed $$$3 cdot 10^5$$$. Output For each test case, print a single integerxa0β the minimum possible total cost of putting chips according to the rules. Example Input 4 3 1 4 1 3 2 2 1 4 5 2 4 5 2 3 5 5 2 4 5 3 3 4 2 1 5 Note The first test case of the example is described in the statement. | 900 | false | true | false | false | false | true | false | false | false | false | 1,009 |
1644B | Problem - 1644B - 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 *800 No tag edit access β Contest materials . Recall that the permutation is the array of length $$$n$$$ which contains each integer from $$$1$$$ to $$$n$$$ exactly once. Your task is for a given number $$$n$$$ print $$$n$$$ distinct anti-Fibonacci permutations of length $$$n$$$. Input The first line contains a single integer $$$t$$$ ($$$1 le t le 48$$$)xa0β the number of test cases. The single line of each test case contains a single integer $$$n$$$ ($$$3 le n le 50$$$). Output For each test case, print $$$n$$$ lines. Each line should contain an anti-Fibonacci permutation of length $$$n$$$. In each test case, you cannot print any permutation more than once. If there are multiple answers, print any of them. It can be shown that it is always possible to find $$$n$$$ different anti-Fibonacci permutations of size $$$n$$$ under the constraints of the problem. Example Input 2 4 3 Output 4 1 3 2 1 2 4 3 3 4 1 2 2 4 1 3 3 2 1 1 3 2 3 1 2 | 800 | false | false | true | false | false | true | true | false | false | false | 2,400 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.