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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
123 | Squares | [
"math"
] | null | null | You are given an infinite checkered field. You should get from a square (*x*1; *y*1) to a square (*x*2; *y*2). Using the shortest path is not necessary. You can move on the field squares in four directions. That is, when you are positioned in any square, you can move to any other side-neighboring one.
A square (*x*; *y*) is considered bad, if at least one of the two conditions is fulfilled:
- |*x*<=+<=*y*|<=≡<=0 (*mod* 2*a*),- |*x*<=-<=*y*|<=≡<=0 (*mod* 2*b*).
Your task is to find the minimum number of bad cells one will have to visit on the way from (*x*1; *y*1) to (*x*2; *y*2). | The only line contains integers *a*, *b*, *x*1, *y*1, *x*2 and *y*2 — the parameters of the bad squares, the coordinates of the initial and the final squares correspondingly (2<=≤<=*a*,<=*b*<=≤<=109 and |*x*1|,|*y*1|,|*x*2|,|*y*2|<=≤<=109). It is guaranteed that the initial and the final square aren't bad. | Print a single number — the minimum number of bad cells that one will have to visit in order to travel from square (*x*1; *y*1) to square (*x*2; *y*2). | [
"2 2 1 0 0 1\n",
"2 2 10 11 0 1\n",
"2 4 3 -1 3 7\n"
] | [
"1\n",
"5\n",
"2\n"
] | In the third sample one of the possible paths in (3;-1)->(3;0)->(3;1)->(3;2)->(4;2)->(4;3)->(4;4)->(4;5)->(4;6)->(4;7)->(3;7). Squares (3;1) and (4;4) are bad. | [
{
"input": "2 2 1 0 0 1",
"output": "1"
},
{
"input": "2 2 10 11 0 1",
"output": "5"
},
{
"input": "2 4 3 -1 3 7",
"output": "2"
},
{
"input": "2 2 9 10 -10 -11",
"output": "10"
},
{
"input": "3 2 -11 -10 10 11",
"output": "7"
},
{
"input": "3 2 11 -12... | 280 | 0 | 3 | 5,388 | |
865 | Save the problem! | [
"constructive algorithms"
] | null | null | Attention: we lost all the test cases for this problem, so instead of solving the problem, we need you to generate test cases. We're going to give you the answer, and you need to print a test case that produces the given answer. The original problem is in the following paragraph.
People don't use cash as often as they used to. Having a credit card solves some of the hassles of cash, such as having to receive change when you can't form the exact amount of money needed to purchase an item. Typically cashiers will give you as few coins as possible in change, but they don't have to. For example, if your change is 30 cents, a cashier could give you a 5 cent piece and a 25 cent piece, or they could give you three 10 cent pieces, or ten 1 cent pieces, two 5 cent pieces, and one 10 cent piece. Altogether there are 18 different ways to make 30 cents using only 1 cent pieces, 5 cent pieces, 10 cent pieces, and 25 cent pieces. Two ways are considered different if they contain a different number of at least one type of coin. Given the denominations of the coins and an amount of change to be made, how many different ways are there to make change?
As we mentioned before, we lost all the test cases for this problem, so we're actually going to give you the number of ways, and want you to produce a test case for which the number of ways is the given number. There could be many ways to achieve this (we guarantee there's always at least one), so you can print any, as long as it meets the constraints described below. | Input will consist of a single integer *A* (1<=≤<=*A*<=≤<=105), the desired number of ways. | In the first line print integers *N* and *M* (1<=≤<=*N*<=≤<=106,<=1<=≤<=*M*<=≤<=10), the amount of change to be made, and the number of denominations, respectively.
Then print *M* integers *D*1,<=*D*2,<=...,<=*D**M* (1<=≤<=*D**i*<=≤<=106), the denominations of the coins. All denominations must be distinct: for any *i*<=≠<=*j* we must have *D**i*<=≠<=*D**j*.
If there are multiple tests, print any of them. You can print denominations in atbitrary order. | [
"18\n",
"3\n",
"314\n"
] | [
"30 4\n1 5 10 25\n",
"20 2\n5 2\n",
"183 4\n6 5 2 139\n"
] | none | [
{
"input": "18",
"output": "30 4\n1 5 10 25"
},
{
"input": "3",
"output": "20 2\n5 2"
},
{
"input": "314",
"output": "183 4\n6 5 2 139"
},
{
"input": "1023",
"output": "2045 2\n1 2"
},
{
"input": "100000",
"output": "199999 2\n1 2"
},
{
"input": "1",
... | 62 | 0 | 3 | 5,391 | |
0 | none | [
"none"
] | null | null | Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to . Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles. | The first and the single line of the input contains 6 space-separated integers *a*1,<=*a*2,<=*a*3,<=*a*4,<=*a*5 and *a*6 (1<=≤<=*a**i*<=≤<=1000) — the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists. | Print a single integer — the number of triangles with the sides of one 1 centimeter, into which the hexagon is split. | [
"1 1 1 1 1 1\n",
"1 2 1 2 1 2\n"
] | [
"6\n",
"13\n"
] | This is what Gerald's hexagon looks like in the first sample:
<img class="tex-graphics" src="https://espresso.codeforces.com/84d193e27b02c38eb1eadc536602a2ec0b9f9519.png" style="max-width: 100.0%;max-height: 100.0%;"/>
And that's what it looks like in the second sample:
<img class="tex-graphics" src="https://espresso.codeforces.com/e29076a96da8ca864654cc6195654d9bf07d31ce.png" style="max-width: 100.0%;max-height: 100.0%;"/> | [
{
"input": "1 1 1 1 1 1",
"output": "6"
},
{
"input": "1 2 1 2 1 2",
"output": "13"
},
{
"input": "2 4 5 3 3 6",
"output": "83"
},
{
"input": "45 19 48 18 46 21",
"output": "6099"
},
{
"input": "66 6 65 6 66 5",
"output": "5832"
},
{
"input": "7 5 4 8 ... | 77 | 0 | 0 | 5,397 | |
374 | Inna and Nine | [
"combinatorics",
"greedy"
] | null | null | Inna loves digit 9 very much. That's why she asked Dima to write a small number consisting of nines. But Dima must have misunderstood her and he wrote a very large number *a*, consisting of digits from 1 to 9.
Inna wants to slightly alter the number Dima wrote so that in the end the number contained as many digits nine as possible. In one move, Inna can choose two adjacent digits in a number which sum equals 9 and replace them by a single digit 9.
For instance, Inna can alter number 14545181 like this: 14545181<=→<=1945181<=→<=194519<=→<=19919. Also, she can use this method to transform number 14545181 into number 19991. Inna will not transform it into 149591 as she can get numbers 19919 and 19991 which contain more digits nine.
Dima is a programmer so he wants to find out how many distinct numbers containing as many digits nine as possible Inna can get from the written number. Help him with this challenging task. | The first line of the input contains integer *a* (1<=≤<=*a*<=≤<=10100000). Number *a* doesn't have any zeroes. | In a single line print a single integer — the answer to the problem. It is guaranteed that the answer to the problem doesn't exceed 263<=-<=1.
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. | [
"369727\n",
"123456789987654321\n",
"1\n"
] | [
"2\n",
"1\n",
"1\n"
] | Notes to the samples
In the first sample Inna can get the following numbers: 369727 → 99727 → 9997, 369727 → 99727 → 9979.
In the second sample, Inna can act like this: 123456789987654321 → 12396789987654321 → 1239678998769321. | [
{
"input": "369727",
"output": "2"
},
{
"input": "123456789987654321",
"output": "1"
},
{
"input": "1",
"output": "1"
},
{
"input": "3636363636363454545454543636363636454545452727272727218181818181999111777",
"output": "1512"
},
{
"input": "1188",
"output": "1... | 124 | 1,945,600 | 3 | 5,398 | |
1,006 | Two Strings Swaps | [
"implementation"
] | null | null | You are given two strings $a$ and $b$ consisting of lowercase English letters, both of length $n$. The characters of both strings have indices from $1$ to $n$, inclusive.
You are allowed to do the following changes:
- Choose any index $i$ ($1 \le i \le n$) and swap characters $a_i$ and $b_i$; - Choose any index $i$ ($1 \le i \le n$) and swap characters $a_i$ and $a_{n - i + 1}$; - Choose any index $i$ ($1 \le i \le n$) and swap characters $b_i$ and $b_{n - i + 1}$.
Note that if $n$ is odd, you are formally allowed to swap $a_{\lceil\frac{n}{2}\rceil}$ with $a_{\lceil\frac{n}{2}\rceil}$ (and the same with the string $b$) but this move is useless. Also you can swap two equal characters but this operation is useless as well.
You have to make these strings equal by applying any number of changes described above, in any order. But it is obvious that it may be impossible to make two strings equal by these swaps.
In one preprocess move you can replace a character in $a$ with another character. In other words, in a single preprocess move you can choose any index $i$ ($1 \le i \le n$), any character $c$ and set $a_i := c$.
Your task is to find the minimum number of preprocess moves to apply in such a way that after them you can make strings $a$ and $b$ equal by applying some number of changes described in the list above.
Note that the number of changes you make after the preprocess moves does not matter. Also note that you cannot apply preprocess moves to the string $b$ or make any preprocess moves after the first change is made. | The first line of the input contains one integer $n$ ($1 \le n \le 10^5$) — the length of strings $a$ and $b$.
The second line contains the string $a$ consisting of exactly $n$ lowercase English letters.
The third line contains the string $b$ consisting of exactly $n$ lowercase English letters. | Print a single integer — the minimum number of preprocess moves to apply before changes, so that it is possible to make the string $a$ equal to string $b$ with a sequence of changes from the list above. | [
"7\nabacaba\nbacabaa\n",
"5\nzcabd\ndbacz\n"
] | [
"4\n",
"0\n"
] | In the first example preprocess moves are as follows: $a_1 := $'b', $a_3 := $'c', $a_4 := $'a' and $a_5:=$'b'. Afterwards, $a = $"bbcabba". Then we can obtain equal strings by the following sequence of changes: $swap(a_2, b_2)$ and $swap(a_2, a_6)$. There is no way to use fewer than $4$ preprocess moves before a sequence of changes to make string equal, so the answer in this example is $4$.
In the second example no preprocess moves are required. We can use the following sequence of changes to make $a$ and $b$ equal: $swap(b_1, b_5)$, $swap(a_2, a_4)$. | [
{
"input": "7\nabacaba\nbacabaa",
"output": "4"
},
{
"input": "5\nzcabd\ndbacz",
"output": "0"
},
{
"input": "1\na\nb",
"output": "1"
},
{
"input": "5\nahmad\nyogaa",
"output": "3"
}
] | 124 | 3,993,600 | 0 | 5,415 | |
1,000 | One Occurrence | [
"data structures",
"divide and conquer"
] | null | null | You are given an array $a$ consisting of $n$ integers, and $q$ queries to it. $i$-th query is denoted by two integers $l_i$ and $r_i$. For each query, you have to find any integer that occurs exactly once in the subarray of $a$ from index $l_i$ to index $r_i$ (a subarray is a contiguous subsegment of an array). For example, if $a = [1, 1, 2, 3, 2, 4]$, then for query $(l_i = 2, r_i = 6)$ the subarray we are interested in is $[1, 2, 3, 2, 4]$, and possible answers are $1$, $3$ and $4$; for query $(l_i = 1, r_i = 2)$ the subarray we are interested in is $[1, 1]$, and there is no such element that occurs exactly once.
Can you answer all of the queries? | The first line contains one integer $n$ ($1 \le n \le 5 \cdot 10^5$).
The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 5 \cdot 10^5$).
The third line contains one integer $q$ ($1 \le q \le 5 \cdot 10^5$).
Then $q$ lines follow, $i$-th line containing two integers $l_i$ and $r_i$ representing $i$-th query ($1 \le l_i \le r_i \le n$). | Answer the queries as follows:
If there is no integer such that it occurs in the subarray from index $l_i$ to index $r_i$ exactly once, print $0$. Otherwise print any such integer. | [
"6\n1 1 2 3 2 4\n2\n2 6\n1 2\n"
] | [
"4\n0\n"
] | none | [
{
"input": "6\n1 1 2 3 2 4\n2\n2 6\n1 2",
"output": "4\n0"
},
{
"input": "10\n5 9 6 4 8 7 4 9 7 6\n10\n4 9\n4 7\n4 7\n4 8\n9 10\n4 9\n4 8\n1 5\n4 4\n2 5",
"output": "8\n8\n8\n8\n6\n8\n8\n8\n4\n9"
}
] | 30 | 0 | 0 | 5,456 | |
461 | Appleman and Tree | [
"dfs and similar",
"dp",
"trees"
] | null | null | Appleman has a tree with *n* vertices. Some of the vertices (at least one) are colored black and other vertices are colored white.
Consider a set consisting of *k* (0<=≤<=*k*<=<<=*n*) edges of Appleman's tree. If Appleman deletes these edges from the tree, then it will split into (*k*<=+<=1) parts. Note, that each part will be a tree with colored vertices.
Now Appleman wonders, what is the number of sets splitting the tree in such a way that each resulting part will have exactly one black vertex? Find this number modulo 1000000007 (109<=+<=7). | The first line contains an integer *n* (2<=<=≤<=*n*<=≤<=105) — the number of tree vertices.
The second line contains the description of the tree: *n*<=-<=1 integers *p*0,<=*p*1,<=...,<=*p**n*<=-<=2 (0<=≤<=*p**i*<=≤<=*i*). Where *p**i* means that there is an edge connecting vertex (*i*<=+<=1) of the tree and vertex *p**i*. Consider tree vertices are numbered from 0 to *n*<=-<=1.
The third line contains the description of the colors of the vertices: *n* integers *x*0,<=*x*1,<=...,<=*x**n*<=-<=1 (*x**i* is either 0 or 1). If *x**i* is equal to 1, vertex *i* is colored black. Otherwise, vertex *i* is colored white. | Output a single integer — the number of ways to split the tree modulo 1000000007 (109<=+<=7). | [
"3\n0 0\n0 1 1\n",
"6\n0 1 1 0 4\n1 1 0 0 1 0\n",
"10\n0 1 2 1 4 4 4 0 8\n0 0 0 1 0 1 1 0 0 1\n"
] | [
"2\n",
"1\n",
"27\n"
] | none | [
{
"input": "3\n0 0\n0 1 1",
"output": "2"
},
{
"input": "6\n0 1 1 0 4\n1 1 0 0 1 0",
"output": "1"
},
{
"input": "10\n0 1 2 1 4 4 4 0 8\n0 0 0 1 0 1 1 0 0 1",
"output": "27"
},
{
"input": "5\n0 1 1 3\n0 0 0 1 1",
"output": "1"
},
{
"input": "10\n0 1 1 2 4 3 3 3 2\... | 31 | 0 | 0 | 5,469 | |
622 | Ants in Leaves | [
"dfs and similar",
"greedy",
"sortings",
"trees"
] | null | null | Tree is a connected graph without cycles. A leaf of a tree is any vertex connected with exactly one other vertex.
You are given a tree with *n* vertices and a root in the vertex 1. There is an ant in each leaf of the tree. In one second some ants can simultaneously go to the parent vertex from the vertex they were in. No two ants can be in the same vertex simultaneously except for the root of the tree.
Find the minimal time required for all ants to be in the root of the tree. Note that at start the ants are only in the leaves of the tree. | The first line contains integer *n* (2<=≤<=*n*<=≤<=5·105) — the number of vertices in the tree.
Each of the next *n*<=-<=1 lines contains two integers *x**i*,<=*y**i* (1<=≤<=*x**i*,<=*y**i*<=≤<=*n*) — the ends of the *i*-th edge. It is guaranteed that you are given the correct undirected tree. | Print the only integer *t* — the minimal time required for all ants to be in the root of the tree. | [
"12\n1 2\n1 3\n1 4\n2 5\n2 6\n3 7\n3 8\n3 9\n8 10\n8 11\n8 12\n",
"2\n2 1\n"
] | [
"6\n",
"1\n"
] | none | [
{
"input": "12\n1 2\n1 3\n1 4\n2 5\n2 6\n3 7\n3 8\n3 9\n8 10\n8 11\n8 12",
"output": "6"
},
{
"input": "2\n2 1",
"output": "1"
},
{
"input": "2\n2 1",
"output": "1"
},
{
"input": "10\n4 10\n6 10\n10 5\n10 7\n8 10\n4 2\n9 10\n4 1\n3 10",
"output": "8"
},
{
"input":... | 30 | 0 | 0 | 5,479 | |
14 | Two Paths | [
"dfs and similar",
"dp",
"graphs",
"shortest paths",
"trees",
"two pointers"
] | D. Two Paths | 2 | 64 | As you know, Bob's brother lives in Flatland. In Flatland there are *n* cities, connected by *n*<=-<=1 two-way roads. The cities are numbered from 1 to *n*. You can get from one city to another moving along the roads.
The «Two Paths» company, where Bob's brother works, has won a tender to repair two paths in Flatland. A path is a sequence of different cities, connected sequentially by roads. The company is allowed to choose by itself the paths to repair. The only condition they have to meet is that the two paths shouldn't cross (i.e. shouldn't have common cities).
It is known that the profit, the «Two Paths» company will get, equals the product of the lengths of the two paths. Let's consider the length of each road equals 1, and the length of a path equals the amount of roads in it. Find the maximum possible profit for the company. | The first line contains an integer *n* (2<=≤<=*n*<=≤<=200), where *n* is the amount of cities in the country. The following *n*<=-<=1 lines contain the information about the roads. Each line contains a pair of numbers of the cities, connected by the road *a**i*,<=*b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*). | Output the maximum possible profit. | [
"4\n1 2\n2 3\n3 4\n",
"7\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n",
"6\n1 2\n2 3\n2 4\n5 4\n6 4\n"
] | [
"1\n",
"0\n",
"4\n"
] | none | [
{
"input": "4\n1 2\n2 3\n3 4",
"output": "1"
},
{
"input": "7\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7",
"output": "0"
},
{
"input": "6\n1 2\n2 3\n2 4\n5 4\n6 4",
"output": "4"
},
{
"input": "2\n2 1",
"output": "0"
},
{
"input": "3\n3 1\n1 2",
"output": "0"
},
{
... | 92 | 0 | 0 | 5,495 |
613 | Skills | [
"binary search",
"brute force",
"dp",
"greedy",
"sortings",
"two pointers"
] | null | null | Lesha plays the recently published new version of the legendary game hacknet. In this version character skill mechanism was introduced. Now, each player character has exactly *n* skills. Each skill is represented by a non-negative integer *a**i* — the current skill level. All skills have the same maximum level *A*.
Along with the skills, global ranking of all players was added. Players are ranked according to the so-called Force. The Force of a player is the sum of the following values:
- The number of skills that a character has perfected (i.e., such that *a**i*<==<=*A*), multiplied by coefficient *c**f*.- The minimum skill level among all skills (*min* *a**i*), multiplied by coefficient *c**m*.
Now Lesha has *m* hacknetian currency units, which he is willing to spend. Each currency unit can increase the current level of any skill by 1 (if it's not equal to *A* yet). Help him spend his money in order to achieve the maximum possible value of the Force. | The first line of the input contains five space-separated integers *n*, *A*, *c**f*, *c**m* and *m* (1<=≤<=*n*<=≤<=100<=000, 1<=≤<=*A*<=≤<=109, 0<=≤<=*c**f*,<=*c**m*<=≤<=1000, 0<=≤<=*m*<=≤<=1015).
The second line contains exactly *n* integers *a**i* (0<=≤<=*a**i*<=≤<=*A*), separated by spaces, — the current levels of skills. | On the first line print the maximum value of the Force that the character can achieve using no more than *m* currency units.
On the second line print *n* integers *a*'*i* (*a**i*<=≤<=*a*'*i*<=≤<=*A*), skill levels which one must achieve in order to reach the specified value of the Force, while using no more than *m* currency units. Numbers should be separated by spaces. | [
"3 5 10 1 5\n1 3 1\n",
"3 5 10 1 339\n1 3 1\n"
] | [
"12\n2 5 2 \n",
"35\n5 5 5 \n"
] | In the first test the optimal strategy is to increase the second skill to its maximum, and increase the two others by 1.
In the second test one should increase all skills to maximum. | [
{
"input": "3 5 10 1 5\n1 3 1",
"output": "12\n2 5 2 "
},
{
"input": "3 5 10 1 339\n1 3 1",
"output": "35\n5 5 5 "
},
{
"input": "2 6 0 1 4\n5 1",
"output": "5\n5 5 "
},
{
"input": "1 1000000000 1000 1000 1000000000000000\n0",
"output": "1000000001000\n1000000000 "
},
... | 31 | 0 | 0 | 5,502 | |
706 | Vasiliy's Multiset | [
"binary search",
"bitmasks",
"data structures",
"trees"
] | null | null | Author has gone out of the stories about Vasiliy, so here is just a formal task description.
You are given *q* queries and a multiset *A*, initially containing only integer 0. There are three types of queries:
1. "+ x" — add integer *x* to multiset *A*.1. "- x" — erase one occurrence of integer *x* from multiset *A*. It's guaranteed that at least one *x* is present in the multiset *A* before this query.1. "? x" — you are given integer *x* and need to compute the value , i.e. the maximum value of bitwise exclusive OR (also know as XOR) of integer *x* and some integer *y* from the multiset *A*.
Multiset is a set, where equal elements are allowed. | The first line of the input contains a single integer *q* (1<=≤<=*q*<=≤<=200<=000) — the number of queries Vasiliy has to perform.
Each of the following *q* lines of the input contains one of three characters '+', '-' or '?' and an integer *x**i* (1<=≤<=*x**i*<=≤<=109). It's guaranteed that there is at least one query of the third type.
Note, that the integer 0 will always be present in the set *A*. | For each query of the type '?' print one integer — the maximum value of bitwise exclusive OR (XOR) of integer *x**i* and some integer from the multiset *A*. | [
"10\n+ 8\n+ 9\n+ 11\n+ 6\n+ 1\n? 3\n- 8\n? 3\n? 8\n? 11\n"
] | [
"11\n10\n14\n13\n"
] | After first five operations multiset *A* contains integers 0, 8, 9, 11, 6 and 1.
The answer for the sixth query is integer <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/9e2f3d4f1a7c134a5695ba1d548df2b4f9292206.png" style="max-width: 100.0%;max-height: 100.0%;"/> — maximum among integers <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/6cb1b5a0f9bbad177b1de700e918187c8fb3e972.png" style="max-width: 100.0%;max-height: 100.0%;"/>, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/7644536d2010111824755b5dd2b6043340b2bf4d.png" style="max-width: 100.0%;max-height: 100.0%;"/>, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/9a437d1611f6c2ae5cd9a275a6ab2df61296988e.png" style="max-width: 100.0%;max-height: 100.0%;"/>, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/4e3eeab99fa495ecdcd103c68de47dd72943016f.png" style="max-width: 100.0%;max-height: 100.0%;"/> and <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/97b73b0f3e59862ed9f80fa83527d97e0ed0a084.png" style="max-width: 100.0%;max-height: 100.0%;"/>. | [
{
"input": "10\n+ 8\n+ 9\n+ 11\n+ 6\n+ 1\n? 3\n- 8\n? 3\n? 8\n? 11",
"output": "11\n10\n14\n13"
},
{
"input": "12\n+ 4\n+ 4\n+ 5\n? 3\n- 4\n? 3\n- 4\n? 3\n? 3\n- 5\n+ 10\n? 1",
"output": "7\n7\n6\n6\n11"
},
{
"input": "10\n? 1\n+ 1\n+ 8\n- 1\n+ 2\n+ 7\n+ 4\n+ 7\n+ 3\n? 7",
"output": ... | 2,869 | 268,390,400 | 0 | 5,510 | |
877 | Olya and Energy Drinks | [
"data structures",
"dfs and similar",
"graphs",
"shortest paths"
] | null | null | Olya loves energy drinks. She loves them so much that her room is full of empty cans from energy drinks.
Formally, her room can be represented as a field of *n*<=×<=*m* cells, each cell of which is empty or littered with cans.
Olya drank a lot of energy drink, so now she can run *k* meters per second. Each second she chooses one of the four directions (up, down, left or right) and runs from 1 to *k* meters in this direction. Of course, she can only run through empty cells.
Now Olya needs to get from cell (*x*1,<=*y*1) to cell (*x*2,<=*y*2). How many seconds will it take her if she moves optimally?
It's guaranteed that cells (*x*1,<=*y*1) and (*x*2,<=*y*2) are empty. These cells can coincide. | The first line contains three integers *n*, *m* and *k* (1<=≤<=*n*,<=*m*,<=*k*<=≤<=1000) — the sizes of the room and Olya's speed.
Then *n* lines follow containing *m* characters each, the *i*-th of them contains on *j*-th position "#", if the cell (*i*,<=*j*) is littered with cans, and "." otherwise.
The last line contains four integers *x*1,<=*y*1,<=*x*2,<=*y*2 (1<=≤<=*x*1,<=*x*2<=≤<=*n*, 1<=≤<=*y*1,<=*y*2<=≤<=*m*) — the coordinates of the first and the last cells. | Print a single integer — the minimum time it will take Olya to get from (*x*1,<=*y*1) to (*x*2,<=*y*2).
If it's impossible to get from (*x*1,<=*y*1) to (*x*2,<=*y*2), print -1. | [
"3 4 4\n....\n###.\n....\n1 1 3 1\n",
"3 4 1\n....\n###.\n....\n1 1 3 1\n",
"2 2 1\n.#\n#.\n1 1 2 2\n"
] | [
"3",
"8",
"-1"
] | In the first sample Olya should run 3 meters to the right in the first second, 2 meters down in the second second and 3 meters to the left in the third second.
In second sample Olya should run to the right for 3 seconds, then down for 2 seconds and then to the left for 3 seconds.
Olya does not recommend drinking energy drinks and generally believes that this is bad. | [
{
"input": "3 4 4\n....\n###.\n....\n1 1 3 1",
"output": "3"
},
{
"input": "3 4 1\n....\n###.\n....\n1 1 3 1",
"output": "8"
},
{
"input": "2 2 1\n.#\n#.\n1 1 2 2",
"output": "-1"
},
{
"input": "10 10 1\n##########\n#.........\n#.#######.\n#.#.....#.\n#.#.###.#.\n#.#.#.#.#.\n... | 124 | 5,222,400 | 0 | 5,513 | |
858 | Polycarp's phone book | [
"data structures",
"implementation",
"sortings"
] | null | null | There are *n* phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
- if he enters 00 two numbers will show up: 100000000 and 100123456, - if he enters 123 two numbers will show up 123456789 and 100123456, - if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number. | The first line contains single integer *n* (1<=≤<=*n*<=≤<=70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct. | Print exactly *n* lines: the *i*-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the *i*-th number from the contacts. If there are several such sequences, print any of them. | [
"3\n123456789\n100000000\n100123456\n",
"4\n123456789\n193456789\n134567819\n934567891\n"
] | [
"9\n000\n01\n",
"2\n193\n81\n91\n"
] | none | [
{
"input": "3\n123456789\n100000000\n100123456",
"output": "9\n000\n01"
},
{
"input": "4\n123456789\n193456789\n134567819\n934567891",
"output": "2\n193\n81\n91"
},
{
"input": "1\n167038488",
"output": "4"
},
{
"input": "5\n115830748\n403459907\n556271610\n430358099\n41396141... | 4,000 | 8,806,400 | 0 | 5,517 | |
821 | Okabe and City | [
"dfs and similar",
"graphs",
"shortest paths"
] | null | null | Okabe likes to be able to walk through his city on a path lit by street lamps. That way, he doesn't get beaten up by schoolchildren.
Okabe's city is represented by a 2D grid of cells. Rows are numbered from 1 to *n* from top to bottom, and columns are numbered 1 to *m* from left to right. Exactly *k* cells in the city are lit by a street lamp. It's guaranteed that the top-left cell is lit.
Okabe starts his walk from the top-left cell, and wants to reach the bottom-right cell. Of course, Okabe will only walk on lit cells, and he can only move to adjacent cells in the up, down, left, and right directions. However, Okabe can also temporarily light all the cells in any single row or column at a time if he pays 1 coin, allowing him to walk through some cells not lit initially.
Note that Okabe can only light a single row or column at a time, and has to pay a coin every time he lights a new row or column. To change the row or column that is temporarily lit, he must stand at a cell that is lit initially. Also, once he removes his temporary light from a row or column, all cells in that row/column not initially lit are now not lit.
Help Okabe find the minimum number of coins he needs to pay to complete his walk! | The first line of input contains three space-separated integers *n*, *m*, and *k* (2<=≤<=*n*,<=*m*,<=*k*<=≤<=104).
Each of the next *k* lines contains two space-separated integers *r**i* and *c**i* (1<=≤<=*r**i*<=≤<=*n*, 1<=≤<=*c**i*<=≤<=*m*) — the row and the column of the *i*-th lit cell.
It is guaranteed that all *k* lit cells are distinct. It is guaranteed that the top-left cell is lit. | Print the minimum number of coins Okabe needs to pay to complete his walk, or -1 if it's not possible. | [
"4 4 5\n1 1\n2 1\n2 3\n3 3\n4 3\n",
"5 5 4\n1 1\n2 1\n3 1\n3 2\n",
"2 2 4\n1 1\n1 2\n2 1\n2 2\n",
"5 5 4\n1 1\n2 2\n3 3\n4 4\n"
] | [
"2\n",
"-1\n",
"0\n",
"3\n"
] | In the first sample test, Okabe can take the path <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/fd8d0b719801e9cfe8f6be340d76a554f6ffb66b.png" style="max-width: 100.0%;max-height: 100.0%;"/>, paying only when moving to (2, 3) and (4, 4).
In the fourth sample, Okabe can take the path <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/a91fe94734a09a4ba86d66070aa8cbeacdb2279f.png" style="max-width: 100.0%;max-height: 100.0%;"/> <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/2ee6688fe94ce8e9a746b8e479e906fe25ff4d86.png" style="max-width: 100.0%;max-height: 100.0%;"/>, paying when moving to (1, 2), (3, 4), and (5, 4). | [
{
"input": "4 4 5\n1 1\n2 1\n2 3\n3 3\n4 3",
"output": "2"
},
{
"input": "5 5 4\n1 1\n2 1\n3 1\n3 2",
"output": "-1"
},
{
"input": "2 2 4\n1 1\n1 2\n2 1\n2 2",
"output": "0"
},
{
"input": "5 5 4\n1 1\n2 2\n3 3\n4 4",
"output": "3"
},
{
"input": "7 10 53\n1 1\n7 5\... | 109 | 0 | 0 | 5,534 | |
0 | none | [
"none"
] | null | null | Peter got a new snow blower as a New Year present. Of course, Peter decided to try it immediately. After reading the instructions he realized that it does not work like regular snow blowing machines. In order to make it work, you need to tie it to some point that it does not cover, and then switch it on. As a result it will go along a circle around this point and will remove all the snow from its path.
Formally, we assume that Peter's machine is a polygon on a plane. Then, after the machine is switched on, it will make a circle around the point to which Peter tied it (this point lies strictly outside the polygon). That is, each of the points lying within or on the border of the polygon will move along the circular trajectory, with the center of the circle at the point to which Peter tied his machine.
Peter decided to tie his car to point *P* and now he is wondering what is the area of ​​the region that will be cleared from snow. Help him. | The first line of the input contains three integers — the number of vertices of the polygon *n* (), and coordinates of point *P*.
Each of the next *n* lines contains two integers — coordinates of the vertices of the polygon in the clockwise or counterclockwise order. It is guaranteed that no three consecutive vertices lie on a common straight line.
All the numbers in the input are integers that do not exceed 1<=000<=000 in their absolute value. | Print a single real value number — the area of the region that will be cleared. Your answer will be considered correct if its absolute or relative error does not exceed 10<=-<=6.
Namely: let's assume that your answer is *a*, and the answer of the jury is *b*. The checker program will consider your answer correct, if . | [
"3 0 0\n0 1\n-1 2\n1 2\n",
"4 1 -1\n0 0\n1 2\n2 0\n1 1\n"
] | [
"12.566370614359172464\n",
"21.991148575128551812\n"
] | In the first sample snow will be removed from that area: | [
{
"input": "3 0 0\n0 1\n-1 2\n1 2",
"output": "12.566370614359172464"
},
{
"input": "4 1 -1\n0 0\n1 2\n2 0\n1 1",
"output": "21.991148575128551812"
},
{
"input": "3 0 0\n-1 1\n0 3\n1 1",
"output": "25.132741228718344928"
},
{
"input": "3 -4 2\n-3 2\n5 -5\n5 3",
"output": ... | 46 | 307,200 | 0 | 5,543 | |
441 | Valera and Tubes | [
"constructive algorithms",
"dfs and similar",
"implementation"
] | null | null | Valera has got a rectangle table consisting of *n* rows and *m* columns. Valera numbered the table rows starting from one, from top to bottom and the columns – starting from one, from left to right. We will represent cell that is on the intersection of row *x* and column *y* by a pair of integers (*x*,<=*y*).
Valera wants to place exactly *k* tubes on his rectangle table. A tube is such sequence of table cells (*x*1,<=*y*1), (*x*2,<=*y*2), ..., (*x**r*,<=*y**r*), that:
- *r*<=≥<=2; - for any integer *i* (1<=≤<=*i*<=≤<=*r*<=-<=1) the following equation |*x**i*<=-<=*x**i*<=+<=1|<=+<=|*y**i*<=-<=*y**i*<=+<=1|<==<=1 holds; - each table cell, which belongs to the tube, must occur exactly once in the sequence.
Valera thinks that the tubes are arranged in a fancy manner if the following conditions are fulfilled:
- no pair of tubes has common cells; - each cell of the table belongs to some tube.
Help Valera to arrange *k* tubes on his rectangle table in a fancy manner. | The first line contains three space-separated integers *n*,<=*m*,<=*k* (2<=≤<=*n*,<=*m*<=≤<=300; 2<=≤<=2*k*<=≤<=*n*·*m*) — the number of rows, the number of columns and the number of tubes, correspondingly. | Print *k* lines. In the *i*-th line print the description of the *i*-th tube: first print integer *r**i* (the number of tube cells), then print 2*r**i* integers *x**i*1,<=*y**i*1,<=*x**i*2,<=*y**i*2,<=...,<=*x**ir**i*,<=*y**ir**i* (the sequence of table cells).
If there are multiple solutions, you can print any of them. It is guaranteed that at least one solution exists. | [
"3 3 3\n",
"2 3 1\n"
] | [
"3 1 1 1 2 1 3\n3 2 1 2 2 2 3\n3 3 1 3 2 3 3\n",
"6 1 1 1 2 1 3 2 3 2 2 2 1\n"
] | Picture for the first sample:
Picture for the second sample: | [
{
"input": "3 3 3",
"output": "3 1 1 1 2 1 3\n3 2 1 2 2 2 3\n3 3 1 3 2 3 3"
},
{
"input": "2 3 1",
"output": "6 1 1 1 2 1 3 2 3 2 2 2 1"
},
{
"input": "2 3 1",
"output": "6 1 1 1 2 1 3 2 3 2 2 2 1"
},
{
"input": "300 300 2",
"output": "2 1 1 1 2\n89998 1 3 1 4 1 5 1 6 1 7... | 233 | 10,240,000 | -1 | 5,556 | |
622 | The Time | [
"implementation"
] | null | null | You are given the current time in 24-hour format hh:mm. Find and print the time after *a* minutes.
Note that you should find only the time after *a* minutes, see the examples to clarify the problem statement.
You can read more about 24-hour format here [https://en.wikipedia.org/wiki/24-hour_clock](https://en.wikipedia.org/wiki/24-hour_clock). | The first line contains the current time in the format hh:mm (0<=≤<=*hh*<=<<=24,<=0<=≤<=*mm*<=<<=60). The hours and the minutes are given with two digits (the hours or the minutes less than 10 are given with the leading zeroes).
The second line contains integer *a* (0<=≤<=*a*<=≤<=104) — the number of the minutes passed. | The only line should contain the time after *a* minutes in the format described in the input. Note that you should print exactly two digits for the hours and the minutes (add leading zeroes to the numbers if needed).
See the examples to check the input/output format. | [
"23:59\n10\n",
"20:20\n121\n",
"10:10\n0\n"
] | [
"00:09\n",
"22:21\n",
"10:10\n"
] | none | [
{
"input": "23:59\n10",
"output": "00:09"
},
{
"input": "20:20\n121",
"output": "22:21"
},
{
"input": "10:10\n0",
"output": "10:10"
},
{
"input": "12:34\n10000",
"output": "11:14"
},
{
"input": "00:00\n10000",
"output": "22:40"
},
{
"input": "00:00\n14... | 217 | 307,200 | 3 | 5,557 | |
430 | Balls Game | [
"brute force",
"two pointers"
] | null | null | Iahub is training for the IOI. What is a better way to train than playing a Zuma-like game?
There are *n* balls put in a row. Each ball is colored in one of *k* colors. Initially the row doesn't contain three or more contiguous balls with the same color. Iahub has a single ball of color *x*. He can insert his ball at any position in the row (probably, between two other balls). If at any moment there are three or more contiguous balls of the same color in the row, they are destroyed immediately. This rule is applied multiple times, until there are no more sets of 3 or more contiguous balls of the same color.
For example, if Iahub has the row of balls [black, black, white, white, black, black] and a white ball, he can insert the ball between two white balls. Thus three white balls are destroyed, and then four black balls become contiguous, so all four balls are destroyed. The row will not contain any ball in the end, so Iahub can destroy all 6 balls.
Iahub wants to destroy as many balls as possible. You are given the description of the row of balls, and the color of Iahub's ball. Help Iahub train for the IOI by telling him the maximum number of balls from the row he can destroy. | The first line of input contains three integers: *n* (1<=≤<=*n*<=≤<=100), *k* (1<=≤<=*k*<=≤<=100) and *x* (1<=≤<=*x*<=≤<=*k*). The next line contains *n* space-separated integers *c*1,<=*c*2,<=...,<=*c**n* (1<=≤<=*c**i*<=≤<=*k*). Number *c**i* means that the *i*-th ball in the row has color *c**i*.
It is guaranteed that the initial row of balls will never contain three or more contiguous balls of the same color. | Print a single integer — the maximum number of balls Iahub can destroy. | [
"6 2 2\n1 1 2 2 1 1\n",
"1 1 1\n1\n"
] | [
"6\n",
"0\n"
] | none | [
{
"input": "6 2 2\n1 1 2 2 1 1",
"output": "6"
},
{
"input": "1 1 1\n1",
"output": "0"
},
{
"input": "10 2 1\n2 1 2 2 1 2 2 1 1 2",
"output": "5"
},
{
"input": "50 2 1\n1 1 2 2 1 2 1 1 2 2 1 2 1 2 1 1 2 2 1 2 1 2 2 1 2 1 2 1 2 2 1 1 2 2 1 1 2 2 1 2 1 1 2 1 1 2 2 1 1 2",
"... | 140 | 614,400 | 3 | 5,558 | |
899 | Months and Years | [
"implementation"
] | null | null | Everybody in Russia uses Gregorian calendar. In this calendar there are 31 days in January, 28 or 29 days in February (depending on whether the year is leap or not), 31 days in March, 30 days in April, 31 days in May, 30 in June, 31 in July, 31 in August, 30 in September, 31 in October, 30 in November, 31 in December.
A year is leap in one of two cases: either its number is divisible by 4, but not divisible by 100, or is divisible by 400. For example, the following years are leap: 2000, 2004, but years 1900 and 2018 are not leap.
In this problem you are given *n* (1<=≤<=*n*<=≤<=24) integers *a*1,<=*a*2,<=...,<=*a**n*, and you have to check if these integers could be durations in days of *n* consecutive months, according to Gregorian calendar. Note that these months could belong to several consecutive years. In other words, check if there is a month in some year, such that its duration is *a*1 days, duration of the next month is *a*2 days, and so on. | The first line contains single integer *n* (1<=≤<=*n*<=≤<=24) — the number of integers.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (28<=≤<=*a**i*<=≤<=31) — the numbers you are to check. | If there are several consecutive months that fit the sequence, print "YES" (without quotes). Otherwise, print "NO" (without quotes).
You can print each letter in arbitrary case (small or large). | [
"4\n31 31 30 31\n",
"2\n30 30\n",
"5\n29 31 30 31 30\n",
"3\n31 28 30\n",
"3\n31 31 28\n"
] | [
"Yes\n\n",
"No\n\n",
"Yes\n\n",
"No\n\n",
"Yes\n\n"
] | In the first example the integers can denote months July, August, September and October.
In the second example the answer is no, because there are no two consecutive months each having 30 days.
In the third example the months are: February (leap year) — March — April – May — June.
In the fourth example the number of days in the second month is 28, so this is February. March follows February and has 31 days, but not 30, so the answer is NO.
In the fifth example the months are: December — January — February (non-leap year). | [
{
"input": "4\n31 31 30 31",
"output": "Yes"
},
{
"input": "2\n30 30",
"output": "No"
},
{
"input": "5\n29 31 30 31 30",
"output": "Yes"
},
{
"input": "3\n31 28 30",
"output": "No"
},
{
"input": "3\n31 31 28",
"output": "Yes"
},
{
"input": "24\n29 28 3... | 46 | 0 | 0 | 5,577 | |
0 | none | [
"none"
] | null | null | 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*<=≤<=*r*) are suitable for pair programming. They decided that the day *i* (*l*<=≤<=*i*<=≤<=*r*) is suitable for pair programming if and only if the number *i* is lucky for Peter and lucky for Bob at the same time. Help the boys to find the number of such days. | 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 | [] | 46 | 0 | 0 | 5,581 | |
397 | On Corruption and Numbers | [
"constructive algorithms",
"implementation",
"math"
] | null | null | Alexey, a merry Berland entrant, got sick of the gray reality and he zealously wants to go to university. There are a lot of universities nowadays, so Alexey is getting lost in the diversity — he has not yet decided what profession he wants to get. At school, he had bad grades in all subjects, and it's only thanks to wealthy parents that he was able to obtain the graduation certificate.
The situation is complicated by the fact that each high education institution has the determined amount of voluntary donations, paid by the new students for admission — *n**i* berubleys. He cannot pay more than *n**i*, because then the difference between the paid amount and *n**i* can be regarded as a bribe!
Each rector is wearing the distinctive uniform of his university. Therefore, the uniform's pockets cannot contain coins of denomination more than *r**i*. The rector also does not carry coins of denomination less than *l**i* in his pocket — because if everyone pays him with so small coins, they gather a lot of weight and the pocket tears. Therefore, a donation can be paid only by coins of denomination *x* berubleys, where *l**i*<=≤<=*x*<=≤<=*r**i* (Berland uses coins of any positive integer denomination). Alexey can use the coins of different denominations and he can use the coins of the same denomination any number of times. When Alexey was first confronted with such orders, he was puzzled because it turned out that not all universities can accept him! Alexey is very afraid of going into the army (even though he had long wanted to get the green uniform, but his dad says that the army bullies will beat his son and he cannot pay to ensure the boy's safety). So, Alexey wants to know for sure which universities he can enter so that he could quickly choose his alma mater.
Thanks to the parents, Alexey is not limited in money and we can assume that he has an unlimited number of coins of each type.
In other words, you are given *t* requests, each of them contains numbers *n**i*,<=*l**i*,<=*r**i*. For each query you need to answer, whether it is possible to gather the sum of exactly *n**i* berubleys using only coins with an integer denomination from *l**i* to *r**i* berubleys. You can use coins of different denominations. Coins of each denomination can be used any number of times. | The first line contains the number of universities *t*, (1<=≤<=*t*<=≤<=1000) Each of the next *t* lines contain three space-separated integers: *n**i*,<=*l**i*,<=*r**i* (1<=≤<=*n**i*,<=*l**i*,<=*r**i*<=≤<=109; *l**i*<=≤<=*r**i*). | For each query print on a single line: either "Yes", if Alexey can enter the university, or "No" otherwise. | [
"2\n5 2 3\n6 4 5\n"
] | [
"Yes\nNo\n"
] | You can pay the donation to the first university with two coins: one of denomination 2 and one of denomination 3 berubleys. The donation to the second university cannot be paid. | [
{
"input": "2\n5 2 3\n6 4 5",
"output": "Yes\nNo"
},
{
"input": "50\n69 6 6\n22 1 1\n23 3 3\n60 13 13\n13 3 3\n7 4 7\n6 1 1\n49 7 9\n68 8 8\n20 2 2\n34 1 1\n79 5 5\n22 1 1\n77 58 65\n10 3 3\n72 5 5\n47 1 1\n82 3 3\n92 8 8\n34 1 1\n42 9 10\n63 14 14\n10 3 3\n38 2 2\n80 6 6\n79 5 5\n53 5 5\n44 7 7\n85... | 93 | 0 | 0 | 5,582 | |
463 | Gargari and Permutations | [
"dfs and similar",
"dp",
"graphs",
"implementation"
] | null | null | Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found *k* permutations. Each of them consists of numbers 1,<=2,<=...,<=*n* in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem | The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=1000; 2<=≤<=*k*<=≤<=5). Each of the next *k* lines contains integers 1,<=2,<=...,<=*n* in some order — description of the current permutation. | Print the length of the longest common subsequence. | [
"4 3\n1 4 2 3\n4 1 2 3\n1 2 4 3\n"
] | [
"3\n"
] | The answer for the first test sample is subsequence [1, 2, 3]. | [
{
"input": "4 3\n1 4 2 3\n4 1 2 3\n1 2 4 3",
"output": "3"
},
{
"input": "6 3\n2 5 1 4 6 3\n5 1 4 3 2 6\n5 4 2 6 3 1",
"output": "3"
},
{
"input": "41 4\n24 15 17 35 13 41 4 14 23 5 8 16 21 18 30 36 6 22 11 29 26 1 40 31 7 3 32 10 28 38 12 20 39 37 34 19 33 27 2 25 9\n22 13 25 24 38 35 2... | 93 | 1,536,000 | 0 | 5,590 | |
305 | Continued Fractions | [
"brute force",
"implementation",
"math"
] | null | null | A continued fraction of height *n* is a fraction of form . You are given two rational numbers, one is represented as and the other one is represented as a finite fraction of height *n*. Check if they are equal. | The first line contains two space-separated integers *p*,<=*q* (1<=≤<=*q*<=≤<=*p*<=≤<=1018) — the numerator and the denominator of the first fraction.
The second line contains integer *n* (1<=≤<=*n*<=≤<=90) — the height of the second fraction. The third line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1018) — the continued fraction.
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. | Print "YES" if these fractions are equal and "NO" otherwise. | [
"9 4\n2\n2 4\n",
"9 4\n3\n2 3 1\n",
"9 4\n3\n1 2 4\n"
] | [
"YES\n",
"YES\n",
"NO\n"
] | In the first sample <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/5ff92f27aebea2560d99ad61202d20bab5ee5390.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
In the second sample <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/221368c79c05fc0ecad4e5f7a64f30b832fd99f5.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
In the third sample <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/4fb4b411afc0fbad27a1c8fdd08ba88ec3830ef5.png" style="max-width: 100.0%;max-height: 100.0%;"/>. | [
{
"input": "9 4\n2\n2 4",
"output": "YES"
},
{
"input": "9 4\n3\n2 3 1",
"output": "YES"
},
{
"input": "9 4\n3\n1 2 4",
"output": "NO"
},
{
"input": "39088169 24157817\n36\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2",
"output": "YES"
},
{
... | 248 | 20,172,800 | 0 | 5,600 | |
369 | Valera and Contest | [
"constructive algorithms",
"implementation",
"math"
] | null | null | Valera loves to participate in competitions. Especially in programming contests. Today he has participated in the contest with his team, consisting of *n* students (including Valera). This contest was an individual competition, so each student in the team solved problems individually.
After the contest was over, Valera was interested in results. He found out that:
- each student in the team scored at least *l* points and at most *r* points; - in total, all members of the team scored exactly *s**all* points; - the total score of the *k* members of the team who scored the most points is equal to exactly *s**k*; more formally, if *a*1,<=*a*2,<=...,<=*a**n* is the sequence of points earned by the team of students in the non-increasing order (*a*1<=≥<=*a*2<=≥<=...<=≥<=*a**n*), then *s**k*<==<=*a*1<=+<=*a*2<=+<=...<=+<=*a**k*.
However, Valera did not find out exactly how many points each of *n* students scored. Valera asked you to recover any distribution of scores between the students of the team, such that all the conditions above are met. | The first line of the input contains exactly six integers *n*,<=*k*,<=*l*,<=*r*,<=*s**all*,<=*s**k* (1<=≤<=*n*,<=*k*,<=*l*,<=*r*<=≤<=1000; *l*<=≤<=*r*; *k*<=≤<=*n*; 1<=≤<=*s**k*<=≤<=*s**all*<=≤<=106).
It's guaranteed that the input is such that the answer exists. | Print exactly *n* integers *a*1,<=*a*2,<=...,<=*a**n* — the number of points each student scored. If there are multiple solutions, you can print any of them. You can print the distribution of points in any order. | [
"5 3 1 3 13 9\n",
"5 3 1 3 15 9\n"
] | [
"2 3 2 3 3 ",
"3 3 3 3 3 "
] | none | [
{
"input": "5 3 1 3 13 9",
"output": "2 3 2 3 3 "
},
{
"input": "5 3 1 3 15 9",
"output": "3 3 3 3 3 "
},
{
"input": "50 25 1 1 50 25",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 "
},
{
"input": "1000 700 782... | 77 | 0 | 3 | 5,603 | |
465 | Inbox (100500) | [
"implementation"
] | null | null | Over time, Alexey's mail box got littered with too many letters. Some of them are read, while others are unread.
Alexey's mail program can either show a list of all letters or show the content of a single letter. As soon as the program shows the content of an unread letter, it becomes read letter (if the program shows the content of a read letter nothing happens). In one click he can do any of the following operations:
- Move from the list of letters to the content of any single letter.- Return to the list of letters from single letter viewing mode.- In single letter viewing mode, move to the next or to the previous letter in the list. You cannot move from the first letter to the previous one or from the last letter to the next one.
The program cannot delete the letters from the list or rearrange them.
Alexey wants to read all the unread letters and go watch football. Now he is viewing the list of all letters and for each letter he can see if it is read or unread. What minimum number of operations does Alexey need to perform to read all unread letters? | The first line contains a single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of letters in the mailbox.
The second line contains *n* space-separated integers (zeros and ones) — the state of the letter list. The *i*-th number equals either 1, if the *i*-th number is unread, or 0, if the *i*-th letter is read. | Print a single number — the minimum number of operations needed to make all the letters read. | [
"5\n0 1 0 1 0\n",
"5\n1 1 0 0 1\n",
"2\n0 0\n"
] | [
"3\n",
"4\n",
"0\n"
] | In the first sample Alexey needs three operations to cope with the task: open the second letter, move to the third one, move to the fourth one.
In the second sample the action plan: open the first letter, move to the second letter, return to the list, open the fifth letter.
In the third sample all letters are already read. | [
{
"input": "5\n0 1 0 1 0",
"output": "3"
},
{
"input": "5\n1 1 0 0 1",
"output": "4"
},
{
"input": "2\n0 0",
"output": "0"
},
{
"input": "9\n1 0 1 0 1 0 1 0 1",
"output": "9"
},
{
"input": "5\n1 1 1 1 1",
"output": "5"
},
{
"input": "14\n0 0 1 1 1 0 1 ... | 155 | 0 | 0 | 5,607 | |
40 | Find Color | [
"constructive algorithms",
"geometry",
"implementation",
"math"
] | A. Find Color | 2 | 256 | Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black. | The first and single line contains two integers *x* and *y* — the coordinates of the hole made in the clock by the ball. Each of the numbers *x* and *y* has an absolute value that does not exceed 1000. | Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black. | [
"-2 1\n",
"2 1\n",
"4 3\n"
] | [
"white\n",
"black\n",
"black\n"
] | none | [
{
"input": "-2 1",
"output": "white"
},
{
"input": "2 1",
"output": "black"
},
{
"input": "4 3",
"output": "black"
},
{
"input": "3 3",
"output": "black"
},
{
"input": "4 4",
"output": "white"
},
{
"input": "-4 4",
"output": "black"
},
{
"i... | 124 | 4,505,600 | 3.960608 | 5,620 |
727 | Guess the Array | [
"constructive algorithms",
"interactive",
"math"
] | null | null | This is an interactive problem. You should use flush operation after each printed line. For example, in C++ you should use fflush(stdout), in Java you should use System.out.flush(), and in Pascal — flush(output).
In this problem you should guess an array *a* which is unknown for you. The only information you have initially is the length *n* of the array *a*.
The only allowed action is to ask the sum of two elements by their indices. Formally, you can print two indices *i* and *j* (the indices should be distinct). Then your program should read the response: the single integer equals to *a**i*<=+<=*a**j*.
It is easy to prove that it is always possible to guess the array using at most *n* requests.
Write a program that will guess the array *a* by making at most *n* requests. | none | none | [
"5\n \n9\n \n7\n \n9\n \n11\n \n6\n "
] | [
"? 1 5\n \n? 2 3\n \n? 4 1\n \n? 5 2\n \n? 3 4\n \n! 4 6 1 5 5"
] | The format of a test to make a hack is:
- The first line contains an integer number *n* (3 ≤ *n* ≤ 5000) — the length of the array.- The second line contains *n* numbers *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">5</sup>) — the elements of the array to guess. | [
{
"input": "5\n4 6 1 5 5",
"output": "5 out of 5"
},
{
"input": "3\n1 1 1",
"output": "3 out of 3"
},
{
"input": "4\n100 1 100 1",
"output": "4 out of 4"
},
{
"input": "10\n9 5 10 7 4 4 8 5 10 5",
"output": "10 out of 10"
},
{
"input": "3\n1 1 1",
"output": "3... | 358 | 9,113,600 | 3 | 5,624 | |
513 | Permutations | [
"brute force"
] | null | null | You are given a permutation *p* of numbers 1,<=2,<=...,<=*n*. Let's define *f*(*p*) as the following sum:
Find the lexicographically *m*-th permutation of length *n* in the set of permutations having the maximum possible value of *f*(*p*). | The single line of input contains two integers *n* and *m* (1<=≤<=*m*<=≤<=*cnt**n*), where *cnt**n* is the number of permutations of length *n* with maximum possible value of *f*(*p*).
The problem consists of two subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
- In subproblem B1 (3 points), the constraint 1<=≤<=*n*<=≤<=8 will hold. - In subproblem B2 (4 points), the constraint 1<=≤<=*n*<=≤<=50 will hold. | Output *n* number forming the required permutation. | [
"2 2\n",
"3 2\n"
] | [
"2 1 \n",
"1 3 2 \n"
] | In the first example, both permutations of numbers {1, 2} yield maximum possible *f*(*p*) which is equal to 4. Among them, (2, 1) comes second in lexicographical order. | [
{
"input": "2 2",
"output": "2 1 "
},
{
"input": "3 2",
"output": "1 3 2 "
},
{
"input": "1 1",
"output": "1 "
},
{
"input": "3 1",
"output": "1 2 3 "
},
{
"input": "3 3",
"output": "2 3 1 "
},
{
"input": "3 4",
"output": "3 2 1 "
},
{
"inp... | 935 | 5,632,000 | 3 | 5,630 | |
665 | Simple Subset | [
"constructive algorithms",
"greedy",
"number theory"
] | null | null | A tuple of positive integers {*x*1,<=*x*2,<=...,<=*x**k*} is called simple if for all pairs of positive integers (*i*,<=<=*j*) (1<=<=≤<=*i*<=<=<<=<=*j*<=≤<=*k*), *x**i*<=<=+<=<=*x**j* is a prime.
You are given an array *a* with *n* positive integers *a*1,<=<=*a*2,<=<=...,<=<=*a**n* (not necessary distinct). You want to find a simple subset of the array *a* with the maximum size.
A prime number (or a prime) is a natural number greater than 1 that has no positive divisors other than 1 and itself.
Let's define a subset of the array *a* as a tuple that can be obtained from *a* by removing some (possibly all) elements of it. | The first line contains integer *n* (1<=≤<=*n*<=≤<=1000) — the number of integers in the array *a*.
The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=106) — the elements of the array *a*. | On the first line print integer *m* — the maximum possible size of simple subset of *a*.
On the second line print *m* integers *b**l* — the elements of the simple subset of the array *a* with the maximum size.
If there is more than one solution you can print any of them. You can print the elements of the subset in any order. | [
"2\n2 3\n",
"2\n2 2\n",
"3\n2 1 1\n",
"2\n83 14\n"
] | [
"2\n3 2\n",
"1\n2\n",
"3\n1 1 2\n",
"2\n14 83\n"
] | none | [
{
"input": "2\n2 3",
"output": "2\n3 2"
},
{
"input": "2\n2 2",
"output": "1\n2"
},
{
"input": "3\n2 1 1",
"output": "3\n1 1 2"
},
{
"input": "2\n83 14",
"output": "2\n14 83"
},
{
"input": "10\n10 10 1 2 3 3 1 2 1 5",
"output": "4\n1 1 10 1"
},
{
"inpu... | 0 | 0 | -1 | 5,639 | |
0 | none | [
"none"
] | null | null | Paladin Manao caught the trail of the ancient Book of Evil in a swampy area. This area contains *n* settlements numbered from 1 to *n*. Moving through the swamp is very difficult, so people tramped exactly *n*<=-<=1 paths. Each of these paths connects some pair of settlements and is bidirectional. Moreover, it is possible to reach any settlement from any other one by traversing one or several paths.
The distance between two settlements is the minimum number of paths that have to be crossed to get from one settlement to the other one. Manao knows that the Book of Evil has got a damage range *d*. This means that if the Book of Evil is located in some settlement, its damage (for example, emergence of ghosts and werewolves) affects other settlements at distance *d* or less from the settlement where the Book resides.
Manao has heard of *m* settlements affected by the Book of Evil. Their numbers are *p*1,<=*p*2,<=...,<=*p**m*. Note that the Book may be affecting other settlements as well, but this has not been detected yet. Manao wants to determine which settlements may contain the Book. Help him with this difficult task. | The first line contains three space-separated integers *n*, *m* and *d* (1<=≤<=*m*<=≤<=*n*<=≤<=100000; 0<=≤<=*d*<=≤<=*n*<=-<=1). The second line contains *m* distinct space-separated integers *p*1,<=*p*2,<=...,<=*p**m* (1<=≤<=*p**i*<=≤<=*n*). Then *n*<=-<=1 lines follow, each line describes a path made in the area. A path is described by a pair of space-separated integers *a**i* and *b**i* representing the ends of this path. | Print a single number — the number of settlements that may contain the Book of Evil. It is possible that Manao received some controversial information and there is no settlement that may contain the Book. In such case, print 0. | [
"6 2 3\n1 2\n1 5\n2 3\n3 4\n4 5\n5 6\n"
] | [
"3\n"
] | Sample 1. The damage range of the Book of Evil equals 3 and its effects have been noticed in settlements 1 and 2. Thus, it can be in settlements 3, 4 or 5. | [] | 60 | 0 | 0 | 5,649 | |
19 | Checkout Assistant | [
"dp"
] | B. Checkout Assistant | 1 | 256 | Bob came to a cash & carry store, put *n* items into his trolley, and went to the checkout counter to pay. Each item is described by its price *c**i* and time *t**i* in seconds that a checkout assistant spends on this item. While the checkout assistant is occupied with some item, Bob can steal some other items from his trolley. To steal one item Bob needs exactly 1 second. What is the minimum amount of money that Bob will have to pay to the checkout assistant? Remember, please, that it is Bob, who determines the order of items for the checkout assistant. | The first input line contains number *n* (1<=≤<=*n*<=≤<=2000). In each of the following *n* lines each item is described by a pair of numbers *t**i*, *c**i* (0<=≤<=*t**i*<=≤<=2000,<=1<=≤<=*c**i*<=≤<=109). If *t**i* is 0, Bob won't be able to steal anything, while the checkout assistant is occupied with item *i*. | Output one number — answer to the problem: what is the minimum amount of money that Bob will have to pay. | [
"4\n2 10\n0 20\n1 5\n1 3\n",
"3\n0 1\n0 10\n0 100\n"
] | [
"8\n",
"111\n"
] | none | [
{
"input": "4\n2 10\n0 20\n1 5\n1 3",
"output": "8"
},
{
"input": "3\n0 1\n0 10\n0 100",
"output": "111"
},
{
"input": "2\n0 635254032\n0 75159864",
"output": "710413896"
},
{
"input": "2\n0 861438648\n1 469893784",
"output": "469893784"
},
{
"input": "2\n2 876232... | 1,000 | 10,444,800 | 0 | 5,653 |
637 | Promocodes with Mistakes | [
"*special",
"brute force",
"constructive algorithms",
"implementation"
] | null | null | During a New Year special offer the "Sudislavl Bars" offered *n* promo codes. Each promo code consists of exactly six digits and gives right to one free cocktail at the bar "Mosquito Shelter". Of course, all the promocodes differ.
As the "Mosquito Shelter" opens only at 9, and partying in Sudislavl usually begins at as early as 6, many problems may arise as to how to type a promotional code without errors. It is necessary to calculate such maximum *k*, that the promotional code could be uniquely identified if it was typed with no more than *k* errors. At that, *k*<==<=0 means that the promotional codes must be entered exactly.
A mistake in this problem should be considered as entering the wrong numbers. For example, value "123465" contains two errors relative to promocode "123456". Regardless of the number of errors the entered value consists of exactly six digits. | The first line of the output contains number *n* (1<=≤<=*n*<=≤<=1000) — the number of promocodes.
Each of the next *n* lines contains a single promocode, consisting of exactly 6 digits. It is guaranteed that all the promocodes are distinct. Promocodes can start from digit "0". | Print the maximum *k* (naturally, not exceeding the length of the promocode), such that any promocode can be uniquely identified if it is typed with at most *k* mistakes. | [
"2\n000000\n999999\n",
"6\n211111\n212111\n222111\n111111\n112111\n121111\n"
] | [
"2\n",
"0\n"
] | In the first sample *k* < 3, so if a bar customer types in value "090909", then it will be impossible to define which promocode exactly corresponds to it. | [
{
"input": "2\n000000\n999999",
"output": "2"
},
{
"input": "6\n211111\n212111\n222111\n111111\n112111\n121111",
"output": "0"
},
{
"input": "1\n123456",
"output": "6"
},
{
"input": "2\n000000\n099999",
"output": "2"
},
{
"input": "2\n000000\n009999",
"output"... | 1,000 | 0 | 0 | 5,663 | |
17 | Hierarchy | [
"dfs and similar",
"dsu",
"greedy",
"shortest paths"
] | B. Hierarchy | 2 | 64 | Nick's company employed *n* people. Now Nick needs to build a tree hierarchy of «supervisor-surbodinate» relations in the company (this is to say that each employee, except one, has exactly one supervisor). There are *m* applications written in the following form: «employee *a**i* is ready to become a supervisor of employee *b**i* at extra cost *c**i*». The qualification *q**j* of each employee is known, and for each application the following is true: *q**a**i*<=><=*q**b**i*.
Would you help Nick calculate the minimum cost of such a hierarchy, or find out that it is impossible to build it. | The first input line contains integer *n* (1<=≤<=*n*<=≤<=1000) — amount of employees in the company. The following line contains *n* space-separated numbers *q**j* (0<=≤<=*q**j*<=≤<=106)— the employees' qualifications. The following line contains number *m* (0<=≤<=*m*<=≤<=10000) — amount of received applications. The following *m* lines contain the applications themselves, each of them in the form of three space-separated numbers: *a**i*, *b**i* and *c**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*, 0<=≤<=*c**i*<=≤<=106). Different applications can be similar, i.e. they can come from one and the same employee who offered to become a supervisor of the same person but at a different cost. For each application *q**a**i*<=><=*q**b**i*. | Output the only line — the minimum cost of building such a hierarchy, or -1 if it is impossible to build it. | [
"4\n7 2 3 1\n4\n1 2 5\n2 4 1\n3 4 1\n1 3 5\n",
"3\n1 2 3\n2\n3 1 2\n3 1 3\n"
] | [
"11\n",
"-1\n"
] | In the first sample one of the possible ways for building a hierarchy is to take applications with indexes 1, 2 and 4, which give 11 as the minimum total cost. In the second sample it is impossible to build the required hierarchy, so the answer is -1. | [
{
"input": "4\n7 2 3 1\n4\n1 2 5\n2 4 1\n3 4 1\n1 3 5",
"output": "11"
},
{
"input": "3\n1 2 3\n2\n3 1 2\n3 1 3",
"output": "-1"
},
{
"input": "1\n2\n0",
"output": "0"
},
{
"input": "2\n5 3\n4\n1 2 0\n1 2 5\n1 2 0\n1 2 7",
"output": "0"
},
{
"input": "3\n9 4 5\n5\... | 216 | 0 | 0 | 5,683 |
644 | Parliament of Berland | [
"*special",
"constructive algorithms"
] | null | null | There are *n* parliamentarians in Berland. They are numbered with integers from 1 to *n*. It happened that all parliamentarians with odd indices are Democrats and all parliamentarians with even indices are Republicans.
New parliament assembly hall is a rectangle consisting of *a*<=×<=*b* chairs — *a* rows of *b* chairs each. Two chairs are considered neighbouring if they share as side. For example, chair number 5 in row number 2 is neighbouring to chairs number 4 and 6 in this row and chairs with number 5 in rows 1 and 3. Thus, chairs have four neighbours in general, except for the chairs on the border of the hall
We know that if two parliamentarians from one political party (that is two Democrats or two Republicans) seat nearby they spent all time discussing internal party issues.
Write the program that given the number of parliamentarians and the sizes of the hall determine if there is a way to find a seat for any parliamentarian, such that no two members of the same party share neighbouring seats. | The first line of the input contains three integers *n*, *a* and *b* (1<=≤<=*n*<=≤<=10<=000, 1<=≤<=*a*,<=*b*<=≤<=100) — the number of parliamentarians, the number of rows in the assembly hall and the number of seats in each row, respectively. | If there is no way to assigns seats to parliamentarians in a proper way print -1.
Otherwise print the solution in *a* lines, each containing *b* integers. The *j*-th integer of the *i*-th line should be equal to the index of parliamentarian occupying this seat, or 0 if this seat should remain empty. If there are multiple possible solution, you may print any of them. | [
"3 2 2\n",
"8 4 3\n",
"10 2 2\n"
] | [
"0 3\n1 2\n",
"7 8 3\n0 1 4\n6 0 5\n0 2 0\n",
"-1\n"
] | In the first sample there are many other possible solutions. For example,
and
The following assignment
is incorrect, because parliamentarians 1 and 3 are both from Democrats party but will occupy neighbouring seats. | [
{
"input": "3 2 2",
"output": "1 2 \n0 3 "
},
{
"input": "8 4 3",
"output": "1 2 3 \n4 5 6 \n7 8 0 \n0 0 0 "
},
{
"input": "10 2 2",
"output": "-1"
},
{
"input": "1 1 1",
"output": "1 "
},
{
"input": "8 3 3",
"output": "1 2 3 \n4 5 6 \n7 8 0 "
},
{
"in... | 61 | 0 | 0 | 5,692 | |
817 | Makes And The Product | [
"combinatorics",
"implementation",
"math",
"sortings"
] | null | null | After returning from the army Makes received a gift — an array *a* consisting of *n* positive integer numbers. He hadn't been solving problems for a long time, so he became interested to answer a particular question: how many triples of indices (*i*,<= *j*,<= *k*) (*i*<=<<=*j*<=<<=*k*), such that *a**i*·*a**j*·*a**k* is minimum possible, are there in the array? Help him with it! | The first line of input contains a positive integer number *n* (3<=≤<=*n*<=≤<=105) — the number of elements in array *a*. The second line contains *n* positive integer numbers *a**i* (1<=≤<=*a**i*<=≤<=109) — the elements of a given array. | Print one number — the quantity of triples (*i*,<= *j*,<= *k*) such that *i*,<= *j* and *k* are pairwise distinct and *a**i*·*a**j*·*a**k* is minimum possible. | [
"4\n1 1 1 1\n",
"5\n1 3 2 3 4\n",
"6\n1 3 3 1 3 2\n"
] | [
"4\n",
"2\n",
"1\n"
] | In the first example Makes always chooses three ones out of four, and the number of ways to choose them is 4.
In the second example a triple of numbers (1, 2, 3) is chosen (numbers, not indices). Since there are two ways to choose an element 3, then the answer is 2.
In the third example a triple of numbers (1, 1, 2) is chosen, and there's only one way to choose indices. | [
{
"input": "4\n1 1 1 1",
"output": "4"
},
{
"input": "5\n1 3 2 3 4",
"output": "2"
},
{
"input": "6\n1 3 3 1 3 2",
"output": "1"
},
{
"input": "3\n1000000000 1000000000 1000000000",
"output": "1"
},
{
"input": "4\n1 1 2 2",
"output": "2"
},
{
"input": ... | 1,106 | 13,926,400 | 3 | 5,701 | |
822 | Crossword solving | [
"brute force",
"implementation",
"strings"
] | null | null | Erelong Leha was bored by calculating of the greatest common divisor of two factorials. Therefore he decided to solve some crosswords. It's well known that it is a very interesting occupation though it can be very difficult from time to time. In the course of solving one of the crosswords, Leha had to solve a simple task. You are able to do it too, aren't you?
Leha has two strings *s* and *t*. The hacker wants to change the string *s* at such way, that it can be found in *t* as a substring. All the changes should be the following: Leha chooses one position in the string *s* and replaces the symbol in this position with the question mark "?". The hacker is sure that the question mark in comparison can play the role of an arbitrary symbol. For example, if he gets string *s*="ab?b" as a result, it will appear in *t*="aabrbb" as a substring.
Guaranteed that the length of the string *s* doesn't exceed the length of the string *t*. Help the hacker to replace in *s* as few symbols as possible so that the result of the replacements can be found in *t* as a substring. The symbol "?" should be considered equal to any other symbol. | The first line contains two integers *n* and *m* (1<=≤<=*n*<=≤<=*m*<=≤<=1000) — the length of the string *s* and the length of the string *t* correspondingly.
The second line contains *n* lowercase English letters — string *s*.
The third line contains *m* lowercase English letters — string *t*. | In the first line print single integer *k* — the minimal number of symbols that need to be replaced.
In the second line print *k* distinct integers denoting the positions of symbols in the string *s* which need to be replaced. Print the positions in any order. If there are several solutions print any of them. The numbering of the positions begins from one. | [
"3 5\nabc\nxaybz\n",
"4 10\nabcd\nebceabazcd\n"
] | [
"2\n2 3 \n",
"1\n2 \n"
] | none | [
{
"input": "3 5\nabc\nxaybz",
"output": "2\n2 3 "
},
{
"input": "4 10\nabcd\nebceabazcd",
"output": "1\n2 "
},
{
"input": "1 1\na\na",
"output": "0"
},
{
"input": "1 1\na\nz",
"output": "1\n1 "
},
{
"input": "3 5\naaa\naaaaa",
"output": "0"
},
{
"input... | 77 | 31,436,800 | 3 | 5,702 | |
301 | Yaroslav and Sequence | [
"constructive algorithms"
] | null | null | Yaroslav has an array, consisting of (2·*n*<=-<=1) integers. In a single operation Yaroslav can change the sign of exactly *n* elements in the array. In other words, in one operation Yaroslav can select exactly *n* array elements, and multiply each of them by -1.
Yaroslav is now wondering: what maximum sum of array elements can be obtained if it is allowed to perform any number of described operations?
Help Yaroslav. | The first line contains an integer *n* (2<=≤<=*n*<=≤<=100). The second line contains (2·*n*<=-<=1) integers — the array elements. The array elements do not exceed 1000 in their absolute value. | In a single line print the answer to the problem — the maximum sum that Yaroslav can get. | [
"2\n50 50 50\n",
"2\n-1 -100 -1\n"
] | [
"150\n",
"100\n"
] | In the first sample you do not need to change anything. The sum of elements equals 150.
In the second sample you need to change the sign of the first two elements. Then we get the sum of the elements equal to 100. | [
{
"input": "2\n50 50 50",
"output": "150"
},
{
"input": "2\n-1 -100 -1",
"output": "100"
},
{
"input": "3\n-959 -542 -669 -513 160",
"output": "2843"
},
{
"input": "4\n717 473 344 -51 -548 703 -869",
"output": "3603"
},
{
"input": "5\n270 -181 957 -509 -6 937 -175... | 46 | 102,400 | 0 | 5,705 | |
1 | Ancient Berland Circus | [
"geometry",
"math"
] | C. Ancient Berland Circus | 2 | 64 | Nowadays all circuses in Berland have a round arena with diameter 13 meters, but in the past things were different.
In Ancient Berland arenas in circuses were shaped as a regular (equiangular) polygon, the size and the number of angles could vary from one circus to another. In each corner of the arena there was a special pillar, and the rope strung between the pillars marked the arena edges.
Recently the scientists from Berland have discovered the remains of the ancient circus arena. They found only three pillars, the others were destroyed by the time.
You are given the coordinates of these three pillars. Find out what is the smallest area that the arena could have. | The input file consists of three lines, each of them contains a pair of numbers –– coordinates of the pillar. Any coordinate doesn't exceed 1000 by absolute value, and is given with at most six digits after decimal point. | Output the smallest possible area of the ancient arena. This number should be accurate to at least 6 digits after the decimal point. It's guaranteed that the number of angles in the optimal polygon is not larger than 100. | [
"0.000000 0.000000\n1.000000 1.000000\n0.000000 1.000000\n"
] | [
"1.00000000\n"
] | [
{
"input": "0.000000 0.000000\n1.000000 1.000000\n0.000000 1.000000",
"output": "1.00000000"
},
{
"input": "71.756151 7.532275\n-48.634784 100.159986\n91.778633 158.107739",
"output": "9991.27897663"
},
{
"input": "18.716839 40.852752\n66.147248 -4.083161\n111.083161 43.347248",
"out... | 62 | 0 | -1 | 5,708 | |
213 | Relay Race | [
"dp"
] | null | null | Furik and Rubik take part in a relay race. The race will be set up on a large square with the side of *n* meters. The given square is split into *n*<=×<=*n* cells (represented as unit squares), each cell has some number.
At the beginning of the race Furik stands in a cell with coordinates (1,<=1), and Rubik stands in a cell with coordinates (*n*,<=*n*). Right after the start Furik runs towards Rubik, besides, if Furik stands at a cell with coordinates (*i*,<=*j*), then he can move to cell (*i*<=+<=1,<=*j*) or (*i*,<=*j*<=+<=1). After Furik reaches Rubik, Rubik starts running from cell with coordinates (*n*,<=*n*) to cell with coordinates (1,<=1). If Rubik stands in cell (*i*,<=*j*), then he can move to cell (*i*<=-<=1,<=*j*) or (*i*,<=*j*<=-<=1). Neither Furik, nor Rubik are allowed to go beyond the boundaries of the field; if a player goes beyond the boundaries, he will be disqualified.
To win the race, Furik and Rubik must earn as many points as possible. The number of points is the sum of numbers from the cells Furik and Rubik visited. Each cell counts only once in the sum.
Print the maximum number of points Furik and Rubik can earn on the relay race. | The first line contains a single integer (1<=≤<=*n*<=≤<=300). The next *n* lines contain *n* integers each: the *j*-th number on the *i*-th line *a**i*,<=*j* (<=-<=1000<=≤<=*a**i*,<=*j*<=≤<=1000) is the number written in the cell with coordinates (*i*,<=*j*). | On a single line print a single number — the answer to the problem. | [
"1\n5\n",
"2\n11 14\n16 12\n",
"3\n25 16 25\n12 18 19\n11 13 8\n"
] | [
"5\n",
"53\n",
"136\n"
] | Comments to the second sample: The profitable path for Furik is: (1, 1), (1, 2), (2, 2), and for Rubik: (2, 2), (2, 1), (1, 1).
Comments to the third sample: The optimal path for Furik is: (1, 1), (1, 2), (1, 3), (2, 3), (3, 3), and for Rubik: (3, 3), (3, 2), (2, 2), (2, 1), (1, 1). The figure to the sample: | [
{
"input": "1\n5",
"output": "5"
},
{
"input": "2\n11 14\n16 12",
"output": "53"
},
{
"input": "3\n25 16 25\n12 18 19\n11 13 8",
"output": "136"
},
{
"input": "4\n35 2 38 10\n15 19 31 32\n21 19 22 15\n37 33 2 13",
"output": "274"
},
{
"input": "5\n4 32 1 18 41\n47... | 122 | 2,867,200 | -1 | 5,717 | |
390 | Inna, Dima and Song | [
"implementation"
] | null | null | Inna is a great piano player and Dima is a modest guitar player. Dima has recently written a song and they want to play it together. Of course, Sereja wants to listen to the song very much.
A song is a sequence of notes. Dima and Inna want to play each note at the same time. At that, they can play the *i*-th note at volume *v* (1<=≤<=*v*<=≤<=*a**i*; *v* is an integer) both on the piano and the guitar. They should retain harmony, so the total volume with which the *i*-th note was played on the guitar and the piano must equal *b**i*. If Dima and Inna cannot play a note by the described rules, they skip it and Sereja's joy drops by 1. But if Inna and Dima play the *i*-th note at volumes *x**i* and *y**i* (*x**i*<=+<=*y**i*<==<=*b**i*) correspondingly, Sereja's joy rises by *x**i*·*y**i*.
Sereja has just returned home from the university and his current joy is 0. Help Dima and Inna play the song so as to maximize Sereja's total joy after listening to the whole song! | The first line of the input contains integer *n* (1<=≤<=*n*<=≤<=105) — the number of notes in the song. The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=106). The third line contains *n* integers *b**i* (1<=≤<=*b**i*<=≤<=106). | In a single line print an integer — the maximum possible joy Sereja feels after he listens to a song. | [
"3\n1 1 2\n2 2 3\n",
"1\n2\n5\n"
] | [
"4\n",
"-1\n"
] | In the first sample, Dima and Inna play the first two notes at volume 1 (1 + 1 = 2, the condition holds), they should play the last note at volumes 1 and 2. Sereja's total joy equals: 1·1 + 1·1 + 1·2 = 4.
In the second sample, there is no such pair (*x*, *y*), that 1 ≤ *x*, *y* ≤ 2, *x* + *y* = 5, so Dima and Inna skip a note. Sereja's total joy equals -1. | [
{
"input": "3\n1 1 2\n2 2 3",
"output": "4"
},
{
"input": "1\n2\n5",
"output": "-1"
},
{
"input": "10\n2 2 3 4 5 6 7 8 9 10\n2 2 3 4 5 6 7 8 9 10",
"output": "96"
},
{
"input": "10\n1 2 3 4 5 6 7 8 9 10\n1 2 3 4 5 6 7 8 9 10",
"output": "94"
},
{
"input": "3\n1000... | 109 | 0 | 0 | 5,728 | |
957 | Tritonic Iridescence | [
"implementation"
] | null | null | Overlooking the captivating blend of myriads of vernal hues, Arkady the painter lays out a long, long canvas.
Arkady has a sufficiently large amount of paint of three colours: cyan, magenta, and yellow. On the one-dimensional canvas split into *n* consecutive segments, each segment needs to be painted in one of the colours.
Arkady has already painted some (possibly none or all) segments and passes the paintbrush to you. You are to determine whether there are at least two ways of colouring all the unpainted segments so that no two adjacent segments are of the same colour. Two ways are considered different if and only if a segment is painted in different colours in them. | The first line contains a single positive integer *n* (1<=≤<=*n*<=≤<=100) — the length of the canvas.
The second line contains a string *s* of *n* characters, the *i*-th of which is either 'C' (denoting a segment painted in cyan), 'M' (denoting one painted in magenta), 'Y' (one painted in yellow), or '?' (an unpainted one). | If there are at least two different ways of painting, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower). | [
"5\nCY??Y\n",
"5\nC?C?Y\n",
"5\n?CYC?\n",
"5\nC??MM\n",
"3\nMMY\n"
] | [
"Yes\n",
"Yes\n",
"Yes\n",
"No\n",
"No\n"
] | For the first example, there are exactly two different ways of colouring: CYCMY and CYMCY.
For the second example, there are also exactly two different ways of colouring: CMCMY and CYCMY.
For the third example, there are four ways of colouring: MCYCM, MCYCY, YCYCM, and YCYCY.
For the fourth example, no matter how the unpainted segments are coloured, the existing magenta segments will prevent the painting from satisfying the requirements. The similar is true for the fifth example. | [
{
"input": "5\nCY??Y",
"output": "Yes"
},
{
"input": "5\nC?C?Y",
"output": "Yes"
},
{
"input": "5\n?CYC?",
"output": "Yes"
},
{
"input": "5\nC??MM",
"output": "No"
},
{
"input": "3\nMMY",
"output": "No"
},
{
"input": "15\n??YYYYYY??YYYY?",
"output"... | 93 | 0 | 0 | 5,729 | |
723 | Polycarp at the Radio | [
"greedy"
] | null | null | Polycarp is a music editor at the radio station. He received a playlist for tomorrow, that can be represented as a sequence *a*1,<=*a*2,<=...,<=*a**n*, where *a**i* is a band, which performs the *i*-th song. Polycarp likes bands with the numbers from 1 to *m*, but he doesn't really like others.
We define as *b**j* the number of songs the group *j* is going to perform tomorrow. Polycarp wants to change the playlist in such a way that the minimum among the numbers *b*1,<=*b*2,<=...,<=*b**m* will be as large as possible.
Find this maximum possible value of the minimum among the *b**j* (1<=≤<=*j*<=≤<=*m*), and the minimum number of changes in the playlist Polycarp needs to make to achieve it. One change in the playlist is a replacement of the performer of the *i*-th song with any other group. | The first line of the input contains two integers *n* and *m* (1<=≤<=*m*<=≤<=*n*<=≤<=2000).
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109), where *a**i* is the performer of the *i*-th song. | In the first line print two integers: the maximum possible value of the minimum among the *b**j* (1<=≤<=*j*<=≤<=*m*), where *b**j* is the number of songs in the changed playlist performed by the *j*-th band, and the minimum number of changes in the playlist Polycarp needs to make.
In the second line print the changed playlist.
If there are multiple answers, print any of them. | [
"4 2\n1 2 3 2\n",
"7 3\n1 3 2 2 2 2 1\n",
"4 4\n1000000000 100 7 1000000000\n"
] | [
"2 1\n1 2 1 2 \n",
"2 1\n1 3 3 2 2 2 1 \n",
"1 4\n1 2 3 4 \n"
] | In the first sample, after Polycarp's changes the first band performs two songs (*b*<sub class="lower-index">1</sub> = 2), and the second band also performs two songs (*b*<sub class="lower-index">2</sub> = 2). Thus, the minimum of these values equals to 2. It is impossible to achieve a higher minimum value by any changes in the playlist.
In the second sample, after Polycarp's changes the first band performs two songs (*b*<sub class="lower-index">1</sub> = 2), the second band performs three songs (*b*<sub class="lower-index">2</sub> = 3), and the third band also performs two songs (*b*<sub class="lower-index">3</sub> = 2). Thus, the best minimum value is 2. | [
{
"input": "4 2\n1 2 3 2",
"output": "2 1\n1 2 1 2 "
},
{
"input": "7 3\n1 3 2 2 2 2 1",
"output": "2 1\n1 3 3 2 2 2 1 "
},
{
"input": "4 4\n1000000000 100 7 1000000000",
"output": "1 4\n1 2 3 4 "
},
{
"input": "1 1\n1",
"output": "1 0\n1 "
},
{
"input": "1 1\n381... | 46 | 0 | 0 | 5,740 | |
498 | Crazy Town | [
"geometry"
] | null | null | Crazy Town is a plane on which there are *n* infinite line roads. Each road is defined by the equation *a**i**x*<=+<=*b**i**y*<=+<=*c**i*<==<=0, where *a**i* and *b**i* are not both equal to the zero. The roads divide the plane into connected regions, possibly of infinite space. Let's call each such region a block. We define an intersection as the point where at least two different roads intersect.
Your home is located in one of the blocks. Today you need to get to the University, also located in some block. In one step you can move from one block to another, if the length of their common border is nonzero (in particular, this means that if the blocks are adjacent to one intersection, but have no shared nonzero boundary segment, then it are not allowed to move from one to another one in one step).
Determine what is the minimum number of steps you have to perform to get to the block containing the university. It is guaranteed that neither your home nor the university is located on the road. | The first line contains two space-separated integers *x*1, *y*1 (<=-<=106<=≤<=*x*1,<=*y*1<=≤<=106) — the coordinates of your home.
The second line contains two integers separated by a space *x*2, *y*2 (<=-<=106<=≤<=*x*2,<=*y*2<=≤<=106) — the coordinates of the university you are studying at.
The third line contains an integer *n* (1<=≤<=*n*<=≤<=300) — the number of roads in the city. The following *n* lines contain 3 space-separated integers (<=-<=106<=≤<=*a**i*,<=*b**i*,<=*c**i*<=≤<=106; |*a**i*|<=+<=|*b**i*|<=><=0) — the coefficients of the line *a**i**x*<=+<=*b**i**y*<=+<=*c**i*<==<=0, defining the *i*-th road. It is guaranteed that no two roads are the same. In addition, neither your home nor the university lie on the road (i.e. they do not belong to any one of the lines). | Output the answer to the problem. | [
"1 1\n-1 -1\n2\n0 1 0\n1 0 0\n",
"1 1\n-1 -1\n3\n1 0 0\n0 1 0\n1 1 -3\n"
] | [
"2\n",
"2\n"
] | Pictures to the samples are presented below (A is the point representing the house; B is the point representing the university, different blocks are filled with different colors): | [
{
"input": "1 1\n-1 -1\n2\n0 1 0\n1 0 0",
"output": "2"
},
{
"input": "1 1\n-1 -1\n3\n1 0 0\n0 1 0\n1 1 -3",
"output": "2"
},
{
"input": "841746 527518\n595261 331297\n10\n-946901 129987 670374\n-140388 -684770 309555\n-302589 415564 -387435\n-565799 -72069 -395358\n-523453 -511446 85489... | 46 | 0 | 0 | 5,741 | |
749 | Voting | [
"greedy",
"implementation",
"two pointers"
] | null | null | There are *n* employees in Alternative Cake Manufacturing (ACM). They are now voting on some very important question and the leading world media are trying to predict the outcome of the vote.
Each of the employees belongs to one of two fractions: depublicans or remocrats, and these two fractions have opposite opinions on what should be the outcome of the vote. The voting procedure is rather complicated:
1. Each of *n* employees makes a statement. They make statements one by one starting from employees 1 and finishing with employee *n*. If at the moment when it's time for the *i*-th employee to make a statement he no longer has the right to vote, he just skips his turn (and no longer takes part in this voting). 1. When employee makes a statement, he can do nothing or declare that one of the other employees no longer has a right to vote. It's allowed to deny from voting people who already made the statement or people who are only waiting to do so. If someone is denied from voting he no longer participates in the voting till the very end. 1. When all employees are done with their statements, the procedure repeats: again, each employees starting from 1 and finishing with *n* who are still eligible to vote make their statements. 1. The process repeats until there is only one employee eligible to vote remaining and he determines the outcome of the whole voting. Of course, he votes for the decision suitable for his fraction.
You know the order employees are going to vote and that they behave optimal (and they also know the order and who belongs to which fraction). Predict the outcome of the vote. | The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=200<=000) — the number of employees.
The next line contains *n* characters. The *i*-th character is 'D' if the *i*-th employee is from depublicans fraction or 'R' if he is from remocrats. | Print 'D' if the outcome of the vote will be suitable for depublicans and 'R' if remocrats will win. | [
"5\nDDRRR\n",
"6\nDDRRRR\n"
] | [
"D\n",
"R\n"
] | Consider one of the voting scenarios for the first sample:
1. Employee 1 denies employee 5 to vote. 1. Employee 2 denies employee 3 to vote. 1. Employee 3 has no right to vote and skips his turn (he was denied by employee 2). 1. Employee 4 denies employee 2 to vote. 1. Employee 5 has no right to vote and skips his turn (he was denied by employee 1). 1. Employee 1 denies employee 4. 1. Only employee 1 now has the right to vote so the voting ends with the victory of depublicans. | [
{
"input": "5\nDDRRR",
"output": "D"
},
{
"input": "6\nDDRRRR",
"output": "R"
},
{
"input": "1\nD",
"output": "D"
},
{
"input": "1\nR",
"output": "R"
},
{
"input": "2\nDR",
"output": "D"
},
{
"input": "3\nRDD",
"output": "D"
},
{
"input": "... | 31 | 0 | -1 | 5,753 | |
814 | An impassioned circulation of affection | [
"brute force",
"dp",
"strings",
"two pointers"
] | null | null | Nadeko's birthday is approaching! As she decorated the room for the party, a long garland of Dianthus-shaped paper pieces was placed on a prominent part of the wall. Brother Koyomi will like it!
Still unsatisfied with the garland, Nadeko decided to polish it again. The garland has *n* pieces numbered from 1 to *n* from left to right, and the *i*-th piece has a colour *s**i*, denoted by a lowercase English letter. Nadeko will repaint at most *m* of the pieces to give each of them an arbitrary new colour (still denoted by a lowercase English letter). After this work, she finds out all subsegments of the garland containing pieces of only colour *c* — Brother Koyomi's favourite one, and takes the length of the longest among them to be the Koyomity of the garland.
For instance, let's say the garland is represented by "kooomo", and Brother Koyomi's favourite colour is "o". Among all subsegments containing pieces of "o" only, "ooo" is the longest, with a length of 3. Thus the Koyomity of this garland equals 3.
But problem arises as Nadeko is unsure about Brother Koyomi's favourite colour, and has swaying ideas on the amount of work to do. She has *q* plans on this, each of which can be expressed as a pair of an integer *m**i* and a lowercase letter *c**i*, meanings of which are explained above. You are to find out the maximum Koyomity achievable after repainting the garland according to each plan. | The first line of input contains a positive integer *n* (1<=≤<=*n*<=≤<=1<=500) — the length of the garland.
The second line contains *n* lowercase English letters *s*1*s*2... *s**n* as a string — the initial colours of paper pieces on the garland.
The third line contains a positive integer *q* (1<=≤<=*q*<=≤<=200<=000) — the number of plans Nadeko has.
The next *q* lines describe one plan each: the *i*-th among them contains an integer *m**i* (1<=≤<=*m**i*<=≤<=*n*) — the maximum amount of pieces to repaint, followed by a space, then by a lowercase English letter *c**i* — Koyomi's possible favourite colour. | Output *q* lines: for each work plan, output one line containing an integer — the largest Koyomity achievable after repainting the garland according to it. | [
"6\nkoyomi\n3\n1 o\n4 o\n4 m\n",
"15\nyamatonadeshiko\n10\n1 a\n2 a\n3 a\n4 a\n5 a\n1 b\n2 b\n3 b\n4 b\n5 b\n",
"10\naaaaaaaaaa\n2\n10 b\n10 z\n"
] | [
"3\n6\n5\n",
"3\n4\n5\n7\n8\n1\n2\n3\n4\n5\n",
"10\n10\n"
] | In the first sample, there are three plans:
- In the first plan, at most 1 piece can be repainted. Repainting the "y" piece to become "o" results in "kooomi", whose Koyomity of 3 is the best achievable; - In the second plan, at most 4 pieces can be repainted, and "oooooo" results in a Koyomity of 6; - In the third plan, at most 4 pieces can be repainted, and "mmmmmi" and "kmmmmm" both result in a Koyomity of 5. | [
{
"input": "6\nkoyomi\n3\n1 o\n4 o\n4 m",
"output": "3\n6\n5"
},
{
"input": "15\nyamatonadeshiko\n10\n1 a\n2 a\n3 a\n4 a\n5 a\n1 b\n2 b\n3 b\n4 b\n5 b",
"output": "3\n4\n5\n7\n8\n1\n2\n3\n4\n5"
},
{
"input": "10\naaaaaaaaaa\n2\n10 b\n10 z",
"output": "10\n10"
},
{
"input": "1... | 61 | 3,993,600 | -1 | 5,768 | |
920 | Swap Adjacent Elements | [
"dfs and similar",
"greedy",
"math",
"sortings",
"two pointers"
] | null | null | You have an array *a* consisting of *n* integers. Each integer from 1 to *n* appears exactly once in this array.
For some indices *i* (1<=≤<=*i*<=≤<=*n*<=-<=1) it is possible to swap *i*-th element with (*i*<=+<=1)-th, for other indices it is not possible. You may perform any number of swapping operations any order. There is no limit on the number of times you swap *i*-th element with (*i*<=+<=1)-th (if the position is not forbidden).
Can you make this array sorted in ascending order performing some sequence of swapping operations? | The first line contains one integer *n* (2<=≤<=*n*<=≤<=200000) — the number of elements in the array.
The second line contains *n* integers *a*1, *a*2, ..., *a**n* (1<=≤<=*a**i*<=≤<=200000) — the elements of the array. Each integer from 1 to *n* appears exactly once.
The third line contains a string of *n*<=-<=1 characters, each character is either 0 or 1. If *i*-th character is 1, then you can swap *i*-th element with (*i*<=+<=1)-th any number of times, otherwise it is forbidden to swap *i*-th element with (*i*<=+<=1)-th. | If it is possible to sort the array in ascending order using any sequence of swaps you are allowed to make, print YES. Otherwise, print NO. | [
"6\n1 2 5 3 4 6\n01110\n",
"6\n1 2 5 3 4 6\n01010\n"
] | [
"YES\n",
"NO\n"
] | In the first example you may swap *a*<sub class="lower-index">3</sub> and *a*<sub class="lower-index">4</sub>, and then swap *a*<sub class="lower-index">4</sub> and *a*<sub class="lower-index">5</sub>. | [
{
"input": "6\n1 2 5 3 4 6\n01110",
"output": "YES"
},
{
"input": "6\n1 2 5 3 4 6\n01010",
"output": "NO"
},
{
"input": "6\n1 6 3 4 5 2\n01101",
"output": "NO"
},
{
"input": "6\n2 3 1 4 5 6\n01111",
"output": "NO"
},
{
"input": "4\n2 3 1 4\n011",
"output": "NO... | 233 | 13,619,200 | 0 | 5,770 | |
230 | Dragons | [
"greedy",
"sortings"
] | null | null | Kirito is stuck on a level of the MMORPG he is playing now. To move on in the game, he's got to defeat all *n* dragons that live on this level. Kirito and the dragons have strength, which is represented by an integer. In the duel between two opponents the duel's outcome is determined by their strength. Initially, Kirito's strength equals *s*.
If Kirito starts duelling with the *i*-th (1<=≤<=*i*<=≤<=*n*) dragon and Kirito's strength is not greater than the dragon's strength *x**i*, then Kirito loses the duel and dies. But if Kirito's strength is greater than the dragon's strength, then he defeats the dragon and gets a bonus strength increase by *y**i*.
Kirito can fight the dragons in any order. Determine whether he can move on to the next level of the game, that is, defeat all dragons without a single loss. | The first line contains two space-separated integers *s* and *n* (1<=≤<=*s*<=≤<=104, 1<=≤<=*n*<=≤<=103). Then *n* lines follow: the *i*-th line contains space-separated integers *x**i* and *y**i* (1<=≤<=*x**i*<=≤<=104, 0<=≤<=*y**i*<=≤<=104) — the *i*-th dragon's strength and the bonus for defeating it. | On a single line print "YES" (without the quotes), if Kirito can move on to the next level and print "NO" (without the quotes), if he can't. | [
"2 2\n1 99\n100 0\n",
"10 1\n100 100\n"
] | [
"YES\n",
"NO\n"
] | In the first sample Kirito's strength initially equals 2. As the first dragon's strength is less than 2, Kirito can fight it and defeat it. After that he gets the bonus and his strength increases to 2 + 99 = 101. Now he can defeat the second dragon and move on to the next level.
In the second sample Kirito's strength is too small to defeat the only dragon and win. | [
{
"input": "2 2\n1 99\n100 0",
"output": "YES"
},
{
"input": "10 1\n100 100",
"output": "NO"
},
{
"input": "123 2\n78 10\n130 0",
"output": "YES"
},
{
"input": "999 2\n1010 10\n67 89",
"output": "YES"
},
{
"input": "2 5\n5 1\n2 1\n3 1\n1 1\n4 1",
"output": "YE... | 0 | 0 | -1 | 5,772 | |
125 | Hobbits' Party | [
"constructive algorithms",
"greedy"
] | null | null | Everyone knows that hobbits love to organize all sorts of parties and celebrations. There are *n* hobbits living in the Shire. They decided to organize the Greatest Party (GP) that would last for several days. Next day the hobbits wrote a guest list, some non-empty set containing all the inhabitants of the Shire. To ensure that everybody enjoy themselves and nobody gets bored, for any two days (say, days A and B) of the GP there existed at least one hobbit, invited to come on day A and on day B. However, to ensure that nobody has a row, for any three different days A, B, C there shouldn't be a hobbit invited on days A, B and C. The Shire inhabitants are keen on keeping the GP going for as long as possible. Your task is given number *n*, to indicate the GP's maximum duration and the guest lists for each day. | The first line contains an integer *n* (3<=≤<=*n*<=≤<=10000), representing the number of hobbits. | In the first output line print a number *k* — the maximum duration of GP in days. Then on *k* lines print the guest lists, (the guests should be separated by spaces). Print each guest list on the single line. Each list can contain an arbitrary positive number of hobbits. The hobbits are numbered with integers from 1 to *n*. | [
"4\n",
"5\n"
] | [
"3\n1 2 \n1 3 \n2 3 \n",
"3\n1 2 \n1 3 \n2 3 \n"
] | none | [
{
"input": "4",
"output": "3\n1 2 \n1 3 \n2 3 "
},
{
"input": "5",
"output": "3\n1 2 \n1 3 \n2 3 "
},
{
"input": "6",
"output": "4\n1 2 3 \n1 4 5 \n2 4 6 \n3 5 6 "
},
{
"input": "7",
"output": "4\n1 2 3 \n1 4 5 \n2 4 6 \n3 5 6 "
},
{
"input": "8",
"output": "4... | 372 | 1,024,000 | -1 | 5,783 | |
877 | Nikita and string | [
"brute force",
"dp"
] | null | null | One day Nikita found the string containing letters "a" and "b" only.
Nikita thinks that string is beautiful if it can be cut into 3 strings (possibly empty) without changing the order of the letters, where the 1-st and the 3-rd one contain only letters "a" and the 2-nd contains only letters "b".
Nikita wants to make the string beautiful by removing some (possibly none) of its characters, but without changing their order. What is the maximum length of the string he can get? | The first line contains a non-empty string of length not greater than 5<=000 containing only lowercase English letters "a" and "b". | Print a single integer — the maximum possible size of beautiful string Nikita can get. | [
"abba\n",
"bab\n"
] | [
"4",
"2"
] | It the first sample the string is already beautiful.
In the second sample he needs to delete one of "b" to make it beautiful. | [
{
"input": "abba",
"output": "4"
},
{
"input": "bab",
"output": "2"
},
{
"input": "bbabbbaabbbb",
"output": "9"
},
{
"input": "bbabbbbbaaba",
"output": "10"
},
{
"input": "bbabbbababaa",
"output": "9"
},
{
"input": "aabbaababbab",
"output": "8"
}... | 77 | 17,715,200 | 0 | 5,784 | |
690 | Tree of Life (easy) | [] | null | null | Heidi has finally found the mythical Tree of Life – a legendary combinatorial structure which is said to contain a prophecy crucially needed to defeat the undead armies.
On the surface, the Tree of Life is just a regular undirected tree well-known from computer science. This means that it is a collection of *n* points (called vertices), some of which are connected using *n*<=-<=1 line segments (edges) so that each pair of vertices is connected by a path (a sequence of one or more edges).
To decipher the prophecy, Heidi needs to perform a number of steps. The first is counting the number of lifelines in the tree – these are paths of length 2, i.e., consisting of two edges. Help her! | The first line of the input contains a single integer *n* – the number of vertices in the tree (1<=≤<=*n*<=≤<=10000). The vertices are labeled with the numbers from 1 to *n*. Then *n*<=-<=1 lines follow, each describing one edge using two space-separated numbers *a* *b* – the labels of the vertices connected by the edge (1<=≤<=*a*<=<<=*b*<=≤<=*n*). It is guaranteed that the input represents a tree. | Print one integer – the number of lifelines in the tree. | [
"4\n1 2\n1 3\n1 4\n",
"5\n1 2\n2 3\n3 4\n3 5\n"
] | [
"3",
"4"
] | In the second sample, there are four lifelines: paths between vertices 1 and 3, 2 and 4, 2 and 5, and 4 and 5. | [
{
"input": "4\n1 2\n1 3\n1 4",
"output": "3"
},
{
"input": "5\n1 2\n2 3\n3 4\n3 5",
"output": "4"
},
{
"input": "2\n1 2",
"output": "0"
},
{
"input": "3\n2 1\n3 2",
"output": "1"
},
{
"input": "10\n5 1\n1 2\n9 3\n10 5\n6 3\n8 5\n2 7\n2 3\n9 4",
"output": "11"
... | 93 | 204,800 | 3 | 5,807 | |
985 | Pencils and Boxes | [
"binary search",
"data structures",
"dp",
"greedy",
"two pointers"
] | null | null | Mishka received a gift of multicolored pencils for his birthday! Unfortunately he lives in a monochrome world, where everything is of the same color and only saturation differs. This pack can be represented as a sequence *a*1,<=*a*2,<=...,<=*a**n* of *n* integer numbers — saturation of the color of each pencil. Now Mishka wants to put all the mess in the pack in order. He has an infinite number of empty boxes to do this. He would like to fill some boxes in such a way that:
- Each pencil belongs to exactly one box; - Each non-empty box has at least *k* pencils in it; - If pencils *i* and *j* belong to the same box, then |*a**i*<=-<=*a**j*|<=≤<=*d*, where |*x*| means absolute value of *x*. Note that the opposite is optional, there can be pencils *i* and *j* such that |*a**i*<=-<=*a**j*|<=≤<=*d* and they belong to different boxes.
Help Mishka to determine if it's possible to distribute all the pencils into boxes. Print "YES" if there exists such a distribution. Otherwise print "NO". | The first line contains three integer numbers *n*, *k* and *d* (1<=≤<=*k*<=≤<=*n*<=≤<=5·105, 0<=≤<=*d*<=≤<=109) — the number of pencils, minimal size of any non-empty box and maximal difference in saturation between any pair of pencils in the same box, respectively.
The second line contains *n* integer numbers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109) — saturation of color of each pencil. | Print "YES" if it's possible to distribute all the pencils into boxes and satisfy all the conditions. Otherwise print "NO". | [
"6 3 10\n7 2 7 7 4 2\n",
"6 2 3\n4 5 3 13 4 10\n",
"3 2 5\n10 16 22\n"
] | [
"YES\n",
"YES\n",
"NO\n"
] | In the first example it is possible to distribute pencils into 2 boxes with 3 pencils in each with any distribution. And you also can put all the pencils into the same box, difference of any pair in it won't exceed 10.
In the second example you can split pencils of saturations [4, 5, 3, 4] into 2 boxes of size 2 and put the remaining ones into another box. | [
{
"input": "6 3 10\n7 2 7 7 4 2",
"output": "YES"
},
{
"input": "6 2 3\n4 5 3 13 4 10",
"output": "YES"
},
{
"input": "3 2 5\n10 16 22",
"output": "NO"
},
{
"input": "8 7 13\n52 85 14 52 92 33 80 85",
"output": "NO"
},
{
"input": "6 4 0\n1 3 2 4 2 1",
"output"... | 0 | 0 | -1 | 5,813 | |
792 | Paths in a Complete Binary Tree | [
"bitmasks",
"trees"
] | null | null | *T* is a complete binary tree consisting of *n* vertices. It means that exactly one vertex is a root, and each vertex is either a leaf (and doesn't have children) or an inner node (and has exactly two children). All leaves of a complete binary tree have the same depth (distance from the root). So *n* is a number such that *n*<=+<=1 is a power of 2.
In the picture you can see a complete binary tree with *n*<==<=15.
Vertices are numbered from 1 to *n* in a special recursive way: we recursively assign numbers to all vertices from the left subtree (if current vertex is not a leaf), then assign a number to the current vertex, and then recursively assign numbers to all vertices from the right subtree (if it exists). In the picture vertices are numbered exactly using this algorithm. It is clear that for each size of a complete binary tree exists exactly one way to give numbers to all vertices. This way of numbering is called symmetric.
You have to write a program that for given *n* answers *q* queries to the tree.
Each query consists of an integer number *u**i* (1<=≤<=*u**i*<=≤<=*n*) and a string *s**i*, where *u**i* is the number of vertex, and *s**i* represents the path starting from this vertex. String *s**i* doesn't contain any characters other than 'L', 'R' and 'U', which mean traverse to the left child, to the right child and to the parent, respectively. Characters from *s**i* have to be processed from left to right, considering that *u**i* is the vertex where the path starts. If it's impossible to process a character (for example, to go to the left child of a leaf), then you have to skip it. The answer is the number of vertex where the path represented by *s**i* ends.
For example, if *u**i*<==<=4 and *s**i*<==<=«UURL», then the answer is 10. | The first line contains two integer numbers *n* and *q* (1<=≤<=*n*<=≤<=1018, *q*<=≥<=1). *n* is such that *n*<=+<=1 is a power of 2.
The next 2*q* lines represent queries; each query consists of two consecutive lines. The first of these two lines contains *u**i* (1<=≤<=*u**i*<=≤<=*n*), the second contains non-empty string *s**i*. *s**i* doesn't contain any characters other than 'L', 'R' and 'U'.
It is guaranteed that the sum of lengths of *s**i* (for each *i* such that 1<=≤<=*i*<=≤<=*q*) doesn't exceed 105. | Print *q* numbers, *i*-th number must be the answer to the *i*-th query. | [
"15 2\n4\nUURL\n8\nLRLLLLLLLL\n"
] | [
"10\n5\n"
] | none | [
{
"input": "15 2\n4\nUURL\n8\nLRLLLLLLLL",
"output": "10\n5"
},
{
"input": "1 1\n1\nL",
"output": "1"
},
{
"input": "1 1\n1\nR",
"output": "1"
},
{
"input": "1 1\n1\nU",
"output": "1"
},
{
"input": "1 10\n1\nURLRLULUR\n1\nLRRRURULULL\n1\nLURURRUUUU\n1\nRRULLLRRUL\... | 2,199 | 12,902,400 | 3 | 5,816 | |
232 | Cycles | [
"binary search",
"constructive algorithms",
"graphs",
"greedy"
] | null | null | John Doe started thinking about graphs. After some thought he decided that he wants to paint an undirected graph, containing exactly *k* cycles of length 3.
A cycle of length 3 is an unordered group of three distinct graph vertices *a*, *b* and *c*, such that each pair of them is connected by a graph edge.
John has been painting for long, but he has not been a success. Help him find such graph. Note that the number of vertices there shouldn't exceed 100, or else John will have problems painting it. | A single line contains an integer *k* (1<=≤<=*k*<=≤<=105) — the number of cycles of length 3 in the required graph. | In the first line print integer *n* (3<=≤<=*n*<=≤<=100) — the number of vertices in the found graph. In each of next *n* lines print *n* characters "0" and "1": the *i*-th character of the *j*-th line should equal "0", if vertices *i* and *j* do not have an edge between them, otherwise it should equal "1". Note that as the required graph is undirected, the *i*-th character of the *j*-th line must equal the *j*-th character of the *i*-th line. The graph shouldn't contain self-loops, so the *i*-th character of the *i*-th line must equal "0" for all *i*. | [
"1\n",
"10\n"
] | [
"3\n011\n101\n110\n",
"5\n01111\n10111\n11011\n11101\n11110\n"
] | none | [
{
"input": "1",
"output": "3\n011\n101\n110"
},
{
"input": "10",
"output": "5\n01111\n10111\n11011\n11101\n11110"
},
{
"input": "2",
"output": "4\n0111\n1011\n1100\n1100"
},
{
"input": "3",
"output": "5\n01001\n10111\n01001\n01001\n11110"
},
{
"input": "4",
"o... | 154 | 0 | -1 | 5,817 | |
992 | Nastya and a Game | [
"brute force",
"implementation",
"math"
] | null | null | Nastya received one more array on her birthday, this array can be used to play a traditional Byteland game on it. However, to play the game the players should first select such a subsegment of the array that , where *p* is the product of all integers on the given array, *s* is their sum, and *k* is a given constant for all subsegments.
Nastya wonders how many subsegments of the array fit the described conditions. A subsegment of an array is several consecutive integers of the array. | The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=2·105, 1<=≤<=*k*<=≤<=105), where *n* is the length of the array and *k* is the constant described above.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=108) — the elements of the array. | In the only line print the number of subsegments such that the ratio between the product and the sum on them is equal to *k*. | [
"1 1\n1\n",
"4 2\n6 3 8 1\n"
] | [
"1\n",
"2\n"
] | In the first example the only subsegment is [1]. The sum equals 1, the product equals 1, so it suits us because <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/627b2899a459d42fe3b2ca04fc812d4132b5f2ca.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
There are two suitable subsegments in the second example — [6, 3] and [3, 8, 1]. Subsegment [6, 3] has sum 9 and product 18, so it suits us because <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/107ecd38fde9817d6565e2059ccd064562470543.png" style="max-width: 100.0%;max-height: 100.0%;"/>. Subsegment [3, 8, 1] has sum 12 and product 24, so it suits us because <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/8abc1793efa3061313ddd52d670a94b430133564.png" style="max-width: 100.0%;max-height: 100.0%;"/>. | [
{
"input": "1 1\n1",
"output": "1"
},
{
"input": "4 2\n6 3 8 1",
"output": "2"
},
{
"input": "94 58\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 29 58 1 1 1 29 58 58 1 1 29 1 1 1 1 2 1 58 1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1 29 1 1 1 1 1 58 1 29 1 1 1 1 1 1 1 1 1 1 1 1 58 1 1 1 ... | 30 | 0 | 0 | 5,820 | |
448 | Painting Fence | [
"divide and conquer",
"dp",
"greedy"
] | null | null | Bizon the Champion isn't just attentive, he also is very hardworking.
Bizon the Champion decided to paint his old fence his favorite color, orange. The fence is represented as *n* vertical planks, put in a row. Adjacent planks have no gap between them. The planks are numbered from the left to the right starting from one, the *i*-th plank has the width of 1 meter and the height of *a**i* meters.
Bizon the Champion bought a brush in the shop, the brush's width is 1 meter. He can make vertical and horizontal strokes with the brush. During a stroke the brush's full surface must touch the fence at all the time (see the samples for the better understanding). What minimum number of strokes should Bizon the Champion do to fully paint the fence? Note that you are allowed to paint the same area of the fence multiple times. | The first line contains integer *n* (1<=≤<=*n*<=≤<=5000) — the number of fence planks. The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109). | Print a single integer — the minimum number of strokes needed to paint the whole fence. | [
"5\n2 2 1 2 1\n",
"2\n2 2\n",
"1\n5\n"
] | [
"3\n",
"2\n",
"1\n"
] | In the first sample you need to paint the fence in three strokes with the brush: the first stroke goes on height 1 horizontally along all the planks. The second stroke goes on height 2 horizontally and paints the first and second planks and the third stroke (it can be horizontal and vertical) finishes painting the fourth plank.
In the second sample you can paint the fence with two strokes, either two horizontal or two vertical strokes.
In the third sample there is only one plank that can be painted using a single vertical stroke. | [
{
"input": "5\n2 2 1 2 1",
"output": "3"
},
{
"input": "2\n2 2",
"output": "2"
},
{
"input": "1\n5",
"output": "1"
},
{
"input": "5\n2 2 1 2 2",
"output": "3"
},
{
"input": "5\n2 2 1 5 1",
"output": "3"
},
{
"input": "1\n1",
"output": "1"
},
{
... | 30 | 0 | 0 | 5,830 | |
225 | Unsolvable | [
"math",
"number theory"
] | null | null | Consider the following equation:
Let's find all integer *z* (*z*<=><=0), for which this equation is unsolvable in positive integers. The phrase "unsolvable in positive integers" means that there are no such positive integers *x* and *y* (*x*,<=*y*<=><=0), for which the given above equation holds.
Let's write out all such *z* in the increasing order: *z*1,<=*z*2,<=*z*3, and so on (*z**i*<=<<=*z**i*<=+<=1). Your task is: given the number *n*, find the number *z**n*. | The first line contains a single integer *n* (1<=≤<=*n*<=≤<=40). | Print a single integer — the number *z**n* modulo 1000000007 (109<=+<=7). It is guaranteed that the answer exists. | [
"1\n",
"2\n",
"3\n"
] | [
"1",
"3",
"15"
] | none | [
{
"input": "1",
"output": "1"
},
{
"input": "2",
"output": "3"
},
{
"input": "3",
"output": "15"
},
{
"input": "4",
"output": "63"
},
{
"input": "5",
"output": "4095"
},
{
"input": "6",
"output": "65535"
},
{
"input": "7",
"output": "26... | 280 | 0 | 0 | 5,849 | |
985 | Chess Placing | [
"implementation"
] | null | null | You are given a chessboard of size 1<=×<=*n*. It is guaranteed that *n* is even. The chessboard is painted like this: "BWBW...BW".
Some cells of the board are occupied by the chess pieces. Each cell contains no more than one chess piece. It is known that the total number of pieces equals to .
In one step you can move one of the pieces one cell to the left or to the right. You cannot move pieces beyond the borders of the board. You also cannot move pieces to the cells that are already occupied.
Your task is to place all the pieces in the cells of the same color using the minimum number of moves (all the pieces must occupy only the black cells or only the white cells after all the moves are made). | The first line of the input contains one integer *n* (2<=≤<=*n*<=≤<=100, *n* is even) — the size of the chessboard.
The second line of the input contains integer numbers (1<=≤<=*p**i*<=≤<=*n*) — initial positions of the pieces. It is guaranteed that all the positions are distinct. | Print one integer — the minimum number of moves you have to make to place all the pieces in the cells of the same color. | [
"6\n1 2 6\n",
"10\n1 2 3 4 5\n"
] | [
"2\n",
"10\n"
] | In the first example the only possible strategy is to move the piece at the position 6 to the position 5 and move the piece at the position 2 to the position 3. Notice that if you decide to place the pieces in the white cells the minimum number of moves will be 3.
In the second example the possible strategy is to move <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/e1e06f6a15cce30628c7a2360c4ffa57a8ba0ebd.png" style="max-width: 100.0%;max-height: 100.0%;"/> in 4 moves, then <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c84dfbe0c6a917b45fc3f69467c256c4ac460eeb.png" style="max-width: 100.0%;max-height: 100.0%;"/> in 3 moves, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/598731d81393332209d914cb0bbe97d8566c887d.png" style="max-width: 100.0%;max-height: 100.0%;"/> in 2 moves and <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/29f71c065c3536e88b54429c734103ad3604f68b.png" style="max-width: 100.0%;max-height: 100.0%;"/> in 1 move. | [
{
"input": "6\n1 2 6",
"output": "2"
},
{
"input": "10\n1 2 3 4 5",
"output": "10"
},
{
"input": "2\n2",
"output": "0"
},
{
"input": "100\n2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 ... | 61 | 0 | 0 | 5,853 | |
402 | Nuts | [
"greedy",
"math"
] | null | null | You have *a* nuts and lots of boxes. The boxes have a wonderful feature: if you put *x* (*x*<=≥<=0) divisors (the spacial bars that can divide a box) to it, you get a box, divided into *x*<=+<=1 sections.
You are minimalist. Therefore, on the one hand, you are against dividing some box into more than *k* sections. On the other hand, you are against putting more than *v* nuts into some section of the box. What is the minimum number of boxes you have to use if you want to put all the nuts in boxes, and you have *b* divisors?
Please note that you need to minimize the number of used boxes, not sections. You do not have to minimize the number of used divisors. | The first line contains four space-separated integers *k*, *a*, *b*, *v* (2<=≤<=*k*<=≤<=1000; 1<=≤<=*a*,<=*b*,<=*v*<=≤<=1000) — the maximum number of sections in the box, the number of nuts, the number of divisors and the capacity of each section of the box. | Print a single integer — the answer to the problem. | [
"3 10 3 3\n",
"3 10 1 3\n",
"100 100 1 1000\n"
] | [
"2\n",
"3\n",
"1\n"
] | In the first sample you can act like this:
- Put two divisors to the first box. Now the first box has three sections and we can put three nuts into each section. Overall, the first box will have nine nuts. - Do not put any divisors into the second box. Thus, the second box has one section for the last nut.
In the end we've put all the ten nuts into boxes.
The second sample is different as we have exactly one divisor and we put it to the first box. The next two boxes will have one section each. | [
{
"input": "3 10 3 3",
"output": "2"
},
{
"input": "3 10 1 3",
"output": "3"
},
{
"input": "100 100 1 1000",
"output": "1"
},
{
"input": "5 347 20 1",
"output": "327"
},
{
"input": "6 978 10 5",
"output": "186"
},
{
"input": "6 856 50 35",
"output"... | 62 | 0 | 0 | 5,855 | |
741 | Arpa's weak amphitheater and Mehrdad's valuable Hoses | [
"dfs and similar",
"dp",
"dsu"
] | null | null | Just to remind, girls in Arpa's land are really nice.
Mehrdad wants to invite some Hoses to the palace for a dancing party. Each Hos has some weight *w**i* and some beauty *b**i*. Also each Hos may have some friends. Hoses are divided in some friendship groups. Two Hoses *x* and *y* are in the same friendship group if and only if there is a sequence of Hoses *a*1,<=*a*2,<=...,<=*a**k* such that *a**i* and *a**i*<=+<=1 are friends for each 1<=≤<=*i*<=<<=*k*, and *a*1<==<=*x* and *a**k*<==<=*y*.
Arpa allowed to use the amphitheater of palace to Mehrdad for this party. Arpa's amphitheater can hold at most *w* weight on it.
Mehrdad is so greedy that he wants to invite some Hoses such that sum of their weights is not greater than *w* and sum of their beauties is as large as possible. Along with that, from each friendship group he can either invite all Hoses, or no more than one. Otherwise, some Hoses will be hurt. Find for Mehrdad the maximum possible total beauty of Hoses he can invite so that no one gets hurt and the total weight doesn't exceed *w*. | The first line contains integers *n*, *m* and *w* (1<=<=≤<=<=*n*<=<=≤<=<=1000, , 1<=≤<=*w*<=≤<=1000) — the number of Hoses, the number of pair of friends and the maximum total weight of those who are invited.
The second line contains *n* integers *w*1,<=*w*2,<=...,<=*w**n* (1<=≤<=*w**i*<=≤<=1000) — the weights of the Hoses.
The third line contains *n* integers *b*1,<=*b*2,<=...,<=*b**n* (1<=≤<=*b**i*<=≤<=106) — the beauties of the Hoses.
The next *m* lines contain pairs of friends, the *i*-th of them contains two integers *x**i* and *y**i* (1<=≤<=*x**i*,<=*y**i*<=≤<=*n*, *x**i*<=≠<=*y**i*), meaning that Hoses *x**i* and *y**i* are friends. Note that friendship is bidirectional. All pairs (*x**i*,<=*y**i*) are distinct. | Print the maximum possible total beauty of Hoses Mehrdad can invite so that no one gets hurt and the total weight doesn't exceed *w*. | [
"3 1 5\n3 2 5\n2 4 2\n1 2\n",
"4 2 11\n2 4 6 6\n6 4 2 1\n1 2\n2 3\n"
] | [
"6\n",
"7\n"
] | In the first sample there are two friendship groups: Hoses {1, 2} and Hos {3}. The best way is to choose all of Hoses in the first group, sum of their weights is equal to 5 and sum of their beauty is 6.
In the second sample there are two friendship groups: Hoses {1, 2, 3} and Hos {4}. Mehrdad can't invite all the Hoses from the first group because their total weight is 12 > 11, thus the best way is to choose the first Hos from the first group and the only one from the second group. The total weight will be 8, and the total beauty will be 7. | [
{
"input": "3 1 5\n3 2 5\n2 4 2\n1 2",
"output": "6"
},
{
"input": "4 2 11\n2 4 6 6\n6 4 2 1\n1 2\n2 3",
"output": "7"
},
{
"input": "10 5 100\n70 67 8 64 28 82 18 61 82 7\n596434 595982 237932 275698 361351 850374 936914 877996 789231 331012\n1 7\n2 4\n3 6\n5 7\n1 5",
"output": "238... | 1,000 | 5,427,200 | 0 | 5,873 | |
954 | Path Counting | [
"combinatorics",
"dp"
] | null | null | You are given a rooted tree. Let's denote *d*(*x*) as depth of node *x*: depth of the root is 1, depth of any other node *x* is *d*(*y*)<=+<=1, where *y* is a parent of *x*.
The tree has the following property: every node *x* with *d*(*x*)<==<=*i* has exactly *a**i* children. Maximum possible depth of a node is *n*, and *a**n*<==<=0.
We define *f**k* as the number of unordered pairs of vertices in the tree such that the number of edges on the simple path between them is equal to *k*.
Calculate *f**k* modulo 109<=+<=7 for every 1<=≤<=*k*<=≤<=2*n*<=-<=2. | The first line of input contains an integer *n* (2<=<=≤<=<=*n*<=<=≤<=<=5<=000) — the maximum depth of a node.
The second line of input contains *n*<=-<=1 integers *a*1,<=<=*a*2,<=<=...,<=<=*a**n*<=-<=1 (2<=≤<=<=*a**i*<=<=≤<=109), where *a**i* is the number of children of every node *x* such that *d*(*x*)<==<=*i*. Since *a**n*<==<=0, it is not given in the input. | Print 2*n*<=-<=2 numbers. The *k*-th of these numbers must be equal to *f**k* modulo 109<=+<=7. | [
"4\n2 2 2\n",
"3\n2 3\n"
] | [
"14 19 20 20 16 16 ",
"8 13 6 9 "
] | This the tree from the first sample: | [
{
"input": "4\n2 2 2",
"output": "14 19 20 20 16 16 "
},
{
"input": "3\n2 3",
"output": "8 13 6 9 "
},
{
"input": "2\n2",
"output": "2 1 "
},
{
"input": "6\n2 2 4 2 4",
"output": "182 415 420 980 1216 2432 1536 3328 2048 4096 "
}
] | 77 | 4,403,200 | -1 | 5,879 | |
644 | Processing Queries | [
"*special",
"constructive algorithms",
"data structures",
"two pointers"
] | null | null | In this problem you have to simulate the workflow of one-thread server. There are *n* queries to process, the *i*-th will be received at moment *t**i* and needs to be processed for *d**i* units of time. All *t**i* are guaranteed to be distinct.
When a query appears server may react in three possible ways:
1. If server is free and query queue is empty, then server immediately starts to process this query. 1. If server is busy and there are less than *b* queries in the queue, then new query is added to the end of the queue. 1. If server is busy and there are already *b* queries pending in the queue, then new query is just rejected and will never be processed.
As soon as server finished to process some query, it picks new one from the queue (if it's not empty, of course). If a new query comes at some moment *x*, and the server finishes to process another query at exactly the same moment, we consider that first query is picked from the queue and only then new query appears.
For each query find the moment when the server will finish to process it or print -1 if this query will be rejected. | The first line of the input contains two integers *n* and *b* (1<=≤<=*n*,<=*b*<=≤<=200<=000) — the number of queries and the maximum possible size of the query queue.
Then follow *n* lines with queries descriptions (in chronological order). Each description consists of two integers *t**i* and *d**i* (1<=≤<=*t**i*,<=*d**i*<=≤<=109), where *t**i* is the moment of time when the *i*-th query appears and *d**i* is the time server needs to process it. It is guaranteed that *t**i*<=-<=1<=<<=*t**i* for all *i*<=><=1. | Print the sequence of *n* integers *e*1,<=*e*2,<=...,<=*e**n*, where *e**i* is the moment the server will finish to process the *i*-th query (queries are numbered in the order they appear in the input) or <=-<=1 if the corresponding query will be rejected. | [
"5 1\n2 9\n4 8\n10 9\n15 2\n19 1\n",
"4 1\n2 8\n4 8\n10 9\n15 2\n"
] | [
"11 19 -1 21 22 \n",
"10 18 27 -1 \n"
] | Consider the first sample.
1. The server will start to process first query at the moment 2 and will finish to process it at the moment 11. 1. At the moment 4 second query appears and proceeds to the queue. 1. At the moment 10 third query appears. However, the server is still busy with query 1, *b* = 1 and there is already query 2 pending in the queue, so third query is just rejected. 1. At the moment 11 server will finish to process first query and will take the second query from the queue. 1. At the moment 15 fourth query appears. As the server is currently busy it proceeds to the queue. 1. At the moment 19 two events occur simultaneously: server finishes to proceed the second query and the fifth query appears. As was said in the statement above, first server will finish to process the second query, then it will pick the fourth query from the queue and only then will the fifth query appear. As the queue is empty fifth query is proceed there. 1. Server finishes to process query number 4 at the moment 21. Query number 5 is picked from the queue. 1. Server finishes to process query number 5 at the moment 22. | [
{
"input": "5 1\n2 9\n4 8\n10 9\n15 2\n19 1",
"output": "11 19 -1 21 22 "
},
{
"input": "4 1\n2 8\n4 8\n10 9\n15 2",
"output": "10 18 27 -1 "
},
{
"input": "1 1\n1000000000 1000000000",
"output": "2000000000 "
},
{
"input": "4 3\n999999996 1000000000\n999999997 1000000000\n99... | 3,571 | 6,451,200 | 3 | 5,884 | |
938 | Run For Your Prize | [
"brute force",
"greedy"
] | null | null | You and your friend are participating in a TV show "Run For Your Prize".
At the start of the show *n* prizes are located on a straight line. *i*-th prize is located at position *a**i*. Positions of all prizes are distinct. You start at position 1, your friend — at position 106 (and there is no prize in any of these two positions). You have to work as a team and collect all prizes in minimum possible time, in any order.
You know that it takes exactly 1 second to move from position *x* to position *x*<=+<=1 or *x*<=-<=1, both for you and your friend. You also have trained enough to instantly pick up any prize, if its position is equal to your current position (and the same is true for your friend). Carrying prizes does not affect your speed (or your friend's speed) at all.
Now you may discuss your strategy with your friend and decide who will pick up each prize. Remember that every prize must be picked up, either by you or by your friend.
What is the minimum number of seconds it will take to pick up all the prizes? | The first line contains one integer *n* (1<=≤<=*n*<=≤<=105) — the number of prizes.
The second line contains *n* integers *a*1, *a*2, ..., *a**n* (2<=≤<=*a**i*<=≤<=106<=-<=1) — the positions of the prizes. No two prizes are located at the same position. Positions are given in ascending order. | Print one integer — the minimum number of seconds it will take to collect all prizes. | [
"3\n2 3 9\n",
"2\n2 999995\n"
] | [
"8\n",
"5\n"
] | In the first example you take all the prizes: take the first at 1, the second at 2 and the third at 8.
In the second example you take the first prize in 1 second and your friend takes the other in 5 seconds, you do this simultaneously, so the total time is 5. | [
{
"input": "3\n2 3 9",
"output": "8"
},
{
"input": "2\n2 999995",
"output": "5"
},
{
"input": "1\n20",
"output": "19"
},
{
"input": "6\n2 3 500000 999997 999998 999999",
"output": "499999"
},
{
"input": "1\n999999",
"output": "1"
},
{
"input": "1\n5100... | 202 | 13,004,800 | 3 | 5,890 | |
0 | none | [
"none"
] | null | null | You are given a convex polygon *P* with *n* distinct vertices *p*1,<=*p*2,<=...,<=*p**n*. Vertex *p**i* has coordinates (*x**i*,<=*y**i*) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number *D* and move each vertex of the polygon a distance of at most *D* from their original positions.
Find the maximum value of *D* such that no matter how you move the vertices, the polygon does not intersect itself and stays convex. | The first line has one integer *n* (4<=≤<=*n*<=≤<=1<=000) — the number of vertices.
The next *n* lines contain the coordinates of the vertices. Line *i* contains two integers *x**i* and *y**i* (<=-<=109<=≤<=*x**i*,<=*y**i*<=≤<=109) — the coordinates of the *i*-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line). | Print one real number *D*, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10<=-<=6.
Namely, let's assume that your answer is *a* and the answer of the jury is *b*. The checker program will consider your answer correct if . | [
"4\n0 0\n0 1\n1 1\n1 0\n",
"6\n5 0\n10 0\n12 -4\n10 -8\n5 -8\n3 -4\n"
] | [
"0.3535533906\n",
"1.0000000000\n"
] | Here is a picture of the first sample
<img class="tex-graphics" src="https://espresso.codeforces.com/f83aa076d2f437f9bb785cae769c3ae310eff351.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Here is an example of making the polygon non-convex.
<img class="tex-graphics" src="https://espresso.codeforces.com/fbadb81630251ca642bd4ddf9088876ade761630.png" style="max-width: 100.0%;max-height: 100.0%;"/>
This is not an optimal solution, since the maximum distance we moved one point is  ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most  ≈ 0.3535533906. | [
{
"input": "4\n0 0\n0 1\n1 1\n1 0",
"output": "0.3535533906"
},
{
"input": "6\n5 0\n10 0\n12 -4\n10 -8\n5 -8\n3 -4",
"output": "1.0000000000"
},
{
"input": "19\n449447997 711296339\n530233434 692216537\n535464528 613140435\n535533467 100893188\n530498867 -265063956\n519107979 -271820709\... | 62 | 5,529,600 | 3 | 5,895 | |
538 | Cutting Banner | [
"brute force",
"implementation"
] | null | null | A large banner with word CODEFORCES was ordered for the 1000-th onsite round of Codeforcesω that takes place on the Miami beach. Unfortunately, the company that made the banner mixed up two orders and delivered somebody else's banner that contains someone else's word. The word on the banner consists only of upper-case English letters.
There is very little time to correct the mistake. All that we can manage to do is to cut out some substring from the banner, i.e. several consecutive letters. After that all the resulting parts of the banner will be glued into a single piece (if the beginning or the end of the original banner was cut out, only one part remains); it is not allowed change the relative order of parts of the banner (i.e. after a substring is cut, several first and last letters are left, it is allowed only to glue the last letters to the right of the first letters). Thus, for example, for example, you can cut a substring out from string 'TEMPLATE' and get string 'TEMPLE' (if you cut out string AT), 'PLATE' (if you cut out TEM), 'T' (if you cut out EMPLATE), etc.
Help the organizers of the round determine whether it is possible to cut out of the banner some substring in such a way that the remaining parts formed word CODEFORCES. | The single line of the input contains the word written on the banner. The word only consists of upper-case English letters. The word is non-empty and its length doesn't exceed 100 characters. It is guaranteed that the word isn't word CODEFORCES. | Print 'YES', if there exists a way to cut out the substring, and 'NO' otherwise (without the quotes). | [
"CODEWAITFORITFORCES\n",
"BOTTOMCODER\n",
"DECODEFORCES\n",
"DOGEFORCES\n"
] | [
"YES\n",
"NO\n",
"YES\n",
"NO\n"
] | none | [
{
"input": "CODEWAITFORITFORCES",
"output": "YES"
},
{
"input": "BOTTOMCODER",
"output": "NO"
},
{
"input": "DECODEFORCES",
"output": "YES"
},
{
"input": "DOGEFORCES",
"output": "NO"
},
{
"input": "ABACABA",
"output": "NO"
},
{
"input": "CODEFORCE",
... | 61 | 4,710,400 | 0 | 5,911 | |
977 | Consecutive Subsequence | [
"dp"
] | null | null | You are given an integer array of length $n$.
You have to choose some subsequence of this array of maximum length such that this subsequence forms a increasing sequence of consecutive integers. In other words the required sequence should be equal to $[x, x + 1, \dots, x + k - 1]$ for some value $x$ and length $k$.
Subsequence of an array can be obtained by erasing some (possibly zero) elements from the array. You can erase any elements, not necessarily going successively. The remaining elements preserve their order. For example, for the array $[5, 3, 1, 2, 4]$ the following arrays are subsequences: $[3]$, $[5, 3, 1, 2, 4]$, $[5, 1, 4]$, but the array $[1, 3]$ is not. | The first line of the input containing integer number $n$ ($1 \le n \le 2 \cdot 10^5$) — the length of the array. The second line of the input containing $n$ integer numbers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$) — the array itself. | On the first line print $k$ — the maximum length of the subsequence of the given array that forms an increasing sequence of consecutive integers.
On the second line print the sequence of the indices of the any maximum length subsequence of the given array that forms an increasing sequence of consecutive integers. | [
"7\n3 3 4 7 5 6 8\n",
"6\n1 3 5 2 4 6\n",
"4\n10 9 8 7\n",
"9\n6 7 8 3 4 5 9 10 11\n"
] | [
"4\n2 3 5 6 \n",
"2\n1 4 \n",
"1\n1 \n",
"6\n1 2 3 7 8 9 \n"
] | All valid answers for the first example (as sequences of indices):
- $[1, 3, 5, 6]$ - $[2, 3, 5, 6]$
All valid answers for the second example:
- $[1, 4]$ - $[2, 5]$ - $[3, 6]$
All valid answers for the third example:
- $[1]$ - $[2]$ - $[3]$ - $[4]$
All valid answers for the fourth example:
- $[1, 2, 3, 7, 8, 9]$ | [
{
"input": "7\n3 3 4 7 5 6 8",
"output": "4\n2 3 5 6 "
},
{
"input": "6\n1 3 5 2 4 6",
"output": "2\n1 4 "
},
{
"input": "4\n10 9 8 7",
"output": "1\n1 "
},
{
"input": "9\n6 7 8 3 4 5 9 10 11",
"output": "6\n1 2 3 7 8 9 "
},
{
"input": "1\n1337",
"output": "1\... | 2,000 | 24,678,400 | 0 | 5,914 | |
689 | Mike and Chocolate Thieves | [
"binary search",
"combinatorics",
"math"
] | null | null | Bad news came to Mike's village, some thieves stole a bunch of chocolates from the local factory! Horrible!
Aside from loving sweet things, thieves from this area are known to be very greedy. So after a thief takes his number of chocolates for himself, the next thief will take exactly *k* times more than the previous one. The value of *k* (*k*<=><=1) is a secret integer known only to them. It is also known that each thief's bag can carry at most *n* chocolates (if they intend to take more, the deal is cancelled) and that there were exactly four thieves involved.
Sadly, only the thieves know the value of *n*, but rumours say that the numbers of ways they could have taken the chocolates (for a fixed *n*, but not fixed *k*) is *m*. Two ways are considered different if one of the thieves (they should be numbered in the order they take chocolates) took different number of chocolates in them.
Mike want to track the thieves down, so he wants to know what their bags are and value of *n* will help him in that. Please find the smallest possible value of *n* or tell him that the rumors are false and there is no such *n*. | The single line of input contains the integer *m* (1<=≤<=*m*<=≤<=1015) — the number of ways the thieves might steal the chocolates, as rumours say. | Print the only integer *n* — the maximum amount of chocolates that thieves' bags can carry. If there are more than one *n* satisfying the rumors, print the smallest one.
If there is no such *n* for a false-rumoured *m*, print <=-<=1. | [
"1\n",
"8\n",
"10\n"
] | [
"8\n",
"54\n",
"-1\n"
] | In the first sample case the smallest *n* that leads to exactly one way of stealing chocolates is *n* = 8, whereas the amounts of stealed chocolates are (1, 2, 4, 8) (the number of chocolates stolen by each of the thieves).
In the second sample case the smallest *n* that leads to exactly 8 ways is *n* = 54 with the possibilities: (1, 2, 4, 8),  (1, 3, 9, 27),  (2, 4, 8, 16),  (2, 6, 18, 54),  (3, 6, 12, 24),  (4, 8, 16, 32),  (5, 10, 20, 40),  (6, 12, 24, 48).
There is no *n* leading to exactly 10 ways of stealing chocolates in the third sample case. | [
{
"input": "1",
"output": "8"
},
{
"input": "8",
"output": "54"
},
{
"input": "10",
"output": "-1"
},
{
"input": "27",
"output": "152"
},
{
"input": "28206",
"output": "139840"
},
{
"input": "32",
"output": "184"
},
{
"input": "115",
"o... | 0 | 0 | -1 | 5,916 | |
412 | Network Configuration | [
"greedy",
"sortings"
] | null | null | The R1 company wants to hold a web search championship. There were *n* computers given for the competition, each of them is connected to the Internet. The organizers believe that the data transfer speed directly affects the result. The higher the speed of the Internet is, the faster the participant will find the necessary information. Therefore, before the competition started, each computer had its maximum possible data transfer speed measured. On the *i*-th computer it was *a**i* kilobits per second.
There will be *k* participants competing in the championship, each should get a separate computer. The organizing company does not want any of the participants to have an advantage over the others, so they want to provide the same data transfer speed to each participant's computer. Also, the organizers want to create the most comfortable conditions for the participants, so the data transfer speed on the participants' computers should be as large as possible.
The network settings of the R1 company has a special option that lets you to cut the initial maximum data transfer speed of any computer to any lower speed. How should the R1 company configure the network using the described option so that at least *k* of *n* computers had the same data transfer speed and the data transfer speed on these computers was as large as possible? | The first line contains two space-separated integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=100) — the number of computers and the number of participants, respectively. In the second line you have a space-separated sequence consisting of *n* integers: *a*1,<=*a*2,<=...,<=*a**n* (16<=≤<=*a**i*<=≤<=32768); number *a**i* denotes the maximum data transfer speed on the *i*-th computer. | Print a single integer — the maximum Internet speed value. It is guaranteed that the answer to the problem is always an integer. | [
"3 2\n40 20 30\n",
"6 4\n100 20 40 20 50 50\n"
] | [
"30\n",
"40\n"
] | In the first test case the organizers can cut the first computer's speed to 30 kilobits. Then two computers (the first and the third one) will have the same speed of 30 kilobits. They should be used as the participants' computers. This answer is optimal. | [
{
"input": "3 2\n40 20 30",
"output": "30"
},
{
"input": "6 4\n100 20 40 20 50 50",
"output": "40"
},
{
"input": "1 1\n16",
"output": "16"
},
{
"input": "2 1\n10000 17",
"output": "10000"
},
{
"input": "2 2\n200 300",
"output": "200"
},
{
"input": "3 1... | 62 | 0 | 3 | 5,926 | |
60 | Where Are My Flakes? | [
"implementation",
"two pointers"
] | A. Where Are My Flakes? | 2 | 256 | One morning the Cereal Guy found out that all his cereal flakes were gone. He found a note instead of them. It turned out that his smart roommate hid the flakes in one of *n* boxes. The boxes stand in one row, they are numbered from 1 to *n* from the left to the right. The roommate left hints like "Hidden to the left of the *i*-th box" ("To the left of *i*"), "Hidden to the right of the *i*-th box" ("To the right of *i*"). Such hints mean that there are no flakes in the *i*-th box as well. The Cereal Guy wants to know the minimal number of boxes he necessarily needs to check to find the flakes considering all the hints. Or he wants to find out that the hints are contradictory and the roommate lied to him, that is, no box has the flakes. | The first line contains two integers *n* and *m* (1<=≤<=*n*<=≤<=1000,<=0<=≤<=*m*<=≤<=1000) which represent the number of boxes and the number of hints correspondingly. Next *m* lines contain hints like "To the left of *i*" and "To the right of *i*", where *i* is integer (1<=≤<=*i*<=≤<=*n*). The hints may coincide. | The answer should contain exactly one integer — the number of boxes that should necessarily be checked or "-1" if the hints are contradictory. | [
"2 1\nTo the left of 2\n",
"3 2\nTo the right of 1\nTo the right of 2\n",
"3 1\nTo the left of 3\n",
"3 2\nTo the left of 2\nTo the right of 1\n"
] | [
"1\n",
"1\n",
"2\n",
"-1\n"
] | none | [
{
"input": "2 1\nTo the left of 2",
"output": "1"
},
{
"input": "3 2\nTo the right of 1\nTo the right of 2",
"output": "1"
},
{
"input": "3 1\nTo the left of 3",
"output": "2"
},
{
"input": "3 2\nTo the left of 2\nTo the right of 1",
"output": "-1"
},
{
"input": "... | 92 | 6,963,200 | 0 | 5,936 |
906 | Party | [
"bitmasks",
"brute force",
"dp",
"graphs"
] | null | null | Arseny likes to organize parties and invite people to it. However, not only friends come to his parties, but friends of his friends, friends of friends of his friends and so on. That's why some of Arseny's guests can be unknown to him. He decided to fix this issue using the following procedure.
At each step he selects one of his guests *A*, who pairwise introduces all of his friends to each other. After this action any two friends of *A* become friends. This process is run until all pairs of guests are friends.
Arseny doesn't want to spend much time doing it, so he wants to finish this process using the minimum number of steps. Help Arseny to do it. | The first line contains two integers *n* and *m* (1<=≤<=*n*<=≤<=22; ) — the number of guests at the party (including Arseny) and the number of pairs of people which are friends.
Each of the next *m* lines contains two integers *u* and *v* (1<=≤<=*u*,<=*v*<=≤<=*n*; *u*<=≠<=*v*), which means that people with numbers *u* and *v* are friends initially. It's guaranteed that each pair of friends is described not more than once and the graph of friendship is connected. | In the first line print the minimum number of steps required to make all pairs of guests friends.
In the second line print the ids of guests, who are selected at each step.
If there are multiple solutions, you can output any of them. | [
"5 6\n1 2\n1 3\n2 3\n2 5\n3 4\n4 5\n",
"4 4\n1 2\n1 3\n1 4\n3 4\n"
] | [
"2\n2 3 ",
"1\n1 "
] | In the first test case there is no guest who is friend of all other guests, so at least two steps are required to perform the task. After second guest pairwise introduces all his friends, only pairs of guests (4, 1) and (4, 2) are not friends. Guest 3 or 5 can introduce them.
In the second test case guest number 1 is a friend of all guests, so he can pairwise introduce all guests in one step. | [
{
"input": "5 6\n1 2\n1 3\n2 3\n2 5\n3 4\n4 5",
"output": "2\n2 3 "
},
{
"input": "4 4\n1 2\n1 3\n1 4\n3 4",
"output": "1\n1 "
},
{
"input": "1 0",
"output": "0"
},
{
"input": "2 1\n2 1",
"output": "0"
},
{
"input": "3 2\n1 3\n2 3",
"output": "1\n3 "
},
{
... | 46 | 5,529,600 | -1 | 5,938 | |
622 | Not Equal on a Segment | [
"data structures",
"implementation"
] | null | null | You are given array *a* with *n* integers and *m* queries. The *i*-th query is given with three integers *l**i*,<=*r**i*,<=*x**i*.
For the *i*-th query find any position *p**i* (*l**i*<=≤<=*p**i*<=≤<=*r**i*) so that *a**p**i*<=≠<=*x**i*. | The first line contains two integers *n*,<=*m* (1<=≤<=*n*,<=*m*<=≤<=2·105) — the number of elements in *a* and the number of queries.
The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=106) — the elements of the array *a*.
Each of the next *m* lines contains three integers *l**i*,<=*r**i*,<=*x**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=*n*,<=1<=≤<=*x**i*<=≤<=106) — the parameters of the *i*-th query. | Print *m* lines. On the *i*-th line print integer *p**i* — the position of any number not equal to *x**i* in segment [*l**i*,<=*r**i*] or the value <=-<=1 if there is no such number. | [
"6 4\n1 2 1 1 3 5\n1 4 1\n2 6 2\n3 4 1\n3 4 2\n"
] | [
"2\n6\n-1\n4\n"
] | none | [
{
"input": "6 4\n1 2 1 1 3 5\n1 4 1\n2 6 2\n3 4 1\n3 4 2",
"output": "2\n6\n-1\n4"
},
{
"input": "1 1\n1\n1 1 1",
"output": "-1"
},
{
"input": "1 1\n2\n1 1 2",
"output": "-1"
},
{
"input": "1 1\n569888\n1 1 967368",
"output": "1"
},
{
"input": "10 10\n1 1 1 1 1 1 ... | 1,000 | 2,355,200 | 0 | 5,944 | |
246 | Buggy Sorting | [
"constructive algorithms",
"greedy",
"sortings"
] | null | null | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of *n* integers *a*1,<=*a*2,<=...,<=*a**n* in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number *n* and array *a*.
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of *n* doesn't exist, print -1. | You've got a single integer *n* (1<=≤<=*n*<=≤<=50) — the size of the sorted array. | Print *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of *n* numbers, you are allowed to print any of them. | [
"1\n"
] | [
"-1\n"
] | none | [
{
"input": "1",
"output": "-1"
},
{
"input": "2",
"output": "-1"
},
{
"input": "3",
"output": "3 2 1 "
},
{
"input": "4",
"output": "4 3 2 1 "
},
{
"input": "5",
"output": "5 4 3 2 1 "
},
{
"input": "6",
"output": "6 5 4 3 2 1 "
},
{
"input... | 109 | 0 | 3 | 5,963 | |
61 | Hard Work | [
"strings"
] | B. Hard Work | 2 | 256 | After the contest in comparing numbers, Shapur's teacher found out that he is a real genius and that no one could possibly do the calculations faster than him even using a super computer!
Some days before the contest, the teacher took a very simple-looking exam and all his *n* students took part in the exam. The teacher gave them 3 strings and asked them to concatenate them. Concatenating strings means to put them in some arbitrary order one after the other. For example from concatenating Alireza and Amir we can get to AlirezaAmir or AmirAlireza depending on the order of concatenation.
Unfortunately enough, the teacher forgot to ask students to concatenate their strings in a pre-defined order so each student did it the way he/she liked.
Now the teacher knows that Shapur is such a fast-calculating genius boy and asks him to correct the students' papers.
Shapur is not good at doing such a time-taking task. He rather likes to finish up with it as soon as possible and take his time to solve 3-SAT in polynomial time. Moreover, the teacher has given some advice that Shapur has to follow. Here's what the teacher said:
- As I expect you know, the strings I gave to my students (including you) contained only lowercase and uppercase Persian Mikhi-Script letters. These letters are too much like Latin letters, so to make your task much harder I converted all the initial strings and all of the students' answers to Latin. - As latin alphabet has much less characters than Mikhi-Script, I added three odd-looking characters to the answers, these include "-", ";" and "_". These characters are my own invention of course! And I call them Signs. - The length of all initial strings was less than or equal to 100 and the lengths of my students' answers are less than or equal to 600 - My son, not all students are genius as you are. It is quite possible that they make minor mistakes changing case of some characters. For example they may write ALiReZaAmIR instead of AlirezaAmir. Don't be picky and ignore these mistakes. - Those signs which I previously talked to you about are not important. You can ignore them, since many students are in the mood for adding extra signs or forgetting about a sign. So something like Iran;;-- is the same as --;IRAN - You should indicate for any of my students if his answer was right or wrong. Do this by writing "WA" for Wrong answer or "ACC" for a correct answer. - I should remind you that none of the strings (initial strings or answers) are empty. - Finally, do these as soon as possible. You have less than 2 hours to complete this. | The first three lines contain a string each. These are the initial strings. They consists only of lowercase and uppercase Latin letters and signs ("-", ";" and "_"). All the initial strings have length from 1 to 100, inclusively.
In the fourth line there is a single integer *n* (0<=≤<=*n*<=≤<=1000), the number of students.
Next *n* lines contain a student's answer each. It is guaranteed that the answer meets what the teacher said. Each answer iconsists only of lowercase and uppercase Latin letters and signs ("-", ";" and "_"). Length is from 1 to 600, inclusively. | For each student write in a different line. Print "WA" if his answer is wrong or "ACC" if his answer is OK. | [
"Iran_\nPersian;\nW_o;n;d;e;r;f;u;l;\n7\nWonderfulPersianIran\nwonderful_PersIAN_IRAN;;_\nWONDERFUL___IRAN__PERSIAN__;;\nIra__Persiann__Wonderful\nWonder;;fulPersian___;I;r;a;n;\n__________IranPersianWonderful__________\nPersianIran_is_Wonderful\n",
"Shapur;;\nis___\na_genius\n3\nShapur__a_is___geniUs\nis___shapu... | [
"ACC\nACC\nACC\nWA\nACC\nACC\nWA\n",
"WA\nACC\nACC\n"
] | none | [
{
"input": "Iran_\nPersian;\nW_o;n;d;e;r;f;u;l;\n7\nWonderfulPersianIran\nwonderful_PersIAN_IRAN;;_\nWONDERFUL___IRAN__PERSIAN__;;\nIra__Persiann__Wonderful\nWonder;;fulPersian___;I;r;a;n;\n__________IranPersianWonderful__________\nPersianIran_is_Wonderful",
"output": "ACC\nACC\nACC\nWA\nACC\nACC\nWA"
},
... | 77 | 409,600 | 0 | 5,969 |
919 | Substring | [
"dfs and similar",
"dp",
"graphs"
] | null | null | You are given a graph with $n$ nodes and $m$ directed edges. One lowercase letter is assigned to each node. We define a path's value as the number of the most frequently occurring letter. For example, if letters on a path are "abaca", then the value of that path is $3$. Your task is find a path whose value is the largest. | The first line contains two positive integers $n, m$ ($1 \leq n, m \leq 300\,000$), denoting that the graph has $n$ nodes and $m$ directed edges.
The second line contains a string $s$ with only lowercase English letters. The $i$-th character is the letter assigned to the $i$-th node.
Then $m$ lines follow. Each line contains two integers $x, y$ ($1 \leq x, y \leq n$), describing a directed edge from $x$ to $y$. Note that $x$ can be equal to $y$ and there can be multiple edges between $x$ and $y$. Also the graph can be not connected. | Output a single line with a single integer denoting the largest value. If the value can be arbitrarily large, output -1 instead. | [
"5 4\nabaca\n1 2\n1 3\n3 4\n4 5\n",
"6 6\nxzyabc\n1 2\n3 1\n2 3\n5 4\n4 3\n6 4\n",
"10 14\nxzyzyzyzqx\n1 2\n2 4\n3 5\n4 5\n2 6\n6 8\n6 5\n2 10\n3 9\n10 9\n4 6\n1 10\n2 8\n3 7\n"
] | [
"3\n",
"-1\n",
"4\n"
] | In the first sample, the path with largest value is $1 \to 3 \to 4 \to 5$. The value is $3$ because the letter 'a' appears $3$ times. | [
{
"input": "5 4\nabaca\n1 2\n1 3\n3 4\n4 5",
"output": "3"
},
{
"input": "6 6\nxzyabc\n1 2\n3 1\n2 3\n5 4\n4 3\n6 4",
"output": "-1"
},
{
"input": "10 14\nxzyzyzyzqx\n1 2\n2 4\n3 5\n4 5\n2 6\n6 8\n6 5\n2 10\n3 9\n10 9\n4 6\n1 10\n2 8\n3 7",
"output": "4"
},
{
"input": "1 1\nf... | 92 | 2,252,800 | 0 | 5,970 | |
297 | Color the Carpet | [
"constructive algorithms"
] | null | null | Even polar bears feel cold when lying on the ice. Therefore, a polar bear Alice is going to make a carpet. The carpet can be viewed as a grid with height *h* and width *w*. Then the grid is divided into *h*<=×<=*w* squares. Alice is going to assign one of *k* different colors to each square. The colors are numbered from 1 to *k*. She may choose not to use all of the colors.
However, there are some restrictions. For every two adjacent squares (squares that shares an edge) *x* and *y*, there is a color constraint in one of the forms:
- *color*(*x*)<==<=*color*(*y*), or - *color*(*x*)<=≠<=*color*(*y*).
Example of the color constraints:
Ideally, Alice wants to satisfy all color constraints. But again, life in the Arctic is hard. It is not always possible to satisfy all color constraints. Fortunately, she will still be happy if at least of the color constraints are satisfied.
If she has 4 colors she can color the carpet in the following way:
And she is happy because of the color constraints are satisfied, and . Your task is to help her color the carpet. | The first line contains three integers *h*,<=*w*,<=*k* (2<=≤<=*h*,<=*w*<=≤<=1000,<=1<=≤<=*k*<=≤<=*w*·*h*).
The next 2*h*<=-<=1 lines describe the color constraints from top to bottom, left to right. They contain *w*<=-<=1,<=*w*,<=*w*<=-<=1,<=*w*,<=...,<=*w*<=-<=1 characters respectively. Each color constraint is represented by a character "E" or "N", where "E" means "<==<=" and "N" means "<=≠<=".
The color constraints listed in the order they are depicted on the picture. | If there is a coloring that satisfies at least of the color constraints, print "YES" (without quotes) in the first line. In each of the next *h* lines, print *w* integers describing the coloring.
Otherwise, print "NO" (without quotes). | [
"3 4 4\nENE\nNNEE\nNEE\nENEN\nENN\n"
] | [
"YES\n1 1 2 2\n3 4 1 1\n3 3 2 4"
] | none | [] | 60 | 0 | 0 | 5,976 | |
0 | none | [
"none"
] | null | null | Dreamoon loves summing up something for no reason. One day he obtains two integers *a* and *b* occasionally. He wants to calculate the sum of all nice integers. Positive integer *x* is called nice if and , where *k* is some integer number in range [1,<=*a*].
By we denote the quotient of integer division of *x* and *y*. By we denote the remainder of integer division of *x* and *y*. You can read more about these operations here: http://goo.gl/AcsXhT.
The answer may be large, so please print its remainder modulo 1<=000<=000<=007 (109<=+<=7). Can you compute it faster than Dreamoon? | The single line of the input contains two integers *a*, *b* (1<=≤<=*a*,<=*b*<=≤<=107). | Print a single integer representing the answer modulo 1<=000<=000<=007 (109<=+<=7). | [
"1 1\n",
"2 2\n"
] | [
"0\n",
"8\n"
] | For the first sample, there are no nice integers because <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/03b1dc6bae5180f8a2d8eb85789e8b393e585970.png" style="max-width: 100.0%;max-height: 100.0%;"/> is always zero.
For the second sample, the set of nice integers is {3, 5}. | [
{
"input": "1 1",
"output": "0"
},
{
"input": "2 2",
"output": "8"
},
{
"input": "4 1",
"output": "0"
},
{
"input": "4 2",
"output": "24"
},
{
"input": "4 3",
"output": "102"
},
{
"input": "4 4",
"output": "264"
},
{
"input": "3 4",
"ou... | 62 | 0 | 3 | 5,979 | |
762 | Two strings | [
"binary search",
"hashing",
"strings",
"two pointers"
] | null | null | You are given two strings *a* and *b*. You have to remove the minimum possible number of consecutive (standing one after another) characters from string *b* in such a way that it becomes a subsequence of string *a*. It can happen that you will not need to remove any characters at all, or maybe you will have to remove all of the characters from *b* and make it empty.
Subsequence of string *s* is any such string that can be obtained by erasing zero or more characters (not necessarily consecutive) from string *s*. | The first line contains string *a*, and the second line — string *b*. Both of these strings are nonempty and consist of lowercase letters of English alphabet. The length of each string is no bigger than 105 characters. | On the first line output a subsequence of string *a*, obtained from *b* by erasing the minimum number of consecutive characters.
If the answer consists of zero characters, output «-» (a minus sign). | [
"hi\nbob\n",
"abca\naccepted\n",
"abacaba\nabcdcba\n"
] | [
"-\n",
"ac\n",
"abcba\n"
] | In the first example strings *a* and *b* don't share any symbols, so the longest string that you can get is empty.
In the second example ac is a subsequence of *a*, and at the same time you can obtain it by erasing consecutive symbols cepted from string *b*. | [
{
"input": "hi\nbob",
"output": "-"
},
{
"input": "abca\naccepted",
"output": "ac"
},
{
"input": "abacaba\nabcdcba",
"output": "abcba"
},
{
"input": "lo\neuhaqdhhzlnkmqnakgwzuhurqlpmdm",
"output": "-"
},
{
"input": "aaeojkdyuilpdvyewjfrftkpcobhcumwlaoiocbfdtvjkhgd... | 77 | 5,017,600 | 0 | 5,990 | |
0 | none | [
"none"
] | null | null | A remote island chain contains *n* islands, labeled 1 through *n*. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands *n* and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order. | The first line contains a single integer *n* (2<=≤<=*n*<=≤<=200<=000) — the total number of islands.
The second line contains *n* space-separated integers *a**i* (0<=≤<=*a**i*<=≤<=*n*<=-<=1) — the statue currently placed on the *i*-th island. If *a**i*<==<=0, then the island has no statue. It is guaranteed that the *a**i* are distinct.
The third line contains *n* space-separated integers *b**i* (0<=≤<=*b**i*<=≤<=*n*<=-<=1) — the desired statues of the *i*th island. Once again, *b**i*<==<=0 indicates the island desires no statue. It is guaranteed that the *b**i* are distinct. | Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise. | [
"3\n1 0 2\n2 0 1\n",
"2\n1 0\n0 1\n",
"4\n1 2 3 0\n0 3 2 1\n"
] | [
"YES\n",
"YES\n",
"NO\n"
] | In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position. | [
{
"input": "3\n1 0 2\n2 0 1",
"output": "YES"
},
{
"input": "2\n1 0\n0 1",
"output": "YES"
},
{
"input": "4\n1 2 3 0\n0 3 2 1",
"output": "NO"
},
{
"input": "9\n3 8 4 6 7 1 5 2 0\n6 4 8 5 3 1 2 0 7",
"output": "NO"
},
{
"input": "4\n2 3 1 0\n2 0 1 3",
"output"... | 187 | 18,636,800 | 3 | 5,998 | |
150 | Quantity of Strings | [
"combinatorics",
"dfs and similar",
"graphs",
"math"
] | null | null | Just in case somebody missed it: this winter is totally cold in Nvodsk! It is so cold that one gets funny thoughts. For example, let's say there are strings with the length exactly *n*, based on the alphabet of size *m*. Any its substring with length equal to *k* is a palindrome. How many such strings exist? Your task is to find their quantity modulo 1000000007 (109<=+<=7). Be careful and don't miss a string or two!
Let us remind you that a string is a palindrome if it can be read the same way in either direction, from the left to the right and from the right to the left. | The first and only line contains three integers: *n*, *m* and *k* (1<=≤<=*n*,<=*m*,<=*k*<=≤<=2000). | Print a single integer — the number of strings of the described type modulo 1000000007 (109<=+<=7). | [
"1 1 1\n",
"5 2 4\n"
] | [
"1\n",
"2\n"
] | In the first sample only one string is valid: "a" (let's denote the only letter of our alphabet as "a").
In the second sample (if we denote the alphabet letters as "a" and "b") the following strings are valid: "aaaaa" and "bbbbb". | [
{
"input": "1 1 1",
"output": "1"
},
{
"input": "5 2 4",
"output": "2"
},
{
"input": "7 4 20",
"output": "16384"
},
{
"input": "8 13 9",
"output": "815730721"
},
{
"input": "10 23 9",
"output": "529"
},
{
"input": "10 25 8",
"output": "25"
},
{... | 124 | 0 | 3 | 6,004 | |
190 | Surrounded | [
"geometry"
] | null | null | So, the Berland is at war with its eternal enemy Flatland again, and Vasya, an accountant, was assigned to fulfil his duty to the nation.
Right now the situation in Berland is dismal — their both cities are surrounded! The armies of flatlanders stand on the borders of circles, the circles' centers are in the surrounded cities. At any moment all points of the flatland ring can begin to move quickly in the direction of the city — that's the strategy the flatlanders usually follow when they besiege cities.
The berlanders are sure that they can repel the enemy's attack if they learn the exact time the attack starts. For that they need to construct a radar that would register any movement at the distance of at most *r* from it. Thus, we can install a radar at such point, that at least one point of the enemy ring will be in its detecting range (that is, at a distance of at most *r*). Then the radar can immediately inform about the enemy's attack.
Due to the newest technologies, we can place a radar at any point without any problems. But the problem is that the berlanders have the time to make only one radar. Besides, the larger the detection radius (*r*) is, the more the radar costs.
That's why Vasya's task (that is, your task) is to find the minimum possible detection radius for the radar. In other words, your task is to find the minimum radius *r* (*r*<=≥<=0) such, that a radar with radius *r* can be installed at some point and it can register the start of the movements of both flatland rings from that point.
In this problem you can consider the cities as material points, the attacking enemy rings - as circles with centers in the cities, the radar's detection range — as a disk (including the border) with the center at the point where the radar is placed. | The input files consist of two lines. Each line represents the city and the flatland ring that surrounds it as three space-separated integers *x**i*, *y**i*, *r**i* (|*x**i*|,<=|*y**i*|<=≤<=104; 1<=≤<=*r**i*<=≤<=104) — the city's coordinates and the distance from the city to the flatlanders, correspondingly.
It is guaranteed that the cities are located at different points. | Print a single real number — the minimum detection radius of the described radar. The answer is considered correct if the absolute or relative error does not exceed 10<=-<=6. | [
"0 0 1\n6 0 3\n",
"-10 10 3\n10 -10 3\n"
] | [
"1.000000000000000",
"11.142135623730951"
] | The figure below shows the answer to the first sample. In this sample the best decision is to put the radar at point with coordinates (2, 0).
The figure below shows the answer for the second sample. In this sample the best decision is to put the radar at point with coordinates (0, 0). | [
{
"input": "0 0 1\n6 0 3",
"output": "1.000000000000000"
},
{
"input": "-10 10 3\n10 -10 3",
"output": "11.142135623730951"
},
{
"input": "2 1 3\n8 9 5",
"output": "1.000000000000000"
},
{
"input": "0 0 1\n-10 -10 9",
"output": "2.071067811865475"
},
{
"input": "1... | 93 | 20,172,800 | 0 | 6,021 | |
150 | Win or Freeze | [
"games",
"math",
"number theory"
] | null | null | You can't possibly imagine how cold our friends are this winter in Nvodsk! Two of them play the following game to warm up: initially a piece of paper has an integer *q*. During a move a player should write any integer number that is a non-trivial divisor of the last written number. Then he should run this number of circles around the hotel. Let us remind you that a number's divisor is called non-trivial if it is different from one and from the divided number itself.
The first person who can't make a move wins as he continues to lie in his warm bed under three blankets while the other one keeps running. Determine which player wins considering that both players play optimally. If the first player wins, print any winning first move. | The first line contains the only integer *q* (1<=≤<=*q*<=≤<=1013).
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator. | In the first line print the number of the winning player (1 or 2). If the first player wins then the second line should contain another integer — his first move (if the first player can't even make the first move, print 0). If there are multiple solutions, print any of them. | [
"6\n",
"30\n",
"1\n"
] | [
"2\n",
"1\n6\n",
"1\n0\n"
] | Number 6 has only two non-trivial divisors: 2 and 3. It is impossible to make a move after the numbers 2 and 3 are written, so both of them are winning, thus, number 6 is the losing number. A player can make a move and write number 6 after number 30; 6, as we know, is a losing number. Thus, this move will bring us the victory. | [
{
"input": "6",
"output": "2"
},
{
"input": "30",
"output": "1\n6"
},
{
"input": "1",
"output": "1\n0"
},
{
"input": "2",
"output": "1\n0"
},
{
"input": "3",
"output": "1\n0"
},
{
"input": "5",
"output": "1\n0"
},
{
"input": "445538663413",... | 62 | 0 | 0 | 6,025 | |
20 | Equation | [
"math"
] | B. Equation | 1 | 256 | You are given an equation:
Your task is to find the number of distinct roots of the equation and print all of them in ascending order. | The first line contains three integer numbers *A*,<=*B* and *C* (<=-<=105<=≤<=*A*,<=*B*,<=*C*<=≤<=105). Any coefficient may be equal to 0. | In case of infinite root count print the only integer -1. In case of no roots print the only integer 0. In other cases print the number of root on the first line and the roots on the following lines in the ascending order. Print roots with at least 5 digits after the decimal point. | [
"1 -5 6\n"
] | [
"2\n2.0000000000\n3.0000000000"
] | none | [
{
"input": "1 -5 6",
"output": "2\n2.0000000000\n3.0000000000"
},
{
"input": "1 1 1",
"output": "0"
},
{
"input": "1 2 1",
"output": "1\n-1.0000000000"
},
{
"input": "0 0 0",
"output": "-1"
},
{
"input": "0 -2 1",
"output": "1\n0.5000000000"
},
{
"inpu... | 31 | 0 | 0 | 6,028 |
898 | Phone Numbers | [
"implementation",
"strings"
] | null | null | Vasya has several phone books, in which he recorded the telephone numbers of his friends. Each of his friends can have one or several phone numbers.
Vasya decided to organize information about the phone numbers of friends. You will be given *n* strings — all entries from Vasya's phone books. Each entry starts with a friend's name. Then follows the number of phone numbers in the current entry, and then the phone numbers themselves. It is possible that several identical phones are recorded in the same record.
Vasya also believes that if the phone number *a* is a suffix of the phone number *b* (that is, the number *b* ends up with *a*), and both numbers are written by Vasya as the phone numbers of the same person, then *a* is recorded without the city code and it should not be taken into account.
The task is to print organized information about the phone numbers of Vasya's friends. It is possible that two different people have the same number. If one person has two numbers *x* and *y*, and *x* is a suffix of *y* (that is, *y* ends in *x*), then you shouldn't print number *x*. If the number of a friend in the Vasya's phone books is recorded several times in the same format, it is necessary to take it into account exactly once.
Read the examples to understand statement and format of the output better. | First line contains the integer *n* (1<=≤<=*n*<=≤<=20) — number of entries in Vasya's phone books.
The following *n* lines are followed by descriptions of the records in the format described in statement. Names of Vasya's friends are non-empty strings whose length does not exceed 10. They consists only of lowercase English letters. Number of phone numbers in one entry is not less than 1 is not more than 10. The telephone numbers consist of digits only. If you represent a phone number as a string, then its length will be in range from 1 to 10. Phone numbers can contain leading zeros. | Print out the ordered information about the phone numbers of Vasya's friends. First output *m* — number of friends that are found in Vasya's phone books.
The following *m* lines must contain entries in the following format "name number_of_phone_numbers phone_numbers". Phone numbers should be separated by a space. Each record must contain all the phone numbers of current friend.
Entries can be displayed in arbitrary order, phone numbers for one record can also be printed in arbitrary order. | [
"2\nivan 1 00123\nmasha 1 00123\n",
"3\nkarl 2 612 12\npetr 1 12\nkatya 1 612\n",
"4\nivan 3 123 123 456\nivan 2 456 456\nivan 8 789 3 23 6 56 9 89 2\ndasha 2 23 789\n"
] | [
"2\nmasha 1 00123 \nivan 1 00123 \n",
"3\nkatya 1 612 \npetr 1 12 \nkarl 1 612 \n",
"2\ndasha 2 23 789 \nivan 4 789 123 2 456 \n"
] | none | [
{
"input": "2\nivan 1 00123\nmasha 1 00123",
"output": "2\nmasha 1 00123 \nivan 1 00123 "
},
{
"input": "3\nkarl 2 612 12\npetr 1 12\nkatya 1 612",
"output": "3\nkatya 1 612 \npetr 1 12 \nkarl 1 612 "
},
{
"input": "4\nivan 3 123 123 456\nivan 2 456 456\nivan 8 789 3 23 6 56 9 89 2\ndash... | 92 | 2,457,600 | 3 | 6,056 | |
380 | Sereja and Brackets | [
"data structures",
"schedules"
] | null | null | Sereja has a bracket sequence *s*1,<=*s*2,<=...,<=*s**n*, or, in other words, a string *s* of length *n*, consisting of characters "(" and ")".
Sereja needs to answer *m* queries, each of them is described by two integers *l**i*,<=*r**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=*n*). The answer to the *i*-th query is the length of the maximum correct bracket subsequence of sequence *s**l**i*,<=*s**l**i*<=+<=1,<=...,<=*s**r**i*. Help Sereja answer all queries.
You can find the definitions for a subsequence and a correct bracket sequence in the notes. | The first line contains a sequence of characters *s*1,<=*s*2,<=...,<=*s**n* (1<=≤<=*n*<=≤<=106) without any spaces. Each character is either a "(" or a ")". The second line contains integer *m* (1<=≤<=*m*<=≤<=105) — the number of queries. Each of the next *m* lines contains a pair of integers. The *i*-th line contains integers *l**i*,<=*r**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=*n*) — the description of the *i*-th query. | Print the answer to each question on a single line. Print the answers in the order they go in the input. | [
"())(())(())(\n7\n1 1\n2 3\n1 2\n1 12\n8 12\n5 11\n2 10\n"
] | [
"0\n0\n2\n10\n4\n6\n6\n"
] | A subsequence of length |*x*| of string *s* = *s*<sub class="lower-index">1</sub>*s*<sub class="lower-index">2</sub>... *s*<sub class="lower-index">|*s*|</sub> (where |*s*| is the length of string *s*) is string *x* = *s*<sub class="lower-index">*k*<sub class="lower-index">1</sub></sub>*s*<sub class="lower-index">*k*<sub class="lower-index">2</sub></sub>... *s*<sub class="lower-index">*k*<sub class="lower-index">|*x*|</sub></sub> (1 ≤ *k*<sub class="lower-index">1</sub> < *k*<sub class="lower-index">2</sub> < ... < *k*<sub class="lower-index">|*x*|</sub> ≤ |*s*|).
A correct bracket sequence is a bracket sequence that can be transformed into a correct aryphmetic expression by inserting characters "1" and "+" between the characters of the string. For example, bracket sequences "()()", "(())" are correct (the resulting expressions "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
For the third query required sequence will be «()».
For the fourth query required sequence will be «()(())(())». | [
{
"input": "())(())(())(\n7\n1 1\n2 3\n1 2\n1 12\n8 12\n5 11\n2 10",
"output": "0\n0\n2\n10\n4\n6\n6"
},
{
"input": "(((((()((((((((((()((()(((((\n1\n8 15",
"output": "0"
},
{
"input": "((()((())(((((((((()(()(()(((((((((((((((()(()((((((((((((((()(((((((((((((((((((()(((\n39\n28 56\n39 ... | 93 | 0 | 0 | 6,071 | |
888 | Almost Identity Permutations | [
"combinatorics",
"dp",
"math"
] | null | null | A permutation *p* of size *n* is an array such that every integer from 1 to *n* occurs exactly once in this array.
Let's call a permutation an almost identity permutation iff there exist at least *n*<=-<=*k* indices *i* (1<=≤<=*i*<=≤<=*n*) such that *p**i*<==<=*i*.
Your task is to count the number of almost identity permutations for given numbers *n* and *k*. | The first line contains two integers *n* and *k* (4<=≤<=*n*<=≤<=1000, 1<=≤<=*k*<=≤<=4). | Print the number of almost identity permutations for given *n* and *k*. | [
"4 1\n",
"4 2\n",
"5 3\n",
"5 4\n"
] | [
"1\n",
"7\n",
"31\n",
"76\n"
] | none | [
{
"input": "4 1",
"output": "1"
},
{
"input": "4 2",
"output": "7"
},
{
"input": "5 3",
"output": "31"
},
{
"input": "5 4",
"output": "76"
},
{
"input": "200 1",
"output": "1"
},
{
"input": "200 2",
"output": "19901"
},
{
"input": "200 3",
... | 93 | 307,200 | 0 | 6,073 | |
420 | Bug in Code | [
"data structures",
"graphs",
"implementation",
"two pointers"
] | null | null | Recently a serious bug has been found in the FOS code. The head of the F company wants to find the culprit and punish him. For that, he set up an organizational meeting, the issue is: who's bugged the code? Each of the *n* coders on the meeting said: 'I know for sure that either *x* or *y* did it!'
The head of the company decided to choose two suspects and invite them to his office. Naturally, he should consider the coders' opinions. That's why the head wants to make such a choice that at least *p* of *n* coders agreed with it. A coder agrees with the choice of two suspects if at least one of the two people that he named at the meeting was chosen as a suspect. In how many ways can the head of F choose two suspects?
Note that even if some coder was chosen as a suspect, he can agree with the head's choice if he named the other chosen coder at the meeting. | The first line contains integers *n* and *p* (3<=≤<=*n*<=≤<=3·105; 0<=≤<=*p*<=≤<=*n*) — the number of coders in the F company and the minimum number of agreed people.
Each of the next *n* lines contains two integers *x**i*, *y**i* (1<=≤<=*x**i*,<=*y**i*<=≤<=*n*) — the numbers of coders named by the *i*-th coder. It is guaranteed that *x**i*<=≠<=*i*,<= *y**i*<=≠<=*i*,<= *x**i*<=≠<=*y**i*. | Print a single integer –– the number of possible two-suspect sets. Note that the order of the suspects doesn't matter, that is, sets (1,<=2) и (2,<=1) are considered identical. | [
"4 2\n2 3\n1 4\n1 4\n2 1\n",
"8 6\n5 6\n5 7\n5 8\n6 2\n2 1\n7 3\n1 3\n1 4\n"
] | [
"6\n",
"1\n"
] | none | [
{
"input": "4 2\n2 3\n1 4\n1 4\n2 1",
"output": "6"
},
{
"input": "8 6\n5 6\n5 7\n5 8\n6 2\n2 1\n7 3\n1 3\n1 4",
"output": "1"
},
{
"input": "3 2\n2 3\n3 1\n2 1",
"output": "3"
},
{
"input": "4 1\n3 2\n4 1\n4 2\n1 2",
"output": "6"
},
{
"input": "4 2\n3 4\n4 3\n4 ... | 30 | 0 | 0 | 6,087 | |
921 | Labyrinth-1 | [] | null | null | You have a robot in a two-dimensional labyrinth which consists of *N*<=×<=*M* cells. Some pairs of cells adjacent by side are separated by a wall or a door. The labyrinth itself is separated from the outside with walls around it. Some labyrinth cells are the exits. In order to leave the labyrinth the robot should reach any exit. There are keys in some cells. Any key can open any door but after the door is opened the key stays in the lock. Thus every key can be used only once. There are no labyrinth cells that contain both a key and an exit. Also there can not be both a wall and a door between the pair of adjacent cells.
Your need to write a program in *abc* language (see the language description below) that will lead the robot to one of the exits. Lets numerate the labyrinth rows from 0 to *N*<=-<=1 top to bottom and the columns – from 0 to *M*<=-<=1 left to right.
In *abc* language the following primary commands are available:
- move-DIR – move to the adjacent cell in the direction. *down* increases the number of the row by 1, *right* increases the number of the column by 1. In case there’s a wall or a closed door in this direction, nothing’s happening. - open-DIR – open the door between the current cell and the adjacent one in *DIR* direction. In case there isn’t any door in this direction or it’s already been opened or the robot doesn’t have a key, nothing’s happening.- take – take the key in the current cell. In case there isn’t any key or the robot has already picked it up, nothing’s happening. The robot is able to carry any number of keys.- terminate – terminate the program. This command is not obligatory to use. In case it’s absent the command is added at the end of the program automatically.
Also, there are the following control commands in *abc* language:
- for-N OPS end – repeat the sequence of the *OPS* commands *N* times, 0<=<<=*N*<=≤<=100000. Each loop counter check counts as a command fulfilled by the robot. - if-ok OPS1 else OPS2 endif – carries out the sequence of the *OPS*1 commands, if the previous command of moving, taking the key or opening the door was successful, otherwise the sequence of the *OPS*2 commands is being carried out. Should there be no previous command run, the sequence *OPS*1 will be carried out. If-ok check counts as a command fulfilled by the robot. - break – stops the current *for* loop. - continue – finishes the current *for* loop iterations.
Note that the control and the primary commands can be fit into each other arbitrarily.
The robot will fulfill your commands sequentially until it exits the labyrinth, or it runs out of the commands, or the *terminate* command is run, or the quantity of the fulfilled commands exceeds the bound number 5·106.
In *abc* language each command is a separate word and should be separated from other commands with at least one space symbol.
You should write a program that prints the sequence of commands leading the robot out of the labyrinth. Of course, as you are a good programmer, you should optimize these sequence.
The number of the non-space symbols in the sequence should not exceed 107. If you succeed in finding the way out of the labyrinth *i* you’ll be granted the number of points equal to:
- *W**i* – labyrinth’s weight, some fixed constant. - *G**i* – number of robots moves. - *O**i* – number of fulfilled commands. Note that this number includes commands like *take* executed in the cells with no key, as well as opening commands applied to the already opened doors. - *L**i* – sequence length in symbols, excluding space symbols and line breaks. - *Q*<==<=10·*N*·*M*.
In case your sequence doesn’t lead the robot to the exit you’ll be granted 0 points. Your programs result will be the sum of all *S**i*. You should maximize this total sum.
All labyrinths will be known and available to you. You can download the archive with labyrinths by any of the given links, password to extract files is aimtechiscool:
1. [https://drive.google.com/file/d/1dkIBfW_Gy6c3FJtXjMXZPMsGKRyn3pzp](https://drive.google.com/file/d/1dkIBfW_Gy6c3FJtXjMXZPMsGKRyn3pzp) 1. [https://www.dropbox.com/s/77jrplnjgmviiwt/aimmaze.zip?dl=0](https://www.dropbox.com/s/77jrplnjgmviiwt/aimmaze.zip?dl=0) 1. [https://yadi.sk/d/JNXDLeH63RzaCi](https://yadi.sk/d/JNXDLeH63RzaCi)
In order to make local testing of your programs more convenient, the program calculating your results (checker) and the labyrinth visualizer will be available. This program is written in *python*3 programming language, that’s why you’re going to need *python*3 interpreter, as well as *pillow* library, which you can install with the following command pip3 install pillow. *pip*3 is a utility program for *python*3 package (library) installation. It will be installed automatically with the *python*3 interpreter.
Example command to run checker and visualizer: python3 aimmaze.py maze.in robot.abc --image maze.png. The checker can be run separately of visualization: python3 aimmaze.py maze.in robot.abc. Flag --output-log will let you see the information of robots each step: python3 aimmaze.py maze.in robot.abc --output-log. Note *python*3 can be installed as *python* on your computer.
To adjust image settings, you can edit constants at the beginning of the program *aimmaze*.*py*. | The first line contains integers *i*,<=Â *W*,<=Â *N*,<=Â *M*,<=Â *x*0,<=Â *y*0,<=Â *C*,<=Â *D*,<=Â *K*,<=Â *E*.
- 1<=≤<=*i*<=≤<=14 – labyrinth’s number, which is needed for a checking program. - 1<=≤<=*W*<=≤<=1018 – labyrinth’s weight, which is needed for a checking program. - 2<=≤<=*N*,<=*M*<=≤<=1000 – labyrinth’s height and width. - 0<=≤<=*x*0<=≤<=*N*<=-<=1,<= 0<=≤<=*y*0<=≤<=*M*<=-<=1 – robot’s starting position (*x*0,<=*y*0). - 0<=≤<=*C*<=≤<=2·*NM* – number of walls. - 0<=≤<=*D*<=≤<=105 – number of doors. - 0<=≤<=*K*<=≤<=105 – number of keys. - 1<=≤<=*E*<=≤<=1000 – number of exits.
The *x* coordinate corresponds to the row number, *y* – to the column number. (0,<=0) cell is located on the left-up corner, so that *down* direction increases the *x* coordinate, while *right* direction increases the *y* coordinate.
Each of the next *C* lines contains 4 integers each *x*1,<=*y*1,<=*x*2,<=*y*2 – the coordinates of cells with a wall between them in a zero based indexing. It is guaranteed that |*x*1<=-<=*x*2|<=+<=|*y*1<=-<=*y*2|<==<=1,<= 0<=≤<=*x*1,<=*x*2<=≤<=*N*<=-<=1,<= 0<=≤<=*y*1,<=*y*2<=≤<=*M*<=-<=1. Also there are always walls around the labyrinth’s borders, which are not given in the labyrinths description.
Each of the next *D* lines contains door description in the same format as walls description. It is guaranteed that doors and walls don’t overlap.
Each of the next *K* rows contains a pair of integer which are the key coordinates in a zero based indexing.
Each of the next *E* rows contains a pair of integer which are the exit coordinates in a zero based indexing.
It is guaranteed that the robots starting position as well as keys and exits are located in pairwise different cells. | Print a program in *abc* language which passes the given labyrinth. Commands have to be separated by at least one space symbol. You can use arbitrary formatting for the program. | [
"1 1 30 30 1 1 1 1 1 1\n1 1 1 2\n2 2 2 3\n1 4\n9 0\n"
] | [
"for-1111\n take\n open-up\n open-left\n open-right\n open-down\n move-left\n if-ok\n for-11\n move-left\n take\n open-up\n open-left\n open-right\n open-down\n end\n else\n move-right\n if-ok\n for-11\n move-right\n take\n open-up\n open-left\n open-right\n open-down\... | none | [] | 46 | 5,632,000 | 2 | 6,097 | |
129 | Students and Shoelaces | [
"brute force",
"dfs and similar",
"graphs",
"implementation"
] | null | null | Anna and Maria are in charge of the math club for junior students. When the club gathers together, the students behave badly. They've brought lots of shoe laces to the club and got tied with each other. Specifically, each string ties together two students. Besides, if two students are tied, then the lace connects the first student with the second one as well as the second student with the first one.
To restore order, Anna and Maria do the following. First, for each student Anna finds out what other students he is tied to. If a student is tied to exactly one other student, Anna reprimands him. Then Maria gathers in a single group all the students who have been just reprimanded. She kicks them out from the club. This group of students immediately leaves the club. These students takes with them the laces that used to tie them. Then again for every student Anna finds out how many other students he is tied to and so on. And they do so until Anna can reprimand at least one student.
Determine how many groups of students will be kicked out of the club. | The first line contains two integers *n* and *m* — the initial number of students and laces (). The students are numbered from 1 to *n*, and the laces are numbered from 1 to *m*. Next *m* lines each contain two integers *a* and *b* — the numbers of students tied by the *i*-th lace (1<=≤<=*a*,<=*b*<=≤<=*n*,<=*a*<=≠<=*b*). It is guaranteed that no two students are tied with more than one lace. No lace ties a student to himself. | Print the single number — the number of groups of students that will be kicked out from the club. | [
"3 3\n1 2\n2 3\n3 1\n",
"6 3\n1 2\n2 3\n3 4\n",
"6 5\n1 4\n2 4\n3 4\n5 4\n6 4\n"
] | [
"0\n",
"2\n",
"1\n"
] | In the first sample Anna and Maria won't kick out any group of students — in the initial position every student is tied to two other students and Anna won't be able to reprimand anyone.
In the second sample four students are tied in a chain and two more are running by themselves. First Anna and Maria kick out the two students from both ends of the chain (1 and 4), then — two other students from the chain (2 and 3). At that the students who are running by themselves will stay in the club.
In the third sample Anna and Maria will momentarily kick out all students except for the fourth one and the process stops at that point. The correct answer is one. | [
{
"input": "3 3\n1 2\n2 3\n3 1",
"output": "0"
},
{
"input": "6 3\n1 2\n2 3\n3 4",
"output": "2"
},
{
"input": "6 5\n1 4\n2 4\n3 4\n5 4\n6 4",
"output": "1"
},
{
"input": "100 0",
"output": "0"
},
{
"input": "5 5\n1 2\n2 3\n3 4\n4 5\n5 1",
"output": "0"
},
... | 124 | 307,200 | 3 | 6,124 | |
70 | Cookies | [
"math"
] | A. Cookies | 1 | 256 | Fangy collects cookies. Once he decided to take a box and put cookies into it in some way. If we take a square *k*<=×<=*k* in size, divided into blocks 1<=×<=1 in size and paint there the main diagonal together with cells, which lie above it, then the painted area will be equal to the area occupied by one cookie *k* in size. Fangy also has a box with a square base 2*n*<=×<=2*n*, divided into blocks 1<=×<=1 in size. In a box the cookies should not overlap, and they should not be turned over or rotated. See cookies of sizes 2 and 4 respectively on the figure:
To stack the cookies the little walrus uses the following algorithm. He takes out of the repository the largest cookie which can fit in some place in the box and puts it there. Everything could be perfect but alas, in the repository the little walrus has infinitely many cookies of size 2 and larger, and there are no cookies of size 1, therefore, empty cells will remain in the box. Fangy wants to know how many empty cells will be left in the end. | The first line contains a single integer *n* (0<=≤<=*n*<=≤<=1000). | Print the single number, equal to the number of empty cells in the box. The answer should be printed modulo 106<=+<=3. | [
"3\n"
] | [
"9"
] | If the box possesses the base of 2<sup class="upper-index">3</sup> × 2<sup class="upper-index">3</sup> (as in the example), then the cookies will be put there in the following manner: | [
{
"input": "3",
"output": "9"
},
{
"input": "1",
"output": "1"
},
{
"input": "2",
"output": "3"
},
{
"input": "4",
"output": "27"
},
{
"input": "6",
"output": "243"
},
{
"input": "11",
"output": "59049"
},
{
"input": "14",
"output": "59... | 77 | 0 | 0 | 6,143 |
534 | Exam | [
"constructive algorithms",
"implementation",
"math"
] | null | null | An exam for *n* students will take place in a long and narrow room, so the students will sit in a line in some order. The teacher suspects that students with adjacent numbers (*i* and *i*<=+<=1) always studied side by side and became friends and if they take an exam sitting next to each other, they will help each other for sure.
Your task is to choose the maximum number of students and make such an arrangement of students in the room that no two students with adjacent numbers sit side by side. | A single line contains integer *n* (1<=≤<=*n*<=≤<=5000) — the number of students at an exam. | In the first line print integer *k* — the maximum number of students who can be seated so that no two students with adjacent numbers sit next to each other.
In the second line print *k* distinct integers *a*1,<=*a*2,<=...,<=*a**k* (1<=≤<=*a**i*<=≤<=*n*), where *a**i* is the number of the student on the *i*-th position. The students on adjacent positions mustn't have adjacent numbers. Formally, the following should be true: |*a**i*<=-<=*a**i*<=+<=1|<=≠<=1 for all *i* from 1 to *k*<=-<=1.
If there are several possible answers, output any of them. | [
"6",
"3\n"
] | [
"6\n1 5 3 6 2 4",
"2\n1 3"
] | none | [
{
"input": "6",
"output": "6\n5 3 1 6 4 2 "
},
{
"input": "3",
"output": "2\n1 3"
},
{
"input": "1",
"output": "1\n1 "
},
{
"input": "2",
"output": "1\n1"
},
{
"input": "4",
"output": "4\n3 1 4 2 "
},
{
"input": "5",
"output": "5\n5 3 1 4 2 "
},
... | 124 | 921,600 | 3 | 6,193 | |
999 | Cards and Joy | [
"dp"
] | null | null | There are $n$ players sitting at the card table. Each player has a favorite number. The favorite number of the $j$-th player is $f_j$.
There are $k \cdot n$ cards on the table. Each card contains a single integer: the $i$-th card contains number $c_i$. Also, you are given a sequence $h_1, h_2, \dots, h_k$. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly $k$ cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals $h_t$ if the player holds $t$ cards containing his favorite number. If a player gets no cards with his favorite number (i.e., $t=0$), his joy level is $0$.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence $h_1, \dots, h_k$ is the same for all the players. | The first line of input contains two integers $n$ and $k$ ($1 \le n \le 500, 1 \le k \le 10$) — the number of players and the number of cards each player will get.
The second line contains $k \cdot n$ integers $c_1, c_2, \dots, c_{k \cdot n}$ ($1 \le c_i \le 10^5$) — the numbers written on the cards.
The third line contains $n$ integers $f_1, f_2, \dots, f_n$ ($1 \le f_j \le 10^5$) — the favorite numbers of the players.
The fourth line contains $k$ integers $h_1, h_2, \dots, h_k$ ($1 \le h_t \le 10^5$), where $h_t$ is the joy level of a player if he gets exactly $t$ cards with his favorite number written on them. It is guaranteed that the condition $h_{t - 1} < h_t$ holds for each $t \in [2..k]$. | Print one integer — the maximum possible total joy levels of the players among all possible card distributions. | [
"4 3\n1 3 2 8 5 5 8 2 2 8 5 2\n1 2 2 5\n2 6 7\n",
"3 3\n9 9 9 9 9 9 9 9 9\n1 2 3\n1 2 3\n"
] | [
"21\n",
"0\n"
] | In the first example, one possible optimal card distribution is the following:
- Player $1$ gets cards with numbers $[1, 3, 8]$; - Player $2$ gets cards with numbers $[2, 2, 8]$; - Player $3$ gets cards with numbers $[2, 2, 8]$; - Player $4$ gets cards with numbers $[5, 5, 5]$.
Thus, the answer is $2 + 6 + 6 + 7 = 21$.
In the second example, no player can get a card with his favorite number. Thus, the answer is $0$. | [
{
"input": "4 3\n1 3 2 8 5 5 8 2 2 8 5 2\n1 2 2 5\n2 6 7",
"output": "21"
},
{
"input": "3 3\n9 9 9 9 9 9 9 9 9\n1 2 3\n1 2 3",
"output": "0"
},
{
"input": "1 1\n1\n2\n1",
"output": "0"
},
{
"input": "1 1\n1\n1\n1",
"output": "1"
},
{
"input": "1 1\n1\n1\n100000",... | 187 | 24,268,800 | 3 | 6,250 | |
137 | Postcards and photos | [
"implementation"
] | null | null | Polycarpus has postcards and photos hung in a row on the wall. He decided to put them away to the closet and hang on the wall a famous painter's picture. Polycarpus does it like that: he goes from the left to the right and removes the objects consecutively. As Polycarpus doesn't want any mix-ups to happen, he will not carry in his hands objects of two different types. In other words, Polycarpus can't carry both postcards and photos simultaneously. Sometimes he goes to the closet and puts the objects there, thus leaving his hands free. Polycarpus must put all the postcards and photos to the closet. He cannot skip objects. What minimum number of times he should visit the closet if he cannot carry more than 5 items? | The only line of the input data contains a non-empty string consisting of letters "С" and "P" whose length does not exceed 100 characters. If the *i*-th character in the string is the letter "С", that means that the *i*-th object (the numbering goes from the left to the right) on Polycarpus' wall is a postcard. And if the *i*-th character is the letter "P", than the *i*-th object on the wall is a photo. | Print the only number — the minimum number of times Polycarpus has to visit the closet. | [
"CPCPCPC\n",
"CCCCCCPPPPPP\n",
"CCCCCCPPCPPPPPPPPPP\n",
"CCCCCCCCCC\n"
] | [
"7\n",
"4\n",
"6\n",
"2\n"
] | In the first sample Polycarpus needs to take one item to the closet 7 times.
In the second sample Polycarpus can first take 3 postcards to the closet; then 3 more. He can take the 6 photos that are left in the similar way, going to the closet twice.
In the third sample Polycarpus can visit the closet twice, both times carrying 3 postcards. Then he can take there 2 photos at once, then one postcard and finally, he can carry the last 10 photos if he visits the closet twice.
In the fourth sample Polycarpus can visit the closet twice and take there all 10 postcards (5 items during each go). | [
{
"input": "CPCPCPC",
"output": "7"
},
{
"input": "CCCCCCPPPPPP",
"output": "4"
},
{
"input": "CCCCCCPPCPPPPPPPPPP",
"output": "6"
},
{
"input": "CCCCCCCCCC",
"output": "2"
},
{
"input": "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC... | 92 | 0 | 0 | 6,254 | |
730 | Bottles | [
"dp"
] | null | null | Nick has *n* bottles of soda left after his birthday. Each bottle is described by two values: remaining amount of soda *a**i* and bottle volume *b**i* (*a**i*<=≤<=*b**i*).
Nick has decided to pour all remaining soda into minimal number of bottles, moreover he has to do it as soon as possible. Nick spends *x* seconds to pour *x* units of soda from one bottle to another.
Nick asks you to help him to determine *k* — the minimal number of bottles to store all remaining soda and *t* — the minimal time to pour soda into *k* bottles. A bottle can't store more soda than its volume. All remaining soda should be saved. | The first line contains positive integer *n* (1<=≤<=*n*<=≤<=100) — the number of bottles.
The second line contains *n* positive integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100), where *a**i* is the amount of soda remaining in the *i*-th bottle.
The third line contains *n* positive integers *b*1,<=*b*2,<=...,<=*b**n* (1<=≤<=*b**i*<=≤<=100), where *b**i* is the volume of the *i*-th bottle.
It is guaranteed that *a**i*<=≤<=*b**i* for any *i*. | The only line should contain two integers *k* and *t*, where *k* is the minimal number of bottles that can store all the soda and *t* is the minimal time to pour the soda into *k* bottles. | [
"4\n3 3 4 3\n4 7 6 5\n",
"2\n1 1\n100 100\n",
"5\n10 30 5 6 24\n10 41 7 8 24\n"
] | [
"2 6\n",
"1 1\n",
"3 11\n"
] | In the first example Nick can pour soda from the first bottle to the second bottle. It will take 3 seconds. After it the second bottle will contain 3 + 3 = 6 units of soda. Then he can pour soda from the fourth bottle to the second bottle and to the third bottle: one unit to the second and two units to the third. It will take 1 + 2 = 3 seconds. So, all the soda will be in two bottles and he will spend 3 + 3 = 6 seconds to do it. | [
{
"input": "4\n3 3 4 3\n4 7 6 5",
"output": "2 6"
},
{
"input": "2\n1 1\n100 100",
"output": "1 1"
},
{
"input": "5\n10 30 5 6 24\n10 41 7 8 24",
"output": "3 11"
},
{
"input": "1\n1\n100",
"output": "1 0"
},
{
"input": "1\n100\n100",
"output": "1 0"
},
{
... | 2,000 | 10,137,600 | 0 | 6,260 | |
586 | Laurenty and Shop | [
"implementation"
] | null | null | A little boy Laurenty has been playing his favourite game Nota for quite a while and is now very hungry. The boy wants to make sausage and cheese sandwiches, but first, he needs to buy a sausage and some cheese.
The town where Laurenty lives in is not large. The houses in it are located in two rows, *n* houses in each row. Laurenty lives in the very last house of the second row. The only shop in town is placed in the first house of the first row.
The first and second rows are separated with the main avenue of the city. The adjacent houses of one row are separated by streets.
Each crosswalk of a street or an avenue has some traffic lights. In order to cross the street, you need to press a button on the traffic light, wait for a while for the green light and cross the street. Different traffic lights can have different waiting time.
The traffic light on the crosswalk from the *j*-th house of the *i*-th row to the (*j*<=+<=1)-th house of the same row has waiting time equal to *a**ij* (1<=≤<=*i*<=≤<=2,<=1<=≤<=*j*<=≤<=*n*<=-<=1). For the traffic light on the crossing from the *j*-th house of one row to the *j*-th house of another row the waiting time equals *b**j* (1<=≤<=*j*<=≤<=*n*). The city doesn't have any other crossings.
The boy wants to get to the store, buy the products and go back. The main avenue of the city is wide enough, so the boy wants to cross it exactly once on the way to the store and exactly once on the way back home. The boy would get bored if he had to walk the same way again, so he wants the way home to be different from the way to the store in at least one crossing.
Help Laurenty determine the minimum total time he needs to wait at the crossroads. | The first line of the input contains integer *n* (2<=≤<=*n*<=≤<=50) — the number of houses in each row.
Each of the next two lines contains *n*<=-<=1 space-separated integer — values *a**ij* (1<=≤<=*a**ij*<=≤<=100).
The last line contains *n* space-separated integers *b**j* (1<=≤<=*b**j*<=≤<=100). | Print a single integer — the least total time Laurenty needs to wait at the crossroads, given that he crosses the avenue only once both on his way to the store and on his way back home. | [
"4\n1 2 3\n3 2 1\n3 2 2 3\n",
"3\n1 2\n3 3\n2 1 3\n",
"2\n1\n1\n1 1\n"
] | [
"12\n",
"11\n",
"4\n"
] | The first sample is shown on the figure above.
In the second sample, Laurenty's path can look as follows:
- Laurenty crosses the avenue, the waiting time is 3; - Laurenty uses the second crossing in the first row, the waiting time is 2; - Laurenty uses the first crossing in the first row, the waiting time is 1; - Laurenty uses the first crossing in the first row, the waiting time is 1; - Laurenty crosses the avenue, the waiting time is 1; - Laurenty uses the second crossing in the second row, the waiting time is 3.
In the last sample Laurenty visits all the crossings, so the answer is 4. | [
{
"input": "4\n1 2 3\n3 2 1\n3 2 2 3",
"output": "12"
},
{
"input": "3\n1 2\n3 3\n2 1 3",
"output": "11"
},
{
"input": "2\n1\n1\n1 1",
"output": "4"
},
{
"input": "2\n1\n1\n2 1",
"output": "5"
},
{
"input": "3\n1 100\n1 1\n100 100 100",
"output": "204"
},
... | 77 | 131,481,600 | 3 | 6,262 | |
218 | Mountain Scenery | [
"brute force",
"constructive algorithms",
"implementation"
] | null | null | Little Bolek has found a picture with *n* mountain peaks painted on it. The *n* painted peaks are represented by a non-closed polyline, consisting of 2*n* segments. The segments go through 2*n*<=+<=1 points with coordinates (1,<=*y*1), (2,<=*y*2), ..., (2*n*<=+<=1,<=*y*2*n*<=+<=1), with the *i*-th segment connecting the point (*i*,<=*y**i*) and the point (*i*<=+<=1,<=*y**i*<=+<=1). For any even *i* (2<=≤<=*i*<=≤<=2*n*) the following condition holds: *y**i*<=-<=1<=<<=*y**i* and *y**i*<=><=*y**i*<=+<=1.
We shall call a vertex of a polyline with an even *x* coordinate a mountain peak.
Bolek fancied a little mischief. He chose exactly *k* mountain peaks, rubbed out the segments that went through those peaks and increased each peak's height by one (that is, he increased the *y* coordinate of the corresponding points). Then he painted the missing segments to get a new picture of mountain peaks. Let us denote the points through which the new polyline passes on Bolek's new picture as (1,<=*r*1), (2,<=*r*2), ..., (2*n*<=+<=1,<=*r*2*n*<=+<=1).
Given Bolek's final picture, restore the initial one. | The first line contains two space-separated integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=100). The next line contains 2*n*<=+<=1 space-separated integers *r*1,<=*r*2,<=...,<=*r*2*n*<=+<=1 (0<=≤<=*r**i*<=≤<=100) — the *y* coordinates of the polyline vertices on Bolek's picture.
It is guaranteed that we can obtain the given picture after performing the described actions on some picture of mountain peaks. | Print 2*n*<=+<=1 integers *y*1,<=*y*2,<=...,<=*y*2*n*<=+<=1 — the *y* coordinates of the vertices of the polyline on the initial picture. If there are multiple answers, output any one of them. | [
"3 2\n0 5 3 5 1 5 2\n",
"1 1\n0 2 0\n"
] | [
"0 5 3 4 1 4 2 \n",
"0 1 0 \n"
] | none | [
{
"input": "3 2\n0 5 3 5 1 5 2",
"output": "0 5 3 4 1 4 2 "
},
{
"input": "1 1\n0 2 0",
"output": "0 1 0 "
},
{
"input": "1 1\n1 100 0",
"output": "1 99 0 "
},
{
"input": "3 1\n0 1 0 1 0 2 0",
"output": "0 1 0 1 0 1 0 "
},
{
"input": "3 1\n0 1 0 2 0 1 0",
"out... | 186 | 0 | 0 | 6,307 | |
386 | Fly, freebies, fly! | [
"binary search",
"brute force",
"implementation"
] | null | null | Everyone loves a freebie. Especially students.
It is well-known that if in the night before exam a student opens window, opens the student's record-book and shouts loudly three times "Fly, freebie, fly!" — then flown freebie helps him to pass the upcoming exam.
In the night before the exam on mathematical analysis *n* students living in dormitory shouted treasured words. The *i*-th student made a sacrament at the time *t**i*, where *t**i* is the number of seconds elapsed since the beginning of the night.
It is known that the freebie is a capricious and willful lady. That night the freebie was near dormitory only for *T* seconds. Therefore, if for two students their sacrament times differ for more than *T*, then the freebie didn't visit at least one of them.
Since all students are optimists, they really want to know what is the maximal number of students visited by the freebie can be. | The first line of the input contains integer *n* (1<=≤<=*n*<=≤<=100), where *n* — the number of students shouted "Fly, freebie, fly!" The second line contains *n* positive integers *t**i* (1<=≤<=*t**i*<=≤<=1000).
The last line contains integer *T* (1<=≤<=*T*<=≤<=1000) — the time interval during which the freebie was near the dormitory. | Print a single integer — the largest number of people who will pass exam tomorrow because of the freebie visit. | [
"6\n4 1 7 8 3 8\n1\n"
] | [
"3\n"
] | none | [
{
"input": "6\n4 1 7 8 3 8\n1",
"output": "3"
},
{
"input": "4\n4 2 1 5\n2",
"output": "2"
},
{
"input": "10\n4 7 1 3 8 5 2 1 8 4\n3",
"output": "6"
},
{
"input": "8\n39 49 37 28 40 17 50 2\n10",
"output": "3"
},
{
"input": "2\n1 1\n1",
"output": "2"
},
{
... | 46 | 0 | 3 | 6,319 | |
717 | Potions Homework | [
"implementation",
"sortings"
] | null | null | Harry Water, Ronaldo, Her-my-oh-knee and their friends have started a new school year at their MDCS School of Speechcraft and Misery. At the time, they are very happy to have seen each other after a long time. The sun is shining, birds are singing, flowers are blooming, and their Potions class teacher, professor Snipe is sulky as usual. Due to his angst fueled by disappointment in his own life, he has given them a lot of homework in Potions class.
Each of the *n* students has been assigned a single task. Some students do certain tasks faster than others. Thus, they want to redistribute the tasks so that each student still does exactly one task, and that all tasks are finished. Each student has their own laziness level, and each task has its own difficulty level. Professor Snipe is trying hard to improve their work ethics, so each student’s laziness level is equal to their task’s difficulty level. Both sets of values are given by the sequence *a*, where *a**i* represents both the laziness level of the *i*-th student and the difficulty of his task.
The time a student needs to finish a task is equal to the product of their laziness level and the task’s difficulty. They are wondering, what is the minimum possible total time they must spend to finish all tasks if they distribute them in the optimal way. Each person should receive one task and each task should be given to one person. Print the answer modulo 10<=007. | The first line of input contains integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of tasks. The next *n* lines contain exactly one integer number *a**i* (1<=≤<=*a**i*<=≤<=100<=000) — both the difficulty of the initial task and the laziness of the *i*-th students. | Print the minimum total time to finish all tasks modulo 10<=007. | [
"2\n1\n3\n"
] | [
"6\n"
] | In the first sample, if the students switch their tasks, they will be able to finish them in 3 + 3 = 6 time units. | [
{
"input": "2\n1\n3",
"output": "6"
}
] | 467 | 6,041,600 | 0 | 6,330 | |
0 | none | [
"none"
] | null | null | First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word *s*. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word *abacabaca* is given. This word can be obtained in the following ways: , where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {*aca*,<=*ba*,<=*ca*}. | The only line contains a string *s* (5<=≤<=|*s*|<=≤<=104) consisting of lowercase English letters. | On the first line print integer *k* — a number of distinct possible suffixes. On the next *k* lines print suffixes.
Print suffixes in lexicographical (alphabetical) order. | [
"abacabaca\n",
"abaca\n"
] | [
"3\naca\nba\nca\n",
"0\n"
] | The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix. | [
{
"input": "abacabaca",
"output": "3\naca\nba\nca"
},
{
"input": "abaca",
"output": "0"
},
{
"input": "gzqgchv",
"output": "1\nhv"
},
{
"input": "iosdwvzerqfi",
"output": "9\ner\nerq\nfi\nqfi\nrq\nvz\nvze\nze\nzer"
},
{
"input": "oawtxikrpvfuzugjweki",
"output... | 62 | 5,632,000 | 0 | 6,334 | |
0 | none | [
"none"
] | null | null | The GCD table *G* of size *n*<=×<=*n* for an array of positive integers *a* of length *n* is defined by formula
Let us remind you that the greatest common divisor (GCD) of two positive integers *x* and *y* is the greatest integer that is divisor of both *x* and *y*, it is denoted as . For example, for array *a*<==<={4,<=3,<=6,<=2} of length 4 the GCD table will look as follows:
Given all the numbers of the GCD table *G*, restore array *a*. | The first line contains number *n* (1<=≤<=*n*<=≤<=500) — the length of array *a*. The second line contains *n*2 space-separated numbers — the elements of the GCD table of *G* for array *a*.
All the numbers in the table are positive integers, not exceeding 109. Note that the elements are given in an arbitrary order. It is guaranteed that the set of the input data corresponds to some array *a*. | In the single line print *n* positive integers — the elements of array *a*. If there are multiple possible solutions, you are allowed to print any of them. | [
"4\n2 1 2 3 4 3 2 6 1 1 2 2 1 2 3 2\n",
"1\n42\n",
"2\n1 1 1 1\n"
] | [
"4 3 6 2",
"42 ",
"1 1 "
] | none | [
{
"input": "4\n2 1 2 3 4 3 2 6 1 1 2 2 1 2 3 2",
"output": "2 3 4 6 "
},
{
"input": "1\n42",
"output": "42 "
},
{
"input": "2\n1 1 1 1",
"output": "1 1 "
},
{
"input": "2\n54748096 1 641009859 1",
"output": "54748096 641009859 "
},
{
"input": "3\n1 7 923264237 374... | 202 | 10,444,800 | 0 | 6,349 | |
353 | Two Heaps | [
"combinatorics",
"constructive algorithms",
"greedy",
"implementation",
"math",
"sortings"
] | null | null | Valera has 2·*n* cubes, each cube contains an integer from 10 to 99. He arbitrarily chooses *n* cubes and puts them in the first heap. The remaining cubes form the second heap.
Valera decided to play with cubes. During the game he takes a cube from the first heap and writes down the number it has. Then he takes a cube from the second heap and write out its two digits near two digits he had written (to the right of them). In the end he obtained a single fourdigit integer — the first two digits of it is written on the cube from the first heap, and the second two digits of it is written on the second cube from the second heap.
Valera knows arithmetic very well. So, he can easily count the number of distinct fourdigit numbers he can get in the game. The other question is: how to split cubes into two heaps so that this number (the number of distinct fourdigit integers Valera can get) will be as large as possible? | The first line contains integer *n* (1<=≤<=*n*<=≤<=100). The second line contains 2·*n* space-separated integers *a**i* (10<=≤<=*a**i*<=≤<=99), denoting the numbers on the cubes. | In the first line print a single number — the maximum possible number of distinct four-digit numbers Valera can obtain. In the second line print 2·*n* numbers *b**i* (1<=≤<=*b**i*<=≤<=2). The numbers mean: the *i*-th cube belongs to the *b**i*-th heap in your division.
If there are multiple optimal ways to split the cubes into the heaps, print any of them. | [
"1\n10 99\n",
"2\n13 24 13 45\n"
] | [
"1\n2 1 \n",
"4\n1 2 2 1 \n"
] | In the first test case Valera can put the first cube in the first heap, and second cube — in second heap. In this case he obtain number 1099. If he put the second cube in the first heap, and the first cube in the second heap, then he can obtain number 9910. In both cases the maximum number of distinct integers is equal to one.
In the second test case Valera can obtain numbers 1313, 1345, 2413, 2445. Note, that if he put the first and the third cubes in the first heap, he can obtain only two numbers 1324 and 1345. | [
{
"input": "1\n10 99",
"output": "1\n2 1 "
},
{
"input": "2\n13 24 13 45",
"output": "4\n1 2 2 1 "
},
{
"input": "5\n21 60 18 21 17 39 58 74 62 34",
"output": "25\n1 1 1 2 2 1 2 1 2 2 "
},
{
"input": "10\n26 43 29 92 22 27 95 56 72 55 93 51 91 30 70 77 32 69 87 98",
"outp... | 218 | 6,963,200 | 0 | 6,359 | |
128 | Numbers | [
"constructive algorithms",
"implementation"
] | null | null | One day Anna got the following task at school: to arrange several numbers in a circle so that any two neighboring numbers differs exactly by 1. Anna was given several numbers and arranged them in a circle to fulfill the task. Then she wanted to check if she had arranged the numbers correctly, but at this point her younger sister Maria came and shuffled all numbers. Anna got sick with anger but what's done is done and the results of her work had been destroyed. But please tell Anna: could she have hypothetically completed the task using all those given numbers? | The first line contains an integer *n* — how many numbers Anna had (3<=≤<=*n*<=≤<=105). The next line contains those numbers, separated by a space. All numbers are integers and belong to the range from 1 to 109. | Print the single line "YES" (without the quotes), if Anna could have completed the task correctly using all those numbers (using all of them is necessary). If Anna couldn't have fulfilled the task, no matter how hard she would try, print "NO" (without the quotes). | [
"4\n1 2 3 2\n",
"6\n1 1 2 2 2 3\n",
"6\n2 4 1 1 2 2\n"
] | [
"YES\n",
"YES\n",
"NO\n"
] | none | [
{
"input": "4\n1 2 3 2",
"output": "YES"
},
{
"input": "6\n1 1 2 2 2 3",
"output": "YES"
},
{
"input": "6\n2 4 1 1 2 2",
"output": "NO"
},
{
"input": "4\n999999998 1000000000 999999999 999999999",
"output": "YES"
},
{
"input": "5\n6 7 6 7 6",
"output": "NO"
... | 652 | 18,944,000 | 3 | 6,366 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.