contestId int64 0 1.01k | name stringlengths 2 58 | tags listlengths 0 11 | title stringclasses 523
values | time-limit stringclasses 8
values | memory-limit stringclasses 8
values | problem-description stringlengths 0 7.15k | input-specification stringlengths 0 2.05k | output-specification stringlengths 0 1.5k | demo-input listlengths 0 7 | demo-output listlengths 0 7 | note stringlengths 0 5.24k | test_cases listlengths 0 402 | timeConsumedMillis int64 0 8k | memoryConsumedBytes int64 0 537M | score float64 -1 3.99 | __index_level_0__ int64 0 621k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
161 | Distance in Tree | [
"dfs and similar",
"dp",
"trees"
] | null | null | A tree is a connected graph that doesn't contain any cycles.
The distance between two vertices of a tree is the length (in edges) of the shortest path between these vertices.
You are given a tree with *n* vertices and a positive number *k*. Find the number of distinct pairs of the vertices which have a distance of ex... | The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=50000, 1<=≤<=*k*<=≤<=500) — the number of vertices and the required distance between the vertices.
Next *n*<=-<=1 lines describe the edges as "*a**i* *b**i*" (without the quotes) (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*, *a**i*<=≠<=*b**i*), where *a**i* and *b**i* ... | Print a single integer — the number of distinct pairs of the tree's vertices which have a distance of exactly *k* between them.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier. | [
"5 2\n1 2\n2 3\n3 4\n2 5\n",
"5 3\n1 2\n2 3\n3 4\n4 5\n"
] | [
"4\n",
"2\n"
] | In the first sample the pairs of vertexes at distance 2 from each other are (1, 3), (1, 5), (3, 5) and (2, 4). | [
{
"input": "5 2\n1 2\n2 3\n3 4\n2 5",
"output": "4"
},
{
"input": "5 3\n1 2\n2 3\n3 4\n4 5",
"output": "2"
},
{
"input": "10 1\n2 1\n3 1\n4 3\n5 4\n6 5\n7 1\n8 6\n9 2\n10 6",
"output": "9"
},
{
"input": "10 2\n2 1\n3 1\n4 3\n5 4\n6 5\n7 1\n8 6\n9 2\n10 6",
"output": "10"
... | 60 | 0 | 0 | 9,093 | |
38 | Let's Go Rolling! | [
"dp",
"sortings"
] | E. Let's Go Rolling! | 2 | 256 | On a number axis directed from the left rightwards, *n* marbles with coordinates *x*1,<=*x*2,<=...,<=*x**n* are situated. Let's assume that the sizes of the marbles are infinitely small, that is in this task each of them is assumed to be a material point. You can stick pins in some of them and the cost of sticking in t... | The first input line contains an integer *n* (1<=≤<=*n*<=≤<=3000) which is the number of marbles. The next *n* lines contain the descriptions of the marbles in pairs of integers *x**i*, *c**i* (<=-<=109<=≤<=*x**i*,<=*c**i*<=≤<=109). The numbers are space-separated. Each description is given on a separate line. No two m... | Output the single number — the least fine you will have to pay. | [
"3\n2 3\n3 4\n1 2\n",
"4\n1 7\n3 1\n5 10\n6 1\n"
] | [
"5\n",
"11\n"
] | none | [
{
"input": "3\n2 3\n3 4\n1 2",
"output": "5"
},
{
"input": "4\n1 7\n3 1\n5 10\n6 1",
"output": "11"
},
{
"input": "1\n-948943148 10",
"output": "10"
},
{
"input": "5\n864449017 54\n864449026 504\n864449027 308\n864449028 284\n864449030 249",
"output": "97"
},
{
"i... | 124 | 3,481,600 | -1 | 9,099 |
542 | Duck Hunt | [
"data structures"
] | null | null | A duck hunter is doing his favorite thing, hunting. He lives in a two dimensional world and is located at point (0,<=0). As he doesn't like walking for his prey, he prefers to shoot only vertically up (because in this case, the ducks fall straight into his hands). The hunter doesn't reload the gun immediately — *r* or ... | The first line of the input contains integers *n*, *r* (1<=≤<=*n*<=≤<=200<=000, 1<=≤<=*r*<=≤<=109) — the number of ducks and the minimum time in seconds between the shots.
Then *n* lines follow, each of them contains two integers *h**i*,<=*t**i* (<=-<=109<=≤<=*h**i*<=<<=*t**i*<=≤<=109) — the *x*-coordinate of the ... | Print a single integer — the maximum number of ducks that can be shot by the hunter. | [
"3 3\n-3 0\n1 3\n-1 2\n",
"4 5\n-1 1\n2 4\n5 9\n6 8\n"
] | [
"3\n",
"3\n"
] | In the first sample the hunter must shoot at time 0, this shot kills ducks 1 and 3. Then the hunter needs to reload the gun and shoot again at time 3. His second shot hits the tail of duck 2.
In the second sample the hunter can make shots at times 0 and 6 to hit three ducks. | [] | 46 | 0 | 0 | 9,109 | |
0 | none | [
"none"
] | null | null | There are *n* types of coins in Byteland. Conveniently, the denomination of the coin type *k* divides the denomination of the coin type *k*<=+<=1, the denomination of the coin type 1 equals 1 tugrick. The ratio of the denominations of coin types *k*<=+<=1 and *k* equals *a**k*. It is known that for each *x* there are a... | The first line contains single integer *n* (1<=≤<=*n*<=≤<=3·105) — the number of coin types.
The second line contains *n*<=-<=1 integers *a*1, *a*2, ..., *a**n*<=-<=1 (1<=≤<=*a**k*<=≤<=109) — the ratios between the coin types denominations. It is guaranteed that for each *x* there are at most 20 coin types of denomina... | Print single integer — the number of ways to pay exactly *m* tugricks modulo 109<=+<=7. | [
"1\n\n4\n2\n",
"2\n1\n4 4\n2\n",
"3\n3 3\n10 10 10\n17\n"
] | [
"1\n",
"3\n",
"6\n"
] | In the first example Byteasar has 4 coins of denomination 1, and he has to pay 2 tugricks. There is only one way.
In the second example Byteasar has 4 coins of each of two different types of denomination 1, he has to pay 2 tugricks. There are 3 ways: pay one coin of the first type and one coin of the other, pay two co... | [
{
"input": "1\n\n4\n2",
"output": "1"
},
{
"input": "2\n1\n4 4\n2",
"output": "3"
},
{
"input": "3\n3 3\n10 10 10\n17",
"output": "6"
},
{
"input": "2\n2\n200000 100000\n34567",
"output": "17284"
},
{
"input": "20\n2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n1 1 1 1 1 ... | 30 | 0 | 0 | 9,113 | |
51 | Cheaterius's Problem | [
"implementation"
] | A. Cheaterius's Problem | 2 | 256 | Cheaterius is a famous in all the Berland astrologist, magician and wizard, and he also is a liar and a cheater. One of his latest inventions is Cheaterius' amulets! They bring luck and wealth, but are rather expensive. Cheaterius makes them himself. The technology of their making is kept secret. But we know that throu... | The first line contains an integer *n* (1<=≤<=*n*<=≤<=1000), where *n* is the number of amulets. Then the amulet's descriptions are contained. Every description occupies two lines and contains two numbers (from 1 to 6) in each line. Between every pair of amulets the line "**" is located. | Print the required number of piles. | [
"4\n31\n23\n**\n31\n23\n**\n13\n32\n**\n32\n13\n",
"4\n51\n26\n**\n54\n35\n**\n25\n61\n**\n45\n53\n"
] | [
"1\n",
"2\n"
] | none | [
{
"input": "4\n31\n23\n**\n31\n23\n**\n13\n32\n**\n32\n13",
"output": "1"
},
{
"input": "4\n51\n26\n**\n54\n35\n**\n25\n61\n**\n45\n53",
"output": "2"
},
{
"input": "4\n56\n61\n**\n31\n31\n**\n33\n11\n**\n11\n33",
"output": "2"
},
{
"input": "4\n36\n44\n**\n32\n46\n**\n66\n41... | 342 | 20,275,200 | 3.876734 | 9,120 |
4 | Before an Exam | [
"constructive algorithms",
"greedy"
] | B. Before an Exam | 0 | 64 | Tomorrow Peter has a Biology exam. He does not like this subject much, but *d* days ago he learnt that he would have to take this exam. Peter's strict parents made him prepare for the exam immediately, for this purpose he has to study not less than *minTime**i* and not more than *maxTime**i* hours per each *i*-th day. ... | The first input line contains two integer numbers *d*,<=*sumTime* (1<=≤<=*d*<=≤<=30,<=0<=≤<=*sumTime*<=≤<=240) — the amount of days, during which Peter studied, and the total amount of hours, spent on preparation. Each of the following *d* lines contains two integer numbers *minTime**i*,<=*maxTime**i* (0<=≤<=*minTime**... | In the first line print YES, and in the second line print *d* numbers (separated by a space), each of the numbers — amount of hours, spent by Peter on preparation in the corresponding day, if he followed his parents' instructions; or print NO in the unique line. If there are many solutions, print any of them. | [
"1 48\n5 7\n",
"2 5\n0 1\n3 5\n"
] | [
"NO\n",
"YES\n1 4 "
] | none | [
{
"input": "1 48\n5 7",
"output": "NO"
},
{
"input": "2 5\n0 1\n3 5",
"output": "YES\n1 4 "
},
{
"input": "1 1\n5 6",
"output": "NO"
},
{
"input": "1 4\n2 4",
"output": "YES\n4 "
},
{
"input": "2 5\n4 6\n0 0",
"output": "YES\n5 0 "
},
{
"input": "27 97... | 31 | 0 | 3 | 9,123 |
219 | Choosing Capital for Treeland | [
"dfs and similar",
"dp",
"graphs",
"trees"
] | null | null | The country Treeland consists of *n* cities, some pairs of them are connected with unidirectional roads. Overall there are *n*<=-<=1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decid... | The first input line contains integer *n* (2<=≤<=*n*<=≤<=2·105) — the number of cities in Treeland. Next *n*<=-<=1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers *s**i*,<=*t**i* (1<=≤<=*s**i*,<=*t**i*<=≤<=*n*; *s**i*<=≠<=*t**i*) — the numbers of cities, connect... | In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order. | [
"3\n2 1\n2 3\n",
"4\n1 4\n2 4\n3 4\n"
] | [
"0\n2 \n",
"2\n1 2 3 \n"
] | none | [
{
"input": "3\n2 1\n2 3",
"output": "0\n2 "
},
{
"input": "4\n1 4\n2 4\n3 4",
"output": "2\n1 2 3 "
},
{
"input": "2\n1 2",
"output": "0\n1 "
},
{
"input": "8\n1 2\n3 2\n4 3\n4 5\n6 5\n6 7\n8 7",
"output": "3\n4 6 8 "
},
{
"input": "10\n2 3\n1 8\n9 5\n5 4\n6 10\n4... | 654 | 62,464,000 | -1 | 9,152 | |
449 | Jzzhu and Squares | [
"dp",
"math",
"number theory"
] | null | null | Jzzhu has two integers, *n* and *m*. He calls an integer point (*x*,<=*y*) of a plane special if 0<=≤<=*x*<=≤<=*n* and 0<=≤<=*y*<=≤<=*m*. Jzzhu defines a unit square as a square with corners at points (*x*,<=*y*), (*x*<=+<=1,<=*y*), (*x*<=+<=1,<=*y*<=+<=1), (*x*,<=*y*<=+<=1), where *x* and *y* are some integers.
Let's... | The first line contains a single integer *t* (1<=≤<=*t*<=≤<=105) — the number of tests.
Each of the next *t* lines contains the description of the test: two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=106) — the value of variables for the current test. | For each test output the total number of dots modulo 1000000007 (109<=+<=7). | [
"4\n1 3\n2 2\n2 5\n3 4\n"
] | [
"3\n8\n26\n58\n"
] | none | [] | 30 | 0 | 0 | 9,159 | |
822 | My pretty girl Noora | [
"brute force",
"dp",
"greedy",
"math",
"number theory"
] | null | null | In Pavlopolis University where Noora studies it was decided to hold beauty contest "Miss Pavlopolis University". Let's describe the process of choosing the most beautiful girl in the university in more detail.
The contest is held in several stages. Suppose that exactly *n* girls participate in the competition initiall... | The first and single line contains three integers *t*, *l* and *r* (1<=≤<=*t*<=<<=109<=+<=7,<=2<=≤<=*l*<=≤<=*r*<=≤<=5·106). | In the first line print single integer — the value of the expression modulo 109<=+<=7. | [
"2 2 4\n"
] | [
"19\n"
] | Consider the sample.
It is necessary to find the value of <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/3ecc798906ae9e9852061ba2dd5cf6b8fce7753b.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
*f*(2) = 1. From two girls you can form only one group of two people, in which there wil... | [
{
"input": "2 2 4",
"output": "19"
},
{
"input": "7 2444902 2613424",
"output": "619309304"
},
{
"input": "7 2055976 2242066",
"output": "231875164"
},
{
"input": "5 431999 611310",
"output": "160643716"
},
{
"input": "9 1621304 1742530",
"output": "797579313"... | 30 | 0 | 0 | 9,172 | |
754 | Fedor and coupons | [
"binary search",
"data structures",
"greedy",
"sortings"
] | null | null | All our characters have hobbies. The same is true for Fedor. He enjoys shopping in the neighboring supermarket.
The goods in the supermarket have unique integer ids. Also, for every integer there is a product with id equal to this integer. Fedor has *n* discount coupons, the *i*-th of them can be used with products w... | The first line contains two integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=3·105) — the number of coupons Fedor has, and the number of coupons he wants to choose.
Each of the next *n* lines contains two integers *l**i* and *r**i* (<=-<=109<=≤<=*l**i*<=≤<=*r**i*<=≤<=109) — the description of the *i*-th coupon. The coupons... | In the first line print single integer — the maximum number of products with which all the chosen coupons can be used. The products with which at least one coupon cannot be used shouldn't be counted.
In the second line print *k* distinct integers *p*1,<=*p*2,<=...,<=*p**k* (1<=≤<=*p**i*<=≤<=*n*) — the ids of the coupo... | [
"4 2\n1 100\n40 70\n120 130\n125 180\n",
"3 2\n1 12\n15 20\n25 30\n",
"5 2\n1 10\n5 15\n14 50\n30 70\n99 100\n"
] | [
"31\n1 2 \n",
"0\n1 2 \n",
"21\n3 4 \n"
] | In the first example if we take the first two coupons then all the products with ids in range [40, 70] can be bought with both coupons. There are 31 products in total.
In the second example, no product can be bought with two coupons, that is why the answer is 0. Fedor can choose any two coupons in this example. | [
{
"input": "4 2\n1 100\n40 70\n120 130\n125 180",
"output": "31\n1 2 "
},
{
"input": "3 2\n1 12\n15 20\n25 30",
"output": "0\n1 2 "
},
{
"input": "5 2\n1 10\n5 15\n14 50\n30 70\n99 100",
"output": "21\n3 4 "
},
{
"input": "7 6\n-8 6\n7 9\n-10 -5\n-6 10\n-7 -3\n5 8\n4 10",
... | 31 | 0 | -1 | 9,189 | |
652 | Nested Segments | [
"data structures",
"sortings"
] | null | null | You are given *n* segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains. | The first line contains a single integer *n* (1<=≤<=*n*<=≤<=2·105) — the number of segments on a line.
Each of the next *n* lines contains two integers *l**i* and *r**i* (<=-<=109<=≤<=*l**i*<=<<=*r**i*<=≤<=109) — the coordinates of the left and the right ends of the *i*-th segment. It is guaranteed that there are n... | Print *n* lines. The *j*-th of them should contain the only integer *a**j* — the number of segments contained in the *j*-th segment. | [
"4\n1 8\n2 3\n4 7\n5 6\n",
"3\n3 4\n1 5\n2 6\n"
] | [
"3\n0\n1\n0\n",
"0\n1\n1\n"
] | none | [
{
"input": "4\n1 8\n2 3\n4 7\n5 6",
"output": "3\n0\n1\n0"
},
{
"input": "3\n3 4\n1 5\n2 6",
"output": "0\n1\n1"
},
{
"input": "1\n-1000000000 1000000000",
"output": "0"
},
{
"input": "2\n-1000000000 999999999\n-999999999 1000000000",
"output": "0\n0"
},
{
"input"... | 1,762 | 50,688,000 | 3 | 9,214 | |
922 | Robot Vacuum Cleaner | [
"greedy",
"sortings"
] | null | null | Pushok the dog has been chasing Imp for a few hours already.
Fortunately, Imp knows that Pushok is afraid of a robot vacuum cleaner.
While moving, the robot generates a string *t* consisting of letters 's' and 'h', that produces a lot of noise. We define noise of string *t* as the number of occurrences of string "sh... | The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105) — the number of strings in robot's memory.
Next *n* lines contain the strings *t*1,<=*t*2,<=...,<=*t**n*, one per line. It is guaranteed that the strings are non-empty, contain only English letters 's' and 'h' and their total length does not exceed 105. | Print a single integer — the maxumum possible noise Imp can achieve by changing the order of the strings. | [
"4\nssh\nhs\ns\nhhhs\n",
"2\nh\ns\n"
] | [
"18\n",
"1\n"
] | The optimal concatenation in the first sample is *ssshhshhhs*. | [
{
"input": "4\nssh\nhs\ns\nhhhs",
"output": "18"
},
{
"input": "2\nh\ns",
"output": "1"
},
{
"input": "6\nh\ns\nhhh\nh\nssssss\ns",
"output": "40"
},
{
"input": "1\ns",
"output": "0"
},
{
"input": "10\nsshshss\nhssssssssh\nhhhhhh\nhhhs\nhshhh\nhhhhshsh\nhh\nh\nshs... | 31 | 0 | 0 | 9,220 | |
620 | Pearls in a Row | [
"greedy"
] | null | null | There are *n* pearls in a row. Let's enumerate them with integers from 1 to *n* from the left to the right. The pearl number *i* has the type *a**i*.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal ... | The first line contains integer *n* (1<=≤<=*n*<=≤<=3·105) — the number of pearls in a row.
The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=109) – the type of the *i*-th pearl. | On the first line print integer *k* — the maximal number of segments in a partition of the row.
Each of the next *k* lines should contain two integers *l**j*,<=*r**j* (1<=≤<=*l**j*<=≤<=*r**j*<=≤<=*n*) — the number of the leftmost and the rightmost pearls in the *j*-th segment.
Note you should print the correct partit... | [
"5\n1 2 3 4 1\n",
"5\n1 2 3 4 5\n",
"7\n1 2 1 3 1 2 1\n"
] | [
"1\n1 5\n",
"-1\n",
"2\n1 3\n4 7\n"
] | none | [
{
"input": "5\n1 2 3 4 1",
"output": "1\n1 5"
},
{
"input": "5\n1 2 3 4 5",
"output": "-1"
},
{
"input": "7\n1 2 1 3 1 2 1",
"output": "2\n1 3\n4 7"
},
{
"input": "9\n1 2 1 2 1 2 1 2 1",
"output": "3\n1 3\n4 6\n7 9"
},
{
"input": "11\n1 1 2 1 2 1 2 1 2 1 1",
"... | 249 | 268,390,400 | 0 | 9,406 | |
549 | The Game Of Parity | [
"games"
] | null | null | There are *n* cities in Westeros. The *i*-th city is inhabited by *a**i* people. Daenerys and Stannis play the following game: in one single move, a player chooses a certain town and burns it to the ground. Thus all its residents, sadly, die. Stannis starts the game. The game ends when Westeros has exactly *k* cities l... | The first line contains two positive space-separated integers, *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=2·105) — the initial number of cities in Westeros and the number of cities at which the game ends.
The second line contains *n* space-separated positive integers *a**i* (1<=≤<=*a**i*<=≤<=106), which represent the populat... | Print string "Daenerys" (without the quotes), if Daenerys wins and "Stannis" (without the quotes), if Stannis wins. | [
"3 1\n1 2 1\n",
"3 1\n2 2 1\n",
"6 3\n5 20 12 7 14 101\n"
] | [
"Stannis\n",
"Daenerys\n",
"Stannis\n"
] | In the first sample Stannis will use his move to burn a city with two people and Daenerys will be forced to burn a city with one resident. The only survivor city will have one resident left, that is, the total sum is odd, and thus Stannis wins.
In the second sample, if Stannis burns a city with two people, Daenerys bu... | [
{
"input": "3 1\n1 2 1",
"output": "Stannis"
},
{
"input": "3 1\n2 2 1",
"output": "Daenerys"
},
{
"input": "6 3\n5 20 12 7 14 101",
"output": "Stannis"
},
{
"input": "6 3\n346 118 330 1403 5244 480",
"output": "Daenerys"
},
{
"input": "7 4\n11 3532 99 3512 12 8 2... | 280 | 17,203,200 | 0 | 9,415 | |
0 | none | [
"none"
] | null | null | ATMs of a well-known bank of a small country are arranged so that they can not give any amount of money requested by the user. Due to the limited size of the bill dispenser (the device that is directly giving money from an ATM) and some peculiarities of the ATM structure, you can get at most *k* bills from it, and the ... | The first line contains two integers *n*, *k* (1<=≤<=*n*<=≤<=5000, 1<=≤<=*k*<=≤<=20).
The next line contains *n* space-separated integers *a**i* (1<=≤<=*a**i*<=≤<=107) — the denominations of the bills that are used in the country. Numbers *a**i* follow in the strictly increasing order.
The next line contains integer ... | For each request for cash withdrawal print on a single line the minimum number of bills it can be done, or print <=-<=1, if it is impossible to get the corresponding sum. | [
"6 20\n10 50 100 500 1000 5000\n8\n4200\n100000\n95000\n96000\n99000\n10100\n2015\n9950\n",
"5 2\n1 2 3 5 8\n8\n1\n3\n5\n7\n9\n11\n13\n15\n"
] | [
"6\n20\n19\n20\n-1\n3\n-1\n-1\n",
"1\n1\n1\n2\n2\n2\n2\n-1\n"
] | none | [
{
"input": "6 20\n10 50 100 500 1000 5000\n8\n4200\n100000\n95000\n96000\n99000\n10100\n2015\n9950",
"output": "6\n20\n19\n20\n-1\n3\n-1\n-1"
},
{
"input": "5 2\n1 2 3 5 8\n8\n1\n3\n5\n7\n9\n11\n13\n15",
"output": "1\n1\n1\n2\n2\n2\n2\n-1"
},
{
"input": "5 5\n1 2 3 6 102\n10\n1\n4\n30\n1... | 498 | 6,656,000 | 3 | 9,420 | |
30 | Shooting Gallery | [
"dp",
"probabilities"
] | C. Shooting Gallery | 2 | 256 | One warm and sunny day king Copa decided to visit the shooting gallery, located at the Central Park, and try to win the main prize — big pink plush panda. The king is not good at shooting, so he invited you to help him.
The shooting gallery is an infinite vertical plane with Cartesian coordinate system on it. The targ... | The first line contains integer *n* (1<=≤<=*n*<=≤<=1000) — amount of targets in the shooting gallery. Then *n* lines follow, each describing one target. Each description consists of four numbers *x**i*, *y**i*, *t**i*, *p**i* (where *x**i*, *y**i*, *t**i* — integers, <=-<=1000<=≤<=*x**i*,<=*y**i*<=≤<=1000,<=0<=≤<=*t**i... | Output the maximum expected value of the amount of targets that was shot by the king. Your answer will be accepted if it differs from the correct answer by not more than 10<=-<=6. | [
"1\n0 0 0 0.5\n",
"2\n0 0 0 0.6\n5 0 5 0.7\n"
] | [
"0.5000000000\n",
"1.3000000000\n"
] | none | [
{
"input": "1\n0 0 0 0.5",
"output": "0.5000000000"
},
{
"input": "2\n0 0 0 0.6\n5 0 5 0.7",
"output": "1.3000000000"
},
{
"input": "1\n-5 2 3 0.886986",
"output": "0.8869860000"
},
{
"input": "4\n10 -7 14 0.926305\n-7 -8 12 0.121809\n-7 7 14 0.413446\n3 -8 6 0.859061",
"... | 218 | 2,252,800 | 3.941304 | 9,431 |
859 | Desk Disorder | [
"combinatorics",
"dfs and similar",
"dsu",
"graphs",
"trees"
] | null | null | A new set of desks just arrived, and it's about time! Things were getting quite cramped in the office. You've been put in charge of creating a new seating chart for the engineers. The desks are numbered, and you sent out a survey to the engineering team asking each engineer the number of the desk they currently sit at,... | Input will begin with a line containing *N* (1<=≤<=*N*<=≤<=100000), the number of engineers.
*N* lines follow, each containing exactly two integers. The *i*-th line contains the number of the current desk of the *i*-th engineer and the number of the desk the *i*-th engineer wants to move to. Desks are numbered from 1... | Print the number of possible assignments, modulo 1000000007<==<=109<=+<=7. | [
"4\n1 5\n5 2\n3 7\n7 3\n",
"5\n1 10\n2 10\n3 10\n4 10\n5 5\n"
] | [
"6\n",
"5\n"
] | These are the possible assignments for the first example:
- 1 5 3 7 - 1 2 3 7 - 5 2 3 7 - 1 5 7 3 - 1 2 7 3 - 5 2 7 3 | [
{
"input": "4\n1 5\n5 2\n3 7\n7 3",
"output": "6"
},
{
"input": "5\n1 10\n2 10\n3 10\n4 10\n5 5",
"output": "5"
},
{
"input": "1\n1 2",
"output": "2"
},
{
"input": "30\n22 37\n12 37\n37 58\n29 57\n43 57\n57 58\n58 53\n45 4\n1 4\n4 51\n35 31\n21 31\n31 51\n51 53\n53 48\n60 55\... | 764 | 13,209,600 | 0 | 9,434 | |
414 | Mashmokh and Reverse Operation | [
"combinatorics",
"divide and conquer"
] | null | null | Mashmokh's boss, Bimokh, didn't like Mashmokh. So he fired him. Mashmokh decided to go to university and participate in ACM instead of finding a new job. He wants to become a member of Bamokh's team. In order to join he was given some programming tasks and one week to solve them. Mashmokh is not a very experienced prog... | The first line of input contains a single integer *n* (0<=≤<=*n*<=≤<=20).
The second line of input contains 2*n* space-separated integers *a*[1],<=*a*[2],<=...,<=*a*[2*n*] (1<=≤<=*a*[*i*]<=≤<=109), the initial array.
The third line of input contains a single integer *m* (1<=≤<=*m*<=≤<=106).
The fourth line of inpu... | Output *m* lines. In the *i*-th line print the answer (the number of inversions) for the *i*-th query. | [
"2\n2 1 4 3\n4\n1 2 0 2\n",
"1\n1 2\n3\n0 1 1\n"
] | [
"0\n6\n6\n0\n",
"0\n1\n0\n"
] | If we reverse an array *x*[1], *x*[2], ..., *x*[*n*] it becomes new array *y*[1], *y*[2], ..., *y*[*n*], where *y*[*i*] = *x*[*n* - *i* + 1] for each *i*.
The number of inversions of an array *x*[1], *x*[2], ..., *x*[*n*] is the number of pairs of indices *i*, *j* such that: *i* < *j* and *x*[*i*] > *x*[*j*]. | [] | 93 | 20,172,800 | 0 | 9,443 | |
79 | Bus Game | [
"greedy"
] | A. Bus Game | 2 | 256 | After Fox Ciel won an onsite round of a programming contest, she took a bus to return to her castle. The fee of the bus was 220 yen. She met Rabbit Hanako in the bus. They decided to play the following game because they got bored in the bus.
- Initially, there is a pile that contains *x* 100-yen coins and *y* 10-yen ... | The first line contains two integers *x* (0<=≤<=*x*<=≤<=106) and *y* (0<=≤<=*y*<=≤<=106), separated by a single space. | If Ciel wins, print "Ciel". Otherwise, print "Hanako". | [
"2 2\n",
"3 22\n"
] | [
"Ciel\n",
"Hanako\n"
] | In the first turn (Ciel's turn), she will choose 2 100-yen coins and 2 10-yen coins. In the second turn (Hanako's turn), she will choose 1 100-yen coin and 12 10-yen coins. In the third turn (Ciel's turn), she can't pay exactly 220 yen, so Ciel will lose. | [
{
"input": "2 2",
"output": "Ciel"
},
{
"input": "3 22",
"output": "Hanako"
},
{
"input": "0 22",
"output": "Ciel"
},
{
"input": "1000 1000",
"output": "Ciel"
},
{
"input": "0 0",
"output": "Hanako"
},
{
"input": "0 21",
"output": "Hanako"
},
{... | 186 | 307,200 | 0 | 9,448 |
7 | Line | [
"math",
"number theory"
] | C. Line | 1 | 256 | A line on the plane is described by an equation *Ax*<=+<=*By*<=+<=*C*<==<=0. You are to find any point on this line, whose coordinates are integer numbers from <=-<=5·1018 to 5·1018 inclusive, or to find out that such points do not exist. | The first line contains three integers *A*, *B* and *C* (<=-<=2·109<=≤<=*A*,<=*B*,<=*C*<=≤<=2·109) — corresponding coefficients of the line equation. It is guaranteed that *A*2<=+<=*B*2<=><=0. | If the required point exists, output its coordinates, otherwise output -1. | [
"2 5 3\n"
] | [
"6 -3\n"
] | none | [
{
"input": "2 5 3",
"output": "6 -3"
},
{
"input": "0 2 3",
"output": "-1"
},
{
"input": "931480234 -1767614767 -320146190",
"output": "-98880374013340920 -52107006370101410"
},
{
"input": "-1548994394 -1586527767 -1203252104",
"output": "-878123061596147680 8573488141506... | 186 | 0 | 0 | 9,449 |
600 | Lomsat gelral | [
"data structures",
"dfs and similar",
"dsu",
"trees"
] | null | null | You are given a rooted tree with root in vertex 1. Each vertex is coloured in some colour.
Let's call colour *c* dominating in the subtree of vertex *v* if there are no other colours that appear in the subtree of vertex *v* more times than colour *c*. So it's possible that two or more colours will be dominating in the... | The first line contains integer *n* (1<=≤<=*n*<=≤<=105) — the number of vertices in the tree.
The second line contains *n* integers *c**i* (1<=≤<=*c**i*<=≤<=*n*), *c**i* — the colour of the *i*-th vertex.
Each of the next *n*<=-<=1 lines contains two integers *x**j*,<=*y**j* (1<=≤<=*x**j*,<=*y**j*<=≤<=*n*) — the edge... | Print *n* integers — the sums of dominating colours for each vertex. | [
"4\n1 2 3 4\n1 2\n2 3\n2 4\n",
"15\n1 2 3 1 2 3 3 1 1 3 2 2 1 2 3\n1 2\n1 3\n1 4\n1 14\n1 15\n2 5\n2 6\n2 7\n3 8\n3 9\n3 10\n4 11\n4 12\n4 13\n"
] | [
"10 9 3 4\n",
"6 5 4 3 2 3 3 1 1 3 2 2 1 2 3\n"
] | none | [
{
"input": "4\n1 2 3 4\n1 2\n2 3\n2 4",
"output": "10 9 3 4"
},
{
"input": "15\n1 2 3 1 2 3 3 1 1 3 2 2 1 2 3\n1 2\n1 3\n1 4\n1 14\n1 15\n2 5\n2 6\n2 7\n3 8\n3 9\n3 10\n4 11\n4 12\n4 13",
"output": "6 5 4 3 2 3 3 1 1 3 2 2 1 2 3"
}
] | 2,000 | 2,662,400 | 0 | 9,471 | |
0 | none | [
"none"
] | null | null | It's a beautiful April day and Wallace is playing football with his friends. But his friends do not know that Wallace actually stayed home with Gromit and sent them his robotic self instead. Robo-Wallace has several advantages over the other guys. For example, he can hit the ball directly to the specified point. And ye... | The first and the single line contains integers *y*1, *y*2, *y**w*, *x**b*, *y**b*, *r* (1<=≤<=*y*1,<=*y*2,<=*y**w*,<=*x**b*,<=*y**b*<=≤<=106; *y*1<=<<=*y*2<=<<=*y**w*; *y**b*<=+<=*r*<=<<=*y**w*; 2·*r*<=<<=*y*2<=-<=*y*1).
It is guaranteed that the ball is positioned correctly in the field, doesn't cross an... | If Robo-Wallace can't score a goal in the described manner, print "-1" (without the quotes). Otherwise, print a single number *x**w* — the abscissa of his point of aiming.
If there are multiple points of aiming, print the abscissa of any of them. When checking the correctness of the answer, all comparisons are made w... | [
"4 10 13 10 3 1\n",
"1 4 6 2 2 1\n",
"3 10 15 17 9 2\n"
] | [
"4.3750000000\n",
"-1\n",
"11.3333333333\n"
] | Note that in the first and third samples other correct values of abscissa *x*<sub class="lower-index">*w*</sub> are also possible. | [
{
"input": "4 10 13 10 3 1",
"output": "4.3750000000"
},
{
"input": "1 4 6 2 2 1",
"output": "-1"
},
{
"input": "3 10 15 17 9 2",
"output": "11.3333333333"
},
{
"input": "4 9 30 3 3 1",
"output": "-1"
},
{
"input": "4 9 13 2 3 1",
"output": "-1"
},
{
"... | 92 | 0 | 0 | 9,481 | |
0 | none | [
"none"
] | null | null | You are given an integer *m*, and a list of *n* distinct integers between 0 and *m*<=-<=1.
You would like to construct a sequence satisfying the properties:
- Each element is an integer between 0 and *m*<=-<=1, inclusive. - All prefix products of the sequence modulo *m* are distinct. - No prefix product modulo *m*... | The first line of input contains two integers *n* and *m* (0<=≤<=*n*<=<<=*m*<=≤<=200<=000) — the number of forbidden prefix products and the modulus.
If *n* is non-zero, the next line of input contains *n* distinct integers between 0 and *m*<=-<=1, the forbidden prefix products. If *n* is zero, this line doesn't ex... | On the first line, print the number *k*, denoting the length of your sequence.
On the second line, print *k* space separated integers, denoting your sequence. | [
"0 5\n",
"3 10\n2 9 1\n"
] | [
"5\n1 2 4 3 0\n",
"6\n3 9 2 9 8 0\n"
] | For the first case, the prefix products of this sequence modulo *m* are [1, 2, 3, 4, 0].
For the second case, the prefix products of this sequence modulo *m* are [3, 7, 4, 6, 8, 0]. | [
{
"input": "0 5",
"output": "5\n1 2 4 3 0"
},
{
"input": "3 10\n2 9 1",
"output": "6\n3 9 2 9 8 0"
},
{
"input": "0 1",
"output": "1\n0"
},
{
"input": "0 720",
"output": "397\n1 7 413 263 389 467 77 283 299 187 293 563 269 47 677 463 599 367 173 143 149 347 557 643 179 54... | 30 | 102,400 | 0 | 9,495 | |
232 | Table | [
"bitmasks",
"combinatorics",
"dp",
"math"
] | null | null | John Doe has an *n*<=×<=*m* table. John Doe can paint points in some table cells, not more than one point in one table cell. John Doe wants to use such operations to make each square subtable of size *n*<=×<=*n* have exactly *k* points.
John Doe wondered, how many distinct ways to fill the table with points are there,... | A single line contains space-separated integers *n*, *m*, *k* (1<=≤<=*n*<=≤<=100; *n*<=≤<=*m*<=≤<=1018; 0<=≤<=*k*<=≤<=*n*2) — the number of rows of the table, the number of columns of the table and the number of points each square must contain.
Please, do not use the %lld specifier to read or write 64-bit integers in ... | In a single line print a single integer — the remainder from dividing the described number of ways by 1000000007 (109<=+<=7). | [
"5 6 1\n"
] | [
"45"
] | Let's consider the first test case: | [
{
"input": "5 6 1",
"output": "45"
},
{
"input": "1 1000000000000000000 0",
"output": "1"
},
{
"input": "100 1000000 5000",
"output": "13662512"
},
{
"input": "100 1000000000000000000 10000",
"output": "1"
},
{
"input": "2 1791938441 1",
"output": "216278738"
... | 30 | 0 | 0 | 9,542 | |
1,005 | Summarize to the Power of Two | [
"brute force",
"greedy",
"implementation"
] | null | null | A sequence $a_1, a_2, \dots, a_n$ is called good if, for each element $a_i$, there exists an element $a_j$ ($i \ne j$) such that $a_i+a_j$ is a power of two (that is, $2^d$ for some non-negative integer $d$).
For example, the following sequences are good:
- $[5, 3, 11]$ (for example, for $a_1=5$ we can choose $a_2=3... | The first line contains the integer $n$ ($1 \le n \le 120000$) — the length of the given sequence.
The second line contains the sequence of integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$). | Print the minimum number of elements needed to be removed from the given sequence in order to make it good. It is possible that you need to delete all $n$ elements, make it empty, and thus get a good sequence. | [
"6\n4 7 1 5 4 9\n",
"5\n1 2 3 4 5\n",
"1\n16\n",
"4\n1 1 1 1023\n"
] | [
"1\n",
"2\n",
"1\n",
"0\n"
] | In the first example, it is enough to delete one element $a_4=5$. The remaining elements form the sequence $[4, 7, 1, 4, 9]$, which is good. | [
{
"input": "6\n4 7 1 5 4 9",
"output": "1"
},
{
"input": "5\n1 2 3 4 5",
"output": "2"
},
{
"input": "1\n16",
"output": "1"
},
{
"input": "4\n1 1 1 1023",
"output": "0"
},
{
"input": "10\n2 10 9 1 10 4 7 8 5 4",
"output": "5"
},
{
"input": "2\n1 1",
... | 249 | 28,262,400 | 3 | 9,582 | |
906 | Power Tower | [
"chinese remainder theorem",
"math",
"number theory"
] | null | null | Priests of the Quetzalcoatl cult want to build a tower to represent a power of their god. Tower is usually made of power-charged rocks. It is built with the help of rare magic by levitating the current top of tower and adding rocks at its bottom. If top, which is built from *k*<=-<=1 rocks, possesses power *p* and we w... | First line of input contains two integers *n* (1<=≤<=*n*<=≤<=105) and *m* (1<=≤<=*m*<=≤<=109).
Second line of input contains *n* integers *w**k* (1<=≤<=*w**k*<=≤<=109) which is the power of rocks that priests have.
Third line of input contains single integer *q* (1<=≤<=*q*<=≤<=105) which is amount of queries from pri... | Output *q* integers. *k*-th of them must be the amount of cumulative power the tower will have if is built from rocks *l**k*,<=*l**k*<=+<=1,<=...,<=*r**k*. | [
"6 1000000000\n1 2 2 3 3 3\n8\n1 1\n1 6\n2 2\n2 3\n2 4\n4 4\n4 5\n4 6\n"
] | [
"1\n1\n2\n4\n256\n3\n27\n597484987\n"
] | 3<sup class="upper-index">27</sup> = 7625597484987 | [
{
"input": "6 1000000000\n1 2 2 3 3 3\n8\n1 1\n1 6\n2 2\n2 3\n2 4\n4 4\n4 5\n4 6",
"output": "1\n1\n2\n4\n256\n3\n27\n597484987"
},
{
"input": "10 20\n792708224 4633945 600798790 384332600 283309209 762285205 750900274 160512987 390669628 205259431\n10\n5 9\n10 10\n8 10\n7 10\n7 10\n10 10\n4 4\n10 1... | 31 | 0 | 0 | 9,584 | |
546 | Soldier and Number Game | [
"constructive algorithms",
"dp",
"math",
"number theory"
] | null | null | Two soldiers are playing a game. At the beginning first of them chooses a positive integer *n* and gives it to the second soldier. Then the second one tries to make maximum possible number of rounds. Each round consists of choosing a positive integer *x*<=><=1, such that *n* is divisible by *x* and replacing *n* wit... | First line of input consists of single integer *t* (1<=≤<=*t*<=≤<=1<=000<=000) denoting number of games soldiers play.
Then follow *t* lines, each contains pair of integers *a* and *b* (1<=≤<=*b*<=≤<=*a*<=≤<=5<=000<=000) defining the value of *n* for a game. | For each game output a maximum score that the second soldier can get. | [
"2\n3 1\n6 3\n"
] | [
"2\n5\n"
] | none | [
{
"input": "2\n3 1\n6 3",
"output": "2\n5"
},
{
"input": "8\n7 1\n263 262\n1000003 1000002\n5000000 4999995\n2 1\n7 4\n12345 12345\n10 1",
"output": "8\n1\n1\n23\n1\n4\n0\n15"
},
{
"input": "3\n1 1\n5000000 1\n5000000 5000000",
"output": "0\n18703742\n0"
}
] | 1,560 | 202,854,400 | -1 | 9,629 | |
847 | Packmen | [
"binary search",
"dp"
] | null | null | A game field is a strip of 1<=×<=*n* square cells. In some cells there are Packmen, in some cells — asterisks, other cells are empty.
Packman can move to neighboring cell in 1 time unit. If there is an asterisk in the target cell then Packman eats it. Packman doesn't spend any time to eat an asterisk.
In the initial ... | The first line contains a single integer *n* (2<=≤<=*n*<=≤<=105) — the length of the game field.
The second line contains the description of the game field consisting of *n* symbols. If there is symbol '.' in position *i* — the cell *i* is empty. If there is symbol '*' in position *i* — in the cell *i* contains an ast... | Print minimum possible time after which Packmen can eat all asterisks. | [
"7\n*..P*P*\n",
"10\n.**PP.*P.*\n"
] | [
"3\n",
"2\n"
] | In the first example Packman in position 4 will move to the left and will eat asterisk in position 1. He will spend 3 time units on it. During the same 3 time units Packman in position 6 will eat both of neighboring with it asterisks. For example, it can move to the left and eat asterisk in position 5 (in 1 time unit) ... | [
{
"input": "7\n*..P*P*",
"output": "3"
},
{
"input": "10\n.**PP.*P.*",
"output": "2"
},
{
"input": "19\n**P.*..*..P..*.*P**",
"output": "7"
},
{
"input": "12\nP**.*P*P*P**",
"output": "3"
},
{
"input": "58\n..P.P*.P*.P...PPP...P*....*..*.**......*P.*P.....**P...*P... | 1,000 | 3,788,800 | 0 | 9,642 | |
774 | Stepan and Vowels | [
"*special",
"implementation",
"strings"
] | null | null | Stepan likes to repeat vowel letters when he writes words. For example, instead of the word "pobeda" he can write "pobeeeedaaaaa".
Sergey does not like such behavior, so he wants to write a program to format the words written by Stepan. This program must combine all consecutive equal vowels to a single vowel. The vowe... | The first line contains the integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of letters in the word written by Stepan.
The second line contains the string *s* which has length that equals to *n* and contains only lowercase English letters — the word written by Stepan. | Print the single string — the word written by Stepan converted according to the rules described in the statement. | [
"13\npobeeeedaaaaa\n",
"22\niiiimpleeemeentatiioon\n",
"18\naeiouyaaeeiioouuyy\n",
"24\naaaoooiiiuuuyyyeeeggghhh\n"
] | [
"pobeda\n",
"implemeentatioon\n",
"aeiouyaeeioouy\n",
"aoiuyeggghhh\n"
] | none | [
{
"input": "13\npobeeeedaaaaa",
"output": "pobeda"
},
{
"input": "22\niiiimpleeemeentatiioon",
"output": "implemeentatioon"
},
{
"input": "18\naeiouyaaeeiioouuyy",
"output": "aeiouyaeeioouy"
},
{
"input": "24\naaaoooiiiuuuyyyeeeggghhh",
"output": "aoiuyeggghhh"
},
{
... | 78 | 5,529,600 | 0 | 9,644 | |
598 | Cut Length | [
"geometry"
] | null | null | Given simple (without self-intersections) *n*-gon. It is not necessary convex. Also you are given *m* lines. For each line find the length of common part of the line and the *n*-gon.
The boundary of *n*-gon belongs to polygon. It is possible that *n*-gon contains 180-degree angles. | The first line contains integers *n* and *m* (3<=≤<=*n*<=≤<=1000;1<=≤<=*m*<=≤<=100). The following *n* lines contain coordinates of polygon vertices (in clockwise or counterclockwise direction). All vertices are distinct.
The following *m* lines contain line descriptions. Each of them contains two distict points of a ... | Print *m* lines, the *i*-th line should contain the length of common part of the given *n*-gon and the *i*-th line. The answer will be considered correct if the absolute or relative error doesn't exceed 10<=-<=6. | [
"4 3\n0 0\n1 0\n1 1\n0 1\n0 0 1 1\n0 0 0 1\n0 0 1 -1\n"
] | [
"1.41421356237309514547\n1.00000000000000000000\n0.00000000000000000000\n"
] | none | [
{
"input": "4 3\n0 0\n1 0\n1 1\n0 1\n0 0 1 1\n0 0 0 1\n0 0 1 -1",
"output": "1.41421356237309514547\n1.00000000000000000000\n0.00000000000000000000"
},
{
"input": "4 9\n0 0\n0 1\n1 1\n1 0\n0 0 1 1\n1 1 0 0\n0 0 1 0\n0 0 0.5 0\n0 0.5 1 0.5\n0 1 1 1\n1 1 1 0\n0.75 0.75 0.75 0.25\n0 0.25 1 0.75",
"... | 77 | 2,355,200 | -1 | 9,672 | |
7 | Memory Manager | [
"implementation"
] | B. Memory Manager | 1 | 64 | There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
... | The first line of the input data contains two positive integers *t* and *m* (1<=≤<=*t*<=≤<=100;1<=≤<=*m*<=≤<=100), where *t* — the amount of operations given to the memory manager for processing, and *m* — the available memory size in bytes. Then there follow *t* lines where the operations themselves are given. The fir... | Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return inte... | [
"6 10\nalloc 5\nalloc 3\nerase 1\nalloc 6\ndefragment\nalloc 6\n"
] | [
"1\n2\nNULL\n3\n"
] | none | [
{
"input": "6 10\nalloc 5\nalloc 3\nerase 1\nalloc 6\ndefragment\nalloc 6",
"output": "1\n2\nNULL\n3"
},
{
"input": "6 1\ndefragment\nalloc 10\nalloc 1\nerase -1\nerase 1\nerase 1",
"output": "NULL\n1\nILLEGAL_ERASE_ARGUMENT\nILLEGAL_ERASE_ARGUMENT"
},
{
"input": "14 100\nalloc 99\nalloc... | 124 | 5,222,400 | 0 | 9,683 |
21 | Stripe 2 | [
"binary search",
"dp",
"sortings"
] | C. Stripe 2 | 1 | 64 | Once Bob took a paper stripe of n squares (the height of the stripe is 1 square). In each square he wrote an integer number, possibly negative. He became interested in how many ways exist to cut this stripe into three pieces so that the sum of numbers from each piece is equal to the sum of numbers from any other piece,... | The first input line contains integer *n* (1<=≤<=*n*<=≤<=105) — amount of squares in the stripe. The second line contains n space-separated numbers — they are the numbers written in the squares of the stripe. These numbers are integer and do not exceed 10000 in absolute value. | Output the amount of ways to cut the stripe into three non-empty pieces so that the sum of numbers from each piece is equal to the sum of numbers from any other piece. Don't forget that it's allowed to cut the stripe along the squares' borders only. | [
"4\n1 2 3 3\n",
"5\n1 2 3 4 5\n"
] | [
"1\n",
"0\n"
] | none | [
{
"input": "1\n-3",
"output": "0"
},
{
"input": "2\n0 0",
"output": "0"
},
{
"input": "3\n0 0 0",
"output": "1"
},
{
"input": "4\n-2 3 3 2",
"output": "0"
},
{
"input": "5\n-6 3 -1 2 -7",
"output": "0"
},
{
"input": "6\n2 3 -3 0 -3 1",
"output": "0... | 109 | 0 | 0 | 9,689 |
113 | Double Happiness | [
"brute force",
"math",
"number theory"
] | C. Double Happiness | 3 | 128 | On the math lesson a teacher asked each pupil to come up with his own lucky numbers. As a fan of number theory Peter chose prime numbers. Bob was more original. He said that number *t* is his lucky number, if it can be represented as:
Now, the boys decided to find out how many days of the interval [*l*,<=*r*] (*l*<=≤... | The first line of the input contains integer numbers *l*,<=*r* (1<=≤<=*l*,<=*r*<=≤<=3·108). | In the only line print the number of days on the segment [*l*,<=*r*], which are lucky for Peter and Bob at the same time. | [
"3 5\n",
"6 66\n"
] | [
"1\n",
"7\n"
] | none | [] | 3,000 | 7,270,400 | 0 | 9,696 |
837 | Two Seals | [
"brute force",
"implementation"
] | null | null | One very important person has a piece of paper in the form of a rectangle *a*<=×<=*b*.
Also, he has *n* seals. Each seal leaves an impression on the paper in the form of a rectangle of the size *x**i*<=×<=*y**i*. Each impression must be parallel to the sides of the piece of paper (but seal can be rotated by 90 degrees... | The first line contains three integer numbers *n*, *a* and *b* (1<=≤<=*n*,<=*a*,<=*b*<=≤<=100).
Each of the next *n* lines contain two numbers *x**i*, *y**i* (1<=≤<=*x**i*,<=*y**i*<=≤<=100). | Print the largest total area that can be occupied by two seals. If you can not select two seals, print 0. | [
"2 2 2\n1 2\n2 1\n",
"4 10 9\n2 3\n1 1\n5 10\n9 11\n",
"3 10 10\n6 6\n7 7\n20 5\n"
] | [
"4\n",
"56\n",
"0\n"
] | In the first example you can rotate the second seal by 90 degrees. Then put impression of it right under the impression of the first seal. This will occupy all the piece of paper.
In the second example you can't choose the last seal because it doesn't fit. By choosing the first and the third seals you occupy the large... | [
{
"input": "2 2 2\n1 2\n2 1",
"output": "4"
},
{
"input": "4 10 9\n2 3\n1 1\n5 10\n9 11",
"output": "56"
},
{
"input": "3 10 10\n6 6\n7 7\n20 5",
"output": "0"
},
{
"input": "2 1 1\n1 1\n1 1",
"output": "0"
},
{
"input": "2 1 2\n1 1\n1 1",
"output": "2"
},
... | 140 | 20,172,800 | 0 | 9,697 | |
837 | Functions On The Segments | [
"data structures"
] | null | null | You have an array *f* of *n* functions.The function *f**i*(*x*) (1<=≤<=*i*<=≤<=*n*) is characterized by parameters: *x*1,<=*x*2,<=*y*1,<=*a*,<=*b*,<=*y*2 and take values:
- *y*1, if *x*<=≤<=*x*1. - *a*·*x*<=+<=*b*, if *x*1<=<<=*x*<=≤<=*x*2. - *y*2, if *x*<=><=*x*2.
There are *m* queries. Each query is deter... | First line contains one integer number *n* (1<=≤<=*n*<=≤<=75000).
Each of the next *n* lines contains six integer numbers: *x*1,<=*x*2,<=*y*1,<=*a*,<=*b*,<=*y*2 (0<=≤<=*x*1<=<<=*x*2<=≤<=2·105, 0<=≤<=*y*1,<=*y*2<=≤<=109, 0<=≤<=*a*,<=*b*<=≤<=104).
Next line contains one integer number *m* (1<=≤<=*m*<=≤<=500000).
Ea... | none | [
"1\n1 2 1 4 5 10\n1\n1 1 2\n",
"3\n2 5 1 1 1 4\n3 6 8 2 5 7\n1 3 5 1 4 10\n3\n1 3 3\n2 3 2\n1 2 5\n"
] | [
"13\n",
"19\n17\n11\n"
] | none | [
{
"input": "1\n1 2 1 4 5 10\n1\n1 1 2",
"output": "13"
},
{
"input": "3\n2 5 1 1 1 4\n3 6 8 2 5 7\n1 3 5 1 4 10\n3\n1 3 3\n2 3 2\n1 2 5",
"output": "19\n17\n11"
},
{
"input": "7\n4 8 562244866 6 8 140807945\n5 7 415374420 7 6 596093578\n3 4 766370993 3 7 973128805\n4 6 841321398 3 2 8931... | 1,403 | 42,905,600 | 0 | 9,701 | |
492 | Vanya and Exams | [
"greedy",
"sortings"
] | null | null | Vanya wants to pass *n* exams and get the academic scholarship. He will get the scholarship if the average grade mark for all the exams is at least *avg*. The exam grade cannot exceed *r*. Vanya has passed the exams and got grade *a**i* for the *i*-th exam. To increase the grade for the *i*-th exam by 1 point, Vanya mu... | The first line contains three integers *n*, *r*, *avg* (1<=≤<=*n*<=≤<=105, 1<=≤<=*r*<=≤<=109, 1<=≤<=*avg*<=≤<=*min*(*r*,<=106)) — the number of exams, the maximum grade and the required grade point average, respectively.
Each of the following *n* lines contains space-separated integers *a**i* and *b**i* (1<=≤<=*a**i*<... | In the first line print the minimum number of essays. | [
"5 5 4\n5 2\n4 7\n3 1\n3 2\n2 5\n",
"2 5 4\n5 2\n5 2\n"
] | [
"4\n",
"0\n"
] | In the first sample Vanya can write 2 essays for the 3rd exam to raise his grade by 2 points and 2 essays for the 4th exam to raise his grade by 1 point.
In the second sample, Vanya doesn't need to write any essays as his general point average already is above average. | [
{
"input": "5 5 4\n5 2\n4 7\n3 1\n3 2\n2 5",
"output": "4"
},
{
"input": "2 5 4\n5 2\n5 2",
"output": "0"
},
{
"input": "6 5 5\n1 7\n2 4\n3 5\n4 6\n5 6\n4 7",
"output": "63"
},
{
"input": "1 1000000000 1000000\n1 1000000",
"output": "999999000000"
},
{
"input": "1... | 795 | 20,480,000 | 0 | 9,707 | |
229 | Shifts | [
"brute force",
"two pointers"
] | null | null | You are given a table consisting of *n* rows and *m* columns. Each cell of the table contains a number, 0 or 1. In one move we can choose some row of the table and cyclically shift its values either one cell to the left, or one cell to the right.
To cyclically shift a table row one cell to the right means to move the ... | The first line contains two space-separated integers: *n* (1<=≤<=*n*<=≤<=100) — the number of rows in the table and *m* (1<=≤<=*m*<=≤<=104) — the number of columns in the table. Then *n* lines follow, each of them contains *m* characters "0" or "1": the *j*-th character of the *i*-th line describes the contents of the ... | Print a single number: the minimum number of moves needed to get only numbers 1 in some column of the table. If this is impossible, print -1. | [
"3 6\n101010\n000100\n100000\n",
"2 3\n111\n000\n"
] | [
"3\n",
"-1\n"
] | In the first sample one way to achieve the goal with the least number of moves is as follows: cyclically shift the second row to the right once, then shift the third row to the left twice. Then the table column before the last one will contain only 1s.
In the second sample one can't shift the rows to get a column cont... | [
{
"input": "3 6\n101010\n000100\n100000",
"output": "3"
},
{
"input": "2 3\n111\n000",
"output": "-1"
},
{
"input": "1 1\n1",
"output": "0"
},
{
"input": "1 1\n0",
"output": "-1"
},
{
"input": "3 1\n1\n1\n0",
"output": "-1"
},
{
"input": "6 2\n10\n11\n... | 310 | 30,105,600 | 0 | 9,711 | |
629 | Famil Door and Brackets | [
"dp",
"strings"
] | null | null | As Famil Door’s birthday is coming, some of his friends (like Gabi) decided to buy a present for him. His friends are going to buy a string consisted of round brackets since Famil Door loves string of brackets of length *n* more than any other strings!
The sequence of round brackets is called valid if and only if:
1... | First line contains *n* and *m* (1<=≤<=*m*<=≤<=*n*<=≤<=100<=000,<=*n*<=-<=*m*<=≤<=2000) — the desired length of the string and the length of the string bought by Gabi, respectively.
The second line contains string *s* of length *m* consisting of characters '(' and ')' only. | Print the number of pairs of string *p* and *q* such that *p*<=+<=*s*<=+<=*q* is a valid sequence of round brackets modulo 109<=+<=7. | [
"4 1\n(\n",
"4 4\n(())\n",
"4 3\n(((\n"
] | [
"4\n",
"1\n",
"0\n"
] | In the first sample there are four different valid pairs:
1. *p* = "(", *q* = "))" 1. *p* = "()", *q* = ")" 1. *p* = "", *q* = "())" 1. *p* = "", *q* = ")()"
In the second sample the only way to obtain a desired string is choose empty *p* and *q*.
In the third sample there is no way to get a valid sequence of b... | [
{
"input": "4 1\n(",
"output": "4"
},
{
"input": "4 4\n(())",
"output": "1"
},
{
"input": "4 3\n(((",
"output": "0"
},
{
"input": "875 50\n)))((())()))((()(())))))())))((((((()))))))()(((((",
"output": "0"
},
{
"input": "1980 464\n))(()()))(((((((((()))))))(()((((... | 514 | 7,168,000 | 0 | 9,745 | |
1,010 | Border | [
"number theory"
] | null | null | Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inhabitant of Earth, therefore she had to pay the tax to enter the territory of Mars.
There are... | The first line contains two integers $n$ and $k$ ($1 \le n \le 100\,000$, $2 \le k \le 100\,000$) — the number of denominations of banknotes and the base of the number system on Mars.
The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 10^9$) — denominations of banknotes on Mars.
All numbers... | On the first line output the number of values $d$ for which Natasha can make the Martians happy.
In the second line, output all these values in increasing order.
Print all numbers in decimal notation. | [
"2 8\n12 20\n",
"3 10\n10 20 30\n"
] | [
"2\n0 4 ",
"1\n0 "
] | Consider the first test case. It uses the octal number system.
If you take one banknote with the value of $12$, you will get $14_8$ in octal system. The last digit is $4_8$.
If you take one banknote with the value of $12$ and one banknote with the value of $20$, the total value will be $32$. In the octal system, it i... | [
{
"input": "2 8\n12 20",
"output": "2\n0 4 "
},
{
"input": "3 10\n10 20 30",
"output": "1\n0 "
},
{
"input": "5 10\n20 16 4 16 2",
"output": "5\n0 2 4 6 8 "
},
{
"input": "10 5\n4 6 8 6 4 10 2 10 8 6",
"output": "5\n0 1 2 3 4 "
},
{
"input": "20 25\n15 10 5 20 10 ... | 155 | 0 | 0 | 9,756 | |
245 | Mishap in Club | [
"greedy",
"implementation"
] | null | null | Polycarpus just has been out of luck lately! As soon as he found a job in the "Binary Cat" cafe, the club got burgled. All ice-cream was stolen.
On the burglary night Polycarpus kept a careful record of all club visitors. Each time a visitor entered the club, Polycarpus put down character "+" in his notes. Similarly, ... | The only line of the input contains a sequence of characters "+" and "-", the characters are written one after another without any separators. The characters are written in the order, in which the corresponding events occurred. The given sequence has length from 1 to 300 characters, inclusive. | Print the sought minimum number of people | [
"+-+-+\n",
"---"
] | [
"1\n",
"3"
] | none | [
{
"input": "+-+-+",
"output": "1"
},
{
"input": "---",
"output": "3"
},
{
"input": "-",
"output": "1"
},
{
"input": "--",
"output": "2"
},
{
"input": "---",
"output": "3"
},
{
"input": "----",
"output": "4"
},
{
"input": "---+",
"output... | 216 | 0 | 0 | 9,784 | |
0 | none | [
"none"
] | null | null | Christmas celebrations are coming to Whoville. Cindy Lou Who and her parents Lou Lou Who and Betty Lou Who decided to give sweets to all people in their street. They decided to give the residents of each house on the street, one kilogram of sweets. So they need as many kilos of sweets as there are homes on their street... | The first line of the input contains two space-separated integers *n* and *t* (2<=≤<=*n*<=≤<=5·105,<=1<=≤<=*t*<=≤<=109). The second line of the input contains *n* characters, the *i*-th of them equals "H" (if the *i*-th segment contains a house), "S" (if the *i*-th segment contains a shop) or "." (if the *i*-th segment... | If there isn't a single value of *k* that makes it possible to give sweets to everybody in at most *t* units of time, print in a single line "-1" (without the quotes). Otherwise, print on a single line the minimum possible value of *k*. | [
"6 6\nHSHSHS\n",
"14 100\n...HHHSSS...SH\n",
"23 50\nHHSS.......SSHHHHHHHHHH\n"
] | [
"1\n",
"0\n",
"8\n"
] | In the first example, there are as many stores, as houses. If the family do not take a single kilo of sweets from home, in order to treat the inhabitants of the first house, they will need to make at least one step back, and they have absolutely no time for it. If they take one kilogram of sweets, they won't need to go... | [] | 60 | 0 | 0 | 9,794 | |
288 | Polo the Penguin and Lucky Numbers | [
"dp",
"implementation",
"math"
] | null | null | Everybody knows that lucky numbers are positive integers that contain only lucky digits 4 and 7 in their decimal representation. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Polo the Penguin have two positive integers *l* and *r* (*l*<=<<=*r*), both of them are lucky numbers. Moreover, their le... | The first line contains a positive integer *l*, and the second line contains a positive integer *r* (1<=≤<=*l*<=<<=*r*<=≤<=10100000). The numbers are given without any leading zeroes.
It is guaranteed that the lengths of the given numbers are equal to each other and that both of them are lucky numbers. | In the single line print a single integer — the answer to the problem modulo 1000000007 (109<=+<=7). | [
"4\n7\n",
"474\n777\n"
] | [
"28\n",
"2316330\n"
] | none | [
{
"input": "4\n7",
"output": "28"
},
{
"input": "474\n777",
"output": "2316330"
},
{
"input": "44\n77",
"output": "11244"
},
{
"input": "444\n777",
"output": "2726676"
},
{
"input": "444\n477",
"output": "636444"
},
{
"input": "444\n744",
"output":... | 2,000 | 33,177,600 | 0 | 9,813 | |
557 | Ann and Half-Palindrome | [
"data structures",
"dp",
"graphs",
"string suffix structures",
"strings",
"trees"
] | null | null | Tomorrow Ann takes the hardest exam of programming where she should get an excellent mark.
On the last theoretical class the teacher introduced the notion of a half-palindrome.
String *t* is a half-palindrome, if for all the odd positions *i* () the following condition is held: *t**i*<==<=*t*|*t*|<=-<=*i*<=+<=1, wh... | The first line of the input contains string *s* (1<=≤<=|*s*|<=≤<=5000), consisting only of characters 'a' and 'b', where |*s*| is the length of string *s*.
The second line contains a positive integer *k* — the lexicographical number of the requested string among all the half-palindrome substrings of the given string ... | Print a substring of the given string that is the *k*-th in the lexicographical order of all substrings of the given string that are half-palindromes. | [
"abbabaab\n7\n",
"aaaaa\n10\n",
"bbaabb\n13\n"
] | [
"abaa\n",
"aaa\n",
"bbaabb\n"
] | By definition, string *a* = *a*<sub class="lower-index">1</sub>*a*<sub class="lower-index">2</sub>... *a*<sub class="lower-index">*n*</sub> is lexicographically less than string *b* = *b*<sub class="lower-index">1</sub>*b*<sub class="lower-index">2</sub>... *b*<sub class="lower-index">*m*</sub>, if either *a* is a pref... | [
{
"input": "abbabaab\n7",
"output": "abaa"
},
{
"input": "aaaaa\n10",
"output": "aaa"
},
{
"input": "bbaabb\n13",
"output": "bbaabb"
},
{
"input": "a\n1",
"output": "a"
},
{
"input": "b\n1",
"output": "b"
},
{
"input": "ababbbbbbbaaaaaaaabbbbbb\n23",
... | 1,500 | 51,200,000 | 0 | 9,834 | |
128 | Statues | [
"dfs and similar"
] | null | null | In this task Anna and Maria play a game with a very unpleasant rival. Anna and Maria are in the opposite squares of a chessboard (8<=×<=8): Anna is in the upper right corner, and Maria is in the lower left one. Apart from them, the board has several statues. Each statue occupies exactly one square. A square that contai... | You are given the 8 strings whose length equals 8, describing the initial position on the board. The first line represents the top row of the board, the next one — for the second from the top, and so on, the last line represents the bottom row. Each character string matches a single cell board in the appropriate row, a... | If Maria wins, print string "WIN". If the statues win, print string "LOSE". | [
".......A\n........\n........\n........\n........\n........\n........\nM.......\n",
".......A\n........\n........\n........\n........\n........\nSS......\nM.......\n",
".......A\n........\n........\n........\n........\n.S......\nS.......\nMS......\n"
] | [
"WIN\n",
"LOSE\n",
"LOSE\n"
] | none | [
{
"input": ".SSSSSSA\n.SSSSSSS\n.SSSSSSS\n.SSSSSSS\n.SSSSSSS\n.SSSSSSS\n.SSSSSSS\nMSSSSSSS",
"output": "WIN"
},
{
"input": "SSSSSSSA\nSSSSSSSS\nSSSSSSSS\nSSSSSSSS\nSSSSSSSS\nSSSSSSSS\nSSSSSSSS\nMSSSSSSS",
"output": "LOSE"
},
{
"input": "SSSSSSSA\n......SS\n.......S\n.......S\n.......S\n.... | 404 | 6,656,000 | 0 | 9,867 | |
656 | Da Vinci Powers | [
"*special"
] | null | null | The input contains a single integer *a* (0<=≤<=*a*<=≤<=35).
Output a single integer. | The input contains a single integer *a* (0<=≤<=*a*<=≤<=35). | Output a single integer. | [
"3\n",
"10\n"
] | [
"8\n",
"1024\n"
] | none | [
{
"input": "3",
"output": "8"
},
{
"input": "10",
"output": "1024"
},
{
"input": "35",
"output": "33940307968"
},
{
"input": "0",
"output": "1"
},
{
"input": "1",
"output": "2"
},
{
"input": "2",
"output": "4"
},
{
"input": "4",
"output... | 46 | 5,529,600 | 0 | 9,881 | |
922 | Cave Painting | [
"brute force",
"number theory"
] | null | null | Imp is watching a documentary about cave painting.
Some numbers, carved in chaotic order, immediately attracted his attention. Imp rapidly proposed a guess that they are the remainders of division of a number *n* by all integers *i* from 1 to *k*. Unfortunately, there are too many integers to analyze for Imp.
Imp wan... | The only line contains two integers *n*, *k* (1<=≤<=*n*,<=*k*<=≤<=1018). | Print "Yes", if all the remainders are distinct, and "No" otherwise.
You can print each letter in arbitrary case (lower or upper). | [
"4 4\n",
"5 3\n"
] | [
"No\n",
"Yes\n"
] | In the first sample remainders modulo 1 and 4 coincide. | [
{
"input": "4 4",
"output": "No"
},
{
"input": "5 3",
"output": "Yes"
},
{
"input": "1 1",
"output": "Yes"
},
{
"input": "744 18",
"output": "No"
},
{
"input": "47879 10",
"output": "Yes"
},
{
"input": "1000000000000000000 1000000000000000000",
"ou... | 155 | 0 | 3 | 9,898 | |
108 | Datatypes | [
"math",
"sortings"
] | B. Datatypes | 2 | 256 | Tattah's youngest brother, Tuftuf, is new to programming.
Since his older brother is such a good programmer, his biggest dream is to outshine him. Tuftuf is a student at the German University in Cairo (GUC) where he learns to write programs in Gava.
Today, Tuftuf was introduced to Gava's unsigned integer datatypes. G... | The first line contains integer *n* (2<=≤<=*n*<=≤<=105) — the number of Gava's unsigned integer datatypes' sizes. The second line contains a single-space-separated list of *n* integers (1<=≤<=*a**i*<=≤<=109) — sizes of datatypes in bits. Some datatypes may have equal sizes. | Print "YES" if Tuftuf will stop using Gava, and "NO" otherwise. | [
"3\n64 16 32\n",
"4\n4 2 1 3\n"
] | [
"NO\n",
"YES\n"
] | In the second example, *x* = 7 (111<sub class="lower-index">2</sub>) fits in 3 bits, but *x*<sup class="upper-index">2</sup> = 49 (110001<sub class="lower-index">2</sub>) does not fit in 4 bits. | [
{
"input": "3\n64 16 32",
"output": "NO"
},
{
"input": "4\n4 2 1 3",
"output": "YES"
},
{
"input": "5\n1 5 3 3 2",
"output": "YES"
},
{
"input": "52\n474 24 24 954 9 234 474 114 24 114 234 24 114 114 234 9 9 24 9 54 234 54 9 954 474 9 54 54 54 234 9 114 24 54 114 954 954 474 ... | 248 | 0 | 0 | 9,900 |
505 | Mr. Kitayuta, the Treasure Hunter | [
"dfs and similar",
"dp",
"two pointers"
] | null | null | The Shuseki Islands are an archipelago of 30001 small islands in the Yutampo Sea. The islands are evenly spaced along a line, numbered from 0 to 30000 from the west to the east. These islands are known to contain many treasures. There are *n* gems in the Shuseki Islands in total, and the *i*-th gem is located on island... | The first line of the input contains two space-separated integers *n* and *d* (1<=≤<=*n*,<=*d*<=≤<=30000), denoting the number of the gems in the Shuseki Islands and the length of the Mr. Kitayuta's first jump, respectively.
The next *n* lines describe the location of the gems. The *i*-th of them (1<=≤<=*i*<=≤<=*n*) c... | Print the maximum number of gems that Mr. Kitayuta can collect. | [
"4 10\n10\n21\n27\n27\n",
"8 8\n9\n19\n28\n36\n45\n55\n66\n78\n",
"13 7\n8\n8\n9\n16\n17\n17\n18\n21\n23\n24\n24\n26\n30\n"
] | [
"3\n",
"6\n",
"4\n"
] | In the first sample, the optimal route is 0 → 10 (+1 gem) → 19 → 27 (+2 gems) → ...
In the second sample, the optimal route is 0 → 8 → 15 → 21 → 28 (+1 gem) → 36 (+1 gem) → 45 (+1 gem) → 55 (+1 gem) → 66 (+1 gem) → 78 (+1 gem) → ...
In the third sample, the optimal route is 0 → 7 → 13 → ... | [
{
"input": "4 10\n10\n21\n27\n27",
"output": "3"
},
{
"input": "8 8\n9\n19\n28\n36\n45\n55\n66\n78",
"output": "6"
},
{
"input": "13 7\n8\n8\n9\n16\n17\n17\n18\n21\n23\n24\n24\n26\n30",
"output": "4"
},
{
"input": "8 4\n9\n15\n15\n16\n22\n25\n25\n28",
"output": "8"
},
... | 46 | 0 | 0 | 9,907 | |
985 | Isomorphic Strings | [
"hashing",
"strings"
] | null | null | You are given a string *s* of length *n* consisting of lowercase English letters.
For two given strings *s* and *t*, say *S* is the set of distinct characters of *s* and *T* is the set of distinct characters of *t*. The strings *s* and *t* are isomorphic if their lengths are equal and there is a one-to-one mapping (bi... | The first line contains two space-separated integers *n* and *m* (1<=≤<=*n*<=≤<=2·105, 1<=≤<=*m*<=≤<=2·105) — the length of the string *s* and the number of queries.
The second line contains string *s* consisting of *n* lowercase English letters.
The following *m* lines contain a single query on each line: *x**i*, *y... | For each query in a separate line print "YES" if substrings *s*[*x**i*... *x**i*<=+<=*len**i*<=-<=1] and *s*[*y**i*... *y**i*<=+<=*len**i*<=-<=1] are isomorphic and "NO" otherwise. | [
"7 4\nabacaba\n1 1 1\n1 4 2\n2 1 3\n2 4 3\n"
] | [
"YES\nYES\nNO\nYES\n"
] | The queries in the example are following:
1. substrings "a" and "a" are isomorphic: *f*(*a*) = *a*; 1. substrings "ab" and "ca" are isomorphic: *f*(*a*) = *c*, *f*(*b*) = *a*; 1. substrings "bac" and "aba" are not isomorphic since *f*(*b*) and *f*(*c*) must be equal to *a* at same time; 1. substrings "bac" and "c... | [
{
"input": "7 4\nabacaba\n1 1 1\n1 4 2\n2 1 3\n2 4 3",
"output": "YES\nYES\nNO\nYES"
},
{
"input": "1 2\nz\n1 1 1\n1 1 1",
"output": "YES\nYES"
},
{
"input": "36 4\naababcbbcbczaaawwwwwaaaabbbbtestbest\n1 7 6\n13 18 5\n23 26 3\n29 33 4",
"output": "YES\nYES\nNO\nNO"
},
{
"inp... | 92 | 102,400 | 0 | 9,954 | |
730 | Bulmart | [
"binary search",
"dfs and similar"
] | null | null | A new trade empire is rising in Berland. Bulmart, an emerging trade giant, decided to dominate the market of ... shovels! And now almost every city in Berland has a Bulmart store, and some cities even have several of them! The only problem is, at the moment sales are ... let's say a little below estimates. Some people ... | The first line contains two integers *n*, *m* (1<=≤<=*n*<=≤<=5000, 0<=≤<=*m*<=≤<=*min*(5000,<=*n*·(*n*<=-<=1)<=/<=2)). Each of the next *m* lines contains two integers *x**e* and *y**e*, meaning that the *e*-th road connects cities *x**e* and *y**e* (1<=≤<=*x**e*,<=*y**e*<=≤<=*n*).
The next line contains a single inte... | Output *q* lines. On the *j*-th line, print an answer for the *j*-th query — the minimum amount of time needed to deliver *r**j* shovels to the customer in city *g**j* spending no more than *a**j* burles. Print -1 if there is no solution for the *j*-th query. | [
"6 4\n4 2\n5 4\n1 2\n3 2\n2\n4 1 2\n3 2 3\n6\n1 2 6\n2 3 7\n3 1 2\n4 3 8\n5 2 5\n6 1 10\n"
] | [
"2\n-1\n2\n2\n3\n-1\n"
] | none | [] | 46 | 0 | 0 | 9,965 | |
241 | Old Peykan | [
"greedy"
] | null | null | There are *n* cities in the country where the Old Peykan lives. These cities are located on a straight line, we'll denote them from left to right as *c*1,<=*c*2,<=...,<=*c**n*. The Old Peykan wants to travel from city *c*1 to *c**n* using roads. There are (*n*<=-<=1) one way roads, the *i*-th road goes from city *c**i*... | The first line of the input contains two space-separated integers *m* and *k* (1<=≤<=*m*,<=*k*<=≤<=1000). The value *m* specifies the number of roads between cities which is equal to *n*<=-<=1.
The next line contains *m* space-separated integers *d*1,<=*d*2,<=...,<=*d**m* (1<=≤<=*d**i*<=≤<=1000) and the following line... | In the only line of the output print a single integer — the minimum time required for The Old Peykan to reach city *c**n* from city *c*1. | [
"4 6\n1 2 5 2\n2 3 3 4\n",
"2 3\n5 6\n5 5\n"
] | [
"10\n",
"14\n"
] | In the second sample above, the Old Peykan stays in *c*<sub class="lower-index">1</sub> for 3 hours. | [
{
"input": "4 6\n1 2 5 2\n2 3 3 4",
"output": "10"
},
{
"input": "2 3\n5 6\n5 5",
"output": "14"
},
{
"input": "24 3\n11 8 8 12 17 4 4 25 39 37 31 32 38 34 29 29 34 39 39 39 17 9 24 6\n3 5 4 3 3 3 4 3 4 3 3 3 3 4 3 3 4 3 4 3 3 3 3 3",
"output": "862"
},
{
"input": "43 5\n6 7 ... | 62 | 0 | 0 | 9,987 | |
488 | Candy Boxes | [
"brute force",
"constructive algorithms",
"math"
] | null | null | There is an old tradition of keeping 4 boxes of candies in the house in Cyberland. The numbers of candies are special if their arithmetic mean, their median and their range are all equal. By definition, for a set {*x*1,<=*x*2,<=*x*3,<=*x*4} (*x*1<=≤<=*x*2<=≤<=*x*3<=≤<=*x*4) arithmetic mean is , median is and range is ... | The first line of input contains an only integer *n* (0<=≤<=*n*<=≤<=4).
The next *n* lines contain integers *a**i*, denoting the number of candies in the *i*-th box (1<=≤<=*a**i*<=≤<=500). | In the first output line, print "YES" if a solution exists, or print "NO" if there is no solution.
If a solution exists, you should output 4<=-<=*n* more lines, each line containing an integer *b*, denoting the number of candies in a missing box.
All your numbers *b* must satisfy inequality 1<=≤<=*b*<=≤<=106. It is g... | [
"2\n1\n1\n",
"3\n1\n1\n1\n",
"4\n1\n2\n2\n3\n"
] | [
"YES\n3\n3\n",
"NO\n",
"YES\n"
] | For the first sample, the numbers of candies in 4 boxes can be 1, 1, 3, 3. The arithmetic mean, the median and the range of them are all 2.
For the second sample, it's impossible to find the missing number of candies.
In the third example no box has been lost and numbers satisfy the condition.
You may output *b* in ... | [
{
"input": "2\n1\n1",
"output": "YES\n3\n3"
},
{
"input": "3\n1\n1\n1",
"output": "NO"
},
{
"input": "4\n1\n2\n2\n3",
"output": "YES"
},
{
"input": "0",
"output": "YES\n1\n1\n3\n3"
},
{
"input": "1\n125",
"output": "YES\n125\n375\n375"
},
{
"input": "2... | 1,000 | 0 | 0 | 10,000 | |
24 | Sequence of points | [
"geometry",
"implementation",
"math"
] | C. Sequence of points | 2 | 256 | You are given the following points with integer coordinates on the plane: *M*0,<=*A*0,<=*A*1,<=...,<=*A**n*<=-<=1, where *n* is odd number. Now we define the following infinite sequence of points *M**i*: *M**i* is symmetric to *M**i*<=-<=1 according (for every natural number *i*). Here point *B* is symmetric to *A* ac... | On the first line you will be given an integer *n* (1<=≤<=*n*<=≤<=105), which will be odd, and *j* (1<=≤<=*j*<=≤<=1018), where *j* is the index of the desired point. The next line contains two space separated integers, the coordinates of *M*0. After that *n* lines follow, where the *i*-th line contain the space separat... | On a single line output the coordinates of *M**j*, space separated. | [
"3 4\n0 0\n1 1\n2 3\n-5 3\n",
"3 1\n5 5\n1000 1000\n-1000 1000\n3 100\n"
] | [
"14 0\n",
"1995 1995\n"
] | none | [
{
"input": "3 4\n0 0\n1 1\n2 3\n-5 3",
"output": "14 0"
},
{
"input": "3 1\n5 5\n1000 1000\n-1000 1000\n3 100",
"output": "1995 1995"
},
{
"input": "1 1\n-1000 -1000\n1000 1000",
"output": "3000 3000"
},
{
"input": "1 1000000000000000000\n-1000 1000\n1000 -1000",
"output"... | 1,808 | 8,704,000 | 3.531788 | 10,011 |
628 | Magic Numbers | [
"dp"
] | null | null | Consider the decimal presentation of an integer. Let's call a number d-magic if digit *d* appears in decimal presentation of the number on even positions and nowhere else.
For example, the numbers 1727374, 17, 1 are 7-magic but 77, 7, 123, 34, 71 are not 7-magic. On the other hand the number 7 is 0-magic, 123 is 2-mag... | The first line contains two integers *m*,<=*d* (1<=≤<=*m*<=≤<=2000, 0<=≤<=*d*<=≤<=9) — the parameters from the problem statement.
The second line contains positive integer *a* in decimal presentation (without leading zeroes).
The third line contains positive integer *b* in decimal presentation (without leading zeroes... | Print the only integer *a* — the remainder after dividing by 109<=+<=7 of the number of d-magic numbers in segment [*a*,<=*b*] that are multiple of *m*. | [
"2 6\n10\n99\n",
"2 0\n1\n9\n",
"19 7\n1000\n9999\n"
] | [
"8\n",
"4\n",
"6\n"
] | The numbers from the answer of the first example are 16, 26, 36, 46, 56, 76, 86 and 96.
The numbers from the answer of the second example are 2, 4, 6 and 8.
The numbers from the answer of the third example are 1767, 2717, 5757, 6707, 8797 and 9747. | [
{
"input": "2 6\n10\n99",
"output": "8"
},
{
"input": "2 0\n1\n9",
"output": "4"
},
{
"input": "19 7\n1000\n9999",
"output": "6"
},
{
"input": "9 4\n33\n52",
"output": "0"
},
{
"input": "10 8\n18\n59",
"output": "0"
},
{
"input": "43 3\n587\n850",
... | 124 | 409,600 | 0 | 10,020 | |
260 | Ancient Prophesy | [
"brute force",
"implementation",
"strings"
] | null | null | A recently found Ancient Prophesy is believed to contain the exact Apocalypse date. The prophesy is a string that only consists of digits and characters "-".
We'll say that some date is mentioned in the Prophesy if there is a substring in the Prophesy that is the date's record in the format "dd-mm-yyyy". We'll say tha... | The first line contains the Prophesy: a non-empty string that only consists of digits and characters "-". The length of the Prophesy doesn't exceed 105 characters. | In a single line print the date of the Apocalypse. It is guaranteed that such date exists and is unique. | [
"777-444---21-12-2013-12-2013-12-2013---444-777\n"
] | [
"13-12-2013"
] | none | [
{
"input": "777-444---21-12-2013-12-2013-12-2013---444-777",
"output": "13-12-2013"
},
{
"input": "30-12-201429-15-208830-12-2014",
"output": "30-12-2014"
},
{
"input": "14-08-201314-08-201314-08-201381-16-20172406414-08-201314-08-201314-08-20134237014-08-201314-08-2013",
"output": "... | 77 | 3,584,000 | -1 | 10,046 | |
776 | The Door Problem | [
"2-sat",
"dfs and similar",
"dsu",
"graphs"
] | null | null | Moriarty has trapped *n* people in *n* distinct rooms in a hotel. Some rooms are locked, others are unlocked. But, there is a condition that the people in the hotel can only escape when all the doors are unlocked at the same time. There are *m* switches. Each switch control doors of some rooms, but each door is control... | First line of input contains two integers *n* and *m* (2<=≤<=*n*<=≤<=105, 2<=≤<=*m*<=≤<=105) — the number of rooms and the number of switches.
Next line contains *n* space-separated integers *r*1,<=*r*2,<=...,<=*r**n* (0<=≤<=*r**i*<=≤<=1) which tell the status of room doors. The *i*-th room is locked if *r**i*<==<=0, ... | Output "YES" without quotes, if it is possible to open all doors at the same time, otherwise output "NO" without quotes. | [
"3 3\n1 0 1\n2 1 3\n2 1 2\n2 2 3\n",
"3 3\n1 0 1\n3 1 2 3\n1 2\n2 1 3\n",
"3 3\n1 0 1\n3 1 2 3\n2 1 2\n1 3\n"
] | [
"NO",
"YES",
"NO"
] | In the second example input, the initial statuses of the doors are [1, 0, 1] (0 means locked, 1 — unlocked).
After toggling switch 3, we get [0, 0, 0] that means all doors are locked.
Then, after toggling switch 1, we get [1, 1, 1] that means all doors are unlocked.
It can be seen that for the first and for the thir... | [
{
"input": "3 3\n1 0 1\n2 1 3\n2 1 2\n2 2 3",
"output": "NO"
},
{
"input": "3 3\n1 0 1\n3 1 2 3\n1 2\n2 1 3",
"output": "YES"
},
{
"input": "3 3\n1 0 1\n3 1 2 3\n2 1 2\n1 3",
"output": "NO"
},
{
"input": "11 10\n0 0 1 0 0 0 0 1 1 0 1\n3 2 3 11\n1 3\n2 6 7\n1 5\n1 11\n1 10\n5 ... | 31 | 0 | 0 | 10,051 | |
168 | Wizards and Minimal Spell | [
"implementation",
"strings"
] | null | null | Let's dive into one of the most interesting areas of magic — writing spells. Learning this exciting but challenging science is very troublesome, so now you will not learn the magic words, but only get to know the basic rules of writing spells.
Each spell consists of several lines. The line, whose first non-space chara... | The input contains multiple lines. All characters in the lines have codes from 32 to 127 (inclusive). Please note that the lines may begin with or end with one or more spaces. The size of the input does not exceed 1048576 (<==<=220) bytes. Newlines are included in this size.
In the Windows operating system used on the... | Print the text of the spell where all extra characters are deleted. Please note that each output line should be followed by a newline.
Please be careful: your answers will be validated by comparing them to the jury's answer byte-by-byte. So, all spaces and newlines matter. | [
"# include <cstdio>\n\nusing namespace std;\n\nint main ( ){\nputs(\"Hello # World\"); #\n#\n}\n",
"#\n\n#\n"
] | [
"# include <cstdio>\nusingnamespacestd;intmain(){puts(\"Hello#World\");#\n#\n}\n",
"#\n\n#\n"
] | In the first sample the amplifying lines are lines 1 and 7. So, lines 2 to 6 are concatenated to each other, all spaces are deleted from them.
In the second sample the amplifying lines are lines 1 and 3. So, no lines are concatenated to each other. | [
{
"input": " # include <cstdio>\n\nusing namespace std;\n\nint main ( ){\nputs(\"Hello # World\"); #\n#\n}",
"output": " # include <cstdio>\nusingnamespacestd;intmain(){puts(\"Hello#World\");#\n#\n}"
},
{
"input": "#\n\n#",
"output": "#\n\n#"
},
{
"input": "#\n \n#",
"... | 156 | 0 | 0 | 10,064 | |
154 | Hometask | [
"greedy"
] | null | null | Sergey attends lessons of the *N*-ish language. Each lesson he receives a hometask. This time the task is to translate some sentence to the *N*-ish language. Sentences of the *N*-ish language can be represented as strings consisting of lowercase Latin letters without spaces or punctuation marks.
Sergey totally forgot ... | The first line contains a non-empty string *s*, consisting of lowercase Latin letters — that's the initial sentence in *N*-ish, written by Sergey. The length of string *s* doesn't exceed 105.
The next line contains integer *k* (0<=≤<=*k*<=≤<=13) — the number of forbidden pairs of letters.
Next *k* lines contain descr... | Print the single number — the smallest number of letters that need to be removed to get a string without any forbidden pairs of neighboring letters. Please note that the answer always exists as it is always possible to remove all letters. | [
"ababa\n1\nab\n",
"codeforces\n2\ndo\ncs\n"
] | [
"2\n",
"1\n"
] | In the first sample you should remove two letters b.
In the second sample you should remove the second or the third letter. The second restriction doesn't influence the solution. | [
{
"input": "ababa\n1\nab",
"output": "2"
},
{
"input": "codeforces\n2\ndo\ncs",
"output": "1"
},
{
"input": "nllnrlrnll\n1\nrl",
"output": "1"
},
{
"input": "aludfbjtwnkgnfl\n1\noy",
"output": "0"
},
{
"input": "pgpgppgggpbbnnn\n2\npg\nnb",
"output": "7"
},
... | 154 | 3,379,200 | 0 | 10,089 | |
926 | A Vital Problem | [] | null | null | Polycarp has a strict daily schedule. He has *n* alarms set for each day, and the *i*-th alarm rings each day at the same time during exactly one minute.
Determine the longest time segment when Polycarp can sleep, i. e. no alarm rings in that period. It is possible that Polycarp begins to sleep in one day, and wakes u... | The first line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of alarms.
Each of the next *n* lines contains a description of one alarm. Each description has a format "hh:mm", where *hh* is the hour when the alarm rings, and *mm* is the minute of that hour when the alarm rings. The number of hours is b... | Print a line in format "hh:mm", denoting the maximum time Polycarp can sleep continuously. *hh* denotes the number of hours, and *mm* denotes the number of minutes. The number of minutes should be between 0 and 59. Look through examples to understand the format better. | [
"1\n05:43\n",
"4\n22:00\n03:21\n16:03\n09:59\n"
] | [
"23:59\n",
"06:37\n"
] | In the first example there is only one alarm which rings during one minute of a day, and then rings again on the next day, 23 hours and 59 minutes later. Polycarp can sleep all this time. | [
{
"input": "1\n05:43",
"output": "23:59"
},
{
"input": "4\n22:00\n03:21\n16:03\n09:59",
"output": "06:37"
},
{
"input": "20\n23:59\n00:00\n00:01\n00:02\n00:03\n00:04\n00:05\n00:06\n00:07\n00:08\n00:09\n00:10\n00:11\n00:12\n00:13\n00:14\n00:15\n00:16\n00:17\n00:18",
"output": "23:40"
... | 109 | 21,401,600 | 0 | 10,112 | |
12 | Ball | [
"data structures",
"sortings"
] | D. Ball | 2 | 256 | *N* ladies attend the ball in the King's palace. Every lady can be described with three values: beauty, intellect and richness. King's Master of Ceremonies knows that ladies are very special creatures. If some lady understands that there is other lady at the ball which is more beautiful, smarter and more rich, she can ... | The first line contains one integer *N* (1<=≤<=*N*<=≤<=500000). The second line contains *N* integer numbers *B**i*, separated by single spaces. The third and the fourth lines contain sequences *I**i* and *R**i* in the same format. It is guaranteed that 0<=≤<=*B**i*,<=*I**i*,<=*R**i*<=≤<=109. | Output the answer to the problem. | [
"3\n1 4 2\n4 3 2\n2 5 3\n"
] | [
"1\n"
] | none | [
{
"input": "3\n1 4 2\n4 3 2\n2 5 3",
"output": "1"
},
{
"input": "5\n2 8 10 0 7\n7 7 3 0 10\n2 8 3 2 2",
"output": "1"
},
{
"input": "5\n3 0 0 2 0\n7 10 7 4 0\n9 1 6 1 9",
"output": "1"
},
{
"input": "5\n5 4 0 2 5\n8 3 1 0 10\n4 5 0 0 5",
"output": "2"
},
{
"input... | 77 | 307,200 | -1 | 10,122 |
392 | Blocked Points | [
"math"
] | null | null | Imagine you have an infinite 2D plane with Cartesian coordinate system. Some of the integral points are blocked, and others are not. Two integral points *A* and *B* on the plane are 4-connected if and only if:
- the Euclidean distance between *A* and *B* is one unit and neither *A* nor *B* is blocked; - or there is ... | The first line contains an integer *n* (0<=≤<=*n*<=≤<=4·107). | Print a single integer — the minimum number of points that should be blocked. | [
"1\n",
"2\n",
"3\n"
] | [
"4\n",
"8\n",
"16\n"
] | none | [
{
"input": "1",
"output": "4"
},
{
"input": "2",
"output": "8"
},
{
"input": "3",
"output": "16"
},
{
"input": "4",
"output": "20"
},
{
"input": "0",
"output": "1"
},
{
"input": "30426905",
"output": "172120564"
},
{
"input": "38450759",
... | 93 | 0 | 0 | 10,135 | |
615 | Multipliers | [
"math",
"number theory"
] | null | null | Ayrat has number *n*, represented as it's prime factorization *p**i* of size *m*, i.e. *n*<==<=*p*1·*p*2·...·*p**m*. Ayrat got secret information that that the product of all divisors of *n* taken modulo 109<=+<=7 is the password to the secret data base. Now he wants to calculate this value. | The first line of the input contains a single integer *m* (1<=≤<=*m*<=≤<=200<=000) — the number of primes in factorization of *n*.
The second line contains *m* primes numbers *p**i* (2<=≤<=*p**i*<=≤<=200<=000). | Print one integer — the product of all divisors of *n* modulo 109<=+<=7. | [
"2\n2 3\n",
"3\n2 3 2\n"
] | [
"36\n",
"1728\n"
] | In the first sample *n* = 2·3 = 6. The divisors of 6 are 1, 2, 3 and 6, their product is equal to 1·2·3·6 = 36.
In the second sample 2·3·2 = 12. The divisors of 12 are 1, 2, 3, 4, 6 and 12. 1·2·3·4·6·12 = 1728. | [
{
"input": "2\n2 3",
"output": "36"
},
{
"input": "3\n2 3 2",
"output": "1728"
},
{
"input": "1\n2017",
"output": "2017"
},
{
"input": "2\n63997 63997",
"output": "135893224"
},
{
"input": "5\n11 7 11 7 11",
"output": "750455957"
},
{
"input": "5\n2 2 ... | 280 | 11,264,000 | 0 | 10,158 | |
351 | Jeff and Removing Periods | [
"data structures"
] | null | null | Cosider a sequence, consisting of *n* integers: *a*1, *a*2, ..., *a**n*. Jeff can perform the following operation on sequence *a*:
- take three integers *v*, *t*, *k* (1<=≤<=*v*,<=*t*<=≤<=*n*; 0<=≤<=*k*; *v*<=+<=*tk*<=≤<=*n*), such that *a**v* = *a**v*<=+<=*t*, *a**v*<=+<=*t* = *a**v*<=+<=2*t*, ..., *a**v*<=+<=*t*(*k... | The first line contains integer *m* (1<=≤<=*m*<=≤<=105). The next line contains *m* integers *b*1, *b*2, ..., *b**m* (1<=≤<=*b**i*<=≤<=105).
The third line contains integer *q* (1<=≤<=*q*<=≤<=105) — the number of questions. The next *q* lines contain pairs of integers, *i*-th of them contains a pair of integers *l**i... | In *q* lines print the answers to Jeff's queries. Print the answers according to the order of questions in input. | [
"5\n2 2 1 1 2\n5\n1 5\n1 1\n2 2\n1 3\n2 3\n",
"10\n2 1 3 3 3 3 1 3 1 1\n10\n4 8\n2 10\n1 10\n4 4\n1 3\n2 4\n6 7\n1 9\n2 5\n1 1\n"
] | [
"2\n1\n1\n2\n2\n",
"2\n3\n3\n1\n3\n2\n2\n3\n2\n1\n"
] | none | [
{
"input": "5\n2 2 1 1 2\n5\n1 5\n1 1\n2 2\n1 3\n2 3",
"output": "2\n1\n1\n2\n2"
},
{
"input": "10\n2 1 3 3 3 3 1 3 1 1\n10\n4 8\n2 10\n1 10\n4 4\n1 3\n2 4\n6 7\n1 9\n2 5\n1 1",
"output": "2\n3\n3\n1\n3\n2\n2\n3\n2\n1"
},
{
"input": "15\n3 3 2 2 1 2 4 1 3 1 1 3 1 4 1\n15\n4 10\n8 9\n12 1... | 1,684 | 9,625,600 | 0 | 10,222 | |
0 | none | [
"none"
] | null | null | Mike has a frog and a flower. His frog is named Xaniar and his flower is named Abol. Initially(at time 0), height of Xaniar is *h*1 and height of Abol is *h*2. Each second, Mike waters Abol and Xaniar.
So, if height of Xaniar is *h*1 and height of Abol is *h*2, after one second height of Xaniar will become and height... | The first line of input contains integer *m* (2<=≤<=*m*<=≤<=106).
The second line of input contains integers *h*1 and *a*1 (0<=≤<=*h*1,<=*a*1<=<<=*m*).
The third line of input contains integers *x*1 and *y*1 (0<=≤<=*x*1,<=*y*1<=<<=*m*).
The fourth line of input contains integers *h*2 and *a*2 (0<=≤<=*h*2,<=*a*... | Print the minimum number of seconds until Xaniar reaches height *a*1 and Abol reaches height *a*2 or print -1 otherwise. | [
"5\n4 2\n1 1\n0 1\n2 3\n",
"1023\n1 2\n1 0\n1 2\n1 1\n"
] | [
"3\n",
"-1\n"
] | In the first sample, heights sequences are following:
Xaniar: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/85da629b05969e7a8a6636d995b8fe7a0494e8f4.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Abol: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/ea... | [
{
"input": "5\n4 2\n1 1\n0 1\n2 3",
"output": "3"
},
{
"input": "1023\n1 2\n1 0\n1 2\n1 1",
"output": "-1"
},
{
"input": "1023\n1 2\n1 2\n1 2\n1 2",
"output": "512"
},
{
"input": "2\n0 1\n1 0\n1 0\n0 1",
"output": "-1"
},
{
"input": "17\n15 12\n15 12\n12 14\n1 11"... | 124 | 0 | 0 | 10,237 | |
803 | Maximal GCD | [
"constructive algorithms",
"greedy",
"math"
] | null | null | You are given positive integer number *n*. You should create such strictly increasing sequence of *k* positive numbers *a*1,<=*a*2,<=...,<=*a**k*, that their sum is equal to *n* and greatest common divisor is maximal.
Greatest common divisor of sequence is maximum of such numbers that every element of sequence is divi... | The first line consists of two numbers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=1010). | If the answer exists then output *k* numbers — resulting sequence. Otherwise output -1. If there are multiple answers, print any of them. | [
"6 3\n",
"8 2\n",
"5 3\n"
] | [
"1 2 3\n",
"2 6\n",
"-1\n"
] | none | [
{
"input": "6 3",
"output": "1 2 3"
},
{
"input": "8 2",
"output": "2 6"
},
{
"input": "5 3",
"output": "-1"
},
{
"input": "1 1",
"output": "1"
},
{
"input": "1 2",
"output": "-1"
},
{
"input": "2 1",
"output": "2"
},
{
"input": "2 10000000... | 124 | 7,270,400 | 3 | 10,278 | |
89 | Widget Library | [
"dp",
"expression parsing",
"graphs",
"implementation"
] | B. Widget Library | 2 | 256 | Vasya writes his own library for building graphical user interface. Vasya called his creation VTK (VasyaToolKit). One of the interesting aspects of this library is that widgets are packed in each other.
A widget is some element of graphical interface. Each widget has width and height, and occupies some rectangle on t... | The first line contains an integer *n* — the number of instructions (1<=≤<=*n*<=≤<=100). Next *n* lines contain instructions in the language VasyaScript — one instruction per line. There is a list of possible instructions below.
- "Widget [name]([x],[y])" — create a new widget [name] of the type Widget possessing the... | For each widget print on a single line its name, width and height, separated by spaces. The lines must be ordered lexicographically by a widget's name.
Please, do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use cout stream (also you may use %I64d specificator) | [
"12\nWidget me(50,40)\nVBox grandpa\nHBox father\ngrandpa.pack(father)\nfather.pack(me)\ngrandpa.set_border(10)\ngrandpa.set_spacing(20)\nWidget brother(30,60)\nfather.pack(brother)\nWidget friend(20,60)\nWidget uncle(100,20)\ngrandpa.pack(uncle)\n",
"15\nWidget pack(10,10)\nHBox dummy\nHBox x\nVBox y\ny.pack(dum... | [
"brother 30 60\nfather 80 60\nfriend 20 60\ngrandpa 120 120\nme 50 40\nuncle 100 20\n",
"dummy 0 0\npack 10 10\nx 40 10\ny 10 10\n"
] | In the first sample the widgets are arranged as follows: | [
{
"input": "12\nWidget me(50,40)\nVBox grandpa\nHBox father\ngrandpa.pack(father)\nfather.pack(me)\ngrandpa.set_border(10)\ngrandpa.set_spacing(20)\nWidget brother(30,60)\nfather.pack(brother)\nWidget friend(20,60)\nWidget uncle(100,20)\ngrandpa.pack(uncle)",
"output": "brother 30 60\nfather 80 60\nfriend 2... | 92 | 0 | 0 | 10,311 |
425 | Sereja and Swaps | [
"brute force",
"sortings"
] | null | null | As usual, Sereja has array *a*, its elements are integers: *a*[1],<=*a*[2],<=...,<=*a*[*n*]. Let's introduce notation:
A swap operation is the following sequence of actions:
- choose two indexes *i*,<=*j* (*i*<=≠<=*j*); - perform assignments *tmp*<==<=*a*[*i*],<=*a*[*i*]<==<=*a*[*j*],<=*a*[*j*]<==<=*tmp*.
What max... | The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=200; 1<=≤<=*k*<=≤<=10). The next line contains *n* integers *a*[1], *a*[2], ..., *a*[*n*] (<=-<=1000<=≤<=*a*[*i*]<=≤<=1000). | In a single line print the maximum value of *m*(*a*) that Sereja can get if he is allowed to perform at most *k* swap operations. | [
"10 2\n10 -1 2 2 2 2 2 2 -1 10\n",
"5 10\n-1 -1 -1 -1 -1\n"
] | [
"32\n",
"-1\n"
] | none | [
{
"input": "10 2\n10 -1 2 2 2 2 2 2 -1 10",
"output": "32"
},
{
"input": "5 10\n-1 -1 -1 -1 -1",
"output": "-1"
},
{
"input": "18 1\n166 788 276 -103 -491 195 -960 389 376 369 630 285 3 575 315 -987 820 466",
"output": "5016"
},
{
"input": "29 6\n-21 486 -630 -433 -123 -387 6... | 1,000 | 102,400 | 0 | 10,365 | |
750 | New Year and Rating | [
"binary search",
"greedy",
"math"
] | null | null | Every Codeforces user has rating, described with one integer, possibly negative or zero. Users are divided into two divisions. The first division is for users with rating 1900 or higher. Those with rating 1899 or lower belong to the second division. In every contest, according to one's performance, his or her rating ch... | The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=200<=000).
The *i*-th of next *n* lines contains two integers *c**i* and *d**i* (<=-<=100<=≤<=*c**i*<=≤<=100, 1<=≤<=*d**i*<=≤<=2), describing Limak's rating change after the *i*-th contest and his division during the *i*-th contest contest. | If Limak's current rating can be arbitrarily big, print "Infinity" (without quotes). If the situation is impossible, print "Impossible" (without quotes). Otherwise print one integer, denoting the maximum possible value of Limak's current rating, i.e. rating after the *n* contests. | [
"3\n-7 1\n5 2\n8 2\n",
"2\n57 1\n22 2\n",
"1\n-5 1\n",
"4\n27 2\n13 1\n-50 1\n8 2\n"
] | [
"1907\n",
"Impossible\n",
"Infinity\n",
"1897\n"
] | In the first sample, the following scenario matches all information Limak remembers and has maximum possible final rating:
- Limak has rating 1901 and belongs to the division 1 in the first contest. His rating decreases by 7. - With rating 1894 Limak is in the division 2. His rating increases by 5. - Limak has rati... | [
{
"input": "3\n-7 1\n5 2\n8 2",
"output": "1907"
},
{
"input": "2\n57 1\n22 2",
"output": "Impossible"
},
{
"input": "1\n-5 1",
"output": "Infinity"
},
{
"input": "4\n27 2\n13 1\n-50 1\n8 2",
"output": "1897"
},
{
"input": "6\n8 1\n-22 1\n9 2\n-7 2\n85 2\n77 1",
... | 156 | 4,812,800 | 3 | 10,371 | |
231 | To Add or Not to Add | [
"binary search",
"sortings",
"two pointers"
] | null | null | A piece of paper contains an array of *n* integers *a*1,<=*a*2,<=...,<=*a**n*. Your task is to find a number that occurs the maximum number of times in this array.
However, before looking for such number, you are allowed to perform not more than *k* following operations — choose an arbitrary element from the array and... | The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=105; 0<=≤<=*k*<=≤<=109) — the number of elements in the array and the number of operations you are allowed to perform, correspondingly.
The third line contains a sequence of *n* integers *a*1,<=*a*2,<=...,<=*a**n* (|*a**i*|<=≤<=109) — the initial array. T... | In a single line print two numbers — the maximum number of occurrences of some number in the array after at most *k* allowed operations are performed, and the minimum number that reaches the given maximum. Separate the printed numbers by whitespaces. | [
"5 3\n6 3 4 0 2\n",
"3 4\n5 5 5\n",
"5 3\n3 1 2 2 1\n"
] | [
"3 4\n",
"3 5\n",
"4 2\n"
] | In the first sample your task is to increase the second element of the array once and increase the fifth element of the array twice. Thus, we get sequence 6, 4, 4, 0, 4, where number 4 occurs 3 times.
In the second sample you don't need to perform a single operation or increase each element by one. If we do nothing, w... | [
{
"input": "5 3\n6 3 4 0 2",
"output": "3 4"
},
{
"input": "3 4\n5 5 5",
"output": "3 5"
},
{
"input": "5 3\n3 1 2 2 1",
"output": "4 2"
},
{
"input": "6 0\n3 2 3 2 3 2",
"output": "3 2"
},
{
"input": "10 15\n1 1 1 4 4 1 4 4 1 4",
"output": "10 4"
},
{
... | 62 | 0 | 0 | 10,408 | |
839 | Game of the Rows | [
"brute force",
"greedy",
"implementation"
] | null | null | Daenerys Targaryen has an army consisting of *k* groups of soldiers, the *i*-th group contains *a**i* soldiers. She wants to bring her army to the other side of the sea to get the Iron Throne. She has recently bought an airplane to carry her army through the sea. The airplane has *n* rows, each of them has 8 seats. We ... | The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=10000, 1<=≤<=*k*<=≤<=100) — the number of rows and the number of groups of soldiers, respectively.
The second line contains *k* integers *a*1,<=*a*2,<=*a*3,<=...,<=*a**k* (1<=≤<=*a**i*<=≤<=10000), where *a**i* denotes the number of soldiers in the *i*-th ... | If we can place the soldiers in the airplane print "YES" (without quotes). Otherwise print "NO" (without quotes).
You can choose the case (lower or upper) for each letter arbitrary. | [
"2 2\n5 8\n",
"1 2\n7 1\n",
"1 2\n4 4\n",
"1 4\n2 2 1 2\n"
] | [
"YES\n",
"NO\n",
"YES\n",
"YES\n"
] | In the first sample, Daenerys can place the soldiers like in the figure below:
In the second sample, there is no way to place the soldiers in the plane since the second group soldier will always have a seat neighboring to someone from the first group.
In the third example Daenerys can place the first group on seats (... | [
{
"input": "2 2\n5 8",
"output": "YES"
},
{
"input": "1 2\n7 1",
"output": "NO"
},
{
"input": "1 2\n4 4",
"output": "YES"
},
{
"input": "1 4\n2 2 1 2",
"output": "YES"
},
{
"input": "10000 100\n749 2244 949 2439 2703 44 2394 124 285 3694 3609 717 1413 155 974 1778... | 46 | 0 | 0 | 10,409 | |
894 | Marco and GCD Sequence | [
"constructive algorithms",
"math"
] | null | null | In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length *n*, but forgot the exact sequence. Let the elements of the sequence ... | The first line contains a single integer *m* (1<=≤<=*m*<=≤<=1000) — the size of the set *S*.
The second line contains *m* integers *s*1,<=*s*2,<=...,<=*s**m* (1<=≤<=*s**i*<=≤<=106) — the elements of the set *S*. It's guaranteed that the elements of the set are given in strictly increasing order, that means *s*1<=<<... | If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer *n* denoting the length of the sequence, *n* should not exceed 4000.
In the second line print *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=106) — the sequence.
We can show that if a solution e... | [
"4\n2 4 6 12\n",
"2\n2 3\n"
] | [
"3\n4 6 12",
"-1\n"
] | In the first example 2 = *gcd*(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among *gcd*(*a*<sub class="lower-index">*i*</sub>, *a*<sub class="lower-index">*i* + 1</sub>, ..., *a*<sub class="lower-index">*j*</sub>) for every 1 ≤ *i*... | [
{
"input": "4\n2 4 6 12",
"output": "7\n2 2 4 2 6 2 12"
},
{
"input": "2\n2 3",
"output": "-1"
},
{
"input": "2\n1 6",
"output": "3\n1 1 6"
},
{
"input": "3\n1 2 7",
"output": "5\n1 1 2 1 7"
},
{
"input": "1\n1",
"output": "1\n1"
},
{
"input": "2\n1 10... | 155 | 2,764,800 | 3 | 10,414 | |
342 | Cupboard and Balloons | [
"geometry"
] | null | null | A girl named Xenia has a cupboard that looks like an arc from ahead. The arc is made of a semicircle with radius *r* (the cupboard's top) and two walls of height *h* (the cupboard's sides). The cupboard's depth is *r*, that is, it looks like a rectangle with base *r* and height *h*<=+<=*r* from the sides. The figure be... | The single line contains two integers *r*,<=*h* (1<=≤<=*r*,<=*h*<=≤<=107). | Print a single integer — the maximum number of balloons Xenia can put in the cupboard. | [
"1 1\n",
"1 2\n",
"2 1\n"
] | [
"3\n",
"5\n",
"2\n"
] | none | [
{
"input": "1 1",
"output": "3"
},
{
"input": "1 2",
"output": "5"
},
{
"input": "2 1",
"output": "2"
},
{
"input": "2 2",
"output": "3"
},
{
"input": "2 3",
"output": "4"
},
{
"input": "4 1",
"output": "1"
},
{
"input": "5 1",
"output"... | 92 | 0 | 0 | 10,446 | |
819 | Mister B and Boring Game | [
"games",
"greedy"
] | null | null | Sometimes Mister B has free evenings when he doesn't know what to do. Fortunately, Mister B found a new game, where the player can play against aliens.
All characters in this game are lowercase English letters. There are two players: Mister B and his competitor.
Initially the players have a string *s* consisting of t... | First and only line contains four space-separated integers: *a*, *b*, *l* and *r* (1<=≤<=*a*,<=*b*<=≤<=12, 1<=≤<=*l*<=≤<=*r*<=≤<=109) — the numbers of letters each player appends and the bounds of the segment. | Print one integer — the minimum possible number of different letters in the segment from position *l* to position *r*, inclusive, in string *s*. | [
"1 1 1 8\n",
"4 2 2 6\n",
"3 7 4 6\n"
] | [
"2",
"3",
"1"
] | In the first sample test one of optimal strategies generate string *s* = "abababab...", that's why answer is 2.
In the second sample test string *s* = "abcdbcaefg..." can be obtained, chosen segment will look like "bcdbc", that's why answer is 3.
In the third sample test string *s* = "abczzzacad..." can be obtained, ... | [
{
"input": "1 1 1 8",
"output": "2"
},
{
"input": "4 2 2 6",
"output": "3"
},
{
"input": "3 7 4 6",
"output": "1"
},
{
"input": "4 5 1 1",
"output": "1"
},
{
"input": "12 12 1 1000",
"output": "13"
},
{
"input": "12 1 1000 1000",
"output": "1"
},... | 2,000 | 15,872,000 | 0 | 10,451 | |
442 | Artem and Array | [
"data structures",
"greedy"
] | null | null | Artem has an array of *n* positive integers. Artem decided to play with it. The game consists of *n* moves. Each move goes like this. Artem chooses some element of the array and removes it. For that, he gets *min*(*a*,<=*b*) points, where *a* and *b* are numbers that were adjacent with the removed number. If the number... | The first line contains a single integer *n* (1<=≤<=*n*<=≤<=5·105) — the number of elements in the array. The next line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=106) — the values of the array elements. | In a single line print a single integer — the maximum number of points Artem can get. | [
"5\n3 1 5 2 6\n",
"5\n1 2 3 4 5\n",
"5\n1 100 101 100 1\n"
] | [
"11\n",
"6\n",
"102\n"
] | none | [
{
"input": "5\n3 1 5 2 6",
"output": "11"
},
{
"input": "5\n1 2 3 4 5",
"output": "6"
},
{
"input": "5\n1 100 101 100 1",
"output": "102"
},
{
"input": "10\n96 66 8 18 30 48 34 11 37 42",
"output": "299"
},
{
"input": "1\n87",
"output": "0"
},
{
"input... | 93 | 0 | -1 | 10,486 | |
913 | Logical Expression | [
"bitmasks",
"dp",
"shortest paths"
] | null | null | You are given a boolean function of three variables which is defined by its truth table. You need to find an expression of minimum length that equals to this function. The expression may consist of:
- Operation AND ('&', ASCII code 38) - Operation OR ('|', ASCII code 124) - Operation NOT ('!', ASCII code 33) -... | The first line contains one integer *n* — the number of functions in the input (1<=≤<=*n*<=≤<=10<=000).
The following *n* lines contain descriptions of functions, the *i*-th of them contains a string of length 8 that consists of digits 0 and 1 — the truth table of the *i*-th function. The digit on position *j* (0<=≤<=... | You should output *n* lines, the *i*-th line should contain the expression of minimum length which equals to the *i*-th function. If there is more than one such expression, output the lexicographically smallest of them. Expressions should satisfy the given grammar and shouldn't contain white spaces. | [
"4\n00110011\n00000111\n11110000\n00011111\n"
] | [
"y\n(y|z)&x\n!x\nx|y&z\n"
] | The truth table for the second function:
<img class="tex-graphics" src="https://espresso.codeforces.com/2b70451f45cd74ee2be475affd7c407d7ed6d5fd.png" style="max-width: 100.0%;max-height: 100.0%;"/> | [
{
"input": "4\n00110011\n00000111\n11110000\n00011111",
"output": "y\n(y|z)&x\n!x\nx|y&z"
},
{
"input": "1\n11001110",
"output": "!y|!z&x"
},
{
"input": "2\n11001110\n01001001",
"output": "!y|!z&x\n!(!x&!z|x&z|y)|x&y&z"
},
{
"input": "3\n10001001\n10111011\n10111101",
"ou... | 30 | 0 | 0 | 10,488 | |
908 | New Year and Curling | [
"brute force",
"geometry",
"implementation",
"math"
] | null | null | Carol is currently curling.
She has *n* disks each with radius *r* on the 2D plane.
Initially she has all these disks above the line *y*<==<=10100.
She then will slide the disks towards the line *y*<==<=0 one by one in order from 1 to *n*.
When she slides the *i*-th disk, she will place its center at the point (*... | The first line will contain two integers *n* and *r* (1<=≤<=*n*,<=*r*<=≤<=1<=000), the number of disks, and the radius of the disks, respectively.
The next line will contain *n* integers *x*1,<=*x*2,<=...,<=*x**n* (1<=≤<=*x**i*<=≤<=1<=000) — the *x*-coordinates of the disks. | Print a single line with *n* numbers. The *i*-th number denotes the *y*-coordinate of the center of the *i*-th disk. The output will be accepted if it has absolute or relative error at most 10<=-<=6.
Namely, let's assume that your answer for a particular value of a coordinate is *a* and the answer of the jury is *b*. ... | [
"6 2\n5 5 6 8 3 12\n"
] | [
"2 6.0 9.87298334621 13.3370849613 12.5187346573 13.3370849613\n"
] | The final positions of the disks will look as follows:
In particular, note the position of the last disk. | [
{
"input": "6 2\n5 5 6 8 3 12",
"output": "2 6.0 9.87298334621 13.3370849613 12.5187346573 13.3370849613"
},
{
"input": "1 1\n5",
"output": "1"
},
{
"input": "5 300\n939 465 129 611 532",
"output": "300 667.864105343 1164.9596696 1522.27745533 2117.05388391"
},
{
"input": "5 ... | 108 | 0 | -1 | 10,504 | |
923 | Primal Sport | [
"math",
"number theory"
] | null | null | Alice and Bob begin their day with a quick game. They first choose a starting number *X*0<=≥<=3 and try to reach one million by the process described below.
Alice goes first and then they take alternating turns. In the *i*-th turn, the player whose turn it is selects a prime number smaller than the current number, an... | The input contains a single integer *X*2 (4<=≤<=*X*2<=≤<=106). It is guaranteed that the integer *X*2 is composite, that is, is not prime. | Output a single integer — the minimum possible *X*0. | [
"14\n",
"20\n",
"8192\n"
] | [
"6\n",
"15\n",
"8191\n"
] | In the first test, the smallest possible starting number is *X*<sub class="lower-index">0</sub> = 6. One possible course of the game is as follows:
- Alice picks prime 5 and announces *X*<sub class="lower-index">1</sub> = 10 - Bob picks prime 7 and announces *X*<sub class="lower-index">2</sub> = 14.
In the second ... | [
{
"input": "14",
"output": "6"
},
{
"input": "20",
"output": "15"
},
{
"input": "8192",
"output": "8191"
},
{
"input": "1000000",
"output": "998677"
},
{
"input": "959806",
"output": "239958"
},
{
"input": "1452",
"output": "1206"
},
{
"inp... | 202 | 1,024,000 | -1 | 10,521 | |
319 | Ping-Pong | [
"data structures"
] | null | null | In this problem at each moment you have a set of intervals. You can move from interval (*a*,<=*b*) from our set to interval (*c*,<=*d*) from our set if and only if *c*<=<<=*a*<=<<=*d* or *c*<=<<=*b*<=<<=*d*. Also there is a path from interval *I*1 from our set to interval *I*2 from our set if there is a seq... | The first line of the input contains integer *n* denoting the number of queries, (1<=≤<=*n*<=≤<=105). Each of the following lines contains a query as described above. All numbers in the input are integers and don't exceed 109 by their absolute value.
It's guaranteed that all queries are correct. | For each query of the second type print "YES" or "NO" on a separate line depending on the answer. | [
"5\n1 1 5\n1 5 11\n2 1 2\n1 2 9\n2 1 2\n"
] | [
"NO\nYES\n"
] | none | [] | 122 | 0 | 0 | 10,541 | |
778 | Bitwise Formula | [
"bitmasks",
"brute force",
"dfs and similar",
"expression parsing",
"implementation"
] | null | null | Bob recently read about bitwise operations used in computers: AND, OR and XOR. He have studied their properties and invented a new game.
Initially, Bob chooses integer *m*, bit depth of the game, which means that all numbers in the game will consist of *m* bits. Then he asks Peter to choose some *m*-bit number. After ... | The first line contains two integers *n* and *m*, the number of variables and bit depth, respectively (1<=≤<=*n*<=≤<=5000; 1<=≤<=*m*<=≤<=1000).
The following *n* lines contain descriptions of the variables. Each line describes exactly one variable. Description has the following format: name of a new variable, space, ... | In the first line output the minimum number that should be chosen by Peter, to make the sum of all variable values minimum possible, in the second line output the minimum number that should be chosen by Peter, to make the sum of all variable values maximum possible. Both numbers should be printed as *m*-bit binary numb... | [
"3 3\na := 101\nb := 011\nc := ? XOR b\n",
"5 1\na := 1\nbb := 0\ncx := ? OR a\nd := ? XOR ?\ne := d AND bb\n"
] | [
"011\n100\n",
"0\n0\n"
] | In the first sample if Peter chooses a number 011<sub class="lower-index">2</sub>, then *a* = 101<sub class="lower-index">2</sub>, *b* = 011<sub class="lower-index">2</sub>, *c* = 000<sub class="lower-index">2</sub>, the sum of their values is 8. If he chooses the number 100<sub class="lower-index">2</sub>, then *a* = ... | [
{
"input": "3 3\na := 101\nb := 011\nc := ? XOR b",
"output": "011\n100"
},
{
"input": "5 1\na := 1\nbb := 0\ncx := ? OR a\nd := ? XOR ?\ne := d AND bb",
"output": "0\n0"
},
{
"input": "2 10\nb := 0100101101\na := ? XOR b",
"output": "0100101101\n1011010010"
},
{
"input": "1 ... | 3,000 | 7,270,400 | 0 | 10,556 | |
301 | Yaroslav and Divisors | [
"data structures"
] | null | null | Yaroslav has an array *p*<==<=*p*1,<=*p*2,<=...,<=*p**n* (1<=≤<=*p**i*<=≤<=*n*), consisting of *n* distinct integers. Also, he has *m* queries:
- Query number *i* is represented as a pair of integers *l**i*, *r**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=*n*). - The answer to the query *l**i*,<=*r**i* is the number of pairs of... | The first line contains the integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=2·105). The second line contains *n* distinct integers *p*1,<=*p*2,<=...,<=*p**n* (1<=≤<=*p**i*<=≤<=*n*). The following *m* lines contain Yaroslav's queries. The *i*-th line contains integers *l**i*,<=*r**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=*n*). | Print *m* integers — the answers to Yaroslav's queries in the order they appear in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier. | [
"1 1\n1\n1 1\n",
"10 9\n1 2 3 4 5 6 7 8 9 10\n1 10\n2 9\n3 8\n4 7\n5 6\n2 2\n9 10\n5 10\n4 10\n"
] | [
"1\n",
"27\n14\n8\n4\n2\n1\n2\n7\n9\n"
] | none | [] | 2,000 | 27,443,200 | 0 | 10,563 | |
774 | Lie or Truth | [
"*special",
"constructive algorithms",
"implementation",
"sortings"
] | null | null | Vasya has a sequence of cubes and exactly one integer is written on each cube. Vasya exhibited all his cubes in a row. So the sequence of numbers written on the cubes in the order from the left to the right equals to *a*1,<=*a*2,<=...,<=*a**n*.
While Vasya was walking, his little brother Stepan played with Vasya's cub... | The first line contains three integers *n*, *l*, *r* (1<=≤<=*n*<=≤<=105, 1<=≤<=*l*<=≤<=*r*<=≤<=*n*) — the number of Vasya's cubes and the positions told by Stepan.
The second line contains the sequence *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=*n*) — the sequence of integers written on cubes in the Vasya's order.
... | Print "LIE" (without quotes) if it is guaranteed that Stepan deceived his brother. In the other case, print "TRUTH" (without quotes). | [
"5 2 4\n3 4 2 3 1\n3 2 3 4 1\n",
"3 1 2\n1 2 3\n3 1 2\n",
"4 2 4\n1 1 1 1\n1 1 1 1\n"
] | [
"TRUTH\n",
"LIE\n",
"TRUTH\n"
] | In the first example there is a situation when Stepan said the truth. Initially the sequence of integers on the cubes was equal to [3, 4, 2, 3, 1]. Stepan could at first swap cubes on positions 2 and 3 (after that the sequence of integers on cubes became equal to [3, 2, 4, 3, 1]), and then swap cubes in positions 3 and... | [
{
"input": "5 2 4\n3 4 2 3 1\n3 2 3 4 1",
"output": "TRUTH"
},
{
"input": "3 1 2\n1 2 3\n3 1 2",
"output": "LIE"
},
{
"input": "4 2 4\n1 1 1 1\n1 1 1 1",
"output": "TRUTH"
},
{
"input": "5 1 3\n2 2 2 1 2\n2 2 2 1 2",
"output": "TRUTH"
},
{
"input": "7 1 4\n2 5 5 5... | 62 | 4,608,000 | 0 | 10,566 | |
229 | Triangles | [
"combinatorics",
"graphs",
"math"
] | null | null | Alice and Bob don't play games anymore. Now they study properties of all sorts of graphs together. Alice invented the following task: she takes a complete undirected graph with *n* vertices, chooses some *m* edges and keeps them. Bob gets the remaining edges.
Alice and Bob are fond of "triangles" in graphs, that is, ... | The first line contains two space-separated integers *n* and *m* (1<=≤<=*n*<=≤<=106,<=0<=≤<=*m*<=≤<=106) — the number of vertices in the initial complete graph and the number of edges in Alice's graph, correspondingly. Then *m* lines follow: the *i*-th line contains two space-separated integers *a**i*, *b**i* (1<=≤<=*a... | Print a single number — the total number of cycles of length 3 in Alice and Bob's graphs together.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is advised to use the cin, cout streams or the %I64d specifier. | [
"5 5\n1 2\n1 3\n2 3\n2 4\n3 4\n",
"5 3\n1 2\n2 3\n1 3\n"
] | [
"3\n",
"4\n"
] | In the first sample Alice has 2 triangles: (1, 2, 3) and (2, 3, 4). Bob's graph has only 1 triangle : (1, 4, 5). That's why the two graphs in total contain 3 triangles.
In the second sample Alice's graph has only one triangle: (1, 2, 3). Bob's graph has three triangles: (1, 4, 5), (2, 4, 5) and (3, 4, 5). In this case... | [] | 2,000 | 3,993,600 | 0 | 10,568 | |
24 | F1 Champions | [
"implementation"
] | B. F1 Champions | 2 | 256 | Formula One championship consists of series of races called Grand Prix. After every race drivers receive points according to their final position. Only the top 10 drivers receive points in the following order 25, 18, 15, 12, 10, 8, 6, 4, 2, 1. At the conclusion of the championship the driver with most points is the cha... | The first line contain integer *t* (1<=≤<=*t*<=≤<=20), where *t* is the number of races. After that all races are described one by one. Every race description start with an integer *n* (1<=≤<=*n*<=≤<=50) on a line of itself, where *n* is the number of clasified drivers in the given race. After that *n* lines follow wit... | Your output should contain exactly two line. On the first line is the name of the champion according to the original rule, and on the second line the name of the champion according to the alternative rule. | [
"3\n3\nHamilton\nVettel\nWebber\n2\nWebber\nVettel\n2\nHamilton\nVettel\n",
"2\n7\nProst\nSurtees\nNakajima\nSchumacher\nButton\nDeLaRosa\nBuemi\n8\nAlonso\nProst\nNinoFarina\nJimClark\nDeLaRosa\nNakajima\nPatrese\nSurtees\n"
] | [
"Vettel\nHamilton\n",
"Prost\nProst\n"
] | It is not guaranteed that the same drivers participate in all races. For the championship consider every driver that has participated in at least one race. The total number of drivers during the whole season is not more then 50. | [
{
"input": "3\n3\nHamilton\nVettel\nWebber\n2\nWebber\nVettel\n2\nHamilton\nVettel",
"output": "Vettel\nHamilton"
},
{
"input": "2\n7\nProst\nSurtees\nNakajima\nSchumacher\nButton\nDeLaRosa\nBuemi\n8\nAlonso\nProst\nNinoFarina\nJimClark\nDeLaRosa\nNakajima\nPatrese\nSurtees",
"output": "Prost\nP... | 436 | 13,824,000 | -1 | 10,575 |
128 | Games with Rectangle | [
"combinatorics",
"dp"
] | null | null | In this task Anna and Maria play the following game. Initially they have a checkered piece of paper with a painted *n*<=×<=*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... | The first and only line contains three integers: *n*,<=*m*,<=*k* (1<=≤<=*n*,<=*m*,<=*k*<=≤<=1000). | 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 (109<=+<=7). | [
"3 3 1\n",
"4 4 1\n",
"6 7 2\n"
] | [
"1\n",
"9\n",
"75\n"
] | 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 1 × 1 square inside the given 3 × ... | [
{
"input": "3 3 1",
"output": "1"
},
{
"input": "4 4 1",
"output": "9"
},
{
"input": "6 7 2",
"output": "75"
},
{
"input": "5 5 3",
"output": "0"
},
{
"input": "2 2 1",
"output": "0"
},
{
"input": "999 999 499",
"output": "1"
},
{
"input": ... | 1,076 | 68,096,000 | 3 | 10,645 | |
741 | Arpa's loud Owf and Mehrdad's evil plan | [
"dfs and similar",
"math"
] | null | null | As you have noticed, there are lovely girls in Arpa’s land.
People in Arpa's land are numbered from 1 to *n*. Everyone has exactly one crush, *i*-th person's crush is person with the number *crush**i*.
Someday Arpa shouted Owf loudly from the top of the palace and a funny game started in Arpa's land. The rules are as... | The first line of input contains integer *n* (1<=≤<=*n*<=≤<=100) — the number of people in Arpa's land.
The second line contains *n* integers, *i*-th of them is *crush**i* (1<=≤<=*crush**i*<=≤<=*n*) — the number of *i*-th person's crush. | If there is no *t* satisfying the condition, print -1. Otherwise print such smallest *t*. | [
"4\n2 3 1 4\n",
"4\n4 4 4 4\n",
"4\n2 1 4 3\n"
] | [
"3\n",
"-1\n",
"1\n"
] | In the first sample suppose *t* = 3.
If the first person starts some round:
The first person calls the second person and says "Owwwf", then the second person calls the third person and says "Owwf", then the third person calls the first person and says "Owf", so the first person becomes Joon-Joon of the round. So the... | [
{
"input": "4\n2 3 1 4",
"output": "3"
},
{
"input": "4\n4 4 4 4",
"output": "-1"
},
{
"input": "4\n2 1 4 3",
"output": "1"
},
{
"input": "5\n2 4 3 1 2",
"output": "-1"
},
{
"input": "5\n2 2 4 4 5",
"output": "-1"
},
{
"input": "5\n2 4 5 4 2",
"out... | 109 | 21,504,000 | 3 | 10,661 | |
468 | Tree | [
"graph matchings"
] | null | null | Little X has a tree consisting of *n* nodes (they are numbered from 1 to *n*). Each edge of the tree has a positive length. Let's define the distance between two nodes *v* and *u* (we'll denote it *d*(*v*,<=*u*)) as the sum of the lengths of edges in the shortest path between *v* and *u*.
A permutation *p* is a seque... | The first line contains an integer *n* (1<=≤<=*n*<=≤<=105).
Each of the next *n*<=-<=1 lines contains three space separated integers *u**i*,<=<=*v**i*,<=*w**i* (1<=≤<=<=*u**i*,<=<=*v**i*<=≤<=<=*n*; 1<=≤<=<=*w**i*<=≤<=<=105), denoting an edge between nodes *u**i* and *v**i* with length equal to *w**i*.
It is guarantee... | In the first line print the maximum possible value of the described sum. In the second line print *n* integers, representing the lexicographically smallest permutation. | [
"2\n1 2 3\n",
"5\n1 2 2\n1 3 3\n2 4 4\n2 5 5\n"
] | [
"6\n2 1\n",
"32\n2 1 4 5 3\n"
] | none | [] | 0 | 0 | -1 | 10,662 | |
57 | Square Earth? | [
"dfs and similar",
"greedy",
"implementation"
] | A. Square Earth? | 2 | 256 | Meg the Rabbit decided to do something nice, specifically — to determine the shortest distance between two points on the surface of our planet. But Meg... what can you say, she wants everything simple. So, she already regards our planet as a two-dimensional circle. No, wait, it's even worse — as a square of side *n*. T... | The single line contains 5 space-separated integers: *n*,<=*x*1,<=*y*1,<=*x*2,<=*y*2 (1<=≤<=*n*<=≤<=1000,<=0<=≤<=*x*1,<=*y*1,<=*x*2,<=*y*2<=≤<=*n*) which correspondingly represent a side of the square, the coordinates of the first point and the coordinates of the second point. It is guaranteed that the points lie on th... | You must print on a single line the shortest distance between the points. | [
"2 0 0 1 0\n",
"2 0 1 2 1\n",
"100 0 0 100 100\n"
] | [
"1\n",
"4\n",
"200\n"
] | none | [
{
"input": "2 0 0 1 0",
"output": "1"
},
{
"input": "2 0 1 2 1",
"output": "4"
},
{
"input": "100 0 0 100 100",
"output": "200"
},
{
"input": "4 0 3 1 4",
"output": "2"
},
{
"input": "10 8 10 10 0",
"output": "12"
},
{
"input": "26 21 0 26 14",
"ou... | 372 | 1,740,800 | 0 | 10,666 |
686 | Little Robber Girl's Zoo | [
"constructive algorithms",
"implementation",
"sortings"
] | null | null | Little Robber Girl likes to scare animals in her zoo for fun. She decided to arrange the animals in a row in the order of non-decreasing height. However, the animals were so scared that they couldn't stay in the right places.
The robber girl was angry at first, but then she decided to arrange the animals herself. She ... | The first line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — number of animals in the robber girl's zoo.
The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109), where *a**i* is the height of the animal occupying the *i*-th place. | Print the sequence of operations that will rearrange the animals by non-decreasing height.
The output should contain several lines, *i*-th of the lines should contain two space-separated integers *l**i* and *r**i* (1<=≤<=*l**i*<=<<=*r**i*<=≤<=*n*) — descriptions of segments the robber girl should name. The segments... | [
"4\n2 1 4 3\n",
"7\n36 28 57 39 66 69 68\n",
"5\n1 2 1 2 1\n"
] | [
"1 4\n",
"1 4\n6 7\n",
"2 5\n3 4\n1 4\n1 4\n"
] | Note that you don't have to minimize the number of operations. Any solution that performs at most 20 000 operations is allowed. | [
{
"input": "4\n2 1 4 3",
"output": "1 2\n3 4"
},
{
"input": "7\n36 28 57 39 66 69 68",
"output": "1 2\n3 4\n6 7"
},
{
"input": "5\n1 2 1 2 1",
"output": "2 3\n4 5\n3 4"
},
{
"input": "78\n7 3 8 8 9 8 10 9 12 11 16 14 17 17 18 18 20 20 25 22 27 26 29 27 35 35 36 36 37 37 38 38... | 31 | 0 | -1 | 10,674 | |
946 | Timetable | [
"dp"
] | null | null | Ivan is a student at Berland State University (BSU). There are *n* days in Berland week, and each of these days Ivan might have some classes at the university.
There are *m* working hours during each Berland day, and each lesson at the university lasts exactly one hour. If at some day Ivan's first lesson is during *i*... | The first line contains three integers *n*, *m* and *k* (1<=≤<=*n*,<=*m*<=≤<=500, 0<=≤<=*k*<=≤<=500) — the number of days in the Berland week, the number of working hours during each day, and the number of lessons Ivan can skip, respectively.
Then *n* lines follow, *i*-th line containing a binary string of *m* charact... | Print the minimum number of hours Ivan has to spend in the university during the week if he skips not more than *k* lessons. | [
"2 5 1\n01001\n10110\n",
"2 5 0\n01001\n10110\n"
] | [
"5\n",
"8\n"
] | In the first example Ivan can skip any of two lessons during the first day, so he spends 1 hour during the first day and 4 hours during the second day.
In the second example Ivan can't skip any lessons, so he spends 4 hours every day. | [
{
"input": "2 5 1\n01001\n10110",
"output": "5"
},
{
"input": "2 5 0\n01001\n10110",
"output": "8"
},
{
"input": "3 4 0\n0000\n0000\n0000",
"output": "0"
},
{
"input": "3 4 12\n1111\n1111\n1111",
"output": "0"
},
{
"input": "3 4 6\n1111\n1111\n1111",
"output":... | 764 | 7,884,800 | 3 | 10,689 | |
41 | Email address | [
"expression parsing",
"implementation"
] | C. Email address | 2 | 256 | Sometimes one has to spell email addresses over the phone. Then one usually pronounces a dot as dot, an at sign as at. As a result, we get something like vasyaatgmaildotcom. Your task is to transform it into a proper email address ([[email protected]](/cdn-cgi/l/email-protection)).
It is known that a proper email add... | The first line contains the email address description. It is guaranteed that that is a proper email address with all the dots replaced by dot an the at signs replaced by at. The line is not empty and its length does not exceed 100 symbols. | Print the shortest email address, from which the given line could be made by the described above replacements. If there are several solutions to that problem, print the lexicographically minimal one (the lexicographical comparison of the lines are implemented with an operator < in modern programming languages).
In ... | [
"vasyaatgmaildotcom\n",
"dotdotdotatdotdotat\n",
"aatt\n"
] | [
"[email protected]\n",
"[email protected]\n",
"a@t\n"
] | none | [
{
"input": "vasyaatgmaildotcom",
"output": "vasya@gmail.com"
},
{
"input": "dotdotdotatdotdotat",
"output": "dot..@..at"
},
{
"input": "aatt",
"output": "a@t"
},
{
"input": "zdotdotatdotz",
"output": "z..@.z"
},
{
"input": "dotdotdotdotatdotatatatdotdotdot",
"... | 124 | 0 | 0 | 10,693 |
862 | Mahmoud and Ehab and the xor | [
"constructive algorithms"
] | null | null | Mahmoud and Ehab are on the third stage of their adventures now. As you know, Dr. Evil likes sets. This time he won't show them any set from his large collection, but will ask them to create a new set to replenish his beautiful collection of sets.
Dr. Evil has his favorite evil integer *x*. He asks Mahmoud and Ehab to... | The only line contains two integers *n* and *x* (1<=≤<=*n*<=≤<=105, 0<=≤<=*x*<=≤<=105) — the number of elements in the set and the desired bitwise-xor, respectively. | If there is no such set, print "NO" (without quotes).
Otherwise, on the first line print "YES" (without quotes) and on the second line print *n* distinct integers, denoting the elements in the set is any order. If there are multiple solutions you can print any of them. | [
"5 5\n",
"3 6\n"
] | [
"YES\n1 2 4 5 7",
"YES\n1 2 5"
] | You can read more about the bitwise-xor operation here: [https://en.wikipedia.org/wiki/Bitwise_operation#XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR)
For the first sample <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/eb8ccd05d3a7a41eff93c98f79d158cf85e702f9.png" style="max-w... | [
{
"input": "5 5",
"output": "YES\n1 2 131072 131078 0 "
},
{
"input": "3 6",
"output": "YES\n131072 131078 0 "
},
{
"input": "3 0",
"output": "YES\n393216 131072 262144"
},
{
"input": "1 0",
"output": "YES\n0"
},
{
"input": "3 3",
"output": "YES\n131072 131075... | 93 | 0 | 0 | 10,743 | |
718 | Efim and Strange Grade | [
"dp",
"implementation",
"math"
] | null | null | Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after th... | The first line of the input contains two integers *n* and *t* (1<=≤<=*n*<=≤<=200<=000, 1<=≤<=*t*<=≤<=109) — the length of Efim's grade and the number of seconds till the end of the break respectively.
The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least on... | Print the maximum grade that Efim can get in *t* seconds. Do not print trailing zeroes. | [
"6 1\n10.245\n",
"6 2\n10.245\n",
"3 100\n9.2\n"
] | [
"10.25\n",
"10.3\n",
"9.2\n"
] | In the first two samples Efim initially has grade 10.245.
During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect.
In the third sample the optimal strategy is to not perform any rounding at all. | [
{
"input": "6 1\n10.245",
"output": "10.25"
},
{
"input": "6 2\n10.245",
"output": "10.3"
},
{
"input": "3 100\n9.2",
"output": "9.2"
},
{
"input": "12 5\n872.04488525",
"output": "872.1"
},
{
"input": "35 8\n984227318.2031144444444444494637612",
"output": "98... | 155 | 1,024,000 | 3 | 10,790 | |
255 | Almost Arithmetical Progression | [
"brute force",
"dp"
] | null | null | Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
- *a*1<==<=*p*, where *p* is some integer; - *a**i*<==<=*a**i*<=-<=1<=+<=(<=-<=1)*i*<=+<=1·... | The first line contains integer *n* (1<=≤<=*n*<=≤<=4000). The next line contains *n* integers *b*1,<=*b*2,<=...,<=*b**n* (1<=≤<=*b**i*<=≤<=106). | Print a single integer — the length of the required longest subsequence. | [
"2\n3 5\n",
"4\n10 20 10 30\n"
] | [
"2\n",
"3\n"
] | In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | [
{
"input": "2\n3 5",
"output": "2"
},
{
"input": "4\n10 20 10 30",
"output": "3"
},
{
"input": "5\n4 4 3 5 1",
"output": "2"
},
{
"input": "6\n2 3 2 2 1 3",
"output": "4"
},
{
"input": "8\n2 2 5 3 4 3 3 2",
"output": "3"
},
{
"input": "2\n468 335",
... | 327 | 66,560,000 | 3 | 10,825 | |
545 | Toy Cars | [
"implementation"
] | null | null | Little Susie, thanks to her older brother, likes to play with cars. Today she decided to set up a tournament between them. The process of a tournament is described in the next paragraph.
There are *n* toy cars. Each pair collides. The result of a collision can be one of the following: no car turned over, one car turne... | The first line contains integer *n* (1<=≤<=*n*<=≤<=100) — the number of cars.
Each of the next *n* lines contains *n* space-separated integers that determine matrix *A*.
It is guaranteed that on the main diagonal there are <=-<=1, and <=-<=1 doesn't appear anywhere else in the matrix.
It is guaranteed that the inpu... | Print the number of good cars and in the next line print their space-separated indices in the increasing order. | [
"3\n-1 0 0\n0 -1 1\n0 2 -1\n",
"4\n-1 3 3 3\n3 -1 3 3\n3 3 -1 3\n3 3 3 -1\n"
] | [
"2\n1 3 ",
"0\n"
] | none | [
{
"input": "3\n-1 0 0\n0 -1 1\n0 2 -1",
"output": "2\n1 3 "
},
{
"input": "4\n-1 3 3 3\n3 -1 3 3\n3 3 -1 3\n3 3 3 -1",
"output": "0"
},
{
"input": "1\n-1",
"output": "1\n1 "
},
{
"input": "2\n-1 0\n0 -1",
"output": "2\n1 2 "
},
{
"input": "2\n-1 1\n2 -1",
"out... | 46 | 2,867,200 | -1 | 10,828 | |
929 | Красивая команда | [
"*special",
"combinatorics",
"math"
] | null | null | Завтра у хоккейной команды, которой руководит Евгений, важный матч. Евгению нужно выбрать шесть игроков, которые выйдут на лед в стартовом составе: один вратарь, два защитника и три нападающих.
Так как это стартовый состав, Евгения больше волнует, насколько красива будет команда на льду, чем способности игроков. А име... | Первая строка содержит три целых числа *g*, *d* и *f* (1<=≤<=*g*<=≤<=1<=000, 1<=≤<=*d*<=≤<=1<=000, 1<=≤<=*f*<=≤<=1<=000) — число вратарей, защитников и нападающих в команде Евгения.
Вторая строка содержит *g* целых чисел, каждое в пределах от 1 до 100<=000 — номера вратарей.
Третья строка содержит *d* целых чисел, к... | Выведите одно целое число — количество возможных стартовых составов. | [
"1 2 3\n15\n10 19\n20 11 13\n",
"2 3 4\n16 40\n20 12 19\n13 21 11 10\n"
] | [
"1\n",
"6\n"
] | В первом примере всего один вариант для выбора состава, который удовлетворяет описанным условиям, поэтому ответ 1.
Во втором примере подходят следующие игровые сочетания (в порядке вратарь-защитник-защитник-нападающий-нападающий-нападающий):
- 16 20 12 13 21 11 - 16 20 12 13 11 10 - 16 20 19 13 21 11 - 16 20 19 1... | [
{
"input": "1 2 3\n15\n10 19\n20 11 13",
"output": "1"
},
{
"input": "2 3 4\n16 40\n20 12 19\n13 21 11 10",
"output": "6"
},
{
"input": "4 4 5\n15 16 19 6\n8 11 9 18\n5 3 1 12 14",
"output": "0"
},
{
"input": "6 7 7\n32 35 26 33 16 23\n4 40 36 12 28 24 3\n39 11 31 37 1 25 6",... | 405 | 28,467,200 | -1 | 10,846 | |
542 | Playing on Graph | [
"graphs",
"shortest paths"
] | null | null | Vova and Marina love offering puzzles to each other. Today Marina offered Vova to cope with the following task.
Vova has a non-directed graph consisting of *n* vertices and *m* edges without loops and multiple edges. Let's define the operation of contraction two vertices *a* and *b* that are not connected by an edge. ... | The first line contains two integers *n*,<=*m* (1<=≤<=*n*<=≤<=1000, 0<=≤<=*m*<=≤<=100<=000) — the number of vertices and the number of edges in the original graph.
Next *m* lines contain the descriptions of edges in the format *a**i*,<=*b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*, *a**i*<=≠<=*b**i*), which means that there i... | If it is impossible to obtain a chain from the given graph, print <=-<=1. Otherwise, print the maximum possible number of edges in the resulting chain. | [
"5 4\n1 2\n2 3\n3 4\n3 5\n",
"4 6\n1 2\n2 3\n1 3\n3 4\n2 4\n1 4\n",
"4 2\n1 3\n2 4\n"
] | [
"3\n",
"-1\n",
"2\n"
] | In the first sample test you can contract vertices 4 and 5 and obtain a chain of length 3.
In the second sample test it is initially impossible to contract any pair of vertexes, so it is impossible to achieve the desired result.
In the third sample test you can contract vertices 1 and 2 and obtain a chain of length 2... | [
{
"input": "5 4\n1 2\n2 3\n3 4\n3 5",
"output": "3"
},
{
"input": "4 6\n1 2\n2 3\n1 3\n3 4\n2 4\n1 4",
"output": "-1"
},
{
"input": "4 2\n1 3\n2 4",
"output": "2"
},
{
"input": "1 0",
"output": "0"
},
{
"input": "1000 0",
"output": "0"
},
{
"input": "1... | 155 | 2,252,800 | 0 | 10,849 | |
724 | Dense Subsequence | [
"data structures",
"greedy",
"strings"
] | null | null | You are given a string *s*, consisting of lowercase English letters, and the integer *m*.
One should choose some symbols from the given string so that any contiguous subsegment of length *m* has at least one selected symbol. Note that here we choose positions of symbols, not the symbols themselves.
Then one uses the ... | The first line of the input contains a single integer *m* (1<=≤<=*m*<=≤<=100<=000).
The second line contains the string *s* consisting of lowercase English letters. It is guaranteed that this string is non-empty and its length doesn't exceed 100<=000. It is also guaranteed that the number *m* doesn't exceed the length... | Print the single line containing the lexicographically smallest string, that can be obtained using the procedure described above. | [
"3\ncbabc\n",
"2\nabcab\n",
"3\nbcabcbaccba\n"
] | [
"a\n",
"aab\n",
"aaabb\n"
] | In the first sample, one can choose the subsequence {3} and form a string "a".
In the second sample, one can choose the subsequence {1, 2, 4} (symbols on this positions are 'a', 'b' and 'a') and rearrange the chosen symbols to form a string "aab". | [
{
"input": "3\ncbabc",
"output": "a"
},
{
"input": "2\nabcab",
"output": "aab"
},
{
"input": "3\nbcabcbaccba",
"output": "aaabb"
},
{
"input": "5\nimmaydobun",
"output": "ab"
},
{
"input": "5\nwjjdqawypvtgrncmqvcsergermprauyevcegjtcrrblkwiugrcjfpjyxngyryxntauxlouv... | 62 | 4,608,000 | 0 | 10,894 | |
952 | 2 + 2 != 4 | [] | null | null | One very experienced problem writer decided to prepare a problem for April Fools Day contest. The task was very simple - given an arithmetic expression, return the result of evaluating this expression. However, looks like there is a bug in the reference solution... | The only line of input data contains the arithmetic expression. The expression will contain between 2 and 10 operands, separated with arithmetic signs plus and/or minus. Each operand will be an integer between 0 and 255, inclusive. | Reproduce the output of the reference solution, including the bug. | [
"8-7+6-5+4-3+2-1-0\n",
"2+2\n",
"112-37\n"
] | [
"4\n",
"-46\n",
"375\n"
] | none | [
{
"input": "8-7+6-5+4-3+2-1-0",
"output": "4"
},
{
"input": "2+2",
"output": "-46"
},
{
"input": "112-37",
"output": "375"
},
{
"input": "255+255+255+255+255+255+255+255+255+255",
"output": "-42450"
},
{
"input": "0-255-255-255-255-255-255-255-255-255",
"outpu... | 31 | 0 | 0 | 10,917 | |
351 | Jeff and Permutation | [
"greedy"
] | null | null | Jeff's friends know full well that the boy likes to get sequences and arrays for his birthday. Thus, Jeff got sequence *p*1,<=*p*2,<=...,<=*p**n* for his birthday.
Jeff hates inversions in sequences. An inversion in sequence *a*1,<=*a*2,<=...,<=*a**n* is a pair of indexes *i*,<=*j* (1<=≤<=*i*<=<<=*j*<=≤<=*n*), such... | The first line contains integer *n* (1<=≤<=*n*<=≤<=2000). The next line contains *n* integers — sequence *p*1, *p*2, ..., *p**n* (|*p**i*|<=≤<=105). The numbers are separated by spaces. | In a single line print the answer to the problem — the minimum number of inversions Jeff can get. | [
"2\n2 1\n",
"9\n-2 0 -1 0 -1 2 1 0 -1\n"
] | [
"0\n",
"6\n"
] | none | [
{
"input": "2\n2 1",
"output": "0"
},
{
"input": "9\n-2 0 -1 0 -1 2 1 0 -1",
"output": "6"
},
{
"input": "9\n0 0 1 1 0 0 1 0 1",
"output": "5"
},
{
"input": "8\n0 1 2 -1 -2 1 -2 2",
"output": "3"
},
{
"input": "24\n-1 -1 2 2 0 -2 2 -1 0 0 2 -2 3 0 2 -3 0 -3 -1 1 0... | 60 | 0 | 0 | 10,919 | |
842 | Ilya And The Tree | [
"dfs and similar",
"graphs",
"math",
"number theory",
"trees"
] | null | null | Ilya is very fond of graphs, especially trees. During his last trip to the forest Ilya found a very interesting tree rooted at vertex 1. There is an integer number written on each vertex of the tree; the number written on vertex *i* is equal to *a**i*.
Ilya believes that the beauty of the vertex *x* is the greatest co... | First line contains one integer number *n* — the number of vertices in tree (1<=≤<=*n*<=≤<=2·105).
Next line contains *n* integer numbers *a**i* (1<=≤<=*i*<=≤<=*n*, 1<=≤<=*a**i*<=≤<=2·105).
Each of next *n*<=-<=1 lines contains two integer numbers *x* and *y* (1<=≤<=*x*,<=*y*<=≤<=*n*, *x*<=≠<=*y*), which means that t... | Output *n* numbers separated by spaces, where *i*-th number equals to maximum possible beauty of vertex *i*. | [
"2\n6 2\n1 2\n",
"3\n6 2 3\n1 2\n1 3\n",
"1\n10\n"
] | [
"6 6 \n",
"6 6 6 \n",
"10 \n"
] | none | [
{
"input": "2\n6 2\n1 2",
"output": "6 6 "
},
{
"input": "3\n6 2 3\n1 2\n1 3",
"output": "6 6 6 "
},
{
"input": "1\n10",
"output": "10 "
},
{
"input": "10\n2 3 4 5 6 7 8 9 10 11\n1 2\n2 3\n3 4\n4 5\n5 6\n6 7\n4 8\n8 9\n9 10",
"output": "2 3 2 1 1 1 1 1 1 1 "
},
{
... | 46 | 819,200 | 0 | 10,933 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.