task stringlengths 0 154k | __index_level_0__ int64 0 39.2k |
|---|---|
Imperial Units (IMPUNITS)
As you may know, there are currently two main sets of measurement units in the world: the metric system and the imperial system. The imperial system receives its name from the British empire, which was the place of its invention and its main user until recently. Nowadays, Britain’s heir, the United States of America, is the only country where a variation of the imperial system is the official measurement system.
For a particular magnitude, in a given measurement system there are N different units U1, U2, ... UN (the number of units depends on both the magnitude and the system). For every i (1 ≤ i ≤ N − 1), a certain number of Ui is equivalent to a certain number of Ui+1. In the metric system we always have that 1Ui is equivalent to 10Ui+1. For instance, 1 decimeter is equivalent to 10 centimeters, 1 gram is equivalent to 10 decigrams, and 1 decaliter is equivalent to 10 liters. On the contrary, in some variations of the imperial system we may have other positive integers instead of 1 and 10. For instance, 32 drams are equivalent to 875 grains.
Since you were born and raised using the much more sensible metric system, you need help learning the imperial system and its variations. You want to be able to transform directly from U1 to UN, that is, you need to know that a certain number of U1 is equivalent to a certain number of UN. To ease further calculations, you want to express the equivalence using only integers values, and these values must be as small as possible.
Input
Each test case is described using several lines. The first line contains an integer N indicating the number of units in the measurement system (2 ≤ N ≤ 10). Line i of the next N − 1 lines describes the relationship between units Ui and Ui+1 with two integers Ai and Bi representing that Ai Ui is equivalent to Bi Ui+1 (1 ≤ Ai < Bi ≤ 100). The end of input is indicated with a line containing a single −1.
Output
For each test case, output a single line with two positive integers C and D representing that CU1 is equivalent to DUN. If there are several alternatives, choose the minimum possible value for C.
Example
Input:
5
1 2
2 3
3 4
2 5
2
6 9
-1
Output:
1 10
2 3 | 32,100 |
Jara’s Legacy (JARA)
Victor Jara was a Chilean teacher, theater director and political activist. He is widely recognized because of his talent as poet and song writer. His most recognized work is probably the song “A Desalambrar” that can be translated from Spanish as “Unwire”. In this song Jara assures that people are the rightful owner of the lands, and so wire fences that delimit private properties should be cut down to allow access to everybody. Although Jara’s proposal is far from being fulfilled, some of his convinced listeners keep trying to make it happen. Since they must face several enemies, they try to make their job efficient by only cutting down the necessary number of fences and not more.
Each fence can be modeled as a segment (straight line) connecting two points in the XY plane. These endpoints are considered to be part of the fence. A cut in a fence removes any contiguous part of the fence except the endpoints. An area is said to be free if and only if, for any pair of points not lying over a fence, there is a (not necessarily straight) line that connect these points without crossing any fence. Given the location of the fences, your job is to calculate the minimum number of fences that need to be cut down to make the area free, according to the above definition.
Input
Each test case is described using several lines. The first line contains an integer N indicating the number of fences in the area (1 ≤ N ≤ 10
5
).
Each of the next N lines describes a different fence using four integers X0, Y0, X1 and Y1 (−10
4
≤ X0, Y0, X1, Y1 ≤ 10
4
). These values represent that there is a fence whose endpoints in the XY plane are (X0, Y0) and (X1, Y1). You may assume that for each fence its two endpoints are distinct. Besides, within each test case, the intersection of any pair of fences is either empty or it is an endpoint of both fences. The end of input is indicated with a line containing a single −1.
Output
For each test case, output a single line containing a single integer representing the minimum number of fences that need to be cut down to make the area free.
Example
Input:
9
-50 0 0 0
0 0 50 0
-50 0 0 50
0 50 50 0
-50 0 0 -50
0 -50 50 0
0 0 0 -50
0 -50 50 -50
50 -50 50 0
2
0 1 2 3
0 0 2 2
-1
Output:
4
0 | 32,101 |
Tower Of Hanoi - Revisited (RANJAN02)
Given 3 three pegs: leftmost peg A, middle peg B and rightmost peg C. Find the shortest sequence of moves that transfers a tower of n disks from the left peg A to the right peg C, if direct moves between A and C are disallowed. (Each move must be to or from the middle peg B.)
Constraints
Initially the left peg A in stacked by n disks in the order of decreasing size.
Only one move can be done at a time and never moving a larger one onto a smaller.
Number of moves will always be less than 2^64.
1 <= n <= 35
Input
Input begins with an integer t, followed by t lines. Each line has the number of disks n.
Output
For each test case, output the minimum number of move required to transfer the n disks from peg A to peg C.
Example
Input:
4
1
2
5
10
Output:
2
8
242
59048 | 32,102 |
Rooks (BIO1)
Aly being one of the smartest guys in his third grade class solved the question "How many ways to assign K cells for rooks in an N*M such that no two rooks are attacking each other" (A rook is a chess piece that can attack other pieces on the same row or the same column) but he was only able to solve it when N*M didn't exceed 10. After some days one of his classmates said he was able to solve it even if N*M reached 100. Aly kept asking how he did it and after questioning a lot of people he knew that he used a program to calculate this for him so he decided to challenge him in front of all his classmates but to do that he also needed a program that not only solve the problem when N*M reaches 100 but when N and M each reach 1,000,000 and he came for you to do that program for him but as he knows that the answer can be really big he wanted the program to output the number of ways modulo 1,000,000,007.
Input
The first and only line of input contains three numbers N, M and K (1 <= N, M <= 1,000,000, 1 <= K <= N*M).
Output
The number of ways required modulo 1,000,000,007.
Example
Input:
4 4 4
Output:
24 | 32,103 |
Flibonakki (FLIB)
G(n) is defined as
G(n) = G(n-1) + f(4n-1) , for n > 0
and G(0) = 0
f(i) is ith Fibonacci number. Given n you need to evaluate G(n) modulo 1000000007.
Input
First line contains number of test cases t (t < 40000). Each of the next t lines contain an integer n (0 <= n < 2^51).
Output
For each test case print G(n) modulo 1000000007.
Example
Input:
2
2
4
Output:
15
714 | 32,104 |
LCM GCD Love (LGLOVE)
Bob fell in love with LCM and GCD. So much that he started seeing LCMs and GCDs everywhere. Betty, his girlfriend was jealous and she gave Bob an array A[ ] of integers, which had nothing to do with LCMs or GCDs.
Quickly, naughty Bob evaluated a new array B[ ] containing n integers, such that B[i] is LCM(1, 2, 3 ... A[i]), A[i]>0. When A[i] is 0, B[i] is also 0.
Angry Betty decided to give m queries to Bob, each being one of the following type:
"0 i j p", meaning add 'p' to each element in A[i...j]. -300000 <= p <= 300000, 0 <= i <= j < n
"1 i j", meaning print the LCM of all elements in B[i...j]. 0 <= i <= j < n
"2 i j", meaning print the GCD of all elements in B[i...j]. 0 <= i <= j < n
Input
First line contains n (n <= 100000) and m (m <= 35000).
Second line contains n integers in the original array A[ ].
Next m lines contain one of the above said queries.
It is guaranteed that A[i] after any number of updates will satisfy 0 <= A[i] <= 300000.
Output
Output one line for each query of type 1 or 2, modulo 1000000007.
Example
Input:
5 5
4 1 3 6 2
1 2 4
2 1 3
0 0 3 2
1 1 2
2 2 4
Output:
60
1
60
2 | 32,105 |
Slow Growing Bacteria (SBACT)
Given an n×n grid of cells, a bacteria colony can colonize these cells. Their growth after every second is governed by the following rules:
One new bacteria is born in cell (i, j) if and only if either one of its four neighboring cells or the cell (i, j) itself has a bacteria population more than or equal to the threshold value, k.
Already living bacteria do not die.
Given, the initial state of the n×n cell grid, you need to accurately estimate the time by when the total bacteria population reaches m.
Input
First line contains t, number of test cases.
Each test case starts with n (side length of grid), k (growth threshold) and m (final population).
Next n lines contain an n×n grid of integers, where ith row, jth column has an integer representing the number of bacteria present initially at cell (i, j).
1< n ≤ 100, 0 < k ≤ 2
45
, 0 < m ≤ 2
45
.
There are no more than n cells with initial population equal to or greater than k.
Output
For each test case print the number of seconds required for the total bacteria population to reach m. If m can never be reached print "Not possible" (quotes for clarity).
Example
Input:
1
3 5 15
0 0 0
0 3 0
0 0 5
Output:
3 | 32,106 |
Biology (BIO)
It was no later than 1869 that Jules Verne succeeded to vulgarize interest in the depths of the oceans through his science-fiction novel “Twenty thousand leagues under the sea”. On board the Nautilus manoeuvred by captain Nemo, the crew visits the lost city of Atlantis and gets to know strangest kinds of sea dwellers.
Nearly a century later, one of the deepest points on Earth, the Challenger Deep was visited by Piccard and Walsh and a Swiss flag was dibbled at 10’924 metres below sea level. The ridership of the Trieste submarine was amazed by the animal life in these depths.
Recently a team of biologists decided to investigate these depths of the Mariana Trench and especially their So Weird Exotic Rare Citizens (SWERC). To this goal a preliminary study was performed, which showed that the species in the Mariana Trench have very local biotopes, which if projected onto the sea surface, can be described by convex polygons. All the biotopes are located at the same depth and some may overlap. The biologists now want to install racks and cameras in each biotope in order to attract and film them. As delicious as the food at the racks might be, no species would ever take the risk to transgress the borders of its habitat. As these cameras and the associated telecommunication system are extremely expensive, their number is to be minimized. Can you tell the biologists for how many cameras they need to account in their budget planning in order not to miss any species if they choose the locations in a clever way? You may consider each camera-rack couple as a mathematical point which must lie
strictly
inside the biotope in order to attract the related species.
INPUT
The input consists of several test-cases separated by an empty line. Each test-case starts with the number of species
S (0<=S<=20)
. Each of the next
S
lines describes one biotope. The first entry indicates the number
n
i
of vertices of the convex polygon. Then follow their coordinates in the order
x1 y1 x2 y2 ... xn
i
yn
i
(|xi|,|yi|<=1000)
. Input terminates on a test-case
with S=0
, which must not be evaluated.
OUTPUT
For each test-case, output the minimum number of camera-rack couples necessary to screen all the species listed in the input.
SAMPLE INPUT
3
3 11.00 0.00 -2.50 7.79 -2.50 -7.79
4 4.00 -3.00 -3.00 4.00 -10.00 -3.00 -3.00 -10.00
4 4.00 2.00 3.00 3.00 2.00 2.00 3.00 1.00
10
7 -317.00 99.00 -330.55 127.15 -361.01 134.10 -385.43 114.62 -385.43 83.38 -361.01 63.90 -330.55 70.85
6 -99.00 93.00 -238.50 334.62 -517.50 334.62 -657.00 93.00 -517.50 -148.62 -238.50 -148.62
4 113.00 -134.00 42.00 -63.00 -29.00 -134.00 42.00 -205.00
3 90.00 -68.00 -261.00 134.65 -261.00 -270.65
7 218.00 -342.00 147.22 -195.02 -11.83 -158.71 -139.38 -260.43 -139.38 -423.57 -11.83 -525.29 147.22 -488.98
6 131.00 -286.00 38.00 -124.92 -148.00 -124.92 -241.00 -286.00 -148.00 -447.08 38.00 -447.08
4 -170.00 -247.00 -172.00 -245.00 -174.00 -247.00 -172.00 -249.00
4 -332.00 -102.00 -395.00 -39.00 -458.00 -102.00 -395.00 -165.00
6 -52.00 -224.00 -196.50 26.28 -485.50 26.28 -630.00 -224.00 -485.50 -474.28 -196.50 -474.28
5 -101.00 163.00 -210.87 314.22 -388.63 256.46 -388.63 69.54 -210.87 11.78
0
SAMPLE OUTPUT
2
5
Sample input 1 Sample input 2 | 32,107 |
Wonderful Randomized Sum (CF33C)
Learn, learn and learn again — Valera has to do this every day. He is studying at mathematical school, where math is the main discipline. The mathematics teacher loves her discipline very much and tries to cultivate this love in children. That's why she always gives her students large and difficult homework. Despite that Valera is one of the best students, he failed to manage with the new homework. That's why he asks for your help. He has the following task. A sequence of n numbers is given. A prefix of a sequence is the part of the sequence (possibly empty), taken from the start of the sequence. A suffix of a sequence is the part of the sequence (possibly empty), taken from the end of the sequence. It is allowed to sequentially make two operations with the sequence. The first operation is to take some prefix of the sequence and multiply all numbers in this prefix by - 1. The second operation is to take some suffix and multiply all numbers in it by - 1. The chosen prefix and suffix may intersect. What is the maximum total sum of the sequence that can be obtained by applying the described operations?
Input
The first line of the input gives the number of test cases, T. T test cases follow, each with two lines. The first line contains integer n (1 ≤ n ≤ 10
5
) — amount of elements in the sequence. The second line contains n integers ai ( - 10
4
≤ ai ≤ 10
4
) — the sequence itself.
Output
For each test case, output one line containing the answer to the problem.
Example
Input:
3
3
-1 -2 -3
5
-4 2 0 5 0
5
-1 10 -5 10 -2
Output:
6
11
18 | 32,108 |
A - Crazy Rows (HAROWS)
Crazy Rows
You are given an
N
x
N
matrix with 0 and 1 values. You can swap any two
adjacent
rows of the matrix.
Your goal is to have all the 1 values in the matrix below or on the main diagonal. That is, for each X where 1 ≤ X ≤ N, there must be no 1 values in row X that are to the right of column X.
Return the minimum number of row swaps you need to achieve the goal.
Input
The first line of input gives the number of cases,
T
.
T
test cases follow.
The first line of each test case has one integer,
N
. Each of the next
N
lines contains
N
characters. Each character is either 0 or 1.
Output
For each test case, output
Case #X: K
where
X
is the test case number, starting from 1, and
K
is the minimum number of row swaps needed to have all the 1 values in the matrix below or on the main diagonal.
You are guaranteed that there is a solution for each test case.
Limits
1 ≤
T
≤ 60
1 ≤
N
≤ 8
Input
Output
3
2
10
11
3
001
100
010
4
1110
1100
1100
1000
Case #1: 0
Case #2: 2
Case #3: 4 | 32,109 |
B - Stock Charts (HASTOCK)
B - Stock Charts
You're in the middle of writing your newspaper's end-of-year economics summary, and you've decided that you want to show a number of charts to demonstrate how different stocks have performed over the course of the last year. You've already decided that you want to show the price of
n
different stocks, all at the same
k
points of the year.
A
simple chart
of one stock's price would draw lines between the points (0, price
0
), (1, price
1
), ... , (k-1, price
k-1
), where price
i
is the price of the stock at the
i
th point in time.
In order to save space, you have invented the concept of an
overlaid chart
. An overlaid chart is the combination of one or more simple charts, and shows the prices of multiple stocks (simply drawing a line for each one). In order to avoid confusion between the stocks shown in a chart, the lines in an overlaid chart may not cross or touch.
Given a list of
n
stocks' prices at each of
k
time points, determine the minimum number of overlaid charts you need to show all of the stocks' prices.
Input
The first line of input will contain a single integer
T
, the number of test cases. After this will follow
T
test cases on different lines, each of the form:
n k
price
0,0
price
0,1
... price
0,k-1
price
1,0
price
1,1
... price
1,k-1
...
price
n-1,0
price
n-1,1
... price
n-1,k-1
Where price
i,j
is an integer, the price of the
i
th stock at time
j
.
Output
For each test case, a single line containing "Case #X: Y", where
X
is the number of the test-case (1-indexed) and
Y
is the minimum number of overlaid charts needed to show the prices of all of the stocks.
Limits
1 ≤
T
≤ 100
2 ≤
k
≤ 25
0 ≤
price
i,j
≤ 1000000
1 ≤
n
≤ 16
Sample
Input:
3
3 4
1 2 3 4
2 3 4 6
6 5 4 3
3 3
5 5 5
4 4 6
4 5 4
5 2
1 1
2 2
5 4
4 4
4 1
Output:
Case #1: 2
Case #2: 3
Case #3: 2 | 32,110 |
D - Alphabetomials (HAALPHA)
As we all know, there is a big difference between polynomials of degree 4 and those of degree 5. The question of the non-existence of a closed formula for the roots of general degree 5 polynomials produced the famous Galois theory, which, as far as the author sees, bears no relation to our problem here.
We consider only the multi-variable polynomials of degree up to 4, over 26 variables, represented by the set of 26 lowercase English letters. Here is one such polynomial:
aber + aab + c
Given a string
S
, we evaluate the polynomial on it. The evaluation gives
p
(
S
) as follows: Each variable is substituted with the number of appearances of that letter in
S
.
For example, take the polynomial above, and let
S
= "abracadabra edgar". There are six a's, two b's, one c, one e, and three r's. So
p(S) = 6 * 2 * 1 * 3 + 6 * 6 * 2 + 1 = 109.
Given a dictionary of distinct words that consist of only lower case letters, we call a string
S
a
d-phrase
if
S = "S
1
S
2
S
3
... S
d
",
where S
i
is any word in the dictionary, for 1 ≤ i ≤ d. i.e.,
S
is in the form of
d
dictionary words separated with spaces. Given a number
K
≤ 10, your task is, for each 1 ≤
d
≤
K
, to compute the sum of
p
(
S
) over all the
d
-phrases. Since the answers might be big, you are asked to compute the remainder when the answer is divided by 10009.
Input
The first line contains the number of cases
T
.
T
test cases follow. The format of each test case is: A line containing an expression
p
for the multi-variable polynomial, as described below in this section, then a space, then follows an integer
K
. A line with an integer
n
, the number of words in the dictionary. Then
n
lines, each with a word, consists of only lower case letters. No word will be repeated in the same test case.
We always write a polynomial in the form of a sum of terms; each term is a product of variables. We write
a
t
simply as
t
a
's concatenated together. For example,
a
2
b
is written as
aab
. Variables in each term are always lexicographically non-decreasing.
Output
For each test case, output a single line in the form
Case #X: sum
1
sum
2
... sum
K
where
X
is the case number starting from 1, and sum
i
is the sum of
p
(
S
), where
S
ranges over all i-phrases, modulo 10009.
Limits
1 ≤
T
≤ 100.
The string
p
consists of one or more terms joined by '+'. It will not start nor end with a '+'. There will be at most 5 terms for each
p
.
Each term consists at least 1 and at most 4 lower case letters, sorted in non-decreasing order. No two terms in the same polynomial will be the same. Each word is non-empty, consists only of lower case English letters, and will not be longer than 50 characters. No word will be repeated in the same dictionary.
Small dataset
1 ≤
n
≤ 20
1 ≤
K
≤ 5
Large dataset
1 ≤
n
≤ 100
1 ≤
K
≤ 10
Sample
Input:
2
ehw+hwww 5
6
where
when
what
whether
who
whose
a+e+i+o+u 3
4
apple
orange
watermelon
banana
Output:
Case #1: 15 1032 7522 6864 253
Case #2: 12 96 576 | 32,111 |
E - Football Team (HATEAM)
A football team will be standing in rows to have a photograph taken. The location of each player will be given by two integers x and y, where y gives the number of the row, and x gives the distance of the player from the left edge of the row. The x values will be all different.
In order to make the photo more interesting, you're going to make sure players who are near each other have shirts of different colors. To do this, you set the following rule:
For each player P:
The closest player to the right of P in the same row, if there is such a player, must have a different shirt color.
The closest player to the right of P in the previous row, if there is such a player, must have a different shirt color.
The closest player to the right of P in the next row, if there is such a player, must have a different shirt color.
More formally, if there is a player at (x1,y1) and (x2,y2), where x1
y1 - 1 ≤ y2 ≤ y1 + 1, and
there is no x3 such that there is a player at (x3, y2) and x1 < x3 < x2.
Find the minimum number of distinct shirt colors required so that this is possible.
Input
The first line of input contains a single integer
T
, the number of test cases. Each test case starts with a line that contains an integer
N
, the number of players, followed by
N
lines of the form
x y
each specifying the position of one player.
Output
For each test case, output
Case #X: c
where
X
is the test case number, starting from 1, and
c
is the minimum number of colors required.
Limits
1 ≤
T
≤ 100
1 ≤
x
≤ 1000
The values of x will all be different.
Small dataset
1 ≤
y
≤ 15
1 ≤
N
≤ 100
Large dataset
1 ≤
y
≤ 30
1 ≤
N
≤ 1000
Sample
Input
3
3
10 10
8 15
12 7
5
1 1
2 1
3 1
4 1
5 1
3
1 1
2 2
3 1
Output
Case #1: 1
Case #2: 2
Case #3: 3 | 32,112 |
F - Interesting Ranges (HARANGES)
A positive integer is a
palindrome
if its decimal representation (without leading zeros) is a palindromic string (a string that reads the same forwards and backwards). For example, the numbers 5, 77, 363, 4884, 11111, 12121 and 349943 are palindromes.
A range of integers is
interesting
if it contains an even number of palindromes. The range [L, R], with L ≤ R, is defined as the sequence of integers from L to R (inclusive): (L, L+1, L+2, ... R-1, R). L and R are the range's first and last numbers.
The range [L
1
, R
1
] is a
subrange
of [L, R] if L ≤ L
1
≤ R
1
≤ R. Your job is to determine how many interesting subranges of [L, R] there are.
Input
The first line of input gives the number of test cases,
T
.
T
test cases follow. Each test case is a single line containing two positive integers,
L
and
R
(in that order), separated by a space.
Output
For each test case, output one line. That line should contain "Case #x: y", where x is the case number starting with 1, and y is the number of interesting subranges of [L, R], modulo 1000000007.
Limits
1 ≤
T
≤ 120
Small dataset: 1 ≤
L
≤
R
≤ 10
13
Large dataset; 1 ≤
L
≤
R
≤ 10
100
Sample
Input:
3
1 2
1 7
12 110
Output:
Case #1: 1
Case #2: 12
Case #3: 2466 | 32,113 |
Lexicographic position (LEXIPOS)
Let us consider the set of integer numbers between 1 and N inclusive. Order them lexicographically (i. e. like in the vocabulary), for example, for N = 11 the order would be: 1, 10, 11, 2, 3, 4, 5, 6, 7, 8, 9.
Denote the position of the number K in this ordering as Q
N,K
. For example, Q
11,2
= 4.
Given N and K, compute Q
N,K
.
Input
The first line contains a number T, which is the number of test cases. T lines follow, each contains 2 integers N and K separated by a single space.
Output
For each test case, print Q
N,K
on a single line.
Constraint
1 ≤ T ≤ 100
1 ≤ K ≤ N ≤ 10
100
Example
Input:
7
1 1
11 2
215 211
215 215
215 26
215 99
1000000000 999999999
Output:
1
4
126
130
135
215
1000000000 | 32,114 |
Hi6 (HISIX)
"I read somewhere that everybody on this planet is separated by only six other people. Six degrees of separation between us and everyone else on this planet. The President of the United States, a gondolier in Venice, just fill in the names. I find it A) extremely comforting that we're so close, and B) like Chinese water torture that we're so close because you have to find the right six people to make the right connection... I am bound to everyone on this planet by a trail of six people." - Ouisa Kitteridge, "Six Degrees of Separation"
Is widely know that one is separated from everyone in the world in no more than 6 degrees of separation. A degree of separation is defined by the minimum numbers of connections you need to make to contact someone else. For instance, if you know personally another person, then you are separated by one degree. If you know somebody through some friend but not directly (a friend of a friend), then you are separated by two degrees, and so on.
Nevertheless, young Kevin Smith is not convinced about this theory and wants to probe it false. To achieve this, he has hacked the Hi6! social network and requested you to help him knock down the theory of six degrees of separation.
Input
The first line contains an integer T, which specifies the number of test cases. Then, T test case descriptions will follow. Each test case will start with a line with one positive integer, N meaning the number of connections. The next N lines will contain the following pattern:
<name_1> <name_2>
meaning that person "<name_1>" is connected with the person "<name_2>" by making D connections and vice versa. Note that both persons can know each other by a lower degree of separation using other connections.
Output
For each input case you must print the string "Case #i: ", where i is the test case number, starting from 1, following by the maximum degree of separation between the specified people. If there is someone that cannot connect to another person, print "INFINITE" instead.
Constraints
All names will be non-empty strings composed only by lowercase characters.
All names will have between 1 and 10 characters, inclusive.
"<name_1>" will be different than "<name_2>" for all connections.
There will be no pair of connections between the same pair of persons.
D will be an integer between 1 and 1000, inclusive, for all connections.
T will be between 1 and 100, inclusive.
N will be between 1 and 10^5, inclusive.
Example
Input:
3
2
john judy 1
mary peter 1
3
john judy 7
john peter 2
judy peter 2
7
john judy 3
katie peter 4
john peter 2
judy mary 1
peter mary 2
john katie 1
katie mary 1
Output:
Case #1: INFINITE
Case #2: 4
Case #3: 3 | 32,115 |
Another Sorting Algorithm (IITD1)
Dexter keeps doing strange things with numbers. Yesterday he found a new algorithm to sort a sequence of numbers and he implemented the following pseudocode to sort the sequence of N numbers (0-based) in ascending order:
Seq = Given sequence of N numbers
swap(i, j)
{
temp = Seq[i]
Seq[i] =Seq[j]
Seq[j] = temp
}
reverse(i, j)
{
Do for k from i to (i+j-1)/2
swap(k, i+j-k)
}
sort()
{
Do for i from 0 to N-1
Do for j from i+1 to N-1
if (Seq[i] > Seq[j]) then reverse(i, j)
}
However unknown to Dexter, his sister Dee Dee added another loop inside the outer loop so that the changed sort function now looks like:
sort()
{
Do for i from 0 to N-1
Do for j from i+1 to N-1
if (Seq[i] > Seq[j]) then reverse(i, j)
Do for j from N-2 to i+2
reverse(i+1, j)
}
When today Dexter tested his program he was frustrated to find that the program was sorting the numbers but it was taking more time than it should (DeeDee's plans always work!)
You have been asked to help estimate the time taken. Given the sequence of numbers that Dexter wants to sort, your job is to find the number of times the swap function has been called.
Input
First line contains the number N, the size of the sequence to be sorted. N lines follow, each containing a single integer (the (i)th of these lines contains the value Seq[i].)
Output
Output a single number representing the number of times the swap function has been called.
Example
Input:
5
1
2
3
4
5
Output:
4
Constraints
1 ≤ N ≤ 4000
0 ≤ Seq[i] ≤ 1,000,000,000 | 32,116 |
Expected Cycle Sums (IITD5)
We are given a sequence S of N distinct integers. Denote by S[i] as ith element of S.
Hardik picks up a random permutation of S , breaks it into product of disjoint cycles & looks at cycle containing S[i].He notes down the sum of all element of this cycle. Call the expected value of this sum as cycleSum[i]. Your task is to find the minimum value amongst all cycleSums.
Assume all permutations of these N numbers are equally likely.
Input
First line contains an integer T which denotes the number of test cases. Then follow description of T test cases. Each test case takes 2 lines. First line contains a single integer N, the size of S. Then follows second line containing N elements of S.
Output
Print the answer for each test case, rounded to exactly one decimal place, in one line each.
Example
Input:
2
1
1
2
1 2
Output:
1.0
2.0
Note
Notion of cycles for any sequence is defined by using index in the sequence (1-N).
Explanation of Examples
In first case only possible permutation is (1) So answer is trivially 1.0
In second case possible permutations are (1)(2) and (12). As both of these are equally likely, cycleSum[1] = 1/2 * 1 + 1/2 * (1+2) = 2.0
And cycleSum[2] = 1/2 * 2 + 1/2 * (1+2) = 2.5. Smaller of these is 2.0, hence the answer.
Constraints
1 ≤ T ≤ 500
1 ≤ N ≤ 5000
All elements of S are distinct integers in range 0 to 10
5 | 32,117 |
Divisor Summation Powered (IITD4)
Define F(n, k) = Sum of k
th
powers of all divisors of n, so for example F(6, 2) = 1
2
+ 2
2
+ 3
2
+ 6
2
= 50
Define further G(a, b, k) as: Sum of F(j, k) where j varies from a to b both inclusive.
Your task is to find G(a, b, k) given a, b and k.
As values of G can get very large, you only need to output the value of G(a, b, k) modulo 10
9
+7.
Input
First line of input file contains a single integer T - denoting the number of test cases.
The follow description of T test cases. Each test case occupies exactly one line which contains three space separated integers a, b and k.
Output
Output your result for each test case in a new line.
Sample
Input:
2
2 2 1
1 3 2
Output:
3
16
Description of Sample
In case 1, we are to find sum of divisors of 2. which is nothing but 1 + 2 = 3.
In case 2, we are to find sum of squares of divisors of 1, 2 and 3. So for 1
2
sum is = 1. For 2 sum is = 1
2
+ 2
2
= 5. For 3 sum is = 1
2
+ 3
2
= 10.
So answer is 16.
Constraints
1 ≤ a ≤ b ≤ 10
5
1 ≤ k ≤ 10
5
Number of test cases ≤ 20 | 32,118 |
Power Calculus (YOKOF)
Starting with
x
and repeatedly multiplying by
x
, we can compute
x
31
with thirty multiplications:
x
2
=
x
*
x
,
x
3
=
x
2
*
x
,
x
4
=
x
3
*
x
,
...
x
31
=
x
30
*
x
.
The operation of squaring can appreciably shorten the sequence of multiplications. The following is a way to compute
x
31
with eight multiplications:
x
2
=
x
*
x
,
x
3
=
x
2
*
x
,
x
6
=
x
3
*
x
3
,
x
7
=
x
6
*
x
,
x
14
=
x
7
*
x
7
,
x
15
=
x
14
*
x
,
x
30
=
x
15
*
x
15
,
x
31
=
x
30
*
x
.
This is not the shortest sequence of multiplications to compute
x
31
. There are many ways with only seven multiplications. The following is one of them:
x
2
=
x
*
x
,
x
4
=
x
2
*
x
2
,
x
8
=
x
4
*
x
4
,
x
10
=
x
8
*
x
2
,
x
20
=
x
10
*
x
10
,
x
30
=
x
20
*
x
10
,
x
31
=
x
30
*
x
.
There however is no way to compute
x
31
with fewer multiplications. Thus this is one of the most efficient ways to compute
x
31
only by multiplications.
If division is also available, we can find a shorter sequence of operations. It is possible to compute
x
31
with six operations (five multiplications and one division):
x
2
=
x
*
x
,
x
4
=
x
2
*
x
2
,
x
8
=
x
4
*
x
4
,
x
16
=
x
8
*
x
8
,
x
32
=
x
16
*
x
16
,
x
31
=
x
32
÷
x
.
This is one of the most efficient ways to compute
x
31
if a division is as fast as a multiplication.
Your mission is to write a program to find the least number of operations to compute
x
n
by multiplication and division starting with
x
for the given positive integer
n
. Products and quotients appearing in the sequence of operations should be
x
to a positive integer's power. In other words,
x
-3
, for example, should never appear.
Input
The input is a sequence of one or more lines each containing a single integer
n
.
n
is positive and less than or equal to 1000. The end of the input is indicated by a zero.
Output
Your program should print the least total number of multiplications and divisions required to compute
x
n
starting with
x
for the integer
n
. The numbers should be written each in a separate line without any superfluous characters such as leading or trailing spaces.
Example
Input:
1
31
70
91
473
512
811
953
0
Output:
0
6
8
9
11
9
13
12 | 32,119 |
The Best Name for Your Baby (YOKOH)
In the year 29XX, the government of a small country somewhere on the earth introduced a law restricting first names of the people only to traditional names in their culture, in order to preserve their cultural uniqueness. The linguists of the country specifies a set of rules once every year, and only names conforming to the rules are allowed in that year. In addition, the law also requires each person to use a name of a specific length calculated from one's birth date because otherwise too many people would use the same very popular names. Since the legislation of that law, the common task of the parents of new babies is to find the name that comes first in the alphabetical order among the legitimate names of the given length because names earlier in the alphabetical order have various benefits in their culture.
Legitimate names are the strings consisting of only lowercase letters that can be obtained by repeatedly applying the rule set to the initial string ``S'', a string consisting only of a single uppercase S.
Applying the rule set to a string is to choose one of the rules and apply it to the string. Each of the rules has the form
A
, where
A
is an uppercase letter and
is a string of lowercase and/or uppercase letters. Applying such a rule to a string is to replace an occurrence of the letter
A
in the string to the string
. That is, when the string has the form ``
A
'', where
and
are arbitrary (possibly empty) strings of letters, applying the rule rewrites it into the string ``
''. If there are two or more occurrences of
A
in the original string, an arbitrary one of them can be chosen for the replacement.
Below is an example set of rules.
S
aAB
(1)
A
(2)
A
Aa
(3)
B
AbbA
(4)
Applying the rule (1) to ``S'', ``aAB'' is obtained. Applying (2) to it results in ``aB'', as A is replaced by an empty string. Then, the rule (4) can be used to make it ``aAbbA''. Applying (3) to the first occurrence of A makes it ``aAabbA''. Applying the rule (2) to the A at the end results in ``aAabb''. Finally, applying the rule (2) again to the remaining A results in ``aabb''. As no uppercase letter remains in this string, ``aabb'' is a legitimate name.
We denote such a rewriting process as follows.
S
aAB
aB
aAbbA
aAabbA
aAabb
aabb
Linguists of the country may sometimes define a ridiculous rule set such as follows.
S
sA
(1)
A
aS
(2)
B
b
(3)
The only possible rewriting sequence with this rule set is:
S
sA
saS
sasA
...
which will never terminate. No legitimate names exist in this case. Also, the rule (3) can never be used, as its left hand side, B, does not appear anywhere else.
It may happen that no rules are supplied for some uppercase letters appearing in the rewriting steps. In its extreme case, even S might have no rules for it in the set, in which case there are no legitimate names, of course. Poor nameless babies, sigh!
Now your job is to write a program that finds the name earliest in the alphabetical order among the legitimate names of the given length conforming to the given set of rules.
Input
The input is a sequence of datasets, followed by a line containing two zeros separated by a space representing the end of the input. Each dataset starts with a line including two integers
n
and
l
separated by a space, where
n
(0 <=
n
<= 50) is the number of rules and
l
(0 <=
l
<= 20) is the required length of the name. After that line,
n
lines each representing a rule follow. Each of these lines starts with one of uppercase letters, A to Z, followed by the character ``='' (instead of ``
'') and then followed by the right hand side of the rule which is a string of letters A to Z and a to z. The length of the string does not exceed 10 and may be zero. There appears no space in the lines representing the rules.
Output
The output consists of the lines showing the answer to each dataset in the same order as the input. Each line is a string of lowercase letters, a to z, which is the first legitimate name conforming to the rules and the length given in the corresponding input dataset. When the given set of rules has no conforming string of the given length, the corresponding line in the output should show a single hyphen, "
-
". No other characters should be included in the output.
Example
Input:
4 3
A=a
A=
S=ASb
S=Ab
2 5
S=aSb
S=
1 5
S=S
1 0
S=S
1 0
A=
2 0
A=
S=AA
4 5
A=aB
A=b
B=SA
S=A
4 20
S=AAAAAAAAAA
A=aA
A=bA
A=
0 0
Output:
abb
-
-
-
-
aabbb
aaaaaaaaaaaaaaaaaaaa | 32,120 |
Cubic Eight-Puzzle (YOKOC)
Let's play a puzzle using eight cubes placed on a 3
x
3 board leaving one empty square.
Faces of cubes are painted with three colors. As a puzzle step, you can roll one of the cubes to the adjacent empty square. Your goal is to make the specified color pattern visible from above by a number of such steps.
The rules of this puzzle are as follows.
Coloring of Cubes:
All the cubes are colored in the same way as shown in Figure 3. The opposite faces have the same color.
Figure 3: Coloring of a cube
Initial Board State:
Eight cubes are placed on the 3
x
3 board leaving one empty square. All the cubes have the same orientation as shown in Figure 4. As shown in the figure, squares on the board are given
x
and
y
coordinates, (1, 1), (1, 2) ... and (3, 3). The position of the initially empty square may vary.
Figure 4: Initial board state
Rolling Cubes:
At each step, we can choose one of the cubes adjacent to the empty square and roll it into the empty square, leaving the original position empty. Figure 5 shows an example.
Figure 5: Rolling a cube
Goal:
The goal of this puzzle is to arrange the cubes so that their top faces form the specified color pattern by a number of cube rolling steps described above.
Your task is to write a program that finds the minimum number of steps required to make the specified color pattern from the given initial state.
Input
The input is a sequence of datasets. The end of the input is indicated by a line containing two zeros separated by a space. The number of datasets is less than 16. Each dataset is formatted as follows.
x
y
F
11
F
21
F
31
F
12
F
22
F
32
F
13
F
23
F
33
The first line contains two integers
x
and
y
separated by a space, indicating the position (
x
,
y
) of the initially empty square. The values of
x
and
y
are 1, 2, or 3.
The following three lines specify the color pattern to make. Each line contains three characters
F
1j
,
F
2j
, and
F
3j
, separated by a space. Character
F
ij
indicates the top color of the cube, if any, at position (
i
,
j
) as follows:
B
: Blue,
W
: White,
R
: Red,
E
: the square is Empty.
There is exactly one '
E
' character in each dataset.
Output
For each dataset, output the minimum number of steps to achieve the goal, when the goal can be reached within 30 steps. Otherwise, output "
-1
" for the dataset.
Example
Input:
1 2
W W W
E W W
W W W
2 1
R B W
R W W
E W W
3 3
W B W
B R E
R B R
3 3
B W R
B W R
B E R
2 1
B B B
B R B
B R E
1 1
R R R
W W W
R R E
2 1
R R R
B W B
R R E
3 2
R R R
W E W
R R R
0 0
Output:
0
3
13
23
29
30
-1
-1 | 32,121 |
Number of Palindromes (NUMOFPAL)
Each palindrome can be always created from the other palindromes, if a single character is also a palindrome. For example, the string "malayalam" can be created by some ways:
malayalam = m + ala + y + ala + m
malayalam = m + a + l + aya + l + a + m
We want to take the value of function NumPal(s) which is the number of different palindromes that can be created using the string S by the above method. If the same palindrome occurs more than once then all of them should be counted separately.
Input
The string S.
Output
The value of function NumPal(s).
Limitations
0 < |s| ≤ 1000
Example
Input:
malayalam
Output:
15 | 32,122 |
Wise And Miser (MISERMAN)
Jack is a wise and miser man. Always tries to save his money.
One day, he wants to go from city A to city B. Between A and B, there are N number of cities (including B and excluding A) and in each city there are M buses numbered from 1 to M. And the fare of each bus is different. Means for all N×M buses, fare (K) may be different or same. Now Jack has to go from city A to city B following these conditions:
At every city, he has to change the bus.
And he can switch to only those buses which have number either equal or 1 less or 1 greater to the previous.
You are to help Jack to go from A to B by spending the minimum amount of money.
N, M, K <= 100.
Input
Line 1: N M
Line 2: N×M Grid
Each row lists the fares the M busses to go form the current city to the next city.
Output
Single Line containing the minimum amount of fare that Jack has to give.
Example
Input:
5 5
1 3 1 2 6
10 2 5 4 15
10 9 6 7 1
2 7 1 5 3
8 2 6 1 9
Output:
10
Explanation
1 → 4 → 1 → 3 → 1: 10 | 32,123 |
Cave Crisis (PC8C)
R2D2 was exploring a tunnel when a cave-in suddenly occurred. Oh no, is he trapped?
Figure1: Overhead view of the cave crisis from the third example test case.
From an overhead view, we can see all the obstacles (debris) on a two-dimensional Cartesian plane. The tunnel is
w
cm wide, bounded by the lines
y
=
w
/2
and
y
= -
w
/2
. R2D2 starts at
(0, 0)
, and has a perfectly circular footprint of radius
r
. The exit of the tunnel lies to the right of the line
x
= 1000
. Between R2D2 and the exit lie a number of polygonal obstacles.
Is it possible for R2D2 to navigate between the obstacles and make it to the exit?
Input
The input file will contain multiple test cases. Each test case begins with a single line containing an even integer
w
(
2 ≤
w
≤ 1000
), the width of the tunnel, and an integer
N
(
0 ≤
N
≤ 100
), the number of obstacles. The next
N
lines each contain the description of a single obstacle. The
i
-th obstacle is a simple polygon, specified on a single line containing an integer
n
i
(
3 ≤
n
i
≤ 10
), the number of vertices, followed by
n
i
pairs of integers,
x
ij
and
y
ij
(
0 ≤
x
ij
≤ 1000
and
-
w
/2 ≤
y
ij
≤
w
/2
for
j
= 1 ...
n
i
), specifying the coordinates of the vertices in counter-clockwise order. Note that obstacles in the input may touch or even overlap. However, you are guaranteed that R2D2's initial location will not touch or overlap any obstacle. The vertices of each polygon are unique, no two non-consecutive edges of the polygon intersect (even at their endpoints), and each polygon is guaranteed to have nonzero area.
The end-of-input is denoted by an invalid test case with
w
=
N
= 0
and should not be processed.
Output
For each input test case, you must determine the maximum radius
r
> 0
that R2D2 could have and still be able to plan a path from his starting location
(0, 0)
to the tunnel exit without overlapping with any of the obstacles. You should print either this maximum radius
r
(rounded to two decimal places) or the message "
impossible
" if no such radius exists.
Example
Input:
6 2
4 2 -1 4 -1 4 1 2 1
3 3 0 6 -1 6 1
8 2
3 1 -1 4 -1 4 4
3 3 -4 6 1 3 1
10 7
4 0 5 4 2 5 3 4 5
3 4 -5 9 -5 9 0
4 8 -5 11 -5 11 -2 8 -2
3 8 3 16 1 11 5
4 21 -5 23 -3 20 -2 15 -4
3 22 3 26 -1 28 0
3 24 0 29 4 25 3
0 0
Output:
1.00
impossible
1.33 | 32,124 |
Optimal Strategy for the ICPC (PC8F)
The following is taken from the official rules for the International Collegiate Programming Contest, as reported at //www.acmicpc-pacnw.org/rules.htm
The total time is the sum of the time consumed for each problem solved. The time consumed for a solved problem is the time elapsed from the beginning of the contest to the submittal of the first accepted run plus 20 penalty minutes for every previously rejected run for that problem. There is no time consumed for a problem that is not solved.
Quite simply, one element of the optimal strategy is not to have any erroneous submissions, so the androids do not have to worry about the penalty minutes. All that remains is to determine the order in which they should submit problems.
Let's assume perfect knowledge -- hey, these androids are good -- so that they can make a very good estimate of the development time required for each of the problems. The task is to determine the order in which the problems should be submitted. The androids realize that their best approach is for each to think independently about different problems rather than having all three work on a single problem. Furthermore, each android types infinitely fast, and does not use the computer terminal while thinking. Hence, up to three problems can be simultaneously in progress at any given time, and it is actually possible for all three bots to submit a problem within the same minute. For the same reason, the number of problems posed is larger than those posed in the contest for biological entities. Being innately fussy, if there are multiple ways to submit the problems and obtain the same score, they will submit the problem order that comes lexicographically first.
Determine the algorithm to solve the most problems and to obtain the best possible score for those problems. Then implement it.
Input
The first line of input to your program is a single integer
n
(0 <
n
< 100), giving the number of data sets -- one for each set of problems. Following that are exactly
n
lines, giving information about each data set. The first number is the number of problems in that dataset as an integer
k
(5 <=
k
<= 15). On the same line, separated by single spaces, are
k
integers, all between 1 and 300 inclusive, giving the estimated time required to solve each problem. The problems themselves are labeled by alphabetic characters starting with A. Note that there are exactly 300 minutes in the contest.
Output
Each data set generates one line of output, giving the data set number, the sequence the problems are submitted, the total number solved, and the final penalty score. See the sample output for format -- all non-blank entries are separated by single blank spaces.
Example
Input:
4
9 25 50 100 150 100 100 150 225 300
10 60 120 99 129 15 150 225 135 50 123
12 6 60 99 45 135 66 231 63 96 39 50 123
15 75 75 75 75 75 75 75 75 75 75 75 75 75 75 75
Output:
Data set 1: A B C D E F G H 8 1450
Data set 2: E I A J C B F H D 9 1473
Data set 3: A J D B K F H I C E L 11 1452
Data set 4: A B C D E F G H I J K L 12 2250 | 32,125 |
Milk Trading (MLK)
Hareedi and Hanadt live in a village with
N
houses built next to each other along one
straight roadway with equal distances between adjacent houses. Some people own cows
and sell the milk their cows produce, while others do not own cows and may need to buy
milk.
Every morning, Hareedi and Hanadi transport milk around the village such that everyone
buys or sells the exact number of bottles they want. Transporting one bottle of milk from
one house to an adjacent house results in one unit of work.
Fortunately
, the number of
milk bottles needed by people is always equal to the number of milk bottles sold by
cow owners.
Task
write a program that is given the number of milk bottles that people at each house needs
to buy or sell, represented as an integer, finds the minimum work necessary to transport
the bottles from sellers to buyers.
Constraints
2 ≤
N
≤ 1,000,000 - the number of houses.
-1000 ≤
B
i
≤ 1000 - an integer representing the number of bottles to be bought from or sold at the house at position
i
.
There are 28 test cases.
Input
Line 1 contains the integer
N
, the number of houses.
Each of the next
N
lines contains an integer
B
i
. If
B
i
> 0 then people in house i are cow owners and want to sell
B
i
bottles of milk. If
B
i
≤ 0 then people at house i are not cow owners
and want to buy
B
i
bottles of milk.
Output
A single line containing a single integer, the minimum work units necessary to transport the bottle of milk.
Example
Input:
5
5
-4
1
-3
1
Output:
9
Explanation
There are 5 houses as shown in the table.
Position
1
2
3
4
5
Bottles
5
-4
1
-3
1
4 bottles are transported from house 1 to house 2, 1 bottle from house 1 to
house 4, 1 bottle from house 3 to house 4, 1 bottle from house 5 to house 4. | 32,126 |
New Game with a Chess Piece (CF36D)
Petya and Vasya are inventing a new game that requires a rectangular board and one chess piece. At the beginning of the game the piece stands in the upper-left corner of the board. Two players move the piece in turns. Each turn the chess piece can be moved either one square to the right or one square down or jump
k
squares diagonally down and to the right. The player who can’t move the piece loses.
The guys haven’t yet thought what to call the game or the best size of the board for it. Your task is to write a program that can determine the outcome of the game depending on the board size.
Input
The first input line contains one integer 1 ≤
t
≤ 20202. Each of the following
t
lines contains three numbers:
k
and
n
,
m
- the jump length and the board’s length and width (1 ≤
n, m ,k
≤ 10
9
).
Output
Output
t
lines that can determine the outcomes of the game on every board. Write «+» if the first player is a winner, and «-» otherwise.
Example
Input:
10
1 1 1
1 2 1
2 1 2
2 2 2
1 3 2
2 3 2
3 1 3
3 2 3
3 3 3
4 3 3
Output:
-
+
+
-
+
+
-
+
-
- | 32,127 |
Fibonacci Factor (FIBFACT)
Let F(n) be nth Fibonacci number. F(0) = 0, F(1) = 1, F(2) = 1, F(3) = 2, F(4) = 3 and so on. Given a positive integer n > 2, print the smallest prime number P such that P divides F(n) but it does not divide any F(k) smaller than F(n). Maximum value of n is limited by P where P < 2
64
. You should print IMPOSSIBLE if no such P exists.
Input
First line of input contains a single positive integer T denoting number of test cases. T ≤ 20. Next T lines contains value of n.
Output
Output value of P corresponding to each n in separate lines.
Example
Input:
2
3
8
Output:
2
7
PS : Source Code Limit changed to 700B. | 32,128 |
Divisors VI (DIVISER9)
Find the smallest integer with exactly
N
odd divisors, where each divisor is greater or equal to 1 !!!
For example for 3 odd divisors, 9 (factors 1, 3, 9) is minimum.
Input
Each line contain
N (0 < N < 10
14
)
. There are 100 inputs total.
Output
One answer on each line for each
N
,
Modulo 1000000007.
Example
Input:
3
1024
Output:
9
97947700 | 32,129 |
Driving Direction (NE06D)
Contrary to the popular belief, alien flying saucers cannot fly arbitrarily around our planet Earth. Their touch down and take off maneuvers are extremely energy consuming, so they carefully plan their mission to Earth to touch down in one particular place, then hover above the ground carrying out their mission, then take off. It was all so easy when human civilization was in its infancy, since flying saucers can hover above all the trees and building, and their shortest path from one mission point to the other was usually a simple straight line -- the most efficient way to travel. However, modern cities have so tall skyscrapers that flying saucers cannot hover above them and the task of navigating modern city became quite a complex one. You were hired by an alien spy to write a piece of software that will ultimately give flying saucers driving directions throughout the city. As your first assignment (to prove your worth to your alien masters) you should write a program that computes the shortest distance for a flying saucer from one point to another. This program will be used by aliens as an aid in planning of mission energy requirements.
The problem is simplified by several facts. First of all, since flying saucer can hover above most of the buildings, you are only concerned with locations of skyscrapers. Second, the problem is actually two-dimensional -- you can look at everything "from above" and pretend that all objects are situated on
OXY
Cartesian plane. Flying saucer is represented by a circle of radius
r
, and since modern cities with skyscrapers tend to be regular, every skyscraper is represented with a rectangle whose sides are parallel to
OX
and
OY
axes.
By definition, the location of flying saucer is the location of its center, and the length of the path it travels is the length of the path its center travels. During its mission flying saucer can touch skyscrapers but it cannot intersect them.
At the first picture a flying saucer of
r
= 1 has to get from point
A
to point
B
. The straight dashed line would have been the shortest path if not for skyscraper 1. The shortest way to avoid skyscraper 1 is going around its top right corner, but skyscraper 2 is too close to fly there. Thus, the answer is to go around the bottom left corner of skyscraper 1 for a total path length of 10.570796.
In the second picture it is impossible for a flying saucer of
r
= 2 to get from point
A
to point
B
, since all skyscrapers are too close to fly in between them.
In the third picture flying saucer of
r
= 1 has to fly in a slalom-like way around two skyscrapers in order to achieve the shortest path of length 11.652892 between
A
and
B
.
Input
The input file contains several test cases, each of them as described below.
The first line of the input file contains integer numbers
r
and
n
(1 ≤ r ≤ 100, 0 ≤ n ≤ 30), where
r
is the radius of the flying saucer, and
n
is the number of skyscrapers. The next line contains four integer numbers
x
A
,
y
A
,
x
B
, and
y
B
(-1000 ≤
x
A
,
y
A
,
x
B
,
y
B
≤ 1000), where (
x
A
,
y
A
) are the coordinates of the starting point of the flying saucer's mission and (
x
B
,
y
B
) are the coordinates of its finishing point.
The following
n
lines describe skyscrapers. Each skyscraper is represented by four integer numbers
x
1
,
y
1
,
x
2
, and
y
2
(-1000 ≤
x
1
,
y
1
,
x
2
,
y
2
≤ 1000,
x
1
<
x
2
,
y
1
<
y
2
) -- coordinates of the corners of the corresponding rectangle.
Skyscrapers neither intersect nor touch each other. Starting and finishing points of the flying saucer's mission are valid locations for flying saucer, that is, it does not intersect any skyscraper in those points, but may touch some of them.
Output
For each test case, write to the output a line with the text "
no solution
" (without quotes) if the flying saucer cannot reach its finishing point from the starting one. Otherwise, write to the output a line with a single number -- the shortest distance that the flying saucer needs to travel to get from the starting point to the finishing point. Answer has to be precise to at least 6 digits after the decimal point.
Example
Input:
1 3
2 7 7 1
3 2 6 4
7 5 9 8
1 8 5 9
2 4
0 0 5 6
8 3 10 6
5 9 9 10
1 4 2 8
3 1 5 3
1 2
0 5 10 5
2 2 4 5
6 5 8 8
Output:
10.570796
no solution
11.652892 | 32,130 |
Mathematics (MATHS)
One could define mathematics as the study of quantity, structure, space and change and as the science of infinity. Sometimes very abstract, mathematics finds nevertheless applications in many engineering domains. The figure below shows so-called Ford circles. These circles are disjoint or tangent and fill the space in a very compact way! Starting with large circles, the space between these circles can be filled with circles of smaller diameter, and so on and so forth.
Mathematicians observed that the diameters and positions of the centers of these circles follow a given scheme, which can be described with the help of Farey sequences. The Farey sequence of order
N
is the sequence of completely reduced fractions between 0 and 1, which have denominators less than or equal to
N
, arranged in increasing size. Thus each Farey sequence starts with the value 0, denoted by the fraction
0
⁄
1
, and ends with the value 1, denoted by the fraction
1
⁄
1
.
The Amazing Circle Mathematicians (ACM) are interested in the number of terms contained in such a Farey sequence as well as in certain precise terms, which they name Interesting and Curious Position In Circle (ICPC). Your job is to provide the ACMs with this abstract information, which helps them to better understand the Ford circles.
Input
The input consists of several test-cases, one per line. Each test-case consists of two numbers, the first is the order
N
(2 ≤
N
≤ 10
6
) of the Farey sequence the ACM is interested in and the second is the ICPC
P
(1 ≤
P
≤ 10
4
). Input terminates on a line containing 0 0 which must not be processed.
Output
For each test-case, output first the ICPC, then the total number of terms in the given Farey sequence.
Example
Input:
2 2
6 12
14 35
0 0
Output:
1/2 3
5/6 13
6/11 65 | 32,131 |
Building Ports (BPORT)
N ports are to be constructed on the bytelandian river. Since trade occurs only along a Y miles stretch of the river, the distance between the start point and the last port must be Y. (Consider start point has the 0th port.)
To optimize the ship movement between important ports, the distance between any two consecutive ports has been fixed to be within a range of possible distances. Also, distance between two consecutive ports can only be an integer number of miles.
As a programmer you have been assigned the job of evaluating the number of different possible arrangements of ports modulo 1000000007.
Input
First line of input contains t. The number of test cases (t < 100).
First line of each test case contains two integers: N, the number of ports to be built (N <= 20) and Y, the distance between the start point and the last port. (Y < 100000)
Next N lines of the test case contains the range of distances between consecutive ports, with ith line giving two integers, the minimum and maximum gap between (i-1)th and ith port.
Output
Print one of output for each test case which is the number of possible arrangements modulo 1000000007.
Example
Input:
1
2 4
0 3
0 3
Output:
3 | 32,132 |
SHOPPERS (SHOPPERS)
A group of N shoppers go to a supermarket. The supermarket has M items. Each shopper wants to buy only the items he likes.
They plan to buy K items in all. A shopper can buy at max only one item. Some shoppers may not buy anything and some items might not be bought.
Input
First line contains the number of test cases.
Each test case contains three integers N, M and K separated by spaces. Then follow N lines containing M characters each.
If jth character of ith line is 1 then ith shopper likes item j.
1<= K <= N, M <= 13
Output
For each test case, output the number of ways K items in all can be bought.
Example
Input:
1
4 4 2
1111
0100
0100
1100
Output:
14 | 32,133 |
Architecture (ARCHI)
Architecture, a tightrope walk between engineering and art! There are probably few invariants shared by the architectural styles around the world and throughout time. Precisely this diversity makes the domain so interesting and challenging.
Any domains may serve as sources of inspiration, mathematical shapes, nature, organisms and even arched slices of Swiss cheese J. Some of our university friends from architecture plan to participate in the prestigious Erect a Palace From Lines (EPFL) contest. This contest is about designing a huge single-floor palace by building horizontal and vertical walls inside the preset square fundament.
The students just finished their creative prototypes, and you are to revise their projects before they enter the contest. Some were obviously overwhelmed by the cryptographic protocol required for the palace description and do not know how many rooms their palace has. Walls are one unit thick and are described by their horizontal and vertical start and end positions. As the palace is huge, these coordinates are expressed in a base 26 system (the latin alphabet). Having overlapping walls is not a problem. For the encryption, read ‘A’ as zero and ‘Z’ as twenty-five. All other letters cover the remaining range in the conventional lexicographic order.
INPUT
The input consists of several test-cases, separated by an empty line. Each test-case starts with the side length of the square palace
n
(A<=n<=Z
Z
) and the number of walls
w
(0<=w<=500) the student placed inside the palace. The palace’s interior spreads thus from 0 to
n-1
, vertically and horizontally. The following
w
lines each describe a wall in the form x1 y1 x2 y2, the horizontal and vertical endpoints of the wall such that (0<=x1,y1,x2,y2<=n-1). Input terminates on a test-case with
n
=A and
w
=0, which must not be processed. You may safely assume that no student placed walls that transgress the fundaments of the palace and that no palace has more than 10’000 rooms.
OUTPUT
For each test-case, output the number of rooms in the palace.
SAMPLE INPUT
P 17
G N G F
F G C G
F O F K
G M N M
C F C M
I E K E
O C O E
B L B N
J M J E
M O J O
H O C O
L H L I
N F K F
M E O E
N D O D
E C E L
G O G L
ZZZZZZZZZZZZZZZZ 4
A GH ZZZZZZZZZZZZZZZY GH
POLYPROG SELECTION POLYPROG CONTEST
TOBE ORNOT TOBE THATSTHEQUESTION
LEADINGZEROS NO LEADINGAS NO
SAMPLE OUTPUT
4
2 | 32,134 |
Road Map (RANJAN05)
There are
x
villages in Andhere Nagar. Each village has its index — an integer number from 1 to
x
. The capital has index a. All the roads in Andhere Nagar are two-way. The road system is such that there is exactly one path from the capital to each city, i.e. the road map looks like a tree. In Andhere Nagar's chronicles the road map is kept in the following way: for each village
i
, different from the capital, there is kept number
p
i
— index of the last village on the way from the capital to
i
.
Once the king of Andhere Nagar, Choupat Raja, decided to move the capital from village a to village b. Naturally, after this the old representation of the road map in Andhere Nagar 's chronicles became incorrect. Please, help the king find out a new representation of the road map in the way described above.
Input
The first line contains three space-separated integers
x
, a, b (2 ≤
x
≤ 5·10
4
, 1 ≤ a ≠ b ≤
n
) — amount of villages in Andhere Nagar, index of the old capital and index of the new one, correspondingly.
The following line contains
x
- 1 space-separated integers — the old representation of the road map. For each city, apart from a, there is given integer
p
i
— index of the last city on the way from the capital to city
i
. All the cities are described in order of increasing indexes.
Output
Output
x
- 1 numbers — new representation of the road map in the same format.
Example 1
Input:
3 2 3
2 2
Output:
2 3
Example 2
Input:
6 2 4
6 1 2 4 2
Output:
6 4 1 4 2 | 32,135 |
Telecommunications (TELECOM)
From beacons over telegraphs and telephones towards radio and television and ultimately computer networks and internet – telecommunication systems knew a tremendous evolution within the last century! This was also clear to Richard Hamming, who was bothered by erroneous data transmission.
As the transmission channel is often very noisy, the received information is not necessarily the information that was sent out. Looking at digital data transmission, a straight-forward way to check for errors would be a supplementary bit of information, a so-called parity bit. Each package of data on
n-1
bits is completed by 1 parity bit, whose value is chosen such that the number of ones in the
n
-bit package is even. Although there is little overhead, parity checking is not very robust. If an even number of bits is flipped during transmission, the check bit remains valid and the error will not be detected. Moreover, although parity can detect errors, it provides no indication on the position of the flipped bit. The data must be discarded entirely and re-transmitted.
If more error-correcting bits are included with a message, and if those bits can be arranged such that different incorrect bits produce different error results, then bad bits could be identified and corrected! Among others, Hamming invented the following algorithm that generates a single-error correcting code for any number of bits.
Hamming single-error correcting code is the same as described in this
Wikipedia article
.
Suppose the original message is described by an unsigned 64-bit integer X. Transform it into a 64-bit 01 string S (Least significant digit first), then use the above procedure to encode it into a 01 string S2. Transform it into a (not necessarily 64-bit) integer Y. Now you are given the integer Y in decimal notation, with at most 1-bit error. Restore the original integer X in decimal notation.
Input
Input contains several lines, each containing a single non-negative integer (in decimal notation). Input terminates with -1.
Output
For each input line output one line with a single integer - the decoded message (in decimal notation).
Example
Input:
0
81
-1
Output:
0
11
Explanation
11 → (1101) (least significant digit first) → encode (1010101) → error in bit 2 (1000101) → 81 (decimal) | 32,136 |
Pebble Solver (PEBBLE)
Pebble is a popular turn-based multi-player game played by kids. In this game, all the players are given a binary string (i.e., a string consisting only of 0's and 1's) of some fixed length. The goal of the game is to convert this binary string to a string containing all 0's.
In a turn, a player is allowed to perform only one operation:- Replace a 1 by a 0 or vice-versa. But each such operation will flip the states of all the bits following the bit you changed.
Take for example, the string: 1001010. You decide to flip the 1 located at the 4th position. The new string after the operation will be : 1000101. (Note that 5th to 7th bits flipped as a result of flipping the 4th bit.)
Your small sister loves to play this game very much. So, you decide to gift her the pebble-solver software which solves this game with the minimum number of operations(how else will you make sure that she always wins?!). And we want to make sure that your software doesn't have any bugs. (he he)
Input
There are going to multiple test cases. Each test case consists of a single line which is the initial bit-string.
Edited:
the maximum length of bit-string <= 1000.
Output
Output corresponding to the each test case in the following format :
"Game #x: y", where x indicates the test case number and y is the minimum number of steps required for your program to solve the game.
Example
Input:
0101
10000
00
Output:
Game #1: 3
Game #2: 2
Game #3: 0 | 32,137 |
Sum of Digits (CPCRC1C)
Majid is a 3rd-grade elementary student and quite well in mathematics. Once, Majid's teacher asked him to calculate the sum of numbers 1 through n.
Majid quickly answered, and his teacher made him another challenge. He asked Majid to calculate the sum of the digits of numbers 1 through n.
Majid did finally find the solution. Now it is your turn, can you find a solution?
Input
Two space-separated integers 0 <= a <= b <= 10
9
.
Program terminates if a and b are -1.
Output
The sum of the digits of numbers a through b.
Example
Input:
1 10
100 777
-1 -1
Output:
46
8655 | 32,138 |
Electrical Engineering (ELEC)
The electrical engineers’ indefatigable strive towards environmentally friendly energy production translated into the recent boom of hydro, solar, wind and geothermal power plants. While the production side seems ready, these ambitious projects have their bottleneck in the transportation and distribution: Besides the energy losses that occur during transportation over long distances, the renewable energy sources cannot provide power on demand – they must be taken as provided by nature. Used at large scale in today’s networks, unreliable green energy can disrupt the balance of power grids easily and cause huge damage along with large-scale power outages.
Serious effort is thus put on researching transient and dynamic phenomena in power grids. You are offered a position in the lab for linear and planar distribution networks. Given a description of the distribution network’s line impedances Z
i
, you are to find the equivalent impedance between some couples of nodes. The knowledge of such equivalent impedances may speed up the network analysis considerably! Impedances are complex number whose real part represents the resistive line behaviour while the imaginary part stands for the capacitive (negative) or inductive (positive) characteristic. Lines are bidirectional, that is impedance(a,b) equals impedance (b,a).
It was proven that any linear and planar graph (can be drawn in a way that its edges intersect only at their endpoints) can be reduced into a single equivalent edge that represents the equivalent impedance between its ending nodes, using the following six transformations:
Now that you have all the necessary operations available, are you able to determine the equivalent impedance between several couples of nodes?
Input
The input consists of several test-cases separated by an empty line. Each test-case starts with the number of nodes
N
(1<=N<=100), the number of bidirectional connections
C
(0<=C<=1000) and the number of equivalent impedances to compute
Z
(0<=Z<=10) on a line. Then follow
C
lines, each describing one bidirectional connection in the form
‘EndPoint_1’ ‘EndPoint_2’ ‘Impedance’
.
‘EndPoint_1’
and ‘EndPoint_2’
are in the range
1
to
N
and impedance has the format ‘
re im
’ where
re
and
im
designate the real and imaginary parts respectively, both being real numbers
d
such that 10
-3
< |d| < 10
3
. The next
Z
lines each hold two integers, the indices of the nodes between which you are to compute the equivalent impedance. Input terminates on a test-case
with N=C=Z=0
, which must not be evaluated.
Output
For each couple of endpoints, output the equivalent impedance in the form ‘
re im
’ where
re
and
im
designate the real and imaginary parts respectively. If the nodes are not connected, output ‘no connection’. Electrical engineers will consider your result as correct if the absolute error on the real and imaginary parts is below 10
-2
. Finish each test-case on a blank line.
Sample
Input:
5 10 3
3 1 12.317 -0.779
5 3 30.107 0.289
5 1 27.447 -22.649
4 2 15.351 24.371
5 5 19.63 -3.549
2 2 11.841 18.757
4 5 4.834 -16.542
3 5 5.022 -22.387
2 5 24.768 -22.356
5 2 27.351 12.053
1 2
2 3
3 3
10 10 4
9 8 6.36 17.411
1 3 27.596 -6.484
9 10 4.735 -8.282
8 8 6.901 27.939
8 4 14.894 3.729
5 4 14.311 -2.422
10 10 11.009 6.225
4 4 3.196 -32.703
10 9 15.282 -14.799
3 9 20.473 27.158
10 9
8 1
2 9
9 6
Output:
23.37 -7.26
19.61 -6.97
0.00 0.00
3.79 -5.46
54.43 38.09
no connection
no connection
Sample input 1 Sample input 2 | 32,139 |
Powered and Squared (CSQUARE)
Description
Marko is learning method of successive squaring so that he can calculate a^b mod m quickly. To give himself practice he wrote many tuples of a, b and m and went to school thinking that he will do it after school.
After school he found that tuples he wrote are modified by his little sister. His sister converted each b into base 3. Marko wrote everything in base 10.
Help Marko to do his excercise.
Input
First line of input contains a number T, number of test cases. Then T test cases follows each containing three numbers a (<=10^9), b and m (<=10^5) (a in base 10, b in base 3 and m in base 10). Number of digits in b will be less than 250.
Output
Output a number for each test case a^b mod m in base 10.
Sample
Input:
2
2 10 10
3 21101 19
Output:
8
3 | 32,140 |
Flowers (FLWRS)
Hanadi has
N
flower pots each with a unique flower. The pots are arranged along in a line.
One day, She decided to change their order under the condition that no two pots that were originally next to each other remain next to each other.
Task
Write a program that is given the number of pots, calculates the number of possible orders satisfying the condition
modulo a given integer M
.
Input
Line 1 contains the integer
N
, the number of flower pots.
Line 2 contains the integer
M
.
Output
A single line containing one integer between
0
and
M-1
(inclusive): the number of possible orders modulo
M
.
Constraints
1 ≤ N ≤ 2,000
2 ≤ M ≤ 1,000,000,000
Number of test cases is 28.
Example
Input:
5
11
Output:
3
Explanation
For 5 pots, there are 14 orders satisfying Hanadi's condition, assuming the original order of pots was "ABCDE", then the 14 possible orders are:
ACEBD
ADBEC
BDACE
BDAEC
BECAD
CADBE
CAEBD
CEADB
CEBDA
DACEB
DBEAC
DBECA
EBDAC
ECADB
14 modulo 11 = 3, so the answer is 3. | 32,141 |
Homo or Hetero (HOMO)
Consider a list of numbers with two operations:
insert number — adds the specified number to the end of the list.
delete number — removes the first occurrence of the specified number from the list. If the list does not contain the number specified, no changes are performed.
For example: the result of the insertion of a number 4 to the list [1, 2, 1] is the list [1, 2, 1, 4]. If we delete the number 1 from this list, we get the list [2, 1, 4], but if we delete the number 3 from the list [1, 2, 1, 4], the list stays unchanged.
The list is homogeneous if it contains at least two equal numbers and the list is heterogeneous if it contains at least two different numbers. For example: the list [2, 2] is homogeneous, the list [2, 1, 4] is heterogeneous, the list [1, 2, 1, 4] is both, and the empty list is neither homogeneous nor heterogeneous.
Write a program that handles a number of the operations insert and delete on the empty list and determines list’s homogeneity and heterogeneity after each operation.
Input
The first line of the input file contains an integer number n — the number of operations to handle (1 ≤ n ≤ 100 000).
Following n lines contain one operation description each. The operation description consists of a word “
insert
” or “
delete
”, followed by an integer number k — the operation argument (−10
9
≤ k ≤ 10
9
).
Output
For each operation output a line, containing a single word, describing the state of the list after the operation:
“
both
” — if the list is both homogeneous and heterogeneous.
“
homo
” — if the list is homogeneous, but not heterogeneous.
“
hetero
” — if the list is heterogeneous, but not homogeneous.
“
neither
” — if the list is neither homogeneous nor heterogeneous.
Example
Input:
11
insert 1
insert 2
insert 1
insert 4
delete 1
delete 3
delete 2
delete 1
insert 4
delete 4
delete 4
Output:
neither
hetero
both
both
hetero
hetero
hetero
neither
homo
neither
neither | 32,142 |
Chemistry (CHEM)
The story started some 5,000 years ago in Ancient Egypt, was continued by the Greeks and Arabs, reached France, Europe, and finally conquered the world. The studies on the compositions of waters, the humans’ greed for purified materials, millions of experiments and many brilliant minds made chemistry what it is today: No more the quest of the Philosopher’s stone, but the study of matter and the changes it undergoes.
There remain nevertheless still groups of stout-hearted followers of ancient believes, so-called alchemist. Keeping their research top-secret, they meet once a year for a conference where they share their recent findings. This year’s location is Lausanne and Extremely Purified Fluorescent Liquids (EPFL) is the topic. The idea is that the chemists brew together some new EPFLs. As we speak about state of the art EPFLs, it is necessary that certain chemists put their very specific knowledge together. Thus for a certain EPFL
E
1
, the presence of chemists
C
1
,
C
2
and
C
3
may be required. For another
E
2
, chemists
C
1
and
C
4
might be necessary.
Although chemists are generally very patient people, as their reactions might take long times, they get very impatient if they are to observe experiments in which they are not involved. As an example, chemist
C
4
would go crazy if he had to assist to the brewage of
E
1
. To ensure a pleasant stay in Lausanne to every chemist, you are to arrange their departure and arrival dates so that each chemist is available whenever his knowledge is required, but is not in Lausanne when other EPFLs are created.
To this purpose, you are given a schedule with ones and zeros. Each column stands for one EPFL, each row for one chemist. There is a 1 at position (
C
i
,E
i
) if chemist
C
i
is needed for EPFL
E
i
, and a zero otherwise. Your task boils now down on rearranging the columns in a way that all ones are consecutive in every line. For traditional reasons, the organizers’ EPFL is always brewed first and corresponds to the first column of the input schedule (
E
1
).
Input
The input consists of several test-cases separated by an empty line. Each test-case starts with the number of chemists
C
(1 ≤ C ≤ 400), followed by the number of EPFLs
E
(1 ≤ E ≤ 400). Then follow
C
lines of
E
characters, ‘1’ or ‘0’. You may assume that there exists exactly one order of EPFLs (initiated by
E
1
) that meets the above constraints. Input terminates on a test-case with
C=E=0
, which must not be processed.
Output
Print each output on a line by itself, which holds
E
numbers, corresponding to the initial position in the planning, arranged such that all chemists are available when necessary and away from Lausanne otherwise. (the first number must always be 1 as a tribute to the host).
Example
Input:
6 5
00010
01000
10101
10100
00011
00101
0 0
Output:
1 3 5 4 2 | 32,143 |
Environmental Engineering (ENVIRON)
One of the major challenges for environmental engineers in the future will be the overall scarcity of potable water. Not only vegetation and wildlife are fundamentally dependent upon adequate freshwater resources, but also humans. Several desalination processes were developed to make sea water drinkable.
Nonetheless, the water distribution is not uniform on planet, and so some regions are lacking water while others possess it on excess. The International Committee for Precious Consumables (ICPC) worked out an ambitious project fostering the uniform distribution of water on Earth (a perfect ball). The richest and poorest regions in terms of water resources were found to lie equidistantly distributed along a circle of maximum length around the Earth (i.e. the centre of the Earth is also the centre of this circle). So the idea came to construct gigantic pipelines that can transport water along this circle.
Each pipeline has two terminals, starting at a location with water abundance and ending in a region with water scarcity. As drilling the Earth on so long distances is not a reasonable option, all pipelines will be above Earth. Further are there dedicated ducts for the pipelines at different heights. That is, a pipeline grows vertically into the sky until one of the allowed heights is reached, makes a 90° angle, and follows the duct at constant height until it is above the depletion region, where it forms another 90° angle to descent vertically to ground.
As all pipelines’ projection to ground must follow the same circle, the ICPC faces a serious problem. They must make sure that no pipelines cross each other in this 2D plane! Further they are concerned about the total length of the pipes, which they’d like to minimize. Your task is to calculate the minimal total length of all the pipes, knowing that the allowed duct heights are non-zero integer multiples of the distance between two adjacent locations (measured along the circle on surface level), which for our purpose has a value of 1.
INPUT
The input consists of several test-cases separated by an empty line. Each test-case starts with the number of locations
N (0<=N<=500)
, followed by a line containing
N
numbers (‘0’ or ‘1’) and describing the locations along the circle. A ‘0’ stands for a location with water depletion, a ‘1’ for a region with water abundance. You may safely assume that there are as many ‘0’ as ‘1’. Input terminates on a test-case
with N=0
, which must not be evaluated.
OUTPUT
For each test-case, output the minimum total length (to a precision of 10
-2
) of the pipes so that each abundance region connects to exactly one depletion region.
SAMPLE INPUT
4
1 0 0 1
8
1 1 1 1 0 0 0 0
0
SAMPLE OUTPUT
9.14
31.00
Sample input 1 Sample input 2 A larger test-case | 32,144 |
Encryption (CENCRY)
Marko is going to write a secret letter to a friend. He thought it is better to encrypt letter so that no other person can read it. After long thought he came up with an encryption scheme which was lame but he thought it will work anyways.
To encrypt a text he first wrote two infinite strings of characters first string consists only of vowels and second string consists of consonants only.
aeiouaeiouaeiouaeiouaeiou....................
bcdfghjklmnpqrstvwxyzbcdfghjklmnpqrstvwxyz...
Following is the scheme for encryption :
let c be any character to be encrypted.
let k be the count of number of times c character occurred in text to be encrypted until now.
first find which of two infinite string contains that character.
then look for kth occurrence of that character in that string.
replace character c by corresponding character in second string.
For example, encrypted text of "baax" will be "abho".
Input
First line of input will contains t, number of test cases. Then t test case follows each test case in a line. Each test case will be a string of small Latin alphabets. Length of string will be less than 5*10^4
Output
For each test case print encrypted text.
Sample :
Input:
2
baax
aaa
Output:
abho
bhn | 32,145 |
Civil Engineering (CIVIL)
Civil engineers are people who build impressive structures from concrete and steel. Throughout the world, sky scrapers get ever higher, bridges get ever wider, and tunnels get ever longer. Most recently, the Gotthard Base Tunnel just pushed the limits a bit further...
In this task, you take the role of a civil engineer who is to build a tunnel through a mountain. Unfortunately, you have a very limited budget, and must construct the cheapest possible tunnel.
Because engineers have a habit of simplifying things, we will model the mountain and the tunnel using basic geometric shapes. First of all, consider that the earth is flat, and two-dimensional. On this flat surface stands a mountain of height h and width w. Each side of the mountain is parabolic (i.e. satisfies y = ax² + bx + c for some a, b, c). You also know that the base of the mountain is smooth, which means that its steepness at the base is zero.
The tunnel is modeled as a horizontal line through the mountain. The best possible tunnel is the one which minimizes construction cost. This cost is proportional to the length of the road which leads to the tunnel, plus the length of the tunnel itself. Consider that each meter of the tunnel is a factor f times as expensive as a meter of road.
Input
The input file consists of several test cases. Each case is given on a line by itself and consists of the three numbers h, w and f, separated by a space. All these are strictly positive floating point numbers. The input file ends with a test case where all numbers are zero (which must not be processed).
Output
Print for each test case a single number, the optimal height t of the tunnel. Always print three digits after the decimal point. You may assume that it is always cheaper to build some tunnel than to drive over the top of the mountain.
Example
Input:
1 2 1.5
9033.66 29752.4 1.56382
0 0 0
Output:
0.313
8852.956 | 32,146 |
Jumping Zippy (JZPCIR)
Jumping Zippy likes to jump. He jumps every day and feels boring. Then he think of a new way to jump. He jumps on a big round plaza. The plaza is divided into n sectors numbered clockwise from 0 to n-1. Firstly, he stands on sector 0. Each time, when he is stand on sector x, he can jump to sector (x-2)%n, (x-1)%n, (x+1)%n or (x+2)%n. His goal is to jump to each sector exactly once and jump back to sector 0 at last. And for the first jump, he never jumps to sector n-1 or sector n-2. He wants to find the number of different ways in which he can complete his goal.
Input
First line is a number t, which is the number of test cases. (1 ≤ t ≤ 1000)
Then following t lines, each line contains a integer n, which is the number of sectors. (5 ≤ n ≤ 10
18
)
Output
For each query n, output a line which contains one integer, the number of different ways Zippy can complete his goal in, modulo 10
9
+9.
Example
Input:
5
5
6
7
8
9
Output:
12
16
23
29
41 | 32,147 |
Number of common divisors (COMDIV)
You will be given T (T ≤ 10
6
) pairs of numbers. All you have to tell is the number of common divisors between the two numbers in each pair.
Input
First line of input: T (Number of test cases)
In next T lines, each have one pair A B (0 < A, B ≤ 10
6
)
Output
One integer describing number of common divisors between two numbers.
Example
Input:
3
100000 100000
12 24
747794 238336
Output:
36
6
2 | 32,148 |
Happy Numbers I (HPYNOS)
The process of “
breaking
” an integer is defined as summing the squares of its digits. For example, the result of breaking the integer
125
is (
1
2
+
2
2
+
5
2
) =
30
. An integer
N
is
happy
if after “
breaking
” it repeatedly the result reaches 1. If the result never reaches 1 no matter how many times the “
breaking
” is repeated, then N is not a happy number.
TASK
Write a program that given an integer N, determines whether it is a happy number or not.
CONSTRAINTS
2 ≤
N
≤ 2,147,483,647
Input
A single line containing a single integer
N
.
Output
A single line containing a single integer
T
which is the number of times the process had to be done to determine that N is happy, or
-1
if
N
is not happy.
Example
Input:
19
Output:
4
1) 19 : 1
2
+ 9
2
= 82
2) 82 : 82 + 2
2
= 68
3) 68 : 6
2
+ 8
2
= 100
4) 100 : 1
2
+ 0
2
+ 0
2
= 1
The solution is 4 because we discovered that the integer 19 is happy after we repeated the process 4 times.
Input:
204
Output:
-1
204 –>
20
–> 4 –> 16 –> 37 –> 58 –> 89 –> 145 –> 42 –>
20
–> 4 –> 16 –> 37 –> 58 –> 89 –> 145 ……
204
is not a happy number because after breaking it several times the results start repeating so we can deduce that if we continue breaking it, the result will never reach 1.
Number of input files is
32
.
Don't use pre-calculated values (Don't Cheat)!!! | 32,149 |
Twist and whirl - want to cheat (TWIST)
English
Vietnamese
A well-known sharper I*** invented a new way to swindle people. There are N thimbles on the table, and there is a small ball with the number under each of them. The balls are numbered with numbers from 1 to N from left to right. At one operation I*** changes the order of some subsequence of successive thimbles to the opposite. Your task is to find the order of numbers (from left to right) in sequence after all of his manipulations. The total number of manipulations is M.
Input
The first line contains two integer numbers N and M (1 <= N <= 100000, 1 <= M <= 100000) separated by a space. Each of the following M lines contains two integer numbers Pi, Qi (1 <= Pi <= Qi <= N) - positions of the leftmost and rightmost thimbles in rotated sequence.
Output
Output the sequence of N numbers - the numbers of balls in the thimbles from left to right.
Sample
Input
5 2
1 3
4 5
Output
3 2 1 5 4
Input
5 2
1 4
2 5
Output
4 5 1 2 3
Note: A naive solution would result in TLE. Have fun! | 32,150 |
Escape (BOI7ESC)
A group of war prisoners are trying to escape from a prison. They have thoroughly planned the escape from the prison itself, and after that they hope to find shelter in a nearby village. However, the village (marked as B, see picture below) and the prison (marked as A) are separated by a canyon which is also guarded by soldiers. These soldiers sit in their pickets and rarely walk; the range of view of each soldier is limited to exactly 100 meters. Thus, depending on the locations of soldiers, it may be possible to pass the canyon safely, keeping the distance to the closest soldier strictly larger than 100 meters at any moment.
You are to write a program which, given the width and the length of the canyon and the coordinates of every soldier in the canyon, and assuming that soldiers do not change their locations, first determines whether prisoners can pass the canyon unnoticed. If this is impossible then the prisoners (having seen enough violence) would like to know the minimum number of soldiers that have to be eliminated in order to pass the canyon safely. A soldier may be eliminated regardless of whether he is visible to any other soldier or not.
Input
The first line contains three integers L, W , and N – the length and the width of the canyon, and the number of soldiers, respectively. Each of the following N lines contains a pair of integers Xi and Yi – the coordinates of i-th soldier in the canyon (0 ≤ Xi ≤ L, 0 ≤ Yi ≤ W ). The coordinates are given in meters, relative to the canyon: the southwestern corner of the canyon has coordinates (0, 0), and the northeastern corner of the canyon has coordinates (L, W ), as seen in the picture above.
Note that passing the canyon may start at coordinate (0, ys ) for any 0 ≤ ys ≤ W and end at coordinate (L, ye ) for any 0 ≤ ye ≤ W . Neither ys nor ye need to be integer.
Output
In the first and only line of the output file the program should print the minimum number of soldiers that have to be eliminated in order for the prisoners to pass the canyon safely. If the prisoners can escape without any elimination, the program should print 0 (zero).
Constraints
1 ≤ W ≤ 50,000 1 ≤ L ≤ 50,000
1 ≤ N ≤ 250
Example
Input:
130 340 5
10 50
130 130
70 170
0 180
60 260
Output:
1 | 32,151 |
Sound (BOI7SOU)
In digital recording, sound is described by a sequence of numbers representing the air pressure, measured at a rapid rate with a fixed time interval between successive measurements. Each value in the sequence is called a sample. An important step in many voice-processing tasks is breaking the recorded sound into chunks of non-silence separated by silence. To avoid accidentally breaking the recording into too few or too many pieces, the silence is often defined as a sequence of m samples where the difference between the lowest and the highest value does not exceed a certain threshold c. Write a program to detect silence in a given recording of n samples according to the given parameter values m and c.
Input
The first line of the file contains three integers: n (1 ≤ n ≤ 1,000,000), the number of samples in the recording; m (1 ≤ m ≤ 10,000), the required length of the silence; and c (0 ≤ c ≤ 10,000), the maximal noise level allowed within silence. The second line of the file contains n integers ai (0 ≤ ai ≤ 1,000,000 for 1 ≤ i ≤ n), separated by single spaces: the samples in the recording.
Output
The file should list all values of i such that max(a[i ... i + m − 1]) − min(a[i ... i + m − 1]) ≤ c. The values should be listed in increasing order, each on a separate line. If there is no silence in the input file, write NONE on the first and only line of the output file.
Example
Input:
7 2 0
0 1 1 2 3 2 2
Output:
2
6 | 32,152 |
Fence (BOI7FEN)
Leopold is indeed a lucky fellow. He just won a huge estate in the lottery. The estate contains several grand buildings in addition to the main mansion, in which he intends to live from now on. However, the estate lacks a fence protecting the premises from trespassers, which concerns Leopold to a great extent. He decides to build a fence, but unfortunately he cannot afford to put it round all of his newly acquired land. After some thinking, he decides it is sufficient to have a fence that encloses the main mansion, except for one important restriction: the fence must not lie too close to any of the buildings.
To be precise, seen from above, each building is enclosed in a surrounding forbidden rectangle within which no part of the fence may lie. The rectangles’ sides are parallel to the x- and y-axis. Each part of the fence must also be parallel either to the x-axis or the y-axis.
Figure 5.1: The main mansion (black) and three other buildings with surrounding forbidden rectangles. The thick black line shows a shortest allowed fence enclosing the main mansion.
Input
The first line of the input file contains a positive integer m (1 ≤ m ≤ 100), the number of buildings of the estate. Then follow m lines each describing a forbidden rectangle enclosing a building. Each row contains four space-separated integers tx, ty, bx, and by, where (tx, ty) are the coordinates of the upper left corner and (bx, by) the coordinates of the bottom right corner of the rectangle. All coordinates obey 0 ≤ tx < bx ≤ 10,000 and 0 ≤ ty < by ≤ 10,000. The first rectangle is the forbidden rectangle enclosing the main mansion.
Output
Contains one line with a single positive integer equal to the minimum length of any allowed fence enclosing the main mansion.
Example
Input:
4
8 4 13 8
2 1 6 7
4 7 9 11
14 7 19 11
Output:
32 | 32,153 |
Sequence (BOI7SEQ)
We are given a sequence a1 ... an. We can manipulate this sequence using the operation reduce(i), which replaces elements ai and ai+1 with a single element max(ai, ai+1), resulting in a new shorter sequence. The cost of this operation is max(ai, ai+1). After n−1 operations reduce, we obtain a sequence of length 1. Our task is to compute the cost of the optimal reducing scheme, i.e. the sequence of reduce operations with minimal cost leading to a sequence of length 1.
Input
The first line contains n (1 ≤ n ≤ 1,000,000), the length of the sequence. The following n lines contain one integer ai, the elements of the sequence (0 ≤ ai ≤ 1,000,000,000).
Output
In the first and only line of the output print the minimal cost of reducing the sequence to a single element.
Example
Input:
3
1
2
3
Output:
5 | 32,154 |
Onotole needs your help (OLOLO)
Onotole has a lot of pyani. Each pyani has a number, writing on it. Pyanis with equal numbers are indistinguishable. Onotole knows everything, so, he knows that each pyani appeared twice, and only one pyani is unique. He wants to get вздръжни эффект, and he needs the unique pyani. Given the list of pyanis denote which one of them appeared once (it is guaranteed that other pyanis appeared twice).
Input
First line of input contains number of pyanis N ≤ 500 000. Next N lines contain a single positive integer 1 ≤ Pi ≤ 10
9
.
Output
Output one positive integer on pyani, which appeared once.
Example
Input:
3
1
8
1
Output:
8
Onotole has found not optimal AC algorithms, so all solutions will be rejudged. He is watching you. | 32,155 |
Bingo! (MBINGO)
Albert, Charles and Mary invented a new version of the classical game Bingo. In traditional Bingo the game is presided over by a non-player known as the caller. At the beginning of the game each player is given a card containing a unique combination of numbers from 0 to N arranged in columns and rows. The caller has a bag containing N + 1 balls, numbered from 0 to N. On each turn, the caller randomly selects a ball from the bag, announces the number of the drawn ball to the players, and sets the ball aside so that it cannot be selected again. Each player searches his card for the called number and marks it if he finds it. The first player who marks a complete pre-announced pattern on the card (for example, a full horizontal line) wins a prize.
In the Albert-Charles-Mary version, on each turn, the caller draws a first ball, returns it to the bag, draws a second ball, returns it to the bag, and then calls out the absolute difference between the two ball numbers. To generate even more excitement, before the game started a possibly empty subset of balls is removed from the bag, in such a way that at least two balls remain there. They would like to know if every number from 0 to N may still be called out with the new drawing method considering the balls that were left in the bag.
Input
Each test case is given using exactly two lines. The first line contains two integers N and B. The meaning of N was described above (1 ≤ N ≤ 90), while B represents the number of balls which remained in the bag (2 ≤ B ≤ N + 1). The second line contains B distinct integers bi, indicating the balls which remained in the bag (0 ≤ bi ≤ N). The last test case is followed by a line containing two zeros.
Output
For each test case output a single line containing a single uppercase 'Y' if is possible to call out every number from 0 to N, inclusive, or a single uppercase 'N' otherwise.
Sample
Input
6 7
2 1 3 4 0 6 5
5 4
5 3 0 1
5 3
1 5 0
0 0
Output
Y
Y
N | 32,156 |
Cocircular Points (MCOCIR)
You probably know what a set of collinear points is: a set of points such that there exists a straight line that passes through all of them. A set of cocircular points is defined in the same fashion, but instead of a straight line, we ask that there is a circle such that every point of the set lies over its perimeter.
The International Collinear Points Centre (ICPC) has assigned you the following task: given a set of points, calculate the size of the larger subset of cocircular points.
Input
Each test case is given using several lines. The first line contains an integer N representing the number of points in the set (1 ≤ N ≤ 100). Each of the next N lines contains two integers X and Y representing the coordinates of a point of the set (−10
4
≤ X, Y ≤ 10
4
). Within each test case, no two points have the same location.
The last test case is followed by a line containing one zero.
Output
For each test case output a single line with a single integer representing the number of points in one of the largest subsets of the input that are cocircular.
Sample
Input
7
-10 0
0 -10
10 0
0 10
-20 10
-10 20
-2 4
4
-10000 10000
10000 10000
10000 -10000
-10000 -9999
3
-1 0
0 0
1 0
0
Output
5
3
2 | 32,157 |
Happy Numbers II (HPYNOSII)
The process of “
breaking
” an integer is defined as summing the squares of its digits. For example, the result of breaking the integer
125
is (
1
2
+
2
2
+
5
2
) =
30
. An integer
N
is
happy
if after “
breaking
” it repeatedly the result reaches 1. If the result never reaches 1 no matter how many times the “
breaking
” is repeated, then N is not a happy number.
Task
Write a program that given an integer
T
(number of test cases) and
T
integers, determines for each number whether it is a happy number or not.
Constraints
1 ≤ T ≤ 1,080,000
2 ≤ N ≤ 2,147,483,647 (number for determining whether it is happy or not)
Input
The first line contains an integer
T
.
Next T lines contain an integer
N
for detemining whether it is happy or not.
Output
T lines containing a single integer
N
which is the number of times the process had to be done to determine that N is happy, or
-1
if
N
is not happy.
Example
Input:
2
19
204
Output:
4
-1
Explanation
First test case
:
19 : 1
2
+ 9
2
= 82
82 : 82 + 2
2
= 68
68 : 6
2
+ 8
2
= 100
100 : 1
2
+ 0
2
+ 0
2
= 1
The solution for 19 is 4 because we discovered that the integer 19 is happy after we repeated the process 4 times.
Second test case
:
204 →
20
→ 4 → 16 → 37 → 58 → 89 → 145 → 42 →
20
→ 4 → 16 → 37 → 58 → 89 → 145 ...
204
is not a happy number because after breaking it several times the results start repeating so we can deduce that if we continue breaking it, the result will never reach 1. | 32,158 |
Flowers Flourish from France (MFLAR10)
Fiona has always loved poetry, and recently she discovered a fascinating poetical form. Tautograms are a special case alliteration, which is the occurrence of the same letter at the beginning of adjacent words. In particular, a sentence is a tautogram if all of its words start with the same letter.
For instance, the following sentences are tautograms:
Flowers Flourish from France
Sam Simmonds speaks softly
Peter pIckEd pePPers
truly tautograms triumph
Fiona wants to dazzle her boyfriend with a romantic letter full of this kind of sentences. Please help Fiona to check if each sentence she wrote down is a tautogram or not.
Input
Each test case is given in a single line that contains a sentence. A sentence consists of a sequence of at most 50 words separated by single spaces. A word is a sequence of at most 20 contiguous uppercase and lowercase letters from the English alphabet. A word contains at least one letter and a sentence contains at least one word.
The last test case is followed by a line containing only a single character ‘
*
’ (asterisk).
Output
For each test case output a single line containing an uppercase ‘
Y
’ if the sentence is a tautogram, or an uppercase ‘
N
’ otherwise.
Example
Sample input:
Flowers Flourish from France
Sam Simmonds speaks softly
Peter pIckEd pePPers
truly tautograms triumph
this is NOT a tautogram
*
Sample Output:
Y
Y
Y
Y
N | 32,159 |
Growing Strings (MGLAR10)
Gene and Gina have a particular kind of farm. Instead of growing animals and vegetables, as it is usually the case in regular farms, they grow strings. A string is a sequence of characters. Strings have the particularity that, as they grow, they add characters to the left and/or to the right of themselves, but they never lose characters, nor insert new characters in the middle.
Gene and Gina have a collection of photos of some strings at different times during their growth. The problem is that the collection is not annotated, so they forgot to which string each photo belongs to. They want to put together a wall to illustrate strings growing procedures, but they need your help to find an appropriate sequence of photos.
Each photo illustrates a string. The sequence of photos must be such that if si comes immediately before si+1 in the sequence, then si+1 is a string that may have grown from si (i.e., si appears as a consecutive substring of si+1). Also, they do not want to use repeated pictures, so all strings in the sequence must be different.
Given a set of strings representing all available photos, your job is to calculate the size of the largest sequence they can produce following the guidelines above.
Input
Each test case is given using several lines. The first line contains an integer N representing the number of strings in the set (1 ≤ N ≤ 10
4
). Each of the following N lines contains a different non-empty string of at most 1000 lowercase letters of the English alphabet. Within each test case, the sum of the lengths of all strings is at most 10
6
.
The last test case is followed by a line containing one zero.
Output
For each test case output a single line with a single integer representing the size of the largest sequence of photos that can be produced.
Example
Input:
6
plant
ant
cant
decant
deca
an
2
supercalifragilisticexpialidocious
rag
0
Output:
4
2 | 32,160 |
Hyperactive Girl (MHLAR10)
Helen is a hyperactive girl. She wants to schedule her activities so that at any moment of the day there is at least one thing she can do. She does not care if her activities overlap in time, as long as every moment of her day has an activity scheduled.
Helen divided the day in a particular way. The day starts at time 0 and finishes at time M. Each moment of the day is represented by a real number between 0 and M, inclusive. Helen made a list of all possible activities, with their start and finish times. Now she must decide which subset of activities to schedule.
If an activity starts at time S and finishes at time F, then we say that it covers all moments between S and F, inclusive. Helen does not want to waste any activities, so she will only choose minimal subsets of activities that cover the day to be scheduled. A subset of activities is a minimal subset that covers the day if and only if:
every moment of the day is covered by at least one activity of the subset; and
removing any of the activities from the subset would leave at least one moment of the day uncovered.
Note that some moments of the day may be covered by more than one activity.
Given the list of possible activities for one day, you must help Helen by determining how many distinct minimal subsets cover the day.
Input
Each test case is given using several lines. The first line contains two integers M and N, representing respectively the highest value for a moment in the day (1 ≤ M ≤ 10
9
) and the number of possible activities for the day (1 ≤ N ≤ 100). Each of the next N lines describes one possible activity and contains two integers S and F, representing respectively the start and finish times of the activity (0 ≤ S < F ≤ M).
The last test case is followed by a line containing two zeros.
Output
For each test case output a single line with a single integer representing the number of minimal subsets that cover the day. To make your life easier, print the remainder of dividing the solution by 10
8
.
Sample
Input:
8 7
0 3
2 5
5 8
1 3
3 6
4 6
0 2
1 1
0 1
2 1
0 1
0 0
Output:
4
1
0 | 32,161 |
Kids’ Wishes (MKLAR10)
Kevin is a kid. He has lunch at school together with many more kids. They use to go outdoors and have lunch sitting on the ground. They love to form a big circle in which each kid has exactly two neighbors, one on the left and one on the right. Sometimes the teacher has problems arranging the circle because some kids wish to sit down next to other kids. Each kid may wish to sit down next to at most two other kids, because each kid has just two neighbors in the circle. The teacher wants to know whether it is possible to arrange the circle in such a way that all kids' wishes are satisfied. You clean up the place when the lunch ends. Since you want to finish your work as early as possible, help the teacher in answering that question.
Input
Each test case is given using several lines. The first line contains two integers K and W representing respectively the number of kids (3 ≤ K ≤ 10
9
) and the number of wishes (0 ≤ W ≤ 10
5
). Kids are identified with numbers between 1 and K. Each of the next W lines describes a different wish using two distinct integers A and B (1 ≤ A, B ≤ K); these values represent that kid A wishes to sit down next to kid B. Each kid has at most two wishes.
The last test case is followed by a line containing two zeros.
Output
For each test case output a single line containing an uppercase 'Y' if it is possible to arrange a circle in such a way that all kids' wishes are satisfied, or an uppercase 'N' otherwise.
Sample
input
4 3
2 3
1 3
2 1
1000000000 0
3 6
3 2
2 1
1 2
1 3
2 3
3 1
0 0
output
N
Y
Y | 32,162 |
Jollo (MJLAR10)
Jollo is a simple card game which the children from Logonia love to play. It is played between two players with a normal deck of 52 cards. In the game, cards are ordered according to their rank and suit, forming a sequence of 52 distinct values.
The game is composed of three rounds, played in a best-of-three series (a player must win two rounds to win the game). At the beginning of the game the deck is shuffled and each player is given a hand of three cards. In each round the players show one card to each other and the player with the highest card wins the round. The cards shown in a round are discarded (i.e., they cannot be shown again).
The King’s son loves to play the game. But he is not very smart, losing frequently to his little sister. And when he loses, he cries so loud no one can stand it. The servant who deals the cards to the Prince and his sister is afraid he will be sent to prison if the Prince continues to lose. The servant is allowed to see every card he deals, and after dealing five cards (three to the Princess and two to the Prince) he wants to know which is the lowest card he should deal to the Prince so that there is no chance he will lose the game, no matter how badly he plays.
Input
Each test case is given in a single line that contains five distinct integers A, B, C, X and Y, describing the cards dealt to the players. The first three cards are given to the Princess (1 ≤ A, B, C ≤ 52) and the last two cards are given to the Prince (1 ≤ X, Y ≤ 52). The last test case is followed by a line containing five zeros.
Output
For each test case output a single line. If there exists a card that will make the Prince win the game no matter how badly he plays, you must print the lowest such a card. Otherwise, print -1.
Example
input
28 51 29 50 52
50 26 19 10 27
10 20 30 24 26
46 48 49 47 50
0 0 0 0 0
output
30
-1
21
51 | 32,163 |
Electric Needs (MELAR10)
You are going to construct a new factory in your city. Since you have major electric needs, having the factory placed close to a power plant is important. You want to build a prioritized list of possible locations.
The area in which the factory needs to be located can be represented as a rectangular grid of N rows and M columns of cells. Some of those cells contain a power plant. The new factory occupies exactly one cell, and can be placed in any empty cell (i.e., any cell that does not contain a power plant).
Numbering rows from 1 to N and columns from 1 to M, the location of a cell can be described by two integers. Cell (i, j) is the cell in row i and column j. The distance between cell (i0, j0) and cell (i1, j1) is max(|i0 - i1|, |j0 - j1|) where |x| represents the absolute value of x. The electric priority of a location is its minimum distance to a power plant.
With this in mind, you will number all possible locations with consecutive integers starting from 1. You will do it in ascending order of electric priority. Among locations with the same electric priority, you will number them in ascending order of their row numbers. Among locations with the same electric priority and row number, you will list them in ascending order of column numbers.
In the following picture you can see a 4 × 7 grid. Black cells are the cells in which there is a power plant. Dark gray cells have an electric priority of 1, light gray cells an electric priority of 2 and white cells an electric priority of 3. The number inside each cell is the number assigned by you to the location.
You will receive several queries about the prioritized list built. In each query you will be given a number representing a position in the prioritized list and you have to calculate which location was assigned the given position.
Input
Each test case is given using several lines. The first line contains three integers N, M and P, representing the number of rows and columns of the grid (1 ≤ N, M ≤ 10^9) and the number of existing power plants (1 ≤ P ≤ 20). Each of the next P lines contains two integers R and C representing the row and column numbers of the location of a power plant (1 ≤ R ≤ N and 1 ≤ C ≤ M). Within each test case, all power plant locations are different. The next line contains a single integer Q representing the number of queries (1 ≤ Q ≤ 50). Then follows a line with Q integers p1, ..., pQ representing positions in the prioritized list (1 ≤ pi ≤ N×M−P).
The last test case is followed by a line containing three zeros.
Output
For each test case output Q + 1 lines. Line i of the first Q lines must contain two integers representing the row and column numbers of the location that was assigned number pi. The last line for each test case must contain a single character ‘-’ (hyphen).
Sample
Input
4 7 2
2 5
4 4
6
1 6 11 16 21 26
1000000000 1000000000 1
1 1
1
999999999999999999
0 0 0
Output
1 4
3 3
4 5
2 7
4 7
4 1
-
1000000000 1000000000
- | 32,164 |
Ingenious Metro (MILAR10)
The King of Logonia will inaugurate soon a new and revolutionary metro, based on an invention of the Royal Engineers, which allows teletransportation.
The new metro consists of a very long tunnel with a station at each kilometer. There are also T teletransporters, which are located at some of the stations. In each station there is a keyboard with T keys, where each key corresponds to one teletransporter. The figure below illustrates a metro system with three teletransporters, located in stations marked A, B and C.
The metro works as follows. The user goes in a station (the start station) and presses the key corresponding to the teletransporter he wants to use. The user is then teletransported to the station which is at the same distance from the teletransporter as the start station, but on the opposite side relative to the teletransporter. More precisely, if the location of the start station is i and the user presses the key corresponding to the teletransporter located in position j, he will be taken to the station located at position 2 × j − i. For example, if the user is in station 6 and wants to go to station −2, he can use the teletransporter C (goes from 6 to 10) and then the teletransporter A (goes from 10 to −2).
The King, however, knows that it is possible that there is no sequence of teletransporters that will take the user from a given station X to a given station Y. To avoid that the users keep trying to go where they cannot go, he wants to make a program available in the Internet to help users. The King wants you to write a program which, given the position of each teletransporter, answers a series of queries. For each query the start and the destination stations are given, and your program must determine if it is possible for the user to go from start to destination.
Input
Each test case is given using several lines. The first line contains two integers T and Q indicating respectively the number of teletransporters (1 ≤ T ≤ 10^5) and the number of queries (1 ≤ Q ≤ 10). The second line contains T different integers ti indicating the position of the teletransporters (−10^7 ≤ ti ≤ 10^7). Each of the Q following lines describes a query and contains two distinct integers S and D indicating the position of the start and destination stations (−10^7 ≤ S, D ≤ 10^7).
The last test case is followed by a line containing two zeros.
Output
For each test case output a single line containing the answers to the Q queries, in the same order that the queries were given in the input. For each query you must output an uppercase ‘Y’ if it is possible to reach the destination station from the start station using the metro, or an uppercase ‘N’ otherwise.
Sample
Input:
1 1
-2
-6 2
5 2
10 20 30 40 50
10 15
20 40
5 3
0 5 -3 -8 4
-1 499
4 237
-1 -591
0 0
Output:
Y
N Y
Y N Y | 32,165 |
Help a researcher (HLPRSRCH)
A scientist was doing a research on some kinds of bacteria. He found that the kinds, he examined, take
T
unit of time to grow (be mature) enough in order to can reproduce.
Also he found that each type reproduces with a constant rate which is
N
new bacteria every
F
unit of time, (where
F
=
T
).
Task
write a program that reads
L
(number of bacteria (at the beginning of the experiment)),
M
(number of mature bacteria of them),
T
(time of each to get mature which is also the time needed for reproducing
N
new bacteria),
N
(rate of reproducing per
T
unit of time) and
Z
(period elapsed by the experiment).
Calculate the number of bacteria after
Z
unit of time. Regardless of life-span.
Constraints
1 ≤
L
≤ 5 number of bacteria (at the beginning of the experiment).
0 ≤
M
≤
L
number of mature bacteria.
1 ≤
T
≤ 5 time of each to get mature which is also the time needed for reproducing
N
new bacteria.
1 ≤
N
≤ 50 rate of reproducing per
T
unit of time.
1 ≤
Z/T
≤ 4,300 period elapsed by the experiment.
Note:
Z
is always divisible by
T
.
Input
L
(number of bacteria (at the beginning of the experiment))
M
(number of mature bacteria of them)
T
(time of each to get mature which is also the time needed for reproducing
N
new bacteria)
N
(rate of reproducing per
T
unit of time)
Z
(period elapsed by the experiment)
Output
the number of bacteria after
Z
unit of time. Regardless of life-span.
Example
Input:
3
2
3
1
3
Output:
5
Input
2
0
1
1
100
Output:
1146295688027634168202
Explanation for Test Case 1
The experiment begins with 2 mature bacteria and one immature bacterium.
For each of the mature bacteria reproduces after 3 units of time.
Then th total becomes 4 - as each one got a new one (2*2).
But for the immature bacterium after 3 units of time, it only become mature.
After all of that the experiment finishes with 5 bacteria. | 32,166 |
National Treasure (ANARC09J)
The great hall of the national museum has been robbed few times recently. Everyone is now worried about the security of the treasures on display. To help secure the hall, the museum contracted with a private security company to provide additional guards to stay in the great hall and keep an eye on the ancient artefacts. The museum would like to hire the minimum number of additional guards so that the great hall is secured. The great hall is represented as a two dimensional grid of R × C cells. Some cells are already occupied with the museum’s guards. All remaining cells are occupied by artefacts of different types (statues, sculptures, . . . etc.) which can be replaced by new hired guards. For each artefact, few other cells in the hall are identified as critical points of the artefact depending on the artefact value, type of vault it is kept inside, and few other factors. In other words, if this artefact is going to stay in the hall then all of its critical points must have guards standing on them. A guard standing in a critical position of multiple artefacts can keep an eye on them all. A guard, however, can not stand in a cell which contains an artefact (instead, you may remove the artefact to allow the guard to stay there). Also you can not remove an artefact and leave the space free (you can only replace an artefact with a new hired guard). Surveying all the artefacts in the great hall you figured out that the critical points of any artefact (marked by a symbol) are always a subset of the 12 neighboring cells as shown in the grid below.
Accordingly, the type of an artefact can be specified as a non-negative integer where the i-th bit is 1 only if critical point number i from the picture above is a critical point of that artefact. For example an artefact of type 595 (in binary 1001010011) can be pictured as shown in the figure below. Note that bits are numbered from right to left (the right-most bit is bit number 1.) If a critical point of an artefact lies outside the hall grid then it is considered secure.
You are given the layout of the great hall and are asked to find the minimum number of additional guards to hire such that all remaining artifacts are secured.
Input
Your program will be tested on one or more test cases. Each test case is specified using R+1 lines. The first line specifies two integers (1 ≤ R, C ≤ 50) which are the dimensions of the museum hall. The next R lines contain C integers separated by one or more spaces. The j-th integer of the i-th row is -1 if cell (i, j) already contains one of the museum’s guards, otherwise it contains an integer (0 ≤ T < 2
12
) representing the type of the artifact in that cell. The last line of the input file has two zeros.
Output
For each test case, print the following line:
k. G
Where k is the test case number (starting at one,) and G is the minimum number of additional guards to hire such that all remaining artifacts are secured.
Example
Input:
1 3
512 -1 2048
2 3
512 2560 2048
512 2560 2048
0 0
Output:
1. 0
2. 2 | 32,167 |
Land Division (ANARC09H)
The king of the Far, Far Away Kingdom has passed-away and the kingdom must be split amongst his K sons. The kingdom, which can be drawn on a rectangular map, consists of N cities. To divide the land, they will draw K − 1 straight segments on the map, all of them parallel to either the vertical or the horizontal axis of the map. This divides the map into exactly K rectangles, all having equal heights (if the dividing lines where vertical), or equal widths (if the dividing lines where horizontal). No segment should pass through any of the cities. Each son will then be assigned one random region out of the K regions and the cities inside that region will be his share. Of course, they want the division to be as fair as possible: theoretically, in the fairest division, each son should get N/K cities (we’ll call this value the baseline), but since the baseline isn’t always a whole number, each of the sons wants to be as close as possible to the baseline. We will calculate the unfairness of each son as the absolute difference between the number of cities assigned to him and the baseline. The fairest division is the one that minimizes the average unfairness of all the sons.
Consider the example above with 3 sons and 6 cities (so the baseline is 6/3 = 2.0) Figure (a) is the original map. Figure (b) shows a non-optimal division (the dashed lines are the 2 dividing lines.) In this case, the middle region contains 3 cities (unfairness of |3 − 2| = 1), the left region contains 1 city (unfairness of |1 − 2| = 1), while the right region contains 2 cities (perfectly fair, unfairness of 0), so the average unfairness is 2/3. Figure (c) shows the optimal division since all three regions contain the same number of cities for an average unfairness of 0. Write a program to determine the fairest land division for a given kingdom.
Input
Your program will be tested on one or more test cases. Each test case is described on N + 1 lines. The first line of each test case specifies two positive integers: (N ≤ 100, 000) and (K ≤ 10) where N is the number of cities and K is number of children. Note that K ≤ N . N lines follows, each describing the coordinates of a city by specifying two integers (x, y) where 0 ≤ x, y ≤ 100, 000. Since coordinates are rounded to the nearest integer, more than one city could have the exact same coordinate on the map. You may assume that the map of the kingdom is any rectangle that contains all of the given points (although such information is not needed by the program.) Note also that while all cities lie on integer coordinates, the dividing lines need not be. The last line of the input file contains two zeros.
Output
For each test case, print the following line:
k. A/B
Where k is the test case number (starting at one,) and A/B is the minimum average that could be obtained. A/B should be an irreducible fraction. Let B=1 when the result is a whole number.
Example
Input:
6 3
0 4
1 3
2 3
3 1
4 4
5 0
4 3
0 0
0 1
1 1
1 0
0 0
Output:
1. 0/1
2. 8/9 | 32,168 |
Stock Chase (ANARC09G)
I have to admit, the solution I proposed last year for solving the bank cash crisis didn’t solve the whole economic crisis. As it turns out, companies don’t have that much cash in the first place. They have assets which are primarily shares in other companies. It is common, and acceptable, for one company to own shares in another. What complicates the issue is for two companies to own shares in each other at the same time. If you think of it for a moment, this means that each company now (indirectly) controls its own shares.
New market regulation is being implemented: No company can control shares in itself, whether directly or indirectly. The Stock Market Authority is looking for a computerized solution that will help it detect any buying activity that will result in a company controlling its own shares. It is obvious why they need a program to do so, just imagine the situation where company A buying shares in B, B buying in C, and then C buying in A. While the first two purchases are acceptable. The third purchase should be rejected since it will lead to the three companies controlling shares in themselves. The program will be given all purchasing transactions in chronological order. The program should reject any transaction that could lead to one company controlling its own shares. All other transactions are accepted.
Input
Your program will be tested on one or more test cases. Each test case is specified on T + 1 lines. The first line specifies two positive numbers: (0 < N ≤ 234) is the number of companies and (0 < T ≤ 100, 000) is the number of transactions. T lines follow, each describing a buying transaction. Each transaction is specified using two numbers A and B where (0 < A, B ≤ N ) indicating that company A wants to buy shares in company B. The last line of the input file has two zeros.
Output
For each test case, print the following line:
k. R
Where k is the test case number (starting at one,) R is the number of transactions that should be rejected.
Example
Input:
3 6
1 2
1 3
3 1
2 1
1 2
2 3
0 0
Output:
1. 2 | 32,169 |
Largest Labeled Common Ancestor (LLCA)
Given a labeled complete k-ary tree, find the largest labeled common ancestor of two given nodes. In a complete k-ary tree, the node in the tree is labeled sequentially from the left most child to right most child, level by level. Largest labeled common ancestor of A and B is defined as the largest labeled node in the tree which has A and B as descendants. A node is a descendant of itself.
Be careful with your finger, the source limit is 256 bytes.
Input
The first line of input contains an integer T (1 <= T <= 100) the number of cases. Each cases contains three integers K, A and B (2 <= K <= 100; 1 <= A, B <= 2,000,000,000).
Output
For each test case, output in a line the largest labeled common ancestor node.
Example
Input:
4
3 42 7
2 2 6
2 1 105
4 10 13
Output:
2
1
1
3
Whitespace Explanation
If there no input in any line, then the output for that line is a blank line :)) Sorry for inconvenience. >:) | 32,170 |
Commuting Functions (COMFUNC)
Two functions f and g (f, g: X → X) are commuting if and only if f(g(x)) = g(f(x)) for each x in X. For example, functions f(x) = x + 1 and g(x) = x − 2 are commuting, whereas functions f(x) = x + 1 and g(x) = 2x are not commuting.
Each function h (h: N
n
→ N
n
, where N
n
= {1, 2, ... n} and n is positive integer) can be represented as a value list — a list in which the i-th element is equal to h(i). For example, a function h(x) = ceil(x/2) from N
5
to N
5
has the value list [1, 1, 2, 2, 3].
The value lists are ordered lexicographically: list [a
1
... a
n
] is smaller than list [b
1
... b
n
] if and only if there exists such an index k that a
k
< b
k
, and a
l
= b
l
for any index l < k.
The function f (f: X → X) is bijective if for every y in X, there is exactly one x in X such that f(x) = y.
Given a bijective function f (f: N
n
→ N
n
, n is positive integer), find the function g that is commuting with f and has the lexicographically smallest possible value list.
Input
The first line of the input file contains the number of test cases. Each test case is described by a line containing a single integer number n — the number of the elements in the value list of a bijective function f (1 ≤ n ≤ 200000), followed by another line which contains the value list of the function f.
Output
For each test case, output a single line containing n integer numbers — the value list of function g that commutes with the function f and has the lexicographically smallest value list.
Example
Input:
2
10
1 2 3 4 5 6 7 8 9 10
10
2 3 4 5 6 7 8 1 9 10
Output:
1 1 1 1 1 1 1 1 1 1
1 2 3 4 5 6 7 8 9 9 | 32,171 |
Defense of a Kingdom (DEFKIN)
Theodore implements a new strategy game “Defense of a Kingdom”. On each level a player defends the Kingdom that is represented by a rectangular grid of cells. The player builds crossbow towers in some cells of the grid. The tower defends all the cells in the same row and the same column. No two towers share a row or a column.
The penalty of the position is the number of cells in the largest undefended rectangle. For example, the position shown on the picture has penalty 12.
Help Theodore write a program that calculates the penalty of the given position.
Input
The first line of the input file contains the number of test cases.
Each test case consists of a line with three integer numbers: w — width of the grid, h — height of the grid and n — number of crossbow towers (1 ≤ w, h ≤ 40 000; 0 ≤ n ≤ min(w, h)).
Each of the following n lines contains two integer numbers x
i
and y
i
— the coordinates of the cell occupied by a tower (1 ≤ x
i
≤ w; 1 ≤ y
i
≤ h).
Output
For each test case, output a single integer number — the number of cells in the largest rectangle that is not defended by the towers.
Example
Input:
1
15 8 3
3 8
11 2
8 6
Output:
12 | 32,172 |
Kitchen Robot (KITROB)
Robots are becoming more and more popular. They are used nowadays not only in manufacturing plants, but also at home. One programmer with his friends decided to create their own home robot. As you may know most programmers like to drink beer when they gather together for a party. After the party there are a lot of empty bottles left on the table. So, it was decided to program robot to collect empty bottles from the table.
The table is a rectangle with the length l and width w. Robot starts at the point (x
r
, y
r
) and n bottles are located at points (x
i
, y
i
) for i = 1, 2 ... n. To collect a bottle robot must move to the point where the bottle is located, take it, and then bring to some point on the border of the table to dispose it. Robot can hold only one bottle at the moment and for simplicity of the control program it is allowed to release bottle only at the border of the table.
You can assume that sizes of robot and bottles are negligibly small (robot and bottles are points), so the robot holding a bottle is allowed to move through the point where another bottle is located. One of the subroutines of the robot control program is the route planning. You are to write the program to determine the minimal length of robot route needed to collect all the bottles from the table.
Input
The first line of the input file contains T, the number of test cases. T test cases follow.
The first line of each test case contains two integer numbers w and l — the width and the length of the table (2 ≤ w, l ≤ 1000).
The second line contains an integer number n — the number of bottles on the table (1 ≤ n ≤ 18). Each of the following n lines contains two integer numbers x
i
and y
i
— coordinates of the i-th bottle (0 < x
i
< w; 0 < y
i
< l). No two bottles are located at the same point.
The last line of the test case contains two integer numbers x
r
and y
r
— coordinates of the robot’s initial position (0 < x
r
< w; 0 < y
r
< l). Robot is not located at the same point as a bottle.
Output
For each test case, output the length of the shortest route of the robot. Your answer should be accurate within an absolute error of 10
-6
.
Example
Input:
1
3 4
2
1 1
2 3
2 1
Output:
5.60555127546399 | 32,173 |
The Lucky Prisoner (LPRISON)
(Maybe) someday there is a planet used to jail much prisoners from universe. One time, the prison manager collects all of prisoners, with handcuff in their hand locked. He orders to officers to unlock all handcuffs. Then, he orders to officers to look at prisoners whose number can divided by two. If his/her handcuff is locked, the open it, otherwise, lock it. Then, he orders again to all officers to look at prisoners whose number can divided by three, and so on.
You, the universe criminal researcher, is requested to calculate the environmental criminal impact by calculating ratio of freed prisoners about all prisoners to the number of prisoners are known.
Input
Line 1 contains one integer T (1 <= T <= 100) number of test cases. Then T next lines contains one number K (1 <= K <= 10
1000
), the number of prisoners.
Output
Output contains K lines, contains the probability of freed prisoners about all prisoners. The probability precision is 10
-500
with bankers' rounding method.
Example
Input:
2
5
100
Output (split for readability) :
0.40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0.10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Whitespace Explanation:
If there no input in any line, then do not print any line :)) Sorry for inconvenience. >:) | 32,174 |
Cow Photographs (COWPIC)
Farmer John wants to take a picture of his entire herd of N (1 ≤ N ≤ 100,000) cows conveniently numbered 1..N so he can show off to his friends.
On picture day, the cows run to form a single line in some arbitrary order with position i containing cow c
i
(1 ≤ c
i
≤ N). Farmer John has his own ideas about how the cows should line up.
FJ thinks cow i may stand only to the left of cow i+1 (for all i, 1 ≤ i ≤ N-1) and that cow N may only stand to the left of Cow 1. Of course, no cow will stand to the left of the first (leftmost) cow in the line.
The cows are hungry for the promised post-photo dinner, so Farmer John wants to take the picture as quickly as possible. Cows are not great at following directions, so he will only choose a pair of adjacent cows and have them switch places once per minute. How quickly is Farmer John able to get them into some acceptable order?
Consider a set of 5 cows whose initial line-up looks like this:
Left Right
3 5 4 2 1
He can first swap the second pair of cows:
3 4 5 2 1
and then swap the rightmost pair:
3 4 5 1 2
to yield an acceptable line-up that required but two minutes of cow swapping.
Input
Line 1: A single integer: N
Lines 2..N+1: Line i+1 contains the number of the i-th cow in line: c
i
Output
Line 1: The minimum amount of time, in minutes, that it takes Farmer John to get the cows into some appropriate order.
Example
Input:
5
3
5
4
2
1
Output:
2 | 32,175 |
Tree Isomorphism (TREEISO)
Given two undirected trees T1 and T2 with equal number of vertices N (1 ≤ N ≤ 100,000) numbered 1 to N, find out if they are isomorphic.
Two trees T1 and T2 are isomorphic if there is a bijection f between the vertex sets of T1 and T2 such that any two vertices u and v of T1 are adjacent in T1 if and only if f(u) and f(v) are adjacent in T2.
Input
The first line of input contains the number of test cases nTest (1 ≤ nTest ≤ 400). Each test case contains:
The first line contains the number of nodes N.
Each of next N-1 lines contain two integers A, B, denoting that there is an edge in T1 between nodes A and B (1 ≤ A, B ≤ N).
Each of next N-1 lines contain two integers A, B, denoting that there is an edge in T2 between nodes A and B (1 ≤ A, B ≤ N).
The sum of N over all test cases will not exceed 100,000.
Output
For each test case print YES if T1 and T2 are isomorphic and NO otherwise.
Example
Input:
2
4
4 2
4 1
2 3
4 2
2 3
4 1
5
3 4
3 2
3 5
3 1
3 4
4 2
2 5
2 1
Output:
YES
NO | 32,176 |
Stacks of Zippy (JZPSTA)
Recently
Zippy
received four stacks, named A B C D respectively. Firstly, there are n elements in stack A (the element sequence is a permutation of 1..n), and stack B C D are empty. He can do four types of operations:
operation a: push the top element of stack A to stack B (if stack A is not empty, this operation can be done.)
operation b: push the top element of stack B to stack D (if stack B is not empty, this operation can be done.)
operation c: push the top element of stack A to stack C (if stack A is not empty, this operation can be done.)
operation d: push the top element of stack C to stack D (if stack C is not empty, this operation can be done.)
He can do 2*n operations in total. Obviously, there are n elements in stack D after he did the 2*n operations. Then he take out the top element in stack D one by one. If the first element he takes out is n, the second is n-1, ... the last is 1, he will be very happy. Also, he wants to make the operation sequence he did lexicographic smallest.
Input
First line is a number t, which is the number of test cases.
Then following t test cases. For each test case, the first line contains a number n, which denotes the number of the elements in stack A. The second line contains n numbers, separated by a space, which are the elements in stack A, from top to the bottom.
You can be sure that the sum of all n does not exceed 200000, and each n is not bigger than 100000.
Output
For each case, output a line. If there exists an answer, output the lexicographic smallest one (the operations Zippy does, separated by a space). If not, output 0.
Example
Input:
2
4
1 3 4 2
4
2 3 4 1
Output:
a b a c a b b d
0 | 32,177 |
Tower Game (Hard) (ADV04A1)
Daniel is building towers out of blocks. He has many black and white blocks. He has built n towers out of those. Now he suggests Max playing the following game. Black block will belong to Daniel and white blocks will be Max's blocks. During his turn the player can take any of his blocks from any tower and remove it and all the blocks above it. As usual the player who can't make the move loses. Daniels make the first move. Determine who will win if both players play optimally.
Input
The input starts with number t - the amount of test cases. The first line of each test is number n - the number of towers. Then n strings follow. Each string is formed of 'B' and 'W' characters, where 'B' means black block and 'W' means white block. Each string describes one tower from bottom to top.
Constraints
1 <= t <= 20
1 <= n <= 1000
String consist of no less than 1 character and no more than 1000 characters.
Output
For each test case print 'Win' if Daniel wins and 'Loss' if Max wins given both players play optimally.
Example
Input:
1
5
BBWWB
BWBB
BB
WWW
WB
Output:
Win
Beware! Much input data. | 32,178 |
Upper Right King (Hard) (ADV04B1)
There is a king in the lower left corner of the n × n chess board. The king can move one step right, one step up or one step up-right. How many ways are there for him to reach the upper right corner of the board?
Input
The first line of input contains number T - the amount of test cases. Next T lines consist of single integer n - the size of the board.
Constraints
1 <= T <= 10000
1 <= n <= 1000000
Output
For each test case output the number of ways to reach upper right corner of n × n board modulo 1000003.
Example
Input:
2
2
3
Output:
3
13 | 32,179 |
Deal or No Deal (ADV04C)
Deal or No Deal is played in many different ways around the world. Many different countries have their own version or versions of the show, each with their own twists on the same general format. The general format is the following.
The game revolves around the opening of a set of numbered briefcases, each of which contains a different prize (cash or otherwise). The contents of all of the cases are known at the start of the game, but the specific location of any prize is unknown. The value of each of the cases is indicated by a label or card sealed within it. The contestant claims (or is assigned) a case to begin the game. The case's value is not revealed until the conclusion of the game.
The contestant then begins choosing cases to be removed from play. The amount inside each choice is immediately revealed; by process of elimination, the amount revealed cannot be inside the player's chosen case. Throughout the game, after a predetermined number of cases have been opened, the banker offers the contestant an amount of money and/or prizes to quit the game, the offer based roughly on the amounts remaining in play and the contestant's demeanour. The player then answers the titular question, choosing:
"Deal", accepting the offer presented and ending the game, or
"No Deal", rejecting the offer and continuing the game.
This process of removing cases and receiving offers continues, until either the player accepts an offer to 'deal', or all offers have been rejected and the values of all unselected cases are revealed. The player wins the value of the deal taken, or if no deal is taken, the contents of the player's case.
For the sake of this problem we will consider that the banker offers are deal before each removing of cases. Also we will assume that banker follows the particular model of contestants behaviour which is - if the banker offers the contestant the prize x the probability that the contestant accepts the deal is:
,
where min and max are the minimum and maximum prizes left in the game respectively. The banker wants to minimize the expected prize the contestant wins. Help the banker calculate the expected prize the contestant is going to win if the banker offers optimal deals.
Input
The first line of input is n - the number of briefcases. Next lines consists of n integers a
1
, a
2
, …, a
n
- the prizes in the briefcases. Number q follows - the amount of situations the banker needs to evaluate. The description of each situation follows: k – the number of prizes still in the game; b
1
, b
2
, …, b
k
– the prizes themselves.
Constraints
2 <= n <= 16
1 <= q <= 100
2 <= k <= n
1 <= a
i
, b
i
<= 10
6
Output
For each situation print the expected prize the contestant is going to win and also the optimal deal the banker should offer. Both numbers should be printed with two digits after the dot.
Example
Input:
4
10 20 30 40
4
2 10 20
2 20 30
2 40 10
4 20 30 10 40
Output:
14.59 12.66
24.59 22.66
23.76 17.99
22.40 17.08 | 32,180 |
UFO (ADV04D)
There is a UFO in the form of the disc of radius r. Currently its center is in point A and it needs to move its center to point B as soon as possible. But the tricky inhabitants of the Earth are starting to suspect something, so they have built a radar in point C with a range of R, which is able to detect a UFO, if any part of it will be in the range. Because of the special features of the UFO it cannot change its height and always maintain vertical alignment. Determine the shortest path for the UFO to reach its destination not being caught by the radar.
Input
The first line of input contains number T — the amount of test cases. Next T line consist of eight integers each x
A
, y
A
, x
B
, y
B
, x
C
, y
C
, r and R — the coordinates of points A, B, C and radii of the UFO and radar coverage. It is guaranteed that the UFO won't be within the radar coverage in points A and B.
Constraints
1 <= T <= 1000
-1000 <= x
A
, y
A
, x
B
, y
B
, x
C
, y
C
, r, R <= 1000
Output
For each test case output a real number which is the shortest UFO path with two decimals after the dot.
Example
Input:
1
0 0 8 0 4 0 1 1
Output:
9.02 | 32,181 |
Prisoner of Benda (ADV04E)
Daniel enjoys watching TV series. One of his favourite is Futurama. One episode has the following plot.
Professor Farnsworth switches bodies with Amy using a new invention so that he can relive his youth. Likewise, Amy is reminiscent of her younger days of constantly eating and wishes to use the Professor's skinny body to gorge herself with food once again. Later, they find they cannot switch their bodies back with each other, because the device will not operate on the same pairing of bodies. The Professor thoughtlessly suggests they might be able to switch back to their original bodies with a third person. Bender switches bodies with the Professor (Amy's body) so he can perform a robbery without being identified. After realizing his mistake, the Professor, now in Bender's body, tires of trying to solve the problem. He decides to live a life of daring stunts and joins a robot circus.
Bender, now in Amy's body, is caught aboard the yacht of Robo-Hungarian emperor Nikolai. When Bender states that he is really a robot who has switched bodies with a human, Nikolai reveals that he feels trapped by his wealth and wishes to live the life of a normal, "peasant" robot. Bender tricks him into switching bodies with a robot wash bucket and inhabits Nikolai's body, planning to live like an emperor. However, he discovers that Nikolai's fiancée and first officer are plotting to kill him. Bender is saved with the assistance of the Professor and the circus' loyal Robo-Hungarian citizens. Meanwhile, Leela switches bodies with Amy, thus inhabiting the Professor's body, when she comes to believe that Fry only loves her for her beauty. In order to beat Leela at her own game, Fry switches bodies with Dr. Zoidberg in an attempt to repulse Leela. This leads them to one-up each other using various disgusting acts while on a date, which climaxes when the two have sex with each other in their equally grotesque bodies, and reconcile. During this time, Amy has overeaten in Leela's body, making it overweight. She switches bodies with Hermes, so she can continue eating while Hermes slims Leela's body back down. While eating, she witnesses Fry and Leela making out in the Professor and Dr. Zoidberg's bodies and loses her appetite for food. Concurrently, Zoidberg and Nikolai, in the respective bodies of Fry and the robot wash bucket, become friends and attempt to assume the lives of Fry and Bender, blowing up their apartment in the process. The bucket, now in Amy's body, professes its love to Scruffy the Janitor, but he turns it away. Finally, two Globetrotters, Ethan "Bubblegum" Tate and "Sweet" Clyde Dixon, mathematically prove that everyone's minds can be restored using two additional bodies and then successfully do so, with themselves as the extras.
We need to replicate how they have accomplished this. We will consider that a certain amount of body switches already took place. We need to determine the sequence of switches after which everyone is in self body, using no more than two extra bodies. Don't forget that two specific bodies can be mind switched only once.
Input
The first line of input contains t - the number of test cases. The description of tests follows. The first line of each test is numbers n - the number of characters and m - the number of body switches already taken place. Next m lines contain the description of switches. Let us mark all bodies with numbers from 1 to n. Then each switch is defined by two numbers a, b - the numbers of bodies used in the switch. The switches are listed chronologically.
Constraints
1 ≤ t ≤ 50
2 ≤ n ≤ 200
1 ≤ m ≤ n(n - 1) / 2
1 ≤ a, b ≤ n
Output
Print the number of switches needed to return everyone to their own bodies in the first line of the output. Then you should print the switches themselves in the order they should be performed. The format should be the same as in the input data. You can output any valid solution. However you shouldn't use more than two extra bodies. The extra bodies should be marked as n+1 and n+2. After all the switches the extra characters should be in their own bodies as well. Also you can't use more than 3n switches.
Example
Input:
1
2 1
1 2
Output:
5
1 3
2 4
2 3
1 4
3 4 | 32,182 |
Four Chips (Hard) (ADV04F1)
There is a n × 1 board. Its cells are numbered with integers from 1 to n. First four cells have indistinguishable chips in them. In one turn you can move one chip to the neighbouring cell or move it symmetrically relatively any other chip (i.e. if you move a chip in cell 10 symmetrically relative to the chip in cell 13 it will end up in cell 16), given that the chip won't leave the board and each cell will have no more than one chip. You need to determine the minimum number of turns needed to reach a certain configuration of chips.
Input
The first line of input contains number T - the amount of test cases. Next T lines consist of four integers a
1
, a
2
, a
3
and a
4
— the numbers of cells where the chips should be in the final configuration.
Constraints
1 ≤ T ≤ 10000
1 ≤ a
1
< a
2
< a
3
< a
4
≤ n
n = 70
Output
For each test case print single integer - the answer to the problem in the statement.
Example
Input:
2
1 2 3 4
1 3 4 6
Output:
0
1 | 32,183 |
Regular expressions (Hard) (ADV04G1)
Regular expression is an expression which defines a set of strings. In this problem regular expression will contain only small latin letters a-z and special characters ‘?’, ‘*’ and ‘+’. Each letter corresponds to itself in the defined strings. Special character can occur only after some letter and means the number of repetitions of the letter:
Character
Repetitions
?
none or one
*
none or more
+
one or more
For example “ac”, “abc”, “acc”, “abcccc”, and so on match regular expression “ab?c+”.
For the given string find the substring which matches the given regular expression. If there are many such substrings find the most left one. If there are many of those as well fing the longest one.
Input
The first line of input contains number T - the amount of test cases. The description of T test cases follows. The first line of each test case is the given string S of length L. Next line contains number n - the amount of regular expressions. Next n lines describe one regular expression Ri each for which you should find the matching substrings.
Constraints
1 <= T <= 100
1 <= n <= 10
1 <= L <= 200
1 <= R
i
<= 100
Output
For each regular expression print the matching substring or -1 if there is no such substring in the given string.
Example
Input:
1
aabbcc
5
b*c
a?b+c+
ab?c
b?c?
a?b?c?
Output:
bbc
abbcc
-1
a | 32,184 |
Join (ADV04H)
There are two tables. These tables are filled with numeric data. Each column of each table has a unique name. You need to implement JOIN operation for those tables. JOIN creates a new result table by combining column values of the two tables based upon the join-predicate. The query compares each row of the first table with each row of the second to find all pairs of rows which satisfy the join-predicate. When the join-predicate is satisfied, column values for each matched pair of rows of the table are combined into a result row. The result of the join can be defined as the outcome of first taking the Cartesian product of all records in the tables (combining every record in the first table with every record in the second table) - then return all the records which satisfy the join predicate. After that needed column are picked and printed as the result. Moreover the resulting rows should be output in the lexicographic order.
Input
The input starts with the description of the first table. The first line consists of k
1
names of the columns of the table separated with spaces. All the names contain only small Latin letters and digits. Next line contain number n
1
– the number of records in the table. In each of the next n
1
lines there are k
1
integers – data written in the table. The description of the second table in the same format follows. Next line is number q – the number of queries. The description of each query follows in the following format:
SELECT <list of the names of columns>
JOIN ON <a name of the column from the first table>=<a name of the column of the second table>
Constraints
2 ≤ k
1
, k
2
≤ 10
1 ≤ n
1
, n
2
≤ 50000
All the integers in the tables are positive and less than 100000.
1 ≤ q ≤ 10
Output
For each query print the result of JOIN operation. You should print only the columns given in the query and in the appropriate order. The rows should be ordered lexicographically. The result of each query won't contain more than 50000 records. Print blank line after the answer for each query. See the example for more information.
Example
Input:
id1 a b
4
1 2 3
2 2 3
3 2 4
2 4 4
id2 c d
3
3 3 3
5 2 1
1 3 4
3
SELECT a,b,c
JOIN ON id1=d
SELECT id1,d
JOIN ON a=c
SELECT id2,id1,d
JOIN ON b=c
Output:
a b c
2 3 2
2 4 3
id1 d
1 1
2 1
3 1
id2 id1 d
1 1 4
1 2 4
3 1 3
3 2 3 | 32,185 |
Invisible point (ADV04J)
Daniel marked a point on a plane with sympathetic ink and he has also drawn a regular n-gon with normal ink. Max can see the n-gon, but can't see the point. Max can draw a line and ask Daniel which side of the line the point is. What is the minimum number of questions Max have to ask to define if the point is inside the n-gon in the worst case?
Input
First line of the input contains number t - the amount of test cases. Each test consists of the single integer n - the amount of sides of the n-gon.
Constraints
1 ≤ t ≤ 100
3 ≤ n ≤ 1000000
Output
For each test case print a single number - the answer to the question in the statement.
Example
Input:
1
4
Output:
3 | 32,186 |
Calculator (ADV04K)
Once little Petya was learning positional numeral systems. Using such systems the numbers are represented as the sequence of digits
a
n
a
n
−1
…
a
2
a
1
a
0
=
n
∑
k
=0
a
k
b
k
,
where b is the base of the numeral system, and 0 <= a
k
< b. Petya was disappointed that one can represent only non-negative numbers this way. But then he found out that there are systems with negative base such as negabinary system in which b = −2, a
k
∈ {0, 1}. One can represent any integer in this system for example 1110
−2
= −6. Moving the idea further Petya came up with his own base b using which he could represent even more numbers given a
k
∈ {0, 1}.
However performing arithmetic operations in this non-standard system turned to be rather difficult. Help Petya implement a calculator for his numeral system.
Input
The first line of input is number T - the amount of test cases. Next T lines contain the description of arithmetic expression consisting of two operands and an operation separated with spaces. Both operands consist of one ‘0’ and ‘1’ digits and have the length of no more than 100. Operation is one of ‘+’, ‘-’ or ‘*’.
Constraints
1 <= T <= 1000
Output
For each test case output a number which is the result of evaluating the given expression.
Example
Input:
5
11 - 11
1 + 1
1100 * 1100
1101 - 11
111 * 1
Output:
0
1100
111010000
111010110
111 | 32,187 |
Miles and kilometers (ADV04L)
If you are travelling a lot you could have met the following problem: different countries use different measurement systems. Notably there are two major measurement systems for distances: metric and imperial. Metric system exploits kilometers while miles are used in the imperial system. It is known that one mile is approximately 1.609 kilometers. By interesting coincidence this is close enough to the value of the golden ration which is about 1.618. On this basis there is an interesting way of converting miles to kilometers. Let's look into Fibonacci sequence:
F
1
=
F
2
= 1,
F
n
=
F
n
−1
+
F
n
−2
, for
n
> 2. The ratio of two successive Fibonacci numbers
F
n
+1
/
F
n
tends to golden ration as
n
tends to infinity. So you can partition the amount of miles you have into Fibonacci numbers, and you should use as large Fibonacci numbers as possible, then for each element in the partition you should go to the next Fibonacci number and sum up the elements again. That way you will get the approximate amount of kilometers. For example, 40 ⇒ 34 + 5 + 1 ⇒ 55 + 8 + 2 ⇒ 65. That means that 40 miles is approximately 65 kilometers (more precise value is 64,37 kilometers). Write a program that implements this method.
Input
The first line of input contains number t – the amount of test cases. The description of t test cases follows. Each test consists of a single integer m - the amount of miles.
Constraints
1 <= t <= 10000
1 <= m <= 10^15
Output
For each test case output the amount of kilometers calculated using the method given in the statement.
Example
Input:
4
1
7
40
128
Output:
2
11
65
207 | 32,188 |
Ljutnja (C1LJUTNJ)
Children in a kindergarten have received a large sack containing M candies. It has been decided that the candies are to be distributed among N children.
Each child has stated the number of candies that it wants. If a child isn’t given the amount of candy it wants, it will get angry. In fact it’ll get angrier for each candy it is deprived of. Some speculate that its anger will be equal to the square of the number of candies it is deprived of. For instance, if Mirko states that he wants 32 candies but receives only 29, he would be missing 3 candies, so his anger would be equal to 9.
Unfortunately, there is an insufficient amount of candy to satisfy all children. Therefore, the candies should be distributed in such a way that the sum of the children’s anger is minimal.
Input
The first line contains two integers, M (1 ≤ M ≤ 2.10
9
) and N (1 ≤ N ≤ 100 000).
The following N lines contain integers (one per line) which represent the wishes of the children. Those numbers are all strictly less than 2.10
9
, and their sum always exceeds M.
Output
The first and only line of output must contain the minimum sum of the children’s anger.
Note: The test cases will ensure that the result fits in a 64-bit unsigned integer: int64 in Pascal, long long in C/C++, long in Java.
Example
Input:
5 3
1
3
2
Output:
1
Input:
10 4
4
5
2
3
Output:
4 | 32,189 |
Tabovi (C1TABOVI)
Zvonkec is yet another programmer employed in a small company. Every day he has to refactor one file of source code. Much to his dismay, the source is usually far from being clear and tidy. He is especially bothered by uneven indentation, i.e. the number of tabulators (tabs) indenting each line.
Fortunately, his editor has a command to select a group of consecutive lines and add or delete a character from the start of each one. Help Zvonkec tidy up the code as quickly as possible.
You are given the number of lines N, a sequence specifying the current number of tabs at the start of each line, and a sequence specifying the required number of tabs at the start of each line.
Zvonkec can execute any number of commands consisting of:
selecting any number of consecutive lines
adding or deleting a single tab to/from the front of each of the selected lines
The two actions above comprise a single command, regardless of the number of selected lines. It should be noted that it is forbidden to delete more tabs from a line than are actually present at the start of a line, as the editor would start deleting characters other than tabs.
You are asked to calculate the minimum number of commands required to tidy up the code.
Input
The first line of input contains a positive integer N (N ≤ 1000).
The second line contains a sequence of N integers Pi (0 ≤ Pi ≤ 80), specifying the number of tabs at the start of i-th line before any editing.
The third line contains a sequence of N integers Ki (0 ≤ Ki ≤ 80), specifying the number of tabs that Zvonkec would like at the start of i-th line.
Output
The first and only line of output must contain the required number, as specified in the problem statement.
Example
Input:
3
3 4 5
6 7 8
Output:
3
Input:
4
1 2 3 4
3 1 1 0
Output:
6
Input:
4
5 4 5 5
1 5 0 1
Output:
10 | 32,190 |
Crni (C2CRNI)
Even though he has found all the most amusing rides, Mirko‟s enthusiasm still isn‟t fading. He opened his graph paper notebook and started colouring squares, and a new, even harder problem dawned on him.
You are given a square table consisting of N rows by N columns. Each cell is either black or white. A set of cells forming a rectangle, with horizontal and vertical edges following cell borders, shall be called a black rectangle if all cells inside the rectangle are black and it consists of at least two cells.
The left image shows two rectangles which are not black rectangles. The rectangle labelled 1 is not a black rectangle because it contains a white cell, and the rectangle labelled 2 is not a black rectangle because it consists of only one cell. On the other hand, the right image shows three valid black rectangles.
Calculate the number of possible selections of two black rectangles that have no common cells. As the required number can be extremely large, you should output the remainder of dividing that number by 10 007.
Input
The first line of input contains the integer N (2 ≤ N ≤ 1000).
Each of the next N lines contains a single row of the table, consisting of N symbols. The symbol 'C' represents a black cell, while 'B' represents a white cell.
Output
The first and only line of output must contain the remainder of dividing the required number by 10 007.
Example
Input:
2
CC
CC
Output:
2
Input:
3
CCB
CCB
CBB
Output:
5
Input:
5
BCCBB
BBCBB
BCCBB
BBBBB
CCBBB
Output:
8 | 32,191 |
Boards (Hard) (ADV04I1)
Super Board Games Inc. is a big company producing board games. A new game was invented within it which may become very popular. A board divided into square cells is required for this game. Left and lower borders of the board should be level and the height of columns of cells should not increase from left to right. Also the board must be entirely paveable with dominoes. After it was found out that the game is the most interesting when played on the board consisting of n cells, it has been decided to release as many versions of the game using different n-cell boards as possible. Help the company count the number of different boards that can be released.
Input
The first line of input is number T - the amount of test cases. Each test is a single integer n - the number of cells.
Constraints
1 <= T <= 100
1 <= n <= 100
Output
For each test case output the answer to the problem in the statement.
Example
Input:
3
2
3
4
Output:
2
0
5 | 32,192 |
Fibonacci Sequence (SPFIBO)
Fibonacci sequence is defined as follow: F
1
= 1, F
2
= 2, F
i
= F
i-1
+ F
i-2
(i > 2).
Each natural number X can be expressed by the maximum numbers that are less than or equal to X in Fibonacci sequence: X = a
1
xF
1
+ a
2
xF
2
+ … Therefore, in Fibonacci system, X is known as: a
n
a
n-1
…a
1
. For example, 1 = 1
F
, 2 = 10
F
, etc. If we write all natural numbers successively in Fibonacci system, we will obtain a sequence like this: 1_1_0… This is called “Fibonacci bit sequence of natural numbers”.
Your task is counting the numbers of times that bit 1 appears in the first N bits of this sequence.
Input
Line 1: An integer N (1 <= N <= 10
15
)
Output
Line 1: An integer K is the result
Example
Input:
2
Output:
2 | 32,193 |
Skyline (SKYLINE)
The director of a new movie needs to create a scaled set for the movie. In the set there will be N skyscrapers, with distinct integer heights from 1 to N meters. The skyline will be determined by the sequence of the heights of the skyscrapers from left to right. It will be a permutation of the integers from 1 to N.
The director is extremely meticulous, so she wants to avoid a certain sloping pattern. She doesn’t want for there to be ANY three buildings in positions i, j and k, i < j < k, where the height of building i is smaller than that of building j, and building j’s height is smaller than building k’s height.
Your task is to tell the director, for a given number of buildings, how many distinct orderings for the skyline avoid the sloping pattern she doesn't like.
Input
There will be several test cases in the input. Each test case will consist of a single line containing a single integer N (3 ≤ N ≤ 1,000), which represents the number of skyscrapers. The heights of the skyscrapers are assumed to be 1, 2, 3, ..., N. The input will end with a line with a single 0.
Output
For each test case, output a single integer, representing the number of good skylines - those avoid the sloping pattern that the director dislikes - modulo 1,000,000. Print each integer on its own line with no spaces. Do not print any blank lines between answers.
Example
Input:
3
4
0
Output:
5
14 | 32,194 |
Operating System Problems (Task Scheduling) (OSPROB1)
As you all know, Operating System (OS) is a software that controls the execution of computer programs and may provide various services. Although modern operating systems are very easy to use and give us lots of services, their designing is not so easy. It needs lots of work and time to design a good OS. But no OS is perfect. Either they are not so usable or they are not so secure (got tons of viruses). Lingates, as an excellent programmer, wants perfection in all things. So he decided to not use this OSs and write his own OS. But he found out this work is not so easy to do alone even for a programmer like him. So he needs your help.
As a programmer with honor he won’t let you do
equal or more
work in a turn then him (Means Lingates has to do more work then you on each turn). Each turn you both divide the works between yourself. But the works are related so it’s better to take works which are adjacent. Like if there are
5
works
5, 2, 7, 1, 3
then Lingates would take 1st work and give you the 2nd work. But you can't take 2nd and 3rd work because that sum to
7 + 2 = 9
which is more than his work (
5
). Again you can't take 2nd and 4th work because they are not adjacent. After you both finish your work you both will again distribute your works. There is no limit how much work you both can take on a turn. Like Lingates can take 1st and 2nd work on first turn and give you
no work
on that turn or he can take 1st, 2nd and 3rd turn (total
5 + 2 + 7 = 14
) and give you only 4th (
1
) or both works (
1 + 3 = 4
). As you are helping him he let you to divide the works but it has to be that Lingates has to do more work on each turn. As you are also a programmer with honor you also like to take the turns and divide the work on each turn such that it
maximizes your total works
.
Write a program which will take the list of work and give the total amount of work done by Lingates and you if you make the list optimally. Again Lingates will do any amount of work you will give him in any turn as long as your work on that turn is less than his.
Input
The first line will be number of test cases (
T ≤ 500
) and each case will start with an integer n (
0 ≤ n ≤ 100
). In the following line n numbers will given as the amount of works (all will be
non negative integer < 1000
)
Output
A single line for each test case first the total work of Lingates and second the work of your.
Example
Input:
4
3
1 2 3
5
5 2 7 1 3
5
6 6 6 6 6
7
4 9 5 7 6 5 1
Output:
6 0
12 6
18 12
20 17
Explanation
In 1st case you have to give Lingates all 3 works because 1 < (2 + 3) and (1 + 2) = 3, so you can't take any work.
In 2nd case you can give Lingates 1st work (5) and you can take 2nd (2). Then you can give Lingates the 3rd (7) and you can take the rest (1 + 3).
In 3rd case you can give Lingates 1st to 3rd work (6 + 6 + 6 = 18). You can take the left two works (6 + 6 = 12).
In 4th case you can give Lingates 4 and 9 and you will take 5 and 7. Then in next turn you can give him 6 and you own take 5. Then you can give him 1. So totalling (4 + 9 + 6 + 1) = 20 and (5 + 7 + 5) = 17. | 32,195 |
Check Ramsey (HS10RMSY)
From Ramsey theorem we know that for every
k, l
pair there exists an integer:
R
(
k, l
) for that if
n >= R
(
k, l
), then if you color the edges of a complete graph on
n
vertices with red and blue then it contains a complete subgraph on
k
vertices whose edges are blue or a complete subgraph on
l
vertices whose edges are red. To get an impression of the theorem you have to count the number of complete subgraphs having
k
nodes with blue edges -
K
(
k
) and the number of complete subgraphs having
l
nodes with red edges -
K
(
l
) for each edge coloring.
To make the problem somewhat easier (or harder?) for each test the probability that an edge is red (or blue) is close to 1/2. This means that on
n
vertices you will see about
n
(
n
-1)/4 red edges.
Input
The first line contains the number of test cases
T
, where
T
<= 100. After it there is a blank line and also after every test. Each test starts with four integers
n
,
k
,
l
,
e
in this order, where 3 <=
k
<=
l
<=
n
< 100, here
e
is the number of red edges (we are not interested in very large monochromatic complete subgraphs, so you can assume that
k
,
l
<= 10 is also true). Then follow
e
lines, each of them gives two integers:
x
,
y
, it means that there is a red edge between points 0 <=
x
,
y
<
n
. All other edges are blue.
Output
For each test print the case number then the count of blue
K
(
k
) and red
K
(
l
) for the edge coloring.
Example
Input:
3
5 3 3 5
0 1
1 2
2 3
3 4
4 0
6 3 3 6
0 1
1 2
2 3
3 4
4 5
5 0
8 3 4 7
0 1
0 2
0 3
0 4
1 2
1 3
2 3
Output:
Case #1:
The number of blue K(3) is 0 and the number of red K(3) is 0.
Case #2:
The number of blue K(3) is 2 and the number of red K(3) is 0.
Case #3:
The number of blue K(3) is 25 and the number of red K(4) is 1. | 32,196 |
Almost square factorisation (HS10SQFT)
For a given number
n
give all almost square factorisations of
n
, so where
n = (a
2
-1) × (b
2
-1)
and
1 < a ≤ b
.
Input
The first line contains the number of test cases
T
, where
T ≤ 1000
. Each of the following
T
lines contains one integer
0 < n < 2
62
.
Output
For each test case print the case number then on a new line the factorisations in increasing order of
a
value. If there is no such factorisation then print an error message, see the sample input/output for the correct format!
Example
Input:
4
546939993600
100
172569415200
3467754019458593280
Output:
Case #1:
546939993600=(31^2-1)*(23869^2-1)=(34^2-1)*(21761^2-1)=(271^2-1)*(2729^2-1)=(351^2-1)*(2107^2-1)=(701^2-1)*(1055^2-1)
Case #2:
For n=100 there is no almost square factorisation.
Case #3:
172569415200=(456^2-1)*(911^2-1)
Case #4:
3467754019458593280=(20513^2-1)*(90781^2-1) | 32,197 |
Multiplicative Palindrome (MULPAL)
Given a sequence of N integers. Find two disjoint contiguous palindromic subsequences. Lets call them X and Y. Your task is to find X and Y such that product of their lengths is maximal possible.
Input
First line will contain one integer N (1 ≤ N ≤ 10
6
).
Second line will contain N integers representing a sequence from the text of the task (0 ≤ A
i
≤ 2×10
9
).
Output
First and only line of output should contain only one integer, the maximum possible product from the text of problem.
Example
Input:
2
1 1
Output:
1
Input:
4
1 1 2 2
Output:
4
Input:
6
10 11 12 12 11 10
Output:
4
Input:
6
0 1 0 1 0 1
Output:
9 | 32,198 |
A Knights’ Tale (ACPC10G)
Imagine a chess board that extends indefinitely in both horizontal and vertical directions. N identical knights are placed on this board, each in a different square. N different squares are specially marked, which we will call the target squares, which could be different from where the knights are initially at. We would like you to determine the minimum number of knight-steps needed so that each of the target squares is occupied by one of the knights.
As illustrated in the figure, a knight moves using the normal ”L” move (1 square in one dimension and 2 squares in the other dimension.) For this problem, it is possible for more than one knight to occupy the same square while trying to reach its final destination as long as each knight ends up in a different target square.
Input
Your program will be tested on one or more test cases. Each test case is specified using 2N +1 lines.
The first line specifies (1 ≤ N ≤ 15) which is the number of knights (or targets.) The following N lines each specifies the position of a knight by specifying two integers representing the x and y location. The remaining N lines each specifies the position of a target square again by specifying two integers representing the x and y location. All coordinates are 32-bit signed integers.
The last case is followed by a line with a single zero.
Output
For each test case, print the following line:
k. m
Where k is the test case number (starting at one,) and m is the minimum number of moves.
Example
Input:
2
3 5
6 5
5 3
7 3
0
Output:
1. 3 | 32,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.