contestId
int64 0
1.01k
| name
stringlengths 2
58
| tags
sequencelengths 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
sequencelengths 0
7
| demo-output
sequencelengths 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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
56 | Domino Principle | [
"binary search",
"data structures",
"sortings"
] | E. Domino Principle | 2 | 256 | Vasya is interested in arranging dominoes. He is fed up with common dominoes and he uses the dominoes of different heights. He put *n* dominoes on the table along one axis, going from left to right. Every domino stands perpendicular to that axis so that the axis passes through the center of its base. The *i*-th domino has the coordinate *x**i* and the height *h**i*. Now Vasya wants to learn for every domino, how many dominoes will fall if he pushes it to the right. Help him do that.
Consider that a domino falls if it is touched strictly above the base. In other words, the fall of the domino with the initial coordinate *x* and height *h* leads to the fall of all dominoes on the segment [*x*<=+<=1,<=*x*<=+<=*h*<=-<=1]. | The first line contains integer *n* (1<=β€<=*n*<=β€<=105) which is the number of dominoes. Then follow *n* lines containing two integers *x**i* and *h**i* (<=-<=108<=β€<=*x**i*<=β€<=108,<=2<=β€<=*h**i*<=β€<=108) each, which are the coordinate and height of every domino. No two dominoes stand on one point. | Print *n* space-separated numbers *z**i* β the number of dominoes that will fall if Vasya pushes the *i*-th domino to the right (including the domino itself). | [
"4\n16 5\n20 5\n10 10\n18 2\n",
"4\n0 10\n1 5\n9 10\n15 10\n"
] | [
"3 1 4 1 ",
"4 1 2 1 "
] | none | [
{
"input": "4\n16 5\n20 5\n10 10\n18 2",
"output": "3 1 4 1 "
},
{
"input": "4\n0 10\n1 5\n9 10\n15 10",
"output": "4 1 2 1 "
},
{
"input": "3\n6 7\n2 9\n-6 10",
"output": "1 2 3 "
},
{
"input": "4\n-6 9\n9 5\n-7 4\n0 9",
"output": "2 1 3 1 "
},
{
"input": "5\n-47 19\n-43 14\n83 27\n-67 46\n-58 98",
"output": "2 1 1 4 3 "
},
{
"input": "6\n20 39\n38 13\n-25 48\n-22 38\n13 39\n90 54",
"output": "2 1 5 4 3 1 "
},
{
"input": "10\n34 9\n-41 26\n-62 32\n1 10\n77 14\n92 7\n-45 35\n75 19\n-23 2\n-46 8",
"output": "1 2 5 1 1 1 3 3 1 4 "
}
] | 2,000 | 17,100,800 | 0 | 49,893 |
201 | Clear Symmetry | [
"constructive algorithms",
"dp",
"math"
] | null | null | Consider some square matrix *A* with side *n* consisting of zeros and ones. There are *n* rows numbered from 1 to *n* from top to bottom and *n* columns numbered from 1 to *n* from left to right in this matrix. We'll denote the element of the matrix which is located at the intersection of the *i*-row and the *j*-th column as *A**i*,<=*j*.
Let's call matrix *A* clear if no two cells containing ones have a common side.
Let's call matrix *A* symmetrical if it matches the matrices formed from it by a horizontal and/or a vertical reflection. Formally, for each pair (*i*,<=*j*) (1<=β€<=*i*,<=*j*<=β€<=*n*) both of the following conditions must be met: *A**i*,<=*j*<==<=*A**n*<=-<=*i*<=+<=1,<=*j* and *A**i*,<=*j*<==<=*A**i*,<=*n*<=-<=*j*<=+<=1.
Let's define the sharpness of matrix *A* as the number of ones in it.
Given integer *x*, your task is to find the smallest positive integer *n* such that there exists a clear symmetrical matrix *A* with side *n* and sharpness *x*. | The only line contains a single integer *x* (1<=β€<=*x*<=β€<=100) β the required sharpness of the matrix. | Print a single number β the sought value of *n*. | [
"4\n",
"9\n"
] | [
"3\n",
"5\n"
] | The figure below shows the matrices that correspond to the samples: | [
{
"input": "4",
"output": "3"
},
{
"input": "9",
"output": "5"
},
{
"input": "10",
"output": "5"
},
{
"input": "12",
"output": "5"
},
{
"input": "1",
"output": "1"
},
{
"input": "19",
"output": "7"
},
{
"input": "3",
"output": "5"
},
{
"input": "2",
"output": "3"
},
{
"input": "5",
"output": "3"
},
{
"input": "6",
"output": "5"
},
{
"input": "7",
"output": "5"
},
{
"input": "8",
"output": "5"
},
{
"input": "11",
"output": "5"
},
{
"input": "13",
"output": "5"
},
{
"input": "14",
"output": "7"
},
{
"input": "15",
"output": "7"
},
{
"input": "16",
"output": "7"
},
{
"input": "17",
"output": "7"
},
{
"input": "18",
"output": "7"
},
{
"input": "20",
"output": "7"
},
{
"input": "21",
"output": "7"
},
{
"input": "22",
"output": "7"
},
{
"input": "23",
"output": "7"
},
{
"input": "24",
"output": "7"
},
{
"input": "25",
"output": "7"
},
{
"input": "26",
"output": "9"
},
{
"input": "27",
"output": "9"
},
{
"input": "28",
"output": "9"
},
{
"input": "29",
"output": "9"
},
{
"input": "30",
"output": "9"
},
{
"input": "31",
"output": "9"
},
{
"input": "32",
"output": "9"
},
{
"input": "33",
"output": "9"
},
{
"input": "34",
"output": "9"
},
{
"input": "35",
"output": "9"
},
{
"input": "36",
"output": "9"
},
{
"input": "37",
"output": "9"
},
{
"input": "38",
"output": "9"
},
{
"input": "39",
"output": "9"
},
{
"input": "40",
"output": "9"
},
{
"input": "41",
"output": "9"
},
{
"input": "42",
"output": "11"
},
{
"input": "43",
"output": "11"
},
{
"input": "44",
"output": "11"
},
{
"input": "45",
"output": "11"
},
{
"input": "46",
"output": "11"
},
{
"input": "47",
"output": "11"
},
{
"input": "48",
"output": "11"
},
{
"input": "49",
"output": "11"
},
{
"input": "50",
"output": "11"
},
{
"input": "51",
"output": "11"
},
{
"input": "52",
"output": "11"
},
{
"input": "53",
"output": "11"
},
{
"input": "54",
"output": "11"
},
{
"input": "55",
"output": "11"
},
{
"input": "56",
"output": "11"
},
{
"input": "57",
"output": "11"
},
{
"input": "58",
"output": "11"
},
{
"input": "59",
"output": "11"
},
{
"input": "60",
"output": "11"
},
{
"input": "61",
"output": "11"
},
{
"input": "62",
"output": "13"
},
{
"input": "63",
"output": "13"
},
{
"input": "64",
"output": "13"
},
{
"input": "65",
"output": "13"
},
{
"input": "66",
"output": "13"
},
{
"input": "67",
"output": "13"
},
{
"input": "68",
"output": "13"
},
{
"input": "69",
"output": "13"
},
{
"input": "70",
"output": "13"
},
{
"input": "71",
"output": "13"
},
{
"input": "72",
"output": "13"
},
{
"input": "73",
"output": "13"
},
{
"input": "74",
"output": "13"
},
{
"input": "75",
"output": "13"
},
{
"input": "76",
"output": "13"
},
{
"input": "77",
"output": "13"
},
{
"input": "78",
"output": "13"
},
{
"input": "79",
"output": "13"
},
{
"input": "80",
"output": "13"
},
{
"input": "81",
"output": "13"
},
{
"input": "82",
"output": "13"
},
{
"input": "83",
"output": "13"
},
{
"input": "84",
"output": "13"
},
{
"input": "85",
"output": "13"
},
{
"input": "86",
"output": "15"
},
{
"input": "87",
"output": "15"
},
{
"input": "88",
"output": "15"
},
{
"input": "89",
"output": "15"
},
{
"input": "90",
"output": "15"
},
{
"input": "91",
"output": "15"
},
{
"input": "92",
"output": "15"
},
{
"input": "93",
"output": "15"
},
{
"input": "94",
"output": "15"
},
{
"input": "95",
"output": "15"
},
{
"input": "96",
"output": "15"
},
{
"input": "97",
"output": "15"
},
{
"input": "98",
"output": "15"
},
{
"input": "99",
"output": "15"
},
{
"input": "100",
"output": "15"
}
] | 124 | 0 | 0 | 49,909 |
|
847 | Noise Level | [
"dfs and similar",
"implementation",
"math"
] | null | null | The Berland's capital has the form of a rectangle with sizes *n*<=Γ<=*m* quarters. All quarters are divided into three types:
- regular (labeled with the character '.') β such quarters do not produce the noise but are not obstacles to the propagation of the noise; - sources of noise (labeled with an uppercase Latin letter from 'A' to 'Z') β such quarters are noise sources and are not obstacles to the propagation of the noise; - heavily built-up (labeled with the character '*') β such quarters are soundproofed, the noise does not penetrate into them and they themselves are obstacles to the propagation of noise.
A quarter labeled with letter 'A' produces *q* units of noise. A quarter labeled with letter 'B' produces 2Β·*q* units of noise. And so on, up to a quarter labeled with letter 'Z', which produces 26Β·*q* units of noise. There can be any number of quarters labeled with each letter in the city.
When propagating from the source of the noise, the noise level is halved when moving from one quarter to a quarter that shares a side with it (when an odd number is to be halved, it's rounded down). The noise spreads along the chain. For example, if some quarter is located at a distance 2 from the noise source, then the value of noise which will reach the quarter is divided by 4. So the noise level that comes from the source to the quarter is determined solely by the length of the shortest path between them. Heavily built-up quarters are obstacles, the noise does not penetrate into them.
The noise level in quarter is defined as the sum of the noise from all sources. To assess the quality of life of the population of the capital of Berland, it is required to find the number of quarters whose noise level exceeds the allowed level *p*. | The first line contains four integers *n*, *m*, *q* and *p* (1<=β€<=*n*,<=*m*<=β€<=250, 1<=β€<=*q*,<=*p*<=β€<=106) β the sizes of Berland's capital, the number of noise units that a quarter 'A' produces, and the allowable noise level.
Each of the following *n* lines contains *m* characters β the description of the capital quarters, in the format that was described in the statement above. It is possible that in the Berland's capital there are no quarters of any type. | Print the number of quarters, in which the noise level exceeds the allowed level *p*. | [
"3 3 100 140\n...\nA*.\n.B.\n",
"3 3 2 8\nB*.\nBB*\nBBB\n",
"3 4 5 4\n..*B\n..**\nD...\n"
] | [
"3\n",
"4\n",
"7\n"
] | The illustration to the first example is in the main part of the statement. | [] | 5,000 | 5,324,800 | 0 | 49,947 |
|
887 | Little Brother | [
"binary search",
"geometry",
"sortings"
] | null | null | Masha's little brother draw two points on a sheet of paper. After that, he draws some circles and gave the sheet to his sister.
Masha has just returned from geometry lesson so she instantly noticed some interesting facts about brother's drawing.
At first, the line going through two points, that brother drew, doesn't intersect or touch any circle.
Also, no two circles intersect or touch, and there is no pair of circles such that one circle is located inside another.
Moreover, for each circle, Masha drew a square of the minimal area with sides parallel axis such that this circle is located inside the square and noticed that there is no two squares intersect or touch and there is no pair of squares such that one square is located inside other.
Now Masha wants to draw circle of minimal possible radius such that it goes through two points that brother drew and doesn't intersect any other circle, but other circles can touch Masha's circle and can be located inside it.
It's guaranteed, that answer won't exceed 1012. It should be held for hacks as well. | First line contains four integers *x*1, *y*1, *x*2, *y*2 (<=-<=105<=β€<=*x*1,<=*y*1,<=*x*2,<=*y*2<=β€<=105)Β β coordinates of points that brother drew. First point has coordinates (*x*1, *y*1) and second point has coordinates (*x*2, *y*2). These two points are different.
The second line contains single integer *n* (1<=β€<=*n*<=β€<=105)Β β the number of circles that brother drew.
Next *n* lines contains descriptions of circles. Each line contains three integers *x**i*, *y**i*, *r**i* (<=-<=105<=β€<=*x**i*,<=*y**i*<=β€<=105, 1<=β€<=*r**i*<=β€<=105) describing circle with center (*x**i*, *y**i*) and radius *r**i*. | Output smallest real number, that it's possible to draw a circle with such radius through given points in such a way that it doesn't intersect other circles.
The output is considered correct if it has a relative or absolute error of at most 10<=-<=4. | [
"2 4 7 13\n3\n3 0 1\n12 4 2\n-4 14 2\n",
"-2 3 10 -10\n2\n7 0 3\n-5 -5 2\n"
] | [
"5.1478150705",
"9.1481831923"
] | <img class="tex-graphics" src="https://espresso.codeforces.com/5a8f62f2439db62d006a0959f077351937f109a0.png" style="max-width: 100.0%;max-height: 100.0%;"/> <img class="tex-graphics" src="https://espresso.codeforces.com/0500120c641e4aab8bb5490323ce5a68957a6621.png" style="max-width: 100.0%;max-height: 100.0%;"/> | [] | 46 | 0 | 0 | 50,085 |
|
374 | Inna and Sequence | [
"binary search",
"data structures",
"dp",
"trees"
] | null | null | Dima's spent much time thinking what present to give to Inna and gave her an empty sequence *w*. Now they want to fill sequence *w* with numbers zero and one. For that, they decided to play an amusing game.
Before the game begins, Dima chooses *m* integers *a*1,<=*a*2,<=...,<=*a**m* (1<=β€<=*a*1<=<<=*a*2<=<<=...<=<<=*a**m*). Then Inna and Dima start playing, that is, adding numbers to sequence *w*. Each new number they choose is added to the end of the sequence. At some moments of time Dima feels that the game is going to end too soon (and he wants to play with Inna as long as possible), so he hits a table hard with his fist. At that the *a*1-th, *a*2-th, *a*3-th, ..., *a**k*-th numbers from the beginning simultaneously fall out of the sequence (the sequence gets *k* numbers less). Here *k* is such maximum number that value *a**k* doesn't exceed the current length of the sequence. If number *a*1 is larger than the current length of *w*, then nothing falls out of the sequence.
You are given the chronological sequence of events in the game. Each event is either adding a number to the end of sequence *w* or Dima's hit on the table. Calculate the sequence *w* after all these events happen. | The first line of the input contains two integers *n* and *m* (1<=β€<=*n*,<=*m*<=β€<=106) showing how many events took place and how many numbers Dima chose.
The next line contains *m* distinct integers *a**i* (1<=β€<=*a**i*<=β€<=106) sorted in the increasing order.
Next *n* lines describe the events in the chronological order. Each line contains a single integer: -1, 0 or 1. Number -1 means that Dima hits the table. Number 0 means that Inna and Dima add number 0 to the end of the sequence. Number 1 means that Inna and Dima add number 1 to the end of the sequence. | In a single line print a sequence of numbers 0 and 1 β the elements of the sequence after all events happen. Print the elements of the sequence in the order from the beginning to the end of the sequence.
If after all events the sequence ends up empty, print "Poor stack!". | [
"10 3\n1 3 6\n-1\n1\n1\n0\n0\n-1\n0\n1\n-1\n1\n",
"2 1\n1\n1\n-1\n"
] | [
"011\n",
"Poor stack!\n"
] | none | [
{
"input": "10 3\n1 3 6\n-1\n1\n1\n0\n0\n-1\n0\n1\n-1\n1",
"output": "011"
},
{
"input": "2 1\n1\n1\n-1",
"output": "Poor stack!"
},
{
"input": "2 1\n1\n-1\n0",
"output": "0"
},
{
"input": "11 2\n2 4\n1\n-1\n1\n-1\n0\n0\n-1\n1\n1\n1\n-1",
"output": "111"
},
{
"input": "4 3\n1 2 4\n1\n0\n1\n-1",
"output": "1"
},
{
"input": "14 3\n1 2 3\n1\n-1\n1\n1\n-1\n1\n1\n1\n-1\n0\n1\n0\n0\n-1",
"output": "0"
}
] | 140 | 0 | 0 | 50,253 |
|
196 | Paint Tree | [
"constructive algorithms",
"divide and conquer",
"geometry",
"sortings",
"trees"
] | null | null | You are given a tree with *n* vertexes and *n* points on a plane, no three points lie on one straight line.
Your task is to paint the given tree on a plane, using the given points as vertexes.
That is, you should correspond each vertex of the tree to exactly one point and each point should correspond to a vertex. If two vertexes of the tree are connected by an edge, then the corresponding points should have a segment painted between them. The segments that correspond to non-adjacent edges, should not have common points. The segments that correspond to adjacent edges should have exactly one common point. | The first line contains an integer *n* (1<=β€<=*n*<=β€<=1500) β the number of vertexes on a tree (as well as the number of chosen points on the plane).
Each of the next *n*<=-<=1 lines contains two space-separated integers *u**i* and *v**i* (1<=β€<=*u**i*,<=*v**i*<=β€<=*n*, *u**i*<=β <=*v**i*) β the numbers of tree vertexes connected by the *i*-th edge.
Each of the next *n* lines contain two space-separated integers *x**i* and *y**i* (<=-<=109<=β€<=*x**i*,<=*y**i*<=β€<=109) β the coordinates of the *i*-th point on the plane. No three points lie on one straight line.
It is guaranteed that under given constraints problem has a solution. | Print *n* distinct space-separated integers from 1 to *n*: the *i*-th number must equal the number of the vertex to place at the *i*-th point (the points are numbered in the order, in which they are listed in the input).
If there are several solutions, print any of them. | [
"3\n1 3\n2 3\n0 0\n1 1\n2 0\n",
"4\n1 2\n2 3\n1 4\n-1 -2\n3 5\n-3 3\n2 0\n"
] | [
"1 3 2\n",
"4 2 1 3\n"
] | The possible solutions for the sample are given below. | [] | 92 | 0 | 0 | 50,265 |
|
633 | Spy Syndrome 2 | [
"data structures",
"dp",
"hashing",
"implementation",
"sortings",
"string suffix structures",
"strings"
] | null | null | After observing the results of Spy Syndrome, Yash realised the errors of his ways. He now believes that a super spy such as Siddhant can't use a cipher as basic and ancient as Caesar cipher. After many weeks of observation of Siddhantβs sentences, Yash determined a new cipher technique.
For a given sentence, the cipher is processed as:
1. Convert all letters of the sentence to lowercase. 1. Reverse each of the words of the sentence individually. 1. Remove all the spaces in the sentence.
For example, when this cipher is applied to the sentence
Kira is childish and he hates losing
the resulting string is
ariksihsidlihcdnaehsetahgnisol
Now Yash is given some ciphered string and a list of words. Help him to find out any original sentence composed using only words from the list. Note, that any of the given words could be used in the sentence multiple times. | The first line of the input contains a single integer *n* (1<=β€<=*n*<=β€<=10<=000)Β β the length of the ciphered text. The second line consists of *n* lowercase English lettersΒ β the ciphered text *t*.
The third line contains a single integer *m* (1<=β€<=*m*<=β€<=100<=000)Β β the number of words which will be considered while deciphering the text. Each of the next *m* lines contains a non-empty word *w**i* (|*w**i*|<=β€<=1<=000) consisting of uppercase and lowercase English letters only. It's guaranteed that the total length of all words doesn't exceed 1<=000<=000. | Print one line β the original sentence. It is guaranteed that at least one solution exists. If there are multiple solutions, you may output any of those. | [
"30\nariksihsidlihcdnaehsetahgnisol\n10\nKira\nhates\nis\nhe\nlosing\ndeath\nchildish\nL\nand\nNote\n",
"12\niherehtolleh\n5\nHI\nHo\nthere\nHeLLo\nhello\n"
] | [
"Kira is childish and he hates losing \n",
"HI there HeLLo \n"
] | In sample case 2 there may be multiple accepted outputs, "HI there HeLLo" and "HI there hello" you may output any of them. | [
{
"input": "30\nariksihsidlihcdnaehsetahgnisol\n10\nKira\nhates\nis\nhe\nlosing\ndeath\nchildish\nL\nand\nNote",
"output": "Kira is childish and he hates losing "
},
{
"input": "12\niherehtolleh\n5\nHI\nHo\nthere\nHeLLo\nhello",
"output": "HI there HeLLo "
},
{
"input": "71\nbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n8\na\naa\naaa\naaaa\naaaaa\naaaaaa\naaaaaaa\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
"output": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab "
},
{
"input": "11\naaaaaaaaaaa\n3\naaaa\naaaaa\naaaaaa",
"output": "aaaaaa aaaaa "
},
{
"input": "5\ncbaed\n6\nbc\nea\nab\ncd\nabc\nde",
"output": "abc de "
},
{
"input": "5\nlehet\n3\nel\nhel\nte",
"output": "hel te "
},
{
"input": "3\naab\n2\na\nbaa",
"output": "baa "
},
{
"input": "3\naab\n2\naa\nbaa",
"output": "baa "
},
{
"input": "9\naaaaaaaaa\n2\naa\naaa",
"output": "aaa aa aa aa "
},
{
"input": "7\nabababc\n2\nba\ncba",
"output": "ba ba cba "
},
{
"input": "7\nkirkirk\n2\nrik\nkrik",
"output": "rik krik "
}
] | 327 | 12,390,400 | -1 | 50,332 |
|
7 | Defining Macros | [
"dp",
"expression parsing",
"implementation"
] | E. Defining Macros | 3 | 256 | Most C/C++ programmers know about excellent opportunities that preprocessor #define directives give; but many know as well about the problems that can arise because of their careless use.
In this problem we consider the following model of #define constructions (also called macros). Each macro has its name and value. The generic syntax for declaring a macro is the following:
#define macro_name macro_value
After the macro has been declared, "macro_name" is replaced with "macro_value" each time it is met in the program (only the whole tokens can be replaced; i.e. "macro_name" is replaced only when it is surrounded by spaces or other non-alphabetic symbol). A "macro_value" within our model can only be an arithmetic expression consisting of variables, four arithmetic operations, brackets, and also the names of previously declared macros (in this case replacement is performed sequentially). The process of replacing macros with their values is called substitution.
One of the main problems arising while using macros β the situation when as a result of substitution we get an arithmetic expression with the changed order of calculation because of different priorities of the operations.
Let's consider the following example. Say, we declared such a #define construction:
#define sum x + y
and further in the program the expression "2 * sum" is calculated. After macro substitution is performed we get "2 * x + y", instead of intuitively expected "2 * (x + y)".
Let's call the situation "suspicious", if after the macro substitution the order of calculation changes, falling outside the bounds of some macro. Thus, your task is to find out by the given set of #define definitions and the given expression if this expression is suspicious or not.
Let's speak more formally. We should perform an ordinary macros substitution in the given expression. Moreover, we should perform a "safe" macros substitution in the expression, putting in brackets each macro value; after this, guided by arithmetic rules of brackets expansion, we can omit some of the brackets. If there exist a way to get an expression, absolutely coinciding with the expression that is the result of an ordinary substitution (character-by-character, but ignoring spaces), then this expression and the macros system are called correct, otherwise β suspicious.
Note that we consider the "/" operation as the usual mathematical division, not the integer division like in C/C++. That's why, for example, in the expression "a*(b/c)" we can omit brackets to get the expression "a*b/c". | The first line contains the only number *n* (0<=β€<=*n*<=β€<=100) β the amount of #define constructions in the given program.
Then there follow *n* lines, each of them contains just one #define construction. Each construction has the following syntax:
#define name expression
where
- name β the macro name, - expression β the expression with which the given macro will be replaced. An expression is a non-empty string, containing digits,names of variables, names of previously declared macros, round brackets and operational signs +-*/. It is guaranteed that the expression (before and after macros substitution) is a correct arithmetic expression, having no unary operations. The expression contains only non-negative integers, not exceeding 109.
All the names (#define constructions' names and names of their arguments) are strings of case-sensitive Latin characters. It is guaranteed that the name of any variable is different from any #define construction.
Then, the last line contains an expression that you are to check. This expression is non-empty and satisfies the same limitations as the expressions in #define constructions.
The input lines may contain any number of spaces anywhere, providing these spaces do not break the word "define" or the names of constructions and variables. In particular, there can be any number of spaces before and after the "#" symbol.
The length of any line from the input file does not exceed 100 characters. | Output "OK", if the expression is correct according to the above given criterion, otherwise output "Suspicious". | [
"1\n#define sum x + y\n1 * sum\n",
"1\n#define sum (x + y)\nsum - sum\n",
"4\n#define sum x + y\n#define mul a * b\n#define div a / b\n#define expr sum + mul * div * mul\nexpr\n",
"3\n#define SumSafe (a+b)\n#define DivUnsafe a/b\n#define DenominatorUnsafe a*b\n((SumSafe) + DivUnsafe/DivUnsafe + x/DenominatorUnsafe)\n"
] | [
"Suspicious\n",
"OK\n",
"OK\n",
"Suspicious\n"
] | none | [
{
"input": "1\n#define sum x + y\n1 * sum",
"output": "Suspicious"
},
{
"input": "1\n#define sum (x + y)\nsum - sum",
"output": "OK"
},
{
"input": "4\n#define sum x + y\n#define mul a * b\n#define div a / b\n#define expr sum + mul * div * mul\nexpr",
"output": "OK"
},
{
"input": "3\n#define SumSafe (a+b)\n#define DivUnsafe a/b\n#define DenominatorUnsafe a*b\n((SumSafe) + DivUnsafe/DivUnsafe + x/DenominatorUnsafe)",
"output": "Suspicious"
},
{
"input": "0\naa + b - c * (ddd * eee / fff * a / b * c + d - b + c - (a + b)) - d",
"output": "OK"
},
{
"input": "2\n#define a b\n#define c d\na + b + c + d + 1234567 -10*(2-2+1000*1000*1000*1000*1000)",
"output": "OK"
},
{
"input": "2\n # define macros ( x + y ) \n # define Macros (x+y)\nmacros/Macros",
"output": "OK"
},
{
"input": "2\n#define A v\n#define a v/v/v\nv/A",
"output": "OK"
},
{
"input": "2\n#define A v\n#define a v/v/v\nv/a",
"output": "Suspicious"
},
{
"input": "2\n#define A v\n#define a v/v/v\nv/(a)",
"output": "OK"
},
{
"input": "1\n#define a x*y\nc/a",
"output": "Suspicious"
},
{
"input": "1\n#define a b*c\na/a*a",
"output": "Suspicious"
},
{
"input": "3\n#define mul x*y\n#define bad x/mul\n#define good x/(mul)\ngood",
"output": "OK"
},
{
"input": "4\n#define sum xx+yy\n#define difference aaaa-bbbBBBB\n#define mult a*b\n#define division aaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nsum+difference+(sum)*(difference)-mult+mult*division+division*mult+division/(mult+sum-(difference))",
"output": "OK"
},
{
"input": "4\n#define sum xx+yy\n#define difference aaaa-bbbBBBB\n#define multiplication a*b\n#define division aaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n(difference/division)+sum",
"output": "Suspicious"
},
{
"input": "4\n#define sum xx+yy\n#define difference aaaa-bbbBBBB\n#define multiplication a*b\n#define division aaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n(difference)*sum",
"output": "Suspicious"
},
{
"input": "4\n#define sum xx+yy\n#define difference aaaa-bbbBBBB\n#define multiplication a*b\n#define division aaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n(sum)/multiplication",
"output": "Suspicious"
},
{
"input": "4\n#define sum xx+yy\n#define difference aaaa-bbbBBBB\n#define multiplication a*b\n#define division aaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nsum/(multiplication)",
"output": "Suspicious"
},
{
"input": "5\n#define sum xx+yy\n#define difference aaaa-bbbBBBB\n#define multiplication a*b\n#define division aaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n#define res (0-difference)\nsum+res*multiplication",
"output": "Suspicious"
},
{
"input": "4\n#define sum xx+yy\n#define difference aaaa-bbbBBBB\n#define multiplication a*b\n#define division aaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\ndivision/(multiplication/(division)/DIVISION/(sum-division-multiplication-(difference)))",
"output": "OK"
},
{
"input": "3\n#define sum x + y\n#define SomeBad (2 * sum)\n#define SomePossiblyGood 0 * SomeBad + (x + x - 2*x) * SomeBad\nSomePossiblyGood",
"output": "Suspicious"
},
{
"input": "2\n#define a 0\n#define b (a-a)*(x/x-1)\nb-b/b*b",
"output": "Suspicious"
},
{
"input": "2\n#define fkdsjfslkjfsdk x/0\n#define fkdsjfslkjfsdksdds 0/(0-0)\nfkdsjfslkjfsdk + fkdsjfslkjfsdks + fkdsjfslkjfsdkssds",
"output": "OK"
},
{
"input": "3\n#define null x/0\n#define some x/x\n#define bad 1/x\nbad/0+0/bad+0/0*bad",
"output": "Suspicious"
},
{
"input": "3\n#define MWjGY x+x*53 *x\n#define ovqZ 2/926+x/A\n#define uU 55-qRj*A*2\nx*A/x-A",
"output": "OK"
},
{
"input": "4\n#define zz 5+7/x*x*9\n#define mlTL 6+x/7+x/x\n#define DUO 7*7-x+zz\n#define IH 6*4-x+x\n67/(5)-IH",
"output": "Suspicious"
},
{
"input": "5\n#define Oc 9/51+65+vN\n#define gga 53/ 94/x/x\n#define ArB x/x/9-77-8\n#define j 76-6/93+vN\n#define cALNN Oc+60499\n8*6-66/x*x",
"output": "OK"
},
{
"input": "3\n#define fSdvwOj (W)*W+73\n#define NAZjc 7695*55-x\n#define AHGGglVwch (6-a-W)\n((5))+W+W",
"output": "OK"
},
{
"input": "4\n#define m bJJD +x \n#define yYkQNzjR (x*19)-892\n#define MNvfxqfbq (x-6*x/8)\n#define nJZdvO 8/4 *m/m\n 9+m/x+x",
"output": "Suspicious"
},
{
"input": "5\n#define Sl x*7-(x)/O\n#define srAOHccTln 3+x*2*O\n#define OFAZk 239751817\n#define JYWrOEgazV (x-O/4)-x\n#define XsOZvalgOh 89905879/7\nx/Sl-(Sl)",
"output": "Suspicious"
},
{
"input": "3\n#define uYdw ((9-x-3) )\n#define fy (((x+21)))\n#define nY ((2+x)-46)\n141141432",
"output": "OK"
},
{
"input": "4\n#define GCvqH (58 )-(x)\n#define g ((x/x+x))\n#define spst hQTJ\n#define i GCvqH\n(((x+6)))",
"output": "OK"
},
{
"input": "5\n#define rg (67)+((x))\n#define ya x-(6/x)*rg\n#define anTxe 10*ya*(x)\n#define xcmo ((x)*(vT))\n#define eg ((vT)) -ya\n((x*(Ii)))",
"output": "OK"
},
{
"input": "3\n#define T ((b/1 +1))\n#define pm (s)-43-(s)\n#define jkNBpvDZl ((x ))/65\n(((58*7)))",
"output": "OK"
},
{
"input": "4\n#define cJitUt 21/(4)+4+4\n#define zHwBOLIvF 4*((41/x))\n#define GbtYVo (E)+(x+3)\n#define zTcZBaby (58)+x-x+x\n(E+E)/8 *4",
"output": "OK"
},
{
"input": "5\n#define mBURKdeKvy 266693986\n#define nWi ( ((x))-4)\n#define iYreeOt ((7/x+42))\n#define laLzP ((aB/35)) \n#define dXjRJ (((B*hX)))\n(1*2+(67))",
"output": "OK"
},
{
"input": "3\n#define UVMQLGvEqOxaAgRkvJH tBd\n#define QoAsBMaUcJzXai x/x-hm/83+8*8/5/hm /x/hm\n#define QtxtzEHCmidm 75 +491928441\n((x)/VUpYoEdDUtLFanGyqfQR )",
"output": "OK"
},
{
"input": "4\n#define efemx 2/1*3*69+81+10/690445104\n#define AyjrEzAjMKZpRPfCOaO 21*9+( j*40+3*4)*ND+w-j*j+x*55\n#define YkJkHcNhXcci 85*3215/40/365819568\n#define MUzvOZSXJujI 9-4/j*j-7-w*23*5+j+9-9*ND*2/37\nND/j*28 -1* ND+22889023/j/j/j",
"output": "OK"
},
{
"input": "5\n#define QNUkjqPcGWF 6*4/908975666-7/10-x*7\n#define xqwhNWiiMaZOcmgiXYY 3936*(e*5*H+2)-TsA+(e)/1-25\n#define tRsSqfqJt ((uT*82/e)+e/(23+(45)-9)+(50))\n#define DtIOWRkYe (8*3/9)*e*x *60041512*2-(e)\n#define qgPgxja (4/x+e/uT*16358009- 6/13*5)\ne+x*e/84/x+uT*H",
"output": "OK"
},
{
"input": "3\n#define lTCUUO JQmj\n#define oUeQMB (12*x+x+x)-75-(79/1)-(7)*1/mr\n#define LAQu xwvBtky\n8654 *1*5-mr-3*J/oUeQMB/x/6/9",
"output": "Suspicious"
},
{
"input": "4\n#define VLuQIO 1-x/33+ Fk+wS/35-wS-(x*iz )\n#define BCIsIR 5*(wS)/x/iz/1+x-x-4-x/68/x/8*x\n#define QPUpmTiB 21-x/895912506+2\n#define wcZLUIqJS 7/65-x*61-(24+iz)+x+315670+x/x\nBCIsIR/VLuQIO",
"output": "Suspicious"
},
{
"input": "5\n#define FDmMYOENCOKmYwYlOl 6-(L)/((((ud/x))/ud-26*8-5))\n#define QkopKBjKdJxhc (6)*4/7-L/781844832 \n#define UjgTieUBXTSTbiLFAhkV 3*1*(52)/6-6*65/x+((L-56))+x+x\n#define yWVYDuqliezpKLwnI 8/4+1+88+97946+(1)-((68))-L/L\n#define AvvED 719901121+95/2/78/1-10+37\n(1*x+ 528176190+17/ud)",
"output": "OK"
},
{
"input": "3\n#define e x *R/5+(x)+4/18/x*R/x-8+1+R\n#define GgGqGYjXoJjIezAVu (( 491563947*R))*9-e-3/4\n#define XgznGUWMxQwh (8/R+4*(e)+10/4*x+24*R+21)-224\n (82493582)",
"output": "OK"
},
{
"input": "4\n#define MrKSTrKhPLeJqOcEPvv (x+x/x)/Qdf-x-x-(2/23)+9442-x\n#define zPHUgmIYE 10- 7*x/x+VwRUuIRezDR*80\n#define OsfThxasHeFZCEZTfD 271456028-(x*x)-8+2*x*x*x+(x)\n#define zVYasB x/x -x-(51)-x*x*((x)) /x \n(x/64-x*( (5+x+x)-(37)/3*22))",
"output": "OK"
},
{
"input": "5\n#define WREol (fcdGZaLzhiFpVQmhHO)\n#define lDTNxcMqPPP 3+(57)/x/91540-x*71-x*6-((1))\n#define afFJVBkr ((12*x-8+9 *lDlx+7+lDlx))\n#define mYEizEWrNtRSQNCcDQrn 732480960+9+x-78-x/1+12*x\n#define IZTmjheAahbNSNFa ((x-x*7+407643063 ))\nXQvMxLNpQnhpimNhAkfX",
"output": "OK"
},
{
"input": "3\n#define Mc x+x*55231- x/x/x+35/x*(5*(x)) -5*x*(1-2-(29/1))\n#define afSVLCdjvylSu bgqv/6+4*x*((Mc/1318/x-8-4)-Mc/Mc/(9))\n#define ZOSV (1+2/x+6* 174806683)-x/x*Mc+52*x-x\nbgqv-x-6*x/72/(x )/afSVLCdjvylSu",
"output": "Suspicious"
},
{
"input": "4\n#define RJIiiGQqn dmpWFcrqQeM+V-o* 55/9*o-o/V*V*o\n#define ElDZlrtzDkeKgsX 498718105* 3/(y)/(4)-(5*x)*1\n#define qwKl jHqPHX\n#define qXzAZkCuchBYR (qy*qwKl-6+5*1+2)-7-3+(38)-o*4/4-1-V*x/6+1*x/o\no*((V))-o+2+((((2*V)/V-o*V/4)))/o*33+y/7 -x+x ",
"output": "OK"
},
{
"input": "5\n#define WTovyGexUNjGMRJv (MQG*18-6)/x/x*x/x-x*akNyw*x+x-x/2/x*20\n#define hpextyhVCa 70*x/67-x*87931-(497612505-7*x-MQG)-x\n#define MRkKnCXFt x-5-21962-x/sOmThNSS/x/6-4+(65+57+x+x+7-7+x/x)\n#define ajsczBLLklBSqqh nGj-38*9 *x/47/8*5/5-72/x*x-x*x*31 /7-44-3+64\n#define jgqfv WTovyGexUNjGMRJv\n 4+338/x*x+13 -795*3-74*2/4+563-x/76401438/83025",
"output": "OK"
},
{
"input": "3\n#define G u+13-35348/2-(u/u)-u/u*u*(OC)-OC -u-u/u*u/9 \n#define RNRQ G*G*u+G/755750/G/G +((u-6*G+6)*2)- 5*96+5/u*275-u\n#define Zg 94363/u*u-41+Gm*G-81/5-1-G*G*x-(5517*5/4)*21 +75\n406690013/WM*G+(u+u)*Zg+2",
"output": "Suspicious"
},
{
"input": "4\n#define RMWAZhIp x*x+12+94*12*5*1-x-141915293\n#define EeguG 9-55+x/29+x+x/E*8*81/x-x*75-4*17-81/x/6+619978*x*x\n#define HvUYEvQTyYmBGvqHSb 454574730/644135926*x/23+E-sy/14\n#define BqMGcT x/(43)+819897061-x*(7/x)-(x)+sy-E-x*79-E+(x)/6/63\n76+3/x/8*x+E-76+sy-sy+9*6/66/sy-77+x-x*sy+E/50/64",
"output": "OK"
},
{
"input": "5\n#define cbt ((((d))+9-3+ (d)/d/6*SDDNqj*50/d+d-m+8/d/1)) \n#define gLrUE 18+ 70*d/3-d*d-d/35 +33-5/9+d-d*387+d-1\n#define AvjmK 9-d-8+(d+m+5/2/x*d+1)/x/d-5-2*(m)+d+17/d+ 4/52/8\n#define SjrJ 90/7/5/d+ 254877982+(m) *x-19\n#define PlykoqfDbwxR 540304590 +d*x/11-(m+d-d-4)*(d-3-1)/d\nd-2+1+46-29620+9-(9*3 /d)*6*m/d+9+(1670)/cbt/d+d",
"output": "OK"
},
{
"input": "3\n#define BuAiJLgAlkj x-3+419032556/409023036-(17*84)+x+8+A\n#define wU 516506880\n#define HeyDGlnaGxBaHjzelvF iRSPqHfgHw/4-(99)*(I)+A+I-9*46*x\nI/CRklg-HeyDGlnaGxBaHjzelvF/3+5 ",
"output": "Suspicious"
},
{
"input": "4\n#define SOlTohcPGckDyF ((D)/G-83+KHGSuJFLHqD/5)\n#define KEUXeOYpg 9+x-8-8/x/9-65-6+4+55*x-58/x+84+D*2-7+D/x-x*G/4-2\n#define YZl (1/67*x*6/2*G)-D/1595107*D+6/x*1+D+3/9/x/26-6+9 \n#define gCatFsZn uBBqilYclMhpVfKKTkGK\n(28682537+ YZl*(4*52) )*x/8- gCatFsZn*x/54/7",
"output": "Suspicious"
},
{
"input": "5\n#define iiXEqDYeyVmIYsOaO fj/x-9-6/x*x+ 1/ 7*2-x -x+9+235*23*Ww+x-2*K+2-x/70\n#define XVgLzhoTUxoBr ( x+x/x/x*6-x)* x+K/24206-2 /5/8-x-7/Ww/K-x+6 \n#define QdfRBaJk 470551685-( 54-x)-30\n#define gEJcAGnF x+x-x+(x/x+9)/x-41-1/fj/1157561+x/x -x/26/x+K*x\n#define lO 7-1*(x*58 )-K*fj /722113691/x/K+2\n2+4*85/86/x*27 /49252-x*x/6-83-7/x+x+K-lO+8-K-x",
"output": "Suspicious"
},
{
"input": "1\n#define sum x+y\nr-sum",
"output": "Suspicious"
},
{
"input": "1\n#define sum x+y\nr+sum",
"output": "OK"
},
{
"input": "1\n#define sum x+y\nr*sum",
"output": "Suspicious"
},
{
"input": "1\n#define sum x+y\nr/sum",
"output": "Suspicious"
},
{
"input": "1\n#define sum x-y\nr+sum",
"output": "OK"
},
{
"input": "1\n#define sum x-y\nr-sum",
"output": "Suspicious"
},
{
"input": "1\n#define sum x-y\nr*sum",
"output": "Suspicious"
},
{
"input": "1\n#define sum x-y\nr/sum",
"output": "Suspicious"
},
{
"input": "1\n#define sum x*y\nr+sum",
"output": "OK"
},
{
"input": "1\n#define sum x*y\nr-sum",
"output": "OK"
},
{
"input": "1\n#define sum x*y\nr*sum",
"output": "OK"
},
{
"input": "1\n#define sum x*y\nr/sum",
"output": "Suspicious"
},
{
"input": "1\n#define sum x/y\nr+sum",
"output": "OK"
},
{
"input": "1\n#define sum x/y\nr-sum",
"output": "OK"
},
{
"input": "1\n#define sum x/y\nr*sum",
"output": "OK"
},
{
"input": "1\n#define sum x/y\nr/sum",
"output": "Suspicious"
},
{
"input": "1\n#define sum x+y\nsum+r",
"output": "OK"
},
{
"input": "1\n#define sum x+y\nsum-r",
"output": "OK"
},
{
"input": "1\n#define sum x+y\nsum*r",
"output": "Suspicious"
},
{
"input": "1\n#define sum x+y\nsum/r",
"output": "Suspicious"
},
{
"input": "1\n#define sum x-y\nsum+r",
"output": "OK"
},
{
"input": "1\n#define sum x-y\nsum-r",
"output": "OK"
},
{
"input": "1\n#define sum x-y\nsum*r",
"output": "Suspicious"
},
{
"input": "1\n#define sum x-y\nsum/r",
"output": "Suspicious"
},
{
"input": "1\n#define sum x*y\nsum+r",
"output": "OK"
},
{
"input": "1\n#define sum x*y\nsum-r",
"output": "OK"
},
{
"input": "1\n#define sum x*y\nsum*r",
"output": "OK"
},
{
"input": "1\n#define sum x*y\nsum/r",
"output": "OK"
},
{
"input": "1\n#define sum x/y\nsum+r",
"output": "OK"
},
{
"input": "1\n#define sum x/y\nsum-r",
"output": "OK"
},
{
"input": "1\n#define sum x/y\nsum*r",
"output": "OK"
},
{
"input": "1\n#define sum x/y\nsum/r",
"output": "OK"
},
{
"input": "1\n#define x 3/2\n2*x",
"output": "OK"
},
{
"input": "2\n # define sum 1000000000 + 1000000000 + 1000000000 \n # define a b + 45 * sum \n a ",
"output": "Suspicious"
}
] | 122 | 102,400 | 3.979476 | 50,405 |
472 | Design Tutorial: Increase the Constraints | [
"bitmasks",
"data structures",
"fft"
] | null | null | There is a simple way to create hard tasks: take one simple problem as the query, and try to find an algorithm that can solve it faster than bruteforce. This kind of tasks usually appears in OI contest, and usually involves data structures.
Let's try to create a task, for example, we take the "Hamming distance problem": for two binary strings *s* and *t* with the same length, the Hamming distance between them is the number of positions at which the corresponding symbols are different. For example, the Hamming distance between "00111" and "10101" is 2 (the different symbols are marked with bold).
We use the Hamming distance problem as a query in the following way: you are given two strings *a* and *b* and several queries. Each query will be: what is the Hamming distance between two strings *a**p*1*a**p*1<=+<=1...*a**p*1<=+<=*len*<=-<=1 and *b**p*2*b**p*2<=+<=1...*b**p*2<=+<=*len*<=-<=1?
Note, that in this problem the strings are zero-based, that is *s*<==<=*s*0*s*1... *s*|*s*|<=-<=1. | The first line contains a string *a* (1<=β€<=|*a*|<=β€<=200000). The second line contains a string *b* (1<=β€<=|*b*|<=β€<=200000). Each character of both strings is either "0" or "1".
The third line contains an integer *q* (1<=β€<=*q*<=β€<=400000) β the number of queries. Each of the following *q* lines contains three integers: *p*1, *p*2 and *len* (0<=β€<=*p*1<=β€<=|*a*|<=-<=*len*;Β 0<=β€<=*p*2<=β€<=|*b*|<=-<=*len*), these numbers denote the parameters of the current query. | Output *q* integers β the answers for the queries. | [
"101010\n11110000\n3\n0 0 3\n2 3 4\n5 7 1\n",
"10001010101011001010100101010011010\n101010100101001010100100101010\n5\n0 0 12\n3 9 7\n6 4 15\n12 15 10\n13 3 20\n"
] | [
"1\n1\n0\n",
"5\n4\n3\n5\n13\n"
] | none | [] | 31 | 0 | 0 | 50,409 |
|
939 | Cutlet | [
"data structures",
"dp"
] | null | null | Arkady wants to have a dinner. He has just returned from a shop where he has bought a semifinished cutlet. He only needs to fry it. The cutlet should be fried for 2*n* seconds, in particular, it should be fried for *n* seconds on one side and *n* seconds on the other side. Arkady has already got a frying pan and turn on fire, but understood that maybe he won't be able to flip the cutlet exactly after *n* seconds after the beginning of cooking.
Arkady is too busy with sorting sticker packs in his favorite messenger and can flip the cutlet only in some periods of time. Namely, there are *k* periods of time in which he can do it, the *i*-th of them is an interval of time from *l**i* seconds after he starts cooking till *r**i* seconds, inclusive. Arkady decided that it's not required to flip the cutlet exactly in the middle of cooking, instead, he will flip it several times in such a way that the cutlet will be fried exactly *n* seconds on one side and *n* seconds on the other side in total.
Help Arkady and find out if it's possible for him to cook the cutlet, if he is able to flip the cutlet only in given periods of time; and if yes, find the minimum number of flips he needs to cook the cutlet. | The first line contains two integers *n* and *k* (1<=β€<=*n*<=β€<=100<=000, 1<=β€<=*k*<=β€<=100)Β β the number of seconds the cutlet should be cooked on each side and number of periods of time in which Arkady can flip it.
The next *k* lines contain descriptions of these intervals. Each line contains two integers *l**i* and *r**i* (0<=β€<=*l**i*<=β€<=*r**i*<=β€<=2Β·*n*), meaning that Arkady can flip the cutlet in any moment starting from *l**i* seconds after the beginning of cooking and finishing at *r**i* seconds after beginning of cooking. In particular, if *l**i*<==<=*r**i* then Arkady can flip the cutlet only in the moment *l**i*<==<=*r**i*. It's guaranteed that *l**i*<=><=*r**i*<=-<=1 for all 2<=β€<=*i*<=β€<=*k*. | Output "Hungry" if Arkady won't be able to fry the cutlet for exactly *n* seconds on one side and exactly *n* seconds on the other side.
Otherwise, output "Full" in the first line, and the minimum number of times he should flip the cutlet in the second line. | [
"10 2\n3 5\n11 13\n",
"10 3\n3 5\n9 10\n11 13\n",
"20 1\n3 19\n"
] | [
"Full\n2\n",
"Full\n1\n",
"Hungry\n"
] | In the first example Arkady should flip the cutlet in time moment 3 seconds after he starts cooking and in time moment 13 seconds after he starts cooking.
In the second example, Arkady can flip the cutlet at 10 seconds after he starts cooking. | [
{
"input": "10 2\n3 5\n11 13",
"output": "Full\n2"
},
{
"input": "10 3\n3 5\n9 10\n11 13",
"output": "Full\n1"
},
{
"input": "20 1\n3 19",
"output": "Hungry"
},
{
"input": "10 1\n0 20",
"output": "Full\n1"
},
{
"input": "10 1\n0 1",
"output": "Hungry"
},
{
"input": "10 1\n10 10",
"output": "Full\n1"
},
{
"input": "10 2\n4 4\n14 14",
"output": "Full\n2"
},
{
"input": "1 1\n0 0",
"output": "Hungry"
},
{
"input": "10 5\n3 3\n5 5\n8 8\n13 13\n16 16",
"output": "Full\n2"
},
{
"input": "10 7\n0 0\n2 6\n8 10\n12 12\n14 14\n17 17\n19 19",
"output": "Full\n1"
},
{
"input": "100 10\n18 18\n30 30\n37 37\n59 59\n83 83\n90 90\n141 141\n149 149\n173 173\n189 189",
"output": "Full\n3"
},
{
"input": "100000 3\n0 50000\n99999 99999\n199998 199998",
"output": "Full\n3"
},
{
"input": "100000 17\n7247 18957\n56758 64403\n79823 83648\n83649 83715\n83732 84946\n84947 84963\n84964 84968\n84970 84978\n84982 84991\n84992 87130\n172421 176513\n176514 176596\n176629 176689\n176692 177213\n197692 199830\n199831 199993\n199997 200000",
"output": "Full\n3"
},
{
"input": "100000 20\n1425 1425\n14050 14050\n17375 17375\n17609 17609\n22704 22704\n25922 25922\n37894 37894\n92308 92308\n94002 94002\n99619 99619\n103208 103208\n110194 110194\n114468 114468\n141214 141214\n145980 145980\n159553 159553\n168441 168441\n169633 169633\n182674 182674\n195738 195738",
"output": "Full\n8"
},
{
"input": "100000 3\n54962 59962\n98273 103273\n174042 179042",
"output": "Full\n1"
},
{
"input": "100000 20\n5000 9999\n14999 19998\n24998 29997\n34997 39996\n44996 49995\n54995 59994\n64994 69993\n74993 79992\n84992 89991\n94991 99990\n104990 109989\n114989 119988\n124988 129987\n134987 139986\n144986 149985\n154985 159984\n164984 169983\n174983 179982\n184982 189981\n194981 199980",
"output": "Full\n2"
},
{
"input": "100 19\n1 1\n14 14\n16 16\n36 36\n45 45\n51 51\n67 67\n77 77\n90 90\n106 106\n116 116\n129 129\n142 142\n153 153\n168 169\n180 180\n183 183\n185 185\n191 191",
"output": "Full\n2"
},
{
"input": "1000 10\n1 1\n122 122\n502 502\n687 687\n731 731\n737 737\n825 825\n878 878\n1159 1159\n1396 1396",
"output": "Hungry"
},
{
"input": "1000 4\n184 196\n726 737\n1114 1131\n1571 1581",
"output": "Full\n4"
},
{
"input": "1000 6\n292 304\n1135 1147\n1338 1350\n1472 1491\n1720 1732\n1773 1790",
"output": "Full\n4"
},
{
"input": "1000 5\n509 528\n540 551\n1332 1347\n1732 1743\n1777 1787",
"output": "Full\n3"
},
{
"input": "100000 1\n0 200000",
"output": "Full\n1"
},
{
"input": "100000 1\n100000 100000",
"output": "Full\n1"
},
{
"input": "100000 2\n234 234\n99766 99766",
"output": "Hungry"
},
{
"input": "100000 2\n0 99999\n100001 200000",
"output": "Full\n2"
},
{
"input": "511 18\n1 1\n2 2\n4 4\n6 6\n10 10\n14 14\n22 22\n30 30\n46 46\n62 62\n94 94\n126 126\n190 190\n254 254\n382 382\n510 510\n766 766\n1022 1022",
"output": "Full\n9"
},
{
"input": "1000 20\n225 225\n429 429\n560 560\n632 632\n650 650\n704 704\n768 768\n797 797\n983 983\n991 991\n1046 1046\n1082 1082\n1233 1233\n1366 1366\n1394 1394\n1456 1456\n1459 1459\n1519 1519\n1967 1967\n1996 1996",
"output": "Full\n4"
},
{
"input": "10000 10\n479 479\n1024 1024\n4388 4388\n4810 4810\n6557 6557\n9697 9697\n11393 11393\n12124 12124\n14600 14600\n17536 17536",
"output": "Full\n7"
},
{
"input": "10000 20\n746 746\n1145 1145\n1897 1897\n4254 4254\n6893 6893\n7434 7434\n8130 8130\n9755 9755\n10033 10033\n10636 10636\n11342 11342\n11651 11651\n12005 12005\n14567 14567\n15196 15196\n15947 15947\n16385 16385\n17862 17862\n18540 18540\n18948 18948",
"output": "Full\n5"
},
{
"input": "10000 12\n1407 1407\n1878 1878\n4636 4636\n5055 5055\n5640 5640\n6379 6379\n6490 6490\n10303 10303\n13028 13028\n13578 13578\n18040 18040\n19477 19477",
"output": "Full\n8"
},
{
"input": "55 20\n1 1\n2 2\n4 4\n6 6\n9 9\n12 12\n16 16\n20 20\n25 25\n30 30\n36 36\n42 42\n49 49\n56 56\n64 64\n72 72\n81 81\n90 90\n100 100\n110 110",
"output": "Full\n2"
},
{
"input": "6 6\n3 3\n5 5\n7 7\n8 8\n9 9\n12 12",
"output": "Full\n2"
},
{
"input": "100000 4\n0 40000\n41000 80000\n99999 99999\n199998 199998",
"output": "Full\n3"
},
{
"input": "100000 12\n1 1751\n23999 25007\n33798 37031\n37117 37426\n37428 37436\n37437 40132\n48648 51062\n51071 51743\n51763 54643\n116077 119442\n190627 195558\n197662 200000",
"output": "Full\n3"
},
{
"input": "100000 14\n213 1640\n6778 14112\n62548 68221\n68495 68864\n68887 68889\n68890 68894\n68896 68988\n69034 71515\n73645 77764\n80059 81085\n81086 81589\n136294 151585\n194157 199448\n199559 200000",
"output": "Full\n3"
},
{
"input": "100000 16\n1 7\n9 307\n405 5574\n50346 54067\n54069 54100\n54101 55097\n56093 61752\n77951 78580\n78585 80749\n85191 87424\n87485 87490\n87491 87694\n87715 94544\n136369 138773\n140012 143346\n195045 200000",
"output": "Full\n3"
},
{
"input": "100000 2\n60000 81999\n120000 140000",
"output": "Full\n3"
},
{
"input": "100000 12\n65418 84245\n86341 90510\n135508 139243\n139287 139389\n139393 139437\n139440 147819\n198670 199954\n199955 199963\n199968 199979\n199980 199985\n199986 199997\n199999 200000",
"output": "Full\n3"
},
{
"input": "100000 11\n42866 45922\n45923 49957\n63729 84014\n115856 125872\n125988 126003\n126004 129147\n131201 134555\n183782 189949\n189955 189967\n189968 197363\n198291 200000",
"output": "Full\n2"
},
{
"input": "100000 8\n69804 76492\n76493 78217\n129407 137816\n137817 139388\n142035 152201\n153150 162227\n196326 199996\n200000 200000",
"output": "Full\n3"
},
{
"input": "100000 18\n16 46\n47 154\n445 526\n537 571\n572 573\n574 580\n582 5922\n70364 73612\n73625 80571\n81628 88168\n122927 127021\n127027 127056\n127204 127409\n127410 134203\n145658 155259\n155270 163684\n198635 199999\n200000 200000",
"output": "Full\n3"
},
{
"input": "100000 15\n10387 11995\n12012 12188\n12297 14393\n14589 15140\n17771 26488\n68905 72975\n73509 73881\n73886 73886\n73887 79513\n143598 147981\n150145 152841\n189148 199265\n199597 199724\n199772 199994\n199999 200000",
"output": "Full\n3"
},
{
"input": "100000 12\n589 2312\n2349 12326\n12499 12759\n12796 21228\n70394 77570\n77571 86238\n133314 135096\n135104 135113\n135118 135128\n135135 137324\n190272 199989\n199998 200000",
"output": "Full\n4"
},
{
"input": "100000 14\n3182 5382\n5847 10785\n26776 36809\n36961 39608\n65919 72524\n73806 75651\n79173 81114\n81115 84538\n112469 113763\n113767 113771\n113777 113790\n113792 119192\n193181 198259\n199859 200000",
"output": "Full\n3"
},
{
"input": "100000 18\n3 535\n551 7905\n74333 87542\n124358 135027\n135108 142254\n142265 143895\n144091 145169\n145255 145273\n145275 145275\n145279 145295\n145302 145336\n145337 145348\n145350 145429\n145430 145431\n145441 145459\n145460 147266\n198447 199999\n200000 200000",
"output": "Full\n3"
},
{
"input": "100000 8\n244 293\n379 886\n68058 75221\n102015 112569\n140672 146088\n146090 146284\n146289 149770\n197995 200000",
"output": "Full\n3"
},
{
"input": "100000 5\n18547 19547\n24249 25249\n58262 59262\n102965 103965\n109453 110453",
"output": "Full\n5"
},
{
"input": "100000 9\n5071 6797\n6916 13337\n64413 72188\n72231 72441\n72458 74946\n122835 133275\n133562 134079\n134098 141894\n195543 200000",
"output": "Full\n4"
},
{
"input": "100000 6\n8828 9828\n81857 82857\n88071 89071\n94010 95010\n141844 142844\n165669 166669",
"output": "Full\n6"
},
{
"input": "100000 7\n5645 6645\n30563 31563\n75140 76140\n107764 108764\n108910 109910\n162122 163122\n169774 170774",
"output": "Full\n3"
},
{
"input": "100000 7\n17993 18993\n30906 31906\n49354 50354\n60696 61696\n106638 107638\n188177 189177\n190333 191333",
"output": "Full\n3"
},
{
"input": "100000 18\n299 2359\n2646 3120\n3122 3123\n3124 4562\n5401 5753\n5754 10619\n72022 81017\n81018 81019\n81020 81020\n81021 81573\n82730 83638\n83643 83648\n83663 83668\n83669 83673\n83678 83681\n83686 91779\n156345 158432\n194512 200000",
"output": "Full\n4"
},
{
"input": "100000 6\n397 1397\n15892 16892\n35746 36746\n94193 95193\n166848 167848\n185228 186228",
"output": "Full\n5"
},
{
"input": "100000 16\n41569 49839\n49854 54485\n59507 68882\n68884 69855\n69997 72083\n105481 108926\n108927 108944\n108969 109043\n109105 109306\n110096 110365\n110573 114375\n180359 187643\n191157 196987\n197083 197113\n197140 197892\n199113 200000",
"output": "Full\n3"
},
{
"input": "1000 2\n909 961\n1820 1859",
"output": "Full\n3"
},
{
"input": "1000 5\n123 174\n716 789\n1284 1360\n1415 1443\n1623 1648",
"output": "Full\n3"
},
{
"input": "1000 5\n381 426\n1092 1122\n1462 1481\n1708 1756\n1799 1847",
"output": "Full\n3"
},
{
"input": "1000 4\n241 259\n1127 1154\n1219 1239\n1739 1758",
"output": "Full\n4"
},
{
"input": "1000 5\n388 407\n488 504\n640 658\n856 875\n1060 1074",
"output": "Full\n9"
},
{
"input": "1000 5\n182 199\n444 460\n628 640\n693 708\n1107 1119",
"output": "Full\n7"
},
{
"input": "1000 2\n771 837\n1015 1049",
"output": "Full\n3"
},
{
"input": "1000 3\n581 617\n802 825\n1040 1080",
"output": "Full\n5"
},
{
"input": "100000 7\n27522 27693\n47266 47410\n58768 58929\n64532 64665\n141173 141356\n150364 150551\n183020 183160",
"output": "Full\n9"
}
] | 140 | 4,300,800 | 0 | 50,497 |
|
468 | Permanent | [
"dp",
"graph matchings",
"math",
"meet-in-the-middle"
] | null | null | Little X has solved the #P-complete problem in polynomial time recently. So he gives this task to you.
There is a special *n*<=Γ<=*n* matrix *A*, you should calculate its permanent modulo 1000000007Β (109<=+<=7). The special property of matrix *A* is almost all its elements equal to 1. Only *k* elements have specified value.
You can find the definition of permanent at the link: https://en.wikipedia.org/wiki/Permanent | The first line contains two space-separated integers *n*,<=*k* (1<=β€<=*n*<=β€<=105;Β 1<=β€<=*k*<=β€<=50).
The next *k* lines contain the description of the matrix. The *i*-th line contains three space-separated integers *x**i*,<=*y**i*,<=*w**i* (1<=β€<=*x**i*,<=<=*y**i*<=β€<=<=*n*;Β 0<=<=β€<=<=*w**i*<=<=β€<=109). These numbers denote that *A**x**i*,<=*y**i*<==<=*w**i*. All the elements of the matrix except of the given elements are equal to 1.
It's guaranteed that all the positions (*x**i*,<=*y**i*) are distinct. | Print the permanent of the matrix modulo 1000000007Β (109<=<=+<=<=7). | [
"3 1\n1 1 2\n",
"10 10\n3 3 367056794\n6 2 124561273\n1 3 46718146\n6 9 415916869\n10 5 985968336\n3 1 526792265\n1 4 386357058\n10 4 349304187\n2 7 102032499\n3 6 502679075\n"
] | [
"8\n",
"233333333\n"
] | none | [] | 31 | 0 | 0 | 50,516 |
|
222 | Decoding Genome | [
"dp",
"matrices"
] | null | null | Recently a top secret mission to Mars has taken place. As a result, scientists managed to obtain some information about the Martian DNA. Now we know that any Martian DNA contains at most *m* different nucleotides, numbered from 1 to *m*. Special characteristics of the Martian DNA prevent some nucleotide pairs from following consecutively in this chain. For example, if the nucleotide 1 and nucleotide 2 can not follow consecutively in the Martian DNA, then the chain of nucleotides [1, 2] is not a valid chain of Martian DNA, but the chain of nucleotides [2, 1] can be a valid chain (if there is no corresponding restriction). The number of nucleotide pairs that can't follow in the DNA chain consecutively, is *k*.
The needs of gene research required information about the quantity of correct *n*-long chains of the Martian DNA. Your task is to write a program that will calculate this value. | The first line contains three space-separated integers *n*,<=*m*,<=*k* (1<=β€<=*n*<=β€<=1015, 1<=β€<=*m*<=β€<=52, 0<=β€<=*k*<=β€<=*m*2).
Next *k* lines contain two characters each, without a space between them, representing a forbidden nucleotide pair. The first character represents the first nucleotide in the forbidden pair, the second character represents the second nucleotide.
The nucleotides with assigned numbers from 1 to 26 are represented by English alphabet letters from "a" to "z" (1 is an "a", 2 is a "b", ..., 26 is a "z"). Nucleotides with assigned numbers from 27 to 52 are represented by English alphabet letters from "A" to "Z" (27 is an "A", 28 is a "B", ..., 52 is a "Z").
It is guaranteed that each forbidden pair occurs at most once in the input. It is guaranteed that nucleotide's numbers in all forbidden pairs cannot be more than *m*. Note that order is important in nucleotide pairs.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier. | Print a single integer β the sought number modulo 1000000007 (109<=+<=7). | [
"3 3 2\nab\nba\n",
"3 3 0\n",
"2 1 1\naa\n"
] | [
"17\n",
"27\n",
"0\n"
] | In the second test case all possible three-nucleotide DNAs are permitted. Each nucleotide can take one of three values, thus in total there are 27 distinct three nucleotide DNAs.
In the third test sample we cannot make any DNA of two nucleotides β the only possible nucleotide "a" cannot occur two times consecutively. | [
{
"input": "3 3 2\nab\nba",
"output": "17"
},
{
"input": "3 3 0",
"output": "27"
},
{
"input": "2 1 1\naa",
"output": "0"
},
{
"input": "3 5 4\ncd\nce\ned\nee",
"output": "89"
},
{
"input": "100 5 4\ncd\nce\ned\nee",
"output": "537303881"
},
{
"input": "1 2 4\naa\nbb\nab\nba",
"output": "2"
},
{
"input": "2 2 4\naa\nbb\nab\nba",
"output": "0"
},
{
"input": "3 3 6\naa\nab\nac\nbb\nbc\ncc",
"output": "1"
},
{
"input": "4 4 13\naa\nbc\nad\nac\nbb\nba\nda\ndb\ndd\ncc\nca\ncb\ncd",
"output": "1"
},
{
"input": "2 3 7\naa\nac\nba\nbb\ncc\nca\ncb",
"output": "2"
},
{
"input": "3 3 7\naa\nac\nba\nbb\ncc\nca\ncb",
"output": "1"
},
{
"input": "4 3 7\naa\nac\nba\nbb\ncc\nca\ncb",
"output": "0"
},
{
"input": "1 52 2\naA\nAa",
"output": "52"
},
{
"input": "100000 52 0",
"output": "378241178"
},
{
"input": "10000 52 10\nEN\nYJ\nKH\nGa\nQA\njY\nYf\nSt\nap\nDT",
"output": "671474539"
},
{
"input": "1000000000000 2 0",
"output": "959366170"
},
{
"input": "100 3 6\naa\nab\nac\nbb\nbc\ncc",
"output": "0"
},
{
"input": "1000 10 20\naa\nbb\ncc\ndd\nee\nff\ngg\nhh\nii\njj\nab\nbc\ncd\nde\nef\nfg\ngh\nhi\nij\nja",
"output": "207125595"
},
{
"input": "5000 3 0",
"output": "22443616"
},
{
"input": "5000 4 7\naa\nab\nac\nad\nba\nca\nda",
"output": "22443616"
},
{
"input": "5000 4 6\nab\nac\nad\nba\nca\nda",
"output": "22443617"
},
{
"input": "10000 5 4\nce\nee\ncd\ned",
"output": "386438816"
},
{
"input": "50000 52 10\nAa\naA\nBy\ntS\nzA\nZu\nyy\nUU\nen\neq",
"output": "447275409"
},
{
"input": "1000000000000 3 5\naa\nab\nac\nba\nca",
"output": "959366170"
},
{
"input": "1000000000000 3 3\naa\nab\nac",
"output": "439049248"
},
{
"input": "1000000000000 3 4\nab\nac\nba\nca",
"output": "959366171"
},
{
"input": "1000000000000 4 9\naa\nab\nac\nad\nbb\nbc\nbd\ncc\ncd",
"output": "8"
},
{
"input": "1000000000000000 52 0",
"output": "588668785"
},
{
"input": "1000000000000000 52 26\naa\nbb\ncc\ndd\nee\nff\ngg\nhh\nii\njj\nkk\nll\nmm\nnn\noo\npp\nqq\nrr\nss\ntt\nuu\nvv\nww\nxx\nyy\nzz",
"output": "271910099"
},
{
"input": "298470512649 26 20\nav\nsf\nqq\nyt\ncz\nkl\nqw\nwe\ner\nrt\nty\nfg\nin\nxy\nbt\nmm\njm\ndp\nno\nuy",
"output": "399097981"
},
{
"input": "10000000000 20 15\nhs\npm\ncd\ner\nht\nmk\nce\nad\nfe\nmj\npf\nlm\nmo\nkd\nde",
"output": "768931983"
},
{
"input": "1000000000000000 26 2\nfj\nho",
"output": "688841650"
},
{
"input": "1000000000000000 10 0",
"output": "478484352"
},
{
"input": "1000000000000000 10 1\ncd",
"output": "82984398"
},
{
"input": "1000000000000000 12 3\nce\ndg\nfb",
"output": "792123851"
},
{
"input": "853332331434235 35 77\nBy\nhs\nzB\njs\nIr\nEa\nHG\nxb\nxG\nFp\nAC\nDt\nwo\nFB\nzh\nim\ntx\nyi\ngC\nkp\njz\ndc\nwE\naa\nsG\nng\ncr\npB\nCg\ncv\nxs\nDn\ndg\nyj\nCd\naC\nIi\ngH\nml\nww\nAD\nir\nti\nEr\nCj\nHt\nAe\nsn\naH\nHv\nan\nDf\nGn\nfC\nay\ngB\nlh\nup\nda\nzs\nbh\nHB\nHd\nmg\nzy\nGi\nzm\nHq\nac\nCB\niE\ncc\nfi\ngm\nHf\neD\nqA",
"output": "351800015"
}
] | 2,000 | 9,113,600 | 0 | 50,536 |
|
676 | The Last Fight Between Human and AI | [
"math"
] | null | null | 100 years have passed since the last victory of the man versus computer in Go. Technologies made a huge step forward and robots conquered the Earth! It's time for the final fight between human and robot that will decide the faith of the planet.
The following game was chosen for the fights: initially there is a polynomial
Polynomial *P*(*x*) is said to be divisible by polynomial *Q*(*x*) if there exists a representation *P*(*x*)<==<=*B*(*x*)*Q*(*x*), where *B*(*x*) is also some polynomial.
Some moves have been made already and now you wonder, is it true that human can guarantee the victory if he plays optimally? | The first line of the input contains two integers *n* and *k* (1<=β€<=*n*<=β€<=100<=000,<=|*k*|<=β€<=10<=000)Β β the size of the polynomial and the integer *k*.
The *i*-th of the following *n*<=+<=1 lines contain character '?' if the coefficient near *x**i*<=-<=1 is yet undefined or the integer value *a**i*, if the coefficient is already known (<=-<=10<=000<=β€<=*a**i*<=β€<=10<=000). Each of integers *a**i* (and even *a**n*) may be equal to 0.
Please note, that it's not guaranteed that you are given the position of the game where it's computer's turn to move. | Print "Yes" (without quotes) if the human has winning strategy, or "No" (without quotes) otherwise. | [
"1 2\n-1\n?\n",
"2 100\n-10000\n0\n1\n",
"4 5\n?\n1\n?\n1\n?\n"
] | [
"Yes\n",
"Yes",
"No"
] | In the first sample, computer set *a*<sub class="lower-index">0</sub> to β-β1 on the first move, so if human can set coefficient *a*<sub class="lower-index">1</sub> to 0.5 and win.
In the second sample, all coefficients are already set and the resulting polynomial is divisible by *x*β-β100, so the human has won. | [
{
"input": "1 2\n-1\n?",
"output": "Yes"
},
{
"input": "2 100\n-10000\n0\n1",
"output": "Yes"
},
{
"input": "4 5\n?\n1\n?\n1\n?",
"output": "No"
},
{
"input": "68 -9959\n-3666\n-3501\n9169\n5724\n1478\n-643\n-3039\n-5537\n-4295\n-1856\n-6720\n6827\n-39\n-9509\n-7005\n1942\n-5173\n-4564\n2390\n4604\n-6098\n-9847\n-9708\n2382\n7421\n8716\n9718\n9895\n-4553\n-8275\n4771\n1538\n-8131\n9912\n-4334\n-3702\n7035\n-106\n-1298\n-6190\n1321\n332\n7673\n-5336\n5141\n-2289\n-1748\n-3132\n-4454\n-2357\n2661\n2756\n-9964\n2859\n-1277\n-259\n-2472\n-9222\n2316\n-6965\n-7811\n-8158\n-9712\n105\n-960\n-1058\n9264\n-7353\n-2555",
"output": "No"
},
{
"input": "5 10\n5400\n-900\n-1014\n325\n-32\n1",
"output": "Yes"
},
{
"input": "5 -6\n-5400\n-2700\n414\n151\n-26\n1",
"output": "No"
},
{
"input": "10 100\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n?",
"output": "No"
},
{
"input": "9 100\n0\n0\n0\n0\n0\n0\n0\n0\n0\n?",
"output": "Yes"
},
{
"input": "4 0\n0\n-10000\n10000\n-10000\n10000",
"output": "Yes"
},
{
"input": "5 3\n?\n?\n?\n?\n?\n?",
"output": "Yes"
},
{
"input": "4 4\n?\n?\n?\n?\n?",
"output": "No"
},
{
"input": "5 6\n-5400\n-2700\n414\n151\n-26\n1",
"output": "Yes"
},
{
"input": "5 10\n30\n27\n-53\n5\n-10\n1",
"output": "Yes"
},
{
"input": "64 4\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n1",
"output": "No"
},
{
"input": "3 0\n5\n3\n?\n13",
"output": "No"
},
{
"input": "4 0\n?\n10000\n-10000\n15\n?",
"output": "Yes"
},
{
"input": "4 0\n0\n3\n?\n13\n?",
"output": "Yes"
},
{
"input": "5 0\n?\n-123\n534\n?\n?\n?",
"output": "No"
},
{
"input": "1 10000\n?\n?",
"output": "Yes"
},
{
"input": "1 10000\n0\n0",
"output": "Yes"
},
{
"input": "1 10000\n?\n0",
"output": "Yes"
},
{
"input": "7 10000\n0\n0\n0\n0\n0\n0\n0\n10000",
"output": "No"
},
{
"input": "32 2\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n1",
"output": "No"
},
{
"input": "64 2\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n1",
"output": "No"
},
{
"input": "100 100\n1\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0",
"output": "No"
},
{
"input": "1 0\n1\n?",
"output": "No"
},
{
"input": "2 0\n0\n?\n?",
"output": "Yes"
},
{
"input": "18 10\n3\n2\n4\n0\n0\n0\n0\n0\n0\n6\n5\n0\n0\n0\n0\n0\n0\n0\n1",
"output": "No"
},
{
"input": "17 10\n3\n6\n0\n0\n0\n0\n0\n0\n7\n9\n0\n0\n0\n0\n0\n0\n0\n1",
"output": "No"
},
{
"input": "3 0\n1\n?\n?\n?",
"output": "No"
},
{
"input": "2 0\n?\n?\n1",
"output": "Yes"
},
{
"input": "1 0\n-1\n?",
"output": "No"
},
{
"input": "17 10\n1\n1\n2\n4\n2\n0\n3\n6\n8\n3\n7\n1\n9\n8\n2\n3\n2\n1",
"output": "No"
},
{
"input": "18 16\n13\n0\n7\n3\n5\n12\n11\n3\n15\n2\n13\n12\n12\n1\n3\n2\n13\n2\n1",
"output": "No"
},
{
"input": "1 0\n?\n?",
"output": "No"
},
{
"input": "102 31\n-1\n4\n-6\n3\n2\n-1\n-4\n7\n-4\n-1\n-1\n3\n4\n2\n1\n-7\n7\n2\n-4\n4\n5\n-4\n-4\n3\n1\n7\n-2\n9\n-6\n-12\n-9\n-1\n6\n3\n-6\n-1\n-7\n0\n-3\n0\n0\n-1\n4\n-4\n2\n-5\n4\n-6\n3\n-2\n-7\n-1\n7\n5\n1\n2\n-8\n1\n-1\n0\n-5\n-7\n1\n6\n7\n4\n5\n-4\n-3\n-3\n1\n-2\n-2\n1\n-5\n-1\n0\n4\n-1\n0\n0\n-1\n-1\n-5\n-6\n0\n-3\n0\n5\n4\n10\n-4\n-2\n6\n-6\n7\n3\n0\n8\n-4\n1\n4\n5",
"output": "No"
},
{
"input": "26 10\n8\n2\n7\n7\n7\n7\n7\n0\n2\n6\n8\n5\n7\n9\n1\n1\n0\n3\n5\n5\n3\n2\n1\n0\n0\n0\n1",
"output": "No"
},
{
"input": "53 10\n1\n1\n5\n8\n3\n2\n9\n9\n6\n2\n8\n7\n0\n3\n1\n2\n3\n1\n4\n3\n9\n5\n8\n4\n2\n0\n9\n0\n8\n5\n4\n5\n3\n2\n4\n2\n9\n8\n4\n9\n3\n1\n2\n9\n2\n3\n0\n2\n0\n9\n2\n4\n7\n1",
"output": "No"
},
{
"input": "84 10\n9\n9\n1\n5\n7\n1\n9\n0\n9\n0\n2\n1\n4\n2\n8\n7\n5\n2\n4\n6\n1\n4\n2\n2\n1\n7\n6\n9\n0\n6\n4\n0\n3\n8\n9\n8\n3\n4\n0\n0\n4\n5\n2\n5\n7\n1\n9\n2\n1\n0\n0\n0\n2\n3\n6\n7\n1\n3\n1\n4\n6\n9\n5\n4\n8\n9\n2\n6\n8\n6\n4\n2\n0\n7\n3\n7\n9\n8\n3\n9\n1\n4\n7\n0\n1",
"output": "No"
},
{
"input": "44 10\n9\n5\n1\n4\n5\n0\n9\n7\n8\n7\n1\n5\n2\n9\n1\n6\n9\n6\n0\n6\n3\n6\n7\n8\n7\n4\n2\n2\n9\n5\n4\n4\n5\n2\n3\n7\n7\n2\n4\n0\n3\n1\n8\n9\n5",
"output": "No"
},
{
"input": "18 10\n3\n6\n0\n0\n0\n0\n0\n0\n0\n6\n1\n0\n0\n0\n0\n0\n0\n0\n1",
"output": "No"
},
{
"input": "100 10000\n427\n5059\n4746\n3792\n2421\n1434\n4381\n9757\n9891\n45\n7135\n933\n8193\n805\n5369\n8487\n5065\n4881\n4459\n4228\n8920\n5272\n7420\n5685\n4612\n2641\n6890\n2826\n2318\n6590\n4634\n5534\n9709\n3951\n3604\n8736\n1303\n9939\n5769\n3690\n6163\n2136\n5933\n4906\n9187\n808\n7153\n5830\n2599\n6141\n5544\n7001\n7919\n205\n4770\n1869\n2840\n6\n100\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0",
"output": "No"
},
{
"input": "19 10\n-6\n-1\n-6\n-1\n-5\n-5\n-9\n0\n-7\n-3\n-7\n0\n-4\n-4\n-7\n-6\n-4\n-4\n-8\n-1",
"output": "No"
},
{
"input": "100 10000\n9137\n5648\n7125\n5337\n4138\n5127\n3419\n7396\n9781\n6103\n3941\n9511\n9183\n4193\n7945\n52\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0",
"output": "No"
},
{
"input": "2 0\n?\n1\n?",
"output": "Yes"
},
{
"input": "30 1000\n564\n146\n187\n621\n589\n852\n981\n874\n602\n667\n263\n721\n246\n93\n992\n868\n168\n521\n618\n471\n511\n876\n742\n810\n899\n258\n172\n177\n523\n417\n68",
"output": "No"
},
{
"input": "30 1000\n832\n350\n169\n416\n972\n507\n385\n86\n581\n80\n59\n281\n635\n507\n86\n639\n257\n738\n325\n285\n688\n20\n263\n763\n443\n467\n952\n928\n590\n876\n13",
"output": "No"
},
{
"input": "1 0\n?\n1",
"output": "Yes"
},
{
"input": "100 2\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n-1",
"output": "No"
},
{
"input": "6 1000\n63\n0\n0\n16\n0\n0\n1",
"output": "No"
}
] | 46 | 0 | 0 | 50,599 |
|
377 | Cookie Clicker | [
"dp",
"geometry"
] | null | null | Kostya is playing the computer game Cookie Clicker. The goal of this game is to gather cookies. You can get cookies using different buildings: you can just click a special field on the screen and get the cookies for the clicks, you can buy a cookie factory, an alchemy lab, a time machine and it all will bring lots and lots of cookies.
At the beginning of the game (time 0), Kostya has 0 cookies and no buildings. He has *n* available buildings to choose from: the *i*-th building is worth *c**i* cookies and when it's built it brings *v**i* cookies at the end of each second. Also, to make the game more interesting to play, Kostya decided to add a limit: at each moment of time, he can use only one building. Of course, he can change the active building each second at his discretion.
It's important that Kostya is playing a version of the game where he can buy new buildings and change active building only at time moments that are multiples of one second. Kostya can buy new building and use it at the same time. If Kostya starts to use a building at the time moment *t*, he can get the first profit from it only at the time moment *t*<=+<=1.
Kostya wants to earn at least *s* cookies as quickly as possible. Determine the number of seconds he needs to do that. | The first line contains two integers *n* and *s* (1<=β€<=*n*<=β€<=2Β·105, 1<=β€<=*s*<=β€<=1016)Β β the number of buildings in the game and the number of cookies Kostya wants to earn.
Each of the next *n* lines contains two integers *v**i* and *c**i* (1<=β€<=*v**i*<=β€<=108, 0<=β€<=*c**i*<=β€<=108)Β β the number of cookies the *i*-th building brings per second and the building's price. | Output the only integerΒ β the minimum number of seconds Kostya needs to earn at least *s* cookies. It is guaranteed that he can do it. | [
"3 9\n1 0\n2 3\n5 4\n",
"3 6\n1 0\n2 2\n5 4\n",
"3 13\n1 0\n2 2\n6 5\n",
"1 10000000000000000\n1 0\n"
] | [
"6\n",
"5\n",
"7\n",
"10000000000000000\n"
] | none | [] | 30 | 0 | 0 | 50,700 |
|
193 | Hamming Distance | [
"constructive algorithms",
"greedy",
"math",
"matrices"
] | null | null | Hamming distance between strings *a* and *b* of equal length (denoted by *h*(*a*,<=*b*)) is equal to the number of distinct integers *i* (1<=β€<=*i*<=β€<=|*a*|), such that *a**i*<=β <=*b**i*, where *a**i* is the *i*-th symbol of string *a*, *b**i* is the *i*-th symbol of string *b*. For example, the Hamming distance between strings "aba" and "bba" equals 1, they have different first symbols. For strings "bbba" and "aaab" the Hamming distance equals 4.
John Doe had a paper on which four strings of equal length *s*1, *s*2, *s*3 and *s*4 were written. Each string *s**i* consisted only of lowercase letters "a" and "b". John found the Hamming distances between all pairs of strings he had. Then he lost the paper with the strings but he didn't lose the Hamming distances between all pairs.
Help John restore the strings; find some four strings *s*'1, *s*'2, *s*'3,<=*s*'4 of equal length that consist only of lowercase letters "a" and "b", such that the pairwise Hamming distances between them are the same as between John's strings. More formally, set *s*'*i* must satisfy the condition .
To make the strings easier to put down on a piece of paper, you should choose among all suitable sets of strings the one that has strings of minimum length. | The first line contains space-separated integers *h*(*s*1,<=*s*2), *h*(*s*1,<=*s*3), *h*(*s*1,<=*s*4). The second line contains space-separated integers *h*(*s*2,<=*s*3) and *h*(*s*2,<=*s*4). The third line contains the single integer *h*(*s*3,<=*s*4).
All given integers *h*(*s**i*,<=*s**j*) are non-negative and do not exceed 105. It is guaranteed that at least one number *h*(*s**i*,<=*s**j*) is positive. | Print -1 if there's no suitable set of strings.
Otherwise print on the first line number *len* β the length of each string. On the *i*-th of the next four lines print string *s*'*i*. If there are multiple sets with the minimum length of the strings, print any of them. | [
"4 4 4\n4 4\n4\n"
] | [
"6\naaaabb\naabbaa\nbbaaaa\nbbbbbb\n"
] | none | [
{
"input": "4 4 4\n4 4\n4",
"output": "6\naaaabb\naabbaa\nbbaaaa\nbbbbbb"
},
{
"input": "10 10 8\n8 8\n10",
"output": "14\naaaabaaaabbbbb\nbaaabbbbbaaaaa\nbbbbaaaaaaaaaa\nbbbbbbbbbbbbbb"
},
{
"input": "50109 50255 50102\n50104 50011\n50085",
"output": "75234\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "99999 99998 99997\n99996 99995\n99994",
"output": "-1"
},
{
"input": "6 6 6\n6 6\n6",
"output": "9\naaaaaabbb\naaabbbaaa\nbbbaaaaaa\nbbbbbbbbb"
},
{
"input": "1 1 1\n1 1\n1",
"output": "-1"
},
{
"input": "2 2 2\n2 2\n2",
"output": "3\naab\naba\nbaa\nbbb"
},
{
"input": "2 1 2\n2 2\n2",
"output": "-1"
},
{
"input": "5 6 6\n6 5\n5",
"output": "-1"
},
{
"input": "5 3 5\n6 4\n2",
"output": "7\nabbaaaa\nbaaaabb\nbbbbbaa\nbbbbbbb"
},
{
"input": "46 53 56\n59 52\n45",
"output": "79\nabbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbb\nbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaa\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
},
{
"input": "544 474 496\n506 492\n484",
"output": "766\naaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "3 6 4\n3 5\n6",
"output": "8\naabbbbaa\nbabbaaaa\nbbaaaaaa\nbbbbbbbb"
},
{
"input": "52 57 55\n45 51\n58",
"output": "85\naaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaa\nbbbbbbbbaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
},
{
"input": "519 484 514\n473 499\n486",
"output": "766\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "4993 5005 4963\n4980 4990\n4952",
"output": "7489\naaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "1 1 1\n0 0\n0",
"output": "1\na\nb\nb\nb"
},
{
"input": "0 1 0\n1 0\n1",
"output": "1\nb\nb\na\nb"
},
{
"input": "1 0 3\n1 2\n3",
"output": "3\naaa\nbaa\naaa\nbbb"
},
{
"input": "1 2 3\n1 2\n3",
"output": "4\nabaa\nbbaa\nbaaa\nbbbb"
},
{
"input": "9067 30712 6906\n25880 68847\n39172",
"output": "-1"
},
{
"input": "59229 81463 16933\n96758 49536\n14180",
"output": "-1"
},
{
"input": "79085 19303 48758\n21707 35376\n45090",
"output": "-1"
},
{
"input": "80578 32276 98528\n3211 43655\n46450",
"output": "-1"
},
{
"input": "87477 87009 32302\n34917 73227\n63224",
"output": "-1"
},
{
"input": "46113 61146 44846\n42628 62962\n75136",
"output": "-1"
},
{
"input": "37134 12916 90594\n63739 15292\n2465",
"output": "-1"
},
{
"input": "91531 33640 37893\n6206 92036\n90317",
"output": "-1"
},
{
"input": "33712 12237 21291\n21634 68568\n88115",
"output": "-1"
},
{
"input": "587 595 578\n558 565\n551",
"output": "870\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "5728 5729 5750\n5631 5768\n5717",
"output": "8623\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "57065 57086 57254\n56989 57079\n57478",
"output": "85909\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "100000 100000 100000\n100000 100000\n100000",
"output": "150000\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "68481 68707 68534\n68658 68503\n68637",
"output": "102939\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "67276 67541 67636\n67719 67590\n67501",
"output": "101405\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "67518 67348 67889\n67414 67041\n67681",
"output": "101459\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "67707 67368 67507\n67497 67414\n67311",
"output": "101314\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "79972 79902 79790\n79812 80040\n80002",
"output": "119927\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "84731 84834 85277\n84723 84716\n84881",
"output": "127496\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "85012 84929 84761\n85479 85041\n85366",
"output": "127943\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "84879 85185 84722\n84930 85151\n84943",
"output": "127512\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "100000 99998 99998\n100000 100000\n100000",
"output": "150000\nbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "99998 99998 100000\n100000 99996\n99994",
"output": "149998\naaabbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "59864 60025 98103\n60065 2344\n14965",
"output": "-1"
},
{
"input": "59872 85081 60032\n52232 59934\n78866",
"output": "-1"
},
{
"input": "7090 59882 60181\n4825 29113\n60159",
"output": "-1"
},
{
"input": "99828 54425 67603\n60232 60026\n59994",
"output": "-1"
},
{
"input": "60039 60073 41174\n60004 13194\n80506",
"output": "-1"
},
{
"input": "59971 68271 59870\n65808 60295\n64495",
"output": "97025\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa..."
},
{
"input": "56764 60173 60003\n98475 2520\n59924",
"output": "-1"
},
{
"input": "44493 42255 30216\n60142 59921\n59981",
"output": "90022\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb..."
},
{
"input": "60046 59770 31988\n59932 79201\n26687",
"output": "-1"
},
{
"input": "60218 34235 60087\n62830 60263\n83853",
"output": "-1"
},
{
"input": "96719 60044 59941\n18657 76626\n60085",
"output": "-1"
},
{
"input": "0 0 1\n0 0\n1",
"output": "-1"
},
{
"input": "1 1 0\n1 0\n0",
"output": "-1"
},
{
"input": "1 0 1\n0 1\n0",
"output": "-1"
},
{
"input": "1 0 0\n0 1\n1",
"output": "-1"
},
{
"input": "1 1 1\n0 0\n0",
"output": "1\na\nb\nb\nb"
},
{
"input": "0 0 0\n0 0\n1",
"output": "-1"
}
] | 46 | 0 | 0 | 50,755 |
|
559 | Randomizer | [
"combinatorics",
"geometry",
"probabilities"
] | null | null | Gerald got tired of playing board games with the usual six-sided die, and he bought a toy called Randomizer. It functions as follows.
A Randomizer has its own coordinate plane on which a strictly convex polygon is painted, the polygon is called a basic polygon. If you shake a Randomizer, it draws some nondegenerate (i.e. having a non-zero area) convex polygon with vertices at some vertices of the basic polygon. The result of the roll (more precisely, the result of the shaking) is considered to be the number of points with integer coordinates, which were strictly inside (the points on the border are not considered) the selected polygon. Now Gerald is wondering: what is the expected result of shaking the Randomizer?
During the shaking the Randomizer considers all the possible non-degenerate convex polygons with vertices at the vertices of the basic polygon. Let's assume that there are *k* versions of the polygons. Then the Randomizer chooses each of them with probability . | The first line of the input contains a single integer *n* (3<=β€<=*n*<=β€<=100<=000) β the number of vertices of the basic polygon.
Next *n* lines contain the coordinates of the vertices of the basic polygon. The *i*-th of these lines contain two integers *x**i* and *y**i* (<=-<=109<=β€<=*x**i*,<=*y**i*<=β€<=109) β the coordinates of the *i*-th vertex of the polygon. The vertices are given in the counter-clockwise order. | Print the sought expected value with absolute or relative error at most 10<=-<=9. | [
"4\n0 0\n2 0\n2 2\n0 2\n",
"5\n0 0\n2 0\n2 2\n1 3\n0 2\n"
] | [
"0.2\n",
"0.8125\n"
] | A polygon is called strictly convex if it is convex and no its vertices lie on the same line.
Let's assume that a random variable takes values *x*<sub class="lower-index">1</sub>,β...,β*x*<sub class="lower-index">*n*</sub> with probabilities *p*<sub class="lower-index">1</sub>,β...,β*p*<sub class="lower-index">*n*</sub>, correspondingly. Then the expected value of this variable equals to <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/e592ba0986f3722e82626df9d579add61ddc5d36.png" style="max-width: 100.0%;max-height: 100.0%;"/>. | [
{
"input": "4\n0 0\n2 0\n2 2\n0 2",
"output": "0.2"
},
{
"input": "5\n0 0\n2 0\n2 2\n1 3\n0 2",
"output": "0.8125"
},
{
"input": "4\n0 0\n3 0\n2 2\n0 3",
"output": "1.2"
},
{
"input": "4\n0 0\n100 0\n67 69\n0 100",
"output": "3999.6"
},
{
"input": "20\n89100 45399\n70710 70710\n45399 89100\n30901 95105\n0 100000\n-30901 95105\n-58778 80901\n-89100 45399\n-95105 30901\n-98768 15643\n-100000 0\n-95105 -30901\n-70710 -70710\n-58778 -80901\n-45399 -89100\n15643 -98768\n45399 -89100\n58778 -80901\n70710 -70710\n100000 0",
"output": "25106803298.815"
},
{
"input": "20\n57205 15642\n67249 45398\n70710 70710\n69839 80900\n67249 89100\n50000 100000\n41563 98768\n32102 95104\n0 70710\n-11061 58778\n-21851 45398\n-67249 -45398\n-69839 -58778\n-70710 -70710\n-69839 -80900\n-57205 -98768\n-50000 -100000\n-32102 -95104\n0 -70710\n32102 -30900",
"output": "12505843611.6819"
},
{
"input": "20\n52 100\n-11 97\n-42 92\n-79 79\n-84 76\n-93 65\n-99 48\n-100 11\n-92 -38\n-86 -66\n-69 -91\n-27 -100\n-15 -99\n2 -95\n35 -76\n65 -57\n82 -33\n100 72\n98 76\n88 93",
"output": "26882.9384298408"
},
{
"input": "15\n1000000000 0\n978147600 207911690\n913545457 406736643\n669130606 743144825\n500000000 866025403\n-104528463 994521895\n-913545457 406736643\n-913545457 -406736643\n-809016994 -587785252\n-309016994 -951056516\n-104528463 -994521895\n104528463 -994521895\n500000000 -866025403\n669130606 -743144825\n978147600 -207911690",
"output": "2.05231022833125e+018"
},
{
"input": "15\n500000001 2\n660141049 406736642\n698401123 587785252\n706137715 743144824\n683012701 866025402\n444996716 994521894\n183012702 866025402\n-500000000 0\n-593029645 -207911690\n-549525178 -994521894\n-444996716 -994521894\n-321019761 -951056516\n-183012701 -866025402\n110615871 -587785252\n500000000 0",
"output": "1.01473191887619e+018"
},
{
"input": "15\n148257411 304191177\n165035262 470087742\n174600280 615439216\n176534428 733893046\n45753176 695272226\n-27653968 413184968\n-174600280 -615439216\n-176534428 -733893046\n-170753175 -820272225\n-157509188 -870801572\n-80254940 -793547324\n-45753175 -695272225\n-9251778 -566610396\n96279489 -59654277\n125000000 125000000",
"output": "1.84057389512113e+017"
},
{
"input": "28\n-554554 1000000\n-631542 976127\n-762151 920824\n-913233 826516\n-943506 779352\n-976486 467573\n-1000000 240619\n-955796 -288536\n-951070 -324371\n-914735 -414613\n-876704 -452785\n-776959 -509256\n-399579 -690223\n-192025 -787833\n-33065 -855303\n347496 -1000000\n778173 -994267\n821449 -863517\n984602 -325460\n1000000 -179420\n985663 -91101\n843079 194982\n742441 382187\n528805 600400\n303429 768298\n191457 812385\n-310370 993063\n-417503 998316",
"output": "2703667390065.33"
},
{
"input": "29\n-126376 1000000\n-209892 989334\n-231981 984160\n-436755 935538\n-566987 884264\n-654712 824685\n-711182 752438\n-839514 388178\n-894583 163150\n-1000000 -284604\n-930453 -515597\n-713076 -749882\n-529452 -938992\n-115883 -1000000\n118239 -999774\n229972 -984024\n281105 -975372\n341914 -954489\n545776 -702132\n728045 -468925\n810234 -309969\n981894 26960\n1000000 318537\n982773 478304\n888619 591066\n780774 695922\n746138 718004\n417771 897712\n326060 938981",
"output": "2784045701093.75"
},
{
"input": "37\n683 1000\n441 995\n334 992\n137 945\n-60 891\n-382 772\n-602 674\n-750 592\n-822 488\n-866 412\n-916 290\n-993 56\n-1000 -75\n-985 -215\n-941 -367\n-696 -659\n-624 -712\n-368 -899\n-337 -914\n-281 -936\n-204 -966\n-62 -985\n54 -1000\n113 -992\n162 -981\n226 -963\n588 -853\n670 -773\n755 -665\n822 -514\n909 -233\n934 -87\n1000 312\n957 595\n914 862\n910 873\n876 954",
"output": "2929934.19624349"
},
{
"input": "43\n452 1000\n403 996\n42 954\n-127 927\n-268 896\n-327 879\n-541 812\n-783 711\n-831 683\n-937 532\n-974 466\n-1000 321\n-947 -30\n-917 -214\n-861 -316\n-776 -467\n-686 -579\n-641 -633\n-467 -777\n-370 -852\n-325 -870\n-117 -947\n-30 -973\n50 -989\n135 -994\n252 -1000\n487 -931\n581 -895\n665 -814\n745 -662\n843 -452\n900 -277\n935 -154\n958 -52\n977 125\n996 352\n1000 412\n993 543\n968 614\n925 675\n832 797\n800 829\n576 944",
"output": "3000372.15797247"
},
{
"input": "49\n-11 1000\n-203 962\n-240 951\n-251 946\n-294 925\n-312 915\n-382 875\n-429 845\n-484 809\n-600 720\n-741 499\n-818 362\n-859 258\n-877 209\n-926 9\n-949 -95\n-966 -176\n-990 -382\n-993 -457\n-1000 -710\n-997 -718\n-964 -793\n-882 -846\n-815 -882\n-713 -920\n-652 -937\n-547 -956\n-513 -961\n-200 -989\n-128 -995\n329 -1000\n594 -968\n630 -954\n759 -852\n792 -823\n798 -815\n941 -507\n983 -348\n1000 -232\n997 118\n995 211\n980 323\n886 580\n860 645\n805 728\n720 849\n699 864\n544 951\n253 980",
"output": "3238413.95529694"
},
{
"input": "3\n0 0\n1 0\n0 1",
"output": "0"
},
{
"input": "3\n0 0\n1000000000 1\n999999999 1",
"output": "0"
},
{
"input": "4\n-1000000000 -1000000000\n1000000000 -1000000000\n1000000000 1000000000\n-1000000000 1000000000",
"output": "2.3999999968e+018"
},
{
"input": "4\n0 -1000000000\n1000000000 0\n0 1000000000\n-1000000000 0",
"output": "1.199999998e+018"
}
] | 62 | 0 | 0 | 50,950 |
|
0 | none | [
"none"
] | null | null | Nanami is an expert at playing games. This day, Nanami's good friend Hajime invited her to watch a game of baseball. Unwilling as she was, she followed him to the stadium. But Nanami had no interest in the game, so she looked around to see if there was something that might interest her. That's when she saw the digital board at one end of the stadium.
The digital board is *n* pixels in height and *m* pixels in width, every pixel is either light or dark. The pixels are described by its coordinate. The *j*-th pixel of the *i*-th line is pixel (*i*,<=*j*). The board displays messages by switching a combination of pixels to light, and the rest to dark. Nanami notices that the state of the pixels on the board changes from time to time. At certain times, certain pixels on the board may switch from light to dark, or from dark to light.
Nanami wonders, what is the area of the biggest light block such that a specific pixel is on its side. A light block is a sub-rectangle of the board, in which all pixels are light. Pixel (*i*,<=*j*) belongs to a side of sub-rectangle with (*x*1,<=*y*1) and (*x*2,<=*y*2) as its upper-left and lower-right vertex if and only if it satisfies the logical condition:
Nanami has all the history of changing pixels, also she has some questions of the described type, can you answer them? | The first line contains three space-separated integers *n*, *m* and *q*Β (1<=β€<=*n*,<=*m*,<=*q*<=β€<=1000) β the height and width of the digital board, and the number of operations.
Then follow *n* lines, each line containing *m* space-separated integers. The *j*-th integer of the *i*-th line is *a**i*,<=*j* β the initial state of pixel (*i*,<=*j*).
- If *a**i*,<=*j*<==<=0, pixel (*i*,<=*j*) is initially dark. - If *a**i*,<=*j*<==<=1, pixel (*i*,<=*j*) is initially light.
Then follow *q* lines, each line containing three space-separated integers *op*, *x*, and *y*Β (1<=β€<=*op*<=β€<=2;Β 1<=β€<=*x*<=β€<=*n*;Β 1<=β€<=*y*<=β€<=*m*), describing an operation.
- If *op*<==<=1, the pixel at (*x*,<=*y*) changes its state (from light to dark or from dark to light). - If *op*<==<=2, Nanami queries the biggest light block with pixel (*x*,<=*y*) on its side. | For each query, print a single line containing one integer β the answer to Nanami's query. | [
"3 4 5\n0 1 1 0\n1 0 0 1\n0 1 1 0\n2 2 2\n2 1 2\n1 2 2\n1 2 3\n2 2 2\n",
"3 3 4\n1 1 1\n1 1 1\n1 1 1\n2 2 2\n1 2 2\n2 1 1\n2 2 1\n"
] | [
"0\n2\n6\n",
"6\n3\n3\n"
] | Consider the first sample.
The first query specifies pixel (2,β2), which is dark itself, so there are no valid light blocks, thus the answer is 0.
The second query specifies pixel (1,β2). The biggest light block is the block with (1,β2) as its upper-left vertex and (1,β3) as its lower-right vertex.
The last query specifies pixel (2,β2), which became light in the third operation. The biggest light block is the block with (1,β2) as its upper-left vertex and (3,β3) as its lower-right vertex. | [] | 1,000 | 96,256,000 | 0 | 51,173 |
|
0 | none | [
"none"
] | null | null | You already know that Valery's favorite sport is biathlon. Due to your help, he learned to shoot without missing, and his skills are unmatched at the shooting range. But now a smaller task is to be performed, he should learn to complete the path fastest.
The track's map is represented by a rectangle *n*<=Γ<=*m* in size divided into squares. Each square is marked with a lowercase Latin letter (which means the type of the plot), with the exception of the starting square (it is marked with a capital Latin letters *S*) and the terminating square (it is marked with a capital Latin letter *T*). The time of movement from one square to another is equal to 1 minute. The time of movement within the cell can be neglected. We can move from the cell only to side-adjacent ones, but it is forbidden to go beyond the map edges. Also the following restriction is imposed on the path: it is not allowed to visit more than *k* different types of squares (squares of one type can be visited an infinite number of times). Squares marked with *S* and *T* have no type, so they are not counted. But *S* must be visited exactly once β at the very beginning, and *T* must be visited exactly once β at the very end.
Your task is to find the path from the square *S* to the square *T* that takes minimum time. Among all shortest paths you should choose the lexicographically minimal one. When comparing paths you should lexicographically represent them as a sequence of characters, that is, of plot types. | The first input line contains three integers *n*, *m* and *k* (1<=β€<=*n*,<=*m*<=β€<=50,<=*n*Β·*m*<=β₯<=2,<=1<=β€<=*k*<=β€<=4). Then *n* lines contain the map. Each line has the length of exactly *m* characters and consists of lowercase Latin letters and characters *S* and *T*. It is guaranteed that the map contains exactly one character *S* and exactly one character *T*.
Pretest 12 is one of the maximal tests for this problem. | If there is a path that satisfies the condition, print it as a sequence of letters β the plot types. Otherwise, print "-1" (without quotes). You shouldn't print the character *S* in the beginning and *T* in the end.
Note that this sequence may be empty. This case is present in pretests. You can just print nothing or print one "End of line"-character. Both will be accepted. | [
"5 3 2\nSba\nccc\naac\nccc\nabT\n",
"3 4 1\nSxyy\nyxxx\nyyyT\n",
"1 3 3\nTyS\n",
"1 4 1\nSxyT\n"
] | [
"bcccc\n",
"xxxx\n",
"y\n",
"-1\n"
] | none | [
{
"input": "5 3 2\nSba\nccc\naac\nccc\nabT",
"output": "bcccc"
},
{
"input": "3 4 1\nSxyy\nyxxx\nyyyT",
"output": "xxxx"
},
{
"input": "1 3 3\nTyS",
"output": "y"
},
{
"input": "1 4 1\nSxyT",
"output": "-1"
},
{
"input": "1 3 3\nSaT",
"output": "a"
},
{
"input": "3 4 1\nSbbT\naaaa\nabba",
"output": "bb"
},
{
"input": "3 5 2\nSbcaT\nacbab\nacccb",
"output": "aacccaa"
},
{
"input": "3 4 1\nSbbb\naaaT\nabbc",
"output": "aaa"
},
{
"input": "3 4 2\nSbbb\naabT\nabbc",
"output": "aab"
},
{
"input": "4 5 3\nabaaa\nbabaT\nSabba\naaaaa",
"output": "aaba"
},
{
"input": "6 6 3\npkhipk\nmlfmak\naqmbae\ndlbfSj\ndpbjcr\naTbqbm",
"output": "cbqb"
},
{
"input": "1 20 3\nacbccbbddbffScTadffd",
"output": "c"
},
{
"input": "1 30 2\nbmjcfldkloleiqqiTnmdjpaSckkijf",
"output": "-1"
},
{
"input": "1 40 1\nfaSfgfTcfadcdfagfbccbffbeaaebagbfcfcgdfd",
"output": "-1"
},
{
"input": "1 50 3\nSaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaTaaaaaaaaaaa",
"output": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
},
{
"input": "5 10 4\naaaaaaaaaa\naaaaaTaaaa\naaaaaaaSaa\naaaaaaaaaa\naaaaaaaaaa",
"output": "aa"
},
{
"input": "5 3 4\naaT\nacc\nbbb\nbbc\ncSb",
"output": "bbbc"
},
{
"input": "5 5 1\ncaTbc\ndccac\ndacda\naacaS\ncdcab",
"output": "-1"
},
{
"input": "10 8 2\nbdcdcbfa\ndecffcce\ndTffdacb\neeedcdbb\nfdbbbcba\nddabfcda\nabdbSeed\nbdcdcffa\ncadbaffa\nfcccddad",
"output": "bbbbee"
},
{
"input": "20 10 3\nebebccacdb\neeebccddeT\neadebecaac\nadeeeaccbc\nbaccccdaed\ndeabceabba\ndadbecbaaa\neacbbcedcb\naeeScdbbab\nbabaecaead\nbacdbebeae\naacbadbeec\nacddceecca\nacaeaebaba\ncdddeaaeae\neabddadade\nddddaeaeed\nbccbaacadd\ndccccbabdc\necdaebeccc",
"output": "bbbcccaccaac"
},
{
"input": "15 10 4\nsejwprqjku\npnjsiopxft\nrsplgvwixq\nendglkchxl\nftihbbexgh\nsxtxbbavge\njcdkusfnmr\nskgsqvflia\nkcxmcxjpae\namaiwcfile\nnjgjSunmwd\nldxvahgreu\necmrajbjuT\nnaioqigols\npbwrmxkltj",
"output": "aajbju"
},
{
"input": "15 3 4\nllv\nttT\nhbo\nogc\nkfe\ngli\nfbx\nkfp\nspm\ncxc\nndw\nSoa\npfh\nedr\nxmv",
"output": "-1"
},
{
"input": "15 15 3\ncbbdccabdcbacbd\nbcabdcacadacdbc\ncbcddbbcdbddcad\nddcabdbbdcabbdc\naabadcccTcabdbb\ncbacaaacaabdbbd\ndbdcbSdabaadbdb\ndbbaddcdddaadbb\nbbddcdcbaccbbaa\nadadadbdbbddccc\ncddbbdaddcbbdcc\nbbaadcdbbcaacca\nadbdcdbbcbddbcd\ncdadbcccddcdbda\ncbcdaabdcabccbc",
"output": "aaca"
},
{
"input": "20 20 2\nddadfcdeTaeccbedeaec\nacafdfdeaffdeabdcefe\nabbcbefcdbbbcdebafef\nfdafdcccbcdeeaedeffc\ndfdaabdefdafabaabcef\nfebdcabacaaaabfacbbe\nabfcaacadfdbfdbaaefd\ndacceeccddccaccdbbce\ncacebecabedbddfbfdad\ndacbfcabbebfddcedffd\ncfcdfacfadcfbcebebaa\nddfbebafaccbebeefbac\nebfaebacbbebdfcbcbea\ndfbaebcfccacfeaccaad\nedeedeceebcbfdbcdbbe\nafaacccfbdecebfdabed\nddbdcedacedadeccaeec\necbSeacbdcccbcedafef\ncfdbeeffbeeafccfdddb\ncefdbdfbabccfdaaadbf",
"output": "-1"
},
{
"input": "10 10 2\nbaaaaaaaaa\nbffacffffa\nbggaccggga\nbbbSccchha\nbdddddccia\nbjddccccca\nbkkdddTaaa\nblllddblla\nbmmmmdbmma\nbbbbbbbbbb",
"output": "ccccc"
},
{
"input": "10 20 3\nbaaaaaaaaaaaaaaaaaaa\nbfffffffacfffffffffa\nbgggggggaccgggggggga\nbbbbbbbbSccchhhhhhha\nbiiiiidddddcciiiiiia\nbjjjjjjddcccccjjjjja\nbkkkkkkkdddTaaaaaaaa\nbllllllllddbllllllla\nbmmmmmmmmmdbmmmmmmma\nbbbbbbbbbbbbbbbbbbbb",
"output": "ccccc"
},
{
"input": "20 10 4\nbaaaaaaaaa\nbffacffffa\nbggaccggga\nbhhaccchha\nbiiaccccia\nbjjaccccca\nbkkakkkkka\nbllallllla\nbbbSmmmmma\nbnnnnnnnna\nbooooooooa\nbpppppTaaa\nbqqqqqbqqa\nbrrrrrbrra\nbdddddbssa\nbtddddbtta\nbuudddbuua\nbvvvddbvva\nbwwwwdbwwa\nbbbbbbbbbb",
"output": "mmmno"
},
{
"input": "20 20 2\nbaaaaaaaaaaaaaaaaaaa\nbfffffffacfffffffffa\nbgggggggaccgggggggga\nbhhhhhhhaccchhhhhhha\nbiiiiiiiacccciiiiiia\nbjjjjjjjacccccjjjjja\nbkkkkkkkacccccckkkka\nblllllllacccccccllla\nbbbbbbbbSccccccccmma\nbddddddddddcccccccna\nbodddddddcccccccccca\nbppddddddddTaaaaaaaa\nbqqqdddddddbqqqqqqqa\nbrrrrddddddbrrrrrrra\nbsssssdddddbsssssssa\nbttttttddddbttttttta\nbuuuuuuudddbuuuuuuua\nbvvvvvvvvddbvvvvvvva\nbwwwwwwwwwdbwwwwwwwa\nbbbbbbbbbbbbbbbbbbbb",
"output": "ccccc"
},
{
"input": "1 10 2\nbaaSaaTacb",
"output": "aa"
}
] | 5,000 | 614,400 | 0 | 51,423 |
|
412 | Giving Awards | [
"dfs and similar"
] | null | null | The employees of the R1 company often spend time together: they watch football, they go camping, they solve contests. So, it's no big deal that sometimes someone pays for someone else.
Today is the day of giving out money rewards. The R1 company CEO will invite employees into his office one by one, rewarding each one for the hard work this month. The CEO knows who owes money to whom. And he also understands that if he invites person *x* to his office for a reward, and then immediately invite person *y*, who has lent some money to person *x*, then they can meet. Of course, in such a situation, the joy of person *x* from his brand new money reward will be much less. Therefore, the R1 CEO decided to invite the staff in such an order that the described situation will not happen for any pair of employees invited one after another.
However, there are a lot of employees in the company, and the CEO doesn't have a lot of time. Therefore, the task has been assigned to you. Given the debt relationships between all the employees, determine in which order they should be invited to the office of the R1 company CEO, or determine that the described order does not exist. | The first line contains space-separated integers *n* and *m* β the number of employees in R1 and the number of debt relations. Each of the following *m* lines contains two space-separated integers *a**i*, *b**i* (1<=β€<=*a**i*,<=*b**i*<=β€<=*n*;Β *a**i*<=β <=*b**i*), these integers indicate that the person number *a**i* owes money to a person a number *b**i*. Assume that all the employees are numbered from 1 to *n*.
It is guaranteed that each pair of people *p*, *q* is mentioned in the input data at most once. In particular, the input data will not contain pairs *p*, *q* and *q*, *p* simultaneously. | Print -1 if the described order does not exist. Otherwise, print the permutation of *n* distinct integers. The first number should denote the number of the person who goes to the CEO office first, the second number denote the person who goes second and so on.
If there are multiple correct orders, you are allowed to print any of them. | [
"2 1\n1 2\n",
"3 3\n1 2\n2 3\n3 1\n"
] | [
"2 1 \n",
"2 1 3 \n"
] | none | [
{
"input": "2 1\n1 2",
"output": "2 1 "
},
{
"input": "3 3\n1 2\n2 3\n3 1",
"output": "2 1 3 "
},
{
"input": "10 45\n10 5\n10 7\n6 1\n5 8\n3 5\n6 5\n1 2\n6 10\n2 9\n9 5\n4 1\n7 5\n1 8\n6 8\n10 9\n7 2\n7 9\n4 10\n7 3\n4 8\n10 3\n10 8\n2 10\n8 2\n4 2\n5 2\n9 1\n4 5\n1 3\n9 6\n3 8\n5 1\n6 4\n4 7\n8 7\n7 1\n9 3\n3 4\n6 2\n3 2\n6 7\n6 3\n4 9\n8 9\n1 10",
"output": "2 3 1 5 7 8 4 6 9 10 "
},
{
"input": "4 6\n3 4\n4 1\n4 2\n2 1\n3 2\n3 1",
"output": "1 2 4 3 "
},
{
"input": "5 10\n4 2\n4 5\n3 1\n2 1\n3 4\n3 2\n5 1\n5 2\n4 1\n5 3",
"output": "1 2 4 3 5 "
}
] | 46 | 0 | 0 | 51,427 |
|
0 | none | [
"none"
] | null | null | Maxim loves to fill in a matrix in a special manner. Here is a pseudocode of filling in a matrix of size (*m*<=+<=1)<=Γ<=(*m*<=+<=1):
Maxim asks you to count, how many numbers *m* (1<=β€<=*m*<=β€<=*n*) are there, such that the sum of values in the cells in the row number *m*<=+<=1 of the resulting matrix equals *t*.
Expression (*x* *xor* *y*) means applying the operation of bitwise excluding "OR" to numbers *x* and *y*. The given operation exists in all modern programming languages. For example, in languages C++ and Java it is represented by character "^", in Pascal β by "xor". | A single line contains two integers *n* and *t* (1<=β€<=*n*,<=*t*<=β€<=1012,<=*t*<=β€<=*n*<=+<=1).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier. | In a single line print a single integer β the answer to the problem. | [
"1 1\n",
"3 2\n",
"3 3\n",
"1000000000000 1048576\n"
] | [
"1\n",
"1\n",
"0\n",
"118606527258\n"
] | none | [
{
"input": "1 1",
"output": "1"
},
{
"input": "3 2",
"output": "1"
},
{
"input": "3 3",
"output": "0"
},
{
"input": "1000000000000 1048576",
"output": "118606527258"
},
{
"input": "35 4",
"output": "11"
},
{
"input": "70 32",
"output": "1"
},
{
"input": "79 32",
"output": "1"
},
{
"input": "63 16",
"output": "6"
},
{
"input": "6 4",
"output": "1"
},
{
"input": "82 16",
"output": "7"
},
{
"input": "4890852 16",
"output": "31009"
},
{
"input": "473038165 2",
"output": "406"
},
{
"input": "326051437 4",
"output": "3601"
},
{
"input": "170427799 16",
"output": "94897"
},
{
"input": "168544291 8",
"output": "20039"
},
{
"input": "82426873 1",
"output": "26"
},
{
"input": "175456797 16384",
"output": "22858807"
},
{
"input": "257655784 16384",
"output": "35969589"
},
{
"input": "9581849 1024",
"output": "1563491"
},
{
"input": "8670529 16384",
"output": "493388"
},
{
"input": "621597009 268435456",
"output": "1"
},
{
"input": "163985731 33554432",
"output": "27"
},
{
"input": "758646694 67108864",
"output": "460"
},
{
"input": "304012333 67108864",
"output": "28"
},
{
"input": "58797441 33554432",
"output": "0"
},
{
"input": "445762753 268435456",
"output": "0"
},
{
"input": "62695452 33554432",
"output": "0"
},
{
"input": "47738179 16777216",
"output": "1"
},
{
"input": "144342486 67108864",
"output": "1"
},
{
"input": "138791611 67108864",
"output": "1"
},
{
"input": "112400107 67108864",
"output": "0"
},
{
"input": "119581441 33554432",
"output": "3"
},
{
"input": "79375582 67108864",
"output": "0"
},
{
"input": "121749691 33554432",
"output": "3"
},
{
"input": "585863386 33554432",
"output": "3655"
},
{
"input": "329622201 19482151",
"output": "0"
},
{
"input": "303397385 106697011",
"output": "0"
},
{
"input": "543649338 175236010",
"output": "0"
},
{
"input": "341001112 155173936",
"output": "0"
},
{
"input": "1000000000 1000000001",
"output": "0"
},
{
"input": "1000000000000 16",
"output": "657969"
},
{
"input": "1000000000000 549755813888",
"output": "0"
},
{
"input": "1000000000000 1048576",
"output": "118606527258"
},
{
"input": "987654321987 1048576",
"output": "116961880791"
},
{
"input": "1000000000000 1000000000000",
"output": "0"
}
] | 186 | 0 | 3 | 51,580 |
|
976 | Minimal k-covering | [
"flows",
"graphs"
] | null | null | You are given a bipartite graph *G*<==<=(*U*,<=*V*,<=*E*), *U* is the set of vertices of the first part, *V* is the set of vertices of the second part and *E* is the set of edges. There might be multiple edges.
Let's call some subset of its edges *k*-covering iff the graph has each of its vertices incident to at least *k* edges. Minimal *k*-covering is such a *k*-covering that the size of the subset is minimal possible.
Your task is to find minimal *k*-covering for each , where *minDegree* is the minimal degree of any vertex in graph *G*. | The first line contains three integers *n*1, *n*2 and *m* (1<=β€<=*n*1,<=*n*2<=β€<=2000, 0<=β€<=*m*<=β€<=2000) β the number of vertices in the first part, the number of vertices in the second part and the number of edges, respectively.
The *i*-th of the next *m* lines contain two integers *u**i* and *v**i* (1<=β€<=*u**i*<=β€<=*n*1,<=1<=β€<=*v**i*<=β€<=*n*2) β the description of the *i*-th edge, *u**i* is the index of the vertex in the first part and *v**i* is the index of the vertex in the second part. | For each print the subset of edges (minimal *k*-covering) in separate line.
The first integer *cnt**k* of the *k*-th line is the number of edges in minimal *k*-covering of the graph. Then *cnt**k* integers follow β original indices of the edges which belong to the minimal *k*-covering, these indices should be pairwise distinct. Edges are numbered 1 through *m* in order they are given in the input. | [
"3 3 7\n1 2\n2 3\n1 3\n3 2\n3 3\n2 1\n2 1\n",
"1 1 5\n1 1\n1 1\n1 1\n1 1\n1 1\n"
] | [
"0 \n3 3 7 4 \n6 1 3 6 7 4 5 \n",
"0 \n1 5 \n2 4 5 \n3 3 4 5 \n4 2 3 4 5 \n5 1 2 3 4 5 \n"
] | none | [
{
"input": "3 3 7\n1 2\n2 3\n1 3\n3 2\n3 3\n2 1\n2 1",
"output": "0 \n3 3 7 4 \n6 1 3 6 7 4 5 "
},
{
"input": "1 1 5\n1 1\n1 1\n1 1\n1 1\n1 1",
"output": "0 \n1 5 \n2 4 5 \n3 3 4 5 \n4 2 3 4 5 \n5 1 2 3 4 5 "
},
{
"input": "1 1 0",
"output": "0 "
},
{
"input": "2000 2000 1\n1387 936",
"output": "0 "
},
{
"input": "2000 2000 2\n804 1037\n1788 295",
"output": "0 "
},
{
"input": "9 9 55\n5 1\n8 3\n1 6\n5 6\n5 9\n6 5\n9 8\n6 6\n5 5\n7 7\n7 2\n1 6\n3 8\n4 3\n1 8\n8 5\n5 4\n6 1\n2 7\n2 6\n2 8\n7 7\n7 3\n6 9\n2 7\n9 3\n3 5\n7 9\n6 8\n4 6\n5 2\n9 2\n4 3\n9 5\n3 2\n2 2\n7 3\n3 8\n3 4\n5 9\n4 2\n7 9\n1 8\n8 8\n9 9\n7 1\n6 6\n4 8\n9 4\n8 8\n3 5\n6 8\n1 6\n7 5\n5 3",
"output": "0 \n9 15 19 51 41 17 47 46 2 45 \n18 43 53 25 36 39 51 33 41 5 17 18 47 22 46 2 50 34 45 \n27 15 43 53 19 25 36 35 39 51 14 33 41 1 5 17 8 18 47 22 42 46 2 16 50 34 45 49 "
},
{
"input": "4 4 88\n2 1\n3 3\n1 1\n4 3\n3 3\n2 1\n1 1\n3 2\n4 3\n1 1\n2 1\n4 4\n2 1\n2 2\n2 4\n2 3\n2 1\n2 4\n3 4\n4 4\n1 2\n1 2\n1 4\n4 4\n1 2\n1 1\n1 2\n4 2\n4 3\n4 4\n4 1\n2 4\n3 4\n3 3\n1 3\n1 1\n4 4\n1 3\n1 2\n3 4\n4 1\n3 1\n3 1\n4 3\n2 3\n1 1\n1 1\n1 1\n3 2\n3 1\n3 3\n1 1\n1 4\n2 2\n3 1\n3 2\n4 2\n2 4\n4 1\n2 3\n3 3\n1 1\n2 3\n2 3\n4 1\n4 1\n3 1\n4 1\n1 4\n3 2\n1 3\n4 4\n4 2\n3 1\n4 3\n3 3\n4 1\n1 1\n2 2\n2 1\n4 1\n1 2\n1 2\n2 1\n4 1\n3 2\n3 1\n2 1",
"output": "0 \n4 83 15 87 75 \n8 82 83 64 88 19 87 72 75 \n12 78 82 83 15 64 88 76 86 87 37 72 75 \n16 71 78 82 83 15 64 79 88 74 76 86 87 30 37 72 75 \n20 69 71 78 82 83 63 64 79 84 88 70 74 76 86 87 24 30 37 72 75 \n24 62 69 71 78 82 83 15 63 64 79 84 88 61 70 74 76 86 87 24 30 37 72 73 75 \n28 53 62 69 71 78 82 83 60 63 64 79 80 84 88 56 61 70 74 76 86 87 20 24 30 37 72 73 75 \n32 52 53 62 69 71 78 82 83 58 60 63 64 79 80 84 88 49 56 61 70 74 76 86 87 20 24 30 37 44 72 73 75 \n36 48 52 53 62 69 71 78 82 83 54 58 6..."
}
] | 1,500 | 51,097,600 | 0 | 51,721 |
|
618 | Hamiltonian Spanning Tree | [
"dfs and similar",
"dp",
"graph matchings",
"greedy",
"trees"
] | null | null | A group of *n* cities is connected by a network of roads. There is an undirected road between every pair of cities, so there are roads in total. It takes exactly *y* seconds to traverse any single road.
A spanning tree is a set of roads containing exactly *n*<=-<=1 roads such that it's possible to travel between any two cities using only these roads.
Some spanning tree of the initial network was chosen. For every road in this tree the time one needs to traverse this road was changed from *y* to *x* seconds. Note that it's not guaranteed that *x* is smaller than *y*.
You would like to travel through all the cities using the shortest path possible. Given *n*, *x*, *y* and a description of the spanning tree that was chosen, find the cost of the shortest path that starts in any city, ends in any city and visits all cities exactly once. | The first line of the input contains three integers *n*, *x* and *y* (2<=β€<=*n*<=β€<=200<=000,<=1<=β€<=*x*,<=*y*<=β€<=109).
Each of the next *n*<=-<=1 lines contains a description of a road in the spanning tree. The *i*-th of these lines contains two integers *u**i* and *v**i* (1<=β€<=*u**i*,<=*v**i*<=β€<=*n*)Β β indices of the cities connected by the *i*-th road. It is guaranteed that these roads form a spanning tree. | Print a single integerΒ β the minimum number of seconds one needs to spend in order to visit all the cities exactly once. | [
"5 2 3\n1 2\n1 3\n3 4\n5 3\n",
"5 3 2\n1 2\n1 3\n3 4\n5 3\n"
] | [
"9\n",
"8\n"
] | In the first sample, roads of the spanning tree have cost 2, while other roads have cost 3. One example of an optimal path is <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/3a11f64ac0349d4ecd3a2b4c3443aeb7ac3b28b9.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
In the second sample, we have the same spanning tree, but roads in the spanning tree cost 3, while other roads cost 2. One example of an optimal path is <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/3fdb844c44665567f5addf82820eb6f96a060920.png" style="max-width: 100.0%;max-height: 100.0%;"/>. | [
{
"input": "5 2 3\n1 2\n1 3\n3 4\n5 3",
"output": "9"
},
{
"input": "5 3 2\n1 2\n1 3\n3 4\n5 3",
"output": "8"
},
{
"input": "50 23129 410924\n18 28\n17 23\n21 15\n18 50\n50 11\n32 3\n44 41\n50 31\n50 34\n5 14\n36 13\n22 40\n20 9\n9 43\n19 47\n48 40\n20 22\n33 45\n35 22\n33 24\n9 6\n13 1\n13 24\n49 20\n1 20\n29 38\n10 35\n25 23\n49 30\n42 8\n20 18\n32 15\n32 1\n27 10\n20 47\n41 7\n20 14\n18 26\n4 20\n20 2\n46 37\n41 16\n46 41\n12 20\n8 40\n18 37\n29 3\n32 39\n23 37",
"output": "8113631"
},
{
"input": "2 3 4\n1 2",
"output": "3"
},
{
"input": "50 491238 12059\n42 3\n5 9\n11 9\n41 15\n42 34\n11 6\n40 16\n23 8\n41 7\n22 6\n24 29\n7 17\n31 2\n17 33\n39 42\n42 6\n41 50\n21 45\n19 41\n1 21\n42 1\n2 25\n17 28\n49 42\n30 13\n4 12\n10 32\n48 35\n21 2\n14 6\n49 29\n18 20\n38 22\n19 37\n20 47\n3 36\n1 44\n20 7\n4 11\n39 26\n30 40\n6 7\n25 46\n2 27\n30 42\n10 11\n8 21\n42 43\n35 8",
"output": "590891"
},
{
"input": "2 4 1\n1 2",
"output": "4"
},
{
"input": "5 2 2\n1 2\n1 3\n1 4\n1 5",
"output": "8"
},
{
"input": "4 100 1\n1 2\n1 3\n1 4",
"output": "102"
},
{
"input": "3 2 1\n1 2\n1 3",
"output": "3"
},
{
"input": "5 6 1\n1 2\n1 3\n1 4\n1 5",
"output": "9"
},
{
"input": "3 100 1\n1 2\n2 3",
"output": "101"
},
{
"input": "2 2 1\n1 2",
"output": "2"
},
{
"input": "5 3 2\n1 2\n1 3\n1 4\n1 5",
"output": "9"
},
{
"input": "4 1000 1\n1 2\n1 3\n1 4",
"output": "1002"
},
{
"input": "4 100 1\n1 2\n2 3\n3 4",
"output": "3"
},
{
"input": "2 3 1\n1 2",
"output": "3"
},
{
"input": "5 4 3\n1 2\n1 3\n1 4\n1 5",
"output": "13"
}
] | 0 | 0 | -1 | 52,042 |
|
528 | Fuzzy Search | [
"bitmasks",
"brute force",
"fft"
] | null | null | Leonid works for a small and promising start-up that works on decoding the human genome. His duties include solving complex problems of finding certain patterns in long strings consisting of letters 'A', 'T', 'G' and 'C'.
Let's consider the following scenario. There is a fragment of a human DNA chain, recorded as a string *S*. To analyze the fragment, you need to find all occurrences of string *T* in a string *S*. However, the matter is complicated by the fact that the original chain fragment could contain minor mutations, which, however, complicate the task of finding a fragment. Leonid proposed the following approach to solve this problem.
Let's write down integer *k*<=β₯<=0 β the error threshold. We will say that string *T* occurs in string *S* on position *i* (1<=β€<=*i*<=β€<=|*S*|<=-<=|*T*|<=+<=1), if after putting string *T* along with this position, each character of string *T* corresponds to the some character of the same value in string *S* at the distance of at most *k*. More formally, for any *j* (1<=β€<=*j*<=β€<=|*T*|) there must exist such *p* (1<=β€<=*p*<=β€<=|*S*|), that |(*i*<=+<=*j*<=-<=1)<=-<=*p*|<=β€<=*k* and *S*[*p*]<==<=*T*[*j*].
For example, corresponding to the given definition, string "ACAT" occurs in string "AGCAATTCAT" in positions 2, 3 and 6.
Note that at *k*<==<=0 the given definition transforms to a simple definition of the occurrence of a string in a string.
Help Leonid by calculating in how many positions the given string *T* occurs in the given string *S* with the given error threshold. | The first line contains three integers |*S*|,<=|*T*|,<=*k* (1<=β€<=|*T*|<=β€<=|*S*|<=β€<=200<=000, 0<=β€<=*k*<=β€<=200<=000) β the lengths of strings *S* and *T* and the error threshold.
The second line contains string *S*.
The third line contains string *T*.
Both strings consist only of uppercase letters 'A', 'T', 'G' and 'C'. | Print a single number β the number of occurrences of *T* in *S* with the error threshold *k* by the given definition. | [
"10 4 1\nAGCAATTCAT\nACAT\n"
] | [
"3\n"
] | If you happen to know about the structure of the human genome a little more than the author of the problem, and you are not impressed with Leonid's original approach, do not take everything described above seriously. | [
{
"input": "10 4 1\nAGCAATTCAT\nACAT",
"output": "3"
},
{
"input": "1 1 0\nA\nA",
"output": "1"
},
{
"input": "1 1 0\nA\nT",
"output": "0"
},
{
"input": "1 1 1\nA\nT",
"output": "0"
},
{
"input": "5 3 0\nATATA\nATA",
"output": "2"
},
{
"input": "5 3 1\nATATA\nATA",
"output": "3"
},
{
"input": "7 1 2\nATGCGTA\nA",
"output": "6"
},
{
"input": "7 1 3\nATGCGTA\nA",
"output": "7"
},
{
"input": "4 4 0\nATGC\nGCTA",
"output": "0"
},
{
"input": "4 4 1\nATGC\nGCTA",
"output": "0"
},
{
"input": "4 4 2\nATGC\nGCTA",
"output": "0"
}
] | 30 | 0 | 0 | 52,059 |
|
1,000 | We Need More Bosses | [
"dfs and similar",
"graphs",
"trees"
] | null | null | Your friend is developing a computer game. He has already decided how the game world should look like β it should consist of $n$ locations connected by $m$ two-way passages. The passages are designed in such a way that it should be possible to get from any location to any other location.
Of course, some passages should be guarded by the monsters (if you just can go everywhere without any difficulties, then it's not fun, right?). Some crucial passages will be guarded by really fearsome monsters, requiring the hero to prepare for battle and designing his own tactics of defeating them (commonly these kinds of monsters are called bosses). And your friend wants you to help him place these bosses.
The game will start in location $s$ and end in location $t$, but these locations are not chosen yet. After choosing these locations, your friend will place a boss in each passage such that it is impossible to get from $s$ to $t$ without using this passage. Your friend wants to place as much bosses as possible (because more challenges means more fun, right?), so he asks you to help him determine the maximum possible number of bosses, considering that any location can be chosen as $s$ or as $t$. | The first line contains two integers $n$ and $m$ ($2 \le n \le 3 \cdot 10^5$, $n - 1 \le m \le 3 \cdot 10^5$) β the number of locations and passages, respectively.
Then $m$ lines follow, each containing two integers $x$ and $y$ ($1 \le x, y \le n$, $x \ne y$) describing the endpoints of one of the passages.
It is guaranteed that there is no pair of locations directly connected by two or more passages, and that any location is reachable from any other location. | Print one integer β the maximum number of bosses your friend can place, considering all possible choices for $s$ and $t$. | [
"5 5\n1 2\n2 3\n3 1\n4 1\n5 2\n",
"4 3\n1 2\n4 3\n3 2\n"
] | [
"2\n",
"3\n"
] | none | [
{
"input": "5 5\n1 2\n2 3\n3 1\n4 1\n5 2",
"output": "2"
},
{
"input": "4 3\n1 2\n4 3\n3 2",
"output": "3"
},
{
"input": "50 72\n35 38\n19 46\n35 12\n27 30\n23 41\n50 16\n31 6\n20 33\n38 1\n10 35\n13 43\n29 25\n25 4\n1 13\n4 20\n36 29\n13 47\n48 5\n30 21\n30 38\n28 50\n41 45\n25 43\n40 36\n19 47\n31 32\n26 28\n8 13\n43 24\n27 35\n14 29\n14 38\n50 9\n34 49\n12 34\n43 42\n41 15\n46 29\n48 11\n48 7\n40 29\n48 21\n18 26\n15 11\n12 39\n18 42\n27 12\n6 9\n19 37\n45 39\n5 36\n37 22\n18 49\n15 38\n24 42\n34 45\n43 3\n2 1\n18 48\n43 30\n26 10\n30 13\n2 27\n8 3\n22 42\n14 4\n14 27\n13 3\n14 10\n41 25\n17 50\n44 9",
"output": "8"
},
{
"input": "5 6\n1 5\n2 3\n3 5\n2 1\n2 5\n2 4",
"output": "1"
}
] | 1,497 | 268,390,400 | 0 | 52,074 |
|
46 | Hercule Poirot Problem | [
"dsu",
"graphs"
] | F. Hercule Poirot Problem | 2 | 256 | Today you are to solve the problem even the famous Hercule Poirot can't cope with! That's why this crime has not yet been solved and this story was never included in Agatha Christie's detective story books.
You are not informed on what crime was committed, when and where the corpse was found and other details. We only know that the crime was committed in a house that has *n* rooms and *m* doors between the pairs of rooms. The house residents are very suspicious, that's why all the doors can be locked with keys and all the keys are different. According to the provided evidence on Thursday night all the doors in the house were locked, and it is known in what rooms were the residents, and what kind of keys had any one of them. The same is known for the Friday night, when all the doors were also locked. On Friday it was raining heavily, that's why nobody left the house and nobody entered it. During the day the house residents could
- open and close doors to the neighboring rooms using the keys at their disposal (every door can be opened and closed from each side); - move freely from a room to a room if a corresponding door is open; - give keys to one another, being in one room.
"Little grey matter" of Hercule Poirot are not capable of coping with such amount of information. Find out if the positions of people and keys on the Thursday night could result in the positions on Friday night, otherwise somebody among the witnesses is surely lying. | The first line contains three preset integers *n*, *m* ΠΈ *k* (1<=β€<=*n*,<=*m*,<=*k*<=β€<=1000) β the number of rooms, the number of doors and the number of house residents respectively. The next *m* lines contain pairs of room numbers which join the doors. The rooms are numbered with integers from 1 to *n*. There cannot be more that one door between the pair of rooms. No door connects a room with itself. The next *k* lines describe the residents' position on the first night. Every line contains a resident's name (a non-empty line consisting of no more than 10 Latin letters), then after a space follows the room number, then, after a space β the number of keys the resident has. Then follow written space-separated numbers of the doors that can be unlocked by these keys. The doors are numbered with integers from 1 to *m* in the order in which they are described in the input data. All the residents have different names, uppercase and lowercase letters considered to be different. Every *m* keys occurs exactly once in the description. Multiple people may be present in one room, some rooms may be empty. The next *k* lines describe the position of the residents on the second night in the very same format. It is guaranteed that in the second night's description the residents' names remain the same and every *m* keys occurs exactly once. | Print "YES" (without quotes) if the second arrangement can result from the first one, otherwise, print "NO". | [
"2 1 2\n1 2\nDmitry 1 1 1\nNatalia 2 0\nNatalia 1 1 1\nDmitry 2 0\n",
"4 4 3\n1 3\n1 2\n2 3\n3 4\nArtem 1 1 4\nDmitry 1 1 2\nEdvard 4 2 1 3\nArtem 2 0\nDmitry 1 0\nEdvard 4 4 1 2 3 4\n"
] | [
"YES\n",
"NO\n"
] | none | [
{
"input": "2 1 2\n1 2\nDmitry 1 1 1\nNatalia 2 0\nNatalia 1 1 1\nDmitry 2 0",
"output": "YES"
},
{
"input": "4 4 3\n1 3\n1 2\n2 3\n3 4\nArtem 1 1 4\nDmitry 1 1 2\nEdvard 4 2 1 3\nArtem 2 0\nDmitry 1 0\nEdvard 4 4 1 2 3 4",
"output": "NO"
},
{
"input": "2 1 1\n2 1\nabsgdf 1 1 1\nabsgdf 1 1 1",
"output": "YES"
},
{
"input": "2 1 1\n2 1\nabsgdf 2 1 1\nabsgdf 1 1 1",
"output": "YES"
},
{
"input": "3 3 3\n1 2\n2 3\n3 1\na 1 1 1\nb 2 1 3\nc 3 1 2\na 3 1 3\nb 1 0\nc 2 2 1 2",
"output": "YES"
},
{
"input": "3 3 3\n1 2\n2 3\n3 1\na 1 1 1\nb 2 1 3\nc 3 1 2\nb 1 1 2\nc 2 1 3\na 3 1 1",
"output": "NO"
},
{
"input": "3 3 3\n1 2\n2 3\n3 1\nb 1 1 2\nc 2 1 3\na 3 1 1\na 3 1 3\nb 1 0\nc 2 2 1 2",
"output": "NO"
},
{
"input": "4 5 3\n1 2\n2 3\n2 4\n1 3\n1 3\na 1 2 4 3\nb 1 0\nc 4 3 1 2 5\na 1 2 4 3\nb 1 1 5\nc 4 2 1 2",
"output": "NO"
},
{
"input": "2 2 2\n1 2\n2 1\nA 1 1 2\nB 1 1 1\nA 1 0\nB 2 2 1 2",
"output": "YES"
},
{
"input": "4 2 4\n2 1\n4 3\na 1 1 1\nb 2 1 2\nc 3 0\nd 4 0\na 2 1 2\nb 1 1 1\nc 3 0\nd 4 0",
"output": "YES"
},
{
"input": "4 2 4\n2 1\n4 3\na 1 1 1\nb 2 1 2\nc 3 0\nd 4 0\na 2 1 2\nb 1 1 1\nc 4 0\nd 3 0",
"output": "NO"
},
{
"input": "6 3 4\n1 2\n3 4\n5 6\na 1 2 1 3\nb 3 1 2\nc 5 0\nd 6 0\na 2 2 1 3\nb 4 1 2\nc 5 0\nd 6 0",
"output": "YES"
},
{
"input": "6 3 4\n1 2\n3 4\n5 6\na 1 2 1 3\nb 3 1 2\nc 5 0\nd 6 0\na 2 1 1\nb 4 2 2 3\nc 5 0\nd 6 0",
"output": "NO"
},
{
"input": "10 20 5\n2 1\n3 1\n4 2\n5 1\n6 5\n7 2\n8 5\n9 8\n10 6\n2 6\n3 5\n3 4\n10 5\n8 3\n9 4\n10 8\n9 2\n6 3\n3 8\n9 8\nDKkXdT 10 20 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20\nOzvgPXMzAr 5 0\nbjac 3 0\ncBPbJtoND 6 0\nw 5 0\nbjac 4 20 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20\nOzvgPXMzAr 2 0\ncBPbJtoND 5 0\nw 10 0\nDKkXdT 4 0",
"output": "YES"
},
{
"input": "10 9 10\n1 2\n2 3\n3 4\n4 5\n5 6\n6 7\n7 8\n8 9\n9 10\nInCeN 1 0\nIzHqPceNhj 2 1 9\neH 3 1 8\nJvgBsNFi 4 1 7\nBA 5 1 6\nRrjSTXJzhL 6 1 5\nDMx 7 1 4\nJzt 8 1 3\nhxBRlDlqwD 9 1 2\nImWeEPkggZ 10 1 1\neH 1 0\nImWeEPkggZ 2 1 9\nDMx 3 1 8\nIzHqPceNhj 4 1 7\nInCeN 5 1 6\nJvgBsNFi 6 1 5\nRrjSTXJzhL 7 1 4\nJzt 8 1 3\nhxBRlDlqwD 9 1 2\nBA 10 1 1",
"output": "YES"
},
{
"input": "11 10 11\n1 2\n2 11\n3 4\n4 11\n5 6\n6 11\n7 8\n8 11\n9 10\n10 11\na 1 1 9\nb 2 1 10\nc 3 0\nd 4 1 1\ne 5 1 3\nf 6 1 4\ng 7 1 5\nh 8 1 6\ni 9 1 7\nj 10 1 8\nk 11 1 2\na 1 0\nb 2 0\nc 3 0\nd 4 0\ne 5 0\nf 6 0\ng 7 0\nh 8 0\ni 9 0\nj 10 0\nk 11 10 1 2 3 4 5 6 7 8 9 10",
"output": "YES"
},
{
"input": "11 10 11\n1 2\n2 11\n3 4\n4 11\n5 6\n6 11\n7 8\n8 11\n9 10\n10 11\na 1 0\nb 2 0\nc 3 0\nd 4 0\ne 5 0\nf 6 0\ng 7 0\nh 8 0\ni 9 0\nj 10 0\nk 11 10 1 2 3 4 5 6 7 8 9 10\na 1 1 9\nb 2 1 10\nc 3 0\nd 4 1 1\ne 5 1 3\nf 6 1 4\ng 7 1 5\nh 8 1 6\ni 9 1 7\nj 10 1 8\nk 11 1 2",
"output": "YES"
},
{
"input": "7 8 2\n3 7\n7 6\n1 2\n4 5\n1 3\n5 6\n4 6\n2 3\na 7 4 3 8 5 2\nb 7 4 4 6 7 1\na 1 4 3 8 5 2\nb 4 4 4 6 7 1",
"output": "NO"
},
{
"input": "7 8 2\n3 7\n7 6\n1 2\n4 5\n1 3\n5 6\n4 6\n2 3\na 1 4 3 8 5 2\nb 4 4 4 6 7 1\na 3 4 3 8 5 2\nb 6 4 4 6 7 1",
"output": "YES"
},
{
"input": "7 7 2\n1 2\n2 3\n3 4\n4 5\n5 6\n6 7\n7 1\na 1 4 1 3 5 7\nb 2 3 2 4 6\na 7 4 1 3 5 7\nb 4 3 2 4 6",
"output": "NO"
},
{
"input": "7 7 2\n1 2\n2 3\n3 4\n4 5\n5 6\n6 7\n7 1\na 1 4 1 3 5 7\nb 2 3 2 4 6\na 4 4 1 3 5 7\nb 4 3 2 4 6",
"output": "YES"
},
{
"input": "10 20 10\n1 10\n5 10\n2 9\n2 6\n9 6\n3 9\n7 1\n10 5\n7 8\n8 7\n2 3\n9 6\n1 6\n5 3\n4 3\n3 7\n8 2\n6 4\n2 3\n4 1\nTjOMmYPRUY 7 3 1 3 9\nj 6 2 11 15\nBanBSrUA 4 2 19 20\ncSWZxzR 8 1 8\nzVoRlNgt 10 2 6 7\nWLGaq 1 3 10 13 17\nKahHtTDj 1 2 2 14\nrUFZmkpI 6 1 16\ni 4 3 4 5 12\nKLGiua 6 1 18\nWLGaq 10 0\ncSWZxzR 3 1 4\nj 2 3 8 13 17\nrUFZmkpI 7 2 1 19\nKahHtTDj 5 1 16\nKLGiua 6 2 2 12\nBanBSrUA 2 4 6 7 10 15\nTjOMmYPRUY 9 3 3 9 18\nzVoRlNgt 10 2 11 20\ni 2 2 5 14",
"output": "YES"
},
{
"input": "10 10 10\n7 10\n1 2\n4 3\n7 4\n9 2\n8 7\n10 8\n6 10\n5 2\n6 10\nznkkxCkkxv 9 1 10\nP 5 1 7\nKOF 1 2 3 9\nwYtfFWkb 3 0\nZPJiebeu 9 1 6\ndgzAhKY 4 0\nayqPf 3 0\nxFSb 9 0\nreYnbMDm 10 1 1\nydSIPy 6 4 2 4 5 8\nKOF 10 1 4\nayqPf 7 1 7\nreYnbMDm 4 1 5\nwYtfFWkb 5 1 6\nznkkxCkkxv 9 2 1 9\nydSIPy 10 0\nP 10 1 8\ndgzAhKY 7 1 2\nZPJiebeu 8 1 3\nxFSb 7 1 10",
"output": "NO"
},
{
"input": "5 8 5\n1 3\n4 2\n1 3\n4 2\n1 5\n5 3\n2 5\n2 5\nTaMmKIk 1 0\nvrLryIxio 1 3 1 6 5\nGFKONi 2 1 4\nTzRVfh 3 2 3 8\nqp 4 2 7 2\nTaMmKIk 1 2 7 4\nvrLryIxio 1 3 1 6 5\nTzRVfh 3 1 8\nqp 4 1 3\nGFKONi 4 1 2",
"output": "YES"
},
{
"input": "10 9 10\n4 7\n4 8\n8 3\n9 2\n8 3\n8 1\n6 9\n4 7\n7 4\nznkkxCkkxv 1 2 3 6\nQlf 3 0\nKOF 5 2 1 8\ndgzAhKY 5 0\nwYtfFWkb 6 2 4 7\nLbYfZPhWd 9 0\nP 10 1 9\nZPJiebeu 10 1 5\nayqPf 10 0\nzmZLwuf 10 1 2\nwYtfFWkb 2 2 7 4\nQlf 3 1 2\nznkkxCkkxv 3 3 6 3 9\nKOF 5 0\ndgzAhKY 5 0\nLbYfZPhWd 9 0\nP 10 1 5\nZPJiebeu 10 0\nayqPf 10 0\nzmZLwuf 10 2 1 8",
"output": "NO"
}
] | 92 | 0 | 0 | 52,120 |
367 | Sereja and the Arrangement of Numbers | [
"graphs",
"greedy",
"sortings"
] | null | null | Let's call an array consisting of *n* integer numbers *a*1, *a*2, ..., *a**n*, beautiful if it has the following property:
- consider all pairs of numbers *x*,<=*y* (*x*<=β <=*y*), such that number *x* occurs in the array *a* and number *y* occurs in the array *a*; - for each pair *x*,<=*y* must exist some position *j* (1<=β€<=*j*<=<<=*n*), such that at least one of the two conditions are met, either *a**j*<==<=*x*,<=*a**j*<=+<=1<==<=*y*, or *a**j*<==<=*y*,<=*a**j*<=+<=1<==<=*x*.
Sereja wants to build a beautiful array *a*, consisting of *n* integers. But not everything is so easy, Sereja's friend Dima has *m* coupons, each contains two integers *q**i*,<=*w**i*. Coupon *i* costs *w**i* and allows you to use as many numbers *q**i* as you want when constructing the array *a*. Values *q**i* are distinct. Sereja has no coupons, so Dima and Sereja have made the following deal. Dima builds some beautiful array *a* of *n* elements. After that he takes *w**i* rubles from Sereja for each *q**i*, which occurs in the array *a*. Sereja believed his friend and agreed to the contract, and now he is wondering, what is the maximum amount of money he can pay.
Help Sereja, find the maximum amount of money he can pay to Dima. | The first line contains two integers *n* and *m* (1<=β€<=*n*<=β€<=2Β·106,<=1<=β€<=*m*<=β€<=105). Next *m* lines contain pairs of integers. The *i*-th line contains numbers *q**i*,<=*w**i* (1<=β€<=*q**i*,<=*w**i*<=β€<=105).
It is guaranteed that all *q**i* are distinct. | In a single line print maximum amount of money (in rubles) Sereja can pay.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier. | [
"5 2\n1 2\n2 3\n",
"100 3\n1 2\n2 1\n3 1\n",
"1 2\n1 1\n2 100\n"
] | [
"5\n",
"4\n",
"100\n"
] | In the first sample Sereja can pay 5 rubles, for example, if Dima constructs the following array: [1,β2,β1,β2,β2]. There are another optimal arrays for this test.
In the third sample Sereja can pay 100 rubles, if Dima constructs the following array: [2]. | [
{
"input": "5 2\n1 2\n2 3",
"output": "5"
},
{
"input": "100 3\n1 2\n2 1\n3 1",
"output": "4"
},
{
"input": "1 2\n1 1\n2 100",
"output": "100"
},
{
"input": "25 29\n82963 53706\n63282 73962\n14996 48828\n84392 31903\n96293 41422\n31719 45448\n46772 17870\n9668 85036\n36704 83323\n73674 63142\n80254 1548\n40663 44038\n96724 39530\n8317 42191\n44289 1041\n63265 63447\n75891 52371\n15007 56394\n55630 60085\n46757 84967\n45932 72945\n72627 41538\n32119 46930\n16834 84640\n78705 73978\n23674 57022\n66925 10271\n54778 41098\n7987 89162",
"output": "575068"
},
{
"input": "53 1\n16942 81967",
"output": "81967"
},
{
"input": "58 38\n6384 48910\n97759 90589\n28947 5031\n45169 32592\n85656 26360\n88538 42484\n44042 88351\n42837 79021\n96022 59200\n485 96735\n98000 3939\n3789 64468\n10894 58484\n26422 26618\n25515 95617\n37452 5250\n39557 66304\n79009 40610\n80703 60486\n90344 37588\n57504 61201\n62619 79797\n51282 68799\n15158 27623\n28293 40180\n9658 62192\n2889 3512\n66635 24056\n18647 88887\n28434 28143\n9417 23999\n22652 77700\n52477 68390\n10713 2511\n22870 66689\n41790 76424\n74586 34286\n47427 67758",
"output": "910310"
},
{
"input": "90 27\n30369 65426\n63435 75442\n14146 41719\n12140 52280\n88688 50550\n3867 68194\n43298 40287\n84489 36456\n6115 63317\n77787 20314\n91186 96913\n57833 44314\n20322 79647\n24482 31197\n11130 57536\n11174 24045\n14293 65254\n94155 24746\n81187 20475\n6169 94788\n77959 22203\n26478 57315\n97335 92373\n99834 47488\n11519 81774\n41764 93193\n23103 89214",
"output": "1023071"
},
{
"input": "44 25\n65973 66182\n23433 87594\n13032 44143\n35287 55901\n92361 46975\n69171 50834\n77761 76668\n32551 93695\n61625 10126\n53695 82303\n94467 18594\n57485 4465\n31153 18088\n21927 24758\n60316 62228\n98759 53110\n41087 83488\n78475 25628\n59929 64521\n78963 60597\n97262 72526\n56261 72117\n80327 82772\n77548 17521\n94925 37764",
"output": "717345"
},
{
"input": "59 29\n93008 65201\n62440 8761\n26325 69109\n30888 54851\n42429 3385\n66541 80705\n52357 33351\n50486 15217\n41358 45358\n7272 37362\n85023 54113\n62697 44042\n60130 32566\n96933 1856\n12963 17735\n44973 38370\n26964 26484\n63636 66849\n12939 58143\n34512 32176\n5826 89871\n63935 91784\n17399 50702\n88735 10535\n93994 57706\n94549 92301\n32642 84856\n55463 82878\n679 82444",
"output": "864141"
},
{
"input": "73 19\n21018 52113\n53170 12041\n44686 99498\n73991 59354\n66652 2045\n56336 99193\n85265 20504\n51776 85293\n21550 17562\n70468 38130\n7814 88602\n84216 64214\n69825 55393\n90671 24028\n98076 67499\n46288 36605\n17222 21707\n25011 99490\n92165 51620",
"output": "860399"
},
{
"input": "6 26\n48304 25099\n17585 38972\n70914 21546\n1547 97770\n92520 48290\n10866 3246\n84319 49602\n57133 31153\n12571 45902\n10424 75601\n22016 80029\n1348 18944\n6410 21050\n93589 44609\n41222 85955\n30147 87950\n97431 40749\n48537 74036\n47186 25854\n39225 55924\n20258 16945\n83319 57412\n20356 54550\n90585 97965\n52076 32143\n93949 24427",
"output": "283685"
},
{
"input": "27 13\n30094 96037\n81142 53995\n98653 82839\n25356 81132\n77842 2012\n88187 81651\n5635 86354\n25453 63263\n61455 12635\n10257 47125\n48214 12029\n21081 92859\n24156 67265",
"output": "588137"
},
{
"input": "1 1\n1 1",
"output": "1"
},
{
"input": "47 10\n1 1\n2 1\n3 1\n4 1\n5 1\n6 1\n7 1\n8 1\n9 1\n10 1",
"output": "9"
},
{
"input": "2 5\n1 1\n2 1\n3 1\n4 1\n5 1",
"output": "2"
},
{
"input": "3 3\n1 1\n2 1\n3 1",
"output": "2"
},
{
"input": "17 6\n1 1\n2 2\n3 3\n4 4\n5 5\n6 6",
"output": "20"
},
{
"input": "7 4\n1 2\n2 3\n3 4\n4 5",
"output": "12"
},
{
"input": "7 4\n1 1\n2 1\n3 1\n4 1",
"output": "3"
},
{
"input": "7 5\n1 1\n2 1\n3 1\n4 1\n5 1",
"output": "3"
},
{
"input": "17 9\n1 1\n2 1\n3 1\n4 1\n5 1\n6 1\n7 1\n8 1\n9 1",
"output": "5"
},
{
"input": "2 2\n1 1\n2 1",
"output": "2"
},
{
"input": "8 7\n1 1\n2 1\n3 1\n4 1\n5 1\n6 1\n7 1",
"output": "4"
},
{
"input": "11 5\n1 1\n2 1\n3 1\n4 1\n5 1",
"output": "5"
},
{
"input": "31 8\n1 1\n2 2\n3 4\n4 8\n5 16\n6 32\n7 64\n8 128",
"output": "254"
},
{
"input": "10 6\n1 1\n2 1\n3 1\n4 1\n5 1\n6 1",
"output": "4"
},
{
"input": "11 10\n1 5\n2 5\n3 5\n4 5\n5 5\n6 5\n7 5\n8 5\n9 5\n10 5",
"output": "25"
},
{
"input": "8 10\n1 1\n2 1\n3 1\n4 1\n5 1\n6 1\n7 1\n8 1\n9 1\n10 1",
"output": "4"
}
] | 296 | 6,144,000 | 0 | 52,407 |
|
512 | Fox And Travelling | [
"dp",
"trees"
] | null | null | Fox Ciel is going to travel to New Foxland during this summer.
New Foxland has *n* attractions that are linked by *m* undirected roads. Two attractions are called adjacent if they are linked by a road. Fox Ciel has *k* days to visit this city and each day she will visit exactly one attraction.
There is one important rule in New Foxland: you can't visit an attraction if it has more than one adjacent attraction that you haven't visited yet.
At the beginning Fox Ciel haven't visited any attraction. During her travelling she may move aribtrarly between attraction. After visiting attraction *a*, she may travel to any attraction *b* satisfying conditions above that hasn't been visited yet, even if it is not reachable from *a* by using the roads (Ciel uses boat for travelling between attractions, so it is possible).
She wants to know how many different travelling plans she can make. Calculate this number modulo 109<=+<=9 for every *k* from 0 to *n* since she hasn't decided for how many days she is visiting New Foxland. | First line contains two integers: *n*, *m* (1<=β€<=*n*<=β€<=100, ), the number of attractions and number of undirected roads.
Then next *m* lines each contain two integers *a**i* and *b**i* (1<=β€<=*a**i*,<=*b**i*<=β€<=*n* and *a**i*<=β <=*b**i*), describing a road. There is no more than one road connecting each pair of attractions. | Output *n*<=+<=1 integer: the number of possible travelling plans modulo 109<=+<=9 for all *k* from 0 to *n*. | [
"3 2\n1 2\n2 3\n",
"4 4\n1 2\n2 3\n3 4\n4 1\n",
"12 11\n2 3\n4 7\n4 5\n5 6\n4 6\n6 12\n5 12\n5 8\n8 9\n10 8\n11 9\n",
"13 0\n"
] | [
"1\n2\n4\n4\n",
"1\n0\n0\n0\n0\n",
"1\n6\n31\n135\n483\n1380\n3060\n5040\n5040\n0\n0\n0\n0\n",
"1\n13\n156\n1716\n17160\n154440\n1235520\n8648640\n51891840\n259459200\n37836791\n113510373\n227020746\n227020746\n"
] | In the first sample test for *k*β=β3 there are 4 travelling plans: {1,β2,β3},β{1,β3,β2},β{3,β1,β2},β{3,β2,β1}.
In the second sample test Ciel can't visit any attraction in the first day, so for *k*β>β0 the answer is 0.
In the third sample test Foxlands look like this: | [
{
"input": "3 2\n1 2\n2 3",
"output": "1\n2\n4\n4"
},
{
"input": "4 4\n1 2\n2 3\n3 4\n4 1",
"output": "1\n0\n0\n0\n0"
},
{
"input": "12 11\n2 3\n4 7\n4 5\n5 6\n4 6\n6 12\n5 12\n5 8\n8 9\n10 8\n11 9",
"output": "1\n6\n31\n135\n483\n1380\n3060\n5040\n5040\n0\n0\n0\n0"
},
{
"input": "13 0",
"output": "1\n13\n156\n1716\n17160\n154440\n1235520\n8648640\n51891840\n259459200\n37836791\n113510373\n227020746\n227020746"
},
{
"input": "1 0",
"output": "1\n1"
},
{
"input": "2 0",
"output": "1\n2\n2"
},
{
"input": "2 1\n1 2",
"output": "1\n2\n2"
},
{
"input": "4 4\n1 2\n2 3\n3 1\n1 4",
"output": "1\n1\n0\n0\n0"
},
{
"input": "10 9\n1 2\n1 3\n1 4\n2 5\n2 6\n3 7\n3 8\n4 9\n4 10",
"output": "1\n6\n30\n126\n456\n1440\n3840\n8640\n17280\n34560\n34560"
},
{
"input": "5 10\n1 2\n2 3\n3 4\n4 5\n5 1\n1 3\n2 4\n3 5\n4 1\n5 2",
"output": "1\n0\n0\n0\n0\n0"
},
{
"input": "100 0",
"output": "1\n100\n9900\n970200\n94109400\n34502319\n277720278\n105705898\n830648433\n419655152\n188618490\n975663956\n834091310\n400034623\n803011895\n59022349\n16899620\n419568071\n824149587\n580265531\n1507588\n120607040\n527956079\n180573793\n904181944\n717827132\n837034423\n940546753\n659912357\n513689281\n471938627\n35703593\n463547899\n521256853\n924208845\n997783230\n855909374\n778199450\n26564909\n647024349\n468484938\n109096028\n436665598\n326604459\n616454001\n521423750\n678305998\n628523568\n311748807\n21..."
},
{
"input": "100 2\n12 34\n12 56",
"output": "1\n99\n9704\n941680\n90458320\n600842488\n346513039\n88126817\n142825254\n372744346\n640812455\n127920061\n952453050\n626691132\n442123857\n302303579\n906937960\n495773343\n501003222\n227553343\n909691654\n49271904\n985878757\n996818267\n125698678\n984367292\n310098640\n691072079\n256138586\n993386986\n577692998\n649307769\n925719562\n98866779\n369987499\n157629902\n768620285\n597655701\n415740627\n581826595\n39990893\n216450750\n339433948\n542198165\n931909567\n624114603\n496806559\n693746271\n944360371\n..."
},
{
"input": "87 14\n6 3\n41 74\n42 60\n13 29\n81 50\n22 31\n2 18\n76 21\n23 14\n82 20\n30 51\n30 55\n28 80\n2 41",
"output": "1\n84\n6976\n572700\n46471400\n726706453\n316070145\n265228551\n650766217\n397694580\n810490016\n588766114\n486939677\n23301479\n69854128\n435879533\n534425387\n176302137\n336389003\n700458175\n694321423\n776580617\n83316821\n704801977\n783786908\n628610450\n159822561\n200235489\n973461472\n97174\n426820671\n312050405\n113809085\n781983585\n206089750\n531282185\n727609686\n762987206\n198914948\n735829661\n849861129\n350151479\n310068089\n364975144\n503290486\n481587910\n403550011\n642896373\n610874464\n795..."
},
{
"input": "11 9\n3 6\n6 1\n10 9\n9 8\n5 2\n7 9\n3 2\n11 7\n7 2",
"output": "1\n6\n31\n138\n532\n1792\n5320\n14016\n33200\n73040\n146080\n146080"
},
{
"input": "39 67\n21 38\n34 3\n28 10\n30 32\n4 12\n36 32\n22 30\n14 11\n25 33\n6 9\n21 10\n35 20\n34 21\n2 35\n12 13\n8 10\n1 17\n31 14\n31 16\n9 22\n12 25\n22 17\n1 14\n35 18\n33 21\n3 21\n30 5\n20 17\n34 22\n19 23\n18 3\n22 12\n38 27\n18 32\n13 11\n4 7\n32 2\n33 30\n4 28\n20 31\n39 37\n7 30\n2 34\n10 3\n15 17\n2 1\n37 31\n14 19\n24 30\n12 37\n8 2\n8 35\n38 25\n25 20\n27 15\n21 9\n22 25\n12 27\n33 6\n37 13\n37 10\n7 36\n7 2\n29 21\n1 37\n13 33\n12 30",
"output": "1\n7\n43\n228\n1020\n3720\n10440\n20160\n20160\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0"
},
{
"input": "15 16\n8 12\n9 3\n4 10\n4 12\n5 10\n14 11\n7 13\n14 10\n4 8\n3 8\n6 14\n9 11\n11 3\n10 2\n15 5\n4 9",
"output": "1\n6\n31\n135\n480\n1320\n2520\n2520\n0\n0\n0\n0\n0\n0\n0\n0"
},
{
"input": "39 5\n4 26\n16 32\n2 36\n38 30\n18 35",
"output": "1\n39\n1482\n54834\n1974024\n69090840\n349088542\n519921787\n637497040\n762408069\n872241872\n295014063\n260393692\n30629621\n796370146\n909253479\n822083307\n907915899\n974149607\n457141567\n142831259\n713793903\n848290146\n420932356\n734917642\n23764531\n332703434\n325144606\n901735245\n919087614\n190876059\n717884522\n743076131\n201532872\n209197223\n45986106\n183944424\n551833272\n103666535\n103666535"
},
{
"input": "18 73\n15 9\n8 17\n17 18\n2 17\n9 17\n17 15\n5 2\n15 8\n2 7\n8 2\n10 12\n7 11\n16 1\n18 7\n11 18\n2 13\n16 3\n12 1\n13 5\n8 6\n7 8\n15 1\n17 16\n9 1\n16 12\n3 13\n16 4\n6 14\n18 16\n12 15\n6 2\n9 3\n4 10\n3 4\n3 1\n6 7\n16 5\n15 13\n13 8\n1 6\n2 3\n16 10\n1 8\n18 3\n3 7\n12 11\n15 4\n11 5\n16 9\n12 5\n18 14\n6 13\n9 11\n18 9\n6 4\n8 11\n1 5\n8 4\n12 9\n3 11\n12 7\n4 18\n4 11\n4 17\n18 10\n6 18\n9 14\n13 12\n8 9\n3 14\n8 12\n13 9\n13 11",
"output": "1\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0"
},
{
"input": "46 59\n37 41\n9 28\n16 3\n3 45\n4 24\n14 3\n31 10\n39 29\n44 22\n21 31\n36 17\n8 44\n28 25\n4 40\n21 3\n31 20\n20 42\n34 25\n28 24\n25 36\n32 34\n45 10\n33 15\n17 37\n27 21\n20 33\n12 40\n38 15\n26 10\n12 28\n5 2\n22 19\n6 17\n39 26\n28 5\n33 44\n23 19\n17 33\n3 18\n28 11\n26 15\n1 8\n34 12\n21 38\n14 27\n40 1\n36 24\n21 5\n17 16\n6 27\n45 24\n37 36\n30 37\n41 9\n46 6\n46 35\n46 40\n14 15\n11 7",
"output": "1\n11\n113\n1081\n9598\n78770\n594450\n4097730\n25576320\n142853760\n702475200\n970475182\n418284710\n540511748\n486431514\n486431514\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0"
},
{
"input": "46 39\n5 1\n20 10\n15 12\n23 39\n5 46\n7 20\n10 15\n14 13\n10 29\n4 9\n24 11\n23 4\n9 17\n45 35\n14 41\n11 36\n37 45\n26 43\n23 30\n9 24\n40 8\n18 42\n27 43\n26 1\n10 44\n13 2\n40 28\n41 22\n34 8\n30 45\n18 31\n30 39\n27 13\n16 8\n15 16\n46 39\n33 26\n46 34\n45 6",
"output": "1\n21\n426\n8340\n157418\n2861600\n50041676\n840802388\n556159899\n447731031\n742162112\n541656432\n665855465\n213762995\n551018805\n487408985\n480483467\n499783200\n137325023\n286243386\n783547189\n757667150\n782491787\n35652955\n936552213\n909332468\n24025205\n533542820\n606700069\n265469096\n581125006\n211502771\n232630734\n314473517\n840164188\n850530410\n52488472\n420469406\n10142705\n373315703\n207418995\n617272390\n378994942\n378994942\n0\n0\n0"
},
{
"input": "94 4\n35 64\n49 54\n91 49\n72 1",
"output": "1\n93\n8558\n779146\n70173376\n251459706\n799378730\n419325370\n771116412\n660012486\n653197338\n143771116\n223815061\n617837913\n980113090\n357967627\n346369250\n103250856\n434035711\n781983878\n703509953\n999549027\n693798803\n823947146\n560177124\n287657333\n890709029\n363526123\n51575057\n904755963\n359677149\n152822293\n770387110\n318964236\n199684960\n67368257\n892160696\n121599305\n626527417\n635357834\n85288535\n917195751\n503733974\n812146618\n700506875\n514770166\n226794059\n26697633\n581019188\n..."
},
{
"input": "22 17\n2 4\n4 1\n19 10\n22 16\n14 9\n9 15\n15 3\n9 10\n14 3\n7 8\n10 11\n14 12\n16 10\n3 6\n12 20\n10 22\n5 13",
"output": "1\n13\n159\n1822\n19460\n192480\n1749120\n14459760\n107412480\n705801600\n18895964\n279814229\n804082534\n21399620\n891452085\n891452085\n0\n0\n0\n0\n0\n0\n0"
},
{
"input": "39 38\n7 14\n37 7\n31 37\n30 31\n28 30\n27 28\n4 27\n29 4\n13 29\n1 13\n21 1\n17 21\n9 17\n20 9\n39 20\n32 39\n26 32\n25 26\n10 25\n5 10\n24 5\n16 24\n35 16\n18 35\n23 18\n22 23\n38 22\n3 38\n8 3\n19 8\n34 19\n36 34\n33 36\n15 33\n6 15\n12 6\n11 12\n2 11",
"output": "1\n2\n4\n8\n16\n32\n64\n128\n256\n512\n1024\n2048\n4096\n8192\n16384\n32768\n65536\n131072\n262144\n524288\n1048576\n2097152\n4194304\n8388608\n16777216\n33554432\n67108864\n134217728\n268435456\n536870912\n73741815\n147483630\n294967260\n589934520\n179869031\n359738062\n719476124\n438952239\n877904478\n877904478"
},
{
"input": "59 58\n5 1\n30 1\n26 1\n18 30\n16 30\n51 5\n17 18\n55 30\n11 18\n42 26\n56 51\n43 55\n14 55\n40 43\n15 14\n23 55\n25 43\n13 15\n41 40\n48 15\n6 13\n4 23\n22 23\n50 25\n20 50\n52 22\n12 50\n21 48\n53 22\n10 20\n34 21\n57 21\n46 10\n58 57\n7 58\n27 34\n31 10\n45 57\n3 57\n39 46\n2 31\n8 7\n54 7\n47 3\n44 45\n29 47\n38 54\n19 29\n37 29\n9 44\n36 54\n35 36\n24 29\n28 36\n49 36\n32 9\n59 24\n33 49",
"output": "1\n23\n516\n11292\n241023\n5016998\n101818269\n14061402\n817490396\n633882406\n285001086\n183039112\n338612173\n792374071\n570319663\n91353477\n742936146\n59684303\n537267253\n779877440\n842744292\n767853666\n902018306\n839151657\n439548607\n271764295\n669160207\n459191311\n513622274\n127447115\n128981623\n81460327\n630746939\n777700007\n531624847\n393938348\n612659345\n274750631\n223423576\n151550052\n358559376\n462650502\n668983593\n834839016\n276856191\n569766603\n710550568\n420747346\n222118690\n199646..."
},
{
"input": "39 38\n28 9\n36 28\n35 36\n3 36\n32 3\n29 32\n5 35\n8 3\n38 36\n21 8\n2 32\n25 29\n7 35\n12 32\n1 28\n24 28\n10 7\n31 32\n27 25\n30 29\n23 25\n34 36\n18 30\n20 23\n39 21\n15 28\n22 21\n13 15\n14 34\n17 35\n37 20\n26 27\n11 20\n19 17\n6 35\n33 20\n4 26\n16 26",
"output": "1\n21\n425\n8284\n155414\n2804386\n48636098\n810031976\n944606932\n294597738\n928529900\n180377354\n963153140\n68785234\n189448879\n775885272\n732622867\n655693824\n661296430\n405881220\n513811982\n13768630\n953745260\n927622528\n616718217\n340614776\n363282265\n184687710\n120603613\n651360302\n716491054\n830663411\n132215301\n858416707\n948092327\n830807545\n808714833\n617429657\n234859305\n234859305"
},
{
"input": "59 58\n41 49\n19 41\n48 19\n36 48\n7 36\n54 7\n44 54\n22 44\n6 22\n14 6\n45 14\n42 45\n24 42\n2 24\n27 2\n51 27\n57 51\n59 57\n50 59\n9 50\n37 9\n43 37\n53 43\n52 53\n5 52\n39 5\n35 39\n29 35\n33 29\n34 33\n17 34\n47 17\n18 47\n8 18\n31 8\n12 31\n21 12\n13 21\n26 13\n46 26\n58 46\n3 58\n56 3\n10 56\n4 10\n20 4\n16 20\n25 16\n38 25\n32 38\n1 32\n23 1\n40 23\n30 40\n11 30\n28 11\n55 28\n15 55",
"output": "1\n2\n4\n8\n16\n32\n64\n128\n256\n512\n1024\n2048\n4096\n8192\n16384\n32768\n65536\n131072\n262144\n524288\n1048576\n2097152\n4194304\n8388608\n16777216\n33554432\n67108864\n134217728\n268435456\n536870912\n73741815\n147483630\n294967260\n589934520\n179869031\n359738062\n719476124\n438952239\n877904478\n755808947\n511617885\n23235761\n46471522\n92943044\n185886088\n371772176\n743544352\n487088695\n974177390\n948354771\n896709533\n793419057\n586838105\n173676201\n347352402\n694704804\n389409599\n778819198\n..."
},
{
"input": "15 14\n10 8\n6 8\n2 8\n1 8\n13 8\n15 8\n4 8\n11 8\n14 8\n3 8\n7 8\n5 8\n9 8\n12 8",
"output": "1\n14\n182\n2184\n24024\n240240\n2162160\n17297280\n121080960\n726485760\n632428773\n529715074\n589145213\n178290417\n356580834\n356580834"
},
{
"input": "39 38\n1 38\n31 38\n16 38\n35 38\n13 38\n15 38\n4 38\n23 38\n34 38\n6 38\n10 38\n36 38\n21 38\n39 38\n17 38\n22 38\n2 38\n9 38\n33 38\n24 38\n20 38\n29 38\n14 38\n32 38\n26 38\n7 38\n3 38\n12 38\n27 38\n28 38\n5 38\n30 38\n19 38\n37 38\n8 38\n11 38\n18 38\n25 38",
"output": "1\n38\n1406\n50616\n1771560\n60233040\n987690311\n606089673\n788779701\n663390823\n238333696\n673343434\n180272556\n687086420\n177160347\n251848292\n792510671\n435234609\n139926708\n798534142\n172148563\n98674107\n677459810\n839356870\n590352942\n264941116\n444234481\n330813727\n638950970\n389509646\n505586787\n44694260\n312859820\n877158911\n385794519\n543178067\n629534192\n259068375\n518136750\n518136750"
},
{
"input": "18 17\n12 13\n6 13\n10 13\n7 13\n3 13\n11 13\n1 13\n14 13\n18 13\n17 13\n5 13\n8 13\n4 13\n2 13\n15 13\n16 13\n9 13",
"output": "1\n17\n272\n4080\n57120\n742560\n8910720\n98017920\n980179200\n821612728\n572901770\n10312354\n61874124\n309370620\n237482471\n712447413\n424894817\n849789634\n849789634"
},
{
"input": "46 45\n13 15\n36 15\n40 15\n33 15\n45 15\n32 15\n11 15\n10 15\n1 15\n46 15\n2 15\n7 15\n43 15\n26 15\n3 15\n6 15\n39 15\n44 15\n38 15\n12 15\n23 15\n37 15\n21 15\n19 15\n25 15\n16 15\n4 15\n31 15\n34 15\n35 15\n22 15\n18 15\n9 15\n14 15\n20 15\n8 15\n5 15\n27 15\n17 15\n28 15\n42 15\n29 15\n30 15\n24 15\n41 15",
"output": "1\n45\n1980\n85140\n3575880\n146611080\n864443155\n713282748\n104744181\n875534670\n519247841\n173674273\n904925237\n862532560\n601041677\n632291825\n968754588\n93882800\n628718382\n975396170\n360300195\n7504794\n180115056\n142646252\n138217517\n902567839\n51356618\n975775742\n563963203\n587374370\n397989839\n969847540\n577865443\n512250696\n147008298\n617091269\n170912636\n538213715\n305709684\n139967770\n839806620\n199033064\n796132256\n388396750\n776793500\n553586991\n553586991"
},
{
"input": "42 42\n22 27\n21 27\n37 27\n30 27\n40 27\n38 27\n31 27\n5 27\n2 27\n12 27\n26 27\n33 27\n6 27\n32 27\n28 27\n35 27\n13 27\n29 27\n1 27\n41 27\n17 27\n34 27\n23 27\n14 27\n15 27\n36 27\n7 27\n25 27\n9 27\n19 27\n18 27\n20 27\n8 27\n39 27\n16 27\n10 27\n3 27\n24 27\n11 27\n42 27\n4 27\n4 42",
"output": "1\n39\n1482\n54834\n1974024\n69090840\n349088542\n519921787\n637497040\n762408069\n872241872\n295014063\n260393692\n30629621\n796370146\n909253479\n822083307\n907915899\n974149607\n457141567\n142831259\n713793903\n848290146\n420932356\n734917642\n23764531\n332703434\n325144606\n901735245\n919087614\n190876059\n717884522\n743076131\n201532872\n209197223\n45986106\n183944424\n551833272\n103666535\n103666535\n0\n0\n0"
},
{
"input": "45 45\n24 28\n27 24\n1 27\n12 1\n18 12\n22 18\n2 22\n5 2\n38 5\n39 38\n3 39\n19 3\n11 19\n31 11\n9 31\n8 9\n23 8\n21 23\n15 21\n44 15\n17 44\n7 17\n13 7\n30 13\n42 30\n36 42\n4 36\n45 4\n10 45\n32 10\n33 32\n34 33\n29 34\n43 29\n25 43\n40 25\n14 40\n41 14\n16 41\n35 16\n6 35\n26 6\n20 28\n37 28\n37 20",
"output": "1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n0\n0\n0"
},
{
"input": "46 45\n16 27\n19 16\n17 19\n13 17\n36 13\n21 36\n45 21\n8 45\n22 8\n40 22\n26 40\n33 26\n34 33\n23 34\n42 23\n44 42\n3 44\n37 3\n39 37\n10 39\n11 10\n28 11\n35 28\n18 35\n5 18\n24 5\n9 24\n25 9\n29 25\n2 29\n31 2\n20 31\n7 20\n30 7\n32 30\n12 32\n6 12\n46 6\n15 46\n43 15\n38 43\n41 38\n4 41\n14 4\n1 14",
"output": "1\n2\n4\n8\n16\n32\n64\n128\n256\n512\n1024\n2048\n4096\n8192\n16384\n32768\n65536\n131072\n262144\n524288\n1048576\n2097152\n4194304\n8388608\n16777216\n33554432\n67108864\n134217728\n268435456\n536870912\n73741815\n147483630\n294967260\n589934520\n179869031\n359738062\n719476124\n438952239\n877904478\n755808947\n511617885\n23235761\n46471522\n92943044\n185886088\n371772176\n371772176"
},
{
"input": "74 73\n73 43\n70 43\n1 43\n49 43\n20 43\n22 43\n7 43\n57 43\n63 43\n13 43\n42 43\n23 43\n59 43\n52 43\n18 43\n15 43\n54 43\n50 43\n48 43\n36 43\n6 43\n61 43\n31 43\n66 43\n37 43\n28 43\n65 43\n14 43\n17 43\n8 43\n60 43\n55 43\n71 43\n9 43\n19 43\n58 43\n11 43\n53 43\n64 43\n5 43\n10 43\n67 43\n51 43\n4 43\n35 43\n2 43\n16 43\n44 43\n72 43\n46 43\n47 43\n32 43\n25 43\n69 43\n41 43\n33 43\n27 43\n39 43\n34 43\n24 43\n21 43\n45 43\n3 43\n62 43\n74 43\n29 43\n26 43\n30 43\n40 43\n38 43\n56 43\n68 43\n12 43",
"output": "1\n73\n5256\n373176\n26122320\n802440071\n565924342\n916930581\n517417806\n632157093\n458053592\n857376044\n157314251\n596169230\n770153485\n439055210\n465201955\n516511201\n924627004\n854484770\n142177166\n535389735\n840265977\n853564449\n678222072\n232881231\n178298989\n380052411\n482410753\n708483696\n173282345\n451140772\n947912262\n864402400\n576095694\n467731868\n773810831\n631000495\n716017622\n60616545\n60962512\n11762878\n376412096\n668774877\n63246130\n834137761\n355857101\n608141646\n811682661\n..."
},
{
"input": "22 21\n1 14\n20 1\n8 20\n5 20\n2 20\n16 1\n9 5\n21 2\n3 16\n19 21\n17 8\n7 8\n4 2\n18 14\n15 17\n6 16\n12 21\n11 2\n22 9\n13 11\n10 13",
"output": "1\n10\n94\n834\n7007\n55860\n422815\n3036565\n20652380\n132614160\n800643900\n521108864\n727072393\n847932174\n47535428\n244196721\n893595849\n73275447\n428168034\n676624531\n353249053\n706498106\n706498106"
},
{
"input": "46 45\n26 5\n33 26\n37 33\n44 37\n9 37\n40 44\n7 9\n39 40\n46 39\n45 39\n41 46\n32 41\n23 32\n21 23\n20 21\n34 20\n30 34\n18 30\n29 18\n36 29\n24 36\n28 36\n4 24\n22 4\n38 4\n27 22\n17 38\n11 17\n16 11\n6 11\n19 6\n12 6\n25 19\n3 12\n8 3\n31 3\n14 8\n15 31\n35 15\n10 35\n2 10\n42 2\n1 2\n43 1\n13 1",
"output": "1\n11\n115\n1143\n10792\n96628\n818302\n6532404\n48959810\n342959330\n234396662\n472822633\n856514624\n98651432\n192761141\n636669608\n855658653\n12337986\n582650181\n269698369\n476276845\n629508581\n591981146\n818492896\n194569467\n979693754\n450466973\n49176348\n255386210\n873786214\n906404921\n298267461\n631573671\n280502764\n927325964\n136762366\n857168053\n618075447\n359198421\n921128794\n464830913\n651546886\n86658148\n956880690\n913761371\n827522733\n827522733"
},
{
"input": "40 39\n5 9\n14 9\n8 9\n25 9\n3 9\n30 9\n4 9\n11 9\n31 9\n26 9\n16 9\n37 9\n12 9\n1 9\n2 9\n22 9\n13 9\n32 9\n19 9\n17 9\n29 9\n27 9\n35 9\n24 9\n21 9\n18 9\n23 9\n33 9\n34 9\n7 9\n6 9\n15 9\n28 9\n20 9\n39 9\n40 9\n38 9\n36 9\n10 9",
"output": "1\n39\n1482\n54834\n1974024\n69090840\n349088542\n519921787\n637497040\n762408069\n872241872\n295014063\n260393692\n30629621\n796370146\n909253479\n822083307\n907915899\n974149607\n457141567\n142831259\n713793903\n848290146\n420932356\n734917642\n23764531\n332703434\n325144606\n901735245\n919087614\n190876059\n717884522\n743076131\n201532872\n209197223\n45986106\n183944424\n551833272\n103666535\n207333070\n207333070"
},
{
"input": "69 68\n23 50\n49 50\n69 50\n4 50\n28 50\n2 50\n42 4\n62 28\n9 28\n25 42\n12 9\n54 42\n10 62\n67 42\n65 42\n53 9\n47 67\n29 54\n41 12\n14 29\n17 14\n15 29\n55 67\n37 53\n51 29\n44 41\n11 51\n64 55\n21 11\n35 15\n13 21\n66 55\n52 37\n57 44\n33 66\n60 64\n27 66\n19 21\n34 66\n48 60\n45 48\n31 27\n22 27\n61 19\n1 48\n59 19\n58 1\n18 45\n68 22\n46 58\n20 59\n16 20\n26 20\n39 59\n40 68\n38 20\n24 39\n5 39\n6 39\n30 39\n3 26\n43 6\n7 39\n36 30\n32 36\n63 36\n56 63\n8 32",
"output": "1\n29\n824\n22936\n625301\n16693622\n436314973\n161554721\n383029354\n542175747\n647805613\n572590515\n918671512\n937956462\n609873167\n705047227\n344964089\n492706709\n472326660\n576306578\n556147428\n889649554\n506728503\n652890369\n623100530\n861847867\n500467182\n94265816\n389888700\n567995832\n575036705\n973089590\n53275431\n327870782\n414502149\n8286559\n20451677\n920874011\n49213700\n879350138\n131928670\n72777869\n459508459\n909914824\n146421978\n633690789\n132239860\n835364780\n937692668\n23187593..."
},
{
"input": "17 16\n4 8\n13 8\n12 8\n9 8\n2 8\n17 8\n10 8\n14 8\n11 8\n16 8\n7 8\n6 8\n15 8\n5 8\n1 8\n3 8",
"output": "1\n16\n240\n3360\n43680\n524160\n5765760\n57657600\n518918400\n151347164\n59430139\n356580834\n782904161\n131616617\n394849851\n789699702\n579399395\n579399395"
},
{
"input": "41 40\n9 22\n8 9\n3 9\n28 9\n35 3\n39 22\n40 35\n14 3\n25 8\n6 8\n36 25\n5 22\n34 35\n21 5\n33 21\n12 35\n27 6\n7 39\n20 28\n10 27\n13 14\n31 12\n32 39\n2 36\n18 36\n15 28\n16 34\n26 8\n4 25\n23 12\n30 31\n29 16\n17 6\n38 21\n11 2\n37 33\n1 33\n19 6\n41 31\n24 18",
"output": "1\n20\n385\n7134\n127252\n2184954\n36109212\n574256586\n785817104\n266120511\n163758452\n278863753\n199676489\n965719182\n842948552\n832992662\n555090591\n132658387\n646298727\n611119931\n360951449\n333722212\n813273262\n98796257\n674407660\n310960237\n733522450\n334454742\n907847707\n54357002\n553243408\n825009522\n812126365\n779430185\n933111878\n491489880\n448152476\n704763274\n842007507\n684015005\n368030001\n368030001"
},
{
"input": "67 67\n58 26\n10 26\n36 26\n8 26\n31 26\n48 26\n41 26\n35 26\n30 26\n51 26\n64 26\n38 26\n65 26\n46 26\n42 26\n2 26\n66 26\n29 26\n1 26\n16 26\n3 26\n14 26\n23 26\n40 26\n59 26\n47 26\n12 26\n21 26\n44 26\n28 26\n45 26\n24 26\n50 26\n43 26\n62 26\n55 26\n25 26\n7 26\n53 26\n61 26\n33 26\n22 26\n11 26\n27 26\n4 26\n54 26\n32 26\n52 26\n19 26\n9 26\n18 26\n49 26\n6 26\n34 26\n67 26\n63 26\n37 26\n56 26\n57 26\n13 26\n60 26\n17 26\n5 26\n15 26\n20 26\n39 26\n39 20",
"output": "1\n64\n4032\n249984\n15249024\n914941440\n981544483\n929579510\n986031602\n217769217\n977306836\n774568676\n52139459\n711251850\n273844026\n692201183\n917857670\n57167764\n686884890\n596704661\n851709511\n475218151\n434380313\n243972984\n2892254\n115690160\n511916204\n452815581\n754176353\n150348465\n262196230\n914671748\n184167414\n893357203\n694073050\n822191320\n843548073\n619345837\n722337455\n780773668\n519341529\n464196588\n676521434\n883471422\n552899700\n57993901\n101884110\n833913971\n176537381\n8..."
},
{
"input": "71 71\n47 64\n45 47\n29 45\n61 29\n3 61\n53 3\n40 53\n65 40\n34 65\n33 34\n31 33\n41 31\n6 41\n38 6\n5 38\n70 5\n7 70\n30 7\n17 30\n55 17\n27 55\n62 27\n44 62\n18 44\n26 18\n15 26\n13 15\n51 13\n10 51\n12 10\n36 12\n24 36\n43 24\n63 43\n67 63\n60 67\n22 60\n39 22\n58 39\n14 58\n32 14\n37 32\n69 37\n68 69\n9 68\n16 9\n20 16\n4 20\n52 4\n42 52\n25 42\n57 25\n49 57\n19 49\n59 19\n46 59\n56 46\n23 56\n2 23\n11 2\n1 11\n48 1\n35 48\n8 35\n66 8\n28 66\n21 28\n50 21\n71 64\n54 64\n54 71",
"output": "1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n0\n0\n0"
},
{
"input": "17 16\n6 10\n13 10\n15 13\n9 10\n12 6\n3 12\n17 13\n14 3\n1 17\n2 17\n16 2\n7 1\n4 1\n5 4\n8 4\n11 7",
"output": "1\n7\n45\n267\n1463\n7380\n34115\n143885\n551775\n1919540\n6046950\n17224375\n44400650\n104039250\n223316450\n446632900\n893265800\n893265800"
},
{
"input": "45 44\n38 9\n4 38\n40 4\n3 40\n31 3\n1 31\n24 1\n27 24\n35 27\n23 35\n39 23\n14 39\n6 14\n13 6\n16 13\n37 16\n36 37\n17 36\n5 17\n41 5\n45 41\n30 45\n29 30\n32 29\n19 32\n26 19\n10 26\n34 10\n15 34\n44 15\n22 44\n12 22\n33 12\n11 33\n28 11\n42 28\n21 42\n8 21\n2 8\n7 2\n20 7\n43 20\n25 43\n18 25",
"output": "1\n2\n4\n8\n16\n32\n64\n128\n256\n512\n1024\n2048\n4096\n8192\n16384\n32768\n65536\n131072\n262144\n524288\n1048576\n2097152\n4194304\n8388608\n16777216\n33554432\n67108864\n134217728\n268435456\n536870912\n73741815\n147483630\n294967260\n589934520\n179869031\n359738062\n719476124\n438952239\n877904478\n755808947\n511617885\n23235761\n46471522\n92943044\n185886088\n185886088"
},
{
"input": "69 68\n38 57\n41 38\n18 41\n59 18\n23 59\n8 23\n50 8\n42 50\n4 42\n49 4\n54 49\n69 54\n45 69\n39 45\n26 39\n30 26\n35 30\n27 35\n61 27\n68 61\n22 68\n1 22\n12 1\n29 12\n47 29\n25 47\n6 25\n34 6\n5 34\n10 5\n44 10\n62 44\n11 62\n52 11\n7 52\n2 7\n65 2\n33 65\n17 33\n21 17\n9 21\n24 9\n3 24\n48 3\n14 48\n13 14\n20 13\n43 20\n64 43\n58 64\n63 58\n19 63\n15 19\n60 15\n28 60\n51 28\n16 51\n31 16\n37 31\n53 37\n40 53\n36 40\n56 36\n55 56\n66 55\n67 66\n46 67\n32 46",
"output": "1\n2\n4\n8\n16\n32\n64\n128\n256\n512\n1024\n2048\n4096\n8192\n16384\n32768\n65536\n131072\n262144\n524288\n1048576\n2097152\n4194304\n8388608\n16777216\n33554432\n67108864\n134217728\n268435456\n536870912\n73741815\n147483630\n294967260\n589934520\n179869031\n359738062\n719476124\n438952239\n877904478\n755808947\n511617885\n23235761\n46471522\n92943044\n185886088\n371772176\n743544352\n487088695\n974177390\n948354771\n896709533\n793419057\n586838105\n173676201\n347352402\n694704804\n389409599\n778819198\n..."
},
{
"input": "55 54\n51 20\n55 51\n32 55\n25 32\n42 25\n19 42\n49 19\n50 49\n1 50\n8 1\n24 8\n39 24\n14 39\n46 14\n43 46\n5 43\n53 5\n17 53\n16 17\n13 16\n54 13\n44 54\n6 44\n38 6\n10 38\n11 10\n23 11\n7 23\n15 7\n52 15\n35 52\n33 35\n12 33\n22 12\n9 22\n30 9\n37 30\n36 37\n4 36\n34 4\n45 34\n31 45\n26 31\n40 26\n41 40\n2 41\n18 2\n27 18\n28 27\n48 28\n29 48\n21 29\n47 21\n3 47",
"output": "1\n2\n4\n8\n16\n32\n64\n128\n256\n512\n1024\n2048\n4096\n8192\n16384\n32768\n65536\n131072\n262144\n524288\n1048576\n2097152\n4194304\n8388608\n16777216\n33554432\n67108864\n134217728\n268435456\n536870912\n73741815\n147483630\n294967260\n589934520\n179869031\n359738062\n719476124\n438952239\n877904478\n755808947\n511617885\n23235761\n46471522\n92943044\n185886088\n371772176\n743544352\n487088695\n974177390\n948354771\n896709533\n793419057\n586838105\n173676201\n347352402\n347352402"
},
{
"input": "65 65\n22 45\n29 22\n10 29\n30 10\n28 30\n33 28\n37 33\n21 37\n12 21\n61 12\n60 61\n48 60\n26 48\n6 26\n54 6\n11 54\n5 11\n18 5\n25 18\n53 25\n51 53\n2 51\n47 2\n3 47\n24 3\n42 24\n55 42\n35 55\n1 35\n56 1\n39 56\n49 39\n52 49\n44 52\n13 44\n17 13\n16 17\n31 16\n32 31\n58 32\n46 58\n38 46\n34 38\n43 34\n40 43\n23 40\n64 23\n57 64\n36 57\n20 36\n63 20\n59 63\n65 59\n14 65\n15 14\n8 15\n27 8\n41 27\n62 41\n19 62\n7 19\n9 7\n4 45\n50 45\n50 4",
"output": "1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n0\n0\n0"
},
{
"input": "18 18\n1 15\n17 15\n6 15\n8 6\n18 17\n16 8\n2 17\n3 8\n5 8\n4 2\n14 1\n12 2\n7 1\n13 3\n9 1\n11 15\n10 15\n10 11",
"output": "1\n9\n73\n530\n3422\n19540\n98322\n436002\n1711584\n5977440\n18536112\n50572368\n119617344\n235243008\n363242880\n363242880\n0\n0\n0"
},
{
"input": "31 30\n26 4\n10 4\n25 26\n22 4\n5 25\n1 22\n30 25\n27 4\n17 10\n23 1\n3 23\n16 17\n18 22\n6 1\n9 26\n28 1\n29 16\n24 5\n11 16\n19 24\n31 4\n7 25\n21 11\n15 3\n12 15\n8 7\n13 16\n14 29\n2 1\n20 10",
"output": "1\n15\n215\n2942\n38393\n477250\n5643140\n63369445\n674570290\n793077276\n566127314\n774493757\n724076274\n193911614\n448938849\n991892401\n284241326\n314349704\n707657555\n444495354\n392327600\n369751381\n217331280\n437641678\n458894187\n95316270\n867327254\n939454921\n738820706\n477641403\n955282806\n955282806"
},
{
"input": "55 54\n20 52\n22 52\n27 52\n24 52\n43 52\n48 52\n36 52\n46 52\n53 52\n17 52\n41 52\n51 52\n37 52\n38 52\n40 52\n35 52\n55 52\n4 52\n42 52\n21 52\n39 52\n44 52\n15 52\n25 52\n28 52\n19 52\n54 52\n12 52\n14 52\n34 52\n9 52\n31 52\n50 52\n13 52\n49 52\n18 52\n29 52\n30 52\n16 52\n6 52\n3 52\n5 52\n47 52\n2 52\n10 52\n23 52\n32 52\n26 52\n7 52\n1 52\n33 52\n45 52\n8 52\n11 52",
"output": "1\n54\n2862\n148824\n7590024\n379501200\n595558638\n586814372\n580275241\n692660852\n169738061\n468474621\n144408523\n65157912\n671474374\n858974726\n500014017\n532475\n19701575\n709256700\n823984284\n15465404\n510358332\n331466480\n275460790\n263823628\n650885149\n224784010\n69168216\n798373607\n959340004\n24159889\n555677447\n224903726\n722978210\n459564074\n731717334\n170911895\n905502197\n488035026\n320525327\n487354542\n335608992\n27307868\n300386548\n3865453\n34789077\n278312616\n948188303\n689129773..."
},
{
"input": "3 2\n3 2\n1 2",
"output": "1\n2\n4\n4"
},
{
"input": "32 31\n5 30\n29 30\n21 30\n17 30\n24 30\n12 30\n2 30\n20 30\n19 30\n3 30\n13 30\n16 30\n26 30\n15 30\n11 30\n1 30\n8 30\n9 30\n18 30\n14 30\n28 30\n10 30\n4 30\n31 30\n23 30\n27 30\n32 30\n22 30\n25 30\n6 30\n7 30",
"output": "1\n31\n930\n26970\n755160\n20389320\n530122320\n253057883\n73389138\n687950165\n134903495\n832973377\n659467396\n529880416\n537847407\n143405838\n294493390\n417400814\n843611351\n966947473\n603369577\n637065293\n370652876\n335875857\n687006838\n809047830\n854286944\n271434684\n85738727\n257216181\n514432362\n28864715\n28864715"
},
{
"input": "51 51\n47 42\n36 42\n22 42\n19 22\n33 47\n32 47\n23 22\n40 22\n16 40\n49 40\n10 16\n2 40\n51 2\n12 16\n17 2\n48 51\n13 48\n20 12\n5 17\n26 48\n38 48\n50 38\n14 50\n11 50\n6 11\n44 38\n24 6\n28 44\n18 28\n37 24\n46 37\n25 18\n39 37\n31 46\n30 39\n7 30\n41 31\n8 30\n21 31\n1 7\n3 7\n27 41\n35 8\n15 3\n45 35\n34 35\n43 34\n29 15\n9 42\n4 42\n4 9",
"output": "1\n19\n348\n6142\n104420\n1709415\n26937580\n408494940\n959571531\n625735279\n414720144\n139482523\n324919873\n451723534\n17139509\n412011044\n767710164\n494287451\n997195961\n534543812\n127250510\n429319674\n638780430\n41794649\n336581900\n793883501\n520202276\n394485319\n281545317\n285697654\n412819512\n49791506\n911942868\n180776304\n855478164\n545059033\n991677358\n202031887\n871580844\n985301168\n862820490\n148074236\n811438573\n879222703\n96102798\n663048087\n692939551\n304415801\n304415801\n0\n0\n0\n..."
}
] | 30 | 0 | 0 | 52,523 |
|
68 | Contact | [
"geometry"
] | E. Contact | 3 | 256 | Little Petya is preparing for the first contact with aliens. He knows that alien spaceships have shapes of non-degenerate triangles and there will be exactly 4 ships. Landing platform for a ship can be made of 3 special columns located at some points of a Cartesian plane such that these 3 points form a triangle equal to the ship with respect to rotations, translations (parallel shifts along some vector) and reflections (symmetries along the edges). The ships can overlap after the landing.
Each column can be used to land more than one ship, for example, if there are two equal ships, we don't need to build 6 columns to land both ships, 3 will be enough. Petya wants to know what minimum number of columns will be enough to land all ships. | Each of 4 lines will contain 6 integers *x*1 *y*1 *x*2 *y*2 *x*3 *y*3 (0<=β€<=*x*1,<=*y*1,<=*x*2,<=*y*2,<=*x*3,<=*y*3<=β€<=20), representing 3 points that describe the shape of each of 4 ships. It is guaranteed that 3 points in each line will represent a non-degenerate triangle. | First line should contain minimum number of columns enough to land all spaceships. | [
"0 0 1 0 1 2\n0 0 0 2 2 2\n0 0 3 0 1 2\n0 0 3 0 2 2\n",
"0 0 0 1 1 1\n0 0 0 2 2 2\n0 0 0 5 5 5\n0 0 0 17 17 17\n"
] | [
"4\n",
"9\n"
] | In the first test case columns can be put in these points: (0,β0),β(1,β0),β(3,β0),β(1,β2). Note that the second ship can land using last 3 columns.
In the second test case following points can be chosen: (0,β0),β(0,β1),β(1,β0),β(0,β2),β(2,β0),β(0,β5),β(5,β0),β(0,β17),β(17,β0). It is impossible to use less than 9 columns. | [] | 92 | 0 | 0 | 52,528 |
887 | Row of Models | [
"greedy",
"sortings"
] | null | null | During the final part of fashion show all models come to the stage and stay in one row and fashion designer stays to right to model on the right. During the rehearsal, Izabella noticed, that row isn't nice, but she can't figure out how to fix it.
Like many other creative people, Izabella has a specific sense of beauty. Evaluating beauty of row of models Izabella looks at heights of models. She thinks that row is nice if for each model distance to nearest model with less height (model or fashion designer) to the right of her doesn't exceed *k* (distance between adjacent people equals 1, the distance between people with exactly one man between them equals 2, etc).
She wants to make row nice, but fashion designer has his own sense of beauty, so she can at most one time select two models from the row and swap their positions if the left model from this pair is higher than the right model from this pair.
Fashion designer (man to the right of rightmost model) has less height than all models and can't be selected for exchange.
You should tell if it's possible to make at most one exchange in such a way that row becomes nice for Izabella. | In first line there are two integers *n* and *k* (1<=β€<=*n*<=β€<=5Β·105, 1<=β€<=*k*<=β€<=*n*)Β β number of models and required distance.
Second line contains *n* space-separated integers *a**i* (1<=β€<=*a**i*<=β€<=109)Β β height of each model. Pay attention that height of fashion designer is not given and can be less than 1. | Print Β«YESΒ» (without quotes) if it's possible to make row nice using at most one exchange, and Β«NOΒ» (without quotes) otherwise. | [
"5 4\n2 3 5 2 5\n",
"5 2\n3 6 2 2 1\n",
"5 2\n5 3 6 5 2\n"
] | [
"NO",
"YES",
"YES"
] | none | [] | 2,000 | 0 | 0 | 52,756 |
|
113 | Petr# | [
"brute force",
"data structures",
"hashing",
"strings"
] | B. Petr# | 2 | 256 | Long ago, when Petya was a schoolboy, he was very much interested in the Petr# language grammar. During one lesson Petya got interested in the following question: how many different continuous substrings starting with the *s**begin* and ending with the *s**end* (it is possible *s**begin*<==<=*s**end*), the given string *t* has. Substrings are different if and only if their contents aren't equal, their positions of occurence don't matter. Petya wasn't quite good at math, that's why he couldn't count this number. Help him! | The input file consists of three lines. The first line contains string *t*. The second and the third lines contain the *s**begin* and *s**end* identificators, correspondingly. All three lines are non-empty strings consisting of lowercase Latin letters. The length of each string doesn't exceed 2000 characters. | Output the only number β the amount of different substrings of *t* that start with *s**begin* and end with *s**end*. | [
"round\nro\nou\n",
"codeforces\ncode\nforca\n",
"abababab\na\nb\n",
"aba\nab\nba\n"
] | [
"1\n",
"0\n",
"4\n",
"1\n"
] | In the third sample there are four appropriate different substrings. They are: ab, abab, ababab, abababab.
In the fourth sample identificators intersect. | [
{
"input": "round\nro\nou",
"output": "1"
},
{
"input": "codeforces\ncode\nforca",
"output": "0"
},
{
"input": "abababab\na\nb",
"output": "4"
},
{
"input": "aba\nab\nba",
"output": "1"
},
{
"input": "abcdefghijklmnopqrstuvwxyz\nabc\nxyz",
"output": "1"
},
{
"input": "aaaaaaaaaaaaaaa\na\na",
"output": "15"
},
{
"input": "aaaaaaaaa\naa\naaa",
"output": "7"
},
{
"input": "rmf\nrm\nf",
"output": "1"
},
{
"input": "kennyhorror\nkenny\nhorror",
"output": "1"
},
{
"input": "itsjustatest\njust\nits",
"output": "0"
},
{
"input": "ololo\ntrololo\nololo",
"output": "0"
},
{
"input": "ololololololololololololololo\no\nl",
"output": "14"
},
{
"input": "includecstdiointmainputshelloworldreturn\ncs\nrn",
"output": "1"
},
{
"input": "imabadsanta\nimabadsantaverybad\nimabadsantaverybad",
"output": "0"
},
{
"input": "codecppforfood\nc\nd",
"output": "3"
},
{
"input": "jelutarnumeratian\njelu\nerathian",
"output": "0"
},
{
"input": "yrbqsdlzrjprklpcaahhhfpkaohwwavwcsookezigzufcfvkmawptgdcdzkprxazchdaquvizhtmsfdpyrsjqtvjepssrqqhzsjpjfvihgojqfgbeudgmgjrgeqykytuswbahfw\njqfgbeudgmgjr\nojqfgbeudgmg",
"output": "0"
},
{
"input": "iifgcaijaakafhkbdgcciiiaihdfgdaejhjdkakljkdekcjilcjfdfhlkgfieaaiabafhleajihlegdkddifghbdbeiigiecbcblakliihcfdgkagfeadlgljijkecajbgekcekkkbflellchieehjkfcchjchigcjjaeclillialjdldiafjajdegcblcljkhfeeefeagbiilabhfjbcbkcailcaalceeekefehiadikjlkalgcghlkjegfeagfeafhibhecdlggehhecliidkghgbfbhfjldegfbifafdidecejlj\njbgekcekkkbflellchieehjkfcchjchigcjjaeclillialjdldiafjajdegcblcljkhfeeefe\nabhfjbcbkcailcaalceeekefehiadikjlkalgcghlkjegfeagfeafhibhecdlggehhecliidkghgbfbhfjldegfb",
"output": "1"
},
{
"input": "bgphoaomnjcjhgkgbflfclbjmkbfonpbmkdomjmkahaoclcbijdjlllnpfkbilgiiidbabgojbbfmliemhicaanadbaahagmfdldbbklelkihlcbkhchlikhefeeafbhkabfdlhnnjnlimbhneafcfeapcbeifgcnaijdnkjpikedmdbhahhgcijddfmamdiaapaeimdhfblpkedamifbbdndmmljmdcffcpmanndeeclnpnkdoieiahchdnkdmfnbocnimclgckdcbp\npcbeifgcnaijdnkjpikedmdbhahhgcijddfmamdiaapaeimdhfblpkedamifbbdndmmljmd\nbklelkihlcbkhchlikhefeeafbhkabfdlhnnjnlimbhneafcfeapcbeifgcnaijdnkjpikedmdbhahhgcijddfmamdiaapaeimdhfblpkedamifbbdndmmljmdcffcpmanndeeclnpnkdoieiahchdnk",
"output": "0"
},
{
"input": "fcgbeabagggfdbacgcaagfbdddefdbcfccfacfffebdgececdabfceadecbgdgdbdadcgfbbaaabcccdefabdfefadfdccbbefbfgcfdadeggggbdadfeadafbaccefdfcbbbadgegbbbcebfbdcfaabddeafbedagbgfdagcccafbddcfafdfaafgefcdceaabggfbaebeaccdfbeeegfdddgfdaagcbdddggcaceadgbddcbdcfddbcddfaebdgcebcbgcacgdeabffbedfabacbadcfgbdfffgadacabegecgdccbcbbaecdabeee\ngd\naa",
"output": "12"
},
{
"input": "bcacddaaccadcddcabdcddbabdbcccacdbcbababadbcaabbaddbbaaddadcbbcbccdcaddabbdbdcbacaccccadc\nc\ndb",
"output": "68"
},
{
"input": "uzxomgizlatyauzgyluecowouypbzladmwvtskagnltgjswsgsjmnjuxsokapatfevwavgxyhtokoaduvkszkybtqntsbaromqptomphrvvsyqchtydgslzsopervrhozsbiuygipfbmuhiaitrqqwdisxilnbuvfrqcnymaqxgiwnjfcvkqcpbiuoiricmuiyr\nsjmn\nmqpt",
"output": "1"
},
{
"input": "dbccdbcdbcccccdaddccadabddabdaaadadcdaacacddcccacbaaaabaa\ndcc\ncdbcc",
"output": "0"
},
{
"input": "abcdefg\nabcde\ncdefg",
"output": "1"
},
{
"input": "aaaaaaaaaaaaaaaaaaaaa\nb\nc",
"output": "0"
},
{
"input": "bcaaa\nbca\nc",
"output": "0"
},
{
"input": "ruruuyruruuy\nru\nuy",
"output": "4"
},
{
"input": "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\nd\nd",
"output": "240"
},
{
"input": "zzzabazzz\naba\nab",
"output": "0"
},
{
"input": "abcdcbaabccdba\nab\nba",
"output": "3"
},
{
"input": "xadyxbay\nx\ny",
"output": "3"
},
{
"input": "aba\nba\nab",
"output": "0"
},
{
"input": "aabbc\na\nb",
"output": "4"
}
] | 310 | 7,168,000 | 0 | 52,826 |
549 | Yura and Developers | [
"data structures",
"divide and conquer"
] | null | null | Yura has a team of *k* developers and a list of *n* tasks numbered from 1 to *n*. Yura is going to choose some tasks to be done this week. Due to strange Looksery habits the numbers of chosen tasks should be a segment of consecutive integers containing no less than 2 numbers, i. e. a sequence of form *l*,<=*l*<=+<=1,<=...,<=*r* for some 1<=β€<=*l*<=<<=*r*<=β€<=*n*.
Every task *i* has an integer number *a**i* associated with it denoting how many man-hours are required to complete the *i*-th task. Developers are not self-confident at all, and they are actually afraid of difficult tasks. Knowing that, Yura decided to pick up a hardest task (the one that takes the biggest number of man-hours to be completed, among several hardest tasks with same difficulty level he chooses arbitrary one) and complete it on his own. So, if tasks with numbers [*l*,<=*r*] are chosen then the developers are left with *r*<=-<=*l* tasks to be done by themselves.
Every developer can spend any integer amount of hours over any task, but when they are done with the whole assignment there should be exactly *a**i* man-hours spent over the *i*-th task.
The last, but not the least problem with developers is that one gets angry if he works more than another developer. A set of tasks [*l*,<=*r*] is considered good if it is possible to find such a distribution of work that allows to complete all the tasks and to have every developer working for the same amount of time (amount of work performed by Yura doesn't matter for other workers as well as for him).
For example, let's suppose that Yura have chosen tasks with following difficulties: *a*<==<=[1,<=2,<=3,<=4], and he has three developers in his disposal. He takes the hardest fourth task to finish by himself, and the developers are left with tasks with difficulties [1,<=2,<=3]. If the first one spends an hour on the first task and an hour on the third one, the second developer spends two hours on the second task and the third developer spends two hours on the third task, then they are done, since every developer worked exactly for two hours and every task has been worked over for the required amount of time. As another example, if the first task required two hours instead of one to be completed then it would be impossible to assign the tasks in a way described above.
Besides work, Yura is fond of problem solving. He wonders how many pairs (*l*,<=*r*) (1<=β€<=*l*<=<<=*r*<=β€<=*n*) exists such that a segment [*l*,<=*r*] is good? Yura has already solved this problem, but he has no time to write the code. Please, help Yura and implement the solution for this problem. | The first line of input contains two positive integers: *n* and *k* (1<=β€<=*n*<=β€<=300<=000,<=1<=β€<=*k*<=β€<=1<=000<=000), the number of tasks in the list and the number of developers in Yura's disposal.
The second line contains *n* integers *a**i* (1<=β€<=*a**i*<=β€<=109). | Output a single integer β the number of pairs (*l*,<=*r*) satisfying the conditions from the statement. | [
"4 3\n1 2 3 4\n",
"4 2\n4 4 7 4\n"
] | [
"3\n",
"6\n"
] | In the first sample there are three good segments:
1. [1;3] β the hardest task requires 3 man-hours, so there are tasks left that require 1 and 2 man-hours. A solution is to make first developer work on the first task for an hour, while second and third developers work on the second task. Each developer works exactly one hour.1. [1;4] β the hardest task requires 4 man-hours, so there are tasks left that require 1, 2 and 3 man-hours. If the first developer spends an hour on the first task and an hour on the third one, the second developer spends two hours on the second task and the third developer spends two hours on the third task, then they are done, since every developer worked exactly for two hours.1. [3;4] β the hardest task requires 4 man-hours, so there is only one task left that requires 3 man-hours. A solution is to make each developer work for an hour. | [] | 374 | 921,600 | -1 | 52,881 |
|
416 | President's Path | [
"dp",
"graphs",
"shortest paths"
] | null | null | Good old Berland has *n* cities and *m* roads. Each road connects a pair of distinct cities and is bidirectional. Between any pair of cities, there is at most one road. For each road, we know its length.
We also know that the President will soon ride along the Berland roads from city *s* to city *t*. Naturally, he will choose one of the shortest paths from *s* to *t*, but nobody can say for sure which path he will choose.
The Minister for Transport is really afraid that the President might get upset by the state of the roads in the country. That is the reason he is planning to repair the roads in the possible President's path.
Making the budget for such an event is not an easy task. For all possible distinct pairs *s*,<=*t* (*s*<=<<=*t*) find the number of roads that lie on at least one shortest path from *s* to *t*. | The first line of the input contains integers *n*,<=*m* (2<=β€<=*n*<=β€<=500, 0<=β€<=*m*<=β€<=*n*Β·(*n*<=-<=1)<=/<=2) β the number of cities and roads, correspondingly. Then *m* lines follow, containing the road descriptions, one description per line. Each description contains three integers *x**i*,<=*y**i*,<=*l**i* (1<=β€<=*x**i*,<=*y**i*<=β€<=*n*,<=*x**i*<=β <=*y**i*,<=1<=β€<=*l**i*<=β€<=106), where *x**i*,<=*y**i* are the numbers of the cities connected by the *i*-th road and *l**i* is its length. | Print the sequence of integers *c*12,<=*c*13,<=...,<=*c*1*n*,<=*c*23,<=*c*24,<=...,<=*c*2*n*,<=...,<=*c**n*<=-<=1,<=*n*, where *c**st* is the number of roads that can lie on the shortest path from *s* to *t*. Print the elements of sequence *c* in the described order. If the pair of cities *s* and *t* don't have a path between them, then *c**st*<==<=0. | [
"5 6\n1 2 1\n2 3 1\n3 4 1\n4 1 1\n2 4 2\n4 5 4\n"
] | [
"1 4 1 2 1 5 6 1 2 1 "
] | none | [] | 93 | 307,200 | 0 | 52,926 |
|
946 | Fibonacci String Subsequences | [
"combinatorics",
"dp",
"matrices"
] | null | null | You are given a binary string *s* (each character of this string is either 0 or 1).
Let's denote the cost of string *t* as the number of occurences of *s* in *t*. For example, if *s* is 11 and *t* is 111011, then the cost of *t* is 3.
Let's also denote the Fibonacci strings sequence as follows:
- *F*(0) is 0;- *F*(1) is 1;- *F*(*i*)<==<=*F*(*i*<=-<=1)<=+<=*F*(*i*<=-<=2) if *i*<=><=1, where <=+<= means the concatenation of two strings.
Your task is to calculate the sum of costs of all subsequences of the string *F*(*x*). Since answer may be large, calculate it modulo 109<=+<=7. | The first line contains two integers *n* and *x* (1<=β€<=*n*<=β€<=100, 0<=β€<=*x*<=β€<=100) β the length of *s* and the index of a Fibonacci string you are interested in, respectively.
The second line contains *s* β a string consisting of *n* characters. Each of these characters is either 0 or 1. | Print the only integer β the sum of costs of all subsequences of the string *F*(*x*), taken modulo 109<=+<=7. | [
"2 4\n11\n",
"10 100\n1010101010\n"
] | [
"14\n",
"553403224\n"
] | none | [
{
"input": "2 4\n11",
"output": "14"
},
{
"input": "10 100\n1010101010",
"output": "553403224"
},
{
"input": "10 5\n0110111100",
"output": "0"
},
{
"input": "100 100\n0001010101110010010100111011010101101111110001101101010111011101010000111000110001111010001001000001",
"output": "365717046"
},
{
"input": "50 50\n00011100010110111111011100101010000001101001001001",
"output": "211494411"
},
{
"input": "100 50\n0110110011111110010000000101010110011001011100000010110100110000000111001011011010110111000010000001",
"output": "355763668"
},
{
"input": "50 100\n11001000000100001111111111100011011110001000110101",
"output": "225470550"
},
{
"input": "10 5\n0110010110",
"output": "0"
},
{
"input": "100 100\n0001000111111101010001010000110001001000011010001001110000110001001010110010101101010001101110100100",
"output": "399119859"
},
{
"input": "50 50\n01011000110110000111110010001111101100010111110000",
"output": "714948296"
},
{
"input": "100 50\n0110101011101001010110011110010001101110110111100101000111001111011101110001000010011111010001100101",
"output": "848198292"
},
{
"input": "50 100\n00000110100111111010111000110011110111010110010101",
"output": "479111747"
},
{
"input": "10 5\n0001000110",
"output": "0"
},
{
"input": "100 100\n0011111110011110110011101011100011101101000100001111000001011011110000011110100111011001111111100100",
"output": "890610403"
},
{
"input": "50 50\n01001010111011110110111100110111010101011101010100",
"output": "681685300"
},
{
"input": "100 50\n0000000000000110011010100101101011000010001001100001100010101101110011011000011000010110100110011101",
"output": "887847887"
},
{
"input": "50 100\n00010100101010011011010110000111010110011101101100",
"output": "114941842"
},
{
"input": "10 5\n0001111100",
"output": "0"
},
{
"input": "100 100\n0110100100001000110111110000100100011011101101101111100010100100011110100100011100000000101000010000",
"output": "313325649"
},
{
"input": "50 50\n01100100001000001111000111100111011110101010001101",
"output": "296269628"
},
{
"input": "100 50\n0001010000010001111100011010101001100101000000000001100001000001001001110010000001011110100101011001",
"output": "178648298"
},
{
"input": "50 100\n00110000001011100010011100111100001111101011101111",
"output": "769038034"
},
{
"input": "10 5\n1001100101",
"output": "0"
},
{
"input": "100 100\n0100001100000111000001001100001110010110010011101010000101000010100100001111000100101000001011111100",
"output": "923483202"
},
{
"input": "50 50\n00100010000101111110000001011010100111110000101100",
"output": "409708636"
},
{
"input": "100 50\n0001001010110010101101010001101110100100111010000101010110101111111001101100011011110101010000111101",
"output": "404698837"
},
{
"input": "50 100\n01101110010011010010101010001100100100110000000110",
"output": "858303348"
},
{
"input": "10 5\n1110010111",
"output": "0"
},
{
"input": "100 100\n0101011110100000000100110111001100110011111001001110010110001100011110101011011110101001011100011101",
"output": "807081430"
},
{
"input": "50 50\n00111110100101010010101111101000000111011111000101",
"output": "619349549"
},
{
"input": "100 50\n0110110000110101001011101000011100000000010100000011110101001001010111001100000011101101000011011100",
"output": "883337527"
},
{
"input": "50 100\n01101000110100101011100101111101001001011010110110",
"output": "815093980"
},
{
"input": "10 5\n1110011111",
"output": "0"
},
{
"input": "100 100\n0001100111110111101110111100011011010001100100001100110101100010111000010001000110100111000101111001",
"output": "302237139"
},
{
"input": "50 50\n00011000010100100011000001011001101110000101010101",
"output": "740098237"
},
{
"input": "100 50\n0110100001101010001101010011011000101111101101100010010110110111101101100111011001001000011100100000",
"output": "530774696"
},
{
"input": "50 100\n01000100110101011110001011000001110000000100011111",
"output": "138545018"
},
{
"input": "10 5\n1110000101",
"output": "0"
},
{
"input": "100 100\n0011111101010100101010000111111001110100001110101000011000000110100010011011011100001110100010001101",
"output": "860040906"
},
{
"input": "50 50\n01000010011011011010010110100001010001011010110100",
"output": "707347275"
},
{
"input": "100 50\n0110011011001101101000001100011011011010100011100110000011011000110111011011100011000000111111000100",
"output": "66265147"
},
{
"input": "50 100\n00010110001100100111100101110001010001110111001110",
"output": "352965752"
},
{
"input": "10 5\n1001111110",
"output": "0"
},
{
"input": "100 100\n0110001111011011111100111000111111011011110101101100101011111000011000110010000110000111110001000101",
"output": "893503058"
},
{
"input": "50 50\n01000110111010101011111100010101111000111000001101",
"output": "734862374"
},
{
"input": "100 50\n0001010011001110101110100111110101111100011000000010100000111110011001110001101010001001101010100000",
"output": "299420410"
},
{
"input": "50 100\n00011000101000010101110111100000111011111001100110",
"output": "470403317"
},
{
"input": "10 5\n1001111000",
"output": "0"
},
{
"input": "100 100\n1001101110100101001011001111100101011111111000100010110101001101111010010000001011101000011000100011",
"output": "867372444"
},
{
"input": "50 50\n10101100011100111101010100100111010000111101110110",
"output": "841531413"
},
{
"input": "100 50\n1111000101010001011011110000101001110111101100010110101001000101010110000000110110111001011100010001",
"output": "227967423"
},
{
"input": "50 100\n10111010110100011110011000100110011000001000011011",
"output": "357273337"
},
{
"input": "1 0\n0",
"output": "1"
},
{
"input": "1 1\n0",
"output": "0"
},
{
"input": "1 0\n1",
"output": "0"
},
{
"input": "1 1\n1",
"output": "1"
},
{
"input": "1 100\n0",
"output": "16747890"
},
{
"input": "1 100\n1",
"output": "731582592"
}
] | 452 | 11,776,000 | 3 | 52,976 |
|
23 | Tetragon | [
"geometry",
"math"
] | D. Tetragon | 3 | 256 | You're given the centers of three equal sides of a strictly convex tetragon. Your task is to restore the initial tetragon. | The first input line contains one number *T* β amount of tests (1<=β€<=*T*<=β€<=5Β·104). Each of the following *T* lines contains numbers *x*1, *y*1, *x*2, *y*2, *x*3, *y*3 β coordinates of different points that are the centers of three equal sides (non-negative integer numbers, not exceeding 10). | For each test output two lines. If the required tetragon exists, output in the first line YES, in the second line β four pairs of numbers β coordinates of the polygon's vertices in clockwise or counter-clockwise order. Don't forget, please, that the tetragon should be strictly convex, i.e. no 3 of its points lie on one line. Output numbers with 9 characters after a decimal point.
If the required tetragon doen't exist, output NO in the first line, and leave the second line empty. | [
"3\n1 1 2 2 3 3\n0 1 1 0 2 2\n9 3 7 9 9 8\n"
] | [
"NO\n\nYES\n3.5 1.5 0.5 2.5 -0.5 -0.5 2.5 0.5\nNO\n\n"
] | none | [] | 124 | 819,200 | -1 | 53,120 |
856 | Eleventh Birthday | [
"combinatorics",
"dp",
"math"
] | null | null | It is Borya's eleventh birthday, and he has got a great present: *n* cards with numbers. The *i*-th card has the number *a**i* written on it. Borya wants to put his cards in a row to get one greater number. For example, if Borya has cards with numbers 1, 31, and 12, and he puts them in a row in this order, he would get a number 13112.
He is only 11, but he already knows that there are *n*! ways to put his cards in a row. But today is a special day, so he is only interested in such ways that the resulting big number is divisible by eleven. So, the way from the previous paragraph is good, because 13112<==<=1192<=Γ<=11, but if he puts the cards in the following order: 31, 1, 12, he would get a number 31112, it is not divisible by 11, so this way is not good for Borya. Help Borya to find out how many good ways to put the cards are there.
Borya considers all cards different, even if some of them contain the same number. For example, if Borya has two cards with 1 on it, there are two good ways.
Help Borya, find the number of good ways to put the cards. This number can be large, so output it modulo 998244353. | Input data contains multiple test cases. The first line of the input data contains an integer *t*Β β the number of test cases (1<=β€<=*t*<=β€<=100). The descriptions of test cases follow.
Each test is described by two lines.
The first line contains an integer *n* (1<=β€<=*n*<=β€<=2000)Β β the number of cards in Borya's present.
The second line contains *n* integers *a**i* (1<=β€<=*a**i*<=β€<=109)Β β numbers written on the cards.
It is guaranteed that the total number of cards in all tests of one input data doesn't exceed 2000. | For each test case output one line: the number of ways to put the cards to the table so that the resulting big number was divisible by 11, print the number modulo 998244353. | [
"4\n2\n1 1\n3\n1 31 12\n3\n12345 67 84\n9\n1 2 3 4 5 6 7 8 9\n"
] | [
"2\n2\n2\n31680\n"
] | none | [] | 46 | 0 | 0 | 53,298 |
|
534 | Handshakes | [
"binary search",
"constructive algorithms",
"data structures",
"greedy"
] | null | null | On February, 30th *n* students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest. | The first line contains integer *n* (1<=β€<=*n*<=β€<=2Β·105) β the number of students who came to CTOP. The next line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (0<=β€<=*a**i*<=<<=*n*), where *a**i* is the number of students with who the *i*-th student shook hands. | If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number *i* that stands to the left of number *j* in this permutation means that the *i*-th student came earlier than the *j*-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible". | [
"5\n2 1 3 0 1\n",
"9\n0 2 3 4 1 1 0 2 2\n",
"4\n0 2 1 1\n"
] | [
"Possible\n4 5 1 3 2 ",
"Possible\n7 5 2 1 6 8 3 4 9",
"Impossible\n"
] | In the first sample from the statement the order of events could be as follows:
- student 4 comes in (*a*<sub class="lower-index">4</sub>β=β0), he has no one to greet; - student 5 comes in (*a*<sub class="lower-index">5</sub>β=β1), he shakes hands with student 4; - student 1 comes in (*a*<sub class="lower-index">1</sub>β=β2), he shakes hands with two students (students 4, 5); - student 3 comes in (*a*<sub class="lower-index">3</sub>β=β3), he shakes hands with three students (students 4, 5, 1); - students 4, 5, 3 form a team and start writing a contest; - student 2 comes in (*a*<sub class="lower-index">2</sub>β=β1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
- student 7 comes in (*a*<sub class="lower-index">7</sub>β=β0), he has nobody to greet; - student 5 comes in (*a*<sub class="lower-index">5</sub>β=β1), he shakes hands with student 7; - student 2 comes in (*a*<sub class="lower-index">2</sub>β=β2), he shakes hands with two students (students 7, 5); - students 7, 5, 2 form a team and start writing a contest; - student 1 comes in(*a*<sub class="lower-index">1</sub>β=β0), he has no one to greet (everyone is busy with the contest); - student 6 comes in (*a*<sub class="lower-index">6</sub>β=β1), he shakes hands with student 1; - student 8 comes in (*a*<sub class="lower-index">8</sub>β=β2), he shakes hands with two students (students 1, 6); - student 3 comes in (*a*<sub class="lower-index">3</sub>β=β3), he shakes hands with three students (students 1, 6, 8); - student 4 comes in (*a*<sub class="lower-index">4</sub>β=β4), he shakes hands with four students (students 1, 6, 8, 3); - students 8, 3, 4 form a team and start writing a contest; - student 9 comes in (*a*<sub class="lower-index">9</sub>β=β2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
- student 1 comes in (*a*<sub class="lower-index">1</sub>β=β0), he has no one to greet; - student 3 comes in (or student 4) (*a*<sub class="lower-index">3</sub>β=β*a*<sub class="lower-index">4</sub>β=β1), he shakes hands with student 1; - student 2 comes in (*a*<sub class="lower-index">2</sub>β=β2), he shakes hands with two students (students 1, 3 (or 4)); - the remaining student 4 (or student 3), must shake one student's hand (*a*<sub class="lower-index">3</sub>β=β*a*<sub class="lower-index">4</sub>β=β1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually. | [
{
"input": "5\n2 1 3 0 1",
"output": "Possible\n4 5 1 3 2 "
},
{
"input": "9\n0 2 3 4 1 1 0 2 2",
"output": "Possible\n7 6 9 3 4 8 1 5 2 "
},
{
"input": "4\n0 2 1 1",
"output": "Impossible"
},
{
"input": "5\n1 0 2 1 0",
"output": "Possible\n5 4 3 2 1 "
},
{
"input": "1\n0",
"output": "Possible\n1 "
},
{
"input": "5\n3 0 4 1 2",
"output": "Possible\n2 4 5 1 3 "
},
{
"input": "3\n1 0 0",
"output": "Impossible"
},
{
"input": "7\n3 0 0 4 2 2 1",
"output": "Possible\n3 7 6 1 4 5 2 "
},
{
"input": "10\n1 0 2 3 3 0 4 4 2 5",
"output": "Possible\n6 1 9 5 8 10 4 7 3 2 "
},
{
"input": "7\n2 4 3 5 1 6 0",
"output": "Possible\n7 5 1 3 2 4 6 "
},
{
"input": "10\n6 2 8 1 4 5 7 3 9 3",
"output": "Impossible"
},
{
"input": "5\n2 0 3 1 1",
"output": "Possible\n2 5 1 3 4 "
},
{
"input": "7\n2 2 3 3 4 0 1",
"output": "Possible\n6 7 2 4 5 1 3 "
},
{
"input": "11\n3 1 1 1 2 2 0 0 2 1 3",
"output": "Possible\n8 10 9 11 4 6 1 3 5 7 2 "
},
{
"input": "6\n0 1 2 1 2 0",
"output": "Possible\n6 4 5 1 2 3 "
},
{
"input": "13\n1 2 0 4 2 1 0 2 0 0 2 3 1",
"output": "Possible\n10 13 11 12 4 8 9 6 5 7 1 2 3 "
},
{
"input": "12\n1 1 0 2 1 1 2 2 0 2 0 0",
"output": "Possible\n12 6 10 11 5 8 9 2 7 3 1 4 "
},
{
"input": "16\n4 7 7 9 1 10 8 3 2 5 11 0 9 9 8 6",
"output": "Possible\n12 5 9 8 1 10 16 3 15 14 6 11 13 2 7 4 "
},
{
"input": "10\n3 4 5 2 7 1 3 0 6 5",
"output": "Possible\n8 6 4 7 2 10 9 5 3 1 "
},
{
"input": "11\n1 1 3 2 2 2 0 1 0 1 3",
"output": "Possible\n9 10 6 11 8 5 3 2 4 7 1 "
},
{
"input": "6\n2 0 2 0 1 1",
"output": "Possible\n4 6 3 2 5 1 "
},
{
"input": "123\n114 105 49 11 115 106 92 74 101 86 39 116 5 48 87 19 40 25 22 42 111 75 84 68 57 119 46 41 23 58 90 102 3 10 78 108 2 21 122 121 120 64 85 32 34 71 4 110 36 30 18 81 52 76 47 33 54 45 29 17 100 27 70 31 89 99 61 6 9 53 20 35 0 79 112 55 96 51 16 62 72 26 44 15 80 82 8 109 14 63 28 43 60 1 113 59 91 103 65 88 94 12 95 104 13 77 69 98 97 24 83 50 73 37 118 56 66 93 117 38 67 107 7",
"output": "Possible\n73 94 37 33 47 13 68 123 87 69 34 4 102 105 89 84 79 60 51 16 71 38 19 29 110 18 82 62 91 59 50 64 44 56 45 72 49 114 120 11 17 28 20 92 83 58 27 55 14 3 112 78 53 70 57 76 116 25 30 96 93 67 80 90 42 99 117 121 24 107 63 46 81 113 8 22 54 106 35 74 85 52 86 111 23 43 10 15 100 65 31 97 7 118 101 103 77 109 108 66 61 9 32 98 104 2 6 122 36 88 48 21 75 95 1 5 12 119 115 26 41 40 39 "
},
{
"input": "113\n105 36 99 43 3 100 60 28 24 46 53 31 50 18 2 35 52 84 30 81 51 108 19 93 1 39 62 79 61 97 27 87 65 90 57 16 80 111 56 102 95 112 8 25 44 10 49 26 70 54 41 22 106 107 63 59 67 33 68 11 12 82 40 89 58 109 92 71 4 69 37 14 48 103 77 64 87 110 66 55 98 23 13 38 15 6 75 78 29 88 74 96 9 91 85 20 42 0 17 86 5 104 76 7 73 32 34 47 101 83 45 21 94",
"output": "Impossible"
},
{
"input": "54\n4 17 18 15 6 0 12 19 20 21 19 14 23 20 7 19 0 2 13 18 2 1 0 1 0 5 11 10 1 16 8 21 20 1 16 1 1 0 15 2 22 2 2 2 18 0 3 9 1 20 19 14 0 2",
"output": "Possible\n53 49 54 47 1 26 5 15 31 48 28 27 7 19 52 39 35 2 45 51 50 32 41 13 10 16 33 20 11 14 3 8 9 4 30 12 46 37 44 38 36 43 25 34 42 23 29 40 17 24 21 6 22 18 "
},
{
"input": "124\n3 10 6 5 21 23 4 6 9 1 9 3 14 27 10 19 29 17 24 17 5 12 20 4 16 2 24 4 21 14 9 22 11 27 4 9 2 11 6 5 6 6 11 4 3 22 6 10 5 15 5 2 16 13 19 8 25 4 18 10 9 5 13 10 19 26 2 3 9 4 7 12 20 20 4 19 11 33 17 25 2 28 15 8 8 15 30 14 18 11 5 10 18 17 18 31 9 7 1 16 3 6 15 24 4 17 10 26 4 23 22 11 19 15 7 26 28 18 32 0 23 8 6 13",
"output": "Possible\n120 99 81 101 109 91 123 115 122 97 107 112 72 124 88 114 100 106 118 113 74 29 111 121 104 80 116 34 117 17 87 96 119 78 82 108 14 57 66 27 46 110 19 32 6 5 76 73 95 65 23 93 55 94 89 16 79 59 53 20 103 25 18 86 63 30 83 54 13 50 92 90 22 64 77 69 60 43 61 48 38 36 15 33 31 2 85 11 98 84 9 71 56 102 105 62 47 75 51 42 70 49 41 58 40 39 44 21 8 35 4 3 28 67 68 24 52 45 7 37 12 10 26 1 "
},
{
"input": "69\n1 5 8 5 4 10 6 0 0 4 5 5 3 1 5 5 9 4 5 7 6 2 0 4 6 2 2 8 2 13 3 7 4 4 1 4 6 1 5 9 6 0 3 3 8 6 7 3 6 7 37 1 8 14 4 2 7 5 4 5 4 2 3 6 5 11 12 3 3",
"output": "Impossible"
},
{
"input": "185\n28 4 4 26 15 21 14 35 22 28 26 24 2 35 21 34 1 23 35 10 6 16 31 0 30 9 18 33 1 22 24 26 22 10 8 27 14 33 16 16 26 22 1 28 32 1 35 12 31 0 21 6 6 5 29 27 1 29 23 22 30 19 37 17 2 2 2 25 3 23 28 0 3 31 34 5 2 23 27 7 26 25 33 27 15 31 31 4 3 21 1 1 23 30 0 13 24 33 26 5 1 17 23 25 36 0 20 0 32 2 2 36 24 26 25 33 35 2 26 27 37 25 12 27 30 21 34 33 29 1 12 1 25 2 29 36 3 11 2 23 25 29 2 32 30 18 3 18 26 19 4 20 23 38 22 13 25 0 1 24 2 25 0 24 0 27 36 1 2 21 1 31 0 17 11 0 28 7 20 5 5 32 37 28 34",
"output": "Possible\n176 171 169 147 151 181 53 178 35 26 34 175 131 156 37 85 40 174 148 150 179 170 155 153 164 162 149 166 184 142 145 172 182 128 185 117 167 183 154 136 121 47 112 63 19 105 127 14 116 75 8 98 16 144 83 87 109 38 86 45 28 74 135 125 49 129 94 23 58 61 177 55 25 71 119 124 44 114 120 10 99 84 1 81 79 157 41 56 141 32 36 133 11 160 122 4 113 115 140 97 104 103 31 82 93 12 68 78 126 60 70 90 42 59 51 33 18 15 30 152 6 9 107 146 62 102 27 39 64 5 22 7 123 96 138 48 20 180 52 80 100 21 88 76 137 3 54 ..."
},
{
"input": "104\n1 0 0 0 2 6 4 8 1 4 2 11 2 0 2 0 0 1 2 0 5 0 3 6 8 5 0 5 1 2 8 1 2 8 9 2 0 4 1 0 2 1 9 5 1 7 7 6 1 0 6 2 3 2 2 0 8 3 9 7 1 7 0 2 3 5 0 5 6 10 0 1 1 2 8 4 4 10 3 4 10 2 1 6 7 1 7 2 1 9 1 0 1 1 2 1 11 2 6 0 2 2 9 7",
"output": "Possible\n100 96 102 79 80 68 99 104 75 103 81 97 90 78 12 59 70 57 43 87 34 35 85 31 84 62 25 69 60 8 51 47 66 48 46 44 24 77 28 6 76 26 65 38 21 58 10 101 53 7 98 23 94 95 92 93 88 71 91 82 67 89 74 63 86 64 56 83 55 50 73 54 40 72 52 37 61 41 27 49 36 22 45 33 20 42 30 17 39 19 16 32 15 14 29 13 4 18 11 3 9 5 2 1 "
},
{
"input": "93\n5 10 0 2 0 3 4 21 17 9 13 2 16 11 10 0 13 5 8 14 10 0 6 19 20 8 12 1 8 11 19 7 8 3 8 10 12 2 9 1 10 5 4 9 4 15 5 8 16 11 10 17 11 3 12 7 9 10 1 7 6 4 10 8 9 10 9 18 9 9 4 5 11 2 12 10 11 9 17 12 1 6 8 15 13 2 11 6 7 10 3 5 12",
"output": "Possible\n22 81 86 91 71 92 88 89 83 78 90 87 93 85 20 84 49 79 68 31 25 8 24 52 46 13 9 80 17 77 75 11 73 55 76 53 37 66 50 27 63 30 70 58 14 69 51 64 67 41 48 65 36 35 57 21 33 44 15 29 39 2 26 10 60 19 82 56 72 61 32 47 23 62 42 54 45 18 34 43 1 6 7 74 16 59 38 5 40 12 3 28 4 "
},
{
"input": "99\n6 13 9 8 5 12 1 6 13 12 11 15 2 5 10 12 13 9 13 4 8 10 11 11 7 2 9 2 13 10 3 0 12 11 14 12 9 9 11 9 1 11 7 12 8 9 6 10 13 14 0 8 8 10 12 8 9 14 5 12 4 9 7 10 8 7 12 14 13 0 10 10 8 12 10 12 6 14 11 10 1 5 8 11 10 13 10 11 7 4 3 3 2 11 8 9 13 12 4",
"output": "Possible\n70 81 93 92 99 82 77 89 95 96 87 94 98 97 78 12 86 68 76 69 58 74 49 50 67 29 35 60 19 88 55 17 84 44 9 79 36 2 42 33 85 39 16 80 34 10 75 24 6 72 23 62 71 11 57 64 83 46 54 73 40 48 65 38 30 56 37 22 53 27 15 52 18 66 45 3 63 21 47 43 4 8 25 59 1 90 14 91 61 5 31 20 28 51 41 26 32 7 13 "
},
{
"input": "153\n5 4 3 3 0 5 5 5 3 3 7 3 5 2 7 4 0 5 2 0 4 6 3 3 2 1 4 3 2 0 8 1 7 6 8 7 5 6 4 5 2 4 0 4 4 2 4 3 3 4 5 6 3 5 5 6 4 4 6 7 1 1 8 4 2 4 3 5 1 4 9 6 3 3 4 8 4 2 4 6 5 9 5 4 1 3 10 3 3 4 2 1 2 7 4 3 6 5 6 6 4 7 6 1 4 4 2 8 5 5 5 3 6 6 7 1 4 8 4 8 5 5 3 9 5 2 2 8 5 6 4 2 0 2 4 3 7 3 3 8 6 2 4 3 7 2 6 1 3 7 2 2 2",
"output": "Possible\n133 148 153 149 143 129 147 150 140 124 87 128 82 145 120 71 137 118 141 115 108 130 102 76 114 94 63 113 60 35 103 36 31 100 33 125 99 15 122 97 11 121 80 135 111 72 131 110 59 119 109 56 117 98 52 106 83 38 105 81 34 101 68 22 95 55 144 90 54 139 84 51 138 79 40 136 77 37 123 75 18 112 70 13 96 66 8 89 64 7 88 58 6 86 57 1 74 50 152 73 47 151 67 45 146 53 44 142 49 42 134 48 39 132 28 27 127 24 21 126 23 16 107 12 2 93 10 116 91 9 104 78 4 92 65 3 85 46 43 69 41 30 62 29 20 61 25 17 32 19 5 26 ..."
},
{
"input": "169\n1 2 1 2 2 4 1 0 0 1 0 1 6 7 5 3 0 1 4 0 3 4 1 5 3 1 3 0 2 1 1 3 1 2 0 0 2 4 0 0 2 2 1 1 2 1 1 1 0 3 2 4 5 5 5 0 0 1 3 1 2 0 0 2 1 0 3 1 3 2 6 1 2 0 0 3 1 2 0 2 2 3 1 1 2 2 2 3 3 2 1 1 0 2 0 4 4 3 3 1 4 2 2 4 2 2 1 2 3 0 1 5 1 0 3 1 2 1 1 3 2 3 4 2 3 6 2 3 3 1 4 4 5 2 0 1 2 2 1 0 2 2 2 2 7 2 2 3 3 8 3 5 2 1 2 1 2 5 3 0 3 1 2 2 1 1 2 4 3",
"output": "Possible\n160 166 167 169 168 158 126 145 150 71 14 152 13 132 133 161 131 112 159 123 55 151 104 54 149 101 53 148 97 24 129 96 15 128 52 164 125 38 163 122 22 157 120 19 155 115 6 153 109 165 147 99 162 146 98 156 144 89 154 143 88 139 142 82 136 141 76 130 138 69 119 137 67 118 134 59 116 127 50 113 124 32 111 121 27 107 117 25 100 108 21 92 106 16 91 105 140 84 103 135 83 102 114 77 94 110 72 90 95 68 87 93 65 86 79 60 85 75 58 81 74 48 80 66 47 78 63 46 73 62 44 70 57 43 64 56 33 61 49 31 51 40 30 45 ..."
},
{
"input": "92\n0 0 2 0 1 1 2 1 2 0 2 1 1 2 2 0 1 1 0 2 1 2 1 1 3 2 2 2 2 0 1 2 1 0 0 0 1 1 0 3 0 1 0 1 2 1 0 2 2 1 2 1 0 0 1 1 2 1 2 0 0 1 2 2 0 2 0 0 2 1 1 2 1 0 2 2 4 0 0 0 2 0 1 1 0 2 0 2 0 1 2 1",
"output": "Possible\n89 92 91 40 77 88 25 90 86 87 84 81 85 83 76 82 73 75 80 71 72 79 70 69 78 62 66 74 58 64 68 56 63 67 55 59 65 52 57 61 50 51 60 46 49 54 44 48 53 42 45 47 38 32 43 37 29 41 33 28 39 31 27 36 24 26 35 23 22 34 21 20 30 18 15 19 17 14 16 13 11 10 12 9 4 8 7 2 6 3 1 5 "
},
{
"input": "12\n0 1 2 3 4 5 6 7 8 0 1 2",
"output": "Possible\n10 11 12 4 5 6 7 8 9 1 2 3 "
}
] | 108 | 0 | 0 | 53,480 |
|
0 | none | [
"none"
] | null | null | A couple of friends, Axel and Marston are travelling across the country of Bitland. There are *n* towns in Bitland, with some pairs of towns connected by one-directional roads. Each road in Bitland is either a pedestrian road or a bike road. There can be multiple roads between any pair of towns, and may even be a road from a town to itself. However, no pair of roads shares the starting and the destination towns along with their types simultaneously.
The friends are now located in the town 1 and are planning the travel route. Axel enjoys walking, while Marston prefers biking. In order to choose a route diverse and equally interesting for both friends, they have agreed upon the following procedure for choosing the road types during the travel:
- The route starts with a pedestrian route.- Suppose that a beginning of the route is written in a string *s* of letters P (pedestrain road) and B (biking road). Then, the string is appended to *s*, where stands for the string *s* with each character changed to opposite (that is, all pedestrian roads changed to bike roads, and vice versa).
In the first few steps the route will look as follows: P, PB, PBBP, PBBPBPPB, PBBPBPPBBPPBPBBP, and so on.
After that the friends start travelling from the town 1 via Bitlandian roads, choosing the next road according to the next character of their route type each time. If it is impossible to choose the next road, the friends terminate their travel and fly home instead.
Help the friends to find the longest possible route that can be travelled along roads of Bitland according to the road types choosing procedure described above. If there is such a route with more than 1018 roads in it, print -1 instead. | The first line contains two integers *n* and *m* (1<=β€<=*n*<=β€<=500, 0<=β€<=*m*<=β€<=2*n*2)Β β the number of towns and roads in Bitland respectively.
Next *m* lines describe the roads. *i*-th of these lines contains three integers *v**i*, *u**i* and *t**i* (1<=β€<=*v**i*,<=*u**i*<=β€<=*n*, 0<=β€<=*t**i*<=β€<=1), where *v**i* and *u**i* denote start and destination towns indices of the *i*-th road, and *t**i* decribes the type of *i*-th road (0 for a pedestrian road, 1 for a bike road). It is guaranteed that for each pair of distinct indices *i*, *j* such that 1<=β€<=*i*,<=*j*<=β€<=*m*, either *v**i*<=β <=*v**j*, or *u**i*<=β <=*u**j*, or *t**i*<=β <=*t**j* holds. | If it is possible to find a route with length strictly greater than 1018, print -1. Otherwise, print the maximum length of a suitable path. | [
"2 2\n1 2 0\n2 2 1\n",
"2 3\n1 2 0\n2 2 1\n2 2 0\n"
] | [
"3\n",
"-1\n"
] | In the first sample we can obtain a route of length 3 by travelling along the road 1 from town 1 to town 2, and then following the road 2 twice from town 2 to itself.
In the second sample we can obtain an arbitrarily long route by travelling the road 1 first, and then choosing road 2 or 3 depending on the necessary type. | [] | 31 | 0 | 0 | 53,562 |
|
44 | BerPaint | [
"geometry",
"graphs"
] | F. BerPaint | 5 | 256 | Anfisa the monkey got disappointed in word processors as they aren't good enough at reflecting all the range of her emotions, that's why she decided to switch to graphics editors. Having opened the BerPaint, she saw a white rectangle *W*<=Γ<=*H* in size which can be painted on. First Anfisa learnt to navigate the drawing tool which is used to paint segments and quickly painted on that rectangle a certain number of black-colored segments. The resulting picture didn't seem bright enough to Anfisa, that's why she turned her attention to the "fill" tool which is used to find a point on the rectangle to paint and choose a color, after which all the area which is the same color as the point it contains, is completely painted the chosen color. Having applied the fill several times, Anfisa expressed her emotions completely and stopped painting. Your task is by the information on the painted segments and applied fills to find out for every color the total area of the areas painted this color after all the fills. | The first input line has two integers *W* and *H* (3<=β€<=*W*,<=*H*<=β€<=104) β the sizes of the initially white rectangular painting area. The second line contains integer *n* β the number of black segments (0<=β€<=*n*<=β€<=100). On the next *n* lines are described the segments themselves, each of which is given by coordinates of their endpoints *x*1,<=*y*1,<=*x*2,<=*y*2 (0<=<<=*x*1,<=*x*2<=<<=*W*,<=0<=<<=*y*1,<=*y*2<=<<=*H*). All segments have non-zero length. The next line contains preset number of fills *m* (0<=β€<=*m*<=β€<=100). Each of the following *m* lines defines the fill operation in the form of "*x* *y* *color*", where (*x*,<=*y*) are the coordinates of the chosen point (0<=<<=*x*<=<<=*W*,<=0<=<<=*y*<=<<=*H*), and *color* β a line of lowercase Latin letters from 1 to 15 symbols in length, determining the color. All coordinates given in the input are integers. Initially the rectangle is "white" in color, whereas the segments are drawn "black" in color. | For every color present in the final picture print on the single line the name of the color and the total area of areas painted that color with an accuracy of 10<=-<=6. Print the colors in any order. | [
"4 5\n6\n1 1 1 3\n1 3 3 3\n3 3 3 1\n3 1 1 1\n1 3 3 1\n1 1 3 3\n2\n2 1 red\n2 2 blue\n",
"5 5\n5\n1 1 2 2\n2 2 4 2\n4 2 4 4\n4 4 2 4\n2 4 2 2\n2\n3 3 black\n3 3 green\n",
"7 4\n9\n1 2 2 3\n2 3 3 2\n3 2 2 1\n2 1 1 2\n3 2 4 2\n4 2 5 3\n5 3 6 2\n6 2 5 1\n5 1 4 2\n2\n2 2 black\n2 2 red\n"
] | [
"blue 0.00000000\nwhite 20.00000000\n",
"green 4.00000000\nwhite 21.00000000\n",
"red 2.00000000\nwhite 26.00000000\n"
] | Initially the black segments painted by Anfisa can also be painted a color if any of the chosen points lays on the segment. The segments have areas equal to 0. That is why if in the final picture only parts of segments is painted some color, then the area, painted the color is equal to 0. | [] | 124 | 0 | 0 | 53,643 |
566 | Logistical Questions | [
"dfs and similar",
"divide and conquer",
"trees"
] | null | null | Some country consists of *n* cities, connected by a railroad network. The transport communication of the country is so advanced that the network consists of a minimum required number of (*n*<=-<=1) bidirectional roads (in the other words, the graph of roads is a tree). The *i*-th road that directly connects cities *a**i* and *b**i*, has the length of *l**i* kilometers.
The transport network is served by a state transporting company FRR (Fabulous Rail Roads). In order to simplify the price policy, it offers a single ride fare on the train. In order to follow the route of length *t* kilometers, you need to pay burles. Note that it is forbidden to split a long route into short segments and pay them separately (a special railroad police, or RRP, controls that the law doesn't get violated).
A Large Software Company decided to organize a programming tournament. Having conducted several online rounds, the company employees determined a list of finalists and sent it to the logistical department to find a place where to conduct finals. The Large Software Company can easily organize the tournament finals in any of the *n* cities of the country, so the the main factor in choosing the city for the last stage of the tournament is the total cost of buying tickets for all the finalists. We know that the *i*-th city of the country has *w**i* cup finalists living there.
Help the company employees find the city such that the total cost of travel of all the participants to it is minimum. | The first line of the input contains number *n* (1<=β€<=*n*<=β€<=200<=000) β the number of cities in the country.
The next line contains *n* integers *w*1,<=*w*2,<=...,<=*w**n* (0<=β€<=*w**i*<=β€<=108) β the number of finalists living in each city of the country.
Next (*n*<=-<=1) lines contain the descriptions of the railroad, the *i*-th line contains three integers, *a**i*, *b**i*, *l**i* (1<=β€<=*a**i*,<=*b**i*<=β€<=*n*, *a**i*<=β <=*b**i*, 1<=β€<=*l**i*<=β€<=1000). | Print two numbers β an integer *f* that is the number of the optimal city to conduct the competition, and the real number *c*, equal to the minimum total cost of transporting all the finalists to the competition. Your answer will be considered correct if two conditions are fulfilled at the same time:
1. The absolute or relative error of the printed number *c* in comparison with the cost of setting up a final in city *f* doesn't exceed 10<=-<=6; 1. Absolute or relative error of the printed number *c* in comparison to the answer of the jury doesn't exceed 10<=-<=6.
If there are multiple answers, you are allowed to print any of them. | [
"5\n3 1 2 6 5\n1 2 3\n2 3 1\n4 3 9\n5 3 1\n",
"2\n5 5\n1 2 2\n"
] | [
"3 192.0",
"1 14.142135623730951000\n"
] | In the sample test an optimal variant of choosing a city to conduct the finals of the competition is 3. At such choice the cost of conducting is <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/4219dfaeaed77b348dc7ca0c500739d1c0ff9e3f.png" style="max-width: 100.0%;max-height: 100.0%;"/> burles.
In the second sample test, whatever city you would choose, you will need to pay for the transport for five participants, so you will need to pay <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/bec9396b77dab4487d19f32c85b0edb26924da8c.png" style="max-width: 100.0%;max-height: 100.0%;"/> burles for each one of them. | [] | 62 | 307,200 | 0 | 53,775 |
|
0 | none | [
"none"
] | null | null | Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to *n*. Help him cope with the task. | The single line contains an integer *n* (1<=β€<=*n*<=β€<=106) β the sum of digits of the required lucky number. | Print on the single line the result β the minimum lucky number, whose sum of digits equals *n*. If such number does not exist, print -1. | [
"11\n",
"10\n"
] | [
"47\n",
"-1\n"
] | none | [
{
"input": "11",
"output": "47"
},
{
"input": "10",
"output": "-1"
},
{
"input": "64",
"output": "4477777777"
},
{
"input": "1",
"output": "-1"
},
{
"input": "4",
"output": "4"
},
{
"input": "7",
"output": "7"
},
{
"input": "12",
"output": "444"
},
{
"input": "1000000",
"output": "4477777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "47",
"output": "44477777"
},
{
"input": "100",
"output": "4444777777777777"
},
{
"input": "700",
"output": "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
},
{
"input": "485",
"output": "44447777777777777777777777777777777777777777777777777777777777777777777"
},
{
"input": "111",
"output": "444447777777777777"
},
{
"input": "85",
"output": "4477777777777"
},
{
"input": "114",
"output": "444477777777777777"
},
{
"input": "474",
"output": "444777777777777777777777777777777777777777777777777777777777777777777"
},
{
"input": "74",
"output": "47777777777"
},
{
"input": "1000",
"output": "4444477777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
},
{
"input": "1024",
"output": "4444777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
},
{
"input": "4444",
"output": "4444477777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "45784",
"output": "4777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "10000",
"output": "4777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "9854",
"output": "4447777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "186",
"output": "477777777777777777777777777"
},
{
"input": "10416",
"output": "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "10417",
"output": "4477777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "3840",
"output": "4777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "100000",
"output": "4447777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "9876",
"output": "4444477777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "99999",
"output": "4777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "777777",
"output": "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "854759",
"output": "4444447777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "11000",
"output": "4444447777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "18951",
"output": "4444777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "999999",
"output": "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "888887",
"output": "4444477777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "999998",
"output": "4444477777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "40008",
"output": "4444447777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "10691",
"output": "4444777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "5",
"output": "-1"
},
{
"input": "6",
"output": "-1"
},
{
"input": "9",
"output": "-1"
},
{
"input": "8",
"output": "44"
},
{
"input": "2",
"output": "-1"
},
{
"input": "3",
"output": "-1"
},
{
"input": "999997",
"output": "4447777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "999996",
"output": "4777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "999990",
"output": "4447777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "999980",
"output": "4444777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "800000",
"output": "4447777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
},
{
"input": "980000",
"output": "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..."
}
] | 92 | 102,400 | 3 | 53,881 |
|
576 | Flights for Regular Customers | [
"dp",
"matrices"
] | null | null | In the country there are exactly *n* cities numbered with positive integers from 1 to *n*. In each city there is an airport is located.
Also, there is the only one airline, which makes *m* flights. Unfortunately, to use them, you need to be a regular customer of this company, namely, you have the opportunity to enjoy flight *i* from city *a**i* to city *b**i* only if you have already made at least *d**i* flights before that.
Please note that flight *i* flies exactly from city *a**i* to city *b**i*. It can not be used to fly from city *b**i* to city *a**i*. An interesting fact is that there may possibly be recreational flights with a beautiful view of the sky, which begin and end in the same city.
You need to get from city 1 to city *n*. Unfortunately, you've never traveled by plane before. What minimum number of flights you have to perform in order to get to city *n*?
Note that the same flight can be used multiple times. | The first line contains two integers, *n* and *m* (2<=β€<=*n*<=β€<=150, 1<=β€<=*m*<=β€<=150) β the number of cities in the country and the number of flights the company provides.
Next *m* lines contain numbers *a**i*, *b**i*, *d**i* (1<=β€<=*a**i*,<=*b**i*<=β€<=*n*, 0<=β€<=*d**i*<=β€<=109), representing flight number *i* from city *a**i* to city *b**i*, accessible to only the clients who have made at least *d**i* flights. | Print "Impossible" (without the quotes), if it is impossible to get from city 1 to city *n* using the airways.
But if there is at least one way, print a single integer β the minimum number of flights you need to make to get to the destination point. | [
"3 2\n1 2 0\n2 3 1\n",
"2 1\n1 2 100500\n",
"3 3\n2 1 0\n2 3 6\n1 2 0\n"
] | [
"2\n",
"Impossible\n",
"8\n"
] | none | [] | 30 | 0 | 0 | 53,965 |
|
896 | Ithea Plays With Chtholly | [
"binary search",
"constructive algorithms",
"games",
"greedy",
"interactive"
] | null | null | This is an interactive problem. Refer to the Interaction section below for better understanding.
Ithea and Chtholly want to play a game in order to determine who can use the kitchen tonight.
Initially, Ithea puts *n* clear sheets of paper in a line. They are numbered from 1 to *n* from left to right.
This game will go on for *m* rounds. In each round, Ithea will give Chtholly an integer between 1 and *c*, and Chtholly needs to choose one of the sheets to write down this number (if there is already a number before, she will erase the original one and replace it with the new one).
Chtholly wins if, at any time, all the sheets are filled with a number and the *n* numbers are in non-decreasing order looking from left to right from sheet 1 to sheet *n*, and if after *m* rounds she still doesn't win, she loses the game.
Chtholly really wants to win the game as she wants to cook something for Willem. But she doesn't know how to win the game. So Chtholly finds you, and your task is to write a program to receive numbers that Ithea gives Chtholly and help her make the decision on which sheet of paper write this number. | The first line contains 3 integers *n*,<=*m* and *c* (, means rounded up)Β β the number of sheets, the number of rounds and the largest possible number Ithea can give to Chtholly respectively. The remaining parts of input are given throughout the interaction process. | none | [
"2 4 4\n2\n1\n3\n"
] | [
"1\n2\n2\n"
] | In the example, Chtholly initially knew there were 2 sheets, 4 rounds and each number was between 1 and 4. She then received a 2 and decided to write it in the 1st sheet. Then she received a 1 and wrote it in the 2nd sheet. At last, she received a 3 and replaced 1 with 3 in the 2nd sheet. At this time all the sheets were filled with a number and they were non-decreasing, so she won the game.
Note that it is required that your program terminate immediately after Chtholly wins and do not read numbers from the input for the remaining rounds. If not, undefined behaviour may arise and it won't be sure whether your program will be accepted or rejected. Also because of this, please be careful when hacking others' codes. In the sample, Chtholly won the game after the 3rd round, so it is required that your program doesn't read the number of the remaining 4th round.
The input format for hacking:
- The first line contains 3 integers *n*,β*m* and *c*; - The following *m* lines each contains an integer between 1 and *c*, indicating the number given to Chtholly in each round. | [
{
"input": "2 4 4\n2\n1\n3\n4",
"output": "3"
},
{
"input": "2 2 2\n1\n2",
"output": "2"
},
{
"input": "3 6 3\n1\n2\n1\n3\n1\n3",
"output": "3"
},
{
"input": "4 8 4\n4\n4\n4\n4\n4\n4\n4\n4",
"output": "4"
},
{
"input": "10 120 15\n6\n11\n9\n11\n3\n12\n11\n12\n2\n8\n3\n11\n13\n5\n12\n11\n9\n3\n10\n9\n9\n13\n13\n5\n6\n11\n3\n15\n8\n8\n10\n13\n7\n6\n4\n14\n9\n10\n5\n13\n4\n1\n8\n6\n13\n1\n3\n4\n9\n12\n2\n7\n3\n3\n7\n2\n2\n9\n2\n4\n2\n2\n11\n12\n15\n13\n6\n2\n11\n1\n8\n3\n13\n6\n15\n6\n4\n3\n4\n15\n15\n9\n5\n8\n3\n6\n14\n14\n5\n9\n4\n4\n14\n1\n12\n4\n12\n9\n11\n7\n4\n2\n5\n4\n4\n13\n13\n4\n5\n8\n3\n4\n2\n15\n3\n10\n9\n8\n12\n8",
"output": "20"
},
{
"input": "2 2 2\n2\n1",
"output": "2"
},
{
"input": "2 2 1\n1\n1",
"output": "2"
},
{
"input": "2 2 2\n2\n2",
"output": "2"
},
{
"input": "3 3 2\n2\n2\n1",
"output": "3"
},
{
"input": "3 3 2\n1\n2\n1",
"output": "3"
},
{
"input": "3 3 2\n2\n1\n2",
"output": "3"
},
{
"input": "3 3 2\n2\n1\n1",
"output": "3"
},
{
"input": "3 3 1\n1\n1\n1",
"output": "3"
},
{
"input": "3 6 3\n2\n2\n3\n3\n1\n1",
"output": "5"
},
{
"input": "3 6 3\n2\n2\n1\n1\n3\n3",
"output": "3"
},
{
"input": "3 6 3\n3\n3\n2\n2\n1\n1",
"output": "3"
},
{
"input": "4 4 2\n1\n2\n2\n1",
"output": "4"
},
{
"input": "4 4 2\n1\n2\n1\n2",
"output": "4"
},
{
"input": "4 4 2\n2\n2\n2\n1",
"output": "4"
},
{
"input": "4 8 3\n2\n1\n2\n1\n2\n1\n1\n1",
"output": "4"
},
{
"input": "4 8 3\n3\n2\n3\n2\n3\n2\n3\n1",
"output": "6"
},
{
"input": "4 8 3\n2\n3\n2\n3\n3\n3\n3\n1",
"output": "6"
},
{
"input": "4 8 4\n2\n3\n2\n3\n2\n3\n2\n3",
"output": "4"
},
{
"input": "4 8 4\n3\n4\n3\n3\n4\n4\n1\n2",
"output": "7"
},
{
"input": "10 100 20\n4\n1\n15\n2\n11\n1\n18\n9\n17\n5\n17\n12\n20\n6\n14\n19\n20\n3\n6\n14\n12\n17\n17\n10\n11\n8\n6\n6\n19\n16\n20\n6\n14\n5\n6\n19\n16\n11\n12\n1\n18\n10\n20\n8\n6\n12\n18\n16\n9\n10\n13\n17\n19\n7\n15\n7\n11\n1\n9\n10\n12\n5\n4\n16\n5\n7\n9\n15\n14\n20\n6\n3\n12\n10\n3\n6\n1\n16\n15\n18\n6\n19\n4\n17\n15\n15\n2\n6\n18\n12\n20\n10\n5\n13\n9\n11\n20\n20\n4\n16",
"output": "20"
},
{
"input": "10 100 20\n11\n11\n11\n11\n11\n11\n11\n11\n11\n10\n10\n10\n10\n10\n10\n10\n10\n10\n9\n9\n9\n9\n9\n9\n9\n9\n9\n8\n8\n8\n8\n8\n8\n8\n8\n8\n7\n7\n7\n7\n7\n7\n7\n7\n7\n6\n6\n6\n6\n6\n6\n6\n6\n6\n5\n5\n5\n5\n5\n5\n5\n5\n5\n4\n4\n4\n4\n4\n4\n4\n4\n4\n3\n3\n3\n3\n3\n3\n3\n3\n3\n2\n2\n2\n2\n2\n2\n2\n2\n2\n1\n1\n1\n1\n1\n1\n1\n1\n1\n12",
"output": "10"
}
] | 31 | 0 | 0 | 54,120 |
|
524 | ΠΠΎΠ·ΠΌΠΎΠΆΠ½ΠΎ, Π²Ρ Π·Π½Π°Π΅ΡΠ΅ ΡΡΠΈΡ
Π»ΡΠ΄Π΅ΠΉ? | [
"implementation"
] | null | null | ΠΡΠ½ΠΎΠ²ΠΎΠΉ Π»ΡΠ±ΠΎΠΉ ΡΠΎΡΠΈΠ°Π»ΡΠ½ΠΎΠΉ ΡΠ΅ΡΠΈ ΡΠ²Π»ΡΠ΅ΡΡΡ ΠΎΡΠ½ΠΎΡΠ΅Π½ΠΈΠ΅ Π΄ΡΡΠΆΠ±Ρ ΠΌΠ΅ΠΆΠ΄Ρ Π΄Π²ΡΠΌΡ ΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΠ΅Π»ΡΠΌΠΈ Π² ΡΠΎΠΌ ΠΈΠ»ΠΈ ΠΈΠ½ΠΎΠΌ ΡΠΌΡΡΠ»Π΅. Π ΠΎΠ΄Π½ΠΎΠΉ ΠΈΠ·Π²Π΅ΡΡΠ½ΠΎΠΉ ΡΠΎΡΠΈΠ°Π»ΡΠ½ΠΎΠΉ ΡΠ΅ΡΠΈ Π΄ΡΡΠΆΠ±Π° ΡΠΈΠΌΠΌΠ΅ΡΡΠΈΡΠ½Π°, ΡΠΎ Π΅ΡΡΡ Π΅ΡΠ»ΠΈ *a* ΡΠ²Π»ΡΠ΅ΡΡΡ Π΄ΡΡΠ³ΠΎΠΌ *b*, ΡΠΎ *b* ΡΠ°ΠΊΠΆΠ΅ ΡΠ²Π»ΡΠ΅ΡΡΡ Π΄ΡΡΠ³ΠΎΠΌ *a*.
Π ΡΡΠΎΠΉ ΠΆΠ΅ ΡΠ΅ΡΠΈ Π΅ΡΡΡ ΡΡΠ½ΠΊΡΠΈΡ, ΠΊΠΎΡΠΎΡΠ°Ρ Π΄Π΅ΠΌΠΎΠ½ΡΡΡΠΈΡΡΠ΅Ρ ΠΌΠ½ΠΎΠΆΠ΅ΡΡΠ²ΠΎ Π»ΡΠ΄Π΅ΠΉ, ΠΈΠΌΠ΅ΡΡΠΈΡ
Π²ΡΡΠΎΠΊΡΡ Π²Π΅ΡΠΎΡΡΠ½ΠΎΡΡΡ Π±ΡΡΡ Π·Π½Π°ΠΊΠΎΠΌΡΠΌΠΈ Π΄Π»Ρ ΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΠ΅Π»Ρ. ΠΡΠ° ΡΡΠ½ΠΊΡΠΈΡ ΡΠ°Π±ΠΎΡΠ°Π΅Ρ ΡΠ»Π΅Π΄ΡΡΡΠΈΠΌ ΠΎΠ±ΡΠ°Π·ΠΎΠΌ. ΠΠ°ΡΠΈΠΊΡΠΈΡΡΠ΅ΠΌ ΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΠ΅Π»Ρ *x*. ΠΡΡΡΡ Π½Π΅ΠΊΠΎΡΠΎΡΡΠΉ Π΄ΡΡΠ³ΠΎΠΉ ΡΠ΅Π»ΠΎΠ²Π΅ΠΊ *y*, Π½Π΅ ΡΠ²Π»ΡΡΡΠΈΠΉΡΡ Π΄ΡΡΠ³ΠΎΠΌ *x* Π½Π° ΡΠ΅ΠΊΡΡΠΈΠΉ ΠΌΠΎΠΌΠ΅Π½Ρ, ΡΠ²Π»ΡΠ΅ΡΡΡ Π΄ΡΡΠ³ΠΎΠΌ Π½Π΅ ΠΌΠ΅Π½Π΅Π΅, ΡΠ΅ΠΌ Π΄Π»Ρ *k*% Π΄ΡΡΠ·Π΅ΠΉ *x*. Π’ΠΎΠ³Π΄Π° ΠΎΠ½ ΡΠ²Π»ΡΠ΅ΡΡΡ ΠΏΡΠ΅Π΄ΠΏΠΎΠ»Π°Π³Π°Π΅ΠΌΡΠΌ Π΄ΡΡΠ³ΠΎΠΌ Π΄Π»Ρ *x*.
Π£ ΠΊΠ°ΠΆΠ΄ΠΎΠ³ΠΎ ΡΠ΅Π»ΠΎΠ²Π΅ΠΊΠ° Π² ΡΠΎΡΠΈΠ°Π»ΡΠ½ΠΎΠΉ ΡΠ΅ΡΠΈ Π΅ΡΡΡ ΡΠ²ΠΎΠΉ ΡΠ½ΠΈΠΊΠ°Π»ΡΠ½ΡΠΉ ΠΈΠ΄Π΅Π½ΡΠΈΡΠΈΠΊΠ°ΡΠΎΡ β ΡΡΠΎ ΡΠ΅Π»ΠΎΠ΅ ΡΠΈΡΠ»ΠΎ ΠΎΡ 1 Π΄ΠΎ 109. ΠΠ°ΠΌ Π΄Π°Π½ ΡΠΏΠΈΡΠΎΠΊ ΠΏΠ°Ρ ΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΠ΅Π»Π΅ΠΉ, ΡΠ²Π»ΡΡΡΠΈΡ
ΡΡ Π΄ΡΡΠ·ΡΡΠΌΠΈ. ΠΠΏΡΠ΅Π΄Π΅Π»ΠΈΡΠ΅ Π΄Π»Ρ ΠΊΠ°ΠΆΠ΄ΠΎΠ³ΠΎ ΡΠΏΠΎΠΌΡΠ½ΡΡΠΎΠ³ΠΎ ΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΠ΅Π»Ρ ΠΌΠ½ΠΎΠΆΠ΅ΡΡΠ²ΠΎ Π΅Π³ΠΎ ΠΏΡΠ΅Π΄ΠΏΠΎΠ»Π°Π³Π°Π΅ΠΌΡΡ
Π΄ΡΡΠ·Π΅ΠΉ. | Π ΠΏΠ΅ΡΠ²ΠΎΠΉ ΡΡΡΠΎΠΊΠ΅ ΡΠ»Π΅Π΄ΡΡΡ Π΄Π²Π° ΡΠ΅Π»ΡΡ
ΡΠΈΡΠ»Π° *m* ΠΈ *k* (1<=β€<=*m*<=β€<=100, 0<=β€<=*k*<=β€<=100) β ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΠΏΠ°Ρ Π΄ΡΡΠ·Π΅ΠΉ ΠΈ Π½Π΅ΠΎΠ±Ρ
ΠΎΠ΄ΠΈΠΌΡΠΉ ΠΏΡΠΎΡΠ΅Π½Ρ ΠΎΠ±ΡΠΈΡ
Π΄ΡΡΠ·Π΅ΠΉ Π΄Π»Ρ ΡΠΎΠ³ΠΎ, ΡΡΠΎΠ±Ρ ΡΡΠΈΡΠ°ΡΡΡΡ ΠΏΡΠ΅Π΄ΠΏΠΎΠ»Π°Π³Π°Π΅ΠΌΡΠΌ Π΄ΡΡΠ³ΠΎΠΌ.
Π ΠΏΠΎΡΠ»Π΅Π΄ΡΡΡΠΈΡ
*m* ΡΡΡΠΎΠΊΠ°Ρ
Π·Π°ΠΏΠΈΡΠ°Π½ΠΎ ΠΏΠΎ Π΄Π²Π° ΡΠΈΡΠ»Π° *a**i*,<=*b**i* (1<=β€<=*a**i*,<=*b**i*<=β€<=109, *a**i*<=β <=*b**i*), ΠΎΠ±ΠΎΠ·Π½Π°ΡΠ°ΡΡΠΈΡ
ΠΈΠ΄Π΅Π½ΡΠΈΡΠΈΠΊΠ°ΡΠΎΡΡ ΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΠ΅Π»Π΅ΠΉ, ΡΠ²Π»ΡΡΡΠΈΡ
ΡΡ Π΄ΡΡΠ·ΡΡΠΌΠΈ.
ΠΠ°ΡΠ°Π½ΡΠΈΡΡΠ΅ΡΡΡ, ΡΡΠΎ ΠΊΠ°ΠΆΠ΄Π°Ρ ΠΏΠ°ΡΠ° Π»ΡΠ΄Π΅ΠΉ ΡΠΈΠ³ΡΡΠΈΡΡΠ΅Ρ Π² ΡΠΏΠΈΡΠΊΠ΅ Π½Π΅ Π±ΠΎΠ»Π΅Π΅ ΠΎΠ΄Π½ΠΎΠ³ΠΎ ΡΠ°Π·Π°. | ΠΠ»Ρ Π²ΡΠ΅Ρ
ΡΠΏΠΎΠΌΡΠ½ΡΡΡΡ
Π»ΡΠ΄Π΅ΠΉ Π² ΠΏΠΎΡΡΠ΄ΠΊΠ΅ Π²ΠΎΠ·ΡΠ°ΡΡΠ°Π½ΠΈΡ id Π²ΡΠ²Π΅Π΄ΠΈΡΠ΅ ΠΈΠ½ΡΠΎΡΠΌΠ°ΡΠΈΡ ΠΎ ΠΏΡΠ΅Π΄ΠΏΠΎΠ»Π°Π³Π°Π΅ΠΌΡΡ
Π΄ΡΡΠ·ΡΡΡ
. ΠΠ½ΡΠΎΡΠΌΠ°ΡΠΈΡ Π΄ΠΎΠ»ΠΆΠ½Π° ΠΈΠΌΠ΅ΡΡ Π²ΠΈΠ΄ "*id*:<=Β *k*Β *id*1Β *id*2Β ...Β *id**k*", Π³Π΄Π΅ *id* β ΡΡΠΎ id ΡΠ°ΠΌΠΎΠ³ΠΎ ΡΠ΅Π»ΠΎΠ²Π΅ΠΊΠ°, *k* β ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ Π΅Π³ΠΎ ΠΏΡΠ΅Π΄ΠΏΠΎΠ»Π°Π³Π°Π΅ΠΌΡΡ
Π΄ΡΡΠ·Π΅ΠΉ, Π° *id*1, *id*2, ..., *id**k* β ΠΈΠ΄Π΅Π½ΡΠΈΡΠΈΠΊΠ°ΡΠΎΡΡ Π΅Π³ΠΎ ΠΏΡΠ΅Π΄ΠΏΠΎΠ»Π°Π³Π°Π΅ΠΌΡΡ
Π΄ΡΡΠ·Π΅ΠΉ Π² Π²ΠΎΠ·ΡΠ°ΡΡΠ°ΡΡΠ΅ΠΌ ΠΏΠΎΡΡΠ΄ΠΊΠ΅. | [
"5 51\n10 23\n23 42\n39 42\n10 39\n39 58\n",
"5 100\n1 2\n1 3\n1 4\n2 3\n2 4\n"
] | [
"10: 1 42\n23: 1 39\n39: 1 23\n42: 1 10\n58: 2 10 42\n",
"1: 0\n2: 0\n3: 1 4\n4: 1 3\n"
] | none | [
{
"input": "5 51\n10 23\n23 42\n39 42\n10 39\n39 58",
"output": "10: 1 42\n23: 1 39\n39: 1 23\n42: 1 10\n58: 2 10 42"
},
{
"input": "5 100\n1 2\n1 3\n1 4\n2 3\n2 4",
"output": "1: 0\n2: 0\n3: 1 4\n4: 1 3"
},
{
"input": "4 1\n1 2\n1 3\n2 3\n4 5",
"output": "1: 0\n2: 0\n3: 0\n4: 0\n5: 0"
},
{
"input": "10 0\n648169314 459970755\n973677547 255163231\n982998000 498743911\n959912791 891928\n404623428 891928\n474720235 271683165\n709045873 539751127\n973677547 179588015\n629049356 622519100\n624998275 958914560",
"output": "891928: 15 179588015 255163231 271683165 459970755 474720235 498743911 539751127 622519100 624998275 629049356 648169314 709045873 958914560 973677547 982998000\n179588015: 16 891928 255163231 271683165 404623428 459970755 474720235 498743911 539751127 622519100 624998275 629049356 648169314 709045873 958914560 959912791 982998000\n255163231: 16 891928 179588015 271683165 404623428 459970755 474720235 498743911 539751127 622519100 624998275 629049356 648169314 709045873 958914560 959912791 982998000\n27168..."
},
{
"input": "10 100\n60976680 603454792\n575754027 696647370\n7534463 570826751\n117972518 472387015\n35713567 439985965\n439985965 928160845\n443596853 828504858\n689509731 117972518\n909843480 592765058\n251752353 490387136",
"output": "7534463: 0\n35713567: 1 928160845\n60976680: 0\n117972518: 0\n251752353: 0\n439985965: 0\n443596853: 0\n472387015: 1 689509731\n490387136: 0\n570826751: 0\n575754027: 0\n592765058: 0\n603454792: 0\n689509731: 1 472387015\n696647370: 0\n828504858: 0\n909843480: 0\n928160845: 1 35713567"
},
{
"input": "10 50\n389900784 512305545\n839319681 243581524\n653226215 616982889\n448655722 826601897\n681021965 23289895\n719595063 481480420\n919744525 839319681\n231872856 784056465\n971842495 248017394\n653226215 297224467",
"output": "23289895: 0\n231872856: 0\n243581524: 1 919744525\n248017394: 0\n297224467: 1 616982889\n389900784: 0\n448655722: 0\n481480420: 0\n512305545: 0\n616982889: 1 297224467\n653226215: 0\n681021965: 0\n719595063: 0\n784056465: 0\n826601897: 0\n839319681: 0\n919744525: 1 243581524\n971842495: 0"
},
{
"input": "10 0\n180745113 666631448\n362104151 349631376\n214251560 538865550\n562805929 576329835\n64121410 646478528\n283223383 861810719\n773038401 214251560\n64208401 693054606\n493180926 960545197\n159614568 831490031",
"output": "64121410: 17 64208401 159614568 180745113 214251560 283223383 349631376 362104151 493180926 538865550 562805929 576329835 666631448 693054606 773038401 831490031 861810719 960545197\n64208401: 17 64121410 159614568 180745113 214251560 283223383 349631376 362104151 493180926 538865550 562805929 576329835 646478528 666631448 773038401 831490031 861810719 960545197\n159614568: 17 64121410 64208401 180745113 214251560 283223383 349631376 362104151 493180926 538865550 562805929 576329835 646478528 666631448 693..."
},
{
"input": "10 50\n946010975 207263044\n923545573 749203275\n862015642 426425906\n749203275 839134958\n910721783 289091881\n827003531 333726912\n49704846 538788252\n382891592 207263044\n333726912 438209022\n974360048 49704846",
"output": "49704846: 0\n207263044: 0\n289091881: 0\n333726912: 0\n382891592: 1 946010975\n426425906: 0\n438209022: 1 827003531\n538788252: 1 974360048\n749203275: 0\n827003531: 1 438209022\n839134958: 1 923545573\n862015642: 0\n910721783: 0\n923545573: 1 839134958\n946010975: 1 382891592\n974360048: 1 538788252"
},
{
"input": "10 100\n570936669 651631651\n508122950 793810569\n374422919 757639639\n395046911 359158844\n544971368 55608511\n554227847 109843524\n199021332 421407912\n82125712 395046911\n923097829 637659245\n754413496 971876441",
"output": "55608511: 0\n82125712: 1 359158844\n109843524: 0\n199021332: 0\n359158844: 1 82125712\n374422919: 0\n395046911: 0\n421407912: 0\n508122950: 0\n544971368: 0\n554227847: 0\n570936669: 0\n637659245: 0\n651631651: 0\n754413496: 0\n757639639: 0\n793810569: 0\n923097829: 0\n971876441: 0"
},
{
"input": "1 0\n42 23",
"output": "23: 0\n42: 0"
},
{
"input": "1 1\n42 23",
"output": "23: 0\n42: 0"
},
{
"input": "1 50\n42 23",
"output": "23: 0\n42: 0"
},
{
"input": "1 99\n42 23",
"output": "23: 0\n42: 0"
},
{
"input": "1 100\n42 23",
"output": "23: 0\n42: 0"
},
{
"input": "2 49\n42 23\n23 14",
"output": "14: 1 42\n23: 0\n42: 1 14"
},
{
"input": "2 50\n42 23\n23 19",
"output": "19: 1 42\n23: 0\n42: 1 19"
},
{
"input": "2 51\n42 23\n23 19",
"output": "19: 1 42\n23: 0\n42: 1 19"
},
{
"input": "3 49\n42 23\n23 19\n32 23",
"output": "19: 2 32 42\n23: 0\n32: 2 19 42\n42: 2 19 32"
},
{
"input": "3 50\n42 23\n23 19\n32 23",
"output": "19: 2 32 42\n23: 0\n32: 2 19 42\n42: 2 19 32"
},
{
"input": "3 51\n42 23\n23 19\n32 23",
"output": "19: 2 32 42\n23: 0\n32: 2 19 42\n42: 2 19 32"
},
{
"input": "10 50\n642733947 618790811\n508838679 118350938\n175990043 144671010\n246628250 434416712\n77433126 913934904\n414906480 399777199\n252618318 930317425\n316103842 356219969\n530311152 441130575\n15047025 839165125",
"output": "15047025: 0\n77433126: 0\n118350938: 0\n144671010: 0\n175990043: 0\n246628250: 0\n252618318: 0\n316103842: 0\n356219969: 0\n399777199: 0\n414906480: 0\n434416712: 0\n441130575: 0\n508838679: 0\n530311152: 0\n618790811: 0\n642733947: 0\n839165125: 0\n913934904: 0\n930317425: 0"
},
{
"input": "10 0\n106531296 450097353\n947110486 953723914\n774225709 111023810\n774225709 642354614\n559826213 258125349\n768234906 870027419\n4234645 388060649\n870027419 545107061\n484961505 497401821\n76024092 367527096",
"output": "4234645: 16 76024092 106531296 111023810 258125349 367527096 450097353 484961505 497401821 545107061 559826213 642354614 768234906 774225709 870027419 947110486 953723914\n76024092: 16 4234645 106531296 111023810 258125349 388060649 450097353 484961505 497401821 545107061 559826213 642354614 768234906 774225709 870027419 947110486 953723914\n106531296: 16 4234645 76024092 111023810 258125349 367527096 388060649 484961505 497401821 545107061 559826213 642354614 768234906 774225709 870027419 947110486 953723..."
},
{
"input": "10 50\n384319275 425419607\n201879842 153061155\n308316219 268723666\n20837191 401468340\n969142307 78803322\n55247385 365896022\n479817129 222255243\n980789245 697120853\n550086907 652472194\n203728124 229637404",
"output": "20837191: 0\n55247385: 0\n78803322: 0\n153061155: 0\n201879842: 0\n203728124: 0\n222255243: 0\n229637404: 0\n268723666: 0\n308316219: 0\n365896022: 0\n384319275: 0\n401468340: 0\n425419607: 0\n479817129: 0\n550086907: 0\n652472194: 0\n697120853: 0\n969142307: 0\n980789245: 0"
},
{
"input": "10 100\n620468113 665248777\n541840309 963681159\n144393749 136223789\n800116851 648535048\n730845154 277782209\n142473309 2838660\n14940106 355463174\n745034887 545886019\n570717131 701899093\n250611530 857683655",
"output": "2838660: 0\n14940106: 0\n136223789: 0\n142473309: 0\n144393749: 0\n250611530: 0\n277782209: 0\n355463174: 0\n541840309: 0\n545886019: 0\n570717131: 0\n620468113: 0\n648535048: 0\n665248777: 0\n701899093: 0\n730845154: 0\n745034887: 0\n800116851: 0\n857683655: 0\n963681159: 0"
},
{
"input": "5 66\n4242 1\n4242 2\n4242 3\n2323 1\n2323 2",
"output": "1: 1 2\n2: 1 1\n3: 2 1 2\n2323: 1 4242\n4242: 1 2323"
},
{
"input": "5 67\n4242 1\n4242 2\n4242 3\n2323 1\n2323 2",
"output": "1: 1 2\n2: 1 1\n3: 2 1 2\n2323: 1 4242\n4242: 0"
},
{
"input": "6 49\n4242 1\n4242 2\n4242 3\n4242 4\n2323 1\n2323 2",
"output": "1: 3 2 3 4\n2: 3 1 3 4\n3: 3 1 2 4\n4: 3 1 2 3\n2323: 1 4242\n4242: 1 2323"
},
{
"input": "6 50\n4242 1\n4242 2\n4242 3\n4242 4\n2323 1\n2323 2",
"output": "1: 3 2 3 4\n2: 3 1 3 4\n3: 3 1 2 4\n4: 3 1 2 3\n2323: 1 4242\n4242: 1 2323"
},
{
"input": "6 51\n4242 1\n4242 2\n4242 3\n4242 4\n2323 1\n2323 2",
"output": "1: 1 2\n2: 1 1\n3: 3 1 2 4\n4: 3 1 2 3\n2323: 1 4242\n4242: 0"
},
{
"input": "11 12\n4242 1\n4242 2\n4242 3\n4242 4\n4242 5\n4242 6\n4242 7\n4242 8\n2323 1\n2323 2\n2323 3",
"output": "1: 7 2 3 4 5 6 7 8\n2: 7 1 3 4 5 6 7 8\n3: 7 1 2 4 5 6 7 8\n4: 7 1 2 3 5 6 7 8\n5: 7 1 2 3 4 6 7 8\n6: 7 1 2 3 4 5 7 8\n7: 7 1 2 3 4 5 6 8\n8: 7 1 2 3 4 5 6 7\n2323: 1 4242\n4242: 1 2323"
},
{
"input": "11 13\n4242 1\n4242 2\n4242 3\n4242 4\n4242 5\n4242 6\n4242 7\n4242 8\n2323 1\n2323 2\n2323 3",
"output": "1: 7 2 3 4 5 6 7 8\n2: 7 1 3 4 5 6 7 8\n3: 7 1 2 4 5 6 7 8\n4: 7 1 2 3 5 6 7 8\n5: 7 1 2 3 4 6 7 8\n6: 7 1 2 3 4 5 7 8\n7: 7 1 2 3 4 5 6 8\n8: 7 1 2 3 4 5 6 7\n2323: 1 4242\n4242: 1 2323"
},
{
"input": "79 58\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n2 3\n2 4\n2 5\n2 6\n2 7\n2 8\n2 9\n2 10\n2 11\n2 12\n2 13\n2 14\n2 15\n2 16\n2 17\n2 18\n2 19\n2 20\n2 21\n2 22\n2 23\n2 24\n2 25\n2 26\n2 27\n2 28\n2 29\n2 30\n2 31",
"output": "1: 1 2\n2: 1 1\n3: 28 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31\n4: 28 3 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31\n5: 28 3 4 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31\n6: 28 3 4 5 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31\n7: 28 3 4 5 6 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31\n8: 28 3 4 5 6 7 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 2..."
}
] | 93 | 0 | -1 | 54,190 |
|
203 | Hit Ball | [
"geometry",
"implementation",
"math"
] | null | null | When Valera was playing football on a stadium, it suddenly began to rain. Valera hid in the corridor under the grandstand not to get wet. However, the desire to play was so great that he decided to train his hitting the ball right in this corridor. Valera went back far enough, put the ball and hit it. The ball bounced off the walls, the ceiling and the floor corridor and finally hit the exit door. As the ball was wet, it left a spot on the door. Now Valera wants to know the coordinates for this spot.
Let's describe the event more formally. The ball will be considered a point in space. The door of the corridor will be considered a rectangle located on plane *xOz*, such that the lower left corner of the door is located at point (0,<=0,<=0), and the upper right corner is located at point (*a*,<=0,<=*b*) . The corridor will be considered as a rectangular parallelepiped, infinite in the direction of increasing coordinates of *y*. In this corridor the floor will be considered as plane *xOy*, and the ceiling as plane, parallel to *xOy* and passing through point (*a*,<=0,<=*b*). We will also assume that one of the walls is plane *yOz*, and the other wall is plane, parallel to *yOz* and passing through point (*a*,<=0,<=*b*).
We'll say that the ball hit the door when its coordinate *y* was equal to 0. Thus the coordinates of the spot are point (*x*0,<=0,<=*z*0), where 0<=β€<=*x*0<=β€<=*a*,<=0<=β€<=*z*0<=β€<=*b*. To hit the ball, Valera steps away from the door at distance *m* and puts the ball in the center of the corridor at point . After the hit the ball flies at speed (*v**x*,<=*v**y*,<=*v**z*). This means that if the ball has coordinates (*x*,<=*y*,<=*z*), then after one second it will have coordinates (*x*<=+<=*v**x*,<=*y*<=+<=*v**y*,<=*z*<=+<=*v**z*).
See image in notes for clarification.
When the ball collides with the ceiling, the floor or a wall of the corridor, it bounces off in accordance with the laws of reflection (the angle of incidence equals the angle of reflection). In the problem we consider the ideal physical model, so we can assume that there is no air resistance, friction force, or any loss of energy. | The first line contains three space-separated integers *a*,<=*b*,<=*m* (1<=β€<=*a*,<=*b*,<=*m*<=β€<=100). The first two integers specify point (*a*,<=0,<=*b*), through which the ceiling and one of the corridor walls pass. The third integer is the distance at which Valera went away from the door.
The second line has three space-separated integers *v**x*,<=*v**y*,<=*v**z* (|*v**x*|,<=|*v**y*|,<=|*v**z*|<=β€<=100,<=*v**y*<=<<=0,<=*v**z*<=β₯<=0) β the speed of the ball after the hit.
It is guaranteed that the ball hits the door. | Print two real numbers *x*0,<=*z*0 β the *x* and *z* coordinates of point (*x*0,<=0,<=*z*0), at which the ball hits the exit door. The answer will be considered correct, if its absolute or relative error does not exceed 10<=<=-<=6. | [
"7 2 11\n3 -11 2\n",
"7 2 11\n4 -3 3\n"
] | [
"6.5000000000 2.0000000000\n",
"4.1666666667 1.0000000000\n"
] | <img class="tex-graphics" src="https://espresso.codeforces.com/0b96c99a50a7ff8657d6301992a0fe440badfb7b.png" style="max-width: 100.0%;max-height: 100.0%;"/> | [
{
"input": "7 2 11\n3 -11 2",
"output": "6.5000000000 2.0000000000"
},
{
"input": "7 2 11\n4 -3 3",
"output": "4.1666666667 1.0000000000"
},
{
"input": "44 94 98\n-17 -64 9",
"output": "4.0312500000 13.7812500000"
},
{
"input": "41 4 58\n81 -9 65",
"output": "31.5000000000 2.8888888889"
},
{
"input": "98 11 74\n79 -66 76",
"output": "58.4242424242 2.7878787879"
},
{
"input": "7 21 86\n1 -19 20",
"output": "5.9736842105 6.5263157895"
},
{
"input": "4 27 2\n-52 -64 31",
"output": "0.3750000000 0.9687500000"
},
{
"input": "8 89 62\n47 -18 53",
"output": "5.8888888889 4.5555555556"
},
{
"input": "57 7 78\n-31 -63 98",
"output": "9.8809523810 4.6666666667"
},
{
"input": "62 14 94\n-33 -20 8",
"output": "0.1000000000 9.6000000000"
},
{
"input": "59 24 6\n65 -73 53",
"output": "34.8424657534 4.3561643836"
},
{
"input": "28 7 59\n83 -44 80",
"output": "13.2954545455 4.7272727273"
},
{
"input": "24 26 75\n80 -97 58",
"output": "22.1443298969 7.1546391753"
},
{
"input": "33 32 87\n-22 -47 2",
"output": "24.2234042553 3.7021276596"
},
{
"input": "30 42 51\n0 -100 57",
"output": "15.0000000000 29.0700000000"
},
{
"input": "87 4 63\n49 -53 68",
"output": "72.2547169811 0.8301886792"
},
{
"input": "84 10 79\n-54 -98 12",
"output": "1.5306122449 9.6734693878"
},
{
"input": "89 20 95\n-32 -52 23",
"output": "13.9615384615 2.0192307692"
},
{
"input": "45 35 55\n67 -9 79",
"output": "18.0555555556 7.2222222222"
},
{
"input": "42 45 71\n64 -54 89",
"output": "21.1481481481 27.0185185185"
},
{
"input": "90 42 17\n8 -17 70",
"output": "53.0000000000 14.0000000000"
},
{
"input": "86 1 77\n5 -70 48",
"output": "48.5000000000 0.8000000000"
},
{
"input": "43 19 93\n-72 -19 93",
"output": "13.0789473684 0.7894736842"
},
{
"input": "48 25 5\n26 -73 2",
"output": "25.7808219178 0.1369863014"
},
{
"input": "45 35 21\n23 -66 58",
"output": "29.8181818182 18.4545454545"
},
{
"input": "2 45 85\n-54 -19 2",
"output": "0.5789473684 8.9473684211"
},
{
"input": "98 4 97\n-57 -72 13",
"output": "27.7916666667 1.5138888889"
},
{
"input": "3 14 13\n42 -22 58",
"output": "2.3181818182 6.2727272727"
},
{
"input": "4 28 25\n-86 -75 68",
"output": "2.6666666667 22.6666666667"
},
{
"input": "46 9 34\n88 -31 94",
"output": "27.5161290323 4.9032258065"
},
{
"input": "1 1 1\n0 -1 0",
"output": "0.5000000000 0.0000000000"
},
{
"input": "100 100 100\n100 -1 100",
"output": "50.0000000000 0.0000000000"
},
{
"input": "15 73 20\n15 -66 11",
"output": "12.0454545455 3.3333333333"
},
{
"input": "1 1 1\n0 -100 100",
"output": "0.5000000000 1.0000000000"
},
{
"input": "1 1 1\n100 -100 0",
"output": "0.5000000000 0.0000000000"
},
{
"input": "100 100 1\n-100 -1 0",
"output": "50.0000000000 0.0000000000"
},
{
"input": "100 100 77\n-14 -100 100",
"output": "39.2200000000 77.0000000000"
},
{
"input": "68 39 46\n-31 -37 3",
"output": "4.5405405405 3.7297297297"
},
{
"input": "17 45 6\n-9 -94 48",
"output": "7.9255319149 3.0638297872"
},
{
"input": "7 34 67\n-36 -47 28",
"output": "5.8191489362 28.0851063830"
}
] | 92 | 0 | 0 | 54,224 |
|
703 | Chris and Road | [
"geometry",
"implementation"
] | null | null | And while Mishka is enjoying her trip...
Chris is a little brown bear. No one knows, where and when he met Mishka, but for a long time they are together (excluding her current trip). However, best friends are important too. John is Chris' best friend.
Once walking with his friend, John gave Chris the following problem:
At the infinite horizontal road of width *w*, bounded by lines *y*<==<=0 and *y*<==<=*w*, there is a bus moving, presented as a convex polygon of *n* vertices. The bus moves continuously with a constant speed of *v* in a straight *Ox* line in direction of decreasing *x* coordinates, thus in time only *x* coordinates of its points are changing. Formally, after time *t* each of *x* coordinates of its points will be decreased by *vt*.
There is a pedestrian in the point (0,<=0), who can move only by a vertical pedestrian crossing, presented as a segment connecting points (0,<=0) and (0,<=*w*) with any speed not exceeding *u*. Thus the pedestrian can move only in a straight line *Oy* in any direction with any speed not exceeding *u* and not leaving the road borders. The pedestrian can instantly change his speed, thus, for example, he can stop instantly.
Please look at the sample note picture for better understanding.
We consider the pedestrian is hit by the bus, if at any moment the point he is located in lies strictly inside the bus polygon (this means that if the point lies on the polygon vertex or on its edge, the pedestrian is not hit by the bus).
You are given the bus position at the moment 0. Please help Chris determine minimum amount of time the pedestrian needs to cross the road and reach the point (0,<=*w*) and not to be hit by the bus. | The first line of the input contains four integers *n*, *w*, *v*, *u* (3<=β€<=*n*<=β€<=10<=000, 1<=β€<=*w*<=β€<=109, 1<=β€<=*v*,<=<=*u*<=β€<=1000)Β β the number of the bus polygon vertices, road width, bus speed and pedestrian speed respectively.
The next *n* lines describes polygon vertices in counter-clockwise order. *i*-th of them contains pair of integers *x**i* and *y**i* (<=-<=109<=β€<=*x**i*<=β€<=109, 0<=β€<=*y**i*<=β€<=*w*)Β β coordinates of *i*-th polygon point. It is guaranteed that the polygon is non-degenerate. | Print the single real *t*Β β the time the pedestrian needs to croos the road and not to be hit by the bus. The answer is considered correct if its relative or absolute error doesn't exceed 10<=-<=6. | [
"5 5 1 2\n1 2\n3 1\n4 3\n3 4\n1 4\n"
] | [
"5.0000000000"
] | Following image describes initial position in the first sample case:
<img class="tex-graphics" src="https://espresso.codeforces.com/6d0966ee3194a0c11a228fa83f19a00157de89f7.png" style="max-width: 100.0%;max-height: 100.0%;"/> | [
{
"input": "5 5 1 2\n1 2\n3 1\n4 3\n3 4\n1 4",
"output": "5.0000000000"
},
{
"input": "3 3 5 2\n3 1\n4 0\n5 1",
"output": "1.5000000000"
},
{
"input": "3 3 2 4\n0 1\n2 1\n1 2",
"output": "1.5000000000"
},
{
"input": "3 3 1 1\n0 0\n1 1\n0 2",
"output": "3.0000000000"
},
{
"input": "9 10 5 2\n22 5\n25 0\n29 0\n31 2\n32 5\n31 8\n29 10\n25 10\n23 8",
"output": "5.0000000000"
},
{
"input": "10 10 2 4\n-4 5\n-3 2\n-1 0\n3 0\n5 2\n6 5\n5 8\n3 10\n-1 10\n-2 9",
"output": "4.5000000000"
},
{
"input": "10 10 1 4\n-1 5\n0 2\n2 0\n5 0\n7 1\n9 5\n8 8\n6 10\n2 10\n0 8",
"output": "10.2500000000"
},
{
"input": "10 10 1 1\n5 5\n7 1\n8 0\n12 0\n14 2\n15 5\n14 8\n12 10\n8 10\n6 8",
"output": "22.0000000000"
},
{
"input": "10 1000 4 5\n-175 23\n-52 1\n129 24\n412 255\n399 767\n218 938\n110 982\n62 993\n-168 979\n-501 650",
"output": "252.0000000000"
},
{
"input": "10 1000 8 4\n1015 375\n1399 10\n1605 11\n1863 157\n1934 747\n1798 901\n1790 907\n1609 988\n1404 991\n1177 883",
"output": "447.8750000000"
},
{
"input": "10 1000 2 8\n-75 224\n-56 197\n0 135\n84 72\n264 6\n643 899\n572 944\n282 996\n110 943\n1 866",
"output": "334.1250000000"
},
{
"input": "10 1000 6 2\n1901 411\n1933 304\n2203 38\n2230 27\n2250 21\n2396 0\n2814 230\n2705 891\n2445 997\n2081 891",
"output": "899.3333333333"
},
{
"input": "10 1000 4 7\n-253 81\n67 2\n341 117\n488 324\n489 673\n380 847\n62 998\n20 1000\n-85 989\n-378 803",
"output": "218.5714285714"
},
{
"input": "10 1000 4 1\n2659 245\n2715 168\n2972 14\n3229 20\n3232 21\n3479 187\n3496 210\n3370 914\n3035 997\n2938 977",
"output": "1787.2500000000"
},
{
"input": "10 1000 2 2\n60 123\n404 0\n619 56\n715 121\n740 144\n614 947\n566 968\n448 997\n300 992\n270 986",
"output": "798.0000000000"
},
{
"input": "10 1000 10 4\n554 284\n720 89\n788 50\n820 35\n924 7\n1324 115\n1309 897\n1063 997\n592 782\n584 770",
"output": "353.6500000000"
},
{
"input": "10 1000 4 8\n-261 776\n-94 67\n-45 42\n23 18\n175 0\n415 72\n258 989\n183 999\n114 998\n-217 833",
"output": "219.7500000000"
},
{
"input": "10 1000 10 2\n2731 286\n3154 1\n3590 210\n3674 406\n3667 625\n3546 844\n3275 991\n3154 999\n2771 783\n2754 757",
"output": "814.9000000000"
},
{
"input": "10 1000 59 381\n131 195\n303 53\n528 0\n546 0\n726 41\n792 76\n917 187\n755 945\n220 895\n124 796",
"output": "2.6246719160"
},
{
"input": "10 1000 519 882\n-407 135\n-222 25\n-211 22\n-168 11\n-90 1\n43 12\n312 828\n175 939\n-174 988\n-329 925",
"output": "1.2030330437"
},
{
"input": "10 1000 787 576\n-126 73\n-20 24\n216 7\n314 34\n312 967\n288 976\n99 999\n-138 920\n-220 853\n-308 734",
"output": "2.0760668149"
},
{
"input": "10 1000 35 722\n320 31\n528 1\n676 34\n979 378\n990 563\n916 768\n613 986\n197 902\n164 876\n34 696",
"output": "1.3850415512"
},
{
"input": "10 1000 791 415\n613 191\n618 185\n999 0\n1023 0\n1084 6\n1162 25\n1306 100\n1351 138\n713 905\n559 724",
"output": "3.8197492879"
},
{
"input": "10 1000 763 109\n-449 324\n-398 224\n-357 170\n45 1\n328 107\n406 183\n428 212\n65 998\n-160 967\n-262 914",
"output": "9.2241153342"
},
{
"input": "10 1000 12 255\n120 71\n847 668\n814 741\n705 877\n698 883\n622 935\n473 991\n176 958\n131 936\n41 871",
"output": "3.9215686275"
},
{
"input": "10 1000 471 348\n-161 383\n339 0\n398 5\n462 19\n606 86\n770 728\n765 737\n747 768\n546 949\n529 956",
"output": "3.9130609854"
},
{
"input": "10 1000 35 450\n259 41\n383 6\n506 2\n552 9\n852 193\n943 383\n908 716\n770 890\n536 994\n28 757",
"output": "28.3139682540"
},
{
"input": "10 1000 750 426\n1037 589\n1215 111\n1545 0\n1616 8\n1729 42\n2026 445\n1964 747\n1904 831\n1763 942\n1757 945",
"output": "2.3474178404"
},
{
"input": "10 1000 505 223\n1564 401\n1689 158\n2078 1\n2428 168\n2477 767\n2424 836\n1929 984\n1906 978\n1764 907\n1723 875",
"output": "8.5946721130"
},
{
"input": "10 1000 774 517\n-252 138\n150 3\n501 211\n543 282\n575 367\n534 736\n382 908\n84 1000\n-78 970\n-344 743",
"output": "2.1733990074"
},
{
"input": "10 1000 22 255\n70 266\n272 61\n328 35\n740 55\n850 868\n550 999\n448 996\n371 980\n302 954\n62 718",
"output": "3.9215686275"
},
{
"input": "10 1000 482 756\n114 363\n190 207\n1016 230\n1039 270\n912 887\n629 999\n514 993\n439 975\n292 898\n266 877",
"output": "3.1264023359"
},
{
"input": "10 1000 750 154\n-154 43\n-134 35\n-41 8\n127 6\n387 868\n179 983\n77 999\n26 999\n-51 990\n-239 909",
"output": "6.6238787879"
},
{
"input": "10 1000 998 596\n1681 18\n2048 59\n2110 98\n2201 185\n2282 327\n2250 743\n2122 893\n1844 999\n1618 960\n1564 934",
"output": "1.6778523490"
},
{
"input": "10 1000 458 393\n826 363\n1241 4\n1402 9\n1441 18\n1800 417\n1804 555\n1248 997\n1207 990\n1116 962\n1029 916",
"output": "5.6450159450"
},
{
"input": "10 1000 430 983\n-206 338\n-86 146\n221 2\n766 532\n531 925\n507 939\n430 973\n369 989\n29 940\n-170 743",
"output": "2.2574889399"
},
{
"input": "5 5 100 2\n1 2\n3 1\n4 3\n3 4\n1 4",
"output": "2.5000000000"
},
{
"input": "3 10 3 2\n1 5\n2 2\n2 8",
"output": "5.0000000000"
}
] | 62 | 0 | 3 | 54,298 |
|
45 | Prime Problem | [
"number theory"
] | G. Prime Problem | 1 | 256 | In Berland prime numbers are fashionable β the respectable citizens dwell only on the floors with numbers that are prime numbers. The numismatists value particularly high the coins with prime nominal values. All the prime days are announced holidays!
Yet even this is not enough to make the Berland people happy. On the main street of the capital stand *n* houses, numbered from 1 to *n*. The government decided to paint every house a color so that the sum of the numbers of the houses painted every color is a prime number.
However it turned out that not all the citizens approve of this decision β many of them protest because they don't want many colored houses on the capital's main street. That's why it is decided to use the minimal possible number of colors. The houses don't have to be painted consecutively, but every one of *n* houses should be painted some color. The one-colored houses should not stand consecutively, any way of painting is acceptable.
There are no more than 5 hours left before the start of painting, help the government find the way when the sum of house numbers for every color is a prime number and the number of used colors is minimal. | The single input line contains an integer *n* (2<=β€<=*n*<=β€<=6000) β the number of houses on the main streets of the capital. | Print the sequence of *n* numbers, where the *i*-th number stands for the number of color for house number *i*. Number the colors consecutively starting from 1. Any painting order is allowed. If there are several solutions to that problem, print any of them. If there's no such way of painting print the single number -1. | [
"8"
] | [
"1 2 2 1 1 1 1 2"
] | none | [
{
"input": "8",
"output": "1 1 1 1 2 1 1 1 "
},
{
"input": "2",
"output": "1 1 "
},
{
"input": "3",
"output": "1 1 2 "
},
{
"input": "4",
"output": "1 1 2 1 "
},
{
"input": "5",
"output": "1 2 1 1 1 "
},
{
"input": "6",
"output": "1 2 1 1 1 1 "
},
{
"input": "7",
"output": "1 1 1 1 2 1 1 "
},
{
"input": "8",
"output": "1 1 1 1 2 1 1 1 "
},
{
"input": "9",
"output": "1 2 1 1 1 1 1 1 1 "
},
{
"input": "10",
"output": "1 2 1 1 1 1 1 1 1 1 "
},
{
"input": "23",
"output": "1 1 1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 "
},
{
"input": "233",
"output": "1 2 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 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 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 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 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": "1009",
"output": "1 2 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 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 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 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 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 1 1 1 1..."
},
{
"input": "2009",
"output": "1 1 2 1 3 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 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 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 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 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 1..."
},
{
"input": "4009",
"output": "1 1 2 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 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 3 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 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 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 1 1 1 1 1..."
},
{
"input": "4509",
"output": "1 1 2 1 1 1 1 1 1 1 1 1 3 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 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 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 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 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": "2539",
"output": "1 1 1 1 1 1 1 1 1 1 2 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 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 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 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 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": "5000",
"output": "1 1 1 1 1 1 2 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 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 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 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 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": "4999",
"output": "1 1 1 1 1 1 1 1 1 1 2 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 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 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 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 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": "4997",
"output": "1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 3 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 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 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 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 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": "5997",
"output": "1 1 2 1 1 1 1 1 1 1 1 1 3 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 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 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 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 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": "5998",
"output": "1 1 2 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 3 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 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 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 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 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": "5999",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 2 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 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 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 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 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": "6000",
"output": "1 1 1 1 1 1 2 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 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 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 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 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": "11",
"output": "1 1 1 1 2 1 1 1 1 1 1 "
},
{
"input": "2109",
"output": "1 1 2 1 3 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 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 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 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 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 1..."
},
{
"input": "4890",
"output": "1 2 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 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 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 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 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 1 1 1 1..."
},
{
"input": "4356",
"output": "1 1 1 1 1 1 2 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 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 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 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 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": "1075",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 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 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 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 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 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": "169",
"output": "1 1 2 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 3 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 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 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": "5792",
"output": "1 1 1 1 1 1 2 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 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 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 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 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": "2244",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 2 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 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 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 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 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": "2757",
"output": "1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 3 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 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 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 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 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": "3769",
"output": "1 2 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 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 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 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 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 1 1 1 1..."
},
{
"input": "3789",
"output": "1 1 2 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 3 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 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 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 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 1 1 1..."
},
{
"input": "3510",
"output": "1 1 2 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 3 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 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 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 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1..."
},
{
"input": "962",
"output": "1 1 2 1 1 1 1 1 1 1 3 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 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 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 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 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": "1834",
"output": "1 2 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 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 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 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 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 1 1 1 1..."
},
{
"input": "5544",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 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 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 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 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 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": "5558",
"output": "1 1 2 1 3 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 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 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 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 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 1..."
},
{
"input": "1005",
"output": "1 2 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 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 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 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 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 1 1 1 1..."
},
{
"input": "3904",
"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 2 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 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 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 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1..."
},
{
"input": "4691",
"output": "1 1 1 1 2 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 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 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 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 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 1..."
},
{
"input": "4998",
"output": "1 2 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 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 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 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 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 1 1 1 1..."
},
{
"input": "4276",
"output": "1 1 1 1 2 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 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 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 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 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 1..."
},
{
"input": "1252",
"output": "1 1 1 1 2 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 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 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 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 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 1..."
},
{
"input": "4447",
"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 2 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 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 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 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 1 1 1 1 1 1 1 1 1..."
},
{
"input": "1927",
"output": "1 1 1 1 1 1 1 1 1 1 2 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 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 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 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 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": "754",
"output": "1 2 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 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 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 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 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 1 1 1 1..."
},
{
"input": "4864",
"output": "1 1 1 1 1 1 1 1 1 1 2 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 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 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 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 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..."
}
] | 60 | 0 | 0 | 54,342 |
958 | Lightsabers (medium) | [
"binary search",
"two pointers"
] | null | null | There is unrest in the Galactic Senate. Several thousand solar systems have declared their intentions to leave the Republic. Master Heidi needs to select the Jedi Knights who will go on peacekeeping missions throughout the galaxy. It is well-known that the success of any peacekeeping mission depends on the colors of the lightsabers of the Jedi who will go on that mission.
Heidi has *n* Jedi Knights standing in front of her, each one with a lightsaber of one of *m* possible colors. She knows that for the mission to be the most effective, she needs to select some contiguous interval of knights such that there are exactly *k*1 knights with lightsabers of the first color, *k*2 knights with lightsabers of the second color, ..., *k**m* knights with lightsabers of the *m*-th color.
However, since the last time, she has learned that it is not always possible to select such an interval. Therefore, she decided to ask some Jedi Knights to go on an indefinite unpaid vacation leave near certain pits on Tatooine, if you know what I mean. Help Heidi decide what is the minimum number of Jedi Knights that need to be let go before she is able to select the desired interval from the subsequence of remaining knights. | The first line of the input contains *n* (1<=β€<=*n*<=β€<=2Β·105) and *m* (1<=β€<=*m*<=β€<=*n*). The second line contains *n* integers in the range {1,<=2,<=...,<=*m*} representing colors of the lightsabers of the subsequent Jedi Knights. The third line contains *m* integers *k*1,<=*k*2,<=...,<=*k**m* (with ) β the desired counts of Jedi Knights with lightsabers of each color from 1 to *m*. | Output one number: the minimum number of Jedi Knights that need to be removed from the sequence so that, in what remains, there is an interval with the prescribed counts of lightsaber colors. If this is not possible, output <=-<=1. | [
"8 3\n3 3 1 2 2 1 1 3\n3 1 1\n"
] | [
"1\n"
] | none | [
{
"input": "8 3\n3 3 1 2 2 1 1 3\n3 1 1",
"output": "1"
},
{
"input": "6 5\n1 2 4 2 4 3\n0 0 1 0 0",
"output": "0"
},
{
"input": "1 1\n1\n1",
"output": "0"
},
{
"input": "2 1\n1 1\n1",
"output": "0"
},
{
"input": "2 1\n1 1\n2",
"output": "0"
},
{
"input": "2 2\n1 2\n1 1",
"output": "0"
},
{
"input": "2 2\n2 2\n1 1",
"output": "-1"
},
{
"input": "3 3\n3 3 2\n0 0 1",
"output": "0"
},
{
"input": "4 4\n4 4 4 4\n0 1 1 1",
"output": "-1"
},
{
"input": "2 2\n1 1\n1 0",
"output": "0"
},
{
"input": "3 3\n3 3 3\n0 0 1",
"output": "0"
},
{
"input": "4 4\n2 4 4 3\n0 1 0 0",
"output": "0"
},
{
"input": "2 2\n2 1\n0 1",
"output": "0"
},
{
"input": "3 3\n3 1 1\n1 1 1",
"output": "-1"
},
{
"input": "4 4\n1 3 1 4\n1 0 0 1",
"output": "0"
},
{
"input": "2 2\n2 1\n1 0",
"output": "0"
},
{
"input": "3 3\n3 1 1\n2 0 0",
"output": "0"
},
{
"input": "4 4\n4 4 2 2\n1 1 1 1",
"output": "-1"
},
{
"input": "2 2\n1 2\n0 2",
"output": "-1"
},
{
"input": "3 3\n3 2 3\n0 2 1",
"output": "-1"
},
{
"input": "4 4\n1 2 4 2\n0 0 1 0",
"output": "-1"
},
{
"input": "4 4\n4 2 1 2\n1 2 0 1",
"output": "0"
},
{
"input": "5 5\n4 4 2 4 2\n0 2 0 3 0",
"output": "0"
},
{
"input": "6 6\n4 3 5 4 5 2\n0 1 0 1 2 0",
"output": "0"
},
{
"input": "4 4\n4 3 3 2\n0 0 2 0",
"output": "0"
},
{
"input": "5 5\n3 4 5 1 4\n1 0 1 1 1",
"output": "0"
},
{
"input": "6 6\n1 1 3 2 2 2\n1 0 0 0 0 0",
"output": "0"
},
{
"input": "4 4\n4 1 1 3\n2 0 0 1",
"output": "0"
},
{
"input": "5 5\n3 4 1 1 5\n2 0 1 1 0",
"output": "0"
},
{
"input": "6 6\n4 3 5 6 5 5\n0 0 1 1 0 0",
"output": "0"
},
{
"input": "4 4\n1 3 4 2\n1 0 0 0",
"output": "0"
},
{
"input": "5 5\n4 1 3 3 3\n0 0 0 1 0",
"output": "0"
},
{
"input": "6 6\n6 2 6 2 5 4\n0 1 0 0 0 1",
"output": "0"
},
{
"input": "4 4\n3 2 1 3\n0 1 0 0",
"output": "0"
},
{
"input": "5 5\n3 4 1 4 2\n1 0 0 1 0",
"output": "0"
},
{
"input": "6 6\n4 1 6 6 3 5\n1 0 1 1 1 2",
"output": "0"
}
] | 436 | 40,448,000 | 3 | 54,466 |
|
566 | Restoring Map | [
"bitmasks",
"constructive algorithms",
"trees"
] | null | null | Archaeologists found some information about an ancient land of Treeland. We know for sure that the Treeland consisted of *n* cities connected by the *n*<=-<=1 road, such that you can get from each city to any other one along the roads. However, the information about the specific design of roads in Treeland has been lost. The only thing that the archaeologists can use is the preserved information about near cities.
Two cities of Treeland were called near, if it were possible to move from one city to the other one by moving through at most two roads. Also, a city is considered near to itself. During the recent excavations archaeologists found a set of *n* notes, each of them represents a list of cities, near to some of the *n* cities of the country. However, unfortunately, none of the found records lets you understand in what order the cities go in the list and for which city in the list the near to it cities were listed.
Help the archaeologists and restore any variant of the map of Treeland that meets the found information. | The first line contains integer *n* (2<=β€<=*n*<=β€<=1000) β the number of cities in the country.
Next *n* lines describe the found lists of near cities. Each list starts from number *k* (1<=β€<=*k*<=β€<=*n*), representing the number of cities in the list followed by *k* city numbers. All numbers in each list are distinct.
It is guaranteed that the given information determines at least one possible road map. | Print *n*<=-<=1 pairs of numbers representing the roads of the country. The *i*-th line must contain two integers *a**i*,<=*b**i* (1<=β€<=*a**i*,<=*b**i*<=β€<=*n*, *a**i*<=β <=*b**i*), showing that there is a road between cities *a**i* and *b**i*.
The answer you print must satisfy the description of close cities from the input. You may print the roads of the countries in any order. The cities that are connected by a road may also be printed in any order.
If there are multiple good answers, you may print any of them. | [
"5\n4 3 2 4 1\n5 5 3 2 4 1\n5 4 2 1 5 3\n4 2 1 4 3\n3 1 4 5\n",
"6\n5 6 1 3 4 2\n5 2 1 3 4 6\n6 3 6 2 5 4 1\n6 6 1 2 5 3 4\n3 5 2 4\n5 3 1 2 4 6\n"
] | [
"1 4\n1 2\n1 3\n4 5\n",
"2 4\n1 2\n2 3\n2 6\n4 5\n"
] | none | [] | 31 | 0 | 0 | 54,473 |
|
263 | Squares | [
"greedy",
"implementation",
"sortings"
] | null | null | Vasya has found a piece of paper with a coordinate system written on it. There are *n* distinct squares drawn in this coordinate system. Let's number the squares with integers from 1 to *n*. It turned out that points with coordinates (0,<=0) and (*a**i*,<=*a**i*) are the opposite corners of the *i*-th square.
Vasya wants to find such integer point (with integer coordinates) of the plane, that belongs to exactly *k* drawn squares. We'll say that a point belongs to a square, if the point is located either inside the square, or on its boundary.
Help Vasya find a point that would meet the described limits. | The first line contains two space-separated integers *n*, *k* (1<=β€<=*n*,<=*k*<=β€<=50). The second line contains space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a**i*<=β€<=109).
It is guaranteed that all given squares are distinct. | In a single line print two space-separated integers *x* and *y* (0<=β€<=*x*,<=*y*<=β€<=109) β the coordinates of the point that belongs to exactly *k* squares. If there are multiple answers, you are allowed to print any of them.
If there is no answer, print "-1" (without the quotes). | [
"4 3\n5 1 3 4\n",
"3 1\n2 4 1\n",
"4 50\n5 1 10 2\n"
] | [
"2 1\n",
"4 0\n",
"-1\n"
] | none | [
{
"input": "4 3\n5 1 3 4",
"output": "2 1"
},
{
"input": "3 1\n2 4 1",
"output": "4 0"
},
{
"input": "4 50\n5 1 10 2",
"output": "-1"
},
{
"input": "3 4\n5 1 4",
"output": "-1"
},
{
"input": "1 1\n2",
"output": "2 1"
},
{
"input": "1 2\n10",
"output": "-1"
},
{
"input": "10 5\n68 78 70 3 77 2 24 17 96 63",
"output": "68 68"
},
{
"input": "5 2\n10 9 19 12 14",
"output": "14 14"
},
{
"input": "2 2\n7 2",
"output": "2 1"
},
{
"input": "2 1\n8 20",
"output": "20 20"
},
{
"input": "2 40\n33 29",
"output": "-1"
},
{
"input": "5 10\n7 5 9 10 8",
"output": "-1"
},
{
"input": "9 8\n83 6 90 96 42 71 11 82 51",
"output": "11 11"
},
{
"input": "40 30\n115644639 84968781 502201719 185562964 985439338 904909761 987469310 392279024 34042735 634622221 839483595 370724480 578485357 293110515 426715668 623544321 361578399 344575100 906293095 989519195 455225 952837951 263384814 771897504 859893161 171980440 959878829 233550924 365529816 203041523 562264000 739766404 289946473 250809088 370936224 210349657 657189623 5710590 638043996 944609028",
"output": "250809088 250809088"
},
{
"input": "50 50\n873312389 604039796 470980211 604092901 317645830 865841782 30190128 90700018 361113641 948274316 775347907 312933768 745800411 976357881 652424427 420068005 77994941 746874884 912886330 875358567 675008609 780785718 874337107 541592914 532566154 316033689 257781802 361740423 72046192 816493561 290190407 245507086 581576441 739752998 801377026 469634060 850496001 558296112 702877640 836956173 304850066 276508329 703262292 394254651 789172012 655966182 103434486 635267748 872287742 750895678",
"output": "2 1"
},
{
"input": "50 1\n282174632 865088564 656352811 984648256 521352785 57911680 996749451 85805091 790762915 281422127 195283931 253923622 554865826 31466324 214732274 790749112 441328969 537583501 612245057 877161587 763349710 784532543 192804116 844363612 235045603 185195996 13097680 541100831 561866993 317797406 403001652 484887637 16410460 587211083 582483610 461878975 571808452 827167600 562613044 787964041 370263360 15717800 907380817 301112202 488431522 827024725 622035351 983160960 309839543 725826915",
"output": "996749451 996749451"
},
{
"input": "50 2\n611819205 916034844 226292837 817298502 176794540 727900268 460009451 154197232 671291076 641633528 316549457 84943963 581078373 360295861 299532522 279193498 61088105 776327911 952977833 796036148 193827182 248414821 822409059 451009120 316494610 702170585 194014479 567762248 201775925 186588924 630333192 849644874 978885690 826471389 136002889 659371057 392112709 74463003 491124655 336372608 480423293 428908070 423023163 749932199 880227915 227662209 304705869 82537803 424363417 744202499",
"output": "952977833 952977833"
},
{
"input": "50 49\n88725980 83881995 59295833 19992230 98694184 93275377 61249454 52781239 92644863 72826940 50546968 49705218 12163764 2370616 74789070 66649536 44427957 38263003 29482181 32784244 68697287 58653702 72057831 71170858 7965262 28000704 62154588 20020410 74475651 17112704 51168707 67055363 94596285 74161506 20821879 13196082 72415147 47307630 29342412 42369019 97867158 37513173 21502544 32181980 10790305 28119093 11323148 54617694 24131594 56797138",
"output": "7965262 7965262"
},
{
"input": "50 40\n96796700 70298164 77962801 85411997 38782814 34003824 38719796 99639116 67985686 99451905 61978628 21844407 12207253 79918 49399043 20719647 39110240 7094466 69163751 33236841 22249070 77179977 59576055 65178969 85705829 95074132 34273099 39626456 4907488 86213552 61097999 82889263 50311083 51771059 1255360 54093385 26718724 93604207 70082669 67044340 47726300 29504508 9910007 22933280 6155028 44655282 92452176 72975646 64485568 28849515",
"output": "22933280 22933280"
},
{
"input": "50 25\n1498786 501094 6396443 1167317 719496 636212 1912961 3111395 9572144 6277130 9288513 7311574 4038261 7897312 6769622 3412399 9996933 4060756 9948079 1769012 7600286 9897826 2087275 5962282 4953810 9654443 5333662 433180 3588803 4130095 9598090 5151122 9842663 2514194 1676006 1626458 6001092 8600794 1723930 8161219 1356724 4329774 8289408 3197404 7978402 1561752 3254820 3668793 6778571 7700292",
"output": "4953810 4953810"
},
{
"input": "40 11\n60208 236973 84548 315924 250944 161962 297861 210884 314453 279066 6713 301121 238667 162406 271727 215696 44559 217356 265375 162107 289254 27492 179940 37333 304851 292475 216268 324087 57771 193073 309245 77531 58743 46448 125774 80238 70527 80833 24488 206156",
"output": "271727 271727"
},
{
"input": "44 38\n1462767 3166364 2098867 3314373 272988 1780023 2892344 3453931 131181 2304994 1855709 770970 3125250 2260136 1472897 2688663 2516513 1842215 187194 725629 1982324 3030991 3106666 2504895 211807 3306495 3315809 2391117 1748124 110461 1156562 1210236 190189 504062 371439 3202405 503823 2844645 568415 3139160 1616378 3185067 3099571 2832834",
"output": "371439 371439"
},
{
"input": "37 15\n438778 549860 49173 79840 234277 898394 923784 647192 886153 382676 312989 525192 837433 210204 822734 218858 732642 336426 241548 478143 133580 508509 279685 393941 361559 59454 924509 236866 531648 567554 476854 399527 678235 527942 854506 697967 609944",
"output": "531648 531648"
},
{
"input": "48 42\n140920201 439599146 631470789 326348765 777305542 246501797 98842561 66698125 328893187 320920834 442056583 300823217 102856871 894833295 183971312 540000242 77621006 301282781 633518310 368397657 266701251 254744062 276445863 624102545 317896643 457301959 840650755 37020968 787211200 835830799 696187545 77377229 666128476 254311406 706645277 592561555 487913577 799871742 248143253 499058221 533238063 603652509 401508758 545626159 728850086 173008168 373273227 772142675",
"output": "140920201 140920201"
},
{
"input": "30 7\n483242884 141465390 673274235 374698924 293895324 745776711 38293296 624522417 759055572 343124219 260836408 738391263 503711346 394651562 297415680 772345540 864523609 288584413 650320686 449000886 409412162 15908489 635266274 210759446 839533571 807852364 888754168 98417552 843606733 776397228",
"output": "772345540 772345540"
},
{
"input": "20 50\n366890701 326770801 264406917 201841167 245146846 423010984 902787383 250242526 915591714 753137694 212804025 728751237 707187607 713393006 915812218 208754076 88791411 661347329 647317959 484135977",
"output": "-1"
},
{
"input": "49 50\n237449581 667894738 947395330 631153874 73096515 526873659 442758248 458113553 593707922 871777170 341397492 276382904 953470766 481575900 456794298 949850484 901479039 641744893 906465923 889863668 865607102 676085245 15087113 733126439 805674805 419604807 578669881 662288768 867202435 312642277 690318191 928184117 255005653 221548485 89241021 776806523 716418093 628174070 549089059 180504011 699093407 914610155 999333080 522769440 884252814 601964726 433999999 961290550 79463155",
"output": "-1"
},
{
"input": "32 50\n7 5 50 2 42 36 28 8 44 3 40 15 33 18 1 6 25 20 39 24 45 35 14 27 17 47 19 49 13 34 22 26",
"output": "-1"
},
{
"input": "20 17\n407 2799 2032 2154 8119 9404 6718 7914 916 4720 1267 9403 5497 4518 9072 7828 8364 8230 3057 7770",
"output": "2032 2032"
},
{
"input": "17 27\n22 8 17 12 24 28 25 20 7 9 4 15 6 33 19 5 10",
"output": "-1"
},
{
"input": "1 1\n1",
"output": "1 1"
},
{
"input": "2 1\n2 1",
"output": "2 1"
},
{
"input": "2 1\n1 2",
"output": "2 1"
},
{
"input": "5 2\n1 2 5 4 3",
"output": "4 0"
},
{
"input": "2 1\n2 3",
"output": "3 3"
},
{
"input": "1 1\n1000000000",
"output": "2 1"
},
{
"input": "5 1\n1 2 3 4 5",
"output": "5 5"
},
{
"input": "5 4\n1 2 3 4 5",
"output": "2 1"
},
{
"input": "4 1\n1 2 999999991 999999999",
"output": "999999999 999999999"
},
{
"input": "3 2\n1 2 3",
"output": "2 1"
},
{
"input": "4 3\n1 1000000000 100000000 10000000",
"output": "2 1"
},
{
"input": "4 4\n1 2 3 4",
"output": "1 1"
},
{
"input": "2 2\n10000000 1000000",
"output": "2 1"
},
{
"input": "3 1\n1 2 3",
"output": "3 3"
},
{
"input": "2 2\n100000000 1000000000",
"output": "2 1"
}
] | 92 | 0 | 3 | 54,642 |
|
301 | Yaroslav and Time | [
"binary search",
"graphs",
"shortest paths"
] | null | null | Yaroslav is playing a game called "Time". The game has a timer showing the lifespan he's got left. As soon as the timer shows 0, Yaroslav's character dies and the game ends. Also, the game has *n* clock stations, station number *i* is at point (*x**i*,<=*y**i*) of the plane. As the player visits station number *i*, he increases the current time on his timer by *a**i*. The stations are for one-time use only, so if the player visits some station another time, the time on his timer won't grow.
A player spends *d*Β·*dist* time units to move between stations, where *dist* is the distance the player has covered and *d* is some constant. The distance between stations *i* and *j* is determined as |*x**i*<=-<=*x**j*|<=+<=|*y**i*<=-<=*y**j*|.
Initially, the player is at station number 1, and the player has strictly more than zero and strictly less than one units of time. At station number 1 one unit of money can increase the time on the timer by one time unit (you can buy only integer number of time units).
Now Yaroslav is wondering, how much money he needs to get to station *n*. Help Yaroslav. Consider the time to buy and to increase the timer value negligibly small. | The first line contains integers *n* and *d* (3<=β€<=*n*<=β€<=100,<=103<=β€<=*d*<=β€<=105) β the number of stations and the constant from the statement.
The second line contains *n*<=-<=2 integers: *a*2,<=*a*3,<=...,<=*a**n*<=-<=1 (1<=β€<=*a**i*<=β€<=103). The next *n* lines contain the coordinates of the stations. The *i*-th of them contains two integers *x**i*, *y**i* (-100<=β€<=*x**i*,<=*y**i*<=β€<=100).
It is guaranteed that no two stations are located at the same point. | In a single line print an integer β the answer to the problem. | [
"3 1000\n1000\n0 0\n0 1\n0 3\n",
"3 1000\n1000\n1 0\n1 1\n1 2\n"
] | [
"2000\n",
"1000\n"
] | none | [
{
"input": "3 1000\n1000\n0 0\n0 1\n0 3",
"output": "2000"
},
{
"input": "3 1000\n1000\n1 0\n1 1\n1 2",
"output": "1000"
},
{
"input": "5 1421\n896 448 727\n-19 -40\n-87 40\n69 51\n-55 61\n-7 67",
"output": "169099"
},
{
"input": "6 1000\n142 712 254 869\n7 0\n95 38\n96 -20\n-7 93\n75 -45\n-80 -20",
"output": "107000"
},
{
"input": "7 1288\n943 265 649 447 806\n-4 -51\n-26 32\n47 -28\n31 32\n61 65\n-45 -37\n82 42",
"output": "229903"
},
{
"input": "8 1931\n440 627 324 538 539 119\n-85 -41\n-91 61\n-84 11\n92 -19\n8 -5\n16 -25\n97 -98\n91 78",
"output": "569018"
},
{
"input": "9 1829\n98 513 987 291 162 637 356\n38 -3\n-89 93\n-86 45\n-43 -84\n-3 -87\n53 -59\n18 -19\n81 -74\n-85 32",
"output": "288982"
},
{
"input": "10 1000\n759 222 589 423 947 507 31 414\n-4 -71\n-31 -53\n24 28\n-13 -65\n-59 -49\n-42 -79\n85 -71\n-60 -17\n28 66\n74 2",
"output": "151000"
},
{
"input": "11 1199\n282 735 54 1000 419 939 901 789 128\n10 -81\n26 72\n19 -91\n-61 85\n0 -33\n-62 79\n-59 65\n-2 -77\n-63 100\n-15 53\n94 54",
"output": "262581"
},
{
"input": "12 1609\n196 486 94 344 524 588 315 504 449 201\n86 -22\n-2 25\n-95 -8\n-5 -30\n-78 71\n5 -54\n-69 -92\n-41 0\n10 19\n61 17\n75 -39\n-46 22",
"output": "282231"
},
{
"input": "3 97325\n40\n43 43\n45 -95\n-93 63",
"output": "15182700"
},
{
"input": "11 1615\n137 681 199 33 388 585 241 518 7\n-60 89\n24 6\n-100 -55\n-26 -90\n-40 -33\n-100 28\n12 34\n-60 -13\n38 -89\n62 81\n-35 54",
"output": "96900"
},
{
"input": "22 1000\n94 609 173 244 930 515 169 56 192 974 923 749 652 987 145 447 578 518 630 917\n13 93\n99 6\n41 -54\n67 -85\n24 38\n23 -65\n9 -60\n-29 -78\n-29 -32\n53 -70\n-83 -50\n31 1\n-85 16\n74 95\n-30 89\n89 -67\n70 -74\n-78 -73\n19 17\n97 4\n97 -27\n-4 -48",
"output": "158000"
},
{
"input": "4 62071\n706 480\n6 96\n51 -12\n99 66\n-69 -61",
"output": "14400472"
},
{
"input": "12 1542\n389 356 290 648 182 94 585 988 762 494\n-46 96\n1 88\n0 95\n-91 -100\n-42 -29\n45 -27\n-52 -34\n-62 27\n-19 46\n-100 95\n5 -55\n-36 -65",
"output": "263034"
},
{
"input": "3 100000\n1\n-100 -100\n-100 -99\n100 100",
"output": "39999999"
},
{
"input": "12 1211\n1 5 7 1000 1000 1000 1000 1000 1000 1000\n1 1\n5 5\n3 4\n4 3\n0 1\n0 2\n0 5\n0 7\n1 0\n3 0\n8 0\n10 10",
"output": "20220"
},
{
"input": "6 1000\n1000 1000 1000 1000\n0 0\n0 -1\n1 -1\n2 -1\n2 0\n2 1",
"output": "1000"
}
] | 0 | 0 | -1 | 54,689 |
|
217 | Bitonix' Patrol | [
"bitmasks",
"brute force",
"combinatorics",
"dfs and similar",
"math"
] | null | null | Byteland is trying to send a space mission onto the Bit-X planet. Their task is complicated by the fact that the orbit of the planet is regularly patrolled by Captain Bitonix, the leader of the space forces of Bit-X.
There are *n* stations around Bit-X numbered clockwise from 1 to *n*. The stations are evenly placed on a circular orbit, so the stations number *i* and *i*<=+<=1 (1<=β€<=*i*<=<<=*n*), and the stations number 1 and *n*, are neighboring. The distance between every pair of adjacent stations is equal to *m* space miles. To go on a patrol, Captain Bitonix jumps in his rocket at one of the stations and flies in a circle, covering a distance of at least one space mile, before finishing in some (perhaps the starting) station.
Bitonix' rocket moves by burning fuel tanks. After Bitonix attaches an *x*-liter fuel tank and chooses the direction (clockwise or counter-clockwise), the rocket flies exactly *x* space miles along a circular orbit in the chosen direction. Note that the rocket has no brakes; it is not possible for the rocket to stop before depleting a fuel tank.
For example, assume that *n*<==<=3 and *m*<==<=60 and Bitonix has fuel tanks with volumes of 10, 60, 90 and 100 liters. If Bitonix starts from station 1, uses the 100-liter fuel tank to go clockwise, then uses the 90-liter fuel tank to go clockwise, and then uses the 10-liter fuel tank to go counterclockwise, he will finish back at station 1. This constitutes a valid patrol. Note that Bitonix does not have to use all available fuel tanks. Another valid option for Bitonix in this example would be to simply use the 60-liter fuel tank to fly to either station 2 or 3.
However, if *n* was equal to 3, *m* was equal to 60 and the only fuel tanks available to Bitonix were one 10-liter tank and one 100-liter tank, he would have no way of completing a valid patrol (he wouldn't be able to finish any patrol exactly at the station).
The Byteland space agency wants to destroy some of Captain Bitonix' fuel tanks so that he cannot to complete any valid patrol. Find how many different subsets of the tanks the agency can destroy to prevent Captain Bitonix from completing a patrol and output the answer modulo 1000000007 (109<=+<=7). | The first line of the input contains three integers *n* (2<=β€<=*n*<=β€<=1000) β the number of stations, *m* (1<=β€<=*m*<=β€<=120) β the distance between adjacent stations, and *t* (1<=β€<=*t*<=β€<=10000) β the number of fuel tanks owned by Captain Bitonix.
The second line of the input contains *t* space-separated integers between 1 and 109, inclusive β the volumes of Bitonix' fuel tanks. | Output a single number β the number of distinct subsets of tanks that the Bytelandian space agency can destroy in order to prevent Captain Bitonix from completing a patrol, modulo 109<=+<=7. | [
"7 6 5\n5 4 12 6 5\n",
"3 60 2\n10 100\n"
] | [
"6\n",
"4\n"
] | All the fuel tanks are distinct, even if some of them have the same capacity. | [] | 30 | 0 | 0 | 54,702 |
|
733 | Drivers Dissatisfaction | [
"data structures",
"dsu",
"graphs",
"trees"
] | null | null | In one kingdom there are *n* cities and *m* two-way roads. Each road connects a pair of cities, and for each road we know the level of drivers dissatisfactionΒ β the value *w**i*.
For each road we know the value *c**i*Β β how many lamziks we should spend to reduce the level of dissatisfaction with this road by one. Thus, to reduce the dissatisfaction with the *i*-th road by *k*, we should spend *k*Β·*c**i* lamziks. And it is allowed for the dissatisfaction to become zero or even negative.
In accordance with the king's order, we need to choose *n*<=-<=1 roads and make them the main roads. An important condition must hold: it should be possible to travel from any city to any other by the main roads.
The road ministry has a budget of *S* lamziks for the reform. The ministry is going to spend this budget for repair of some roads (to reduce the dissatisfaction with them), and then to choose the *n*<=-<=1 main roads.
Help to spend the budget in such a way and then to choose the main roads so that the total dissatisfaction with the main roads will be as small as possible. The dissatisfaction with some roads can become negative. It is not necessary to spend whole budget *S*.
It is guaranteed that it is possible to travel from any city to any other using existing roads. Each road in the kingdom is a two-way road. | The first line contains two integers *n* and *m* (2<=β€<=*n*<=β€<=2Β·105, *n*<=-<=1<=β€<=*m*<=β€<=2Β·105)Β β the number of cities and the number of roads in the kingdom, respectively.
The second line contains *m* integers *w*1,<=*w*2,<=...,<=*w**m* (1<=β€<=*w**i*<=β€<=109), where *w**i* is the drivers dissatisfaction with the *i*-th road.
The third line contains *m* integers *c*1,<=*c*2,<=...,<=*c**m* (1<=β€<=*c**i*<=β€<=109), where *c**i* is the cost (in lamziks) of reducing the dissatisfaction with the *i*-th road by one.
The next *m* lines contain the description of the roads. The *i*-th of this lines contain a pair of integers *a**i* and *b**i* (1<=β€<=*a**i*,<=*b**i*<=β€<=*n*, *a**i*<=β <=*b**i*) which mean that the *i*-th road connects cities *a**i* and *b**i*. All roads are two-way oriented so it is possible to move by the *i*-th road from *a**i* to *b**i*, and vice versa. It is allowed that a pair of cities is connected by more than one road.
The last line contains one integer *S* (0<=β€<=*S*<=β€<=109)Β β the number of lamziks which we can spend for reforms. | In the first line print *K*Β β the minimum possible total dissatisfaction with main roads.
In each of the next *n*<=-<=1 lines print two integers *x*,<=*v**x*, which mean that the road *x* is among main roads and the road *x*, after the reform, has the level of dissatisfaction *v**x*.
Consider that roads are numbered from 1 to *m* in the order as they are given in the input data. The edges can be printed in arbitrary order. If there are several answers, print any of them. | [
"6 9\n1 3 1 1 3 1 2 2 2\n4 1 4 2 2 5 3 1 6\n1 2\n1 3\n2 3\n2 4\n2 5\n3 5\n3 6\n4 5\n5 6\n7\n",
"3 3\n9 5 1\n7 7 2\n2 1\n3 1\n3 2\n2\n"
] | [
"0\n1 1\n3 1\n6 1\n7 2\n8 -5\n",
"5\n3 0\n2 5\n"
] | none | [
{
"input": "6 9\n1 3 1 1 3 1 2 2 2\n4 1 4 2 2 5 3 1 6\n1 2\n1 3\n2 3\n2 4\n2 5\n3 5\n3 6\n4 5\n5 6\n7",
"output": "0\n1 1\n3 1\n6 1\n7 2\n8 -5"
},
{
"input": "3 3\n9 5 1\n7 7 2\n2 1\n3 1\n3 2\n2",
"output": "5\n3 0\n2 5"
},
{
"input": "7 6\n8 10 4 8 4 4\n45 51 13 13 37 26\n2 7\n7 1\n6 3\n3 1\n5 4\n1 4\n4",
"output": "38\n3 4\n5 4\n6 4\n1 8\n4 8\n2 10"
},
{
"input": "9 8\n2 8 2 10 2 2 5 8\n31 29 17 16 31 22 10 13\n5 2\n8 2\n7 3\n3 1\n6 8\n4 7\n1 2\n9 2\n69",
"output": "33\n1 2\n3 2\n5 2\n6 2\n7 -1\n2 8\n8 8\n4 10"
},
{
"input": "20 24\n197 80 213 112 390 387 286 280 307 200 334 337 330 178 354 231 134 14 6 297 12 341 248 115\n13 1 3 12 14 1 17 5 11 24 17 8 13 2 21 10 16 4 21 18 13 15 11 3\n1 18\n7 2\n11 2\n2 13\n12 3\n14 3\n7 4\n15 5\n7 6\n6 10\n18 6\n7 14\n8 18\n20 8\n11 9\n14 9\n9 18\n11 17\n15 14\n19 14\n16 15\n20 15\n19 16\n20 17\n19",
"output": "3701\n19 6\n21 12\n18 14\n2 61\n4 112\n24 115\n17 134\n14 178\n1 197\n10 200\n3 213\n16 231\n23 248\n8 280\n7 286\n9 307\n13 330\n6 387\n5 390"
},
{
"input": "10 10\n1 2 1 2 1 1 2 2 1 1\n3 3 2 2 2 2 2 2 1 2\n9 10\n1 7\n6 5\n4 10\n8 9\n2 6\n10 2\n3 8\n9 1\n5 3\n5",
"output": "7\n1 1\n3 1\n5 1\n6 1\n9 -4\n10 1\n2 2\n4 2\n7 2"
},
{
"input": "10 10\n2 1 1 1 2 2 2 1 1 1\n2 1 2 1 2 5 2 1 3 3\n1 3\n6 2\n9 7\n10 1\n4 5\n6 3\n3 6\n5 10\n2 9\n8 4\n1",
"output": "11\n2 0\n3 1\n4 1\n8 1\n9 1\n10 1\n1 2\n5 2\n6 2"
},
{
"input": "2 1\n6\n3\n1 2\n1000000000",
"output": "-333333327\n1 -333333327"
},
{
"input": "2 1\n1\n1\n1 2\n317856227",
"output": "-317856226\n1 -317856226"
},
{
"input": "2 1\n1\n1\n1 2\n1000000000",
"output": "-999999999\n1 -999999999"
},
{
"input": "2 1\n1000000000\n1000000000\n1 2\n1000000000",
"output": "999999999\n1 999999999"
},
{
"input": "5 4\n1 5 5 5\n1 5 5 5\n1 2\n2 3\n3 4\n4 5\n100",
"output": "-84\n1 -99\n2 5\n3 5\n4 5"
}
] | 93 | 0 | 0 | 54,769 |
|
891 | Envy | [
"data structures",
"dsu",
"graphs"
] | null | null | For a connected undirected weighted graph *G*, MST (minimum spanning tree) is a subgraph of *G* that contains all of *G*'s vertices, is a tree, and sum of its edges is minimum possible.
You are given a graph *G*. If you run a MST algorithm on graph it would give you only one MST and it causes other edges to become jealous. You are given some queries, each query contains a set of edges of graph *G*, and you should determine whether there is a MST containing all these edges or not. | The first line contains two integers *n*, *m* (2<=<=β€<=*n*,<=*m*<=<=β€<=5Β·105, *n*<=-<=1<=β€<=*m*)Β β the number of vertices and edges in the graph and the number of queries.
The *i*-th of the next *m* lines contains three integers *u**i*, *v**i*, *w**i* (*u**i*<=β <=*v**i*, 1<=β€<=*w**i*<=β€<=5Β·105)Β β the endpoints and weight of the *i*-th edge. There can be more than one edges between two vertices. It's guaranteed that the given graph is connected.
The next line contains a single integer *q* (1<=β€<=*q*<=β€<=5Β·105)Β β the number of queries.
*q* lines follow, the *i*-th of them contains the *i*-th query. It starts with an integer *k**i* (1<=β€<=*k**i*<=β€<=*n*<=-<=1)Β β the size of edges subset and continues with *k**i* distinct space-separated integers from 1 to *m*Β β the indices of the edges. It is guaranteed that the sum of *k**i* for 1<=β€<=*i*<=β€<=*q* does not exceed 5Β·105. | For each query you should print "YES" (without quotes) if there's a MST containing these edges and "NO" (of course without quotes again) otherwise. | [
"5 7\n1 2 2\n1 3 2\n2 3 1\n2 4 1\n3 4 1\n3 5 2\n4 5 2\n4\n2 3 4\n3 3 4 5\n2 1 7\n2 1 2\n"
] | [
"YES\nNO\nYES\nNO\n"
] | This is the graph of sample:
Weight of minimum spanning tree on this graph is 6.
MST with edges (1,β3,β4,β6), contains all of edges from the first query, so answer on the first query is "YES".
Edges from the second query form a cycle of length 3, so there is no spanning tree including these three edges. Thus, answer is "NO". | [
{
"input": "5 7\n1 2 2\n1 3 2\n2 3 1\n2 4 1\n3 4 1\n3 5 2\n4 5 2\n4\n2 3 4\n3 3 4 5\n2 1 7\n2 1 2",
"output": "YES\nNO\nYES\nNO"
},
{
"input": "5 8\n2 1 4\n3 1 4\n4 1 5\n5 2 3\n4 5 2\n4 5 4\n1 4 4\n3 4 2\n10\n1 1\n3 4 1 5\n1 2\n3 4 1 3\n2 4 3\n3 2 5 4\n2 2 4\n4 3 2 1 4\n1 3\n2 2 1",
"output": "YES\nYES\nYES\nNO\nNO\nYES\nYES\nNO\nNO\nNO"
},
{
"input": "12 29\n2 1 1\n3 1 2\n4 1 5\n5 1 3\n6 3 5\n7 3 3\n8 7 4\n9 4 2\n10 2 4\n11 1 4\n12 2 5\n5 9 2\n6 9 3\n12 5 1\n2 10 1\n10 11 5\n5 7 4\n2 12 5\n10 11 3\n5 9 3\n2 12 2\n11 12 1\n1 6 4\n2 10 4\n12 7 1\n6 12 4\n7 10 1\n4 7 3\n12 4 5\n10\n10 12 6 3 8 7 5 11 10 9 1\n9 12 9 10 7 4 6 1 8 3\n2 5 3\n7 7 11 10 12 6 5 9\n9 3 8 10 2 9 12 6 11 7\n2 6 2\n8 4 1 7 10 12 2 9 11\n10 5 9 3 1 4 7 6 2 10 8\n9 10 8 6 11 1 4 7 3 2\n3 7 6 11",
"output": "NO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO"
},
{
"input": "14 16\n2 1 3\n3 1 5\n4 3 4\n5 3 5\n6 3 5\n7 2 1\n8 6 5\n9 2 5\n10 2 2\n11 1 4\n12 5 2\n13 12 4\n14 12 4\n8 11 2\n13 14 2\n12 14 5\n10\n12 3 12 6 1 13 8 4 9 5 10 11 14\n6 3 7 10 12 11 2\n1 8\n5 14 13 11 4 1\n3 9 4 2\n11 1 2 11 8 7 5 9 12 13 4 10\n13 7 10 5 6 4 9 12 1 3 8 14 11 13\n3 3 9 12\n10 13 1 14 11 9 10 6 12 8 3\n4 8 11 4 1",
"output": "NO\nYES\nYES\nYES\nYES\nNO\nNO\nYES\nNO\nYES"
},
{
"input": "5 9\n2 1 2\n3 1 3\n4 2 4\n5 3 3\n4 5 5\n4 5 1\n1 3 3\n1 5 1\n5 4 3\n10\n4 4 5 3 2\n3 4 5 1\n3 1 3 4\n1 1\n4 1 4 5 2\n4 2 3 1 5\n3 2 3 4\n3 5 2 1\n4 5 1 4 2\n3 3 2 5",
"output": "NO\nNO\nNO\nYES\nNO\nNO\nNO\nNO\nNO\nNO"
},
{
"input": "20 24\n2 1 3\n3 1 5\n4 1 5\n5 1 13\n6 2 7\n7 4 7\n8 6 7\n9 8 12\n10 4 11\n11 5 12\n12 10 12\n13 2 11\n14 12 8\n15 7 1\n16 10 7\n17 4 4\n18 13 9\n19 2 11\n20 10 10\n16 19 2\n1 5 14\n19 20 17\n3 7 11\n15 17 11\n20\n3 16 9 20\n3 24 9 12\n1 5\n2 9 12\n3 1 6 11\n3 2 5 21\n4 13 17 7 3\n3 21 11 20\n4 3 19 12 18\n2 22 17\n1 12\n3 1 24 13\n4 14 11 5 21\n4 5 7 13 11\n3 1 7 22\n1 12\n4 9 15 22 24\n3 19 15 21\n4 18 8 7 20\n4 17 11 3 19",
"output": "YES\nNO\nYES\nYES\nYES\nNO\nYES\nNO\nYES\nNO\nYES\nNO\nNO\nYES\nNO\nYES\nNO\nNO\nYES\nYES"
},
{
"input": "16 29\n2 1 1\n3 2 5\n4 2 1\n5 3 7\n6 1 2\n7 4 6\n8 4 4\n9 3 10\n10 8 3\n11 8 8\n12 2 7\n13 2 6\n14 11 1\n15 4 2\n16 3 4\n14 16 8\n9 15 5\n3 6 6\n11 15 10\n11 15 6\n11 13 8\n2 6 8\n11 13 1\n13 15 10\n13 15 10\n10 13 7\n1 9 9\n10 13 8\n1 15 2\n20\n2 26 6\n2 18 10\n1 1\n4 12 13 21 28\n1 28\n4 10 27 26 16\n3 10 1 9\n3 17 10 16\n1 23\n2 14 6\n4 25 24 6 3\n2 3 23\n3 24 22 8\n1 7\n1 29\n3 20 28 1\n4 10 5 11 17\n3 1 8 22\n1 15\n1 4",
"output": "NO\nNO\nYES\nNO\nNO\nNO\nNO\nNO\nYES\nYES\nNO\nYES\nNO\nYES\nYES\nNO\nNO\nNO\nYES\nYES"
},
{
"input": "2 2\n1 2 1\n1 2 2\n2\n1 1\n1 2",
"output": "YES\nNO"
},
{
"input": "3 2\n1 2 3\n2 3 6\n3\n1 1\n1 2\n2 1 2",
"output": "YES\nYES\nYES"
}
] | 30 | 0 | 0 | 54,783 |
|
653 | Paper task | [
"data structures",
"string suffix structures",
"strings"
] | null | null | Alex was programming while Valentina (his toddler daughter) got there and started asking many questions about the round brackets (or parenthesis) in the code. He explained her a bit and when she got it he gave her a task in order to finish his code on time.
For the purpose of this problem we consider only strings consisting of opening and closing round brackets, that is characters '(' and ')'.
The sequence of brackets is called correct if:
1. it's empty; 1. it's a correct sequence of brackets, enclosed in a pair of opening and closing brackets; 1. it's a concatenation of two correct sequences of brackets.
For example, the sequences "()()" and "((()))(())" are correct, while ")(()", "(((((" and "())" are not.
Alex took a piece of paper, wrote a string *s* consisting of brackets and asked Valentina to count the number of distinct non-empty substrings of *s* that are correct sequences of brackets. In other words, her task is to count the number of non-empty correct sequences of brackets that occur in a string *s* as a substring (don't mix up with subsequences).
When Valentina finished the task, Alex noticed he doesn't know the answer. Help him don't loose face in front of Valentina and solve the problem! | The first line of the input contains an integer *n* (1<=β€<=*n*<=β€<=500<=000)Β β the length of the string *s*.
The second line contains a string *s* of length *n* consisting of only '(' and ')'. | Print the number of distinct non-empty correct sequences that occur in *s* as substring. | [
"10\n()()()()()\n",
"7\n)(())()\n"
] | [
"5\n",
"3\n"
] | In the first sample, there are 5 distinct substrings we should count: "()", "()()", "()()()", "()()()()" and "()()()()()".
In the second sample, there are 3 distinct substrings we should count: "()", "(())" and "(())()". | [
{
"input": "10\n()()()()()",
"output": "5"
},
{
"input": "7\n)(())()",
"output": "3"
},
{
"input": "1\n(",
"output": "0"
},
{
"input": "2\n))",
"output": "0"
},
{
"input": "15\n(())(()())(()()",
"output": "5"
},
{
"input": "30\n()(())(())(())()(())()()()(()(",
"output": "34"
},
{
"input": "100\n(((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))",
"output": "50"
},
{
"input": "1\n)",
"output": "0"
},
{
"input": "2\n)(",
"output": "0"
},
{
"input": "2\n((",
"output": "0"
},
{
"input": "3\n(()",
"output": "1"
},
{
"input": "3\n()(",
"output": "1"
},
{
"input": "5\n()(()",
"output": "1"
},
{
"input": "7\n(()(())",
"output": "3"
},
{
"input": "10\n()()((())(",
"output": "3"
},
{
"input": "10\n((((()))))",
"output": "5"
},
{
"input": "20\n()()((()())())()()((",
"output": "13"
},
{
"input": "20\n(((((((((())))))))))",
"output": "10"
},
{
"input": "20\n))(())))))((((()))((",
"output": "3"
},
{
"input": "50\n()(())()()()(()())()(())()()()()(())()()(())()()()",
"output": "142"
},
{
"input": "50\n((((((((((((((((((((((((()))))))))))))))))))))))))",
"output": "25"
},
{
"input": "50\n)))(()(())())())(())()())(())()((()()))(()(()(((()",
"output": "13"
},
{
"input": "100\n)(()))))))(())()))())())(())())))))))()())))()())()((()))())((((()()((()((()((((((((()(((()())(((()(",
"output": "9"
},
{
"input": "500\n()(()()()()()(())())((()(()))()()(())())()(())(()()())()()(())(())(())(())(())()()(())((()))()()()()()(())()()()()((())())()(())(())(())()((())(()))(())(()()()()(())())((()()(())()))(())(()()()((()))())((())(())(())())()((()(()))())()(())((())()()(()))()(()(())()((()))()())(())()((()))()()(())(((()())())()())((()()(())))()(())((())())()()()((())()(())()())((()))(())(())()()((())()()()(())())()()(()()((())()))()()()((())()()()(()))()(()()())()()()()((())())()()(())((()))()()(()()()()()()())()()((",
"output": "4051"
},
{
"input": "500\n(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))",
"output": "250"
},
{
"input": "500\n)()))))()())))))(())))))))()))))))())))))))()))))))))))()))()))()))(())(()))()())()(()))))()))))))))()))))())))))))))))))(()()))))))))()())))))))()))))()))))))()))())))))))))()))))()))))))))()))))()))))()()))))())))))))())(()()))))))))())))))()())))))((()((((())(()(((((()((((((((((((((()(()((((((((((((((()((((()()))(((((((()((()()(((((((()(((()((((()(((()(((((((((((((((()((()(()((())(()))()(()(((()((((((((()((()(((((((()(((((((()(((((())()())()((((((()(((()(())))((((((()(()((((())(((()((((((()()",
"output": "17"
}
] | 30 | 0 | -1 | 54,872 |
|
804 | Ice cream coloring | [
"constructive algorithms",
"dfs and similar",
"greedy"
] | null | null | Isart and Modsart were trying to solve an interesting problem when suddenly Kasra arrived. Breathless, he asked: "Can you solve a problem I'm stuck at all day?"
We have a tree *T* with *n* vertices and *m* types of ice cream numerated from 1 to *m*. Each vertex *i* has a set of *s**i* types of ice cream. Vertices which have the *i*-th (1<=β€<=*i*<=β€<=*m*) type of ice cream form a connected subgraph. We build a new graph *G* with *m* vertices. We put an edge between the *v*-th and the *u*-th (1<=β€<=*u*,<=*v*<=β€<=*m*, *u*<=β <=*v*) vertices in *G* if and only if there exists a vertex in *T* that has both the *v*-th and the *u*-th types of ice cream in its set. The problem is to paint the vertices of *G* with minimum possible number of colors in a way that no adjacent vertices have the same color.
Please note that we consider that empty set of vertices form a connected subgraph in this problem.
As usual, Modsart don't like to abandon the previous problem, so Isart wants you to solve the new problem. | The first line contains two integer *n* and *m* (1<=β€<=*n*,<=*m*<=β€<=3Β·105)Β β the number of vertices in *T* and the number of ice cream types.
*n* lines follow, the *i*-th of these lines contain single integer *s**i* (0<=β€<=*s**i*<=β€<=3Β·105) and then *s**i* distinct integers, each between 1 and *m*Β β the types of ice cream in the *i*-th vertex. The sum of *s**i* doesn't exceed 5Β·105.
*n*<=-<=1 lines follow. Each of these lines describes an edge of the tree with two integers *u* and *v* (1<=β€<=*u*,<=*v*<=β€<=*n*)Β β the indexes of connected by this edge vertices. | Print single integer *c* in the first lineΒ β the minimum number of colors to paint the vertices in graph *G*.
In the second line print *m* integers, the *i*-th of which should be the color of the *i*-th vertex. The colors should be between 1 and *c*. If there are some answers, print any of them. | [
"3 3\n1 1\n2 2 3\n1 2\n1 2\n2 3\n",
"4 5\n0\n1 1\n1 3\n3 2 4 5\n2 1\n3 2\n4 3\n"
] | [
"2\n1 1 2 ",
"3\n1 1 1 2 3 "
] | In the first example the first type of ice cream is present in the first vertex only, so we can color it in any color. The second and the third ice cream are both presented in the second vertex, so we should paint them in different colors.
In the second example the colors of the second, the fourth and the fifth ice cream should obviously be distinct. | [
{
"input": "3 3\n1 1\n2 2 3\n1 2\n1 2\n2 3",
"output": "2\n1 1 2 "
},
{
"input": "4 5\n0\n1 1\n1 3\n3 2 4 5\n2 1\n3 2\n4 3",
"output": "3\n1 1 1 2 3 "
},
{
"input": "7 35\n3 17 20 32\n4 3 14 24 25\n4 4 10 17 26\n7 2 9 13 17 23 28 30\n9 1 2 7 8 13 16 18 33 35\n8 5 6 11 15 17 22 29 34\n5 12 19 21 27 31\n2 1\n3 1\n4 3\n5 4\n6 3\n7 4",
"output": "9\n1 2 1 2 2 3 3 5 3 3 4 1 4 2 5 6 1 7 2 2 3 6 5 3 4 4 4 6 7 7 5 3 8 8 9 "
},
{
"input": "7 39\n7 5 10 15 27 31 33 39\n7 5 16 21 27 28 29 33\n3 15 26 27\n13 1 2 4 7 11 12 15 24 26 27 35 36 38\n4 20 27 37 39\n10 6 7 9 14 18 19 23 26 27 32\n10 3 5 8 13 17 22 25 30 33 34\n2 1\n3 1\n4 3\n5 1\n6 4\n7 2",
"output": "13\n2 5 2 6 1 2 7 3 3 2 8 9 4 5 3 2 5 6 8 1 3 7 9 10 8 1 4 5 7 9 5 10 6 10 11 12 2 13 7 "
},
{
"input": "15 57\n7 1 12 25 28 40 43 47\n6 2 27 41 53 56 57\n8 2 4 21 26 27 31 34 45\n9 8 20 22 24 35 37 38 44 50\n4 3 7 48 51\n3 8 14 37\n5 10 13 15 32 47\n5 10 18 23 32 47\n2 36 55\n2 8 37\n5 9 29 49 52 56\n5 8 16 30 37 54\n3 17 19 46\n4 6 11 33 39\n3 5 42 56\n2 1\n3 2\n4 2\n5 4\n6 4\n7 1\n8 7\n9 4\n10 6\n11 2\n12 6\n13 5\n14 2\n15 11",
"output": "9\n1 1 1 3 1 1 2 1 1 1 2 2 2 2 3 2 1 2 2 2 4 3 3 4 3 5 2 4 2 3 6 4 3 7 5 1 6 7 4 5 3 2 6 8 8 3 7 3 3 9 4 4 4 4 2 5 6 "
},
{
"input": "3 3\n0\n0\n0\n1 2\n2 3",
"output": "1\n1 1 1 "
},
{
"input": "1 1\n0",
"output": "1\n1 "
},
{
"input": "1 5\n0",
"output": "1\n1 1 1 1 1 "
},
{
"input": "1 2\n0",
"output": "1\n1 1 "
},
{
"input": "2 3\n1 1\n1 2\n1 2",
"output": "1\n1 1 1 "
},
{
"input": "3 5\n0\n0\n0\n1 2\n2 3",
"output": "1\n1 1 1 1 1 "
},
{
"input": "1 4\n0",
"output": "1\n1 1 1 1 "
},
{
"input": "2 2\n0\n0\n1 2",
"output": "1\n1 1 "
},
{
"input": "1 3\n0",
"output": "1\n1 1 1 "
},
{
"input": "4 5\n0\n0\n0\n0\n2 1\n3 2\n4 3",
"output": "1\n1 1 1 1 1 "
},
{
"input": "4 4\n0\n0\n0\n0\n1 2\n2 3\n3 4",
"output": "1\n1 1 1 1 "
},
{
"input": "4 5\n0\n0\n0\n0\n1 2\n2 3\n3 4",
"output": "1\n1 1 1 1 1 "
},
{
"input": "1 5\n1 1",
"output": "1\n1 1 1 1 1 "
},
{
"input": "3 5\n0\n0\n0\n1 2\n1 3",
"output": "1\n1 1 1 1 1 "
},
{
"input": "3 2\n1 1\n1 2\n2 1 2\n1 3\n2 3",
"output": "2\n1 2 "
},
{
"input": "1 100000\n1 1",
"output": "1\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 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 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 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 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ..."
},
{
"input": "1 300000\n0",
"output": "1\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 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 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 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 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ..."
},
{
"input": "2 3\n0\n0\n1 2",
"output": "1\n1 1 1 "
},
{
"input": "1 10\n1 5",
"output": "1\n1 1 1 1 1 1 1 1 1 1 "
},
{
"input": "1 1000\n0",
"output": "1\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 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 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 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 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ..."
},
{
"input": "3 6\n3 1 2 3\n3 4 5 6\n2 1 4\n1 3\n2 3",
"output": "3\n1 2 3 2 1 3 "
},
{
"input": "3 5\n0\n0\n0\n1 3\n2 3",
"output": "1\n1 1 1 1 1 "
},
{
"input": "3 5\n1 1\n1 3\n1 5\n1 2\n2 3",
"output": "1\n1 1 1 1 1 "
},
{
"input": "2 1\n0\n0\n1 2",
"output": "1\n1 "
},
{
"input": "3 4\n1 1\n2 2 3\n1 2\n1 2\n2 3",
"output": "2\n1 1 2 1 "
},
{
"input": "1 5\n3 1 2 3",
"output": "3\n1 2 3 1 1 "
},
{
"input": "3 2\n1 1\n1 2\n2 1 2\n1 3\n3 2",
"output": "2\n1 2 "
},
{
"input": "1 2\n1 1",
"output": "1\n1 1 "
},
{
"input": "3 6\n3 1 2 3\n3 4 5 6\n3 4 2 5\n1 3\n2 3",
"output": "3\n1 2 3 1 3 2 "
},
{
"input": "3 3\n1 1\n1 2\n2 1 2\n1 3\n2 3",
"output": "2\n1 2 1 "
},
{
"input": "1 10\n0",
"output": "1\n1 1 1 1 1 1 1 1 1 1 "
},
{
"input": "3 5\n0\n0\n1 1\n1 2\n2 3",
"output": "1\n1 1 1 1 1 "
}
] | 31 | 307,200 | 0 | 54,951 |
|
360 | Levko and Array Recovery | [
"greedy",
"implementation"
] | null | null | Levko loves array *a*1,<=*a*2,<=... ,<=*a**n*, consisting of integers, very much. That is why Levko is playing with array *a*, performing all sorts of operations with it. Each operation Levko performs is of one of two types:
1. Increase all elements from *l**i* to *r**i* by *d**i*. In other words, perform assignments *a**j*<==<=*a**j*<=+<=*d**i* for all *j* that meet the inequation *l**i*<=β€<=*j*<=β€<=*r**i*. 1. Find the maximum of elements from *l**i* to *r**i*. That is, calculate the value .
Sadly, Levko has recently lost his array. Fortunately, Levko has records of all operations he has performed on array *a*. Help Levko, given the operation records, find at least one suitable array. The results of all operations for the given array must coincide with the record results. Levko clearly remembers that all numbers in his array didn't exceed 109 in their absolute value, so he asks you to find such an array. | The first line contains two integers *n* and *m* (1<=β€<=*n*,<=*m*<=β€<=5000) β the size of the array and the number of operations in Levko's records, correspondingly.
Next *m* lines describe the operations, the *i*-th line describes the *i*-th operation. The first integer in the *i*-th line is integer *t**i* (1<=β€<=*t**i*<=β€<=2) that describes the operation type. If *t**i*<==<=1, then it is followed by three integers *l**i*, *r**i* and *d**i* (1<=β€<=*l**i*<=β€<=*r**i*<=β€<=*n*, <=-<=104<=β€<=*d**i*<=β€<=104) β the description of the operation of the first type. If *t**i*<==<=2, then it is followed by three integers *l**i*, *r**i* and *m**i* (1<=β€<=*l**i*<=β€<=*r**i*<=β€<=*n*, <=-<=5Β·107<=β€<=*m**i*<=β€<=5Β·107) β the description of the operation of the second type.
The operations are given in the order Levko performed them on his array. | In the first line print "YES" (without the quotes), if the solution exists and "NO" (without the quotes) otherwise.
If the solution exists, then on the second line print *n* integers *a*1,<=*a*2,<=... ,<=*a**n* (|*a**i*|<=β€<=109) β the recovered array. | [
"4 5\n1 2 3 1\n2 1 2 8\n2 3 4 7\n1 1 3 3\n2 3 4 8\n",
"4 5\n1 2 3 1\n2 1 2 8\n2 3 4 7\n1 1 3 3\n2 3 4 13\n"
] | [
"YES\n4 7 4 7",
"NO\n"
] | none | [
{
"input": "4 5\n1 2 3 1\n2 1 2 8\n2 3 4 7\n1 1 3 3\n2 3 4 8",
"output": "YES\n8 7 4 7 "
},
{
"input": "4 5\n1 2 3 1\n2 1 2 8\n2 3 4 7\n1 1 3 3\n2 3 4 13",
"output": "NO"
},
{
"input": "97 29\n2 78 82 356152\n2 14 29 430177\n1 59 84 3680\n1 49 89 -2247\n1 92 96 3701\n2 54 89 377271\n1 62 70 -507\n2 94 97 431563\n1 46 55 -9257\n1 51 83 1627\n1 10 20 6633\n1 17 34 -9263\n2 66 92 383251\n1 12 82 3884\n1 78 96 -5379\n2 13 35 424798\n1 68 91 2939\n2 80 84 214725\n1 61 85 -4390\n1 85 96 3106\n2 17 25 424798\n1 91 93 7298\n2 32 94 429290\n2 20 74 427777\n1 56 87 -4571\n2 71 91 351695\n1 45 64 2697\n2 20 40 427777\n1 60 96 -3025",
"output": "YES\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 414281 414281 414281 414281 423544 423544 423544 423544 430177 430177 430177 430177 430177 430177 430177 430177 430177 430177 430177 430177 430177 430177 420914 423893 423893 423893 423893 423893 423893 423893 423893 423893 423893 433150 433150 433150 435397 435397 433770 433770 433770 379518 379518 379518 379518 379518 375838 375838 375838 375838 375838 375838 375838 375..."
},
{
"input": "1 4\n1 1 1 2\n2 1 1 6\n1 1 1 1\n2 1 1 7",
"output": "YES\n4 "
},
{
"input": "1 4\n1 1 1 2\n2 1 1 6\n1 1 1 1\n2 1 1 8",
"output": "NO"
},
{
"input": "1 2\n2 1 1 8\n2 1 1 7",
"output": "NO"
},
{
"input": "1 2\n2 1 1 10\n2 1 1 5",
"output": "NO"
},
{
"input": "2 2\n2 1 1 10\n2 1 2 5",
"output": "NO"
},
{
"input": "1 2\n2 1 1 5\n2 1 1 1",
"output": "NO"
},
{
"input": "2 2\n2 1 2 8\n2 1 2 7",
"output": "NO"
},
{
"input": "1 2\n2 1 1 1\n2 1 1 0",
"output": "NO"
},
{
"input": "1 1\n2 1 1 40000000",
"output": "YES\n40000000 "
},
{
"input": "1 2\n2 1 1 2\n2 1 1 1",
"output": "NO"
},
{
"input": "3 2\n2 1 2 100\n2 1 3 50",
"output": "NO"
}
] | 46 | 0 | 0 | 55,100 |
|
142 | Help Greg the Dwarf 2 | [
"geometry"
] | null | null | Greg the Dwarf has been really busy recently with excavations by the Neverland Mountain. However for the well-known reasons (as you probably remember he is a very unusual dwarf and he cannot stand sunlight) Greg can only excavate at night. And in the morning he should be in his crypt before the first sun ray strikes. That's why he wants to find the shortest route from the excavation point to his crypt. Greg has recollected how the Codeforces participants successfully solved the problem of transporting his coffin to a crypt. So, in some miraculous way Greg appeared in your bedroom and asks you to help him in a highly persuasive manner. As usual, you didn't feel like turning him down.
After some thought, you formalized the task as follows: as the Neverland mountain has a regular shape and ends with a rather sharp peak, it can be represented as a cone whose base radius equals *r* and whose height equals *h*. The graveyard where Greg is busy excavating and his crypt can be represented by two points on the cone's surface. All you've got to do is find the distance between points on the cone's surface.
The task is complicated by the fact that the mountain's base on the ground level and even everything below the mountain has been dug through by gnome (one may wonder whether they've been looking for the same stuff as Greg...). So, one can consider the shortest way to pass not only along the side surface, but also along the cone's base (and in a specific case both points can lie on the cone's base β see the first sample test)
Greg will be satisfied with the problem solution represented as the length of the shortest path between two points β he can find his way pretty well on his own. He gave you two hours to solve the problem and the time is ticking! | The first input line contains space-separated integers *r* and *h* (1<=β€<=*r*,<=*h*<=β€<=1000) β the base radius and the cone height correspondingly. The second and third lines contain coordinates of two points on the cone surface, groups of three space-separated real numbers. The coordinates of the points are given in the systems of coordinates where the origin of coordinates is located in the centre of the cone's base and its rotation axis matches the *OZ* axis. In this coordinate system the vertex of the cone is located at the point (0,<=0,<=*h*), the base of the cone is a circle whose center is at the point (0,<=0,<=0), lying on the *XOY* plane, and all points on the cone surface have a non-negative coordinate *z*. It is guaranteed that the distances from the points to the cone surface do not exceed 10<=-<=12. All real numbers in the input have no more than 16 digits after decimal point. | Print the length of the shortest path between the points given in the input, with absolute or relative error not exceeding 10<=-<=6. | [
"2 2\n1.0 0.0 0.0\n-1.0 0.0 0.0\n",
"2 2\n1.0 0.0 0.0\n1.0 0.0 1.0\n",
"2 2\n1.0 0.0 1.0\n-1.0 0.0 1.0\n",
"2 2\n1.0 0.0 0.0\n0.0 1.0 1.0\n"
] | [
"2.000000000",
"2.414213562",
"2.534324263",
"3.254470198"
] | none | [
{
"input": "2 2\n1.0 0.0 0.0\n-1.0 0.0 0.0",
"output": "2.0000000000000000"
},
{
"input": "2 2\n1.0 0.0 0.0\n1.0 0.0 1.0",
"output": "2.414213562373095"
},
{
"input": "2 2\n1.0 0.0 1.0\n-1.0 0.0 1.0",
"output": "2.534324262661599"
},
{
"input": "2 2\n1.0 0.0 0.0\n0.0 1.0 1.0",
"output": "3.254470197706959"
},
{
"input": "2 2\n1 0 1\n1 0 1",
"output": "0.000000000000000"
},
{
"input": "2 2\n0 2 0\n2 0 0",
"output": "2.8284271247461903"
},
{
"input": "1 3\n0.333333333333333 0 2\n-0.666666666666666 0 1",
"output": "1.769124183375466"
},
{
"input": "4 2\n0 2 1\n0 -3 0",
"output": "7.617495113916503"
},
{
"input": "1 1\n0 0 1\n0 0 0",
"output": "2.414213562373095"
},
{
"input": "100 100\n99 0 1\n-99 0 1",
"output": "202.828427124746210"
},
{
"input": "88 105\n-83.647129195665613 27.334186970232459 0.000000000000000\n0.000000000000000 0.000000000000000 0.000000000000000",
"output": "88.0000000000000000"
},
{
"input": "95 115\n-94.798837559409705 6.179028838308848 0.000000000000000\n3.342582693513654 12.928467665102536 98.835138349494315",
"output": "141.297194476396560"
},
{
"input": "139 163\n-7.064282061617403 -119.648796858761900 22.448079209184119\n-3.099235383286207 130.020758014221030 10.486305761961773",
"output": "320.994208466804080"
},
{
"input": "89 165\n-77.601546118264423 -40.138626159725227 3.026234987879706\n-32.536564505566112 79.820562899551433 5.196277486773833",
"output": "138.055005811202530"
},
{
"input": "167 201\n-44.045042116268228 2.240298676664706 147.919173318547560\n-1.653062448517331 166.991818316171730 0.000000000000000",
"output": "229.161875457891940"
},
{
"input": "209 155\n10.339810149948200 207.429619805582460 0.973633003803984\n207.268022593198170 13.679741073068795 0.950049728912131",
"output": "280.113608256360580"
},
{
"input": "214 197\n-139.010054266533840 145.275848992143410 11.903485508393622\n201.707752886360570 -61.822489603821438 2.789960360351068",
"output": "435.069479445623240"
},
{
"input": "220 199\n7.702486930770317 -17.352156624704840 181.827313666644470\n-19.019292298570587 -58.442551586093003 143.407124141606430",
"output": "62.376512949023279"
},
{
"input": "125 223\n91.992953839808365 76.334473682993220 9.741805344154667\n-84.359519829273182 -91.096969326992280 1.502290062829727",
"output": "262.322409454934590"
},
{
"input": "135 242\n59.558351552645604 -52.913315274992456 99.187441396521223\n-24.675990127584633 -14.025205052053790 191.120333614367500",
"output": "136.624783180323310"
},
{
"input": "253 27\n-23.383556363495956 -3.075490409857886 24.483030221151189\n72.245718245226726 -82.324921811851368 15.311020040812947",
"output": "124.691284935369720"
},
{
"input": "254 54\n0.000000000000000 0.000000000000000 54.000000000000000\n0.000000000000000 0.000000000000000 0.000000000000000",
"output": "513.676722098843470"
},
{
"input": "267 42\n61.269272425153595 5.673599488606665 32.320903001753486\n-63.797770810112304 -38.267051239340162 30.297514320612102",
"output": "133.678382741735420"
},
{
"input": "38 278\n5.399109546042840 -8.432443753698909 204.748343438560110\n-5.230748245976885 1.555327155842188 238.077119640322790",
"output": "38.093735046969364"
},
{
"input": "78 282\n-1.664125131541297 -59.562854026849507 66.573343539272599\n71.149972890338546 -22.703911105882042 11.986524947742422",
"output": "102.658307334262700"
},
{
"input": "245 283\n-65.200025215297188 211.893667712412820 26.916275024999653\n81.954925476524096 -210.905000365566200 21.636551653267666",
"output": "553.847834491559980"
},
{
"input": "160 284\n-11.848288916318076 151.632288175726250 14.032286789548566\n55.204568662902133 -137.884714926791870 20.367746237801001",
"output": "355.266014577463070"
},
{
"input": "296 125\n0.000000000000000 0.000000000000000 0.000000000000000\n0.000000000000000 0.000000000000000 0.000000000000000",
"output": "0.0000000000000000"
},
{
"input": "307 13\n-270.438955322231150 -145.298903795659300 0.000000000000000\n0.000000000000000 0.000000000000000 0.000000000000000",
"output": "307.0000000000000000"
},
{
"input": "248 318\n-104.624749910959410 138.999195918964920 94.919838172486877\n228.999165107773990 95.201798197000812 0.000000000000000",
"output": "378.618071232051190"
},
{
"input": "320 305\n133.785417250379680 -214.950689891414610 63.683625243294543\n31.210648478715274 -54.393542268080502 245.227875205476610",
"output": "263.170090569639000"
},
{
"input": "279 320\n176.409341581619770 -216.149818882041610 0.000000000000000\n-80.839498717221858 -72.772525941007075 195.246130236928480",
"output": "362.984167377827590"
},
{
"input": "166 326\n-159.080559959952890 47.427581034961378 0.000000000000000\n64.219952084615173 -58.053751680168347 155.988180576648150",
"output": "350.312896450586380"
},
{
"input": "313 326\n268.206244981551440 -161.351821039912720 0.000000000000000\n32.335370169772631 -20.887667026020182 285.906088038778530",
"output": "396.367934965696240"
},
{
"input": "337 155\n103.562025742828280 213.837241376601870 45.720328048223415\n-12.785007455865372 -193.917849947259270 65.615662078921559",
"output": "451.739183365123150"
},
{
"input": "391 393\n69.363017479144332 381.996349660945500 2.771345269553063\n-4.314168772882780 -327.594317606469870 63.701456901510852",
"output": "872.611999302211980"
},
{
"input": "453 388\n-81.104385878292348 94.096725495772120 281.598867297277200\n319.890281685634530 320.747888041504270 0.000000000000000",
"output": "547.976632686011840"
},
{
"input": "462 27\n-159.864787795012400 -17.769652438662003 17.599713760563326\n-43.201695776047600 16.275482559188674 24.302000751547617",
"output": "121.714300862770440"
},
{
"input": "408 497\n267.962525371795490 -106.500517621999510 145.748954986607150\n406.530738343103910 -34.594201569204905 0.000000000000000",
"output": "213.676529817838540"
},
{
"input": "4 501\n1.256027912095488 1.550849382650718 251.041040422217460\n2.794539216444501 -2.861913794605588 0.000000000000000",
"output": "251.094303330067670"
},
{
"input": "505 405\n-171.258217521977260 26.368423921428572 266.035850862244220\n-322.844337173239810 -330.811068528084830 34.293877778928582",
"output": "454.191411638506740"
},
{
"input": "93 528\n36.658812293708685 85.470061900145083 0.000000000000000\n0.000000000000000 0.000000000000000 0.000000000000000",
"output": "93.0000000000000000"
},
{
"input": "19 536\n-2.323956629404414 0.854918404455399 466.144562395750310\n-11.970821418787578 -14.754641119305361 0.000000000000000",
"output": "466.515075604037010"
},
{
"input": "543 213\n-11.022498941354053 -208.184746146469020 131.221988486140450\n-261.342433954058090 237.839371010998720 74.386870834762945",
"output": "529.265581335714840"
},
{
"input": "552 538\n-219.196257175740500 505.979100989387290 0.567204598667054\n-13.005338942244901 -501.382586206790510 49.169271940131331",
"output": "1147.290245679384000"
},
{
"input": "290 555\n-35.294429133672416 -33.484539794537760 461.892222209193390\n-252.058361325518750 -143.410538266524330 0.000000000000000",
"output": "521.936684362155690"
},
{
"input": "557 356\n412.616943315331810 -374.160738305226630 0.000000000000000\n-119.143786824695810 28.916320481813823 277.639995153037090",
"output": "758.644272670264740"
},
{
"input": "108 567\n-77.326538888682109 -75.396328713652466 0.000000000000000\n-85.325412036343849 1.454640554847149 118.976494340335650",
"output": "142.855584570014320"
},
{
"input": "604 507\n256.435816856724730 546.860742632915960 0.000000000000000\n0.000000000000000 0.000000000000000 507.000000000000000",
"output": "788.584174327637130"
},
{
"input": "206 610\n85.003724396840582 -183.792743756824360 10.370249946816582\n-132.372286093682990 124.137988504975570 72.626760718535252",
"output": "489.630683838895320"
},
{
"input": "12 621\n-6.805901628792963 -2.400041575385406 247.536715624015390\n-9.888929727632208 -6.797725269673083 0.000000000000000",
"output": "247.595041963414560"
},
{
"input": "186 636\n125.502577654577490 -76.943123644053074 132.632626038618070\n10.998850276346941 11.375883701939239 581.893591807090730",
"output": "472.553289667418480"
},
{
"input": "194 640\n-185.594418018322020 -28.430658132256557 20.587563671749706\n162.386754505225720 71.184945374190377 55.079159027002405",
"output": "462.832453430235830"
},
{
"input": "381 647\n314.650162349171300 199.407123669264730 14.407770163811673\n-199.461288368305470 -305.260525670149090 27.766889571708951",
"output": "792.391879168826340"
},
{
"input": "663 558\n185.667839327817890 0.821162517806038 401.735041310258740\n541.204579549448680 -169.787472718591060 80.617413258449716",
"output": "508.589197900185520"
},
{
"input": "665 337\n-81.930040429089274 477.240591033892090 91.612221878619039\n-94.047744970766075 579.582133079572710 39.445199819169396",
"output": "115.507697648901770"
},
{
"input": "670 162\n128.165741407183870 -19.582009069376959 130.651054537534490\n-669.944585774285540 8.616959540400943 0.000000000000000",
"output": "819.927464516420400"
},
{
"input": "681 160\n-613.743030379663540 -295.094040367452070 0.000000000000000\n-138.987119977579430 -666.666018693271890 0.000000000000000",
"output": "602.8755340355712600"
},
{
"input": "700 694\n-491.323781315873530 391.487036614876730 71.164119861786261\n369.587380114008230 585.823923455896420 7.272344266525618",
"output": "925.471286233843440"
},
{
"input": "392 711\n275.256598579833170 279.101782398931620 0.000000000000000\n370.063048151715410 37.629657168787716 36.327559021646451",
"output": "265.894529685532690"
},
{
"input": "496 720\n-81.481055925005222 -489.261522629100850 0.000000000000000\n0.000000000000000 0.000000000000000 720.000000000000000",
"output": "874.308869908119620"
},
{
"input": "307 732\n-263.300272665471650 149.674800448139620 9.850014526791911\n252.974089914966560 152.268689048374710 27.979618318814200",
"output": "564.688286438940510"
},
{
"input": "708 735\n-372.227682278060970 -591.827556222709400 9.185583606570070\n-158.326918524255120 656.057627975817580 34.370737282300794",
"output": "1359.983114591124600"
},
{
"input": "562 761\n447.905573469315980 327.128350332647590 9.957782797299041\n-426.805719967420540 -331.040778689403110 29.600587789132693",
"output": "1173.053559827348900"
},
{
"input": "770 459\n88.786807039677768 -138.447991737814420 360.957772634164770\n183.265921873443600 -185.090929054817020 303.732327011363680",
"output": "119.910138117875160"
},
{
"input": "775 303\n220.814458005458700 -81.823041961067929 210.932255816936160\n-194.572073117032460 238.686633634201710 182.603770274642930",
"output": "547.658318653906580"
},
{
"input": "310 795\n-37.954433819069251 175.532754257961810 334.440556394379200\n-110.110062248727290 289.785738419925340 0.000000000000000",
"output": "360.711396236277610"
},
{
"input": "754 796\n216.565988894870090 153.972540922843820 515.476132607224140\n-47.509812467842735 752.501706123826920 0.000000000000000",
"output": "838.208600447662770"
},
{
"input": "800 645\n752.626854703574510 271.206227028445370 0.000000000000000\n-95.598746603765832 -604.427250606550160 151.622809761020480",
"output": "1320.622324323393100"
},
{
"input": "805 653\n687.624915941348040 -164.311988032427020 79.508586205624965\n762.951730761017420 256.767709279745700 0.000000000000000",
"output": "437.165612527832140"
},
{
"input": "816 723\n-409.404815276986650 251.893602766220970 297.094693677376310\n-102.999857434057130 -809.473303678733940 0.000000000000000",
"output": "1222.018824276540700"
},
{
"input": "857 741\n-856.534963081445990 28.228655991135017 0.000000000000000\n-145.707872297531990 -844.522478061138490 0.000000000000000",
"output": "1125.5974835534469000"
},
{
"input": "874 748\n-704.291967415513110 456.985614182417630 29.473929299402851\n0.000000000000000 0.000000000000000 0.000000000000000",
"output": "919.329269786949230"
},
{
"input": "881 682\n-39.602632901035470 880.109442891794970 0.000000000000000\n-232.291083077826440 -675.068070887951990 129.343123219787340",
"output": "1793.990810649566800"
},
{
"input": "893 2\n-87.049912924255025 -888.747046498540840 0.000000000000000\n-102.087930879379740 -77.695608292576296 1.712674372195576",
"output": "811.192659983106640"
},
{
"input": "893 745\n-744.291957980134610 493.435387144150350 0.000000000000000\n-229.382232313548710 -863.036958362069870 0.000000000000000",
"output": "1450.9132467894781000"
},
{
"input": "894 380\n62.028165472337882 891.845562128408120 0.000000000000000\n-281.506413354874670 848.522326895453260 0.000000000000000",
"output": "346.2555552782370100"
},
{
"input": "894 795\n-79.319376955375546 737.053160611378190 135.782330090001180\n-276.945076779847170 -850.022014095755370 0.000000000000000",
"output": "1863.330948809297300"
},
{
"input": "895 266\n-460.946965864515730 600.620195555266720 40.981602257928387\n178.077028677831550 166.078812707948770 193.629343617797820",
"output": "790.950234454675300"
},
{
"input": "902 469\n-665.302587586102280 0.024106493977479 123.072157668834680\n58.789007076917628 -165.366933065562050 377.744642427558010",
"output": "799.180998688435470"
},
{
"input": "909 879\n695.074972696372130 413.045294912773730 97.145264807840434\n-705.229230890123060 -517.817269433920730 32.956360377477495",
"output": "2002.737605542867900"
},
{
"input": "196 936\n-1.157629940182491 -1.112914249009275 928.331349563707700\n-43.366603227838930 -132.521475146312530 270.118439199950160",
"output": "672.528850625547190"
},
{
"input": "939 172\n760.602725383313210 550.640076764737840 0.000000000000000\n0.000000000000000 0.000000000000000 0.000000000000000",
"output": "939.0000000000001100"
},
{
"input": "952 565\n389.334410842084650 868.747786491710600 0.000000000000000\n492.169149678581280 807.768438499273320 3.622308459447762",
"output": "119.630652845404640"
},
{
"input": "588 957\n219.263290283055740 515.577240145252860 45.140983359549089\n-516.487259323793180 -279.513083799093290 1.187280610002339",
"output": "1161.121426778588100"
},
{
"input": "754 959\n344.733007448335230 -670.126881792474360 0.510505088991700\n-508.306819760418310 499.529742923366650 52.560459621746233",
"output": "1555.419070886616100"
},
{
"input": "406 962\n-49.783332082275358 -248.776028266368480 360.848848877620410\n-1.952167810020501 -3.487333391971083 952.530329833034900",
"output": "642.294343165613210"
},
{
"input": "973 436\n47.525346927433176 69.727668618789224 398.187783288826440\n-827.862618951791770 511.246011370534060 0.000000000000000",
"output": "1061.333336198369400"
},
{
"input": "974 336\n-412.402783094129350 395.821170200124020 138.808395601866750\n-31.097990341177809 10.151078095017953 324.715080477288270",
"output": "573.326026015034130"
},
{
"input": "997 897\n966.907255849128660 63.326755791696719 25.210646226492816\n-691.417709012145790 -678.273873083398140 25.584924238061610",
"output": "1940.382463863425300"
},
{
"input": "1000 1000\n0.000000000000000 0.000000000000000 0.000000000000000\n0.000000000000000 0.000000000000000 0.000000000000000",
"output": "0.0000000000000000"
},
{
"input": "1000 1000\n0.000000000000000 0.000000000000000 1000.000000000000000\n0.000000000000000 0.000000000000000 1000.000000000000000",
"output": "0.000000000000000"
},
{
"input": "1000 1000\n0.000000000000000 0.000000000000000 0.000000000000000\n0.000000000000000 0.000000000000000 1000.000000000000000",
"output": "2414.213562373095100"
},
{
"input": "1000 1000\n519.430292507390280 822.183052823439540 27.481207829697631\n-925.681320081855800 -271.775638373096170 35.247231690112748",
"output": "1953.674308800189900"
},
{
"input": "1000 1000\n-865.729850457726000 -306.217565767793640 81.709538567284440\n891.442934337587080 215.701160976332830 82.831806031769716",
"output": "2229.685117365914700"
},
{
"input": "1000 1000\n-451.257094270773560 -345.250138251562930 431.818142587758190\n68.190857559004940 -27.380462017482774 926.517466327546120",
"output": "801.825262695840930"
},
{
"input": "1000 1000\n-876.740604189171450 -386.919633788012220 41.678086421560081\n659.134284294775630 733.795718905435480 13.635887809815506",
"output": "2031.701640955472400"
},
{
"input": "1000 1000\n-20.534295190826231 133.273184243935670 865.154166109953510\n-711.474516721095600 -638.507879949720520 44.024947657417599",
"output": "1355.676743956396400"
},
{
"input": "1000 1000\n969.207183920193190 -213.270785951424980 7.605424489407109\n-631.538647292108290 -722.789524216293670 40.174099463677607",
"output": "1778.286143061074400"
},
{
"input": "1000 1000\n-378.383150861597360 -21.882887748889253 620.984605019557530\n291.284330016681450 461.398444104171010 454.348934634031140",
"output": "930.253674386416260"
}
] | 124 | 0 | 0 | 55,125 |
|
501 | Misha and Forest | [
"constructive algorithms",
"data structures",
"greedy",
"sortings",
"trees"
] | null | null | Let's define a forest as a non-directed acyclic graph (also without loops and parallel edges). One day Misha played with the forest consisting of *n* vertices. For each vertex *v* from 0 to *n*<=-<=1 he wrote down two integers, *degree**v* and *s**v*, were the first integer is the number of vertices adjacent to vertex *v*, and the second integer is the XOR sum of the numbers of vertices adjacent to *v* (if there were no adjacent vertices, he wrote down 0).
Next day Misha couldn't remember what graph he initially had. Misha has values *degree**v* and *s**v* left, though. Help him find the number of edges and the edges of the initial graph. It is guaranteed that there exists a forest that corresponds to the numbers written by Misha. | The first line contains integer *n* (1<=β€<=*n*<=β€<=216), the number of vertices in the graph.
The *i*-th of the next lines contains numbers *degree**i* and *s**i* (0<=β€<=*degree**i*<=β€<=*n*<=-<=1, 0<=β€<=*s**i*<=<<=216), separated by a space. | In the first line print number *m*, the number of edges of the graph.
Next print *m* lines, each containing two distinct numbers, *a* and *b* (0<=β€<=*a*<=β€<=*n*<=-<=1, 0<=β€<=*b*<=β€<=*n*<=-<=1), corresponding to edge (*a*,<=*b*).
Edges can be printed in any order; vertices of the edge can also be printed in any order. | [
"3\n2 3\n1 0\n1 0\n",
"2\n1 1\n1 0\n"
] | [
"2\n1 0\n2 0\n",
"1\n0 1\n"
] | The XOR sum of numbers is the result of bitwise adding numbers modulo 2. This operation exists in many modern programming languages. For example, in languages C++, Java and Python it is represented as "^", and in Pascal β as "xor". | [
{
"input": "3\n2 3\n1 0\n1 0",
"output": "2\n1 0\n2 0"
},
{
"input": "2\n1 1\n1 0",
"output": "1\n0 1"
},
{
"input": "10\n3 13\n2 6\n1 5\n3 5\n1 3\n2 2\n2 6\n1 6\n1 3\n2 3",
"output": "9\n2 5\n4 3\n7 6\n8 3\n5 0\n6 1\n3 9\n1 0\n9 0"
},
{
"input": "10\n1 2\n1 7\n1 0\n1 8\n0 0\n1 9\n0 0\n1 1\n1 3\n1 5",
"output": "4\n0 2\n1 7\n3 8\n5 9"
},
{
"input": "5\n1 1\n2 2\n2 2\n2 6\n1 3",
"output": "4\n0 1\n4 3\n1 2\n3 2"
},
{
"input": "10\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0",
"output": "0"
},
{
"input": "11\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n1 8\n1 7\n0 0\n0 0",
"output": "1\n7 8"
},
{
"input": "12\n0 0\n1 3\n0 0\n1 1\n0 0\n1 7\n0 0\n1 5\n0 0\n0 0\n0 0\n0 0",
"output": "2\n1 3\n5 7"
},
{
"input": "13\n2 7\n0 0\n0 0\n2 11\n2 7\n2 14\n2 3\n2 1\n1 11\n3 15\n1 6\n2 11\n1 9",
"output": "10\n8 11\n10 6\n12 9\n11 3\n6 9\n3 0\n9 5\n0 4\n5 7\n4 7"
},
{
"input": "14\n1 10\n1 9\n3 4\n1 2\n0 0\n1 11\n1 12\n1 10\n1 10\n2 10\n3 15\n3 14\n2 4\n0 0",
"output": "10\n0 10\n1 9\n3 2\n5 11\n6 12\n7 10\n8 10\n9 11\n12 2\n11 2"
},
{
"input": "15\n0 0\n1 6\n3 2\n1 13\n2 15\n2 5\n1 1\n2 1\n1 4\n1 2\n0 0\n1 14\n0 0\n1 3\n2 9",
"output": "9\n1 6\n3 13\n8 4\n9 2\n11 14\n4 7\n14 2\n7 5\n2 5"
},
{
"input": "16\n1 10\n2 13\n1 13\n2 1\n1 3\n2 2\n1 14\n0 0\n1 1\n1 14\n1 0\n0 0\n0 0\n1 2\n2 15\n0 0",
"output": "8\n0 10\n2 13\n4 3\n6 14\n8 1\n9 14\n3 5\n1 5"
},
{
"input": "17\n0 0\n2 6\n0 0\n2 11\n0 0\n1 13\n1 3\n1 10\n0 0\n1 1\n1 7\n0 0\n0 0\n3 9\n0 0\n2 12\n0 0",
"output": "7\n5 13\n6 3\n7 10\n9 1\n3 13\n1 15\n13 15"
},
{
"input": "18\n0 0\n0 0\n2 19\n1 2\n2 29\n0 0\n1 7\n1 6\n1 12\n1 13\n0 0\n1 12\n4 23\n1 9\n0 0\n0 0\n2 14\n1 4",
"output": "9\n3 2\n6 7\n8 12\n9 13\n11 12\n17 4\n2 16\n4 12\n16 12"
},
{
"input": "19\n1 13\n0 0\n1 9\n1 11\n1 11\n2 3\n2 30\n0 0\n1 5\n1 2\n0 0\n5 29\n1 6\n2 11\n0 0\n0 0\n0 0\n0 0\n2 13",
"output": "10\n0 13\n2 9\n3 11\n4 11\n8 5\n12 6\n13 11\n5 11\n6 18\n11 18"
},
{
"input": "20\n0 0\n2 15\n0 0\n2 7\n1 1\n0 0\n0 0\n0 0\n1 9\n2 11\n0 0\n1 1\n0 0\n0 0\n1 3\n0 0\n0 0\n0 0\n0 0\n0 0",
"output": "5\n4 1\n8 9\n11 1\n14 3\n9 3"
},
{
"input": "1\n0 0",
"output": "0"
}
] | 218 | 2,252,800 | -1 | 55,216 |
|
734 | Anton and Chess | [
"implementation"
] | null | null | Anton likes to play chess. Also, he likes to do programming. That is why he decided to write the program that plays chess. However, he finds the game on 8 to 8 board to too simple, he uses an infinite one instead.
The first task he faced is to check whether the king is in check. Anton doesn't know how to implement this so he asks you to help.
Consider that an infinite chess board contains one white king and the number of black pieces. There are only rooks, bishops and queens, as the other pieces are not supported yet. The white king is said to be in check if at least one black piece can reach the cell with the king in one move.
Help Anton and write the program that for the given position determines whether the white king is in check.
Remainder, on how do chess pieces move:
- Bishop moves any number of cells diagonally, but it can't "leap" over the occupied cells. - Rook moves any number of cells horizontally or vertically, but it also can't "leap" over the occupied cells. - Queen is able to move any number of cells horizontally, vertically or diagonally, but it also can't "leap". | The first line of the input contains a single integer *n* (1<=β€<=*n*<=β€<=500<=000)Β β the number of black pieces.
The second line contains two integers *x*0 and *y*0 (<=-<=109<=β€<=*x*0,<=*y*0<=β€<=109)Β β coordinates of the white king.
Then follow *n* lines, each of them contains a character and two integers *x**i* and *y**i* (<=-<=109<=β€<=*x**i*,<=*y**i*<=β€<=109)Β β type of the *i*-th piece and its position. Character 'B' stands for the bishop, 'R' for the rook and 'Q' for the queen. It's guaranteed that no two pieces occupy the same position. | The only line of the output should contains "YES" (without quotes) if the white king is in check and "NO" (without quotes) otherwise. | [
"2\n4 2\nR 1 1\nB 1 5\n",
"2\n4 2\nR 3 3\nB 1 5\n"
] | [
"YES\n",
"NO\n"
] | Picture for the first sample:
Picture for the second sample: | [
{
"input": "2\n4 2\nR 1 1\nB 1 5",
"output": "YES"
},
{
"input": "2\n4 2\nR 3 3\nB 1 5",
"output": "NO"
},
{
"input": "5\n-1 1\nR -10 10\nQ -9 9\nQ -2 -8\nB -6 10\nB -10 1",
"output": "YES"
},
{
"input": "20\n-321 454\nQ 967 -89\nR -811 454\nQ -404 454\nR -734 454\nQ -804 454\nQ -316 77\nQ -802 454\nB -499 454\nQ 401 -663\nQ -601 454\nQ -974 454\nB 710 298\nB -917 454\nB -555 -542\nQ -337 950\nR 501 40\nR 355 310\nB 657 -374\nR -860 454\nR 839 -10",
"output": "YES"
},
{
"input": "3\n-1000000000 -1000000000\nB 1000000000 -1000000000\nB -1000000000 1000000000\nB 1000000000 1000000000",
"output": "YES"
},
{
"input": "4\n1000000000 -1000000000\nB -1000000000 -1000000000\nB -1000000000 1000000000\nB 1000000000 1000000000\nR 0 0",
"output": "NO"
},
{
"input": "5\n-1000000000 1000000000\nR -1000000000 -1000000000\nB 1000000000 -1000000000\nR 1000000000 1000000000\nB -1000000000 0\nB 0 1000000000",
"output": "YES"
},
{
"input": "6\n-1000000000 1000000000\nR -1000000000 -1000000000\nB 1000000000 -1000000000\nR 1000000000 1000000000\nB -1000000000 0\nB 0 1000000000\nQ 0 0",
"output": "YES"
},
{
"input": "5\n1000000000 1000000000\nQ -1000000000 -1000000000\nQ -1000000000 1000000000\nQ 1000000000 -1000000000\nB 1000000000 0\nB 0 1000000000",
"output": "YES"
},
{
"input": "6\n1000000000 1000000000\nQ -1000000000 -1000000000\nQ -1000000000 1000000000\nQ 1000000000 -1000000000\nB 1000000000 0\nB 0 1000000000\nR 0 0",
"output": "NO"
},
{
"input": "6\n-1000000000 -1000000000\nB 1000000000 1000000000\nR 0 0\nQ 2 2\nR 4851521 8054854\nR -1000000000 1000000000\nB -1000000000 379",
"output": "NO"
},
{
"input": "4\n0 0\nB 0 1\nB -1 0\nR 1 1\nQ -1 -1",
"output": "YES"
},
{
"input": "3\n0 0\nR -1 -1\nR 1 -1\nB 0 1",
"output": "NO"
},
{
"input": "2\n0 0\nR 0 2\nB 0 1",
"output": "NO"
},
{
"input": "2\n5 5\nR 7 5\nB 6 5",
"output": "NO"
},
{
"input": "2\n1 1\nR 1 3\nB 1 2",
"output": "NO"
},
{
"input": "2\n0 0\nB 1 0\nR -2 0",
"output": "YES"
},
{
"input": "2\n4 2\nB 1 5\nR 3 3",
"output": "NO"
},
{
"input": "1\n0 0\nB 1 -1",
"output": "YES"
},
{
"input": "2\n0 0\nB 2 2\nR 1 1",
"output": "NO"
},
{
"input": "2\n1 0\nR 0 -1\nB 3 2",
"output": "YES"
}
] | 4,000 | 8,908,800 | 0 | 55,302 |
|
404 | Marathon | [
"implementation",
"math"
] | null | null | Valera takes part in the Berland Marathon. The marathon race starts at the stadium that can be represented on the plane as a square whose lower left corner is located at point with coordinates (0,<=0) and the length of the side equals *a* meters. The sides of the square are parallel to coordinate axes.
As the length of the marathon race is very long, Valera needs to have extra drink during the race. The coach gives Valera a bottle of drink each *d* meters of the path. We know that Valera starts at the point with coordinates (0,<=0) and runs counter-clockwise. That is, when Valera covers *a* meters, he reaches the point with coordinates (*a*,<=0). We also know that the length of the marathon race equals *nd*<=+<=0.5 meters.
Help Valera's coach determine where he should be located to help Valera. Specifically, determine the coordinates of Valera's positions when he covers *d*,<=2Β·*d*,<=...,<=*n*Β·*d* meters. | The first line contains two space-separated real numbers *a* and *d* (1<=β€<=*a*,<=*d*<=β€<=105), given with precision till 4 decimal digits after the decimal point. Number *a* denotes the length of the square's side that describes the stadium. Number *d* shows that after each *d* meters Valera gets an extra drink.
The second line contains integer *n* (1<=β€<=*n*<=β€<=105) showing that Valera needs an extra drink *n* times. | Print *n* lines, each line should contain two real numbers *x**i* and *y**i*, separated by a space. Numbers *x**i* and *y**i* in the *i*-th line mean that Valera is at point with coordinates (*x**i*,<=*y**i*) after he covers *i*Β·*d* meters. Your solution will be considered correct if the absolute or relative error doesn't exceed 10<=-<=4.
Note, that this problem have huge amount of output data. Please, do not use cout stream for output in this problem. | [
"2 5\n2\n",
"4.147 2.8819\n6\n"
] | [
"1.0000000000 2.0000000000\n2.0000000000 0.0000000000\n",
"2.8819000000 0.0000000000\n4.1470000000 1.6168000000\n3.7953000000 4.1470000000\n0.9134000000 4.1470000000\n0.0000000000 2.1785000000\n0.7034000000 0.0000000000\n"
] | none | [
{
"input": "2 5\n2",
"output": "1.0000000000 2.0000000000\n2.0000000000 0.0000000000"
},
{
"input": "4.147 2.8819\n6",
"output": "2.8819000000 0.0000000000\n4.1470000000 1.6168000000\n3.7953000000 4.1470000000\n0.9134000000 4.1470000000\n0.0000000000 2.1785000000\n0.7034000000 0.0000000000"
},
{
"input": "16904.8597 21646.2846\n10",
"output": "16904.8597000000 4741.4249000000\n7422.0099000000 16904.8597000000\n0.0000000000 2680.5850000000\n16904.8597000000 2060.8399000000\n10102.5949000000 16904.8597000000\n0.0000000000 5361.1700000000\n16285.1146000000 0.0000000000\n12783.1799000000 16904.8597000000\n0.0000000000 8041.7550000000\n13604.5296000000 0.0000000000"
},
{
"input": "40356.3702 72886.7142\n100",
"output": "40356.3702000000 32530.3440000000\n0.0000000000 15652.0524000000\n40356.3702000000 16878.2916000000\n0.0000000000 31304.1048000000\n40356.3702000000 1226.2392000000\n6599.7870000000 40356.3702000000\n25930.5570000000 0.0000000000\n22251.8394000000 40356.3702000000\n10278.5046000000 0.0000000000\n37903.8918000000 40356.3702000000\n0.0000000000 5373.5478000000\n40356.3702000000 27156.7962000000\n0.0000000000 21025.6002000000\n40356.3702000000 11504.7438000000\n0.0000000000 36677.6526000000\n36209.0616000000 ..."
},
{
"input": "70092.4982 95833.7741\n1000",
"output": "70092.4982000000 25741.2759000000\n18609.9464000000 70092.4982000000\n7131.3295000000 0.0000000000\n70092.4982000000 32872.6054000000\n11478.6169000000 70092.4982000000\n14262.6590000000 0.0000000000\n70092.4982000000 40003.9349000000\n4347.2874000000 70092.4982000000\n21393.9885000000 0.0000000000\n70092.4982000000 47135.2644000000\n0.0000000000 67308.4561000000\n28525.3180000000 0.0000000000\n70092.4982000000 54266.5939000000\n0.0000000000 60177.1266000000\n35656.6475000000 0.0000000000\n70092.4982000000..."
},
{
"input": "39712.7105 19285.2846\n10000",
"output": "19285.2846000000 0.0000000000\n38570.5692000000 0.0000000000\n39712.7105000000 18143.1433000000\n39712.7105000000 37428.4279000000\n22711.7085000000 39712.7105000000\n3426.4239000000 39712.7105000000\n0.0000000000 23853.8498000000\n0.0000000000 4568.5652000000\n14716.7194000000 0.0000000000\n34002.0040000000 0.0000000000\n39712.7105000000 13574.5781000000\n39712.7105000000 32859.8627000000\n27280.2737000000 39712.7105000000\n7994.9891000000 39712.7105000000\n0.0000000000 28422.4150000000\n0.0000000000 9137..."
},
{
"input": "97591.0354 49021.4126\n100000",
"output": "49021.4126000000 0.0000000000\n97591.0354000000 451.7898000000\n97591.0354000000 49473.2024000000\n96687.4558000000 97591.0354000000\n47666.0432000000 97591.0354000000\n0.0000000000 96235.6660000000\n0.0000000000 47214.2534000000\n1807.1592000000 0.0000000000\n50828.5718000000 0.0000000000\n97591.0354000000 2258.9490000000\n97591.0354000000 51280.3616000000\n94880.2966000000 97591.0354000000\n45858.8840000000 97591.0354000000\n0.0000000000 94428.5068000000\n0.0000000000 45407.0942000000\n3614.3184000000 0...."
},
{
"input": "1 100000\n100000",
"output": "0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000..."
},
{
"input": "1 1\n1",
"output": "1.0000000000 0.0000000000"
},
{
"input": "99999.9999 99999.9998\n100000",
"output": "99999.9998000000 0.0000000000\n99999.9999000000 99999.9997000000\n0.0003000000 99999.9999000000\n0.0000000000 0.0004000000\n99999.9994000000 0.0000000000\n99999.9999000000 99999.9993000000\n0.0007000000 99999.9999000000\n0.0000000000 0.0008000000\n99999.9990000000 0.0000000000\n99999.9999000000 99999.9989000000\n0.0011000000 99999.9999000000\n0.0000000000 0.0012000000\n99999.9986000000 0.0000000000\n99999.9999000000 99999.9985000000\n0.0015000000 99999.9999000000\n0.0000000000 0.0016000000\n99999.998200000..."
},
{
"input": "1.0001 9999.9999\n100000",
"output": "-0.0000000000 1.0001000000\n1.0001000000 1.0001000000\n1.0001000000 0.0000000000\n-0.0000000000 0.0000000000\n0.0000000000 1.0001000000\n1.0001000000 1.0001000000\n1.0001000000 0.0000000000\n-0.0000000000 0.0000000000\n0.0000000000 1.0001000000\n1.0001000000 1.0001000000\n1.0001000000 0.0000000000\n-0.0000000000 0.0000000000\n0.0000000000 1.0001000000\n1.0001000000 1.0001000000\n1.0001000000 0.0000000000\n-0.0000000000 0.0000000000\n0.0000000000 1.0001000000\n1.0001000000 1.0001000000\n1.0001000000 0.00000..."
},
{
"input": "100000 1\n100000",
"output": "1.0000000000 0.0000000000\n2.0000000000 0.0000000000\n3.0000000000 0.0000000000\n4.0000000000 0.0000000000\n5.0000000000 0.0000000000\n6.0000000000 0.0000000000\n7.0000000000 0.0000000000\n8.0000000000 0.0000000000\n9.0000000000 0.0000000000\n10.0000000000 0.0000000000\n11.0000000000 0.0000000000\n12.0000000000 0.0000000000\n13.0000000000 0.0000000000\n14.0000000000 0.0000000000\n15.0000000000 0.0000000000\n16.0000000000 0.0000000000\n17.0000000000 0.0000000000\n18.0000000000 0.0000000000\n19.0000000000 0...."
},
{
"input": "100000 100000\n100000",
"output": "100000.0000000000 0.0000000000\n100000.0000000000 100000.0000000000\n0.0000000000 100000.0000000000\n0.0000000000 0.0000000000\n100000.0000000000 0.0000000000\n100000.0000000000 100000.0000000000\n0.0000000000 100000.0000000000\n0.0000000000 0.0000000000\n100000.0000000000 0.0000000000\n100000.0000000000 100000.0000000000\n0.0000000000 100000.0000000000\n0.0000000000 0.0000000000\n100000.0000000000 0.0000000000\n100000.0000000000 100000.0000000000\n0.0000000000 100000.0000000000\n0.0000000000 0.0000000000\n..."
},
{
"input": "100000 100000\n100000",
"output": "100000.0000000000 0.0000000000\n100000.0000000000 100000.0000000000\n0.0000000000 100000.0000000000\n0.0000000000 0.0000000000\n100000.0000000000 0.0000000000\n100000.0000000000 100000.0000000000\n0.0000000000 100000.0000000000\n0.0000000000 0.0000000000\n100000.0000000000 0.0000000000\n100000.0000000000 100000.0000000000\n0.0000000000 100000.0000000000\n0.0000000000 0.0000000000\n100000.0000000000 0.0000000000\n100000.0000000000 100000.0000000000\n0.0000000000 100000.0000000000\n0.0000000000 0.0000000000\n..."
},
{
"input": "1.6055 15170.3125\n100000",
"output": "1.5485000000 0.0000000000\n1.6055000000 1.4915000000\n0.1710000000 1.6055000000\n0.0000000000 0.2280000000\n1.3205000000 0.0000000000\n1.6055000000 1.2635000000\n0.3990000000 1.6055000000\n0.0000000000 0.4560000000\n1.0925000000 0.0000000000\n1.6055000000 1.0355000000\n0.6270000000 1.6055000000\n0.0000000000 0.6840000000\n0.8645000000 0.0000000000\n1.6055000000 0.8075000000\n0.8550000000 1.6055000000\n0.0000000000 0.9120000000\n0.6365000000 0.0000000000\n1.6055000000 0.5795000000\n1.0830000000 1.6055000000..."
},
{
"input": "2.5828 24165.5413\n100000",
"output": "0.8645000000 0.0000000000\n1.7290000000 0.0000000000\n2.5828000000 0.0107000000\n2.5828000000 0.8752000000\n2.5828000000 1.7397000000\n2.5614000000 2.5828000000\n1.6969000000 2.5828000000\n0.8324000000 2.5828000000\n0.0000000000 2.5507000000\n0.0000000000 1.6862000000\n0.0000000000 0.8217000000\n0.0428000000 0.0000000000\n0.9073000000 0.0000000000\n1.7718000000 0.0000000000\n2.5828000000 0.0535000000\n2.5828000000 0.9180000000\n2.5828000000 1.7825000000\n2.5186000000 2.5828000000\n1.6541000000 2.5828000000..."
},
{
"input": "2.9320 33160.7701\n100000",
"output": "2.9320000000 2.7821000000\n0.0000000000 0.2998000000\n2.9320000000 2.4823000000\n0.0000000000 0.5996000000\n2.9320000000 2.1825000000\n0.0000000000 0.8994000000\n2.9320000000 1.8827000000\n0.0000000000 1.1992000000\n2.9320000000 1.5829000000\n0.0000000000 1.4990000000\n2.9320000000 1.2831000000\n0.0000000000 1.7988000000\n2.9320000000 0.9833000000\n0.0000000000 2.0986000000\n2.9320000000 0.6835000000\n0.0000000000 2.3984000000\n2.9320000000 0.3837000000\n0.0000000000 2.6982000000\n2.9320000000 0.0839000000..."
},
{
"input": "71601.9916 1.6928\n100000",
"output": "1.6928000000 0.0000000000\n3.3856000000 0.0000000000\n5.0784000000 0.0000000000\n6.7712000000 0.0000000000\n8.4640000000 0.0000000000\n10.1568000000 0.0000000000\n11.8496000000 0.0000000000\n13.5424000000 0.0000000000\n15.2352000000 0.0000000000\n16.9280000000 0.0000000000\n18.6208000000 0.0000000000\n20.3136000000 0.0000000000\n22.0064000000 0.0000000000\n23.6992000000 0.0000000000\n25.3920000000 0.0000000000\n27.0848000000 0.0000000000\n28.7776000000 0.0000000000\n30.4704000000 0.0000000000\n32.163200000..."
},
{
"input": "15145.9844 2.4240\n100000",
"output": "2.4240000000 0.0000000000\n4.8480000000 0.0000000000\n7.2720000000 0.0000000000\n9.6960000000 0.0000000000\n12.1200000000 0.0000000000\n14.5440000000 0.0000000000\n16.9680000000 0.0000000000\n19.3920000000 0.0000000000\n21.8160000000 0.0000000000\n24.2400000000 0.0000000000\n26.6640000000 0.0000000000\n29.0880000000 0.0000000000\n31.5120000000 0.0000000000\n33.9360000000 0.0000000000\n36.3600000000 0.0000000000\n38.7840000000 0.0000000000\n41.2080000000 0.0000000000\n43.6320000000 0.0000000000\n46.05600000..."
},
{
"input": "58689.9772 5.1934\n100000",
"output": "5.1934000000 0.0000000000\n10.3868000000 0.0000000000\n15.5802000000 0.0000000000\n20.7736000000 0.0000000000\n25.9670000000 0.0000000000\n31.1604000000 0.0000000000\n36.3538000000 0.0000000000\n41.5472000000 0.0000000000\n46.7406000000 0.0000000000\n51.9340000000 0.0000000000\n57.1274000000 0.0000000000\n62.3208000000 0.0000000000\n67.5142000000 0.0000000000\n72.7076000000 0.0000000000\n77.9010000000 0.0000000000\n83.0944000000 0.0000000000\n88.2878000000 0.0000000000\n93.4812000000 0.0000000000\n98.67460..."
},
{
"input": "26244.1561 49410.8330\n100000",
"output": "26244.1561000000 23166.6769000000\n0.0000000000 6154.9584000000\n26244.1561000000 17011.7185000000\n0.0000000000 12309.9168000000\n26244.1561000000 10856.7601000000\n0.0000000000 18464.8752000000\n26244.1561000000 4701.8017000000\n0.0000000000 24619.8336000000\n24790.9994000000 0.0000000000\n4530.6359000000 26244.1561000000\n18636.0410000000 0.0000000000\n10685.5943000000 26244.1561000000\n12481.0826000000 0.0000000000\n16840.5527000000 26244.1561000000\n6326.1242000000 0.0000000000\n22995.5111000000 26244..."
},
{
"input": "26253.1158 32456.3935\n100000",
"output": "26253.1158000000 6203.2777000000\n13846.5604000000 26253.1158000000\n0.0000000000 7643.2827000000\n24813.1108000000 0.0000000000\n21489.8431000000 26253.1158000000\n0.0000000000 15286.5654000000\n17169.8281000000 0.0000000000\n26253.1158000000 23373.1058000000\n0.0000000000 22929.8481000000\n9526.5454000000 0.0000000000\n26253.1158000000 15729.8231000000\n4320.0150000000 26253.1158000000\n1883.2627000000 0.0000000000\n26253.1158000000 8086.5404000000\n11963.2977000000 26253.1158000000\n0.0000000000 5760.02..."
},
{
"input": "26262.0740 15501.9524\n100000",
"output": "15501.9524000000 0.0000000000\n26262.0740000000 4741.8308000000\n26262.0740000000 20243.7832000000\n16778.4124000000 26262.0740000000\n1276.4600000000 26262.0740000000\n0.0000000000 12036.5816000000\n3465.3708000000 0.0000000000\n18967.3232000000 0.0000000000\n26262.0740000000 8207.2016000000\n26262.0740000000 23709.1540000000\n13313.0416000000 26262.0740000000\n0.0000000000 24073.1632000000\n0.0000000000 8571.2108000000\n6930.7416000000 0.0000000000\n22432.6940000000 0.0000000000\n26262.0740000000 11672.5..."
},
{
"input": "22635.8777 74922.1758\n10",
"output": "0.0000000000 15621.3350000000\n8606.7923000000 22635.8777000000\n22635.8777000000 21043.6281000000\n22635.8777000000 5422.2931000000\n12436.8358000000 0.0000000000\n0.0000000000 3184.4992000000\n0.0000000000 18805.8342000000\n11791.2915000000 22635.8777000000\n22635.8777000000 17859.1289000000\n22635.8777000000 2237.7939000000"
},
{
"input": "5681.4396 74931.1355\n10",
"output": "5681.4396000000 1072.4207000000\n3536.5982000000 5681.4396000000\n0.0000000000 2464.1775000000\n4289.6828000000 0.0000000000\n5681.4396000000 5362.1035000000\n0.0000000000 4928.3550000000\n1825.5053000000 0.0000000000\n5681.4396000000 2897.9260000000\n1711.0929000000 5681.4396000000\n0.0000000000 638.6722000000"
},
{
"input": "52372.0072 97869.2372\n100",
"output": "52372.0072000000 45497.2300000000\n0.0000000000 13749.5544000000\n52372.0072000000 31747.6756000000\n0.0000000000 27499.1088000000\n52372.0072000000 17998.1212000000\n0.0000000000 41248.6632000000\n52372.0072000000 4248.5668000000\n2626.2104000000 52372.0072000000\n42871.0196000000 0.0000000000\n16375.7648000000 52372.0072000000\n29121.4652000000 0.0000000000\n30125.3192000000 52372.0072000000\n15371.9108000000 0.0000000000\n43874.8736000000 52372.0072000000\n1622.3564000000 0.0000000000\n52372.0072000000 ..."
},
{
"input": "35417.5676 97878.1954\n100",
"output": "8374.5074000000 35417.5676000000\n35417.5676000000 18668.5528000000\n10294.0454000000 0.0000000000\n0.0000000000 33498.0296000000\n35417.5676000000 28962.5982000000\n20588.0908000000 0.0000000000\n0.0000000000 23203.9842000000\n31578.4916000000 35417.5676000000\n30882.1362000000 0.0000000000\n0.0000000000 12909.9388000000\n21284.4462000000 35417.5676000000\n35417.5676000000 5758.6140000000\n0.0000000000 2615.8934000000\n10990.4008000000 35417.5676000000\n35417.5676000000 16052.6594000000\n7678.1520000000 0..."
},
{
"input": "21992.2179 21320.7493\n1000",
"output": "21320.7493000000 0.0000000000\n21992.2179000000 20649.2807000000\n2014.4058000000 21992.2179000000\n0.0000000000 2685.8744000000\n18634.8749000000 0.0000000000\n21992.2179000000 17963.4063000000\n4700.2802000000 21992.2179000000\n0.0000000000 5371.7488000000\n15949.0005000000 0.0000000000\n21992.2179000000 15277.5319000000\n7386.1546000000 21992.2179000000\n0.0000000000 8057.6232000000\n13263.1261000000 0.0000000000\n21992.2179000000 12591.6575000000\n10072.0290000000 21992.2179000000\n0.0000000000 10743.4..."
},
{
"input": "5037.7799 21329.7059\n1000",
"output": "1178.5863000000 0.0000000000\n2357.1726000000 0.0000000000\n3535.7589000000 0.0000000000\n4714.3452000000 0.0000000000\n5037.7799000000 855.1516000000\n5037.7799000000 2033.7379000000\n5037.7799000000 3212.3242000000\n5037.7799000000 4390.9105000000\n4506.0630000000 5037.7799000000\n3327.4767000000 5037.7799000000\n2148.8904000000 5037.7799000000\n970.3041000000 5037.7799000000\n0.0000000000 4829.4977000000\n0.0000000000 3650.9114000000\n0.0000000000 2472.3251000000\n0.0000000000 1293.7388000000\n0.0000000..."
},
{
"input": "79870.5443 51056.8773\n10000",
"output": "51056.8773000000 0.0000000000\n79870.5443000000 22243.2103000000\n79870.5443000000 73300.0876000000\n35384.1237000000 79870.5443000000\n0.0000000000 64197.7907000000\n0.0000000000 13140.9134000000\n37915.9639000000 0.0000000000\n79870.5443000000 9102.2969000000\n79870.5443000000 60159.1742000000\n48525.0371000000 79870.5443000000\n0.0000000000 77338.7041000000\n0.0000000000 26281.8268000000\n24775.0505000000 0.0000000000\n75831.9278000000 0.0000000000\n79870.5443000000 47018.2608000000\n61665.9505000000 79..."
},
{
"input": "62916.1032 51065.8339\n10000",
"output": "51065.8339000000 0.0000000000\n62916.1032000000 39215.5646000000\n35550.8079000000 62916.1032000000\n0.0000000000 47401.0772000000\n3664.7567000000 0.0000000000\n54730.5906000000 0.0000000000\n62916.1032000000 42880.3213000000\n31886.0512000000 62916.1032000000\n0.0000000000 43736.3205000000\n7329.5134000000 0.0000000000\n58395.3473000000 0.0000000000\n62916.1032000000 46545.0780000000\n28221.2945000000 62916.1032000000\n0.0000000000 40071.5638000000\n10994.2701000000 0.0000000000\n62060.1040000000 0.00000..."
},
{
"input": "79870.5443 51056.8773\n10000",
"output": "51056.8773000000 0.0000000000\n79870.5443000000 22243.2103000000\n79870.5443000000 73300.0876000000\n35384.1237000000 79870.5443000000\n0.0000000000 64197.7907000000\n0.0000000000 13140.9134000000\n37915.9639000000 0.0000000000\n79870.5443000000 9102.2969000000\n79870.5443000000 60159.1742000000\n48525.0371000000 79870.5443000000\n0.0000000000 77338.7041000000\n0.0000000000 26281.8268000000\n24775.0505000000 0.0000000000\n75831.9278000000 0.0000000000\n79870.5443000000 47018.2608000000\n61665.9505000000 79..."
},
{
"input": "62916.1032 51065.8339\n10000",
"output": "51065.8339000000 0.0000000000\n62916.1032000000 39215.5646000000\n35550.8079000000 62916.1032000000\n0.0000000000 47401.0772000000\n3664.7567000000 0.0000000000\n54730.5906000000 0.0000000000\n62916.1032000000 42880.3213000000\n31886.0512000000 62916.1032000000\n0.0000000000 43736.3205000000\n7329.5134000000 0.0000000000\n58395.3473000000 0.0000000000\n62916.1032000000 46545.0780000000\n28221.2945000000 62916.1032000000\n0.0000000000 40071.5638000000\n10994.2701000000 0.0000000000\n62060.1040000000 0.00000..."
},
{
"input": "3 99999.1\n100000",
"output": "3.0000000000 0.1000000000\n2.8000000000 3.0000000000\n0.0000000000 2.7000000000\n0.4000000000 0.0000000000\n3.0000000000 0.5000000000\n2.4000000000 3.0000000000\n0.0000000000 2.3000000000\n0.8000000000 0.0000000000\n3.0000000000 0.9000000000\n2.0000000000 3.0000000000\n0.0000000000 1.9000000000\n1.2000000000 0.0000000000\n3.0000000000 1.3000000000\n1.6000000000 3.0000000000\n0.0000000000 1.5000000000\n1.6000000000 0.0000000000\n3.0000000000 1.7000000000\n1.2000000000 3.0000000000\n0.0000000000 1.1000000000..."
},
{
"input": "3 99999.2\n100000",
"output": "3.0000000000 0.2000000000\n2.6000000000 3.0000000000\n0.0000000000 2.4000000000\n0.8000000000 0.0000000000\n3.0000000000 1.0000000000\n1.8000000000 3.0000000000\n0.0000000000 1.6000000000\n1.6000000000 0.0000000000\n3.0000000000 1.8000000000\n1.0000000000 3.0000000000\n0.0000000000 0.8000000000\n2.4000000000 0.0000000000\n3.0000000000 2.6000000000\n0.2000000000 3.0000000000\n0.0000000000 0.0000000000\n3.0000000000 0.2000000000\n2.6000000000 3.0000000000\n0.0000000000 2.4000000000\n0.8000000000 0.0000000000..."
},
{
"input": "3 99999.0001\n100000",
"output": "3.0000000000 0.0001000000\n2.9998000000 3.0000000000\n0.0000000000 2.9997000000\n0.0004000000 0.0000000000\n3.0000000000 0.0005000000\n2.9994000000 3.0000000000\n0.0000000000 2.9993000000\n0.0008000000 0.0000000000\n3.0000000000 0.0009000000\n2.9990000000 3.0000000000\n0.0000000000 2.9989000000\n0.0012000000 0.0000000000\n3.0000000000 0.0013000000\n2.9986000000 3.0000000000\n0.0000000000 2.9985000000\n0.0016000000 0.0000000000\n3.0000000000 0.0017000000\n2.9982000000 3.0000000000\n0.0000000000 2.9981000000..."
},
{
"input": "3 99999.0002\n100000",
"output": "3.0000000000 0.0002000000\n2.9996000000 3.0000000000\n0.0000000000 2.9994000000\n0.0008000000 0.0000000000\n3.0000000000 0.0010000000\n2.9988000000 3.0000000000\n0.0000000000 2.9986000000\n0.0016000000 0.0000000000\n3.0000000000 0.0018000000\n2.9980000000 3.0000000000\n0.0000000000 2.9978000000\n0.0024000000 0.0000000000\n3.0000000000 0.0026000000\n2.9972000000 3.0000000000\n0.0000000000 2.9970000000\n0.0032000000 0.0000000000\n3.0000000000 0.0034000000\n2.9964000000 3.0000000000\n0.0000000000 2.9962000000..."
},
{
"input": "100000 99999.0002\n100000",
"output": "99999.0002000000 0.0000000000\n100000.0000000000 99998.0004000000\n2.9994000000 100000.0000000000\n0.0000000000 3.9992000000\n99995.0010000000 0.0000000000\n100000.0000000000 99994.0012000000\n6.9986000000 100000.0000000000\n0.0000000000 7.9984000000\n99991.0018000000 0.0000000000\n100000.0000000000 99990.0020000000\n10.9978000000 100000.0000000000\n0.0000000000 11.9976000000\n99987.0026000000 0.0000000000\n100000.0000000000 99986.0028000000\n14.9970000000 100000.0000000000\n0.0000000000 15.9968000000\n999..."
},
{
"input": "99999.9998 99999.9999\n100000",
"output": "99999.9998000000 0.0001000000\n99999.9996000000 99999.9998000000\n0.0000000000 99999.9995000000\n0.0004000000 0.0000000000\n99999.9998000000 0.0005000000\n99999.9992000000 99999.9998000000\n0.0000000000 99999.9991000000\n0.0008000000 0.0000000000\n99999.9998000000 0.0009000000\n99999.9988000000 99999.9998000000\n0.0000000000 99999.9987000000\n0.0012000000 0.0000000000\n99999.9998000000 0.0013000000\n99999.9984000000 99999.9998000000\n0.0000000000 99999.9983000000\n0.0016000000 0.0000000000\n99999.999800000..."
},
{
"input": "1 9999.9999\n100000",
"output": "0.0000000000 0.0001000000\n0.0000000000 0.0002000000\n0.0000000000 0.0003000000\n0.0000000000 0.0004000000\n0.0000000000 0.0005000000\n0.0000000000 0.0006000000\n0.0000000000 0.0007000000\n0.0000000000 0.0008000000\n0.0000000000 0.0009000000\n0.0000000000 0.0010000000\n0.0000000000 0.0011000000\n0.0000000000 0.0012000000\n0.0000000000 0.0013000000\n0.0000000000 0.0014000000\n0.0000000000 0.0015000000\n0.0000000000 0.0016000000\n0.0000000000 0.0017000000\n0.0000000000 0.0018000000\n0.0000000000 0.0019000000..."
},
{
"input": "1.0001 9996.9996\n100000",
"output": "0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000\n0.0000000000 0.0000000000..."
},
{
"input": "1.0001 99999.9999\n100000",
"output": "0.9992000000 1.0001000000\n0.0018000000 0.0000000000\n0.9974000000 1.0001000000\n0.0036000000 0.0000000000\n0.9956000000 1.0001000000\n0.0054000000 0.0000000000\n0.9938000000 1.0001000000\n0.0072000000 0.0000000000\n0.9920000000 1.0001000000\n0.0090000000 0.0000000000\n0.9902000000 1.0001000000\n0.0108000000 0.0000000000\n0.9884000000 1.0001000000\n0.0126000000 0.0000000000\n0.9866000000 1.0001000000\n0.0144000000 0.0000000000\n0.9848000000 1.0001000000\n0.0162000000 0.0000000000\n0.9830000000 1.0001000000..."
},
{
"input": "1.0001 100000\n100000",
"output": "0.9991000000 1.0001000000\n0.0020000000 0.0000000000\n0.9971000000 1.0001000000\n0.0040000000 0.0000000000\n0.9951000000 1.0001000000\n0.0060000000 0.0000000000\n0.9931000000 1.0001000000\n0.0080000000 0.0000000000\n0.9911000000 1.0001000000\n0.0100000000 0.0000000000\n0.9891000000 1.0001000000\n0.0120000000 0.0000000000\n0.9871000000 1.0001000000\n0.0140000000 0.0000000000\n0.9851000000 1.0001000000\n0.0160000000 0.0000000000\n0.9831000000 1.0001000000\n0.0180000000 0.0000000000\n0.9811000000 1.0001000000..."
},
{
"input": "1.1 99999.9\n100000",
"output": "1.1000000000 0.0000000000\n1.1000000000 1.1000000000\n0.0000000000 1.1000000000\n-0.0000000000 0.0000000000\n1.1000000000 0.0000000000\n1.1000000000 1.1000000000\n0.0000000000 1.1000000000\n-0.0000000000 0.0000000000\n1.1000000000 0.0000000000\n1.1000000000 1.1000000000\n0.0000000000 1.1000000000\n-0.0000000000 0.0000000000\n1.1000000000 0.0000000000\n1.1000000000 1.1000000000\n0.0000000000 1.1000000000\n-0.0000000000 0.0000000000\n1.1000000000 0.0000000000\n1.1000000000 1.1000000000\n0.0000000000 1.100000..."
},
{
"input": "1.0001 99997\n100000",
"output": "0.0000000000 0.9988000000\n0.9975000000 1.0001000000\n1.0001000000 0.0039000000\n0.0052000000 0.0000000000\n0.0000000000 0.9936000000\n0.9923000000 1.0001000000\n1.0001000000 0.0091000000\n0.0104000000 0.0000000000\n0.0000000000 0.9884000000\n0.9871000000 1.0001000000\n1.0001000000 0.0143000000\n0.0156000000 0.0000000000\n0.0000000000 0.9832000000\n0.9819000000 1.0001000000\n1.0001000000 0.0195000000\n0.0208000000 0.0000000000\n0.0000000000 0.9780000000\n0.9767000000 1.0001000000\n1.0001000000 0.0247000000..."
},
{
"input": "1.1101 100000\n100000",
"output": "1.1101000000 1.0819000000\n0.0000000000 0.0564000000\n1.1101000000 1.0255000000\n0.0000000000 0.1128000000\n1.1101000000 0.9691000000\n0.0000000000 0.1692000000\n1.1101000000 0.9127000000\n0.0000000000 0.2256000000\n1.1101000000 0.8563000000\n0.0000000000 0.2820000000\n1.1101000000 0.7999000000\n0.0000000000 0.3384000000\n1.1101000000 0.7435000000\n0.0000000000 0.3948000000\n1.1101000000 0.6871000000\n0.0000000000 0.4512000000\n1.1101000000 0.6307000000\n0.0000000000 0.5076000000\n1.1101000000 0.5743000000..."
}
] | 623 | 9,216,000 | 0 | 55,336 |
|
249 | Endless Matrix | [
"math"
] | null | null | A Russian space traveller Alisa Selezneva, like any other schoolgirl of the late 21 century, is interested in science. She has recently visited the MIT (Moscow Institute of Time), where its chairman and the co-inventor of the time machine academician Petrov told her about the construction of a time machine.
During the demonstration of the time machine performance Alisa noticed that the machine does not have high speed and the girl got interested in the reason for such disadvantage. As it turns out on closer examination, one of the problems that should be solved for the time machine isn't solved by an optimal algorithm. If you find a way to solve this problem optimally, the time machine will run faster and use less energy.
A task that none of the staff can solve optimally is as follows. There exists a matrix *a*, which is filled by the following rule:
The cells are consecutive positive integers, starting with one. Besides, *a**i*,<=*j*<=<<=*a**t*,<=*k* (*i*,<=*j*,<=*t*,<=*k*<=β₯<=1), if:
1. *max*(*i*,<=*j*)<=<<=*max*(*t*,<=*k*); 1. *max*(*i*,<=*j*)<==<=*max*(*t*,<=*k*) and *j*<=<<=*k*; 1. *max*(*i*,<=*j*)<==<=*max*(*t*,<=*k*), *j*<==<=*k* and *i*<=><=*t*.
So, after the first 36 numbers are inserted, matrix *a* will look as follows:
To solve the problem, you should learn to find rather quickly for the given values of *x*1,<=*y*1,<=*x*2 and *y*2 (*x*1<=β€<=*x*2,<=*y*1<=β€<=*y*2) the meaning of expression:
As the meaning of this expression can be large enough, it is sufficient to know only the last 10 digits of the sought value.
So, no one in MTI can solve the given task. Alice was brave enough to use the time machine and travel the past to help you.
Your task is to write a program that uses the given values *x*1,<=*y*1,<=*x*2 and *y*2 finds the last 10 digits of the given expression. | The first input line contains a single integer *t* (1<=β€<=*t*<=β€<=105) β the number of test sets for which you should solve the problem.
Each of the next *t* lines contains the description of a test β four positive integers *x*1,<=*y*1,<=*x*2 and *y*2 (1<=β€<=*x*1<=β€<=*x*2<=β€<=109,<=1<=β€<=*y*1<=β€<=*y*2<=β€<=109), separated by spaces. | For each query print the meaning of the expression if it contains at most 10 characters. Otherwise, print three characters "." (without the quotes), and then ten last digits of the time expression. Print the answer to each query on a single line. Follow the format, given in the sample as closely as possible. | [
"5\n1 1 1 1\n2 2 3 3\n2 3 5 6\n100 87 288 2002\n4 2 5 4\n"
] | [
"1\n24\n300\n...5679392764\n111\n"
] | none | [] | 92 | 0 | 0 | 55,338 |
|
303 | Rotatable Number | [
"math",
"number theory"
] | null | null | Bike is a smart boy who loves math very much. He invented a number called "Rotatable Number" inspired by 142857.
As you can see, 142857 is a magic number because any of its rotatings can be got by multiplying that number by 1,<=2,<=...,<=6 (numbers from one to number's length). Rotating a number means putting its last several digit into first. For example, by rotating number 12345 you can obtain any numbers: 12345,<=51234,<=45123,<=34512,<=23451. It's worth mentioning that leading-zeroes are allowed. So both 4500123 and 0123450 can be obtained by rotating 0012345. You can see why 142857 satisfies the condition. All of the 6 equations are under base 10.
- 142857Β·1<==<=142857; - 142857Β·2<==<=285714; - 142857Β·3<==<=428571; - 142857Β·4<==<=571428; - 142857Β·5<==<=714285; - 142857Β·6<==<=857142.
Now, Bike has a problem. He extends "Rotatable Number" under any base *b*. As is mentioned above, 142857 is a "Rotatable Number" under base 10. Another example is 0011 under base 2. All of the 4 equations are under base 2.
- 0011Β·1<==<=0011; - 0011Β·10<==<=0110; - 0011Β·11<==<=1001; - 0011Β·100<==<=1100.
So, he wants to find the largest *b* (1<=<<=*b*<=<<=*x*) so that there is a positive "Rotatable Number" (leading-zeroes allowed) of length *n* under base *b*.
Note that any time you multiply a rotatable number by numbers from 1 to its length you should get a rotating of that number. | The only line contains two space-separated integers *n*,<=*x* (1<=β€<=*n*<=β€<=5Β·106,<=2<=β€<=*x*<=β€<=109). | Print a single integer β the largest *b* you found. If no such *b* exists, print -1 instead. | [
"6 11\n",
"5 8\n"
] | [
"10\n",
"-1\n"
] | none | [] | 2,000 | 307,200 | 0 | 55,341 |
|
545 | Paths and Trees | [
"graphs",
"greedy",
"shortest paths"
] | null | null | Little girl Susie accidentally found her elder brother's notebook. She has many things to do, more important than solving problems, but she found this problem too interesting, so she wanted to know its solution and decided to ask you about it. So, the problem statement is as follows.
Let's assume that we are given a connected weighted undirected graph *G*<==<=(*V*,<=*E*) (here *V* is the set of vertices, *E* is the set of edges). The shortest-path tree from vertex *u* is such graph *G*1<==<=(*V*,<=*E*1) that is a tree with the set of edges *E*1 that is the subset of the set of edges of the initial graph *E*, and the lengths of the shortest paths from *u* to any vertex to *G* and to *G*1 are the same.
You are given a connected weighted undirected graph *G* and vertex *u*. Your task is to find the shortest-path tree of the given graph from vertex *u*, the total weight of whose edges is minimum possible. | The first line contains two numbers, *n* and *m* (1<=β€<=*n*<=β€<=3Β·105, 0<=β€<=*m*<=β€<=3Β·105) β the number of vertices and edges of the graph, respectively.
Next *m* lines contain three integers each, representing an edge β *u**i*,<=*v**i*,<=*w**i* β the numbers of vertices connected by an edge and the weight of the edge (*u**i*<=β <=*v**i*,<=1<=β€<=*w**i*<=β€<=109). It is guaranteed that graph is connected and that there is no more than one edge between any pair of vertices.
The last line of the input contains integer *u* (1<=β€<=*u*<=β€<=*n*) β the number of the start vertex. | In the first line print the minimum total weight of the edges of the tree.
In the next line print the indices of the edges that are included in the tree, separated by spaces. The edges are numbered starting from 1 in the order they follow in the input. You may print the numbers of the edges in any order.
If there are multiple answers, print any of them. | [
"3 3\n1 2 1\n2 3 1\n1 3 2\n3\n",
"4 4\n1 2 1\n2 3 1\n3 4 1\n4 1 2\n4\n"
] | [
"2\n1 2 \n",
"4\n2 3 4 \n"
] | In the first sample there are two possible shortest path trees:
- with edges 1βββ3 and 2βββ3 (the total weight is 3); - with edges 1βββ2 and 2βββ3 (the total weight is 2);
And, for example, a tree with edges 1βββ2 and 1βββ3 won't be a shortest path tree for vertex 3, because the distance from vertex 3 to vertex 2 in this tree equals 3, and in the original graph it is 1. | [
{
"input": "3 3\n1 2 1\n2 3 1\n1 3 2\n3",
"output": "2\n1 2 "
},
{
"input": "4 4\n1 2 1\n2 3 1\n3 4 1\n4 1 2\n4",
"output": "4\n2 3 4 "
},
{
"input": "4 5\n1 2 1\n1 3 1\n2 4 1\n3 4 1\n2 3 10\n1",
"output": "3\n1 2 3 "
},
{
"input": "6 8\n1 2 30\n1 3 20\n2 3 50\n4 2 100\n2 5 40\n3 5 10\n3 6 50\n5 6 60\n4",
"output": "230\n1 4 5 6 7 "
},
{
"input": "1 0\n1",
"output": "0"
},
{
"input": "2 1\n1 2 1000000000\n2",
"output": "1000000000\n1 "
}
] | 2,635 | 76,288,000 | 3 | 55,582 |
|
989 | A Trance of Nightfall | [
"dp",
"geometry",
"matrices",
"probabilities"
] | null | null | "Flowing and passing like this, the water isn't gone ultimately; Waxing and waning like that, the moon doesn't shrink or grow eventually."
"Everything is transient in a way and perennial in another."
Kanno doesn't seem to make much sense out of Mino's isolated words, but maybe it's time that they enjoy the gentle breeze and the night skyΒ β the inexhaustible gifts from nature.
Gazing into the sky of stars, Kanno indulges in a night's tranquil dreams.
There is a set $S$ of $n$ points on a coordinate plane.
Kanno starts from a point $P$ that can be chosen on the plane. $P$ is not added to $S$ if it doesn't belong to $S$. Then the following sequence of operations (altogether called a move) is repeated several times, in the given order:
1. Choose a line $l$ such that it passes through at least two elements in $S$ and passes through Kanno's current position. If there are multiple such lines, one is chosen equiprobably. 1. Move to one of the points that belong to $S$ and lie on $l$. The destination is chosen equiprobably among all possible ones, including Kanno's current position (if it does belong to $S$).
There are $q$ queries each consisting of two integers $(t_i, m_i)$. For each query, you're to help Kanno maximize the probability of the stopping position being the $t_i$-th element in $S$ after $m_i$ moves with a proper selection of $P$, and output this maximum probability. Note that according to rule 1, $P$ should belong to at least one line that passes through at least two points from $S$. | The first line contains a positive integer $n$ ($2 \leq n \leq 200$)Β β the number of points in $S$.
The $i$-th of the following $n$ lines contains two space-separated integers $x_i$ and $y_i$ ($-10^4 \leq x_i, y_i \leq 10^4$)Β β the coordinates of the $i$-th point in $S$. The input guarantees that for all $1 \leq i \lt j \leq n$, $(x_i, y_i) \neq (x_j, y_j)$ holds.
The next line contains a positive integer $q$ ($1 \leq q \leq 200$)Β β the number of queries.
Each of the following $q$ lines contains two space-separated integers $t$ and $m$ ($1 \leq t_i \leq n$, $1 \leq m_i \leq 10^4$)Β β the index of the target point and the number of moves, respectively. | Output $q$ lines each containing a decimal numberΒ β the $i$-th among them denotes the maximum probability of staying on the $t_i$-th point after $m_i$ steps, with a proper choice of starting position $P$.
Your answer will be considered correct if each number in your output differs from the corresponding one in jury's answer by at most $10^{-6}$.
Formally, let your answer be $a$, and the jury's answer be $b$. Your answer is considered correct if $|a - b| \le 10^{-6}$. | [
"5\n0 0\n1 3\n2 2\n3 1\n4 4\n10\n1 1\n2 1\n3 1\n4 1\n5 1\n3 2\n3 3\n3 4\n3 5\n3 6\n"
] | [
"0.50000000000000000000\n0.50000000000000000000\n0.33333333333333331483\n0.50000000000000000000\n0.50000000000000000000\n0.18518518518518517491\n0.15226337448559670862\n0.14494741655235482414\n0.14332164812274550414\n0.14296036624949901017\n"
] | The points in $S$ and possible candidates for line $l$ are depicted in the following figure.
For the first query, when $P = (-1, -3)$, $l$ is uniquely determined to be $3x = y$, and thus Kanno will move to $(0, 0)$ with a probability of $\frac 1 2$.
For the third query, when $P = (2, 2)$, $l$ is chosen equiprobably between $x + y = 4$ and $x = y$. Kanno will then move to the other four points with a probability of $\frac 1 2 \cdot \frac 1 3 = \frac 1 6$ each, or stay at $(2, 2)$ with a probability of $\frac 1 3$. | [] | 2,000 | 614,400 | 0 | 55,793 |
|
51 | bHTML Tables Analisys | [
"expression parsing"
] | B. bHTML Tables Analisys | 2 | 256 | In this problem is used an extremely simplified version of HTML table markup. Please use the statement as a formal document and read it carefully.
A string is a bHTML table, if it satisfies the grammar:
Blanks in the grammar are only for purposes of illustration, in the given data there will be no spaces. The bHTML table is very similar to a simple regular HTML table in which meet only the following tags : "table", "tr", "td", all the tags are paired and the table contains at least one row and at least one cell in each row. Have a look at the sample tests as examples of tables.
As can be seen, the tables may be nested. You are given a table (which may contain other(s)). You need to write a program that analyzes all the tables and finds the number of cells in each of them. The tables are not required to be rectangular. | For convenience, input data can be separated into non-empty lines in an arbitrary manner. The input data consist of no more than 10 lines. Combine (concatenate) all the input lines into one, to get a text representation *s* of the specified table. String *s* corresponds to the given grammar (the root element of grammar is TABLE), its length does not exceed 5000. Only lower case letters are used to write tags. There are no spaces in the given string *s*. | Print the sizes of all the tables in the non-decreasing order. | [
"<table><tr><td></td></tr></table>\n",
"<table>\n<tr>\n<td>\n<table><tr><td></td></tr><tr><td></\ntd\n></tr><tr\n><td></td></tr><tr><td></td></tr></table>\n</td>\n</tr>\n</table>\n",
"<table><tr><td>\n<table><tr><td>\n<table><tr><td>\n<table><tr><td></td><td></td>\n</tr><tr><td></td></tr></table>\n</td></tr></table>\n</td></tr></table>\n</td></tr></table>\n"
] | [
"1 ",
"1 4 ",
"1 1 1 3 "
] | none | [
{
"input": "<table><tr><td></td></tr></table>",
"output": "1 "
},
{
"input": "<table>\n<tr>\n<td>\n<table><tr><td></td></tr><tr><td></\ntd\n></tr><tr\n><td></td></tr><tr><td></td></tr></table>\n</td>\n</tr>\n</table>",
"output": "1 4 "
},
{
"input": "<table><tr><td>\n<table><tr><td>\n<table><tr><td>\n<table><tr><td></td><td></td>\n</tr><tr><td></td></tr></table>\n</td></tr></table>\n</td></tr></table>\n</td></tr></table>",
"output": "1 1 1 3 "
},
{
"input": "<\nt\na\nble><tr><td></td>\n</\ntr>\n</\nt\nab\nle>",
"output": "1 "
},
{
"input": "<table><tr><td><table><tr><td></td></tr></table></td></tr></table>",
"output": "1 1 "
},
{
"input": "<table><tr><td><table><tr><td><table><tr><td></td></tr></table></td></tr></table></td></tr></table>",
"output": "1 1 1 "
},
{
"input": "<table><tr><td><table><tr><td></td></tr></table></td></tr></table>",
"output": "1 1 "
},
{
"input": "<table><tr><td><table><tr><td><table><tr><td></td></tr></table></td></tr></table></td></tr></table>",
"output": "1 1 1 "
},
{
"input": "<table><tr><td><table><tr><td></td><td></td></tr></table></td><td><table><tr><td></td></tr></table></td></tr></table>",
"output": "1 2 2 "
},
{
"input": "<table><tr><td><table><tr><td></td><td></td></tr></table></td><td><table><tr><td></td></tr></table></td></tr></table>",
"output": "1 2 2 "
},
{
"input": "<table><tr><td><table><tr><td></td></tr></table></td></tr><tr><td><table><tr><td><table><tr><td></td></tr></table></td></tr></table></td></tr></table>",
"output": "1 1 1 2 "
},
{
"input": "<table><tr><td><table><tr><td><table><tr><td><table><tr><td><table><tr><td><table><tr><td><table><tr><td><table><tr><td><table><tr><td><table><tr><td><table><tr><td><table><tr><td><table><tr><td><table><tr><td></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table>",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 "
}
] | 62 | 0 | 0 | 55,942 |
833 | The Bakery | [
"binary search",
"data structures",
"divide and conquer",
"dp",
"two pointers"
] | null | null | Some time ago Slastyona the Sweetmaid decided to open her own bakery! She bought required ingredients and a wonder-oven which can bake several types of cakes, and opened the bakery.
Soon the expenses started to overcome the income, so Slastyona decided to study the sweets market. She learned it's profitable to pack cakes in boxes, and that the more distinct cake types a box contains (let's denote this number as the value of the box), the higher price it has.
She needs to change the production technology! The problem is that the oven chooses the cake types on its own and Slastyona can't affect it. However, she knows the types and order of *n* cakes the oven is going to bake today. Slastyona has to pack exactly *k* boxes with cakes today, and she has to put in each box several (at least one) cakes the oven produced one right after another (in other words, she has to put in a box a continuous segment of cakes).
Slastyona wants to maximize the total value of all boxes with cakes. Help her determine this maximum possible total value. | The first line contains two integers *n* and *k* (1<=β€<=*n*<=β€<=35000, 1<=β€<=*k*<=β€<=*min*(*n*,<=50))Β β the number of cakes and the number of boxes, respectively.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a**i*<=β€<=*n*)Β β the types of cakes in the order the oven bakes them. | Print the only integerΒ β the maximum total value of all boxes with cakes. | [
"4 1\n1 2 2 1\n",
"7 2\n1 3 3 1 4 4 4\n",
"8 3\n7 7 8 7 7 8 1 7\n"
] | [
"2\n",
"5\n",
"6\n"
] | In the first example Slastyona has only one box. She has to put all cakes in it, so that there are two types of cakes in the box, so the value is equal to 2.
In the second example it is profitable to put the first two cakes in the first box, and all the rest in the second. There are two distinct types in the first box, and three in the second box then, so the total value is 5. | [
{
"input": "4 1\n1 2 2 1",
"output": "2"
},
{
"input": "7 2\n1 3 3 1 4 4 4",
"output": "5"
},
{
"input": "8 3\n7 7 8 7 7 8 1 7",
"output": "6"
},
{
"input": "50 5\n2 39 16 20 32 36 29 42 14 23 9 4 28 17 45 16 46 1 39 33 47 15 34 43 6 6 12 15 46 11 32 16 31 12 41 33 47 35 22 3 10 4 9 36 22 22 17 33 15 46",
"output": "49"
},
{
"input": "50 6\n41 23 41 16 33 6 25 15 15 11 14 12 21 2 16 42 25 3 5 17 37 11 10 50 33 28 1 35 9 50 40 8 33 14 43 34 8 42 6 31 21 11 39 34 2 30 33 44 38 45",
"output": "50"
},
{
"input": "50 7\n34 49 9 4 29 13 17 46 12 12 14 20 11 36 33 19 46 5 28 48 35 7 31 7 21 47 3 5 26 42 6 50 27 15 45 39 20 48 1 5 37 30 11 36 28 35 8 13 19 45",
"output": "50"
},
{
"input": "1 1\n1",
"output": "1"
},
{
"input": "42 12\n18 1 14 10 6 40 25 10 39 7 36 25 36 11 11 24 38 27 22 26 41 38 24 35 1 6 15 40 7 14 41 11 38 5 41 32 28 2 38 22 12 2",
"output": "42"
},
{
"input": "2 2\n1 1",
"output": "2"
}
] | 2,500 | 4,608,000 | 0 | 56,169 |
|
386 | Diverse Substrings | [
"dp",
"strings",
"two pointers"
] | null | null | String diversity is the number of symbols that occur in the string at least once. Diversity of *s* will be denoted by *d*(*s*). For example , *d*("aaa")=1, *d*("abacaba")=3.
Given a string *s*, consisting of lowercase Latin letters. Consider all its substrings. Obviously, any substring diversity is a number from 1 to *d*(*s*). Find statistics about substrings diversity: for each *k* from 1 to *d*(*s*), find how many substrings of *s* has a diversity of exactly *k*. | The input consists of a single line containing *s*. It contains only lowercase Latin letters, the length of *s* is from 1 to 3Β·105. | Print to the first line the value *d*(*s*). Print sequence *t*1,<=*t*2,<=...,<=*t**d*(*s*) to the following lines, where *t**i* is the number of substrings of *s* having diversity of exactly *i*. | [
"abca\n",
"aabacaabbad\n"
] | [
"3\n4\n3\n3\n",
"4\n14\n19\n28\n5\n"
] | Consider the first example.
We denote by *s*(*i*,β*j*) a substring of "abca" with the indices in the segment [*i*,β*j*].
- *s*(1,β1)β=β "a", *d*("a")β=β1 - *s*(2,β2)β=β "b", *d*("b")β=β1 - *s*(3,β3)β=β "c", *d*("c")β=β1 - *s*(4,β4)β=β "a", *d*("a")β=β1 - *s*(1,β2)β=β "ab", *d*("ab")β=β2 - *s*(2,β3)β=β "bc", *d*("bc")β=β2 - *s*(3,β4)β=β "ca", *d*("ca")β=β2 - *s*(1,β3)β=β "abc", *d*("abc")β=β3 - *s*(2,β4)β=β "bca", *d*("bca")β=β3 - *s*(1,β4)β=β "abca", *d*("abca")β=β3
Total number of substring with diversity 1 is 4, with diversity 2 equals 3, 3 diversity is 3. | [
{
"input": "abca",
"output": "3\n4\n3\n3"
},
{
"input": "aabacaabbad",
"output": "4\n14\n19\n28\n5"
},
{
"input": "a",
"output": "1\n1"
},
{
"input": "cabaccbcaa",
"output": "3\n12\n13\n30"
},
{
"input": "ccabaccbbb",
"output": "3\n15\n13\n27"
},
{
"input": "accbbaabaa",
"output": "3\n14\n24\n17"
},
{
"input": "bdbdeabeecddebabaebbcaeabeabcadcbcacebdebaaadbcebabacdedbadadbcbdeccabecbecedcbdadbaabdaaaeebbdddcde",
"output": "5\n116\n140\n215\n377\n4202"
},
{
"input": "faaacffcdacdbafffebbaecbbddadbafcddfbbafbebedafcbbccdefcfcddbdefbaabbeacbdcadfdfbeffdbccdbbcefdbeacf",
"output": "6\n120\n138\n171\n226\n469\n3926"
},
{
"input": "ccdfadbdcdadgcgabgcebbccebeabbcebeeacabcbcbdgebabeebbbbecgedecedbeabceegdbbaggagggfgbddgddaaaafeggad",
"output": "7\n127\n166\n208\n394\n478\n2183\n1494"
},
{
"input": "bbcbcaabaccbbbbbccbccbabcaacbacbacacbacbaabbcaccaabccabcaacababcabbacaacccbcbbbcccbacbcbaccbbbaaccca",
"output": "3\n141\n268\n4641"
},
{
"input": "edcdedddbceddbbccceecbdebdaeadeaaeedbdbbbcdaaabaccaadabdcaeeecbdadbebdbeceedbdedcecadecbdeccdeacedce",
"output": "5\n124\n157\n221\n676\n3872"
},
{
"input": "bacebgfbaceddfbfbddaadfgadfcgdfcbeefdfafggadgbfeebcgafefedafgaebafbaadedbffdgcdfacaegeacecgbeabggfed",
"output": "7\n109\n123\n149\n214\n304\n424\n3727"
},
{
"input": "gefighcgdehbaidhajhfhhigfgdbhabejcadbdbecfiabgjdecedbcicggfdajahjgbdbfheggibhieijdjihcfgbbbchddjdcci",
"output": "10\n108\n120\n126\n142\n149\n186\n223\n271\n680\n3045"
},
{
"input": "oqhvuewbdwqslxqigksfkuykyrfnzpbjdispjazvmyvbthdoquzeldlxuzjowjoxebgogjwhxgordphgbmtrkfooknjvjigskskz",
"output": "25\n101\n107\n114\n110\n117\n127\n137\n152\n148\n140\n172\n152\n172\n186\n173\n186\n183\n198\n202\n181\n194\n214\n174\n224\n1186"
},
{
"input": "cbbaacbaba",
"output": "3\n12\n15\n28"
},
{
"input": "acabaaabbc",
"output": "3\n14\n22\n19"
},
{
"input": "bccbcabaaa",
"output": "3\n14\n17\n24"
},
{
"input": "cbbcaaaabc",
"output": "3\n17\n14\n24"
},
{
"input": "caacbbbbab",
"output": "3\n17\n18\n20"
},
{
"input": "bbbbaccbac",
"output": "3\n17\n10\n28"
}
] | 78 | 0 | 0 | 56,210 |
|
398 | Cards | [
"constructive algorithms",
"implementation"
] | null | null | User ainta loves to play with cards. He has *a* cards containing letter "o" and *b* cards containing letter "x". He arranges the cards in a row, and calculates the score of the deck by the formula below.
1. At first, the score is 0. 1. For each block of contiguous "o"s with length *x* the score increases by *x*2. 1. For each block of contiguous "x"s with length *y* the score decreases by *y*2.
For example, if *a*<==<=6,<=*b*<==<=3 and ainta have arranged the cards in the order, that is described by string "ooxoooxxo", the score of the deck equals 22<=-<=12<=+<=32<=-<=22<=+<=12<==<=9. That is because the deck has 5 blocks in total: "oo", "x", "ooo", "xx", "o".
User ainta likes big numbers, so he wants to maximize the score with the given cards. Help ainta make the score as big as possible. Note, that he has to arrange all his cards. | The first line contains two space-separated integers *a* and *b* (0<=β€<=*a*,<=*b*<=β€<=105;Β *a*<=+<=*b*<=β₯<=1) β the number of "o" cards and the number of "x" cards. | In the first line print a single integer *v* β the maximum score that ainta can obtain.
In the second line print *a*<=+<=*b* characters describing the deck. If the *k*-th card of the deck contains "o", the *k*-th character must be "o". If the *k*-th card of the deck contains "x", the *k*-th character must be "x". The number of "o" characters must be equal to *a*, and the number of "x " characters must be equal to *b*. If there are many ways to maximize *v*, print any.
Please, do not write the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier. | [
"2 3\n",
"4 0\n",
"0 4\n"
] | [
"-1\nxoxox\n",
"16\noooo",
"-16\nxxxx"
] | none | [
{
"input": "2 3",
"output": "-1\nxoxox"
},
{
"input": "4 0",
"output": "16\noooo"
},
{
"input": "0 4",
"output": "-16\nxxxx"
},
{
"input": "8 6",
"output": "46\nxxxooooooooxxx"
},
{
"input": "28691 28312",
"output": "809737773\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "1 1",
"output": "0\nox"
},
{
"input": "46000 39000",
"output": "2092541530\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "1234 5678",
"output": "976892\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "19310 18",
"output": "372875938\nxxxxxxxxxooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "38 5",
"output": "1431\nxxxooooooooooooooooooooooooooooooooooooooxx"
},
{
"input": "2 122",
"output": "-4960\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
},
{
"input": "9966 12376",
"output": "95873950\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "4 2",
"output": "14\nxoooox"
},
{
"input": "0 26501",
"output": "-702303001\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx..."
},
{
"input": "500 500",
"output": "220582\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "98751 29491",
"output": "9725946462\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "1 18468",
"output": "-170533511\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx..."
},
{
"input": "75232 0",
"output": "5659853824\nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "83093 94343",
"output": "6827912284\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "86224 91008",
"output": "7359384778\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "92608 85844",
"output": "8502762302\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "94989 92701",
"output": "8942524504\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "83195 80484",
"output": "6856118621\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "4 9",
"output": "-13\nxxoxxoxxoxxox"
},
{
"input": "8 10",
"output": "16\nxxxxoooooooxxxoxxx"
},
{
"input": "223 874",
"output": "15479\nxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxx..."
},
{
"input": "206 209",
"output": "34847\nxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxx"
},
{
"input": "493 442",
"output": "217415\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "18931 31308",
"output": "346300009\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "21944 37439",
"output": "465971835\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "29626 16323",
"output": "869876049\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "78912 100000",
"output": "6148027918\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "5 17",
"output": "-44\nxxxoxxxoxxxoxxxoxxxoxx"
},
{
"input": "2 60570",
"output": "-1222908298\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx..."
},
{
"input": "23 89946",
"output": "-337095103\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx..."
},
{
"input": "7 18030",
"output": "-40635107\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx..."
},
{
"input": "27813 15",
"output": "773562856\nxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "29648 34",
"output": "879003326\nxxxxxxxxxxxxxxxxxooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "25661 14735",
"output": "651917342\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "2596 14758",
"output": "4665910\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "21478 14813",
"output": "455254951\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "1454 26690",
"output": "-444804\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "31161 18112",
"output": "962094403\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "1698 32709",
"output": "-523357\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "749 9800",
"output": "-113239\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoxxxxxxxxxxxxxxxxxxxxxxxxxxxxxo..."
},
{
"input": "79123 95821",
"output": "6184587446\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "79979 92032",
"output": "6323396597\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "99979 12032",
"output": "9985440319\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "1 2",
"output": "-1\nxox"
},
{
"input": "2 1",
"output": "3\noox"
},
{
"input": "1 1",
"output": "0\nox"
},
{
"input": "1 0",
"output": "1\no"
},
{
"input": "0 1",
"output": "-1\nx"
},
{
"input": "2 2",
"output": "2\nxoox"
},
{
"input": "4 1",
"output": "15\noooox"
},
{
"input": "4 2",
"output": "14\nxoooox"
},
{
"input": "4 3",
"output": "11\nxxoooox"
},
{
"input": "4 4",
"output": "8\nxxooooxx"
},
{
"input": "4 5",
"output": "3\nxxxooooxx"
},
{
"input": "4 6",
"output": "-2\nxxxooooxxx"
},
{
"input": "4 7",
"output": "-7\nxxxoooxxoxx"
},
{
"input": "99999 99997",
"output": "9910809718\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooooooooooooooooooooooooooooooo..."
}
] | 108 | 102,400 | 0 | 56,293 |
|
757 | Team Rocket Rises Again | [
"data structures",
"graphs",
"shortest paths"
] | null | null | It's the turn of the year, so Bash wants to send presents to his friends. There are *n* cities in the Himalayan region and they are connected by *m* bidirectional roads. Bash is living in city *s*. Bash has exactly one friend in each of the other cities. Since Bash wants to surprise his friends, he decides to send a Pikachu to each of them. Since there may be some cities which are not reachable from Bash's city, he only sends a Pikachu to those friends who live in a city reachable from his own city. He also wants to send it to them as soon as possible.
He finds out the minimum time for each of his Pikachus to reach its destination city. Since he is a perfectionist, he informs all his friends with the time their gift will reach them. A Pikachu travels at a speed of 1 meters per second. His friends were excited to hear this and would be unhappy if their presents got delayed. Unfortunately Team Rocket is on the loose and they came to know of Bash's plan. They want to maximize the number of friends who are unhappy with Bash.
They do this by destroying exactly one of the other *n*<=-<=1 cities. This implies that the friend residing in that city dies, so he is unhappy as well.
Note that if a city is destroyed, all the roads directly connected to the city are also destroyed and the Pikachu may be forced to take a longer alternate route.
Please also note that only friends that are waiting for a gift count as unhappy, even if they die.
Since Bash is already a legend, can you help Team Rocket this time and find out the maximum number of Bash's friends who can be made unhappy by destroying exactly one city. | The first line contains three space separated integers *n*, *m* and *s* (2<=β€<=*n*<=β€<=2Β·105, , 1<=β€<=*s*<=β€<=*n*)Β β the number of cities and the number of roads in the Himalayan region and the city Bash lives in.
Each of the next *m* lines contain three space-separated integers *u*, *v* and *w* (1<=β€<=*u*,<=*v*<=β€<=*n*, *u*<=β <=*v*, 1<=β€<=*w*<=β€<=109) denoting that there exists a road between city *u* and city *v* of length *w* meters.
It is guaranteed that no road connects a city to itself and there are no two roads that connect the same pair of cities. | Print a single integer, the answer to the problem. | [
"4 4 3\n1 2 1\n2 3 1\n2 4 1\n3 1 1\n",
"7 11 2\n1 2 5\n1 3 5\n2 4 2\n2 5 2\n3 6 3\n3 7 3\n4 6 2\n3 4 2\n6 7 3\n4 5 7\n4 7 7\n"
] | [
"2\n",
"4\n"
] | In the first sample, on destroying the city 2, the length of shortest distance between pairs of cities (3,β2) and (3,β4) will change. Hence the answer is 2. | [] | 93 | 512,000 | 0 | 56,348 |
|
581 | Three Logos | [
"bitmasks",
"brute force",
"constructive algorithms",
"geometry",
"implementation",
"math"
] | null | null | Three companies decided to order a billboard with pictures of their logos. A billboard is a big square board. A logo of each company is a rectangle of a non-zero area.
Advertisers will put up the ad only if it is possible to place all three logos on the billboard so that they do not overlap and the billboard has no empty space left. When you put a logo on the billboard, you should rotate it so that the sides were parallel to the sides of the billboard.
Your task is to determine if it is possible to put the logos of all the three companies on some square billboard without breaking any of the described rules. | The first line of the input contains six positive integers *x*1,<=*y*1,<=*x*2,<=*y*2,<=*x*3,<=*y*3 (1<=β€<=*x*1,<=*y*1,<=*x*2,<=*y*2,<=*x*3,<=*y*3<=β€<=100), where *x**i* and *y**i* determine the length and width of the logo of the *i*-th company respectively. | If it is impossible to place all the three logos on a square shield, print a single integer "-1" (without the quotes).
If it is possible, print in the first line the length of a side of square *n*, where you can place all the three logos. Each of the next *n* lines should contain *n* uppercase English letters "A", "B" or "C". The sets of the same letters should form solid rectangles, provided that:
- the sizes of the rectangle composed from letters "A" should be equal to the sizes of the logo of the first company, - the sizes of the rectangle composed from letters "B" should be equal to the sizes of the logo of the second company, - the sizes of the rectangle composed from letters "C" should be equal to the sizes of the logo of the third company,
Note that the logos of the companies can be rotated for printing on the billboard. The billboard mustn't have any empty space. If a square billboard can be filled with the logos in multiple ways, you are allowed to print any of them.
See the samples to better understand the statement. | [
"5 1 2 5 5 2\n",
"4 4 2 6 4 2\n"
] | [
"5\nAAAAA\nBBBBB\nBBBBB\nCCCCC\nCCCCC\n",
"6\nBBBBBB\nBBBBBB\nAAAACC\nAAAACC\nAAAACC\nAAAACC\n"
] | none | [
{
"input": "5 1 2 5 5 2",
"output": "5\nAAAAA\nBBBBB\nBBBBB\nCCCCC\nCCCCC"
},
{
"input": "4 4 2 6 4 2",
"output": "6\nBBBBBB\nBBBBBB\nAAAACC\nAAAACC\nAAAACC\nAAAACC"
},
{
"input": "1 3 1 3 3 1",
"output": "3\nAAA\nBBB\nCCC"
},
{
"input": "2 4 1 4 1 4",
"output": "4\nAAAA\nAAAA\nBBBB\nCCCC"
},
{
"input": "7 2 7 2 7 3",
"output": "7\nAAAAAAA\nAAAAAAA\nBBBBBBB\nBBBBBBB\nCCCCCCC\nCCCCCCC\nCCCCCCC"
},
{
"input": "1 10 6 10 3 10",
"output": "10\nAAAAAAAAAA\nBBBBBBBBBB\nBBBBBBBBBB\nBBBBBBBBBB\nBBBBBBBBBB\nBBBBBBBBBB\nBBBBBBBBBB\nCCCCCCCCCC\nCCCCCCCCCC\nCCCCCCCCCC"
},
{
"input": "20 1 20 1 18 20",
"output": "20\nAAAAAAAAAAAAAAAAAAAA\nBBBBBBBBBBBBBBBBBBBB\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCC"
},
{
"input": "75 31 69 100 25 31",
"output": "100\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB..."
},
{
"input": "6 23 23 12 5 23",
"output": "23\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBB\nCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCC..."
},
{
"input": "40 12 2 40 26 40",
"output": "40\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nBBB..."
},
{
"input": "3 49 1 49 49 45",
"output": "49\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC..."
},
{
"input": "56 6 35 56 15 56",
"output": "56\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB..."
},
{
"input": "70 6 70 62 70 2",
"output": "70\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBB..."
},
{
"input": "80 65 80 12 3 80",
"output": "80\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAA..."
},
{
"input": "90 20 54 90 90 16",
"output": "90\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "75 100 19 100 6 100",
"output": "100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "17 100 100 22 61 100",
"output": "100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "19 100 67 100 100 14",
"output": "100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "15 100 100 12 100 73",
"output": "100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "100 69 100 10 21 100",
"output": "100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "100 8 31 100 61 100",
"output": "100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "33 100 100 65 100 2",
"output": "100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "67 100 100 16 17 100",
"output": "100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "2 1 3 1 2 2",
"output": "3\nBBB\nACC\nACC"
},
{
"input": "1 2 2 4 3 2",
"output": "4\nBBBB\nBBBB\nACCC\nACCC"
},
{
"input": "7 4 3 3 4 3",
"output": "7\nAAAAAAA\nAAAAAAA\nAAAAAAA\nAAAAAAA\nBBBCCCC\nBBBCCCC\nBBBCCCC"
},
{
"input": "2 1 9 10 1 8",
"output": "10\nBBBBBBBBBB\nBBBBBBBBBB\nBBBBBBBBBB\nBBBBBBBBBB\nBBBBBBBBBB\nBBBBBBBBBB\nBBBBBBBBBB\nBBBBBBBBBB\nBBBBBBBBBB\nAACCCCCCCC"
},
{
"input": "20 4 8 16 12 16",
"output": "20\nAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAA\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCC"
},
{
"input": "9 23 14 8 15 14",
"output": "23\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAA\nBBBBBBBBCCCCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCCCCC\nBBBBBBBBCCCCCCCCCCCCCCC\nBBBBBBB..."
},
{
"input": "1 37 3 40 37 39",
"output": "40\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nACC..."
},
{
"input": "2 37 2 12 47 49",
"output": "49\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC..."
},
{
"input": "25 25 56 31 31 25",
"output": "56\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB..."
},
{
"input": "70 64 6 43 27 6",
"output": "70\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAA..."
},
{
"input": "80 46 34 35 45 34",
"output": "80\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAA..."
},
{
"input": "5 48 90 85 5 42",
"output": "90\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB..."
},
{
"input": "100 95 5 79 5 21",
"output": "100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "75 66 25 66 100 34",
"output": "100\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC..."
},
{
"input": "67 45 45 33 100 55",
"output": "100\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC..."
},
{
"input": "13 68 100 87 13 32",
"output": "100\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB..."
},
{
"input": "100 20 96 80 80 4",
"output": "100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "100 73 27 35 65 27",
"output": "100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "100 12 88 61 39 88",
"output": "100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA..."
},
{
"input": "100 100 100 100 100 100",
"output": "-1"
},
{
"input": "1 100 100 1 1 100",
"output": "-1"
},
{
"input": "100 100 100 1 100 100",
"output": "-1"
},
{
"input": "3 8 4 8 2 8",
"output": "-1"
},
{
"input": "70 7 70 2 70 62",
"output": "-1"
},
{
"input": "6 100 20 100 75 100",
"output": "-1"
},
{
"input": "17 100 62 100 100 22",
"output": "-1"
},
{
"input": "2 3 2 5 5 8",
"output": "-1"
},
{
"input": "70 10 47 59 23 59",
"output": "-1"
},
{
"input": "42 69 41 31 58 100",
"output": "-1"
},
{
"input": "96 70 3 100 30 96",
"output": "-1"
},
{
"input": "1 1 2 2 2 2",
"output": "-1"
},
{
"input": "2 5 6 7 3 4",
"output": "-1"
},
{
"input": "2 3 2 3 2 2",
"output": "-1"
},
{
"input": "1 1 1 1 1 1",
"output": "-1"
},
{
"input": "5 31 95 90 64 5",
"output": "95\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBB..."
},
{
"input": "23 36 57 80 44 23",
"output": "80\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBB..."
},
{
"input": "4 53 92 88 4 39",
"output": "92\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB..."
},
{
"input": "12 51 78 90 39 12",
"output": "90\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB..."
},
{
"input": "37 44 90 53 37 46",
"output": "90\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB..."
},
{
"input": "40 9 72 81 41 9",
"output": "81\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nBBBBBBBBB..."
}
] | 93 | 0 | 3 | 56,389 |
|
954 | Matrix Walk | [
"implementation"
] | null | null | There is a matrix *A* of size *x*<=Γ<=*y* filled with integers. For every , *A**i*,<=*j*<==<=*y*(*i*<=-<=1)<=+<=*j*. Obviously, every integer from [1..*xy*] occurs exactly once in this matrix.
You have traversed some path in this matrix. Your path can be described as a sequence of visited cells *a*1, *a*2, ..., *a**n* denoting that you started in the cell containing the number *a*1, then moved to the cell with the number *a*2, and so on.
From the cell located in *i*-th line and *j*-th column (we denote this cell as (*i*,<=*j*)) you can move into one of the following cells:
1. (*i*<=+<=1,<=*j*) β only if *i*<=<<=*x*; 1. (*i*,<=*j*<=+<=1) β only if *j*<=<<=*y*; 1. (*i*<=-<=1,<=*j*) β only if *i*<=><=1; 1. (*i*,<=*j*<=-<=1) β only if *j*<=><=1.
Notice that making a move requires you to go to an adjacent cell. It is not allowed to stay in the same cell. You don't know *x* and *y* exactly, but you have to find any possible values for these numbers such that you could start in the cell containing the integer *a*1, then move to the cell containing *a*2 (in one step), then move to the cell containing *a*3 (also in one step) and so on. Can you choose *x* and *y* so that they don't contradict with your sequence of moves? | The first line contains one integer number *n* (1<=β€<=*n*<=β€<=200000) β the number of cells you visited on your path (if some cell is visited twice, then it's listed twice).
The second line contains *n* integers *a*1, *a*2, ..., *a**n* (1<=β€<=*a**i*<=β€<=109) β the integers in the cells on your path. | If all possible values of *x* and *y* such that 1<=β€<=*x*,<=*y*<=β€<=109 contradict with the information about your path, print NO.
Otherwise, print YES in the first line, and in the second line print the values *x* and *y* such that your path was possible with such number of lines and columns in the matrix. Remember that they must be positive integers not exceeding 109. | [
"8\n1 2 3 6 9 8 5 2\n",
"6\n1 2 1 2 5 3\n",
"2\n1 10\n"
] | [
"YES\n3 3\n",
"NO\n",
"YES\n4 9\n"
] | The matrix and the path on it in the first test looks like this:
Also there exist multiple correct answers for both the first and the third examples. | [
{
"input": "8\n1 2 3 6 9 8 5 2",
"output": "YES\n1000000000 3"
},
{
"input": "6\n1 2 1 2 5 3",
"output": "NO"
},
{
"input": "2\n1 10",
"output": "YES\n1000000000 9"
},
{
"input": "3\n1 2 2",
"output": "NO"
},
{
"input": "1\n1",
"output": "YES\n1000000000 1"
},
{
"input": "1\n6",
"output": "YES\n1000000000 1"
},
{
"input": "2\n2 3",
"output": "YES\n1000000000 1"
},
{
"input": "2\n1000000000 1",
"output": "YES\n1000000000 999999999"
},
{
"input": "4\n3 2 4 2",
"output": "NO"
},
{
"input": "5\n1 2 5 4 3",
"output": "NO"
},
{
"input": "2\n1 1",
"output": "NO"
},
{
"input": "3\n1 3 4",
"output": "YES\n1000000000 2"
},
{
"input": "1\n1000000000",
"output": "YES\n1000000000 1"
},
{
"input": "6\n1 4 5 6 3 2",
"output": "YES\n1000000000 3"
},
{
"input": "8\n1 2 3 6 9 8 7 6",
"output": "NO"
},
{
"input": "9\n4 3 2 1 5 6 7 8 9",
"output": "NO"
},
{
"input": "8\n2 5 8 9 6 3 2 1",
"output": "YES\n1000000000 3"
},
{
"input": "4\n1 2 1 3",
"output": "YES\n1000000000 2"
},
{
"input": "3\n1 4 3",
"output": "NO"
},
{
"input": "5\n1 2 3 4 1",
"output": "NO"
},
{
"input": "6\n3 5 2 1 2 1",
"output": "NO"
},
{
"input": "2\n1000000000 999999999",
"output": "YES\n1000000000 1"
},
{
"input": "3\n2 4 3",
"output": "YES\n1000000000 2"
},
{
"input": "5\n1 2 3 2 4",
"output": "NO"
},
{
"input": "6\n10 8 6 4 2 1",
"output": "YES\n1000000000 2"
},
{
"input": "7\n1 4 7 8 9 10 11",
"output": "NO"
},
{
"input": "8\n1 2 3 2 3 4 3 8",
"output": "YES\n1000000000 5"
},
{
"input": "4\n3 4 3 5",
"output": "YES\n1000000000 2"
},
{
"input": "4\n1 4 3 2",
"output": "NO"
},
{
"input": "13\n1 3 4 6 5 3 1 2 4 6 5 3 1",
"output": "YES\n1000000000 2"
},
{
"input": "3\n1 3 2",
"output": "NO"
},
{
"input": "6\n4 3 6 9 8 7",
"output": "NO"
},
{
"input": "6\n1 2 4 3 5 6",
"output": "YES\n1000000000 2"
},
{
"input": "5\n1 2 4 3 1",
"output": "YES\n1000000000 2"
},
{
"input": "5\n1 2 4 3 5",
"output": "YES\n1000000000 2"
},
{
"input": "5\n3 6 5 4 3",
"output": "NO"
},
{
"input": "37\n94 7 32 29 57 22 11 70 57 61 12 75 93 24 4 47 98 43 99 22 50 32 37 64 80 9 40 87 38 70 17 41 77 76 20 66 48",
"output": "NO"
},
{
"input": "2\n99999999 100000000",
"output": "YES\n1000000000 1"
},
{
"input": "5\n3 4 5 6 2",
"output": "NO"
},
{
"input": "6\n3 8 7 6 5 4",
"output": "NO"
},
{
"input": "10\n999999999 999999998 999999997 999999996 999999995 999999994 999999993 999999992 999999991 999999990",
"output": "YES\n1000000000 1"
},
{
"input": "2\n1000000000 999999998",
"output": "YES\n1000000000 2"
},
{
"input": "5\n8 9 10 14 13",
"output": "NO"
},
{
"input": "4\n1 3 2 4",
"output": "NO"
},
{
"input": "4\n2 3 5 6",
"output": "NO"
},
{
"input": "5\n1 2 3 4 2",
"output": "NO"
},
{
"input": "3\n5 6 4",
"output": "YES\n1000000000 2"
},
{
"input": "1\n1000000",
"output": "YES\n1000000000 1"
},
{
"input": "3\n9 10 1",
"output": "NO"
},
{
"input": "28\n1 3 5 7 9 10 8 6 4 2 1 2 4 3 5 6 8 7 9 10 8 7 5 6 4 3 1 2",
"output": "YES\n1000000000 2"
},
{
"input": "5\n3 4 5 6 9",
"output": "NO"
},
{
"input": "3\n6 8 7",
"output": "YES\n1000000000 2"
},
{
"input": "1\n100000000",
"output": "YES\n1000000000 1"
},
{
"input": "6\n2 4 6 5 6 5",
"output": "YES\n1000000000 2"
},
{
"input": "2\n999999999 1000000000",
"output": "YES\n1000000000 1"
},
{
"input": "4\n3 6 7 8",
"output": "NO"
},
{
"input": "23\n92 34 58 40 76 3 38 66 76 23 85 36 47 43 22 46 98 72 97 80 57 77 96",
"output": "NO"
},
{
"input": "3\n6 7 4",
"output": "NO"
},
{
"input": "4\n1 2 4 3",
"output": "YES\n1000000000 2"
},
{
"input": "3\n3 2 4",
"output": "NO"
},
{
"input": "5\n1 4 3 2 1",
"output": "NO"
},
{
"input": "5\n1 3 5 4 3",
"output": "NO"
},
{
"input": "3\n19260816 19260817 19260818",
"output": "YES\n1000000000 1"
},
{
"input": "3\n1 3 6",
"output": "NO"
},
{
"input": "2\n999999998 1000000000",
"output": "YES\n1000000000 2"
},
{
"input": "8\n2 4 6 5 6 5 3 4",
"output": "YES\n1000000000 2"
},
{
"input": "3\n4 3 6",
"output": "NO"
},
{
"input": "2\n246642 246641",
"output": "YES\n1000000000 1"
},
{
"input": "3\n9 7 5",
"output": "YES\n1000000000 2"
},
{
"input": "10\n1 2 1 2 1 2 1 2 1 2",
"output": "YES\n1000000000 1"
},
{
"input": "5\n1 3 5 7 8",
"output": "YES\n1000000000 2"
},
{
"input": "4\n1 10 9 10",
"output": "NO"
},
{
"input": "2\n2 4",
"output": "YES\n1000000000 2"
},
{
"input": "8\n1 2 4 3 5 6 8 7",
"output": "YES\n1000000000 2"
},
{
"input": "3\n4 3 2",
"output": "YES\n1000000000 1"
},
{
"input": "3\n3 2 1",
"output": "YES\n1000000000 1"
},
{
"input": "4\n999 1000 2000 2001",
"output": "NO"
},
{
"input": "3\n4 2 5",
"output": "NO"
},
{
"input": "2\n500000000 1000000000",
"output": "YES\n1000000000 500000000"
},
{
"input": "3\n4 5 7",
"output": "NO"
},
{
"input": "5\n1 3 4 5 4",
"output": "NO"
},
{
"input": "7\n550 555 554 553 554 555 560",
"output": "YES\n1000000000 5"
}
] | 61 | 1,945,600 | 0 | 56,401 |
|
568 | Symmetric and Transitive | [
"combinatorics",
"dp",
"math"
] | null | null | Little Johnny has recently learned about set theory. Now he is studying binary relations. You've probably heard the term "equivalence relation". These relations are very important in many areas of mathematics. For example, the equality of the two numbers is an equivalence relation.
A set Ο of pairs (*a*,<=*b*) of elements of some set *A* is called a binary relation on set *A*. For two elements *a* and *b* of the set *A* we say that they are in relation Ο, if pair , in this case we use a notation .
Binary relation is equivalence relation, if:
1. It is reflexive (for any *a* it is true that );1. It is symmetric (for any *a*, *b* it is true that if , then );1. It is transitive (if and , than ).
Little Johnny is not completely a fool and he noticed that the first condition is not necessary! Here is his "proof":
Take any two elements, *a* and *b*. If , then (according to property (2)), which means (according to property (3)).
It's very simple, isn't it? However, you noticed that Johnny's "proof" is wrong, and decided to show him a lot of examples that prove him wrong.
Here's your task: count the number of binary relations over a set of size *n* such that they are symmetric, transitive, but not an equivalence relations (i.e. they are not reflexive).
Since their number may be very large (not 0, according to Little Johnny), print the remainder of integer division of this number by 109<=+<=7. | A single line contains a single integer *n* (1<=β€<=*n*<=β€<=4000). | In a single line print the answer to the problem modulo 109<=+<=7. | [
"1\n",
"2\n",
"3\n"
] | [
"1\n",
"3\n",
"10\n"
] | If *n*β=β1 there is only one such relationΒ β an empty one, i.e. <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/8891a227c918474e5d76377d4644cd7cc01e1ffd.png" style="max-width: 100.0%;max-height: 100.0%;"/>. In other words, for a single element *x* of set *A* the following is hold: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/947c6cf761375432db9bd77796bccc89f1f1546d.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
If *n*β=β2 there are three such relations. Let's assume that set *A* consists of two elements, *x* and *y*. Then the valid relations are <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/8891a227c918474e5d76377d4644cd7cc01e1ffd.png" style="max-width: 100.0%;max-height: 100.0%;"/>, Οβ=β{(*x*,β*x*)}, Οβ=β{(*y*,β*y*)}. It is easy to see that the three listed binary relations are symmetric and transitive relations, but they are not equivalence relations. | [
{
"input": "1",
"output": "1"
},
{
"input": "2",
"output": "3"
},
{
"input": "3",
"output": "10"
},
{
"input": "4",
"output": "37"
},
{
"input": "5",
"output": "151"
},
{
"input": "6",
"output": "674"
},
{
"input": "7",
"output": "3263"
},
{
"input": "8",
"output": "17007"
},
{
"input": "9",
"output": "94828"
},
{
"input": "10",
"output": "562595"
},
{
"input": "42",
"output": "738186543"
},
{
"input": "2000",
"output": "323848720"
},
{
"input": "4000",
"output": "341934157"
},
{
"input": "2345",
"output": "832335061"
},
{
"input": "2500",
"output": "544067513"
},
{
"input": "2780",
"output": "951043097"
},
{
"input": "2999",
"output": "634360769"
},
{
"input": "3000",
"output": "949793998"
},
{
"input": "20",
"output": "654959364"
},
{
"input": "76",
"output": "130527569"
},
{
"input": "133",
"output": "334338018"
},
{
"input": "345",
"output": "838683603"
},
{
"input": "555",
"output": "31983119"
},
{
"input": "666",
"output": "86247911"
},
{
"input": "777",
"output": "765401747"
},
{
"input": "999",
"output": "867937200"
},
{
"input": "1234",
"output": "845807965"
},
{
"input": "1730",
"output": "730878735"
},
{
"input": "3333",
"output": "938772236"
},
{
"input": "3555",
"output": "810675957"
},
{
"input": "3789",
"output": "397160465"
},
{
"input": "3999",
"output": "124834909"
}
] | 77 | 2,867,200 | -1 | 56,443 |
|
425 | Sereja and Sets | [
"dp"
] | null | null | Let's assume that set *S* consists of *m* distinct intervals [*l*1,<=*r*1], [*l*2,<=*r*2], ..., [*l**m*,<=*r**m*] (1<=β€<=*l**i*<=β€<=*r**i*<=β€<=*n*; *l**i*,<=*r**i* are integers).
Let's assume that *f*(*S*) is the maximum number of intervals that you can choose from the set *S*, such that every two of them do not intersect. We assume that two intervals, [*l*1,<=*r*1] and [*l*2,<=*r*2], intersect if there is an integer *x*, which meets two inequalities: *l*1<=β€<=*x*<=β€<=*r*1 and *l*2<=β€<=*x*<=β€<=*r*2.
Sereja wonders, how many sets *S* are there, such that *f*(*S*)<==<=*k*? Count this number modulo 1000000007 (109<=+<=7). | The first line contains integers *n*, *k* (1<=β€<=*n*<=β€<=500;Β 0<=β€<=*k*<=β€<=500). | In a single line, print the answer to the problem modulo 1000000007 (109<=+<=7). | [
"3 1\n",
"3 2\n",
"2 0\n",
"2 2\n"
] | [
"23\n",
"32\n",
"1\n",
"2\n"
] | none | [] | 15 | 0 | 0 | 56,451 |
|
958 | Guard Duty (medium) | [
"binary search",
"dp",
"greedy",
"sortings"
] | null | null | Princess Heidi decided to give orders to all her *K* Rebel ship commanders in person. Unfortunately, she is currently travelling through hyperspace, and will leave it only at *N* specific moments *t*1,<=*t*2,<=...,<=*t**N*. The meetings with commanders must therefore start and stop at those times. Namely, each commander will board her ship at some time *t**i* and disembark at some later time *t**j*. Of course, Heidi needs to meet with all commanders, and no two meetings can be held during the same time. Two commanders cannot even meet at the beginnings/endings of the hyperspace jumps, because too many ships in one position could give out their coordinates to the enemy.
Your task is to find minimum time that Princess Heidi has to spend on meetings, with her schedule satisfying the conditions above. | The first line contains two integers *K*, *N* (2<=β€<=2*K*<=β€<=*N*<=β€<=500000, *K*<=β€<=5000). The second line contains *N* distinct integers *t*1,<=*t*2,<=...,<=*t**N* (1<=β€<=*t**i*<=β€<=109) representing the times when Heidi leaves hyperspace. | Output only one integer: the minimum time spent on meetings. | [
"2 5\n1 4 6 7 12\n",
"3 6\n6 3 4 2 5 1\n",
"4 12\n15 7 4 19 3 30 14 1 5 23 17 25\n"
] | [
"4\n",
"3\n",
"6\n"
] | In the first example, there are five valid schedules: [1,β4],β[6,β7] with total time 4, [1,β4],β[6,β12] with total time 9, [1,β4],β[7,β12] with total time 8, [1,β6],β[7,β12] with total time 10, and [4,β6],β[7,β12] with total time 7. So the answer is 4.
In the second example, there is only 1 valid schedule: [1,β2],β[3,β4],β[5,β6].
For the third example, one possible schedule with total time 6 is: [1,β3],β[4,β5],β[14,β15],β[23,β25]. | [] | 3,000 | 97,280,000 | 0 | 56,453 |
|
703 | Mishka and Divisors | [
"dp",
"number theory"
] | null | null | After playing with her beautiful array, Mishka decided to learn some math. After learning how to multiply, divide and what is divisibility, she is now interested in solving the following problem.
You are given integer *k* and array *a*1,<=*a*2,<=...,<=*a**n* of *n* integers. You are to find non-empty subsequence of array elements such that the product of its elements is divisible by *k* and it contains minimum possible number of elements.
Formally, you are to find a sequence of indices 1<=β€<=*i*1<=<<=*i*2<=<<=...<=<<=*i**m*<=β€<=*n* such that is divisible by *k* while *m* is minimum possible among all such variants.
If there are more than one such subsequences, you should choose one among them, such that sum of its elements is minimum possible.
Mishka quickly solved this problem. Will you do so? | The first line of the input contains two integers *n* and *k* (1<=β€<=*n*<=β€<=1<=000, 1<=β€<=*k*<=β€<=1012).
The second line of the input contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a**i*<=β€<=1012)Β β array elements. | Print single positive integer *m* in the first lineΒ β the number of elements in desired sequence.
In the second line print *m* distinct integersΒ β the sequence of indices of given array elements, which should be taken into the desired sequence.
If there are more than one such subsequence (e.g. subsequence of minimum possible number of elements and with minimum possible sum of elements), you can print any of them.
If there are no such subsequences, print <=-<=1 in the only line. | [
"5 60\n2 4 6 5 2\n"
] | [
"3\n4 3 1 "
] | none | [
{
"input": "5 60\n2 4 6 5 2",
"output": "3\n4 3 1 "
},
{
"input": "10 66\n93 799 19 143 1739 1403 19 1681 8513 1457",
"output": "-1"
},
{
"input": "10 78\n2473 7234 317 3793 6638 6 7789 753 1117 8243",
"output": "-1"
},
{
"input": "10 78\n19 1081 143 5 31 61 1363 319 39 589",
"output": "-1"
},
{
"input": "10 99\n3229 5659 5813 3517 8647 8761 9209 1931 7459 2467",
"output": "-1"
},
{
"input": "10 60\n145 14 1073 437 473 731 3127 1829 469 497",
"output": "-1"
},
{
"input": "10 60\n6982 5 10 8803 831 9733 6722 5099 3 1553",
"output": "3\n9 7 3 "
},
{
"input": "10 64\n1363 7 779 671 1739 31 893 731 53 215",
"output": "-1"
},
{
"input": "10 62\n9041 5431 233 1 4261 3769 2713 6737 9521 2647",
"output": "-1"
},
{
"input": "10 55\n1121 481 2173 41 1003 43 799 1159 1541 7",
"output": "-1"
},
{
"input": "10 100\n5531 6323 6418 5023 113 9859 1571 9788 4999 3778",
"output": "-1"
},
{
"input": "10 63\n61 1121 2537 95 2627 1219 59 41 583 91",
"output": "-1"
},
{
"input": "10 100\n1 2 1 5 2 97 4 83 4 4",
"output": "-1"
},
{
"input": "10 63\n781 118 3953 2021 1 29 47 1271 6 31",
"output": "-1"
},
{
"input": "10 88\n11 1 1 1 1 1 8 1 4 1",
"output": "2\n7 1 "
},
{
"input": "10 63\n205 533 67 59 259 649 115 1003 649 29",
"output": "-1"
},
{
"input": "10 96\n1 1 1 1 1 2 1 4 2 2",
"output": "-1"
},
{
"input": "10 70\n43 6 87 213 43 2077 57 82 893 1189",
"output": "-1"
},
{
"input": "10 84\n1 3 1 3 1 3 1 12 1 4",
"output": "-1"
},
{
"input": "10 66\n106 67 23 235 1961 26 1 2059 9 37",
"output": "-1"
},
{
"input": "10 72\n2 3 3 1 4 2 1 4 4 1",
"output": "4\n5 3 2 1 "
},
{
"input": "10 8250\n177 1189 305 2537 37 901 77 61 209 169",
"output": "-1"
},
{
"input": "10 5500\n4 50 5779 5 4903 2663 55 4327 3670 8006",
"output": "3\n7 2 1 "
},
{
"input": "10 6200\n4331 1537 893 26 15 451 74 319 21 41",
"output": "-1"
},
{
"input": "10 7370\n5 11 5011 4766 3902 919 134 4166 22 9970",
"output": "3\n7 2 1 "
},
{
"input": "10 6460\n2479 61 527 451 287 71 41 1961 31 671",
"output": "-1"
},
{
"input": "10 9660\n35 8859 5 6982 14 2462 12 9868 6626 353",
"output": "-1"
},
{
"input": "10 8370\n41 799 11 209 31 921 551 87 13 14",
"output": "-1"
},
{
"input": "10 6348\n7522 489 8373 491 4 2699 2 2459 8209 1506",
"output": "-1"
},
{
"input": "10 8932\n901 7 1961 62 59 3551 37 74 86 3127",
"output": "-1"
},
{
"input": "10 8772\n5006 2092 4286 51 1429 8331 12 4377 1046 7778",
"output": "-1"
},
{
"input": "10 64\n2 2 2 2 2 2 2 2 2 2",
"output": "6\n6 5 4 3 2 1 "
},
{
"input": "10 60\n100223 14271 33611 86 4958 2537 160247 121 126697 16165",
"output": "4\n10 5 4 2 "
},
{
"input": "10 8192\n2 1642 7702 2 2 2 2 2 2 9742",
"output": "-1"
},
{
"input": "10 7560\n1771 1369 1435 1667 5254 10105 3551 71 1849 12121",
"output": "-1"
},
{
"input": "100 524288\n129634 340498 47114 64514 759698 262046 7694 109154 638366 4502 409246 665726 162926 395146 228946 345502 163298 81658 156614 176234 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2",
"output": "19\n39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 "
},
{
"input": "100 67108864\n98304578 265238 54740242 426158 30712454 296486 171214 9511358 475298 774398 98372446 4995842 65101618 62058562 26951882 42782738 3228454 7660934 26263642 201874 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2",
"output": "26\n46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 "
},
{
"input": "2 1\n1000000000000 999999999999",
"output": "1\n2"
},
{
"input": "5 1\n3 2 4 1 5",
"output": "1\n4"
},
{
"input": "5 1\n3 1 4 2 5",
"output": "1\n2"
},
{
"input": "5 1\n4 2 6 8 9",
"output": "1\n2"
},
{
"input": "5 1\n5 69 1 3 4",
"output": "1\n3"
},
{
"input": "2 1\n2 3",
"output": "1\n1"
},
{
"input": "3 1\n3 2 1",
"output": "1\n3"
},
{
"input": "2 1\n10 2",
"output": "1\n2"
}
] | 1,000 | 15,462,400 | 0 | 56,473 |
|
566 | Max and Min | [
"geometry"
] | null | null | Two kittens, Max and Min, play with a pair of non-negative integers *x* and *y*. As you can guess from their names, kitten Max loves to maximize and kitten Min loves to minimize. As part of this game Min wants to make sure that both numbers, *x* and *y* became negative at the same time, and kitten Max tries to prevent him from doing so.
Each kitten has a set of pairs of integers available to it. Kitten Max has *n* pairs of non-negative integers (*a**i*,<=*b**i*) (1<=β€<=*i*<=β€<=*n*), and kitten Min has *m* pairs of non-negative integers (*c**j*,<=*d**j*) (1<=β€<=*j*<=β€<=*m*). As kitten Max makes a move, it can take any available pair (*a**i*,<=*b**i*) and add *a**i* to *x* and *b**i* to *y*, and kitten Min can take any available pair (*c**j*,<=*d**j*) and subtract *c**j* from *x* and *d**j* from *y*. Each kitten can use each pair multiple times during distinct moves.
Max moves first. Kitten Min is winning if at some moment both numbers *a*, *b* are negative simultaneously. Otherwise, the winner of the game is kitten Max. Determine which kitten wins if both of them play optimally. | The first line contains two integers, *n* and *m* (1<=β€<=*n*,<=*m*<=β€<=100<=000) β the number of pairs of numbers available to Max and Min, correspondingly.
The second line contains two integers *x*, *y* (1<=β€<=*x*,<=*y*<=β€<=109) β the initial values of numbers with which the kittens are playing.
Next *n* lines contain the pairs of numbers *a**i*,<=*b**i* (1<=β€<=*a**i*,<=*b**i*<=β€<=109) β the pairs available to Max.
The last *m* lines contain pairs of numbers *c**j*,<=*d**j* (1<=β€<=*c**j*,<=*d**j*<=β€<=109) β the pairs available to Min. | Print Β«MaxΒ» (without the quotes), if kitten Max wins, or "Min" (without the quotes), if kitten Min wins. | [
"2 2\n42 43\n2 3\n3 2\n3 10\n10 3\n",
"1 1\n1 1\n3 4\n1 1\n"
] | [
"Min\n",
"Max\n"
] | In the first test from the statement Min can respond to move (2,β3) by move (3,β10), and to move (3,β2) by move (10,β3). Thus, for each pair of Max and Min's moves the values of both numbers *x* and *y* will strictly decrease, ergo, Min will win sooner or later.
In the second sample test after each pair of Max and Min's moves both numbers *x* and *y* only increase, thus none of them will become negative. | [] | 514 | 10,547,200 | 0 | 56,487 |
|
0 | none | [
"none"
] | null | null | In the spirit of the holidays, Saitama has given Genos two grid paths of length *n* (a weird gift even by Saitama's standards). A grid path is an ordered sequence of neighbouring squares in an infinite grid. Two squares are neighbouring if they share a side.
One example of a grid path is (0,<=0)<=β<=(0,<=1)<=β<=(0,<=2)<=β<=(1,<=2)<=β<=(1,<=1)<=β<=(0,<=1)<=β<=(<=-<=1,<=1). Note that squares in this sequence might be repeated, i.e. path has self intersections.
Movement within a grid path is restricted to adjacent squares within the sequence. That is, from the *i*-th square, one can only move to the (*i*<=-<=1)-th or (*i*<=+<=1)-th squares of this path. Note that there is only a single valid move from the first and last squares of a grid path. Also note, that even if there is some *j*-th square of the path that coincides with the *i*-th square, only moves to (*i*<=-<=1)-th and (*i*<=+<=1)-th squares are available. For example, from the second square in the above sequence, one can only move to either the first or third squares.
To ensure that movement is not ambiguous, the two grid paths will not have an alternating sequence of three squares. For example, a contiguous subsequence (0,<=0)<=β<=(0,<=1)<=β<=(0,<=0) cannot occur in a valid grid path.
One marble is placed on the first square of each grid path. Genos wants to get both marbles to the last square of each grid path. However, there is a catch. Whenever he moves one marble, the other marble will copy its movement if possible. For instance, if one marble moves east, then the other marble will try and move east as well. By try, we mean if moving east is a valid move, then the marble will move east.
Moving north increases the second coordinate by 1, while moving south decreases it by 1. Similarly, moving east increases first coordinate by 1, while moving west decreases it.
Given these two valid grid paths, Genos wants to know if it is possible to move both marbles to the ends of their respective paths. That is, if it is possible to move the marbles such that both marbles rest on the last square of their respective paths. | The first line of the input contains a single integer *n* (2<=β€<=*n*<=β€<=1<=000<=000)Β β the length of the paths.
The second line of the input contains a string consisting of *n*<=-<=1 characters (each of which is either 'N', 'E', 'S', or 'W')Β β the first grid path. The characters can be thought of as the sequence of moves needed to traverse the grid path. For example, the example path in the problem statement can be expressed by the string "NNESWW".
The third line of the input contains a string of *n*<=-<=1 characters (each of which is either 'N', 'E', 'S', or 'W')Β β the second grid path. | Print "YES" (without quotes) if it is possible for both marbles to be at the end position at the same time. Print "NO" (without quotes) otherwise. In both cases, the answer is case-insensitive. | [
"7\nNNESWW\nSWSWSW\n",
"3\nNN\nSS\n"
] | [
"YES\n",
"NO\n"
] | In the first sample, the first grid path is the one described in the statement. Moreover, the following sequence of moves will get both marbles to the end: NNESWWSWSW.
In the second sample, no sequence of moves can get both marbles to the end. | [
{
"input": "7\nNNESWW\nSWSWSW",
"output": "YES"
},
{
"input": "3\nNN\nSS",
"output": "NO"
},
{
"input": "3\nES\nNW",
"output": "NO"
},
{
"input": "5\nWSSE\nWNNE",
"output": "NO"
},
{
"input": "2\nE\nE",
"output": "YES"
},
{
"input": "2\nW\nS",
"output": "YES"
},
{
"input": "2\nS\nN",
"output": "NO"
},
{
"input": "100\nWNWWSWWSESWWWSSSSWSSEENWNWWWWNNENESWSESSENEENNWWWWWSSWSWSENESWNEENESWWNNEESESWSEEENWWNWNNWWNNWWWWSW\nEESEESSENWNWWWNWWNWWNWWSWNNWNWNWSWNNEENWSWNNESWSWNWSESENWSWSWWWWNNEESSSWSSESWWSSWSSWSWNEEESWWSSSSEN",
"output": "NO"
},
{
"input": "200\nNESENEESEESWWWNWWSWSWNWNNWNNESWSWNNWNWNENESENNESSWSESWWSSSEEEESSENNNESSWWSSSSESWSWWNNEESSWWNNWSWSSWWNWNNEENNENWWNESSSENWNESWNESWNESEESSWNESSSSSESESSWNNENENESSWWNNWWSWWNESEENWWWWNWWNWWNENESESSWWSWWSES\nNWNESESSENNNESWNWWSWWWNWSESSSWWNWWNNWSENWSWNENNNWWSWWSWNNNESWWWSSESSWWWSSENWSENWWNENESESWNENNESWNWNNENNWWWSENWSWSSSENNWWNEESENNESEESSEESWWWWWWNWNNNESESWSSEEEESWNENWSESEEENWNNWWNWNNNNWWSSWNEENENEEEEEE",
"output": "YES"
},
{
"input": "11\nWWNNNNWNWN\nENWSWWSSEE",
"output": "YES"
},
{
"input": "12\nWNNWSWWSSSE\nNESWNNNWSSS",
"output": "YES"
}
] | 2,000 | 5,836,800 | 0 | 56,517 |
|
901 | Weighting a Tree | [
"constructive algorithms",
"dfs and similar",
"graphs"
] | null | null | You are given a connected undirected graph with *n* vertices and *m* edges. The vertices are enumerated from 1 to *n*.
You are given *n* integers *c*1,<=*c*2,<=...,<=*c**n*, each of them is between <=-<=*n* and *n*, inclusive. It is also guaranteed that the parity of *c**v* equals the parity of degree of vertex *v*. The degree of a vertex is the number of edges connected to it.
You are to write a weight between <=-<=2Β·*n*2 and 2Β·*n*2 (inclusive) on each edge in such a way, that for each vertex *v* the sum of weights on edges connected to this vertex is equal to *c**v*, or determine that this is impossible. | The first line contains two integers *n* and *m* (2<=β€<=*n*<=β€<=105, *n*<=-<=1<=β€<=*m*<=β€<=105)Β β the number of vertices and the number of edges.
The next line contains *n* integers *c*1,<=*c*2,<=...,<=*c**n* (<=-<=*n*<=β€<=*c**i*<=β€<=*n*), where *c**i* is the required sum of weights of edges connected to vertex *i*. It is guaranteed that the parity of *c**i* equals the parity of degree of vertex *i*.
The next *m* lines describe edges of the graph. The *i*-th of these lines contains two integers *a**i* and *b**i* (1<=β€<=*a**i*,<=*b**i*<=β€<=*n*; *a**i*<=β <=*b**i*), meaning that the *i*-th edge connects vertices *a**i* and *b**i*.
It is guaranteed that the given graph is connected and does not contain loops and multiple edges. | If there is no solution, print "NO".
Otherwise print "YES" and then *m* lines, the *i*-th of them is the weight of the *i*-th edge *w**i* (<=-<=2Β·*n*2<=β€<=*w**i*<=β€<=2Β·*n*2). | [
"3 3\n2 2 2\n1 2\n2 3\n1 3\n",
"4 3\n-1 0 2 1\n1 2\n2 3\n3 4\n",
"6 6\n3 5 5 5 1 5\n1 4\n3 2\n4 3\n4 5\n3 5\n5 6\n",
"4 4\n4 4 2 4\n1 2\n2 3\n3 4\n4 1\n"
] | [
"YES\n1\n1\n1\n",
"YES\n-1\n1\n1\n",
"YES\n3\n5\n3\n-1\n-3\n5\n",
"NO"
] | none | [
{
"input": "3 3\n2 2 2\n1 2\n2 3\n1 3",
"output": "YES\n1\n1\n1"
},
{
"input": "4 3\n-1 0 2 1\n1 2\n2 3\n3 4",
"output": "YES\n-1\n1\n1"
},
{
"input": "6 6\n3 5 5 5 1 5\n1 4\n3 2\n4 3\n4 5\n3 5\n5 6",
"output": "YES\n3\n5\n3\n-1\n-3\n5"
},
{
"input": "4 4\n4 4 2 4\n1 2\n2 3\n3 4\n4 1",
"output": "NO"
},
{
"input": "2 1\n1 1\n1 2",
"output": "YES\n1"
},
{
"input": "5 7\n4 1 5 3 -1\n2 4\n5 4\n5 2\n1 5\n1 2\n4 1\n1 3",
"output": "YES\n3\n0\n-1\n0\n-1\n0\n5"
},
{
"input": "10 12\n5 1 1 8 -8 10 -3 -2 1 7\n5 3\n8 2\n10 9\n4 6\n5 6\n4 5\n5 10\n4 7\n8 4\n3 1\n3 6\n6 10",
"output": "YES\n0\n1\n1\n15\n-7\n-1\n0\n-3\n-3\n5\n-4\n6"
},
{
"input": "20 40\n-9 -10 -9 15 -3 -5 -17 -10 -6 2 -13 19 10 -15 15 -14 17 0 7 -8\n3 17\n6 18\n15 12\n2 5\n18 3\n16 20\n6 17\n20 10\n10 18\n9 12\n15 3\n6 4\n15 16\n20 6\n20 9\n9 4\n4 8\n14 5\n11 7\n12 11\n3 13\n14 19\n7 17\n16 14\n19 7\n12 13\n14 13\n13 11\n9 14\n13 17\n8 19\n5 20\n2 17\n2 16\n12 5\n8 1\n20 3\n6 2\n5 18\n13 8",
"output": "YES\n-19\n-12\n27\n-10\n10\n-2\n0\n0\n2\n-8\n0\n7\n-12\n0\n-6\n8\n0\n7\n-53\n0\n0\n8\n36\n0\n0\n0\n-30\n40\n0\n0\n-1\n0\n0\n0\n0\n-9\n0\n0\n0\n0"
},
{
"input": "8 12\n-6 2 -3 2 6 -7 1 -5\n2 1\n5 6\n1 6\n1 4\n8 2\n2 7\n2 5\n8 3\n8 4\n3 7\n7 6\n3 1",
"output": "NO"
},
{
"input": "10 13\n3 4 -3 8 6 4 -5 1 3 -7\n9 5\n9 2\n10 3\n1 4\n3 5\n9 1\n6 10\n10 4\n3 1\n2 7\n1 6\n1 7\n7 8",
"output": "YES\n-7\n10\n-16\n3\n13\n0\n4\n5\n0\n-6\n0\n0\n1"
},
{
"input": "43 52\n-23 -18 -35 21 -12 38 -35 -11 28 -20 27 -5 9 -19 -39 -25 -32 32 -36 28 11 37 1 -25 -22 9 -15 21 25 -39 10 36 -30 -40 22 26 25 -27 -22 -38 -1 18 -13\n33 40\n31 23\n30 26\n21 17\n6 2\n41 19\n32 39\n32 23\n13 14\n25 35\n31 30\n19 32\n25 22\n34 36\n7 40\n23 6\n40 12\n1 3\n23 43\n36 13\n18 33\n17 32\n7 3\n21 34\n41 35\n20 7\n23 1\n41 8\n25 19\n20 29\n42 5\n40 21\n9 37\n17 41\n30 10\n41 18\n39 1\n20 24\n20 4\n42 3\n20 25\n5 16\n31 9\n42 28\n10 11\n19 42\n31 38\n25 2\n31 27\n17 25\n13 15\n31 20",
"output": "NO"
},
{
"input": "2 1\n1 1\n2 1",
"output": "YES\n1"
}
] | 186 | 2,150,400 | -1 | 56,593 |
|
523 | Mean Requests | [
"*special",
"implementation"
] | null | null | In this problem you will have to deal with a real algorithm that is used in the VK social network.
As in any other company that creates high-loaded websites, the VK developers have to deal with request statistics regularly. An important indicator reflecting the load of the site is the mean number of requests for a certain period of time of *T* seconds (for example, *T*<==<=60Β *seconds*<==<=1Β *min* and *T*<==<=86400Β *seconds*<==<=1Β *day*). For example, if this value drops dramatically, that shows that the site has access problem. If this value grows, that may be a reason to analyze the cause for the growth and add more servers to the website if it is really needed.
However, even such a natural problem as counting the mean number of queries for some period of time can be a challenge when you process the amount of data of a huge social network. That's why the developers have to use original techniques to solve problems approximately, but more effectively at the same time.
Let's consider the following formal model. We have a service that works for *n* seconds. We know the number of queries to this resource *a**t* at each moment of time *t* (1<=β€<=*t*<=β€<=*n*). Let's formulate the following algorithm of calculating the mean with exponential decay. Let *c* be some real number, strictly larger than one.
Thus, the mean variable is recalculated each second using the number of queries that came at that second. We can make some mathematical calculations and prove that choosing the value of constant *c* correctly will make the value of mean not very different from the real mean value *a**x* at *t*<=-<=*T*<=+<=1<=β€<=*x*<=β€<=*t*.
The advantage of such approach is that it only uses the number of requests at the current moment of time and doesn't require storing the history of requests for a large time range. Also, it considers the recent values with the weight larger than the weight of the old ones, which helps to react to dramatic change in values quicker.
However before using the new theoretical approach in industrial programming, there is an obligatory step to make, that is, to test its credibility practically on given test data sets. Your task is to compare the data obtained as a result of the work of an approximate algorithm to the real data.
You are given *n* values *a**t*, integer *T* and real number *c*. Also, you are given *m* moments *p**j* (1<=β€<=*j*<=β€<=*m*), where we are interested in the mean value of the number of queries for the last *T* seconds. Implement two algorithms. The first one should calculate the required value by definition, i.e. by the formula . The second algorithm should calculate the mean value as is described above. Print both values and calculate the relative error of the second algorithm by the formula , where *approx* is the approximate value, obtained by the second algorithm, and *real* is the exact value obtained by the first algorithm. | The first line contains integer *n* (1<=β€<=*n*<=β€<=2Β·105), integer *T* (1<=β€<=*T*<=β€<=*n*) and real number *c* (1<=<<=*c*<=β€<=100) β the time range when the resource should work, the length of the time range during which we need the mean number of requests and the coefficient *c* of the work of approximate algorithm. Number *c* is given with exactly six digits after the decimal point.
The next line contains *n* integers *a**t* (1<=β€<=*a**t*<=β€<=106) β the number of queries to the service at each moment of time.
The next line contains integer *m* (1<=β€<=*m*<=β€<=*n*) β the number of moments of time when we are interested in the mean number of queries for the last *T* seconds.
The next line contains *m* integers *p**j* (*T*<=β€<=*p**j*<=β€<=*n*), representing another moment of time for which we need statistics. Moments *p**j* are strictly increasing. | Print *m* lines. The *j*-th line must contain three numbers *real*, *approx* and *error*, where:
- is the real mean number of queries for the last *T* seconds; - *approx* is calculated by the given algorithm and equals *mean* at the moment of time *t*<==<=*p**j* (that is, after implementing the *p**j*-th iteration of the cycle); - is the relative error of the approximate algorithm.
The numbers you printed will be compared to the correct numbers with the relative or absolute error 10<=-<=4. It is recommended to print the numbers with at least five digits after the decimal point. | [
"1 1 2.000000\n1\n1\n1\n",
"11 4 1.250000\n9 11 7 5 15 6 6 6 6 6 6\n8\n4 5 6 7 8 9 10 11\n",
"13 4 1.250000\n3 3 3 3 3 20 3 3 3 3 3 3 3\n10\n4 5 6 7 8 9 10 11 12 13\n"
] | [
"1.000000 0.500000 0.500000\n",
"8.000000 4.449600 0.443800\n9.500000 6.559680 0.309507\n8.250000 6.447744 0.218455\n8.000000 6.358195 0.205226\n8.250000 6.286556 0.237993\n6.000000 6.229245 0.038207\n6.000000 6.183396 0.030566\n6.000000 6.146717 0.024453\n",
"3.000000 1.771200 0.409600\n3.000000 2.016960 0.327680\n7.250000 5.613568 0.225715\n7.250000 5.090854 0.297813\n7.250000 4.672684 0.355492\n7.250000 4.338147 0.401635\n3.000000 4.070517 0.356839\n3.000000 3.856414 0.285471\n3.000000 3.685131 0.228377\n3.000000 3.548105 0.182702\n"
] | none | [
{
"input": "1 1 2.000000\n1\n1\n1",
"output": "1.000000 0.500000 0.500000"
},
{
"input": "11 4 1.250000\n9 11 7 5 15 6 6 6 6 6 6\n8\n4 5 6 7 8 9 10 11",
"output": "8.000000 4.449600 0.443800\n9.500000 6.559680 0.309507\n8.250000 6.447744 0.218455\n8.000000 6.358195 0.205226\n8.250000 6.286556 0.237993\n6.000000 6.229245 0.038207\n6.000000 6.183396 0.030566\n6.000000 6.146717 0.024453"
},
{
"input": "13 4 1.250000\n3 3 3 3 3 20 3 3 3 3 3 3 3\n10\n4 5 6 7 8 9 10 11 12 13",
"output": "3.000000 1.771200 0.409600\n3.000000 2.016960 0.327680\n7.250000 5.613568 0.225715\n7.250000 5.090854 0.297813\n7.250000 4.672684 0.355492\n7.250000 4.338147 0.401635\n3.000000 4.070517 0.356839\n3.000000 3.856414 0.285471\n3.000000 3.685131 0.228377\n3.000000 3.548105 0.182702"
},
{
"input": "1 1 2.000000\n4\n1\n1",
"output": "4.000000 2.000000 0.500000"
},
{
"input": "1 1 2.000000\n1121\n1\n1",
"output": "1121.000000 560.500000 0.500000"
},
{
"input": "1 1 2.000000\n758432\n1\n1",
"output": "758432.000000 379216.000000 0.500000"
},
{
"input": "3 1 2.000000\n8 25 21\n3\n1 2 3",
"output": "8.000000 4.000000 0.500000\n25.000000 14.500000 0.420000\n21.000000 17.750000 0.154762"
},
{
"input": "19 3 1.333333\n12 15 11 10 16 4 9 2 24 3 6 3 21 21 2 16 13 12 2\n17\n3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19",
"output": "12.666667 7.250003 0.427631\n12.000000 7.937505 0.338541\n12.333333 9.953131 0.192989\n10.000000 8.464850 0.153515\n9.666667 8.598640 0.110486\n5.000000 6.948982 0.389796\n11.666667 11.211739 0.038994\n9.666667 9.158807 0.052537\n11.000000 8.369107 0.239172\n4.000000 7.026832 0.756708\n10.000000 10.520127 0.052013\n15.000000 13.140098 0.123993\n14.666667 10.355076 0.293972\n13.000000 11.766310 0.094899\n10.333333 12.074736 0.168523\n13.666667 12.056055 0.117850\n9.000000 9.542043 0.060227"
},
{
"input": "64 3 1.333333\n1337 1913 135 885 1567 1049 1116 368 350 725 517 1874 588 918 1923 998 1237 1098 121 1304 1459 942 538 1480 293 178 958 728 1240 1721 1549 825 928 1189 194 626 1872 670 1145 200 333 1772 1136 614 174 1448 249 1783 798 1375 1574 870 360 398 1387 1092 314 294 1056 1890 1170 697 668 1570\n62\n3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64",
"output": "1128.333333 580.453454 0.485566\n977.666667 656.590254 0.328411\n862.333333 884.192912 0.025349\n1167.000000 925.394915 0.207031\n1244.000000 973.046430 0.217808\n844.333333 821.785028 0.026705\n611.333333 703.838947 0.151318\n481.000000 709.129387 0.474281\n530.666667 661.097206 0.245786\n1038.666667 964.323145 0.071576\n993.000000 870.242577 0.123623\n1126.666667 882.182153 0.216998\n1143.000000 1142.386900 0.000536\n1279.666667 1106.290452 0.135485\n1386.000000 1138.968124 0.178234\n1111.000000 1128.726375 0.015955\n81..."
}
] | 46 | 0 | 0 | 56,597 |
|
959 | Mahmoud and Ehab and the message | [
"dsu",
"greedy",
"implementation"
] | null | null | Mahmoud wants to send a message to his friend Ehab. Their language consists of *n* words numbered from 1 to *n*. Some words have the same meaning so there are *k* groups of words such that all the words in some group have the same meaning.
Mahmoud knows that the *i*-th word can be sent with cost *a**i*. For each word in his message, Mahmoud can either replace it with another word of the same meaning or leave it as it is. Can you help Mahmoud determine the minimum cost of sending the message?
The cost of sending the message is the sum of the costs of sending every word in it. | The first line of input contains integers *n*, *k* and *m* (1<=β€<=*k*<=β€<=*n*<=β€<=105,<=1<=β€<=*m*<=β€<=105)Β β the number of words in their language, the number of groups of words, and the number of words in Mahmoud's message respectively.
The second line contains *n* strings consisting of lowercase English letters of length not exceeding 20 which represent the words. It's guaranteed that the words are distinct.
The third line contains *n* integers *a*1, *a*2, ..., *a**n* (1<=β€<=*a**i*<=β€<=109) where *a**i* is the cost of sending the *i*-th word.
The next *k* lines describe the groups of words of same meaning. The next *k* lines each start with an integer *x* (1<=β€<=*x*<=β€<=*n*) which means that there are *x* words in this group, followed by *x* integers which represent the indices of words in this group. It's guaranteed that each word appears in exactly one group.
The next line contains *m* space-separated words which represent Mahmoud's message. Each of these words appears in the list of language's words. | The only line should contain the minimum cost to send the message after replacing some words (maybe none) with some words of the same meaning. | [
"5 4 4\ni loser am the second\n100 1 1 5 10\n1 1\n1 3\n2 2 5\n1 4\ni am the second\n",
"5 4 4\ni loser am the second\n100 20 1 5 10\n1 1\n1 3\n2 2 5\n1 4\ni am the second\n"
] | [
"107",
"116"
] | In the first sample, Mahmoud should replace the word "second" with the word "loser" because it has less cost so the cost will be 100+1+5+1=107.
In the second sample, Mahmoud shouldn't do any replacement so the cost will be 100+1+5+10=116. | [
{
"input": "5 4 4\ni loser am the second\n100 1 1 5 10\n1 1\n1 3\n2 2 5\n1 4\ni am the second",
"output": "107"
},
{
"input": "5 4 4\ni loser am the second\n100 20 1 5 10\n1 1\n1 3\n2 2 5\n1 4\ni am the second",
"output": "116"
},
{
"input": "1 1 1\na\n1000000000\n1 1\na",
"output": "1000000000"
},
{
"input": "1 1 10\na\n1000000000\n1 1\na a a a a a a a a a",
"output": "10000000000"
}
] | 31 | 0 | 0 | 56,600 |
|
71 | Nuclear Fusion | [
"bitmasks",
"dp"
] | E. Nuclear Fusion | 1 | 256 | There is the following puzzle popular among nuclear physicists.
A reactor contains a set of *n* atoms of some chemical elements. We shall understand the phrase "atomic number" as the number of this atom's element in the periodic table of the chemical elements.
You are allowed to take any two different atoms and fuse a new one from them. That results in a new atom, whose number is equal to the sum of the numbers of original atoms. The fusion operation can be performed several times.
The aim is getting a new pregiven set of *k* atoms.
The puzzle's difficulty is that it is only allowed to fuse two atoms into one, it is not allowed to split an atom into several atoms. You are suggested to try to solve the puzzle. | The first line contains two integers *n* and *k* (1<=β€<=*k*<=β€<=*n*<=β€<=17). The second line contains space-separated symbols of elements of *n* atoms, which are available from the start. The third line contains space-separated symbols of elements of *k* atoms which need to be the result of the fusion. The symbols of the elements coincide with the symbols from the periodic table of the chemical elements. The atomic numbers do not exceed 100 (elements possessing larger numbers are highly unstable). Some atoms can have identical numbers (that is, there can be several atoms of the same element). The sum of numbers of initial atoms is equal to the sum of numbers of the atoms that need to be synthesized. | If it is impossible to synthesize the required atoms, print "NO" without the quotes. Otherwise, print on the first line Β«YESΒ», and on the next *k* lines print the way of synthesizing each of *k* atoms as equations. Each equation has the following form: "*x*1+*x*2+...+*x**t*->*y**i*", where *x**j* is the symbol of the element of some atom from the original set, and *y**i* is the symbol of the element of some atom from the resulting set. Each atom from the input data should occur in the output data exactly one time. The order of summands in the equations, as well as the output order does not matter. If there are several solutions, print any of them. For a better understanding of the output format, see the samples. | [
"10 3\nMn Co Li Mg C P F Zn Sc K\nSn Pt Y\n",
"2 1\nH H\nHe\n",
"2 2\nBk Fm\nCf Es\n"
] | [
"YES\nMn+C+K->Sn\nCo+Zn+Sc->Pt\nLi+Mg+P+F->Y\n",
"YES\nH+H->He\n",
"NO\n"
] | The reactions from the first example possess the following form (the atomic number is written below and to the left of the element):
<img align="middle" class="tex-formula" src="https://espresso.codeforces.com/6f2ce1bed492cbe40ff1bb4600fe53aebc680ace.png" style="max-width: 100.0%;max-height: 100.0%;"/>
<img align="middle" class="tex-formula" src="https://espresso.codeforces.com/edbd66c81b30040884ff79761e8a0ff37dc1fa9d.png" style="max-width: 100.0%;max-height: 100.0%;"/>
<img align="middle" class="tex-formula" src="https://espresso.codeforces.com/9f68585680e3f916d2ec79a9aac68b2ee880cba7.png" style="max-width: 100.0%;max-height: 100.0%;"/>
To find a periodic table of the chemical elements, you may use your favorite search engine.
The pretest set contains each of the first 100 elements of the periodic table at least once. You can use that information to check for misprints. | [
{
"input": "10 3\nMn Co Li Mg C P F Zn Sc K\nSn Pt Y",
"output": "YES\nCo+Mg->Y\nLi+P+F+Zn+Sc->Pt\nMn+C+K->Sn"
},
{
"input": "2 1\nH H\nHe",
"output": "YES\nH+H->He"
},
{
"input": "2 2\nBk Fm\nCf Es",
"output": "NO"
},
{
"input": "8 8\nTl Pb Bi Po Np Pu Am Cm\nAt Rn Fr Ra Ac Th Pa U",
"output": "NO"
},
{
"input": "4 2\nZr Nb Sr Zr\nHg Au",
"output": "YES\nNb+Sr->Au\nZr+Zr->Hg"
},
{
"input": "8 1\nBe B N O Ne Na Al Si\nHf",
"output": "YES\nBe+B+N+O+Ne+Na+Al+Si->Hf"
},
{
"input": "7 3\nH He Be O S Ge Gd\nIr Cr Fe",
"output": "NO"
},
{
"input": "6 3\nCl Ni Ti V Ar Cu\nRh Br La",
"output": "YES\nNi+Cu->La\nCl+Ar->Br\nTi+V->Rh"
},
{
"input": "5 5\nOs Lu Ta Re W\nW Ta Re Os Lu",
"output": "YES\nLu->Lu\nOs->Os\nRe->Re\nTa->Ta\nW->W"
},
{
"input": "8 7\nCa Ga As Er Tm Yb Se Ho\nEu Sm Dy Tb Pm Kr Y",
"output": "NO"
},
{
"input": "3 2\nRb Rb Mo\nNd Ba",
"output": "NO"
},
{
"input": "8 8\nTc Ru Ce Pr Pd Ba Ag Cs\nCd In Sn Sb Sb Te I Xe",
"output": "NO"
},
{
"input": "1 1\nH\nH",
"output": "YES\nH->H"
},
{
"input": "1 1\nFm\nFm",
"output": "YES\nFm->Fm"
},
{
"input": "17 17\nFm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm\nFm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm Fm",
"output": "YES\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm\nFm->Fm"
},
{
"input": "17 17\nEs Es Es Es Es Es Es Es Es Es Es Es Es Es Es Es Es\nFm Fm Fm Fm Fm Fm Fm Fm Cf Cf Cf Cf Cf Cf Cf Cf Es",
"output": "NO"
},
{
"input": "3 1\nH H H\nLi",
"output": "YES\nH+H+H->Li"
},
{
"input": "4 2\nBe Li He B\nN N",
"output": "YES\nBe+Li->N\nHe+B->N"
},
{
"input": "5 2\nH S He Be O\nAr Al",
"output": "YES\nH+Be+O->Al\nS+He->Ar"
},
{
"input": "17 17\nH H H H H H H H H H H H H H H H H\nH H H H H H H H H H H H H H H H H",
"output": "YES\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H"
},
{
"input": "17 1\nH H H H H H H H H H H H H H H H H\nCl",
"output": "YES\nH+H+H+H+H+H+H+H+H+H+H+H+H+H+H+H+H->Cl"
},
{
"input": "17 10\nH H H H H H H H H H H H H H H H H\nH H H H H H H H H O",
"output": "YES\nH+H+H+H+H+H+H+H->O\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H"
},
{
"input": "17 10\nH H H H H H H H H H H H H H H H H\nO H H H H H H H H H",
"output": "YES\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH+H+H+H+H+H+H+H->O"
},
{
"input": "17 4\nH H H H H H H H H H H H H H H H H\nHe B B B",
"output": "YES\nH+H+H+H+H->B\nH+H+H+H+H->B\nH+H+H+H+H->B\nH+H->He"
},
{
"input": "17 3\nH H H H H H H H H H H H H H H H H\nH O O",
"output": "YES\nH+H+H+H+H+H+H+H->O\nH+H+H+H+H+H+H+H->O\nH->H"
},
{
"input": "17 10\nH H H H H H H H H H H H H H H H H\nH H H H H H H H He N",
"output": "YES\nH+H+H+H+H+H+H->N\nH+H->He\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H\nH->H"
},
{
"input": "17 6\nH H H H H H H H H H H H H H H H H\nH H H He Be O",
"output": "YES\nH+H+H+H+H+H+H+H->O\nH+H+H+H->Be\nH+H->He\nH->H\nH->H\nH->H"
},
{
"input": "17 17\nNe Na Mg B C N O F P Al Si He Li H Be S Cl\nH Mg Be B Na Si P C N Cl O Al He Li F Ne S",
"output": "YES\nS->S\nNe->Ne\nF->F\nLi->Li\nHe->He\nAl->Al\nO->O\nCl->Cl\nN->N\nC->C\nP->P\nSi->Si\nNa->Na\nB->B\nBe->Be\nMg->Mg\nH->H"
},
{
"input": "16 8\nLi Li Li Li Li Li Li Li Li Li Li Li Li Li Li Li\nC C C C C C C C",
"output": "YES\nLi+Li->C\nLi+Li->C\nLi+Li->C\nLi+Li->C\nLi+Li->C\nLi+Li->C\nLi+Li->C\nLi+Li->C"
},
{
"input": "17 17\nHe He He He He He He He He He He He He He He He He\nHe He He He He He He He He He He He He He He Li H",
"output": "NO"
},
{
"input": "17 10\nHe He He He He He He He He He He He He He He He He\nHe He He He He He He He Li P",
"output": "NO"
},
{
"input": "17 11\nHe He He He He He He He He He He He He He He He He\nHe He He He He He He He S H H",
"output": "NO"
},
{
"input": "17 4\nHe He He He He He He He He He He He He He He He He\nS S H H",
"output": "NO"
},
{
"input": "17 6\nHe He He He He He He He He He He He He He He He He\nNe Ne Ne He H H",
"output": "NO"
},
{
"input": "17 2\nH H H H H H H H H H H H H H H H H\nO F",
"output": "YES\nH+H+H+H+H+H+H+H+H->F\nH+H+H+H+H+H+H+H->O"
},
{
"input": "17 2\nH H H H H H H H H H H H H H H H H\nF O",
"output": "YES\nH+H+H+H+H+H+H+H->O\nH+H+H+H+H+H+H+H+H->F"
},
{
"input": "17 3\nH H H H H H H H H H H H H H H H H\nO H O",
"output": "YES\nH+H+H+H+H+H+H+H->O\nH->H\nH+H+H+H+H+H+H+H->O"
},
{
"input": "17 3\nH H H H H H H H H H H H H H H H H\nO O H",
"output": "YES\nH->H\nH+H+H+H+H+H+H+H->O\nH+H+H+H+H+H+H+H->O"
},
{
"input": "17 12\nHe He He He He He He He He He He He He He He He He\nHe He He He He He He He O O H H",
"output": "NO"
},
{
"input": "10 5\nNa F Li Zn Sr Kr Rh As Ru Se\nPa As Rn Y Se",
"output": "YES\nSe->Se\nF+Zn->Y\nLi+Sr+Rh->Rn\nAs->As\nNa+Kr+Ru->Pa"
},
{
"input": "13 4\nNa Br V N Cu Nb Se Zn Zn Al C B Cu\nFr Gd Ce Po",
"output": "YES\nBr+N+Cu+Al->Po\nNa+Nb+C->Ce\nSe+Zn->Gd\nV+Zn+B+Cu->Fr"
},
{
"input": "15 7\nAr Br Pd Y Na Mn Ga Rb He Br In Pd O Kr In\nPa Dy Ra Yb Pd Nd Pd",
"output": "YES\nPd->Pd\nBr+Mn->Nd\nPd->Pd\nNa+He+In+O->Yb\nY+In->Ra\nGa+Br->Dy\nAr+Rb+Kr->Pa"
},
{
"input": "16 5\nSr Kr S S Rh Ar Cu Sc O Be Ca Ga B Be Tc Ne\nTh Tc Fr Ir Ag",
"output": "YES\nAr+Cu->Ag\nS+S+Rh->Ir\nSr+Sc+O+Ca->Fr\nTc->Tc\nKr+Be+Ga+B+Be+Ne->Th"
},
{
"input": "16 6\nRh Pd N N Ar Y S S Sn Br Zn P Sn Ne Sr Mn\nCm At S Fr Re Ra",
"output": "YES\nPd+N+Br->Ra\nN+Ar+Sn->Re\nY+Ne+Sr->Fr\nS->S\nRh+P+Mn->At\nS+Zn+Sn->Cm"
},
{
"input": "16 7\nGa As Ne In Ga Be Ag Cr H Se Ge Pd Ag He Co Cr\nBk W Pt Cr Hg As Ba",
"output": "YES\nGa+Cr+H->Ba\nAs->As\nIn+Ga->Hg\nCr->Cr\nGe+Pd->Pt\nAg+Co->W\nNe+Be+Se+Ag+He->Bk"
},
{
"input": "16 8\nSr Ge Be Kr P Zr Al P Na Ne F B Ru Rh C K\nZr C Sm Zr K Os Pd I",
"output": "YES\nSr+P->I\nKr+Ne->Pd\nGe+Ru->Os\nK->K\nZr->Zr\nBe+Al+Rh->Sm\nC->C\nP+Na+F+B->Zr"
},
{
"input": "17 5\nKr Ge N K Ar Zn N Ni Sc Pd Zn Cl Al Be Ca Cu He\nOs Zn Th Tl Pb",
"output": "YES\nKr+Ge+N+N->Pb\nZn+Sc+Zn->Tl\nK+Ar+Be+Ca+Cu->Th\nCl+Al->Zn\nNi+Pd+He->Os"
},
{
"input": "17 6\nTc Li Zn Ne Tc Pd S Fe Tc S Co Cr Mn F Fe K Sc\nAu Fm Yb Fe Tm Bi",
"output": "YES\nTc+Zn+Ne->Bi\nTc+Fe->Tm\nFe->Fe\nTc+Co->Yb\nLi+Pd+S+S+K->Fm\nCr+Mn+F+Sc->Au"
},
{
"input": "17 7\nK K Ga In Nb Ca Cr Cu Cr C Na Mg Li Ge Ga Br K\nSe Pt Ho Sm Xe Cf Mg",
"output": "YES\nMg->Mg\nIn+Ca+Cu->Cf\nK+Cr+Na->Xe\nK+Cr+K->Sm\nGe+Br->Ho\nGa+Nb+C->Pt\nLi+Ga->Se"
},
{
"input": "17 8\nSc C Li Mg Ar Al Al C Na Tc Mo Cl O Sn S Ar Sc\nSc Rh Cu Al Pt C Lu Cs",
"output": "YES\nMg+Tc->Cs\nAr+Na+Mo->Lu\nC->C\nLi+Cl+O+Sn->Pt\nAl->Al\nAl+S->Cu\nSc+C+Ar->Rh\nSc->Sc"
},
{
"input": "17 13\nHe Ru Cu Sr P Br Ar Cr Na In Kr In Ca K Zn Rb Se\nKr Sr Na K P Hf He In Cf Ca Ar Cu Bi",
"output": "YES\nIn+Se->Bi\nCu->Cu\nAr->Ar\nCa->Ca\nRu+Cr+Zn->Cf\nIn->In\nHe->He\nBr+Rb->Hf\nP->P\nK->K\nNa->Na\nSr->Sr\nKr->Kr"
},
{
"input": "17 16\nCu C C Ti Ca Ag Y Ru Rh Cu Na Rh Pd Br Br Li Sr\nLi Ag Ti Te C Sr Ru Br Na Br Ca Rh Rh Cu Cu Y",
"output": "YES\nY->Y\nCu->Cu\nCu->Cu\nRh->Rh\nRh->Rh\nCa->Ca\nBr->Br\nNa->Na\nBr->Br\nRu->Ru\nSr->Sr\nC->C\nC+Pd->Te\nTi->Ti\nAg->Ag\nLi->Li"
},
{
"input": "17 17\nNa Fe K Nb Ti As Se Rb Pd Y In Co Kr Al Sc Ni Ar\nAl In K Se Pd Na Y Ar Ti Ni Sc Kr Fe Co Rb Nb As",
"output": "YES\nAs->As\nNb->Nb\nRb->Rb\nCo->Co\nFe->Fe\nKr->Kr\nSc->Sc\nNi->Ni\nTi->Ti\nAr->Ar\nY->Y\nNa->Na\nPd->Pd\nSe->Se\nK->K\nIn->In\nAl->Al"
},
{
"input": "15 8\nSi Pr Se F Br Sb Ti Cs Cr Sb La Cu V Ca Cr\nSb Sb Cd Fr Eu Mo Lu Pu",
"output": "YES\nPr+Br->Pu\nSi+La->Lu\nTi+Ca->Mo\nSe+Cu->Eu\nF+Cs+V->Fr\nCr+Cr->Cd\nSb->Sb\nSb->Sb"
},
{
"input": "16 7\nSe Ba Cr O Sb Sn In Cr Pd V Zr Na Sn F Ti Pr\nFm Y Ac Pb Ba Es Pa",
"output": "YES\nSe+Pd+Na->Pa\nCr+Sb+Cr->Es\nBa->Ba\nV+Pr->Pb\nIn+Zr->Ac\nO+F+Ti->Y\nSn+Sn->Fm"
},
{
"input": "16 6\nV Rh Nd Ce S Mn O N Cu Ni Ne Ne Y V Co Li\nFr Tm Cf Es Cr Se",
"output": "YES\nN+Co->Se\nS+O->Cr\nNd+Y->Es\nRh+Mn+Ni->Cf\nV+Ne+Ne+V+Li->Tm\nCe+Cu->Fr"
},
{
"input": "16 6\nBr Nd Mn Li Li Br Na Mo Sb Ne Mn Cr V N Ne Cr\nCu Yb Nd Mo Ac Cf",
"output": "YES\nMn+Mn+Cr+Cr->Cf\nNa+Sb+Ne+N+Ne->Ac\nMo->Mo\nNd->Nd\nBr+Br->Yb\nLi+Li+V->Cu"
},
{
"input": "17 8\nTe Cu Ca O Be Y Ge Sc Al Sb Pr Zn As Pd V Mo N\nYb Cu V Bk Hf Pu Br Ac",
"output": "YES\nPr+Zn->Ac\nCa+O+N->Br\nTe+Mo->Pu\nY+As->Hf\nSb+Pd->Bk\nV->V\nCu->Cu\nBe+Ge+Sc+Al->Yb"
},
{
"input": "17 8\nNb Tc O Si Zr Ti Tc Ce C Ar Sc Sb S Ag I Rh Li\nSe Sb I Mo Am Tl Fr Rn",
"output": "YES\nTc+Tc->Rn\nO+Ce+Sc->Fr\nNb+Zr->Tl\nAg+Rh+Li->Am\nSi+Ti+C->Mo\nI->I\nSb->Sb\nAr+S->Se"
},
{
"input": "17 7\nSc Ti Kr Cr Zr C F Ne Ge Kr In Se I Cd Sr Ru He\nBr Ra Bi Tc Np Hf Th",
"output": "YES\nNe+Ge+Cd->Th\nKr+Kr->Hf\nZr+I->Np\nSc+Ti->Tc\nIn+Se->Bi\nC+Sr+Ru->Ra\nCr+F+He->Br"
},
{
"input": "14 6\nH C Ca S Fe Na H S F V C Sc Ne B\nFe Sc P O Es He",
"output": "NO"
},
{
"input": "15 5\nCo V Na C Fe S Ca Ca V Fe O N N Sc Sc\nRn Te Bi V Ar",
"output": "YES\nNa+N->Ar\nV->V\nCo+S+Ca+Ca->Bi\nFe+Fe->Te\nC+V+O+N+Sc+Sc->Rn"
},
{
"input": "15 5\nNi F Si Ca Mg Mn Ar Ca Ar B Cu H S Li Li\nNe Pu Ru Mn Cd",
"output": "YES\nNi+Ca->Cd\nMn->Mn\nSi+Mg+Ar->Ru\nCa+Ar+B+Cu+S+Li+Li->Pu\nF+H->Ne"
},
{
"input": "16 7\nBe Fe Cr O Sc Ca K Cr S V Ne Na Ca F Ti Cu\nFe Cl V Pu Re Sc Zn",
"output": "YES\nBe+Fe->Zn\nSc->Sc\nCr+Ca+Na+Ca->Re\nK+Cr+Ti+Cu->Pu\nV->V\nO+F->Cl\nS+Ne->Fe"
},
{
"input": "16 7\nV P Zn Ni S Mn O N Cu Ni Ne Ne F V Co Li\nBa Cr Gd Nd Na Zn Pd",
"output": "YES\nZn+S->Pd\nV+N->Zn\nO+Li->Na\nNe+V+Co->Nd\nMn+Cu+Ne->Gd\nP+F->Cr\nNi+Ni->Ba"
},
{
"input": "16 9\nB Zn Mn Li Li B Na Mg Sc Ne Mn Cr V N Ne Cr\nB V Cd Sc Al Fm B Cl C",
"output": "NO"
},
{
"input": "17 6\nTi Cu Ca O Be F He Sc Al Sc Cu Zn Li S V Mg N\nK Ra N Ag Na Bk",
"output": "YES\nTi+Ca+Sc+Al+Sc->Bk\nF+He->Na\nO+S+V->Ag\nBe+Li->N\nCu+Cu+Zn->Ra\nMg+N->K"
},
{
"input": "17 8\nNa Al O Si Ne Ti Al Ni C Ar Sc Sc S Cl V P Li\nSi Ba Pa Na F Ar Fe Se",
"output": "YES\nAl+Sc->Se\nNe+S->Fe\nAr->Ar\nC+Li->F\nNa->Na\nO+Ti+Sc+Cl+V->Pa\nAl+Ni+P->Ba\nSi->Si"
},
{
"input": "17 10\nSc Ti C Cr Ne C F Ne He C K Be V Ar O Si He\nO Pb Sc Ca V Be O Be Ca Si",
"output": "NO"
},
{
"input": "17 6\nNi Mn H Cr P Ca Cu Sc Be P Be P C Ne He Zn Ti\nPd Ta Fm Ti He Ni",
"output": "YES\nNi->Ni\nHe->He\nH+Sc->Ti\nMn+Cr+P+P+P+C->Fm\nCu+Be+Ne+Zn->Ta\nCa+Be+Ti->Pd"
},
{
"input": "14 8\nS Br Sc Pd Ga Ga C Fe Zr Ga Li Cu Pd Sn\nPm Au Te Y Sm Ag Li Er",
"output": "NO"
},
{
"input": "15 6\nNe Cl Ar Co Li S Nb Pd S V H Nb Ag Pd Ca\nSm Ho Xe U Tb Ge",
"output": "YES\nS+S->Ge\nNb+V+H->Tb\nPd+Pd->U\nNe+Cl+Co->Xe\nAg+Ca->Ho\nAr+Li+Nb->Sm"
},
{
"input": "15 7\nH Ge Rh Ar Y Ca Ni Tc B Li Zn Ru O Pd K\nAl Eu Se Cu At Gd Np",
"output": "NO"
},
{
"input": "16 7\nKr Se F Ca Cu H Zr He Cd Tc F Na Ru Zr Fe Si\nEu Ga Th At F Ho Pm",
"output": "NO"
},
{
"input": "16 11\nCa Kr Cl Ar V F Tc Sr Li Zn Cd P N In Ca Mn\nLi Fr Tb Be Os S Ni Ga Cd Ne As",
"output": "NO"
},
{
"input": "16 8\nBr Al Ga Zn Rh Ne V Zn Se H Br Mg Se Tc Mn Ag\nSi Fm Po Rn Gd Mo N Sb",
"output": "NO"
},
{
"input": "17 11\nV In Si Mg F Cd V Nb V Zr In Co Ge Kr Sn Nb Mg\nAl Es Ac Ac Ti Sb Mg Th Co Mn Mg",
"output": "NO"
},
{
"input": "17 10\nCd Nb Li Rb Tc Sn V Nb Cr Mo Sr Ga C Cd Rh Kr Tc\nBk Te V U Ta Es Be I Es N",
"output": "NO"
},
{
"input": "17 11\nMg As Sc Se Ni Cu Ti Sr Mo Sn Se Fe Sn Se Fe Y Pd\nCr Cu Ca Hf Fr Tm K In Tc La Am",
"output": "NO"
},
{
"input": "17 8\nGe Sc Se Fe Ge Mn Ca Rh Ca Br Ru F Cr Zr P Ar H\nTc Cm Fm Gd Se Ti Mn La",
"output": "NO"
},
{
"input": "17 10\nHe He He He He He He He He He He He He He He He He\nHe He He He He He He Ar H H",
"output": "NO"
},
{
"input": "17 4\nHe He He He He He He He He He He He He He He He He\nAr Si H H",
"output": "NO"
},
{
"input": "17 4\nHe He He He He He He He He He He He He He He He He\nSi Ar H H",
"output": "NO"
},
{
"input": "17 4\nH H H H H H H H H H H H H H H H F\nO O O H",
"output": "NO"
},
{
"input": "17 4\nH H H H H H H H H H H H H H H H O\nN N N Li",
"output": "NO"
},
{
"input": "17 5\nH H H H H H H H H H H H H H H H Ne\nC C C C He",
"output": "NO"
},
{
"input": "17 5\nH H H H H H H H H H H H H H H H O\nB B B B Be",
"output": "NO"
},
{
"input": "17 6\nH H H H H H H H H H H H H H H H B\nBe Be Be Be Be H",
"output": "NO"
},
{
"input": "17 7\nH H H H H H H H H H H H H H H H B\nLi Li Li Li Li Li Li",
"output": "NO"
},
{
"input": "17 10\nH H H H H H H H H H H H H H H H Be\nHe He He He He He He He He He",
"output": "NO"
},
{
"input": "17 17\nH H H H H H H H H H H H H H H H Li\nHe H H H H H H H H H H H H H H H He",
"output": "NO"
},
{
"input": "17 17\nBe Be Be Be Be Be Be Be Be Be Be Be Be Be Be Be Be\nBe Be Be Be Be Be Be Be Be Be Be Be Be Be Be He C",
"output": "NO"
},
{
"input": "17 17\nH He Li Be B C N O F Ne Na Mg Al Si P S Cl\nCl S P Si Al Mg Na Ne F O N C B Be Li He H",
"output": "YES\nH->H\nHe->He\nLi->Li\nBe->Be\nB->B\nC->C\nN->N\nO->O\nF->F\nNe->Ne\nNa->Na\nMg->Mg\nAl->Al\nSi->Si\nP->P\nS->S\nCl->Cl"
}
] | 342 | 9,728,000 | 3.81088 | 56,741 |
286 | Shifting | [
"implementation"
] | null | null | John Doe has found the beautiful permutation formula.
Let's take permutation *p*<==<=*p*1,<=*p*2,<=...,<=*p**n*. Let's define transformation *f* of this permutation:
where *k* (*k*<=><=1) is an integer, the transformation parameter, *r* is such maximum integer that *rk*<=β€<=*n*. If *rk*<==<=*n*, then elements *p**rk*<=+<=1,<=*p**rk*<=+<=2 and so on are omitted. In other words, the described transformation of permutation *p* cyclically shifts to the left each consecutive block of length *k* and the last block with the length equal to the remainder after dividing *n* by *k*.
John Doe thinks that permutation *f*(*f*(Β ...Β *f*(*p*<==<=[1,<=2,<=...,<=*n*],<=2)Β ...Β ,<=*n*<=-<=1),<=*n*) is beautiful. Unfortunately, he cannot quickly find the beautiful permutation he's interested in. That's why he asked you to help him.
Your task is to find a beautiful permutation for the given *n*. For clarifications, see the notes to the third sample. | A single line contains integer *n* (2<=β€<=*n*<=β€<=106). | Print *n* distinct space-separated integers from 1 to *n* β a beautiful permutation of size *n*. | [
"2\n",
"3\n",
"4\n"
] | [
"2 1 \n",
"1 3 2 \n",
"4 2 3 1 \n"
] | A note to the third test sample:
- *f*([1,β2,β3,β4],β2)β=β[2,β1,β4,β3] - *f*([2,β1,β4,β3],β3)β=β[1,β4,β2,β3] - *f*([1,β4,β2,β3],β4)β=β[4,β2,β3,β1] | [] | 92 | 0 | 0 | 56,833 |
|
875 | Royal Questions | [
"dsu",
"graphs",
"greedy"
] | null | null | In a medieval kingdom, the economic crisis is raging. Milk drops fall, Economic indicators are deteriorating every day, money from the treasury disappear. To remedy the situation, King Charles Sunnyface decided make his *n* sons-princes marry the brides with as big dowry as possible.
In search of candidates, the king asked neighboring kingdoms, and after a while several delegations arrived with *m* unmarried princesses. Receiving guests, Karl learned that the dowry of the *i* th princess is *w**i* of golden coins.
Although the action takes place in the Middle Ages, progressive ideas are widespread in society, according to which no one can force a princess to marry a prince whom she does not like. Therefore, each princess has an opportunity to choose two princes, for each of which she is ready to become a wife. The princes were less fortunate, they will obey the will of their father in the matter of choosing a bride.
Knowing the value of the dowry and the preferences of each princess, Charles wants to play weddings in such a way that the total dowry of the brides of all his sons would be as great as possible. At the same time to marry all the princes or princesses is not necessary. Each prince can marry no more than one princess, and vice versa, each princess can marry no more than one prince.
Help the king to organize the marriage of his sons in the most profitable way for the treasury. | The first line contains two integers *n*, *m* (2<=β€<=*n*<=β€<=200<=000, 1<=β€<=*m*<=β€<=200<=000)Β β number of princes and princesses respectively.
Each of following *m* lines contains three integers *a**i*, *b**i*, *w**i* (1<=β€<=*a**i*,<=*b**i*<=β€<=*n*, *a**i*<=β <=*b**i*, 1<=β€<=*w**i*<=β€<=10<=000)Β β number of princes, which *i*-th princess is ready to marry and the value of her dowry. | Print the only integerΒ β the maximum number of gold coins that a king can get by playing the right weddings. | [
"2 3\n1 2 5\n1 2 1\n2 1 10\n",
"3 2\n1 2 10\n3 2 20\n"
] | [
"15",
"30"
] | none | [
{
"input": "2 3\n1 2 5\n1 2 1\n2 1 10",
"output": "15"
},
{
"input": "3 2\n1 2 10\n3 2 20",
"output": "30"
},
{
"input": "2 2\n1 2 1\n1 2 2",
"output": "3"
},
{
"input": "3 3\n1 3 4\n1 3 2\n1 3 8",
"output": "12"
},
{
"input": "2 1\n1 2 6",
"output": "6"
},
{
"input": "4 3\n1 2 1\n2 3 2\n3 4 1",
"output": "4"
},
{
"input": "4 2\n1 2 4\n1 2 5",
"output": "9"
},
{
"input": "4 2\n1 2 3\n1 3 4",
"output": "7"
},
{
"input": "4 4\n1 2 6971\n1 2 4379\n3 4 1092\n3 2 9449",
"output": "21891"
},
{
"input": "7 6\n3 5 4229\n2 7 7116\n3 4 2492\n7 3 3742\n7 3 2996\n3 4 8359",
"output": "26442"
},
{
"input": "7 15\n5 4 9125\n3 6 2173\n2 1 2908\n7 3 9796\n5 3 9402\n6 2 9802\n7 6 8455\n6 1 9821\n1 2 9799\n7 2 8280\n1 4 1845\n3 5 6506\n2 1 2821\n6 7 4858\n1 3 9568",
"output": "67313"
},
{
"input": "10 50\n2 8 7070\n10 5 1352\n1 5 760\n4 8 6903\n4 1 6374\n5 4 2255\n2 7 1351\n8 3 7621\n8 5 5733\n7 6 7104\n7 2 594\n2 4 7972\n3 10 6868\n4 8 1694\n3 5 93\n8 9 5825\n8 10 510\n9 6 2703\n9 2 8798\n8 7 7146\n3 4 4939\n2 6 9369\n6 8 3402\n5 4 6563\n8 7 5404\n4 7 7863\n8 5 4330\n9 5 9133\n5 10 3601\n9 5 7030\n8 6 7647\n4 9 8909\n1 6 4289\n10 1 1326\n4 9 7531\n3 10 8884\n9 4 2286\n6 2 2643\n10 2 2100\n7 3 8342\n3 7 9225\n5 4 653\n1 10 3427\n3 6 3328\n8 2 5568\n4 10 4697\n8 4 4305\n8 3 5660\n9 4 8040\n4 6 5439",
"output": "84721"
},
{
"input": "10 9\n9 7 9297\n5 1 2172\n4 10 9919\n10 9 9478\n6 2 6941\n1 6 2934\n2 8 1499\n3 4 7388\n8 3 4845",
"output": "54473"
},
{
"input": "10 10\n1 9 4597\n6 2 3894\n7 8 2691\n3 10 8150\n5 3 1567\n6 1 560\n6 3 9273\n7 6 5282\n2 9 434\n9 1 2511",
"output": "38525"
},
{
"input": "2 2\n2 1 1473\n1 2 5870",
"output": "7343"
},
{
"input": "4 4\n4 2 1646\n2 4 3586\n3 1 3468\n1 3 6363",
"output": "15063"
},
{
"input": "8 8\n3 8 4455\n1 2 5674\n2 1 4563\n4 5 5728\n5 4 2115\n8 3 5634\n6 7 8260\n7 6 1492",
"output": "37921"
},
{
"input": "2 1\n1 2 792",
"output": "792"
},
{
"input": "5 4\n1 4 6895\n3 5 2890\n4 2 2089\n2 3 8673",
"output": "20547"
},
{
"input": "2 2\n1 2 10000\n2 1 10000",
"output": "20000"
}
] | 124 | 0 | 0 | 56,863 |
|
518 | Pasha and Pipe | [
"binary search",
"brute force",
"combinatorics",
"dp",
"implementation"
] | null | null | On a certain meeting of a ruling party "A" minister Pavel suggested to improve the sewer system and to create a new pipe in the city.
The city is an *n*<=Γ<=*m* rectangular squared field. Each square of the field is either empty (then the pipe can go in it), or occupied (the pipe cannot go in such square). Empty squares are denoted by character '.', occupied squares are denoted by character '#'.
The pipe must meet the following criteria:
- the pipe is a polyline of width 1, - the pipe goes in empty squares, - the pipe starts from the edge of the field, but not from a corner square, - the pipe ends at the edge of the field but not in a corner square, - the pipe has at most 2 turns (90 degrees), - the border squares of the field must share exactly two squares with the pipe, - if the pipe looks like a single segment, then the end points of the pipe must lie on distinct edges of the field, - for each non-border square of the pipe there are exacly two side-adjacent squares that also belong to the pipe, - for each border square of the pipe there is exactly one side-adjacent cell that also belongs to the pipe.
Here are some samples of allowed piping routes:
Here are some samples of forbidden piping routes:
In these samples the pipes are represented by characters '<=*<='.
You were asked to write a program that calculates the number of distinct ways to make exactly one pipe in the city.
The two ways to make a pipe are considered distinct if they are distinct in at least one square. | The first line of the input contains two integers *n*,<=*m* (2<=β€<=*n*,<=*m*<=β€<=2000)Β βΒ the height and width of Berland map.
Each of the next *n* lines contains *m* characters β the map of the city.
If the square of the map is marked by character '.', then the square is empty and the pipe can through it.
If the square of the map is marked by character '#', then the square is full and the pipe can't through it. | In the first line of the output print a single integer β the number of distinct ways to create a pipe. | [
"3 3\n...\n..#\n...\n",
"4 2\n..\n..\n..\n..\n",
"4 5\n#...#\n#...#\n###.#\n###.#\n"
] | [
"3",
"2\n",
"4"
] | In the first sample there are 3 ways to make a pipe (the squares of the pipe are marked by characters 'β*β'): | [] | 46 | 0 | 0 | 56,927 |
|
479 | Long Jumps | [
"binary search",
"greedy",
"implementation"
] | null | null | Valery is a PE teacher at a school in Berland. Soon the students are going to take a test in long jumps, and Valery has lost his favorite ruler!
However, there is no reason for disappointment, as Valery has found another ruler, its length is *l* centimeters. The ruler already has *n* marks, with which he can make measurements. We assume that the marks are numbered from 1 to *n* in the order they appear from the beginning of the ruler to its end. The first point coincides with the beginning of the ruler and represents the origin. The last mark coincides with the end of the ruler, at distance *l* from the origin. This ruler can be repesented by an increasing sequence *a*1,<=*a*2,<=...,<=*a**n*, where *a**i* denotes the distance of the *i*-th mark from the origin (*a*1<==<=0, *a**n*<==<=*l*).
Valery believes that with a ruler he can measure the distance of *d* centimeters, if there is a pair of integers *i* and *j* (1<=β€<=*i*<=β€<=*j*<=β€<=*n*), such that the distance between the *i*-th and the *j*-th mark is exactly equal to *d* (in other words, *a**j*<=-<=*a**i*<==<=*d*).
Under the rules, the girls should be able to jump at least *x* centimeters, and the boys should be able to jump at least *y* (*x*<=<<=*y*) centimeters. To test the children's abilities, Valery needs a ruler to measure each of the distances *x* and *y*.
Your task is to determine what is the minimum number of additional marks you need to add on the ruler so that they can be used to measure the distances *x* and *y*. Valery can add the marks at any integer non-negative distance from the origin not exceeding the length of the ruler. | The first line contains four positive space-separated integers *n*, *l*, *x*, *y* (2<=β€<=*n*<=β€<=105, 2<=β€<=*l*<=β€<=109, 1<=β€<=*x*<=<<=*y*<=β€<=*l*) β the number of marks, the length of the ruler and the jump norms for girls and boys, correspondingly.
The second line contains a sequence of *n* integers *a*1,<=*a*2,<=...,<=*a**n* (0<==<=*a*1<=<<=*a*2<=<<=...<=<<=*a**n*<==<=*l*), where *a**i* shows the distance from the *i*-th mark to the origin. | In the first line print a single non-negative integer *v* β the minimum number of marks that you need to add on the ruler.
In the second line print *v* space-separated integers *p*1,<=*p*2,<=...,<=*p**v* (0<=β€<=*p**i*<=β€<=*l*). Number *p**i* means that the *i*-th mark should be at the distance of *p**i* centimeters from the origin. Print the marks in any order. If there are multiple solutions, print any of them. | [
"3 250 185 230\n0 185 250\n",
"4 250 185 230\n0 20 185 250\n",
"2 300 185 230\n0 300\n"
] | [
"1\n230\n",
"0\n",
"2\n185 230\n"
] | In the first sample it is impossible to initially measure the distance of 230 centimeters. For that it is enough to add a 20 centimeter mark or a 230 centimeter mark.
In the second sample you already can use the ruler to measure the distances of 185 and 230 centimeters, so you don't have to add new marks.
In the third sample the ruler only contains the initial and the final marks. We will need to add two marks to be able to test the children's skills. | [
{
"input": "3 250 185 230\n0 185 250",
"output": "1\n230"
},
{
"input": "4 250 185 230\n0 20 185 250",
"output": "0"
},
{
"input": "2 300 185 230\n0 300",
"output": "2\n185 230"
},
{
"input": "4 300 4 5\n0 6 7 300",
"output": "1\n11"
},
{
"input": "2 100 30 70\n0 100",
"output": "1\n30"
},
{
"input": "2 300 140 160\n0 300",
"output": "1\n140"
},
{
"input": "4 300 1 2\n0 298 299 300",
"output": "0"
},
{
"input": "3 350 150 160\n0 310 350",
"output": "1\n150"
},
{
"input": "4 300 4 5\n0 298 299 300",
"output": "1\n294"
},
{
"input": "19 180 117 148\n0 1 19 20 21 28 57 65 68 70 78 88 100 116 154 157 173 179 180",
"output": "2\n117 148"
},
{
"input": "14 134 99 114\n0 6 8 19 50 61 69 83 84 96 111 114 125 134",
"output": "1\n99"
},
{
"input": "18 187 27 157\n0 17 18 31 36 37 40 53 73 86 96 107 119 150 167 181 184 187",
"output": "1\n27"
},
{
"input": "20 179 69 120\n0 6 8 11 21 24 55 61 83 84 96 111 114 116 125 140 147 154 176 179",
"output": "1\n27"
},
{
"input": "16 115 62 112\n0 5 24 32 38 43 44 57 62 72 74 92 103 105 113 115",
"output": "1\n112"
},
{
"input": "112 1867 1261 1606\n0 7 17 43 67 70 87 112 129 141 148 162 179 180 189 202 211 220 231 247 250 277 308 311 327 376 400 406 409 417 418 444 480 512 514 515 518 547 572 575 578 587 612 617 654 684 701 742 757 761 788 821 825 835 841 843 850 858 869 872 881 936 939 969 970 971 997 1026 1040 1045 1068 1070 1073 1076 1095 1110 1115 1154 1166 1178 1179 1203 1204 1225 1237 1241 1246 1275 1302 1305 1311 1312 1315 1338 1340 1419 1428 1560 1561 1576 1591 1594 1618 1643 1658 1660 1664 1689 1803 1822 1835 1867",
"output": "1\n1808"
},
{
"input": "2 2 1 2\n0 2",
"output": "1\n1"
},
{
"input": "3 2 1 2\n0 1 2",
"output": "0"
},
{
"input": "3 10 2 3\n0 1 10",
"output": "1\n3"
},
{
"input": "4 10 3 5\n0 1 9 10",
"output": "1\n4"
},
{
"input": "5 1000 777 778\n0 1 500 501 1000",
"output": "1\n778"
},
{
"input": "3 10 1 3\n0 2 10",
"output": "1\n3"
},
{
"input": "4 300 120 150\n0 110 140 300",
"output": "1\n260"
},
{
"input": "5 401 300 400\n0 100 250 350 401",
"output": "1\n400"
},
{
"input": "3 10 1 8\n0 7 10",
"output": "1\n8"
},
{
"input": "4 1000 2 3\n0 400 405 1000",
"output": "1\n402"
},
{
"input": "6 12 7 10\n0 1 3 4 6 12",
"output": "1\n10"
},
{
"input": "4 1000 10 20\n0 500 530 1000",
"output": "1\n510"
},
{
"input": "3 8 2 3\n0 7 8",
"output": "1\n5"
},
{
"input": "4 10 8 9\n0 4 5 10",
"output": "2\n8 9"
},
{
"input": "4 10 7 8\n0 5 6 10",
"output": "2\n7 8"
},
{
"input": "6 35 29 30\n0 10 11 31 32 35",
"output": "1\n2"
},
{
"input": "5 200000 1 100029\n0 100000 100009 100010 200000",
"output": "1\n100029"
},
{
"input": "4 1000 900 901\n0 950 951 1000",
"output": "1\n50"
},
{
"input": "6 504 400 500\n0 3 5 103 105 504",
"output": "1\n503"
},
{
"input": "5 550 300 400\n0 151 251 450 550",
"output": "1\n150"
},
{
"input": "4 300 40 50\n0 280 290 300",
"output": "1\n240"
},
{
"input": "2 1000000000 100000000 500000000\n0 1000000000",
"output": "2\n100000000 500000000"
},
{
"input": "4 600 100 400\n0 50 350 600",
"output": "1\n450"
},
{
"input": "4 100 7 8\n0 3 4 100",
"output": "1\n11"
},
{
"input": "4 100 80 81\n0 2 3 100",
"output": "1\n83"
},
{
"input": "3 13 8 10\n0 2 13",
"output": "1\n10"
},
{
"input": "4 10 7 8\n0 4 5 10",
"output": "2\n7 8"
},
{
"input": "3 450 100 400\n0 150 450",
"output": "1\n50"
},
{
"input": "4 500 30 50\n0 20 40 500",
"output": "1\n50"
},
{
"input": "4 100 10 11\n0 4 5 100",
"output": "1\n15"
},
{
"input": "2 10 5 7\n0 10",
"output": "2\n5 7"
},
{
"input": "6 100 70 71\n0 50 51 90 91 100",
"output": "1\n20"
},
{
"input": "4 9 6 7\n0 4 5 9",
"output": "2\n6 7"
},
{
"input": "3 10 1 8\n0 3 10",
"output": "1\n2"
},
{
"input": "3 12 1 2\n0 10 12",
"output": "1\n1"
},
{
"input": "4 100 3 5\n0 40 48 100",
"output": "1\n43"
},
{
"input": "3 20 17 18\n0 19 20",
"output": "1\n2"
},
{
"input": "4 1000 45 46\n0 2 3 1000",
"output": "1\n48"
},
{
"input": "4 10 5 7\n0 4 6 10",
"output": "2\n5 7"
},
{
"input": "3 12 1 3\n0 10 12",
"output": "1\n9"
},
{
"input": "4 20 6 7\n0 1 15 20",
"output": "1\n7"
},
{
"input": "3 11 3 5\n0 9 11",
"output": "1\n6"
},
{
"input": "3 100 9 10\n0 99 100",
"output": "1\n90"
},
{
"input": "3 10 7 8\n0 1 10",
"output": "1\n8"
},
{
"input": "3 10 5 6\n0 9 10",
"output": "1\n4"
},
{
"input": "3 10 7 8\n0 9 10",
"output": "1\n2"
},
{
"input": "3 10 6 7\n0 9 10",
"output": "1\n3"
},
{
"input": "3 9 6 7\n0 1 9",
"output": "1\n7"
},
{
"input": "3 1000000000 99 100\n0 1 1000000000",
"output": "1\n100"
},
{
"input": "4 10 3 5\n0 2 4 10",
"output": "1\n5"
},
{
"input": "4 100 90 91\n0 7 8 100",
"output": "1\n98"
},
{
"input": "4 100 80 81\n0 98 99 100",
"output": "1\n18"
}
] | 1,000 | 13,107,200 | 0 | 57,061 |
|
39 | Inverse Function | [
"implementation"
] | G. Inverse Function | 5 | 64 | Petya wrote a programme on C++ that calculated a very interesting function *f*(*n*). Petya ran the program with a certain value of *n* and went to the kitchen to have some tea. The history has no records concerning how long the program had been working. By the time Petya returned, it had completed the calculations and had the result. However while Petya was drinking tea, a sly virus managed to destroy the input file so that Petya can't figure out for which value of *n* the program was run. Help Petya, carry out the inverse function!
Mostly, the program consists of a function in C++ with the following simplified syntax:
- *function* ::= int f(int n) {*operatorSequence*}- *operatorSequence* ::= *operator*Β |Β *operator*Β *operatorSequence*- *operator* ::= return *arithmExpr*; | if (*logicalExpr*) return *arithmExpr*;- *logicalExpr* ::= *arithmExpr*<=><=*arithmExpr* | *arithmExpr*<=<<=*arithmExpr* | *arithmExpr* == *arithmExpr*- *arithmExpr* ::= *sum*- *sum* ::= *product* | *sum*<=+<=*product* | *sum*<=-<=*product*- *product* ::= *multiplier* | *product*<=*<=*multiplier* | *product*<=/<=*multiplier*- *multiplier* ::= n | *number* | f(*arithmExpr*)- *number* ::= 0|1|2|... |32767
The whitespaces in a *operatorSequence* are optional.
Thus, we have a function, in which body there are two kinds of operators. There is the operator "return *arithmExpr*;" that returns the value of the expression as the value of the function, and there is the conditional operator "if (*logicalExpr*) return *arithmExpr*;" that returns the value of the arithmetical expression when and only when the logical expression is true. Guaranteed that no other constructions of C++ language β cycles, assignment operators, nested conditional operators etc, and other variables except the *n* parameter are used in the function. All the constants are integers in the interval [0..32767].
The operators are performed sequentially. After the function has returned a value other operators in the sequence are not performed. Arithmetical expressions are performed taking into consideration the standard priority of the operations. It means that first all the products that are part of the sum are calculated. During the calculation of the products the operations of multiplying and division are performed from the left to the right. Then the summands are summed, and the addition and the subtraction are also performed from the left to the right. Operations ">" (more), "<" (less) and "==" (equals) also have standard meanings.
Now you've got to pay close attention! The program is compiled with the help of 15-bit Berland C++ compiler invented by a Berland company BerSoft, that's why arithmetical operations are performed in a non-standard way. Addition, subtraction and multiplication are performed modulo 32768 (if the result of subtraction is negative, then 32768 is added to it until the number belongs to the interval [0..32767]). Division "/" is a usual integer division where the remainder is omitted.
Examples of arithmetical operations:
Guaranteed that for all values of *n* from 0 to 32767 the given function is performed correctly. That means that:
1. Division by 0 never occures.
2. When performing a function for the value *n*<==<=*N* recursive calls of the function *f* may occur only for the parameter value of 0,<=1,<=...,<=*N*<=-<=1. Consequently, the program never has an infinite recursion.
3. As the result of the sequence of the operators, the function always returns a value.
We have to mention that due to all the limitations the value returned by the function *f* is independent from either global variables or the order of performing the calculations of arithmetical expressions as part of the logical one, or from anything else except the value of *n* parameter. That's why the *f* function can be regarded as a function in its mathematical sense, i.e. as a unique correspondence between any value of *n* from the interval [0..32767] and a value of *f*(*n*) from the same interval.
Given the value of *f*(*n*), and you should find *n*. If the suitable *n* value is not unique, you should find the maximal one (from the interval [0..32767]). | The first line has an integer *f*(*n*) from the interval [0..32767]. The next lines have the description of the function *f*. In the description can be found extra spaces and line breaks (see the examples) which, of course, canβt break key words int, if, return and numbers. The size of input data canβt exceed 100 bytes. | Output a single number β the answer to the problem. If thereβs no answer, output "-1" (without quotes). | [
"17\nint f(int n)\n{\nif (n < 100) return 17;\nif (n > 99) return 27;\n}\n",
"13\nint f(int n)\n{\nif (n == 0) return 0;\nreturn f(n - 1) + 1;\n}\n",
"144\nint f(int n)\n{\nif (n == 0) return 0;\nif (n == 1) return n;\nreturn f(n - 1) + f(n - 2);\n}"
] | [
"99\n",
"13",
"24588\n"
] | none | [
{
"input": "17\nint f(int n)\n{\nif (n < 100) return 17;\nif (n > 99) return 27;\n}",
"output": "99"
},
{
"input": "13\nint f(int n)\n{\nif (n == 0) return 0;\nreturn f(n - 1) + 1;\n}",
"output": "13"
},
{
"input": "144\nint f(int n)\n{\nif (n == 0) return 0;\nif (n == 1) return n;\nreturn f(n - 1) + f(n - 2);\n}",
"output": "24588"
},
{
"input": "32767\nint f(int n)\n{\nreturn n;\n}",
"output": "32767"
},
{
"input": "27926\nint f(int n)\n{\nreturn n*n + 5*n/3 + 19 * 1423;\n}",
"output": "29"
},
{
"input": "1\nint f(int n)\n{\nif (n == 0) return 153/12+5;\nreturn 32767/n;\n}",
"output": "32767"
},
{
"input": "32\nint f(int n)\n{\nif (n == 0) return 1;\nreturn f(n - 1) * 7;\n}",
"output": "-1"
},
{
"input": "1\nint f(int n)\n{\nif (n == 0) return 1;\nreturn f(n - 1) * 7;\n}",
"output": "28672"
},
{
"input": "0\nint f(int n)\n{\nif (n < 2) return 1;\nreturn f(n - 1) + f(n - 2);\n}",
"output": "24575"
},
{
"input": "32\nint f(int n)\n{\nif (n < 2) return 1;\nreturn f(n - 1) + f(n - 2);\n}",
"output": "15959"
},
{
"input": "12351\nint f(int n)\n{\nif (n < 3) return n;\nreturn f(n - 1) * n + f(n - 2) + f(n - 3) / 5;\n}",
"output": "26464"
},
{
"input": "0\nint f(int n){if (n < 1) return 0;return f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(0)))))))))))))))));}",
"output": "32767"
},
{
"input": "0\nint f(int n){if (n < 1) return 1;if (n < 2) return 0;return f(f(f(f(f(f(f(f(f(f(n-1))))))))));}",
"output": "32767"
},
{
"input": "1\nint f(int n){if (n < 1) return 1;if (n < 2) return 0;return f(f(f(f(f(f(f(f(f(f(n-1))))))))));}",
"output": "32766"
},
{
"input": "14\nint f(int n)\n{\nif (n < 1) return 0;\nreturn f(n / 2) + 1;\n}",
"output": "16383"
},
{
"input": "12\nint f(int n)\n{\nif (n < 1) return 0;\nreturn f(n / 2) + 1;\n}",
"output": "4095"
},
{
"input": "100\nint f(int n){if (n < 3) return 1;return f(n-1)+f(n-2)+f(n-3);}",
"output": "-1"
},
{
"input": "7113\nint f(int n)\n{\nif (n < 3) return n;\nreturn f(n - 1) * n + f(n - 2) + f(n - 3) / 5;\n}",
"output": "31277"
},
{
"input": "7169\nint f(int n){if (n < 7) return 1; return f(n-1)+f(n-2)+f(n-3)+f(n-4)+f(n-5)-f(n-6)-f(n-7);}",
"output": "32258"
},
{
"input": "32657\nint f(int n){if (n < 7) return 1; return f(n-1)+f(n-2)+f(n-3)+f(n-4)+f(n-5)-f(n-6)-f(n-7);}",
"output": "32308"
},
{
"input": "5\nint f(int n){if (n < 2) return 1;if (n < 8) return 2;if (n > 8) return 7;if (n > 2) return 5;}",
"output": "8"
},
{
"input": "2\nint f(int n){if (n < 2) return 1;if (n < 8) return 2;if (n > 8) return 7;if (n > 2) return 5;}",
"output": "7"
},
{
"input": "1\nint f(int n){if (n < 2) return 1;if (n < 8) return 2;if (n > 8) return 7;if (n > 2) return 5;}",
"output": "1"
},
{
"input": "7\nint f(int n){if (n < 2) return 1;if (n < 8) return 2;if (n > 8) return 7;if (n > 2) return 5;}",
"output": "32767"
},
{
"input": "6\nint f(int n){if (n < 1025) return n*5+12/6-n/3*15-7;return f(n/2)-f(n-7)*f(n-7)-1024;}",
"output": "-1"
},
{
"input": "32763\nint f(int n){if (n < 1025) return n*5+12/6-n/3*15-7;return f(n/2)-f(n-7)*f(n-7)-1024;}",
"output": "1023"
},
{
"input": "280\nint f(int n){if (n < 1025) return n*5+12/6-n/3*15-7;return f(n/2)-f(n-7)*f(n-7)-1024;}",
"output": "32746"
},
{
"input": "1\nint f(int n){return 1;return 2;return 3;return 4;return 5;return 6;return 7;return 8;return 9;}",
"output": "32767"
},
{
"input": "2\nint f(int n){return 1;return 2;return 3;return 4;return 5;return 6;return 7;return 8;return 9;}",
"output": "-1"
},
{
"input": "3647\nint f(int n){return 1*2*3+2*3*4-3*4*5-4*5*6+5*6*7+n*n*n-n/2/4/5+n+1/2+3*9*6-12+17/7*6+1-1;}",
"output": "23117"
},
{
"input": "17463\nint f(int n){return 1*2*3+2*3*4-3*4*5-4*5*6+5*6*7+n*n*n-n/2/4/5+n+1/2+3*9*6-12+17/7*6+1-1;}",
"output": "9167"
},
{
"input": "17\nint f(int n){if (n > 1000) return n/n;if (n > 100) return n/2;if (n > 10) return n; return 7;}",
"output": "17"
},
{
"input": "55\nint f(int n)\n{\nif (n < 2) return 0;if (f(n-1) == f(n-2)) return f(n-2)+1;return f(n-1);\n}",
"output": "111"
},
{
"input": "3\nint f(int n)\n{\nif (n > 5) return 8;\nif (n < 3) return 1;\nreturn f(12/n/n)+1;\n}",
"output": "-1"
},
{
"input": "2\nint f(int n)\n{\nif (n > 5) return 8;\nif (n < 3) return 1;\nreturn f(12/n/n)+1;\n}",
"output": "5"
},
{
"input": "354\nint f(int n)\n{\nif (n < 4) return 1;\nreturn f(n-1)*f(n-2)*f(n-3)*f(n-4)+n;\n}",
"output": "19794"
},
{
"input": "9182\nint f(int n)\n{\nif (n < 4) return 1;\nreturn f(n-1)*f(n-2)*f(n-3)*f(n-4)+n;\n}",
"output": "27142"
},
{
"input": "32767\nint f(int n)\n{\nif (n < 5) return 0-1;if (f(n/2)*f(n-1) < 0) return f(n+28);return 10;\n}",
"output": "4"
},
{
"input": "57\nint f(int n)\n{\nif (n/2*2 == n) return 1;\nif (n/2*2 == n-1) return 0;\nreturn 57;\n}",
"output": "-1"
},
{
"input": "1\nint f(int n)\n{\nif (n/2*2 == n) return 1;\nif (n/2*2 == n-1) return 0;\nreturn 57;\n}",
"output": "32766"
},
{
"input": "15\nint f(int n){if (n > 1) return f(n-2)/f(n-1)+15;if (n == 0) return 0;if (n == 1) return 1;}",
"output": "32767"
}
] | 60 | 52,428,800 | 0 | 57,147 |
794 | Choosing Carrot | [
"games",
"math"
] | null | null | Oleg the bank client and Igor the analyst are arguing again. This time, they want to pick a gift as a present for their friend, ZS the coder. After a long thought, they decided that their friend loves to eat carrots the most and thus they want to pick the best carrot as their present.
There are *n* carrots arranged in a line. The *i*-th carrot from the left has juiciness *a**i*. Oleg thinks ZS loves juicy carrots whereas Igor thinks that he hates juicy carrots. Thus, Oleg would like to maximize the juiciness of the carrot they choose while Igor would like to minimize the juiciness of the carrot they choose.
To settle this issue, they decided to play a game again. Oleg and Igor take turns to play the game. In each turn, a player can choose a carrot from either end of the line, and eat it. The game ends when only one carrot remains. Oleg moves first. The last remaining carrot will be the carrot that they will give their friend, ZS.
Oleg is a sneaky bank client. When Igor goes to a restroom, he performs *k* moves before the start of the game. Each move is the same as above (eat a carrot from either end of the line). After Igor returns, they start the game with Oleg still going first.
Oleg wonders: for each *k* such that 0<=β€<=*k*<=β€<=*n*<=-<=1, what is the juiciness of the carrot they will give to ZS if he makes *k* extra moves beforehand and both players play optimally? | The first line of input contains a single integer *n* (1<=β€<=*n*<=β€<=3Β·105)Β β the total number of carrots.
The next line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a**i*<=β€<=109). Here *a**i* denotes the juiciness of the *i*-th carrot from the left of the line. | Output *n* space-separated integers *x*0,<=*x*1,<=...,<=*x**n*<=-<=1. Here, *x**i* denotes the juiciness of the carrot the friends will present to ZS if *k*<==<=*i*. | [
"4\n1 2 3 5\n",
"5\n1000000000 1000000000 1000000000 1000000000 1\n"
] | [
"3 3 5 5\n",
"1000000000 1000000000 1000000000 1000000000 1000000000\n"
] | For the first example,
When *k*β=β0, one possible optimal game is as follows:
- Oleg eats the carrot with juiciness 1.- Igor eats the carrot with juiciness 5.- Oleg eats the carrot with juiciness 2.- The remaining carrot has juiciness 3.
When *k*β=β1, one possible optimal play is as follows:
- Oleg eats the carrot with juiciness 1 beforehand.- Oleg eats the carrot with juiciness 2.- Igor eats the carrot with juiciness 5.- The remaining carrot has juiciness 3.
When *k*β=β2, one possible optimal play is as follows:
- Oleg eats the carrot with juiciness 1 beforehand.- Oleg eats the carrot with juiciness 2 beforehand.- Oleg eats the carrot with juiciness 3.- The remaining carrot has juiciness 5.
When *k*β=β3, one possible optimal play is as follows:
- Oleg eats the carrot with juiciness 1 beforehand.- Oleg eats the carrot with juiciness 2 beforehand.- Oleg eats the carrot with juiciness 3 beforehand.- The remaining carrot has juiciness 5.
Thus, the answer is 3,β3,β5,β5.
For the second sample, Oleg can always eat the carrot with juiciness 1 since he always moves first. So, the remaining carrot will always have juiciness 1000000000. | [
{
"input": "4\n1 2 3 5",
"output": "3 3 5 5"
},
{
"input": "5\n1000000000 1000000000 1000000000 1000000000 1",
"output": "1000000000 1000000000 1000000000 1000000000 1000000000"
},
{
"input": "4\n1 12 3 5",
"output": "12 3 12 12"
},
{
"input": "5\n1 3 2 2 4",
"output": "2 3 2 4 4"
},
{
"input": "5\n1 2 3 2 1",
"output": "2 3 2 3 3"
},
{
"input": "1\n1941283",
"output": "1941283"
},
{
"input": "3\n2 8 2",
"output": "2 8 8"
},
{
"input": "3\n6 4 6",
"output": "4 6 6"
},
{
"input": "3\n5 8 7",
"output": "7 8 8"
},
{
"input": "40\n2 2 88 88 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 7 7 2 2 2 2 2 2 2 2 2 2 2",
"output": "2 2 2 2 2 2 2 2 2 2 2 2 2 2 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 88 88 88 88 88 88 88 88"
},
{
"input": "10\n1 10 1 1 1 1 1 1 1 1",
"output": "1 1 1 1 1 1 10 1 10 10"
}
] | 202 | 2,048,000 | -1 | 57,238 |
|
403 | Beautiful Pairs of Numbers | [
"combinatorics",
"dp"
] | null | null | The sequence of integer pairs (*a*1,<=*b*1),<=(*a*2,<=*b*2),<=...,<=(*a**k*,<=*b**k*) is beautiful, if the following statements are fulfilled:
- 1<=β€<=*a*1<=β€<=*b*1<=<<=*a*2<=β€<=*b*2<=<<=...<=<<=*a**k*<=β€<=*b**k*<=β€<=*n*, where *n* is a given positive integer; - all numbers *b*1<=-<=*a*1, *b*2<=-<=*a*2, ..., *b**k*<=-<=*a**k* are distinct.
For the given number *n* find the number of beautiful sequences of length *k*. As the answer can be rather large, print the remainder after dividing it by 1000000007 (109<=+<=7). | The first line contains integer *t* (1<=β€<=*t*<=β€<=<=2Β·105) β the number of the test data.
Each of the next *t* lines contains two integers *n* and *k* (1<=β€<=*k*<=β€<=*n*<=β€<=1000). | For each test from the input print the answer to the problem modulo 1000000007 (109<=+<=7). Print the answers to the tests in the order in which the tests are given in the input. | [
"6\n1 1\n2 1\n2 2\n3 1\n3 2\n3 3\n"
] | [
"1\n3\n0\n6\n2\n0\n"
] | In the first test sample there is exactly one beautiful sequence: (1,β1).
In the second test sample, the following sequences are beautiful:
- (1,β1); - (1,β2); - (2,β2).
In the fourth test sample, the following sequences are beautiful:
- (1,β1); - (1,β2); - (1,β3); - (2,β2); - (2,β3); - (3,β3).
In the fifth test sample, the following sequences are beautiful:
- (1,β1),β(2,β3); - (1,β2),β(3,β3).
In the third and sixth samples, there are no beautiful sequences. | [
{
"input": "6\n1 1\n2 1\n2 2\n3 1\n3 2\n3 3",
"output": "1\n3\n0\n6\n2\n0"
}
] | 31 | 0 | 0 | 57,246 |
|
868 | El Toll Caves | [
"math"
] | null | null | The prehistoric caves of El Toll are located in MoiΓ (Barcelona). You have heard that there is a treasure hidden in one of *n* possible spots in the caves. You assume that each of the spots has probability 1<=/<=*n* to contain a treasure.
You cannot get into the caves yourself, so you have constructed a robot that can search the caves for treasure. Each day you can instruct the robot to visit exactly *k* distinct spots in the caves. If none of these spots contain treasure, then the robot will obviously return with empty hands. However, the caves are dark, and the robot may miss the treasure even when visiting the right spot. Formally, if one of the visited spots does contain a treasure, the robot will obtain it with probability 1<=/<=2, otherwise it will return empty. Each time the robot searches the spot with the treasure, his success probability is independent of all previous tries (that is, the probability to miss the treasure after searching the right spot *x* times is 1<=/<=2*x*).
What is the expected number of days it will take to obtain the treasure if you choose optimal scheduling for the robot? Output the answer as a rational number modulo 109<=+<=7. Formally, let the answer be an irreducible fraction *P*<=/<=*Q*, then you have to output . It is guaranteed that *Q* is not divisible by 109<=+<=7. | The first line contains the number of test cases *T* (1<=β€<=*T*<=β€<=1000).
Each of the next *T* lines contains two integers *n* and *k* (1<=β€<=*k*<=β€<=*n*<=β€<=5Β·108). | For each test case output the answer in a separate line. | [
"3\n1 1\n2 1\n3 2\n"
] | [
"2\n500000007\n777777786\n"
] | In the first case the robot will repeatedly search in the only spot. The expected number of days in this case is 2. Note that in spite of the fact that we know the treasure spot from the start, the robot still has to search there until he succesfully recovers the treasure.
In the second case the answer can be shown to be equal to 7β/β2 if we search the two spots alternatively. In the third case the answer is 25β/β9. | [] | 31 | 0 | 0 | 57,355 |
|
277 | Game | [
"games",
"implementation"
] | null | null | Two players play the following game. Initially, the players have a knife and a rectangular sheet of paper, divided into equal square grid cells of unit size. The players make moves in turn, the player who can't make a move loses. In one move, a player can take the knife and cut the paper along any segment of the grid line (not necessarily from border to border). The part of the paper, that touches the knife at least once, is considered cut. There is one limit not to turn the game into an infinite cycle: each move has to cut the paper, that is the knife has to touch the part of the paper that is not cut before.
Obviously, the game ends when the entire sheet is cut into 1<=Γ<=1 blocks. During the game, the pieces of the sheet are not allowed to move. It is also prohibited to cut along the border. The coordinates of the ends of each cut must be integers.
You are given an *n*<=Γ<=*m* piece of paper, somebody has already made *k* cuts there. Your task is to determine who will win if the players start to play on this sheet. You can consider that both players play optimally well. If the first player wins, you also need to find the winning first move. | The first line contains three integers *n*, *m*, *k* (1<=β€<=*n*,<=*m*<=β€<=109,<=0<=β€<=*k*<=β€<=105) β the sizes of the piece of paper and the number of cuts. Then follow *k* lines, each containing 4 integers *xb**i*,<=*yb**i*,<=*xe**i*,<=*ye**i* (0<=β€<=*xb**i*,<=*xe**i*<=β€<=*n*,<=0<=β€<=*yb**i*,<=*ye**i*<=β€<=*m*) β the coordinates of the ends of the existing cuts.
It is guaranteed that each cut has a non-zero length, is either vertical or horizontal and doesn't go along the sheet border.
The cuts may intersect, overlap and even be the same. That is, it is not guaranteed that the cuts were obtained during any correct game. | If the second player wins, print "SECOND". Otherwise, in the first line print "FIRST", and in the second line print any winning move of the first player (the coordinates of the cut ends, follow input format to print them). | [
"2 1 0\n",
"2 2 4\n0 1 2 1\n0 1 2 1\n1 2 1 0\n1 1 1 2\n"
] | [
"FIRST\n1 0 1 1\n",
"SECOND\n"
] | none | [] | 92 | 819,200 | -1 | 57,386 |
|
732 | Sockets | [
"greedy",
"sortings"
] | null | null | The ICM ACPC World Finals is coming! Unfortunately, the organizers of the competition were so busy preparing tasks that totally missed an important technical point β the organization of electricity supplement for all the participants workstations.
There are *n* computers for participants, the *i*-th of which has power equal to positive integer *p**i*. At the same time there are *m* sockets available, the *j*-th of which has power euqal to positive integer *s**j*. It is possible to connect the *i*-th computer to the *j*-th socket if and only if their powers are the same: *p**i*<==<=*s**j*. It is allowed to connect no more than one computer to one socket. Thus, if the powers of all computers and sockets are distinct, then no computer can be connected to any of the sockets.
In order to fix the situation professor Puch Williams urgently ordered a wagon of adaptersΒ β power splitters. Each adapter has one plug and one socket with a voltage divider between them. After plugging an adapter to a socket with power *x*, the power on the adapter's socket becomes equal to , it means that it is equal to the socket's power divided by two with rounding up, for example and .
Each adapter can be used only once. It is possible to connect several adapters in a chain plugging the first to a socket. For example, if two adapters are plugged one after enother to a socket with power 10, it becomes possible to connect one computer with power 3 to this socket.
The organizers should install adapters so that it will be possible to supply with electricity the maximum number of computers *c* at the same time. If there are several possible connection configurations, they want to find the one that uses the minimum number of adapters *u* to connect *c* computers.
Help organizers calculate the maximum number of connected computers *c* and the minimum number of adapters *u* needed for this.
The wagon of adapters contains enough of them to do the task. It is guaranteed that it's possible to connect at least one computer. | The first line contains two integers *n* and *m* (1<=β€<=*n*,<=*m*<=β€<=200<=000)Β β the number of computers and the number of sockets.
The second line contains *n* integers *p*1,<=*p*2,<=...,<=*p**n* (1<=β€<=*p**i*<=β€<=109)Β β the powers of the computers.
The third line contains *m* integers *s*1,<=*s*2,<=...,<=*s**m* (1<=β€<=*s**i*<=β€<=109)Β β the power of the sockets. | In the first line print two numbers *c* and *u*Β β the maximum number of computers which can at the same time be connected to electricity and the minimum number of adapters needed to connect *c* computers.
In the second line print *m* integers *a*1,<=*a*2,<=...,<=*a**m* (0<=β€<=*a**i*<=β€<=109), where *a**i* equals the number of adapters orginizers need to plug into the *i*-th socket. The sum of all *a**i* should be equal to *u*.
In third line print *n* integers *b*1,<=*b*2,<=...,<=*b**n* (0<=β€<=*b**i*<=β€<=*m*), where the *b**j*-th equals the number of the socket which the *j*-th computer should be connected to. *b**j*<==<=0 means that the *j*-th computer should not be connected to any socket. All *b**j* that are different from 0 should be distinct. The power of the *j*-th computer should be equal to the power of the socket *b**j* after plugging in *a**b**j* adapters. The number of non-zero *b**j* should be equal to *c*.
If there are multiple answers, print any of them. | [
"2 2\n1 1\n2 2\n",
"2 1\n2 100\n99\n"
] | [
"2 2\n1 1\n1 2\n",
"1 6\n6\n1 0\n"
] | none | [
{
"input": "2 2\n1 1\n2 2",
"output": "2 2\n1 1\n1 2"
},
{
"input": "2 1\n2 100\n99",
"output": "1 6\n6\n1 0"
},
{
"input": "1 1\n1\n1",
"output": "1 0\n0\n1"
},
{
"input": "2 1\n2 570129\n753393670",
"output": "1 29\n29\n1 0"
},
{
"input": "1 2\n258\n270411237 421787464",
"output": "1 20\n20 0\n1"
},
{
"input": "2 2\n607578 103023\n185480405 843960081",
"output": "1 13\n0 13\n0 2"
},
{
"input": "7 14\n3001266 412 1 6352768 8464826 377123633 47905\n754247265 394532939 770046583 653892313 683423733 954533833 49604822 768323920 915021669 957143548 958842438 215985395 436153649 784873711",
"output": "5 68\n1 0 0 0 0 0 26 8 0 0 0 19 0 14\n8 12 7 0 0 1 14"
},
{
"input": "20 6\n324808990 694282896 520370119 517339237 249359185 819827071 836664188 76139629 244199124 859108203 814663867 990442180 691917477 27941652 77863315 303453003 127803150 902014007 4 9889\n280249976 516845282 648041227 501870516 331037759 269068401",
"output": "2 43\n0 0 16 27 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 3"
},
{
"input": "20 20\n358327 61255 12574 9380 648412 27 60308 161816 959334 3323307 57728 14362672 407549 919521 304966 903649 183517838 137 343976 707862\n385844885 411993472 662795782 682392195 420983806 236452620 212691602 367035675 542587750 793595102 417329702 210900246 286770075 128917988 494041151 229802747 164905921 109491119 981875934 337128745",
"output": "10 116\n0 15 12 0 0 12 6 1 0 0 10 0 21 0 13 4 0 22 0 0\n0 0 2 0 0 18 15 3 0 7 6 16 11 0 0 0 8 13 0 0"
},
{
"input": "12 20\n673751 364358 11 569147 4743 872206 139438 573283 424256 1446 43981 119128\n835584295 255782087 822018911 771649013 621621692 505282732 552293130 993930709 587169173 273568178 123207358 575541287 352014954 690005410 571134122 681872675 757895271 172751211 650124600 393178774",
"output": "4 72\n0 0 0 0 17 0 0 0 0 0 0 0 0 0 12 0 19 24 0 0\n0 0 18 0 5 0 15 0 0 17 0 0"
},
{
"input": "17 19\n2 4 5 2 1 2 3 3 3 4 1 1 2 3 4 2 4\n999999998 999999998 1000000000 1000000000 999999996 999999998 999999999 1000000000 999999999 999999996 999999996 999999998 1000000000 999999997 999999999 999999996 1000000000 999999996 1000000000",
"output": "12 347\n29 29 0 0 28 29 30 0 30 28 28 30 0 29 0 28 0 29 0\n18 5 0 14 12 1 0 0 0 10 7 9 2 0 11 6 16"
},
{
"input": "18 16\n4 4 10 2 8 2 5 2 7 2 1 3 10 8 2 7 1 7\n999999990 999999939 999999987 999999980 999999913 999999934 999999992 999999915 999999985 999999942 999999946 999999931 999999917 999999923 999999929 999999902",
"output": "11 315\n0 29 0 0 27 29 0 28 0 30 30 29 28 29 29 27\n8 13 0 14 16 15 0 12 0 6 10 0 0 5 2 0 11 0"
},
{
"input": "10 20\n92004 532907 4 483 975386 12721 298085 98 407776 82592864\n405840200 505732458 951128293 660742906 376845577 590033550 833632727 9301018 200803969 843977787 841335596 177264092 410815195 696181563 73521741 834528337 107557963 610477119 918083019 214974686",
"output": "7 109\n0 20 0 3 12 0 16 0 0 0 0 0 22 0 0 0 25 11 0 0\n5 0 17 2 0 7 18 13 0 4"
},
{
"input": "2 2\n9 17\n33 36",
"output": "2 3\n1 2\n2 1"
}
] | 2,000 | 1,433,600 | 0 | 57,424 |
|
93 | Lostborn | [
"dp",
"math",
"number theory"
] | E. Lostborn | 2 | 256 | Igor K. very much likes a multiplayer role playing game WineAge II. Who knows, perhaps, that might be the reason for his poor performance at the university. As any person who plays the game, he is interested in equipping his hero with as good weapon and outfit as possible.
One day, as he was reading the game's forum yet again, he discovered a very interesting fact. As it turns out, each weapon in the game is characterised with *k* different numbers: *a*1,<=...,<=*a**k*. They are called hit indicators and according to the game developers' plan they are pairwise coprime.
The damage that is inflicted during a hit depends not only on the weapon's characteristics, but also on the hero's strength parameter. Thus, if the hero's strength equals *n*, than the inflicted damage will be calculated as the number of numbers on the segment , that aren't divisible by any hit indicator *a**i*.
Recently, having fulfilled another quest, Igor K. found a new Lostborn sword. He wants to know how much damage he will inflict upon his enemies if he uses it. | The first line contains two integers: *n* and *k* (1<=β€<=*n*<=β€<=1013, 1<=β€<=*k*<=β€<=100). They are the indicator of Igor K's hero's strength and the number of hit indicators.
The next line contains space-separated *k* integers *a**i* (1<=β€<=*a**i*<=β€<=1000). They are Lostborn sword's hit indicators. The given *k* numbers are pairwise coprime. | Print the single number β the damage that will be inflicted by Igor K.'s hero when he uses his new weapon.
Please, do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specificator. | [
"20 3\n2 3 5\n",
"50 2\n15 8\n"
] | [
"6\n",
"41\n"
] | none | [] | 2,000 | 11,571,200 | 0 | 57,431 |
387 | George and Cards | [
"binary search",
"data structures"
] | null | null | George is a cat, so he loves playing very much.
Vitaly put *n* cards in a row in front of George. Each card has one integer written on it. All cards had distinct numbers written on them. Let's number the cards from the left to the right with integers from 1 to *n*. Then the *i*-th card from the left contains number *p**i* (1<=β€<=*p**i*<=β€<=*n*).
Vitaly wants the row to have exactly *k* cards left. He also wants the *i*-th card from left to have number *b**i* written on it. Vitaly gave a task to George, to get the required sequence of cards using the remove operation *n*<=-<=*k* times.
In one remove operation George can choose *w* (1<=β€<=*w*; *w* is not greater than the current number of cards in the row) contiguous cards (contiguous subsegment of cards). Let's denote the numbers written on these card as *x*1,<=*x*2,<=...,<=*x**w* (from the left to the right). After that, George can remove the card *x**i*, such that *x**i*<=β€<=*x**j* for each *j* (1<=β€<=*j*<=β€<=*w*). After the described operation George gets *w* pieces of sausage.
George wondered: what maximum number of pieces of sausage will he get in total if he reaches his goal and acts optimally well? Help George, find an answer to his question! | The first line contains integers *n* and *k* (1<=β€<=*k*<=β€<=*n*<=β€<=106) β the initial and the final number of cards.
The second line contains *n* distinct space-separated integers *p*1,<=*p*2,<=...,<=*p**n* (1<=β€<=*p**i*<=β€<=*n*) β the initial row of cards.
The third line contains *k* space-separated integers *b*1,<=*b*2,<=...,<=*b**k* β the row of cards that you need to get. It is guaranteed that it's possible to obtain the given row by using the remove operation for *n*<=-<=*k* times. | Print a single integer β the maximum number of pieces of sausage that George can get if he acts optimally well. | [
"3 2\n2 1 3\n1 3\n",
"10 5\n1 2 3 4 5 6 7 8 9 10\n2 4 6 8 10\n"
] | [
"1\n",
"30\n"
] | none | [] | 30 | 0 | 0 | 57,437 |
|
0 | none | [
"none"
] | null | null | Alyona has built *n* towers by putting small cubes some on the top of others. Each cube has size 1<=Γ<=1<=Γ<=1. A tower is a non-zero amount of cubes standing on the top of each other. The towers are next to each other, forming a row.
Sometimes Alyona chooses some segment towers, and put on the top of each tower several cubes. Formally, Alyouna chooses some segment of towers from *l**i* to *r**i* and adds *d**i* cubes on the top of them.
Let the sequence *a*1,<=*a*2,<=...,<=*a**n* be the heights of the towers from left to right. Let's call as a segment of towers *a**l*,<=*a**l*<=+<=1,<=...,<=*a**r* a hill if the following condition holds: there is integer *k* (*l*<=β€<=*k*<=β€<=*r*) such that *a**l*<=<<=*a**l*<=+<=1<=<<=*a**l*<=+<=2<=<<=...<=<<=*a**k*<=><=*a**k*<=+<=1<=><=*a**k*<=+<=2<=><=...<=><=*a**r*.
After each addition of *d**i* cubes on the top of the towers from *l**i* to *r**i*, Alyona wants to know the maximum width among all hills. The width of a hill is the number of towers in it. | The first line contain single integer *n* (1<=β€<=*n*<=β€<=3Β·105)Β β the number of towers.
The second line contain *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a**i*<=β€<=109)Β β the number of cubes in each tower.
The third line contain single integer *m* (1<=β€<=*m*<=β€<=3Β·105)Β β the number of additions.
The next *m* lines contain 3 integers each. The *i*-th of these lines contains integers *l**i*, *r**i* and *d**i* (1<=β€<=*l*<=β€<=*r*<=β€<=*n*, 1<=β€<=*d**i*<=β€<=109), that mean that Alyona puts *d**i* cubes on the tio of each of the towers from *l**i* to *r**i*. | Print *m* lines. In *i*-th line print the maximum width of the hills after the *i*-th addition. | [
"5\n5 5 5 5 5\n3\n1 3 2\n2 2 1\n4 4 1\n"
] | [
"2\n4\n5\n"
] | The first sample is as follows:
After addition of 2 cubes on the top of each towers from the first to the third, the number of cubes in the towers become equal to [7,β7,β7,β5,β5]. The hill with maximum width is [7,β5], thus the maximum width is 2.
After addition of 1 cube on the second tower, the number of cubes in the towers become equal to [7,β8,β7,β5,β5]. The hill with maximum width is now [7,β8,β7,β5], thus the maximum width is 4.
After addition of 1 cube on the fourth tower, the number of cubes in the towers become equal to [7,β8,β7,β6,β5]. The hill with maximum width is now [7,β8,β7,β6,β5], thus the maximum width is 5. | [] | 31 | 0 | 0 | 57,449 |
|
542 | Quest | [
"dp",
"greedy"
] | null | null | Polycarp is making a quest for his friends. He has already made *n* tasks, for each task the boy evaluated how interesting it is as an integer *q**i*, and the time *t**i* in minutes needed to complete the task.
An interesting feature of his quest is: each participant should get the task that is best suited for him, depending on his preferences. The task is chosen based on an interactive quiz that consists of some questions. The player should answer these questions with "yes" or "no". Depending on the answer to the question, the participant either moves to another question or goes to one of the tasks that are in the quest. In other words, the quest is a binary tree, its nodes contain questions and its leaves contain tasks.
We know that answering any of the questions that are asked before getting a task takes exactly one minute from the quest player. Polycarp knows that his friends are busy people and they can't participate in the quest for more than *T* minutes. Polycarp wants to choose some of the *n* tasks he made, invent the corresponding set of questions for them and use them to form an interactive quiz as a binary tree so that no matter how the player answers quiz questions, he spends at most *T* minutes on completing the whole quest (that is, answering all the questions and completing the task). Specifically, the quest can contain zero questions and go straight to the task. Each task can only be used once (i.e., the people who give different answers to questions should get different tasks).
Polycarp wants the total "interest" value of the tasks involved in the quest to be as large as possible. Help him determine the maximum possible total interest value of the task considering that the quest should be completed in *T* minutes at any variant of answering questions. | The first line contains two integers *n* and *T* (1<=β€<=*n*<=β€<=1000, 1<=β€<=*T*<=β€<=100) β the number of tasks made by Polycarp and the maximum time a quest player should fit into.
Next *n* lines contain two integers *t**i*,<=*q**i* (1<=β€<=*t**i*<=β€<=*T*, 1<=β€<=*q**i*<=β€<=1000) each β the time in minutes needed to complete the *i*-th task and its interest value. | Print a single integer β the maximum possible total interest value of all the tasks in the quest. | [
"5 5\n1 1\n1 1\n2 2\n3 3\n4 4\n",
"5 5\n4 1\n4 2\n4 3\n4 4\n4 5\n",
"2 2\n1 1\n2 10\n"
] | [
"11\n",
"9\n",
"10\n"
] | In the first sample test all the five tasks can be complemented with four questions and joined into one quest.
In the second sample test it is impossible to use all the five tasks, but you can take two of them, the most interesting ones.
In the third sample test the optimal strategy is to include only the second task into the quest.
Here is the picture that illustrates the answers to the sample tests. The blue circles represent the questions, the two arrows that go from every circle represent where a person goes depending on his answer to that question. The tasks are the red ovals. | [
{
"input": "5 5\n1 1\n1 1\n2 2\n3 3\n4 4",
"output": "11"
},
{
"input": "5 5\n4 1\n4 2\n4 3\n4 4\n4 5",
"output": "9"
},
{
"input": "2 2\n1 1\n2 10",
"output": "10"
},
{
"input": "10 1\n1 732\n1 649\n1 821\n1 756\n1 377\n1 216\n1 733\n1 420\n1 857\n1 193",
"output": "857"
},
{
"input": "26 5\n2 377\n3 103\n1 547\n2 700\n3 616\n5 363\n2 316\n5 260\n3 385\n2 460\n4 206\n4 201\n3 236\n1 207\n1 400\n2 382\n2 365\n1 633\n1 775\n4 880\n1 808\n1 871\n3 518\n1 805\n3 771\n3 598",
"output": "6977"
},
{
"input": "42 4\n1 897\n2 883\n1 766\n1 169\n3 671\n3 751\n2 204\n2 550\n3 873\n2 348\n2 286\n1 413\n1 551\n4 821\n2 573\n1 423\n4 59\n3 881\n2 450\n1 206\n3 181\n3 218\n3 870\n2 906\n1 695\n1 162\n3 370\n3 580\n2 874\n2 864\n3 47\n3 126\n2 494\n4 21\n3 791\n4 520\n4 917\n2 244\n4 74\n3 348\n4 416\n3 581",
"output": "4698"
},
{
"input": "70 4\n1 83\n3 923\n2 627\n4 765\n3 74\n4 797\n4 459\n2 682\n1 840\n2 414\n4 797\n3 832\n3 203\n2 939\n4 694\n1 157\n3 544\n1 169\n3 100\n4 69\n1 851\n3 605\n4 562\n1 718\n3 74\n3 740\n2 655\n2 804\n2 218\n4 186\n4 999\n3 989\n2 407\n4 702\n2 15\n1 509\n4 376\n4 260\n1 533\n2 514\n3 520\n4 737\n2 877\n2 383\n1 556\n3 745\n2 659\n2 636\n2 443\n4 819\n2 382\n4 660\n1 376\n2 410\n3 379\n4 996\n3 944\n4 949\n2 485\n3 434\n3 786\n3 367\n4 403\n3 330\n3 625\n2 302\n3 673\n3 794\n3 411\n1 256",
"output": "4946"
},
{
"input": "17 1\n1 632\n1 996\n1 665\n1 432\n1 565\n1 350\n1 857\n1 183\n1 982\n1 910\n1 938\n1 155\n1 176\n1 168\n1 419\n1 814\n1 487",
"output": "996"
},
{
"input": "10 9\n1 518\n3 971\n5 862\n2 71\n8 138\n4 121\n6 967\n1 518\n9 754\n7 607",
"output": "4773"
},
{
"input": "1 2\n1 1",
"output": "1"
}
] | 202 | 1,843,200 | 3 | 57,454 |
|
234 | Champions' League | [
"implementation"
] | null | null | In the autumn of this year, two Russian teams came into the group stage of the most prestigious football club competition in the world β the UEFA Champions League. Now, these teams have already started to play in the group stage and are fighting for advancing to the playoffs. In this problem we are interested in the draw stage, the process of sorting teams into groups.
The process of the draw goes as follows (the rules that are described in this problem, are somehow simplified compared to the real life). Suppose *n* teams will take part in the group stage (*n* is divisible by four). The teams should be divided into groups of four. Let's denote the number of groups as *m* (). Each team has a rating β an integer characterizing the team's previous achievements. The teams are sorted by the rating's decreasing (no two teams have the same rating).
After that four "baskets" are formed, each of which will contain *m* teams: the first *m* teams with the highest rating go to the first basket, the following *m* teams go to the second one, and so on.
Then the following procedure repeats *m*<=-<=1 times. A team is randomly taken from each basket, first from the first basket, then from the second, then from the third, and at last, from the fourth. The taken teams form another group. After that, they are removed from their baskets.
The four teams remaining in the baskets after (*m*<=-<=1) such procedures are performed, form the last group.
In the real draw the random selection of teams from the basket is performed by people β as a rule, the well-known players of the past. As we have none, we will use a random number generator, which is constructed as follows. Its parameters are four positive integers *x*,<=*a*,<=*b*,<=*c*. Every time there is a call to the random number generator, it produces the following actions:
- calculates ; - replaces parameter *x* by value *y* (assigns ); - returns *x* as another random number.
Operation means taking the remainder after division: , .
A random number generator will be used in the draw as follows: each time we need to randomly choose a team from the basket, it will generate a random number *k*. The teams that yet remain in the basket are considered numbered with consecutive integers from 0 to *s*<=-<=1, in the order of decreasing rating, where *s* is the current size of the basket. Then a team number is taken from the basket.
Given a list of teams and the parameters of the random number generator, determine the result of the draw. | The first input line contains integer *n* (4<=β€<=*n*<=β€<=64, *n* is divisible by four) β the number of teams that take part in the sorting. The second line contains four space-separated integers *x*,<=*a*,<=*b*,<=*c* (1<=β€<=*x*,<=*a*,<=*b*,<=*c*<=β€<=1000) β the parameters of the random number generator. Each of the following *n* lines describes one team. The description consists of the name of the team and its rating, separated by a single space. The name of a team consists of uppercase and lowercase English letters and has length from 1 to 20 characters. A team's rating is an integer from 0 to 1000. All teams' names are distinct. All team's ratings are also distinct. | Print the way the teams must be sorted into groups. Print the groups in the order, in which they are formed in the sorting. Number the groups by consecutive uppercase English letters, starting from letter 'A'. Inside each group print the teams' names one per line, in the order of decreasing of the teams' rating. See samples for a better understanding of the output format. | [
"8\n1 3 1 7\nBarcelona 158\nMilan 90\nSpartak 46\nAnderlecht 48\nCeltic 32\nBenfica 87\nZenit 79\nMalaga 16\n"
] | [
"Group A:\nBarcelona\nBenfica\nSpartak\nCeltic\nGroup B:\nMilan\nZenit\nAnderlecht\nMalaga\n"
] | In the given sample the random number generator will be executed four times:
- <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/2d76d911e7446d6db4b0be2679ce6e5ab930ab92.png" style="max-width: 100.0%;max-height: 100.0%;"/>, - <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/cc339c0d810046d7adb9ef4339e48f5554842ae2.png" style="max-width: 100.0%;max-height: 100.0%;"/>, - <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/74fb01e5b91f6c73ead806139c45f3e73fa1232d.png" style="max-width: 100.0%;max-height: 100.0%;"/>, - <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/f8a9ac4805dfae22b7d7a65c5daa8f4cc5a21a5a.png" style="max-width: 100.0%;max-height: 100.0%;"/>. | [
{
"input": "8\n1 3 1 7\nBarcelona 158\nMilan 90\nSpartak 46\nAnderlecht 48\nCeltic 32\nBenfica 87\nZenit 79\nMalaga 16",
"output": "Group A:\nBarcelona\nBenfica\nSpartak\nCeltic\nGroup B:\nMilan\nZenit\nAnderlecht\nMalaga"
},
{
"input": "4\n777 556 763 235\nkRnl 221\nSnxtrev 981\nBAaxtAFAyfYKea 390\nfFZFDYLJSweUcSTo 786",
"output": "Group A:\nSnxtrev\nfFZFDYLJSweUcSTo\nBAaxtAFAyfYKea\nkRnl"
},
{
"input": "8\n901 45 13 488\nOsIigEKvzr 17\nigyDhJRjjWEKyCcj 636\nEWy 744\njEvkGATY 856\nXoAReWWsizfhgghKVwce 48\nQJhC 313\ntVhGMnuNsuHGxgIwWBne 776\nVaz 538",
"output": "Group A:\njEvkGATY\nigyDhJRjjWEKyCcj\nVaz\nOsIigEKvzr\nGroup B:\ntVhGMnuNsuHGxgIwWBne\nEWy\nQJhC\nXoAReWWsizfhgghKVwce"
},
{
"input": "12\n833 327 250 132\nYEyarZRB 885\nfrmHdNAlQeIHfZKRtv 497\nuoLLUlvcfYwTdv 925\necAWANMtesQ 699\ntoiWq 780\npODVFJNsXR 907\ndIsuoewbQ 513\nggFwjKDhKEszcOdK 321\nX 809\nVlVvIMBsyjjWjVCIn 670\nHFGTWMutbl 539\nkwXVz 415",
"output": "Group A:\npODVFJNsXR\ntoiWq\nHFGTWMutbl\nkwXVz\nGroup B:\nYEyarZRB\necAWANMtesQ\ndIsuoewbQ\nggFwjKDhKEszcOdK\nGroup C:\nuoLLUlvcfYwTdv\nX\nVlVvIMBsyjjWjVCIn\nfrmHdNAlQeIHfZKRtv"
},
{
"input": "16\n957 624 660 738\nBHTXvn 379\nBzAcZuVA 3\nsadCjjoxTbLK 367\nHPb 319\nzMXuyAKOOwPASEBPgdHT 266\nsOxtRopt 782\nMcusDFgpzhV 13\nEaEQYJeFNxURmNCxj 570\nwHlWHmGdIQTFhT 942\nSsoam 656\nibcNogJowwwzYnpOqvj 869\nJRgUxqAAS 385\nKXUjcPfXlkCk 136\nBaKvykbVHvJfuMG 479\nBhp 987\nTZijlaAWwsxjI 178",
"output": "Group A:\nBhp\nBaKvykbVHvJfuMG\nBHTXvn\nTZijlaAWwsxjI\nGroup B:\nwHlWHmGdIQTFhT\nSsoam\nsadCjjoxTbLK\nKXUjcPfXlkCk\nGroup C:\nibcNogJowwwzYnpOqvj\nEaEQYJeFNxURmNCxj\nHPb\nMcusDFgpzhV\nGroup D:\nsOxtRopt\nJRgUxqAAS\nzMXuyAKOOwPASEBPgdHT\nBzAcZuVA"
},
{
"input": "20\n929 489 330 104\njaUAdJjoPuWR 149\nSaiwZbt 672\nLzPkR 262\nxgsswZE 260\ntZLUuTFIaUGJfLBgegXv 769\nk 575\ngurQeJEUDM 422\nfZZMVLHtskwDIDUUDn 67\nsfedSxoMi 730\ny 476\nyIx 938\nqJhgtmSMxMuTDMv 28\ncHrOJkHWloIHKrpSAFW 4\nTKfplTy 217\ndDoZxJCVtcnxUBMn 193\ntGvpsqcR 477\nBJdqXFwKggEXBpGtDklL 287\niwj 981\nrYktOUnAteluBUa 438\nfx 835",
"output": "Group A:\nfx\ny\nBJdqXFwKggEXBpGtDklL\nfZZMVLHtskwDIDUUDn\nGroup B:\nsfedSxoMi\nk\nTKfplTy\njaUAdJjoPuWR\nGroup C:\niwj\ntGvpsqcR\nLzPkR\nqJhgtmSMxMuTDMv\nGroup D:\ntZLUuTFIaUGJfLBgegXv\nrYktOUnAteluBUa\nxgsswZE\ncHrOJkHWloIHKrpSAFW\nGroup E:\nyIx\nSaiwZbt\ngurQeJEUDM\ndDoZxJCVtcnxUBMn"
},
{
"input": "24\n245 331 580 709\nNdpxiALpbR 946\nUOKNn 450\nLq 282\nWTIH 172\nwzMnNFkgi 979\nOBlbpApXwYw 33\nVpAfFWZMMn 298\nhSbPXcDUffQmdNrAKFX 835\nv 184\nMa 299\nyDKclUeu 29\nTKzQWh 146\noDVRDmzJSEQXB 0\nlzIHcLMzbNfdWlR 207\npPfD 169\nWqbFRRZHyLUlA 276\nAYVDqvLH 958\nJQwr 467\noQNIQxzJINuwZyTGCFGL 378\nCZFxlngUOUxGO 203\nbQJOJTiixquoU 525\nAAlBCcXNRaRDr 730\nprTwSjtFg 680\nrIotvgzFJEcvHzmtlpC 448",
"output": "Group A:\nNdpxiALpbR\nbQJOJTiixquoU\nv\nWTIH\nGroup B:\nhSbPXcDUffQmdNrAKFX\nJQwr\nVpAfFWZMMn\npPfD\nGroup C:\nwzMnNFkgi\nUOKNn\nLq\nTKzQWh\nGroup D:\nprTwSjtFg\nMa\nlzIHcLMzbNfdWlR\noDVRDmzJSEQXB\nGroup E:\nAAlBCcXNRaRDr\noQNIQxzJINuwZyTGCFGL\nCZFxlngUOUxGO\nOBlbpApXwYw\nGroup F:\nAYVDqvLH\nrIotvgzFJEcvHzmtlpC\nWqbFRRZHyLUlA\nyDKclUeu"
},
{
"input": "28\n369 628 181 611\nPELvmOnSLLhesHZC 51\nHDB 70\njtXgxW 250\nRIGDkRnJ 689\nSGFjYUhBNQkD 336\nzFQPC 575\nJDRfwVwySlEBrHvthaWf 455\ntHfoSxGFay 740\nrSatVkzNbNcsZ 830\nmgTfx 486\nPqayqVapVt 683\nPIevReLuzAWIRYYALpVG 162\nECGBbtoYZmZvz 552\nD 672\nnqipiMngIxjeinnoNn 93\nWPRoCcsqdvegzgBpnTZl 666\nOW 407\nTcPRRmbIeLXJgLQJPM 724\nC 685\niEhJ 624\nkhPOtf 791\nTclkBL 381\nDxzZnInMdfPlwoHOJfV 204\nzJhuFtIw 438\nOBSf 153\nnwUKNKkclwFj 557\nJBPEYzuBfwEp 447\nFdFbBjdsbKzZeWHjCy 778",
"output": "Group A:\nkhPOtf\nnwUKNKkclwFj\nTclkBL\nHDB\nGroup B:\nFdFbBjdsbKzZeWHjCy\nECGBbtoYZmZvz\nJBPEYzuBfwEp\njtXgxW\nGroup C:\ntHfoSxGFay\nD\nSGFjYUhBNQkD\nnqipiMngIxjeinnoNn\nGroup D:\nrSatVkzNbNcsZ\nPqayqVapVt\nzJhuFtIw\nOBSf\nGroup E:\nTcPRRmbIeLXJgLQJPM\nzFQPC\nOW\nDxzZnInMdfPlwoHOJfV\nGroup F:\nC\nWPRoCcsqdvegzgBpnTZl\nJDRfwVwySlEBrHvthaWf\nPELvmOnSLLhesHZC\nGroup G:\nRIGDkRnJ\niEhJ\nmgTfx\nPIevReLuzAWIRYYALpVG"
},
{
"input": "16\n739 738 264 596\nvw 694\neNvZdEJEUOzGyiWqtuJ 10\nT 470\nJhSpNappmqvI 264\nNuKYfB 480\nn 520\nxWye 815\nTNdotJCqHXxGRQAlrbwr 556\njv 539\nEJFHyutiNO 20\nwQYqbzyWPD 706\nMzw 18\nmBdS 47\npagRISHOTNRo 330\nZhVxdSlqKIW 137\nOk 897",
"output": "Group A:\nwQYqbzyWPD\nTNdotJCqHXxGRQAlrbwr\nT\nmBdS\nGroup B:\nOk\nn\nZhVxdSlqKIW\nEJFHyutiNO\nGroup C:\nxWye\njv\npagRISHOTNRo\nMzw\nGroup D:\nvw\nNuKYfB\nJhSpNappmqvI\neNvZdEJEUOzGyiWqtuJ"
},
{
"input": "32\n463 944 341 922\nSkD 891\nTy 529\nzRWUwZYHXZUaAcKyXxGy 485\njlygkhQxpItR 978\nBdGtZAZoHIRTkjHH 807\nxd 722\nbqT 265\nHAiWsxbo 961\nreLvvwlxCS 542\nctTAITlVWIufKURyPA 253\nq 285\ndeGVnCRQnTG 762\ndFc 671\ngAqAFVHHkjnm 353\nRtbFinNtuzLh 4\nWjyAbYxPPxofPlzEO 555\neyx 63\nCQW 373\nhQv 130\nEk 662\nKyXGZRM 206\nDsM 783\noVuzRacsULBlfh 49\nOrPNeoeugzjhO 115\nuDhnVdYYgxrPtF 928\nuCerPWMN 423\nDaAeJseMVvlHB 401\nIPRdFWWgEUh 1\nECNR 721\nJmxTxVabmLaJHMFN 767\ngkxfB 34\nXrLaVSSxPPSNoG 118",
"output": "Group A:\nHAiWsxbo\nECNR\ngAqAFVHHkjnm\ngkxfB\nGroup B:\nJmxTxVabmLaJHMFN\nTy\nbqT\neyx\nGroup C:\ndeGVnCRQnTG\ndFc\nKyXGZRM\nXrLaVSSxPPSNoG\nGroup D:\nBdGtZAZoHIRTkjHH\nreLvvwlxCS\nDaAeJseMVvlHB\nIPRdFWWgEUh\nGroup E:\nDsM\nzRWUwZYHXZUaAcKyXxGy\nctTAITlVWIufKURyPA\nRtbFinNtuzLh\nGroup F:\njlygkhQxpItR\nWjyAbYxPPxofPlzEO\nuCerPWMN\nhQv\nGroup G:\nSkD\nEk\nq\noVuzRacsULBlfh\nGroup H:\nuDhnVdYYgxrPtF\nxd\nCQW\nOrPNeoeugzjhO"
},
{
"input": "32\n840 703 928 114\nTFyKEAkwucqjJssFDgca 883\nmR 319\nutVPAbHecnhsgghakRCI 79\nKKeQowcLQfACy 260\ng 403\nMFclszcOAtGfOXYTPwJO 700\neIYgezEW 856\nTzjFdEYivRFoaM 204\no 90\nQEWChTyhACPWfxah 558\nwCIaMVONNze 735\nHd 491\nfy 926\nuMYqbsLqfKJvduGi 585\nYF 866\nUdDqwNnepgKIIhN 673\ni 465\nzsEKzWqNsF 181\nvnmh 250\ney 58\nseNBVZciWvQOJQLbp 85\nlwQWMngAL 531\nzbFIfsqbh 1\npudIOioWuq 582\nWIdfQvsIBYOQ 417\nFpeQyQAdJaLhtKg 606\njLSCNVCsmvhkcqkWDv 92\nXuBspCvd 995\nLwEquKHEGILJ 869\nwrejOz 460\npelu 502\nCRf 671",
"output": "Group A:\nXuBspCvd\npudIOioWuq\nKKeQowcLQfACy\nTzjFdEYivRFoaM\nGroup B:\nTFyKEAkwucqjJssFDgca\nlwQWMngAL\nwrejOz\njLSCNVCsmvhkcqkWDv\nGroup C:\nfy\nQEWChTyhACPWfxah\nWIdfQvsIBYOQ\nzsEKzWqNsF\nGroup D:\nYF\nFpeQyQAdJaLhtKg\nvnmh\nseNBVZciWvQOJQLbp\nGroup E:\nLwEquKHEGILJ\nuMYqbsLqfKJvduGi\nHd\no\nGroup F:\neIYgezEW\nCRf\nmR\nutVPAbHecnhsgghakRCI\nGroup G:\nwCIaMVONNze\nUdDqwNnepgKIIhN\ni\ney\nGroup H:\nMFclszcOAtGfOXYTPwJO\npelu\ng\nzbFIfsqbh"
}
] | 62 | 0 | 0 | 57,563 |
|
53 | Dead Ends | [
"bitmasks",
"dp"
] | E. Dead Ends | 5 | 256 | Life in Bertown has become hard. The city has too many roads and the government spends too much to maintain them. There are *n* junctions and *m* two way roads, at which one can get from each junction to any other one. The mayor wants to close some roads so that the number of roads left totaled to *n*<=-<=1 roads and it were still possible to get from each junction to any other one. Besides, the mayor is concerned with the number of dead ends which are the junctions from which only one road goes. There shouldn't be too many or too few junctions. Having discussed the problem, the mayor and his assistants decided that after the roads are closed, the road map should contain exactly *k* dead ends. Your task is to count the number of different ways of closing the roads at which the following conditions are met:
- There are exactly *n*<=-<=1 roads left. - It is possible to get from each junction to any other one. - There are exactly *k* dead ends on the resulting map.
Two ways are considered different if there is a road that is closed in the first way, and is open in the second one. | The first line contains three integers *n*, *m* and *k* (3<=β€<=*n*<=β€<=10,<=*n*<=-<=1<=β€<=*m*<=β€<=*n*Β·(*n*<=-<=1)<=/<=2,<=2<=β€<=*k*<=β€<=*n*<=-<=1) which represent the number of junctions, roads and dead ends correspondingly. Then follow *m* lines each containing two different integers *v*1 and *v*2 (1<=β€<=*v*1,<=*v*2<=β€<=*n*,<=*v*1<=β <=*v*2) which represent the number of junctions connected by another road. There can be no more than one road between every pair of junctions. The junctions are numbered with integers from 1 to *n*. It is guaranteed that it is possible to get from each junction to any other one along the original roads. | Print a single number β the required number of ways. | [
"3 3 2\n1 2\n2 3\n1 3\n",
"4 6 2\n1 2\n2 3\n3 4\n4 1\n1 3\n2 4\n",
"4 6 3\n1 2\n2 3\n3 4\n4 1\n1 3\n2 4\n"
] | [
"3\n",
"12\n",
"4\n"
] | none | [
{
"input": "3 3 2\n1 2\n2 3\n1 3",
"output": "3"
},
{
"input": "4 6 2\n1 2\n2 3\n3 4\n4 1\n1 3\n2 4",
"output": "12"
},
{
"input": "4 6 3\n1 2\n2 3\n3 4\n4 1\n1 3\n2 4",
"output": "4"
},
{
"input": "5 4 3\n2 1\n5 3\n3 2\n1 4",
"output": "0"
},
{
"input": "5 10 2\n2 4\n1 5\n2 5\n3 5\n4 3\n1 4\n3 1\n5 4\n3 2\n2 1",
"output": "60"
},
{
"input": "6 6 2\n6 3\n5 2\n5 1\n3 5\n6 2\n4 3",
"output": "1"
},
{
"input": "7 7 5\n2 1\n4 2\n7 1\n4 5\n7 6\n2 6\n2 3",
"output": "0"
},
{
"input": "5 5 2\n1 2\n2 3\n3 4\n4 2\n4 5",
"output": "1"
},
{
"input": "9 19 8\n1 9\n3 9\n3 6\n7 1\n3 1\n6 9\n2 9\n5 2\n5 6\n4 1\n8 6\n8 2\n1 6\n3 2\n8 7\n7 5\n6 2\n7 6\n4 2",
"output": "0"
},
{
"input": "10 10 9\n6 4\n2 4\n4 1\n8 1\n1 9\n7 6\n6 8\n5 1\n10 8\n2 3",
"output": "0"
},
{
"input": "10 44 3\n3 10\n1 5\n10 5\n7 10\n4 9\n2 9\n2 10\n8 4\n10 9\n10 8\n5 2\n9 7\n5 3\n10 4\n5 4\n2 6\n1 2\n1 6\n1 8\n4 2\n5 9\n10 1\n7 4\n3 2\n6 9\n3 1\n6 4\n8 9\n3 6\n3 4\n1 7\n2 7\n6 8\n3 8\n1 4\n6 10\n5 7\n7 3\n6 7\n5 6\n2 8\n8 7\n3 9\n1 9",
"output": "13547520"
},
{
"input": "10 21 6\n3 8\n1 10\n3 4\n2 9\n9 8\n7 9\n7 10\n6 5\n7 6\n7 3\n5 7\n10 4\n8 6\n9 5\n6 10\n8 7\n10 8\n2 8\n4 7\n1 9\n2 5",
"output": "3358"
},
{
"input": "10 35 9\n2 3\n6 8\n1 5\n10 9\n5 3\n9 3\n6 9\n5 6\n1 7\n9 7\n8 3\n8 10\n7 5\n8 2\n1 9\n6 7\n6 2\n9 5\n4 2\n7 3\n4 10\n8 5\n6 4\n3 10\n6 3\n10 5\n1 10\n8 1\n9 8\n8 7\n1 3\n7 2\n10 7\n1 6\n9 2",
"output": "0"
},
{
"input": "10 34 3\n3 6\n1 9\n2 1\n2 4\n1 10\n7 3\n1 7\n3 5\n6 1\n10 6\n10 7\n9 2\n5 7\n5 2\n5 4\n10 4\n3 9\n10 2\n6 7\n5 9\n2 6\n1 4\n10 9\n3 10\n7 8\n9 7\n8 9\n6 9\n10 8\n7 4\n8 5\n7 2\n5 6\n4 8",
"output": "948807"
},
{
"input": "10 11 6\n9 8\n8 5\n3 2\n6 9\n1 8\n2 6\n10 4\n6 4\n7 2\n6 7\n9 3",
"output": "1"
},
{
"input": "10 25 9\n10 8\n9 10\n6 9\n8 5\n1 7\n4 7\n5 3\n8 6\n9 2\n10 1\n7 2\n7 10\n3 1\n9 5\n4 10\n7 3\n5 7\n2 5\n6 1\n4 8\n2 4\n8 7\n8 2\n2 6\n5 10",
"output": "0"
},
{
"input": "10 39 4\n5 7\n5 9\n10 1\n4 8\n5 8\n8 1\n6 8\n3 7\n9 7\n8 3\n10 2\n1 9\n1 3\n4 9\n6 9\n2 7\n1 7\n7 4\n6 5\n6 7\n4 5\n5 2\n2 1\n10 5\n3 10\n3 5\n1 4\n2 3\n9 3\n4 2\n9 2\n10 6\n9 10\n10 4\n6 4\n9 8\n2 6\n1 5\n4 3",
"output": "9552530"
},
{
"input": "10 39 7\n3 1\n4 6\n1 7\n3 4\n6 1\n3 9\n7 5\n1 9\n2 8\n4 2\n5 3\n3 10\n2 1\n9 2\n1 8\n7 8\n4 10\n7 6\n8 10\n5 6\n5 4\n6 9\n3 6\n7 3\n4 1\n6 10\n10 9\n6 2\n9 4\n9 7\n5 9\n5 2\n2 7\n8 3\n8 5\n8 6\n7 4\n3 2\n8 4",
"output": "177142"
},
{
"input": "10 16 9\n1 5\n10 5\n3 1\n2 9\n8 1\n4 2\n7 9\n4 8\n7 4\n1 7\n2 6\n6 10\n7 2\n8 3\n1 6\n2 3",
"output": "0"
},
{
"input": "10 34 8\n10 3\n9 3\n8 1\n3 7\n2 5\n9 1\n5 10\n2 3\n8 4\n2 10\n5 4\n5 8\n4 9\n5 3\n9 10\n2 4\n4 10\n2 9\n9 5\n3 8\n1 4\n7 6\n7 2\n6 5\n6 9\n7 8\n1 3\n4 6\n3 6\n10 8\n1 6\n1 7\n5 7\n2 1",
"output": "448"
},
{
"input": "8 9 4\n7 3\n8 6\n7 2\n2 8\n5 2\n4 1\n6 7\n1 8\n3 5",
"output": "3"
},
{
"input": "10 45 9\n10 3\n1 7\n9 1\n1 10\n4 1\n3 7\n4 2\n10 8\n10 6\n8 7\n8 4\n8 2\n6 7\n10 2\n1 8\n5 8\n3 6\n6 4\n9 5\n9 8\n2 5\n2 1\n5 4\n6 9\n4 9\n3 1\n3 9\n5 1\n4 7\n7 10\n2 3\n9 2\n4 3\n4 10\n8 3\n5 10\n9 7\n6 5\n3 5\n8 6\n6 1\n2 6\n10 9\n5 7\n2 7",
"output": "10"
},
{
"input": "10 45 8\n7 2\n3 7\n4 8\n1 8\n9 6\n7 6\n10 7\n6 3\n2 8\n6 2\n4 10\n9 2\n10 3\n6 1\n8 9\n5 2\n4 5\n5 1\n4 1\n6 10\n10 9\n3 5\n7 5\n6 5\n10 8\n4 2\n9 5\n2 3\n4 6\n4 9\n7 9\n1 10\n2 10\n1 2\n8 6\n3 8\n4 3\n9 1\n5 10\n9 3\n7 4\n7 1\n8 7\n3 1\n5 8",
"output": "11430"
},
{
"input": "10 45 7\n1 10\n8 6\n7 6\n10 9\n2 6\n6 4\n7 1\n8 7\n3 8\n2 3\n4 10\n4 9\n10 7\n10 5\n5 2\n2 4\n3 1\n4 3\n6 9\n3 7\n7 4\n2 8\n6 1\n10 3\n8 10\n7 5\n4 8\n4 5\n3 5\n9 2\n7 2\n10 2\n5 8\n6 10\n8 1\n6 5\n1 4\n5 9\n9 7\n1 2\n9 3\n1 5\n6 3\n9 1\n8 9",
"output": "695520"
},
{
"input": "10 45 6\n6 2\n2 10\n4 8\n3 5\n7 10\n2 9\n8 3\n5 9\n7 9\n7 6\n5 10\n1 3\n1 6\n5 4\n3 4\n7 8\n8 6\n2 4\n1 4\n1 8\n10 3\n5 6\n1 9\n3 2\n10 9\n3 7\n10 1\n1 5\n2 7\n2 5\n9 4\n3 6\n7 4\n8 5\n10 6\n9 6\n3 9\n5 7\n10 4\n8 10\n6 4\n7 1\n2 8\n9 8\n2 1",
"output": "8573040"
},
{
"input": "10 45 5\n2 5\n6 8\n7 5\n6 9\n5 9\n5 3\n10 6\n1 9\n10 7\n3 10\n1 2\n4 8\n9 10\n2 8\n2 6\n4 2\n7 6\n1 8\n7 2\n2 10\n8 5\n8 3\n4 1\n1 10\n4 10\n4 6\n3 1\n4 7\n5 4\n7 8\n7 3\n10 5\n6 1\n9 7\n3 6\n1 5\n2 9\n9 3\n3 4\n9 8\n7 1\n4 9\n10 8\n6 5\n3 2",
"output": "31752000"
},
{
"input": "10 45 4\n8 6\n10 2\n9 5\n1 7\n8 7\n7 10\n2 5\n5 10\n10 1\n1 8\n4 1\n10 9\n6 9\n3 7\n10 4\n5 6\n1 5\n4 7\n7 9\n10 3\n4 3\n6 4\n2 1\n5 3\n10 6\n1 9\n8 2\n3 8\n6 3\n8 5\n3 9\n4 2\n7 5\n2 9\n4 5\n2 7\n2 6\n6 7\n8 4\n8 10\n3 2\n4 9\n9 8\n6 1\n3 1",
"output": "40219200"
},
{
"input": "10 45 3\n8 5\n10 7\n6 8\n10 8\n5 4\n9 2\n8 3\n1 8\n8 7\n1 6\n4 7\n9 1\n10 6\n4 8\n7 1\n1 2\n3 6\n2 6\n9 10\n2 8\n10 5\n6 9\n2 7\n7 5\n4 6\n1 3\n5 2\n4 3\n9 7\n4 9\n6 5\n1 10\n5 1\n2 3\n10 3\n4 10\n1 4\n9 5\n9 8\n7 6\n2 4\n2 10\n3 5\n9 3\n7 3",
"output": "16934400"
},
{
"input": "10 45 2\n7 3\n3 2\n8 6\n6 10\n7 6\n2 7\n4 3\n6 5\n2 9\n10 2\n6 1\n5 1\n8 1\n3 1\n4 7\n3 6\n1 10\n9 10\n5 7\n1 2\n9 4\n4 1\n5 3\n1 9\n10 3\n8 3\n7 9\n9 8\n4 2\n5 9\n10 7\n6 9\n2 8\n2 6\n8 4\n5 2\n7 8\n8 10\n8 5\n5 4\n4 10\n3 9\n1 7\n5 10\n4 6",
"output": "1814400"
},
{
"input": "10 44 5\n8 4\n3 8\n1 3\n2 6\n7 4\n7 1\n4 6\n7 2\n3 7\n4 10\n3 10\n10 1\n2 3\n5 7\n5 8\n8 2\n9 5\n3 9\n5 3\n8 1\n4 5\n2 4\n1 6\n10 7\n9 1\n6 8\n8 10\n10 5\n9 10\n9 8\n1 4\n6 10\n8 7\n3 6\n4 3\n9 6\n7 6\n9 7\n1 2\n2 10\n1 5\n2 5\n4 9\n2 9",
"output": "25401600"
},
{
"input": "10 43 9\n7 1\n4 5\n8 3\n5 1\n2 5\n9 2\n8 4\n8 2\n5 8\n4 2\n9 8\n7 10\n10 2\n4 7\n9 5\n2 3\n8 6\n10 5\n6 4\n3 5\n8 1\n3 1\n3 7\n6 9\n4 10\n9 7\n6 3\n7 5\n3 4\n9 10\n7 2\n4 1\n7 8\n1 10\n3 9\n10 6\n10 3\n6 7\n6 1\n1 2\n1 9\n5 6\n6 2",
"output": "6"
},
{
"input": "10 42 5\n1 3\n10 2\n1 7\n5 8\n6 7\n3 5\n3 2\n10 5\n8 1\n3 9\n6 3\n8 4\n6 9\n1 4\n9 2\n8 3\n6 5\n2 4\n7 9\n4 6\n8 10\n1 2\n3 10\n7 2\n5 4\n1 10\n6 2\n2 8\n4 3\n6 1\n4 9\n2 5\n10 4\n10 6\n8 7\n9 5\n9 10\n5 1\n10 7\n8 6\n7 5\n8 9",
"output": "15986880"
}
] | 60 | 0 | 0 | 57,612 |
195 | Analyzing Polyline | [
"geometry",
"math",
"sortings"
] | null | null | As Valeric and Valerko were watching one of the last Euro Championship games in a sports bar, they broke a mug. Of course, the guys paid for it but the barman said that he will let them watch football in his bar only if they help his son complete a programming task. The task goes like that.
Let's consider a set of functions of the following form:
Valeric and Valerko really want to watch the next Euro Championship game, so they asked you to help them. | The first line contains integer *n* (1<=β€<=*n*<=β€<=105) β the number of functions. Each of the following *n* lines contains two space-separated integer numbers *k**i*,<=*b**i* (<=-<=109<=β€<=*k**i*,<=*b**i*<=β€<=109) that determine the *i*-th function. | Print a single number β the number of angles that do not equal 180 degrees in the graph of the polyline that equals the sum of the given functions. | [
"1\n1 0\n",
"3\n1 0\n0 2\n-1 1\n",
"3\n-2 -4\n1 7\n-5 1\n"
] | [
"1\n",
"2\n",
"3\n"
] | none | [
{
"input": "1\n1 0",
"output": "1"
},
{
"input": "3\n1 0\n0 2\n-1 1",
"output": "2"
},
{
"input": "3\n-2 -4\n1 7\n-5 1",
"output": "3"
},
{
"input": "10\n9 9\n-5 2\n-2 9\n0 6\n6 7\n-1 -10\n-8 6\n3 6\n-3 -9\n0 4",
"output": "8"
},
{
"input": "10\n-4 -9\n5 9\n-4 -1\n6 -1\n-10 -10\n3 4\n3 5\n3 10\n9 7\n4 -7",
"output": "10"
},
{
"input": "5\n3 3\n2 2\n2 -3\n-3 3\n-1 1",
"output": "3"
},
{
"input": "4\n0 2\n-1 -2\n1 0\n-2 2",
"output": "3"
},
{
"input": "10\n-1 2\n0 1\n-2 0\n1 1\n-1 -1\n-2 1\n-2 2\n2 -1\n0 -1\n-1 0",
"output": "5"
},
{
"input": "15\n0 3\n-1 -3\n0 -2\n1 3\n1 0\n1 3\n0 3\n-2 -1\n2 -1\n-3 -2\n-1 -1\n2 -3\n-1 3\n3 -3\n0 1",
"output": "9"
},
{
"input": "10\n32 -84\n-24 -21\n-4 26\n67 -34\n22 50\n-15 20\n3 -39\n-86 62\n56 -81\n34 -91",
"output": "10"
},
{
"input": "2\n0 5\n0 -5",
"output": "0"
},
{
"input": "3\n1 1000000000\n1 1000000000\n1 1000000000",
"output": "1"
},
{
"input": "4\n1000000000 -1000000000\n-1000000000 1000000000\n-200000000 200000000\n200000000 -200000000",
"output": "1"
},
{
"input": "1\n3 5",
"output": "1"
},
{
"input": "1\n1 1",
"output": "1"
},
{
"input": "2\n1 1000000000\n-1 1000000000",
"output": "2"
},
{
"input": "5\n79 49\n72 40\n-5 0\n-70 26\n-98 23",
"output": "5"
},
{
"input": "10\n148 134\n145 140\n105 144\n196 199\n195 166\n110 175\n140 198\n112 188\n147 145\n153 196",
"output": "10"
},
{
"input": "6\n1000000000 1\n-1000000000 -1\n999999999 1\n-999999999 -1\n7 22\n318181815 999999990",
"output": "3"
},
{
"input": "5\n1000000000 1000000000\n1000000000 1000000000\n1000000000 1000000000\n1000000000 1000000000\n294967296 294967296",
"output": "1"
}
] | 1,652 | 13,312,000 | 0 | 57,662 |
|
784 | Touchy-Feely Palindromes | [
"*special",
"implementation"
] | null | null | The only line of the input contains a string of digits. The length of the string is between 1 and 10, inclusive.
Output "Yes" or "No". | The only line of the input contains a string of digits. The length of the string is between 1 and 10, inclusive. | Output "Yes" or "No". | [
"373\n",
"121\n",
"436\n"
] | [
"Yes\n",
"No\n",
"Yes\n"
] | none | [
{
"input": "373",
"output": "Yes"
},
{
"input": "121",
"output": "No"
},
{
"input": "436",
"output": "Yes"
},
{
"input": "7",
"output": "Yes"
},
{
"input": "8",
"output": "No"
},
{
"input": "4357087936",
"output": "Yes"
},
{
"input": "806975480",
"output": "Yes"
},
{
"input": "3333333333",
"output": "Yes"
},
{
"input": "90785",
"output": "Yes"
},
{
"input": "7467467",
"output": "Yes"
},
{
"input": "64",
"output": "Yes"
},
{
"input": "584609",
"output": "Yes"
},
{
"input": "69154",
"output": "No"
},
{
"input": "363567",
"output": "No"
},
{
"input": "557654",
"output": "No"
},
{
"input": "772961",
"output": "No"
},
{
"input": "788958",
"output": "No"
},
{
"input": "992045",
"output": "No"
},
{
"input": "116325",
"output": "No"
},
{
"input": "320432",
"output": "No"
},
{
"input": "314729",
"output": "No"
},
{
"input": "531816",
"output": "No"
},
{
"input": "673902416",
"output": "No"
},
{
"input": "880089713",
"output": "No"
},
{
"input": "004176110",
"output": "No"
}
] | 62 | 0 | -1 | 57,711 |
|
46 | Parking Lot | [
"data structures",
"implementation"
] | D. Parking Lot | 2 | 256 | Nowadays it is becoming increasingly difficult to park a car in cities successfully. Let's imagine a segment of a street as long as *L* meters along which a parking lot is located. Drivers should park their cars strictly parallel to the pavement on the right side of the street (remember that in the country the authors of the tasks come from the driving is right side!). Every driver when parking wants to leave for themselves some extra space to move their car freely, that's why a driver is looking for a place where the distance between his car and the one behind his will be no less than *b* meters and the distance between his car and the one in front of his will be no less than *f* meters (if there's no car behind then the car can be parked at the parking lot segment edge; the same is true for the case when there're no cars parked in front of the car). Let's introduce an axis of coordinates along the pavement. Let the parking lot begin at point 0 and end at point *L*. The drivers drive in the direction of the coordinates' increasing and look for the earliest place (with the smallest possible coordinate) where they can park the car. In case there's no such place, the driver drives on searching for his perfect peaceful haven. Sometimes some cars leave the street and free some space for parking. Considering that there never are two moving cars on a street at a time write a program that can use the data on the drivers, entering the street hoping to park there and the drivers leaving it, to model the process and determine a parking lot space for each car. | The first line contains three integers *L*, *b* ΠΈ *f* (10<=β€<=*L*<=β€<=100000,<=1<=β€<=*b*,<=*f*<=β€<=100). The second line contains an integer *n* (1<=β€<=*n*<=β€<=100) that indicates the number of requests the program has got. Every request is described on a single line and is given by two numbers. The first number represents the request type. If the request type is equal to 1, then in that case the second number indicates the length of a car (in meters) that enters the street looking for a place to park. And if the request type is equal to 2, then the second number identifies the number of such a request (starting with 1) that the car whose arrival to the parking lot was described by a request with this number, leaves the parking lot. It is guaranteed that that car was parked at the moment the request of the 2 type was made. The lengths of cars are integers from 1 to 1000. | For every request of the 1 type print number -1 on the single line if the corresponding car couldn't find place to park along the street. Otherwise, print a single number equal to the distance between the back of the car in its parked position and the beginning of the parking lot zone. | [
"30 1 2\n6\n1 5\n1 4\n1 5\n2 2\n1 5\n1 4\n",
"30 1 1\n6\n1 5\n1 4\n1 5\n2 2\n1 5\n1 4\n",
"10 1 1\n1\n1 12\n"
] | [
"0\n6\n11\n17\n23\n",
"0\n6\n11\n17\n6\n",
"-1\n"
] | none | [
{
"input": "30 1 2\n6\n1 5\n1 4\n1 5\n2 2\n1 5\n1 4",
"output": "0\n6\n11\n17\n23"
},
{
"input": "30 1 1\n6\n1 5\n1 4\n1 5\n2 2\n1 5\n1 4",
"output": "0\n6\n11\n17\n6"
},
{
"input": "10 1 1\n1\n1 12",
"output": "-1"
},
{
"input": "10 1 1\n1\n1 9",
"output": "0"
},
{
"input": "10 1 1\n1\n1 10",
"output": "0"
},
{
"input": "10 1 1\n2\n1 3\n1 6",
"output": "0\n4"
},
{
"input": "10 1 1\n2\n1 3\n1 7",
"output": "0\n-1"
},
{
"input": "10 1 1\n5\n1 1\n1 2\n1 3\n2 2\n1 4",
"output": "0\n2\n5\n-1"
},
{
"input": "10 1 1\n5\n1 4\n2 1\n1 3\n2 3\n1 1",
"output": "0\n0\n0"
},
{
"input": "10 1 1\n5\n1 2\n1 3\n1 1\n1 4\n1 2",
"output": "0\n3\n7\n-1\n-1"
},
{
"input": "20 1 2\n10\n1 3\n1 2\n2 2\n2 1\n1 4\n1 2\n1 2\n2 7\n1 2\n1 1",
"output": "0\n4\n0\n5\n8\n8\n11"
},
{
"input": "20 2 1\n10\n1 5\n1 2\n1 1\n1 1\n1 2\n2 4\n1 3\n1 1\n2 5\n1 5",
"output": "0\n7\n11\n14\n17\n-1\n14\n-1"
},
{
"input": "20 2 2\n10\n1 2\n1 3\n1 3\n1 5\n1 5\n1 1\n1 2\n1 5\n1 5\n1 5",
"output": "0\n4\n9\n14\n-1\n-1\n-1\n-1\n-1\n-1"
},
{
"input": "30 2 1\n10\n1 4\n2 1\n1 1\n1 3\n1 1\n1 1\n1 2\n1 5\n2 4\n2 7",
"output": "0\n0\n3\n8\n11\n14\n18"
},
{
"input": "30 1 2\n10\n1 1\n1 1\n2 1\n1 5\n1 2\n2 4\n1 6\n2 5\n2 2\n2 7",
"output": "0\n2\n4\n10\n13"
},
{
"input": "50 2 3\n15\n1 7\n1 6\n1 1\n2 3\n2 1\n2 2\n1 1\n1 4\n1 6\n1 2\n1 8\n1 6\n2 7\n1 8\n2 9",
"output": "0\n9\n17\n0\n3\n9\n17\n21\n31\n39"
},
{
"input": "50 2 4\n15\n1 4\n1 4\n2 1\n2 2\n1 8\n1 7\n2 5\n1 2\n1 7\n2 8\n1 7\n2 11\n1 3\n2 6\n2 9",
"output": "0\n6\n0\n10\n0\n19\n28\n0"
},
{
"input": "50 3 3\n20\n1 4\n2 1\n1 1\n2 3\n1 1\n2 5\n1 7\n2 7\n1 4\n1 1\n1 10\n1 5\n1 2\n2 9\n2 11\n1 1\n1 9\n2 13\n1 8\n1 1",
"output": "0\n0\n0\n0\n0\n7\n11\n24\n32\n0\n11\n32\n43"
},
{
"input": "50 3 2\n20\n1 6\n1 1\n2 2\n1 2\n1 3\n1 1\n1 2\n2 4\n1 7\n1 1\n2 6\n1 9\n2 12\n2 9\n1 8\n1 6\n1 1\n1 8\n2 15\n1 2",
"output": "0\n9\n9\n14\n20\n24\n29\n9\n39\n29\n40\n20\n-1\n29"
},
{
"input": "50 3 1\n30\n1 9\n2 1\n1 6\n1 5\n1 8\n1 1\n2 6\n1 7\n2 3\n2 8\n1 7\n2 4\n2 5\n2 11\n1 2\n2 15\n1 6\n1 3\n2 17\n1 9\n1 3\n2 18\n1 3\n2 23\n2 21\n1 8\n1 2\n2 27\n1 8\n2 29",
"output": "0\n0\n9\n17\n28\n28\n0\n0\n0\n9\n15\n0\n6\n0\n11\n27"
}
] | 0 | 0 | -1 | 57,754 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.