Booklet 2012 Bubble Cup Serbia

BUBBLE CUP 7DC
Student programming contest

Microsoft Development Center Serbia
Problem set & Analysis

From the Finals and Qualification rounds
Belgrade, 2012
Scientific committee:
Andreja Ili
Andrija Jovanovi
Milan Vugdelija
Mladen Radojevi
Miroslav Bogdanovi
Draen ari
Dimitrije Filipovi
eljko Nikolii
Milan Novakovi
Qualification analyses:
Nikola Milosavljevi
Boris Grubi
Duan Zdravkovi
Dimitrije Dimi
Uros Joksimovic
Milos Biljanovic
Dejan Pekter
Bartek Dudek
Linh Nguyen
Petar Velikovi
Ivan Stoi
Goran ui
Bartosz Tarnawski
Vanja Petrovi Tankovi
Vladislav Haralampiev
Aleksandar Ivanovi
Stjepan Glavina
Patrick Klitzke
Teodor Von Burg
Filip Paveti
Predrag Miloevi
Danilo Vunjak
Marko Bakovi
Cover:
Sava ajetinac
Typesetting:
Andreja Ili
Proofreader:
Andrija Jovanovi
Volume editor:
Dragan Tomi
Contents
Preface ...................................................................................................................................... 6
About Bubble Cup and MDCS ...................................................................................................... 7
Bubble Cup Finals 2012 ............................................................................................................... 8
Problem A: Good sets ......................................................................................................................... 9
Problem B: Wheel Of Fortune ........................................................................................................... 13
Problem C: MaxDiff .......................................................................................................................... 15
Problem D: Cars................................................................................................................................ 18
Problem E: Triangles ......................................................................................................................... 22
Problem F: Olympic Games ............................................................................................................... 25
Problem G: Matrix ............................................................................................................................ 27
Problem H: String covering ............................................................................................................... 31
Problem I: Polygons .......................................................................................................................... 34
Qualification ............................................................................................................................ 37
Problem R1 01: November Rain (code: RAIN1) .................................................................................. 39
Problem R1 02: Ambiguous Permutations (code: PERMUT2) .............................................................. 41
Problem R1 03: Roll Playing Games (code: RPGAMES) ....................................................................... 43
Problem R1 04: Manhattan Wire (code: MMAHWIRE) ....................................................................... 45
Problem R1 05: Spheres (code: KULE) ................................................................................................ 48
Problem R1 06: Sightseeing (code: GCPC11H) .................................................................................... 52
Problem R1 07: Segment Flip (code: SFLIP) ........................................................................................ 54
Problem R1 08: K12 - Building Construction (code: KOPC12A) ............................................................ 57
Problem R1 09: Its a Murder! (code: DCEPC206) ................................................................................ 59
Problem R1 10: Words on graphs (code: AMBIG) ............................................................................... 61
Problem R2 01: Zig-Zag Permutation (code: ZZPERM) ........................................................................ 63
Problem R2 02: DEL Command II (code: DELCOMM2) ........................................................................ 65
Problem R2 03: Boxes (code: BOX) .................................................................................................... 67
Problem R2 04: Cryptography (code: CRYPTO) ................................................................................... 72
Problem R2 05: Slow Growing Bacteria (code: SBACT) ....................................................................... 74
Problem R2 06: Reverse the sequence (code: REVSEQ) ...................................................................... 76
MDCS Bubble Cup 7DC
Problem R2 07: Cover the string (code: MAIN8_E) ............................................................................. 78

Problem R2 08: Dynamic LCA (code: DYNALCA) ................................................................................. 80
Problem R2 09: Magic Bitwise AND Operation (code: AND) ............................................................... 82
Problem R2 10: Contaminated City (code: 1CONTCITY 19).................................................................. 84
Problem R3 01: Four Mines (code: MINES4)....................................................................................... 87
Problem R3 02: Lost in Madrid (code: LIM) ........................................................................................ 93
Problem R3 03: Circles (code: CIRCLES) .............................................................................................. 96
Problem R3 04: Bridges! More bridges! (code: BRII) ......................................................................... 100
Problem R3 05: Polynomial f(x) to Polynomial h(x) (code: POLTOPOL).............................................. 103
Problem R3 06: Factorial challenge (code: FUNFACT) ....................................................................... 105
Problem R3 07: Hi6 (code: HISIX)..................................................................................................... 106
Problem R3 08: Frequent values (code: FREQUENT) ......................................................................... 109
Preface
Dear Finalist of BubbleCup 5,
Thank you for participating in the fifth edition of the Bubble Cup. On behalf of Microsoft Development
Center Serbia (MDCS), I wish you a warm welcome to Belgrade and I hope that you will enjoy yourself.
MDCS has a keen interest in putting together a world class event. Most of our team members participated
in similar competitions in the past and have passion for solving difficult technical problems.
This edition of the Bubble Cup is special. It is its fifth anniversary and it is the most international event that
we have had so far. Not only do we have the participants from the region (Bulgaria, Croatia, Serbia) but
teams from Germany and Poland fought their way to the Finals too. This means that BubbleCup is reaching
more and more fans every year.
Given that we live in a world where technological innovation will shape the future, your potential future
impact on humankind will be great. Take this opportunity to advance your technical knowledge and to build
relationships that could last you a lifetime. I wish you all warm welcome to Belgrade.
Thanks,
Dragan Tomi
MDCS Group Manager/Director
MDCS Bubble Cup 7DC
About Bubble Cup and MDCS

BubbleCup is a coding contest started by Microsoft Development Center Serbia in 2008 with a purpose of
creating a local competition similar to the ACM Collegiate Contest, but soon that idea was outgrown and
the vision was expanded to attracting talented programmers from the entire region and promoting the
values of communication, companionship and teamwork.
The contest has been growing in popularity with each new iteration. In its first year close to 100
participants took part and this year while in 2012 this number is over 500.
This year the emphasis was on keeping intact all of the things that made BubbleCup work in previous years
but taking every opportunity to tweak and subtly improve the format of the contest. The third qualifying
round was added this year, where contestants had the opportunity to choose the problems themselves.
Microsoft Development Center Serbia (MDCS) was created with a mission to take an active part in
conception of novel Microsoft technologies by hiring unique local talent from Serbia and the region. Our
teams contribute components to some of Microsofts premier and most innovative products such as SQL
Server, Office & Bing. The whole effort started in 2005, and during the last 7 years a number of products
came out as a result of great team work and effort.
Our development center is becoming widely recognized across Microsoft as a center of excellence for the
following domains: computational algebra engines, pattern recognition, object classification, computational
geometry and core database systems. The common theme uniting all of the efforts within the development
center is applied mathematics. MDCS teams maintain collaboration with engineers from various Microsoft
development centers around the world (Redmond, Israel, India, Ireland and China), and Microsoft
researchers from Redmond, Cambridge and Asia.
MDCS Bubble Cup 7DC
Bubble Cup Finals 7DC

Problem set & Analysis
Taken from xkcd.com A web comic of Romance, Sarcasm, Math, and Language
MDCS Bubble Cup 7DC
BubbleCup Finals 2012
Finals 2012
The finals of BubbleCup 5 were held on September 8th 2012, with 17 teams competing at the Faculty of
Electrical Engineering in Belgrade. There were 9 problems and five hours to solve them.
The were no changes to the rules from the previous years. As a reminder: the team which solves the most
problems wins. In case of ties, the team with less penalty points (gained for incorrect submissions and
deducted based on qualification results) is preferred. Programming style is not taken into account.
The difficulty of the problems was relatively balanced no problem was solved by more than 12 teams
(unlike last year, when 3 problems were solved by every team), and one problem remained unsolved. The
accent was mostly on problems which required original thinking, with only a few that were tricky to
implement.
14
12
10
8
6
4
2
0
Good Sets Wheel Of MaxDiff
Fortune
Cars
Triangles Olympic
Games
Matrix
String Polygons
covering
Figure 1. Number of accepted solutions per problems

60
50
40
30
20
10
0
Good Sets Wheel Of MaxDiff
Fortune
Cars
Triangles Olympic
Games
Matrix
String Polygons
covering
Figure 2. Number of submissions per problems

The competition was initially very close, but towards the end the team koko koko euro spoko pulled away
from the rest and had no problems winning the first place with 8 solved problems. The fight for second and
third was very exciting and continued until the last couple of minutes. In the end the second place went to
S-Force and the third to Suit Up! (finishing in the top three for the third consecutive year).
9
MDCS Bubble Cup 7DC
Problem A: Good sets

Similar to the previous year, the Scientific Committee decided to give some special awards:
The first accepted solution - Silver lightning: koko koko euro spoko (Poland)
The shortest accepted solution - Vertipaq coders: H-Rast (Croatia)
The most persistent team - while (! accepted): The Code Breathers (Gemany)
BubbleCup friend - The best mentor: Dusko Obradovic, team Gimnazija Sombor (Serbia)
ID
A
B
C
D
E
F
G
H
I
Problem Name
Good Sets
Wheel Of Fortune
MaxDiff
Cars
Triangles
Olympic Games
Matrix
String covering
Polygons
ACC/ SUB ratio

0.39
0.34
0.24
0.20
0.34
0.05
0.37
0.17
/
Min elapsed until first

accepted solution
33
15
17
201
87
211
167
104
/
Table 1. Statistic for time and accepted / submitted ratio

The Scientific Committee would like to thank all the teams and individuals for their interest, enthusiasm
and hard work.
MDCS Bubble Cup 7DC
10
BubbleCup Finals 2012

Author: Milan Vugdelija
Implementation and analysis: Milan Vugdelija
Statement:
Let be the set
properties:
, where
is a given natural number. Set B is called good if it has the following
a)
is a subset of ;
b) For every , if belongs to , then
doesn't belong to ;
c) No other set can have properties a) and b) and a greater number of elements than ;
For example, if
good, while
superset of ).
, then
is not good (note that set
Given positive integer numbers
and
, and the set

is
from the third property doesn't have to be a
compute the following:
The number of elements in every good set;

With how many zeros the total number of good sets ends, if written in base .
Input:
The first and only line of input contains two integers
and , separated with one empty space,
representing cardinality of the set and the given base , respectively.
Output:
Output contains only one line with two integers, separated with one empty space: the number of elements
in every good set and number of zeros at the end of the total number of good sets in base , respectively.
Example input:
Example output:
12 3
8 1
Example explanation:
All good sets consist of 8 elements and there are 6 of them - 6(10) = 20(3).
Constraints:
Number
is a prime number.
Time and memory limit: 0.5s / 64 MB
Solution and analysis:

Divide set into chains such that each chain starts with an odd number from
doubled values from . For example, if
, set is
11
and contains repeatedly

and the chains
MDCS Bubble Cup 7DC

are
,
,
, , , . Here the first chain contains elements, the second chain
, the third , and there are three one-element chains. Now elements are chosen from each chain
independently.
Let us denote with
the maximal number of elements from a chain of length such that no two are
consecutive. It is not hard to see that if a chain has an odd number of elements, there is only one way to
pick the maximal number of elements from that chain (take every element with an odd index). So, for a
chain with
elements, that maximal number is . In other words, we have that
.
For chains with an even number of elements, say , maximal number of elements that can be taken is .
Can we apply some sort of induction here? For
elements we see that we must use
exactly one element out of the last two (because otherwise we would have to select
elements from
, which is not possible by induction). If we choose the last one, then from the first
we must select of
them and this can be done in
ways. In the second case, if we do not select the last one, then we
would have to select
elements from first
. From prior discussion we have that there is only
one way to do this. Now we have:
Finally, from induction we have that
, because
It remains to count chains of each different length, add up maximal numbers of elements for each chain,
and multiply ways to choose such elements from each chain. Actually, instead of computing the exact
number of ways to form a good set, it is required only to compute how many times this number is divisible
by a given prime number .
MDCS Bubble Cup 7DC
12
Problem B: Wheel Of Fortune

Author: Draen ari
Implementation and analysis: Draen ari
Statement:
You are on a quiz show playing the game Wheel of Fortune. The wheel has fields of the same size, and
each field
is associated with a value:
. Each time you spin the wheel you have
equal probability of hitting any of the fields. You will spin the wheel times. When you spin the wheel
for the -th time and it stops on field , if it is your first time hitting that field,
dollars is added to your
prize and field gets marked. If the wheel stops at a marked field, meaning you've hit that field in some of
your previous spins (
), your score does not increase.
What is the expected value of the prize you'll take home?
Input:
The first line contains two integers, number of fields on the wheel, and number of times you get to
spin the wheel. The following
lines contain one integer each, representing values of the fields .
Output:
Output contains exactly one real number expected value of your overall prize, rounded to 5 decimal
places.
Example input:
Example output:
2 2
10
20
22.50
Constraints:

In order to calculate the expected prize value, we can observe the expected value that we can gain from
each field. By the rules of the game, for each field we can get either 0 points if we never hit that field in
our
spins, or exactly
points if we hit at least once (i.e. we get the same score for field no matter how
many times the wheel stops at that field). Thus, the expected overall prize can be calculated as the
expected sum of prizes each field will give us, so we have:
13
MDCS Bubble Cup 7DC
Given that we have fields of the same size, and we are making random draws (i.e. wheel spins), it is
obvious that for each field of the wheel we have the same binomial distribution over the number of hits
after
spins:
( )
Here
stands for the probability of exactly
field in a single spin, so
hits after
spins, and
denotes probability of hitting the
Now we can write the distribution over prize value for each field:
(
In order to avoid dealing with binomial coefficients, we can rewrite the above distribution in simpler terms:
(
so we end up with:
(
Finally, we can calculate the expected overall prize as:

[
which yields an easy
MDCS Bubble Cup 7DC
) )
solution.
14
Problem C: MaxDiff
Problem C: MaxDiff
Author: Milan Novakovi
Implementation and analysis: Andrija Jovanovi
Statement:
You are given an array of integers of length . We will define
as the sum of absolute differences
between all pairs of consecutive elements in . More formally, assuming that is zero-based:
|
|
Your task is to find the permutation
of the array
for which the value
is maximized.
Input:
The first line of input will contain one integer , representing the size of the array . The second line will
contain space-separated integers, representing the elements of the array.
Output:
The first and only line of output should contain a single integer equal to the largest sum of differences of
consecutive elements obtainable from as described in the problem statement.
Example input:
Example output:
3
2 3 5
There are six possible ways to reorder the array:
The sums of differences are then respectively
.
and , and the largest among them is .
Constraints:

It is obviously infeasible to generate all permutations of , calculate the value for each one and pick the
maximum, so lets try to observe some things about the problem that will help us reduce the space of
possible solutions.
We will assume that all elements in the array are distinct. The proofs for the case when equal elements are
allowed are slightly more difficult and there is a number of corner cases that have to be taken care of, so
they will be left to the reader as an exercise
First, lets notice a relatively obvious but very important fact: there will always exist an optimal solution in
15
MDCS Bubble Cup 7DC
Problem C: MaxDiff
which the elements are sorted in a zig-zag manner, i.e. it will not contain a triple of consecutive elements
such that
(or
). Proving this is easy: if we have a
triple satisfying this condition, we can just pull out its middle element and place it at the end of the array
it is trivial to verify that cannot decrease after this transformation.
The other fact is slightly harder to notice. Lets denote the median of with . (A reminder: the median of
an array is the middle element of the sorted array if the number of elements is odd, and the average of the
two middle elements if the number of elements is even). Clearly depends only on the elements of and
not on the permutation. We will prove the following:
Lemma. There is an optimal solution in which there are no two consecutive elements that are either both
larger or both smaller than the median.
Proof. The first thing to notice here is that, due to the zig-zag principle discussed above, an optimal
solution cant contain a sequence of exactly two consecutive elements on the same side of the median.
Lets assume that there are at least three such consecutive elements. It is easy to see that we can always
pick exactly three consecutive elements from this sequence such that
. Since the
rest of the array now has at least two more elements that are under the median than elements that are
over it, we can use the same reasoning to conclude that somewhere else in the array there are three
consecutive elements under the median, ordered as
. Since
(the former is over the median and the latter under it), we can swap these two elements and get a solution
that preserves all the inequalities and is strictly better than the previous one.
Now we have enough information to deduce the most important statement:
If the order of elements in A satisfies the two principles described above, its value of S is
|
where
is the median of A.
It should be clear that this holds from the following argument: since for all
arent on the same side of the median, their absolute difference is |
|
|. For each element except the first and the last one the term |
final sum, while for the two edge elements it appears just once.
elements
and
| |
|
| appears twice in the
This gives us the final step in the solution: since all terms in the sum are non-negative, we just have to
| |
|. If the total number of elements is even, we pick the two
minimize the value |
middle elements for the ends otherwise the zig-zag property would not hold. If it is odd, we pick the
median element at one end and the element closest to it by absolute value at the other.
Note that we dont even have to generate the exact permutation, since all permutations
constructed
in this way will have the same value
and the above discussion gives us the guarantee that
permutations which dont satisfy these conditions cannot possibly result in a better solution.
The implementation ends up being very simple: first we find the median of the array A, then we find the
edge elements as described in the previous paragraph, and finally we sum up the absolute differences of
the elements from the median, multiplying by two for all except the leftmost and the rightmost element.
There are still some traps that need to be avoided edge cases with a very small number of elements need
to be dealt with, the solution has to be kept in a 64-bit value, repeating values can pose a problem for
MDCS Bubble Cup 7DC
16
Problem C: MaxDiff
certain implementations. However, none of that should present a serious challenge for any competitor with
decent technique.
Complexity
There is a choice for the algorithm used to calculate the median. The simplest way is to sort all the
elements and pick the one(s) in the middle, which takes
time. We can do better the wellknown quickSelect algorithm gives expected
time. Although its running time depends on the pivot
choice and its worst-case complexity is
, median-of-three or just random pivot choice should be
enough since none of the test cases targeted this scenario (at least not intentionally). For the more
paranoid contestants, the pivot can be chosen using the median-of-medians algorithm, which guarantees
running time but is tricky to implement and slower on average than simple quickSelect.
The rest of the algorithm can be done in a single pass of the array, giving an overall
of the algorithm. The memory complexity is obviously
.
17
time complexity
MDCS Bubble Cup 7DC
Problem D: Cars
Problem D: Cars
Author: Mladen Radojevi
Implementation and analysis: Dimitrije Filipovi
Statement:
There are cars parked at the parking lot and a new car is arriving. The parking lot is a space between two
walls and cars are parked along one line between those walls. The driver will park his car if there is a free
parking spot that is long enough (at least as long as the car). Otherwise, he will have to move a few cars in
order to make appropriate space for his car. The car can be moved to the left or to the right along the
parking lot, but at most until it reaches a wall or another car.
Your task is to find the minimal total distance by which currently parked cars have to be moved in order to
provide enough space for the arriving car.
Figure 1. Optimal car moves for the given example.
Input:
The first line of input contains three space-separated integers ,
and
. They denote the number of
cars already parked, the coordinate of the left wall and the coordinate of the right wall, respectively. Each
of the following lines contains two integers, describing a parked car: the coordinate of the leftmost
point of the car, and the length of the car. The last line of the input contains one integer
, the
length of the arriving car.
Output:
Output contains only one line with one integer the sum of distances by which parked cars have to be
moved to provide enough space for the arriving car. If a solution doesnt exist the output should be
.
Example input:
Example output:
4 0 22
2 3
7 3
11 2
16 4
7
The best way is to push the second car to the left by 1, the third car to the left by 2 and the fourth car to
the right by 2. It will create an empty space of length 7, so the new car can be parked there. The sum of all
movement lengths is 5 (= 1 + 2 + 2).
MDCS Bubble Cup 7DC
18
Problem D: Cars
Constraints:

Lets enumerate the cars with 1 to from left to right. (To be able to do that, we will need to sort the array
of cars first). Consider each car in turn. For each car , find the first car
such that the sum of free
parking spots between and is greater than the length of the new car. For each such pair
we will find
the optimal solution, and then use these to compute the global minimum.
Lets consider a given pair of cars
. In the case that the pair
also satisfies the total empty
length constraint, we can narrow down the search space by removing car from the set of cars for which
we will consider moves. We will repeat this process as long as removing the leftmost car will still satisfy the
total empty space length constraint. Lets denote the leftmost car remaining in this set with .
Lets enumerate empty spaces between cars and with numbers

space
such that
. We will find the first empty
. We will move every car in the direction of
whichever car ( or ) is closer to it, in order to reduce the total distance covered. In this way, the upper
bound on the distance any given car can move is
, whereas if we moved any car in the
other direction (to the car which is farther away from it) this upper bound would be greater.
Lets define four values for every car:
Cost for moving car to the leftmost position possible

(if all cars before it were parked consecutively from the left wall, with no space between cars).
total cost for moving all cars from 0 to (inclusive) to the left wall.
Another pair of arrays
, representing free space and total cost of moving to the right wall.
These values can be pre-computed in
time with two passes through the array.
We would like to compute the cost of moving all cars between and away from the middle ( ), without
moving any other cars.
19
MDCS Bubble Cup 7DC
Problem D: Cars
m
Consider only cars
(The rightmost car moved to the left) and
. We will separately calculate the cost
of moving cars to the left and to the right. The cost can be calculated in the following way:
The cost of moving car
and all cars left of it to the left wall is
If we moved all cars left of car

(inclusive) to the left wall and all cars from to to the car , the cost
difference between this configuration and the previous is
. (It is the cost of moving
cars to the right by the sum of empty spaces left of ).
Now we can determine the cost of moving only cars from

difference between this configuration and the previous is
to
to the left towards car . Since the cost

,
This cost can be calculated as
In the same way (using pre-computed

), we can determine the cost of moving remaining cars
between and to the right in the consecutive configuration without moving .
The only issue here is that we may have created more space than what is needed for the new car. To
reduce the cost we should first compare
and
(the number of cars we moved to the left and
the number of cars we moved to the right).
Let
be the sum of empty spaces between cars and , and let be the space we created for the new car.
Lets say that

In this case, the cost for creating the empty space to fit the new car should be reduced by
MDCS Bubble Cup 7DC
20
Problem D: Cars
In the case that we moved more cars to the right than to the left the same logic applies using the values
from
and
After calculating
for each car as a first car ( ), we should easily be able to pick the best one.
The time complexity of the solution is dominated by the initial sort the rest of the algorithm is linear. This
means that the overall time complexity is
.
21
MDCS Bubble Cup 7DC
Problem E: Triangles
Author: Mladen Radojevi
Implementation and analysis: Mladen Radojevi
Milan Vugdelija
Statement:
You are given an array of positive integers. Find the maximal substring (i.e. a subset of at least three
consecutive elements of the array) so that any three distinct elements from that substring can form the
sides of a triangle. Also, find the maximal subsequence (a subset consisting of at least three elements, not
necessarily consecutive) with the same property.
Input:
The first line of input contains one integer , the number of elements in the array. The next
the elements of the array.
lines contain
Output:
Output consists of exactly two lines, each containing one integer the length of the maximal substring and
the maximal subsequence with the property described above, respectively. If such substring or
subsequence doesnt exist, the corresponding value is zero.
Example input:
Example output:
5
60
30
20
40
60
3
4
Constraints
Elements of the array are positive integers, each less than or equal to

Input size limit 100000 suggests that any solution to this problem should work in
faster).
time (or
Part a (substring):
To verify that some substring fulfills the requirement, it is enough to check if the sum of two smallest
numbers in a substring is greater than the largest number in that substring. Indeed, if the inequality holds
for these three elements, it will hold for any three numbers in that substring.
There are several ways to find the length of the longest such substring, two of which will be explained here.
MDCS Bubble Cup 7DC
22
Solution 1:
Suppose that we want to check if there exists a substring of length with the described property. We can
divide input array into slots of length (the last slot may have less than elements). For each slot
, we can compute the following arrays:
-
Prefix maximum:
Suffix maximum:
Prefix minimum:
Suffix minimum:
Prefix second minimum:
Suffix second minimum:
With this pre-calculation, we can find the maximum, minimum and second minimum of any substring of
input array of length in constant time. Namely, any substring of length covers entirely one slot or lies in
two consecutive slots, so min and max are straightforward to compute using suffix arrays of the left slot
and prefix arrays of the right slot, while computing second min requires several comparisons between
minima and second minima of two parts of the substring.
Acting as described, it is possible to check all substrings of length
gives us an
algorithm for the original problem.
in linear time. Doing binary search on
Solution 2:
We start with the substring consisting of the first three elements of the input array. If the current substring
has the required property, we move the right boundary of the substring forward, introducing a new
element into it; otherwise we move forward the left boundary of the substring, removing one element
form the substring.
To check if the substring has the triangle property, we can use one heap that extracts maximum, and one
that extracts minimum - lets call the heaps and respectively. When the right boundary moves, we just
put a new element into both heaps. Moving the left boundary requires removing one particular element
from both heaps. Instead of removing that element immediately, we can use two auxiliary heaps (again,
one for max and one for min, call them
and
) and put the element that should have been removed
there. As long as that element is not equal to max of the heap , it doesnt matter if it is present in the
heap or not. So every time we extract the max of heap , we also extract the max of
; if they are not
equal, the max is regular and we can use it (we just put back the max of
); if the two maxima are equal,
we do the (delayed) removal from both and
, and get another max from both until they differ. We do
the same with heaps and
for extraction of the minimal element.
Getting min/max from the heap and putting a new element into all 4 heaps requires
time, so we
can check one particular substring in logarithmic time. Since after each check one of the substrings
boundaries moves forward, there are
substrings to check, so the total running time is again
.
Part b (subsequence):
It is easy to prove that if some elements of a sorted array form a subset with the described property, then
the entire segment (from minimal to maximal element of the subset) also has the property. So, , the
maximal subset of the original array with the described property is a substring of the sorted array.
Therefore, to solve part b, it is enough to sort the input array and then search for the longest substring
23
MDCS Bubble Cup 7DC
using (any) solution of part a. The running time of such algorithm would be
log n) for finding the longest substring, which gives
in total.
for sorting and O(n
It is also possible to find the longest substring with the given property in a sorted array more directly.
Obviously, the two smallest elements are the first two elements of a substring, and the largest is the last
one, so there is no need to use heaps or auxiliary prefix/suffix arrays to find minima and maxima of a
substring. The running time in this case is still
due to sorting, even though finding the longest
substring in a sorted array can be done in linear time.
MDCS Bubble Cup 7DC
24
Problem F: Olympic Games

Authors: Mladen Radojevi
Implementation and analysis: Mladen Radojevi
Statement:
Young boy, Oliver, has watched the Olympic Games this year for the first time. The number of countries
which participated in the Olympics is . There are
different sports and each country had its own
representative in some of the sports. In each sport the gold medal is won by exactly one country among
the ones that have representatives for that sport. And, of course, for every sport there is at least one
country which competes in it.
Oliver noticed that a small number of countries won a huge number of gold medals, and that a lot of
countries didnt win any. Now, he is wondering what could be the minimal difference in the number of gold
medals between the country which took the most and the country which took the least. Oliver is still too
young to figure out the answer to this question, so please help him.
Input:
The first line contains , the number of participating countries. The second line contains , the number of
sports. The third line contains the total number of competitors, . Each of the next m lines contains two
integers, and , which mean that country had a representative in sport .
Output:
Output contains only one integer the minimal possible difference in the number of gold medals between
the country which took the most gold medals and the country which took the least.
Constraints:
No pair
for each
is contained in the input more than once
Example input:
Example output:
3
4
6
0
0
0
1
1
2
0
1
2
2
3
3
25
MDCS Bubble Cup 7DC

Lets describe the algorithm for solving this problem. Initially, no sport is assigned to any country. Going
circularly through all countries we try to assign new sport to the currently considered country, while
maintaining the number of sports assigned to other countries (actually, we try to find an augmenting path
in a bipartite graph which starts from the country being considered and ends at some yet unused sport). If
at some moment no new augmenting path for a particular country exists, we can skip that country in all
subsequent iterations in order to save time. Since for every sport there is at least one country which
competes in it, after a certain number of iterations each sport will be assigned to some country.
By this algorithm we get a matching where the number of gold medals taken by country with the minimal
number of gold medals is maximal and the number of gold medals taken by the country with the maximal
number of gold medals is minimal. Therefore, this matching has the desired property that the difference
between these two values is minimal.
As the number of iterations which can find augmenting paths is at most
(there are at most
unsuccessful findings) and each augmenting path can be found in
time, where is the number of
edges, the time complexity of the solution is
. The memory complexity is
.
MDCS Bubble Cup 7DC
26
Problem G: Matrix
Problem G: Matrix
Author: Andreja Ili
Implementation and analysis: Andreja Ili
Statement:
You are given a square binary matrix of dimension
. Elements on the main diagonal are all ones.
th
We want to compute the
power of this matrix (MDCS written in ASCII codes is
). To make things more interesting, we will define binary operations
(addition) and
(multiplication) as the following:
+
0
1
0
0
1
1
1
1
0
1
0
0
0
1
0
1
So basically, addition is logical OR and multiplication is logical AND.

The input matrix is too big for normal time constraints, so it will be given by listing all positions of ones in it.
th
Also, for the output only the number of ones in the
power of the matrix is sufficient.
Input:
The first line contains two integers, and - dimension of the square matrix
it. Each of the next lines contains two integers and which means that
and the number of ones in

is equal to
Output:
th
Output contains only one integer the number of ones in the

Example input:
Example output:
4
1
1
1
2
2
3
3
4
11
8
1
3
4
2
3
1
3
4
power of the given matrix.
From the input we have that
]. Its
th
power is [
], which has
ones in it.
Constraints:
27
MDCS Bubble Cup 7DC
Problem G: Matrix
Indices and from the input satisfy the condition

and these pairs are unique.
The matrix elements are or 1 and the elements on the main diagonal all ones. All elements that
are not listed in the input have zero value.
Note:
For two square matrices and with dimensions
is product of these two matrices if:
, we say that matrix , with the same dimension,

, for every

At first glance, this problem requires fast multiplication of the sparse binary matrices with a given definition
for operations. This is known and very hard problem for implementation. The standard approach for matrix
multiplication gives as time complexity
which is very big for the problem constraints. Logarithmic
powering is also too slow. But, in our case solution has nothing to do with this this is a graph theory
problem.
Before we start the analysis of this problem, lets look at the adjacency matrix of an arbitrary directed
graph
. As we know, the adjacency matrix is a binary one and its element
is equal to
if and only if there is an edge from vertex to vertex (directed edge). The adjacency matrix is a square
one, so it is allowed to consider powers of this matrix:
for every
. From now on we will assume
that operations are defined as in the problem statement.
Can we, with some corresponding graph property, define the square of the matrix ? The element at
position
is going to be equal to one if and only if there is a vertex such that
and
. This means that
is equal to if and only if there is a path of length in the starting
graph . Using mathematical induction we can prove the following property:
if and only if there is a path from vertex
to vertex
of length .
We have an additional property of the start matrix: elements on the main diagonal are ones. This means
that all of the vertices have loops. In other words, we can circle around any vertex for an arbitrarily long
time. So, if there is a path of length between vertices and , then there is path of length
between
them for every
(we can just append a circle of length
to path). This means that, with the
above property of matrix , we have
if and only if there is a path from vertex
to vertex
of length less than or equal to .
Now we can go back to our original problem. In the input we have a directed graph with vertices and
edges, where every vertex has a loop. From the above definition of the element
, we have that
starting from
power of matrix is not going to change. This is very important, because in this way
we have to calculate the -th power, and of course
. The problem can be reformulated as:
find the number of edges in the transitive closure of the given graph ,
i.e. for every vertex calculate the number of vertices that are reachable from it
Nave approach for the transitive closure leads to complexity
MDCS Bubble Cup 7DC
graph tour, DFS or BFS, from every
28
Problem G: Matrix
vertex separately. A better idea is to find the strongly connected components (SCC) first. In this way,
submatrices for every component have all elements equal to one (so we do not want to waste time
there). After finding the SCCs, we can shrink every component to just one vertex. In this way we can
obtain a directed acyclic graph (DAG).
Figure 1. Creating DAG graph from SCC components
Things are a little bit easier. If we assume that for every component we have a list of all components that
are reachable from it, we can easily transfer this to the start graph and calculate the final result. But how
can we initialize these lists with the given time constraints?
For DAG we can find its topological sort order. We can initialize the lists for every component in this order,
because it holds that by the time when we are examining some component, all components reachable from
it are already initialized. Let us denote with
the current component for which we want to
initialize the list. Unfortunately, we cannot simply connect all lists from their neighbors, because there
can be some duplicates (see Figure 2 for example). On the other hand, these lists can be
long, so the
union of these sets must require passing through them multiple times.
Figure 2. Example of a topological sort and mask arrays (for the case of 2-bit numbers)
The best way to maintain these lists is to store them in some sort of marked array (when a component is
in the list we are going to mark the corresponding element). If we use simple boolean arrays, complexity
will again be
. Idea is to use bit masks. For every component we are going to store an array
of length
of long type. This way we can mark some component
in this
array as
29
MDCS Bubble Cup 7DC
Problem G: Matrix
In other words, for each component there is a unique corresponding bit in every array. Now, we can
initialize the array for
by simply
-ing the arrays for its neighbors element-wise (which
represents union). Note that although the complexity remains
, the reduction of the constant
factor is very significant.
Complexity:
In this problem we have quite a pipeline of graph algorithms. First, the complexity of finding SCCs and
building a DAG is
. Finding the topological order has the same complexity. Finally, performing the
dynamic programming approach for initialization of bit mask arrays as described above has
complexity if we use a 64-bit integer type for bit masks. Indeed, every array is going to be iterated for every
component which has an edge directed at the corresponding component for that array. So, for every edge
we have one tour through some array. This brings us to the final complexity of
Test data:
The data corpus for this problem consists of 24 test cases. Test cases are created with one (or more) of the
following methods:
Random generation of a binary matrix with given probability for and

Generation of a matrix that corresponds to a tree with some additional cross or / and up edges
Generation of a matrix that corresponds to a path with some additional edges
Creating a SCC graph from a tree with cross edges and blossoming a SCC components in every
vertex
Special cases (triangle, all ones, only loops)
Num
00
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
4
10
100
1000
500
2000
2500
3000
3000
3000
5000
4000
3000
5000
5000
5000
5000
5000
5000
5000
5000
1
4500
5000
8
31
5187
1000
125250
161804
127736
5999
36871
193412
161017
67879
182515
9999
59870
194846
179948
196411
189283
188570
184753
1
118341
143657
Comment
test case from problem statement
by hand
Random with
All zeros except on the main diagonal
One in the upper triangle
Random with
Random upper triangle with
Random tree structure
Path with down edges
Expanded SCC graph with
Random with
Random tree structure with cross edges
Random tree structure
Random tree structure with down cross edges
Expanded SCC graph with small
Random with
Path with down edges
Random tree structure with cross edges
Random tree structure with down cross edges
Only one vertex
Components: SCC, Tree, Path, Random
Components: big SCC, Tree, Path, Random
Table 1. Test data description
MDCS Bubble Cup 7DC
30
Problem H: String covering

Author: Andreja Ili
Implementation and analysis: Andreja Ili
Statement:
We say that string covers string if can be obtained by putting together several copies of string ,
where overlapping between two successive copies of is allowed but the overlapped parts must match.
After connecting these copies the whole generated string must match string .
For example, string
covers string
does not cover , because the last character
, with two copies (see Figure 1). String

cannot be covered.
Figure 1. All possible coverings of string
You are given string . Write a program that calculates how many strings
way.
exist that cover string
in this
Input:
The first and only line of the input contains string .
Output:
Output contains only one integer the number of different strings that cover given string .
Constraints:
String consists exclusively of letters a - z.

Output the final solution modulo
.
Example input:
Example output:
ababab

Problem H on this years BubbleCup finals was a string problem. For a given string it was asked to find
how many strings there exist that covers this string. We say that string
covers string if can be
31
MDCS Bubble Cup 7DC

obtained by putting several copies of string where overlapping between two successive copies of is
allowed but the overlapped parts must match. After connection of these copies whole generated string
must match string . First thing that we can observe is that necessary condition for string is that it is
some prefix of the string . So, the asked modulo in the task description is only a small trick.
Now we know that the final answer is going to be smaller or equal to (solution is equal to if and only if
all char in are equal). Nave approach would be to check every prefix of the string . When testing for the
prefix
we have to find all occurrences of it as substrings in
and then see if these
occurrences covers whole string (here we can see that string has to be an suffix as well). Complexity of
this algorithm is approximately
, but it can be reduces to quadratic with some hash functions for
substrings. In any case this is too big for our constraints.
Can we, in some other way, track these occurrences for prefixes? Let us assume that for the prefix
occurrences in the string starts at positions
. For the prefix
start positions
are subset of the start positions for . Idea is to store these occurrences in some nice way that can be
updated fast when adding new character on the end (moving to the next prefix).
For this we can use data structure: suffix array. Let us denote with suffix array is equal to the start
position of the -th suffix in the lexicographic order. Then the positions for prefixes
are successive in the
array . For every prefix we can define some segment in the suffix array
which means that suffices in
this segment starts with given prefix. Nice thing is that these segments create an inclusive chain:
. In this way we can easily obtain segments.
Figure 1. Example of suffix array and prefix check.
Now we have the start positions of occurrences for any prefix. Problem is to, in some efficient way, see if
they cover the whole string . For this we must use additional data structure max heap. In heap we are
going to store the lengths between two successive positions - gaps. When we remove some occurrence, we
will remove two distances / gaps (from prior to current one and from current one to next occurrence) and
add the new one which is the sum of the removed ones (from prior to next). Finally, we can state that
current prefix covers the whole string if and only if the max element in the heap (max distance between
two successive occurrences) is smaller or equal to the prefix length.
==========================================================================================
01 initialization of the suffix array S;
02 sol = 0;
03 for k = 1 to n - 1 do
MDCS Bubble Cup 7DC
32

04
add in heap key-value pair (k, 1);
05 segmentLeft = 1; segmentRight = n;
06 for k = 1 to n do
07
while (char at position k of segmentLeft-th suffix is different from A [k]) do
08
remove from heap key prior and segmentLeft;
09
add in heap key-value pair (prior, next prior);
10
inc(segmentLeft);
11
while (char at position k of segmentRight-th suffix is different from A [k]) do
12
remove from heap key prior and segmentLeft;
13
add in heap key-value pair (prior, next prior);
14
dec(segmentRight);
15
16
if (max in heap <= k)
17
inc(sol);
18 endfor
==========================================================================================
Figure 1. Pseudo code for described algorithm
Complexity:
Sorting the suffixes with suffix array takes
time. This can be implemented in the linear time but
in our case this is sufficient. After that for every prefix, in order as in the given string, we are going to
maintain the above segments in linear time overall (in every step we are going to shrink current segment
with only one compering of chars). For heap, every position is going to be added exactly one time and
removed at most one time. Taking all of this in to account we get the final complexity:
.
Test data:
Test corpus consists of 15 test cases. In the random string we can expect only one covering string the
string itself. Many ideas for test generation is to create some recursive string that has many occurrences
of prefixes in it. The worst case for this is to use small number of different chars. Description of the test
data with some comments is given below.
Num
00
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
6
45690
90010
90000
80.000
10.002
98.904
50.003
96.048
99.999
99.999
78950
100.000
1
90.000
100.000
Solution
3
9138
10
10000
1
3334
8242
1
16
1
99.999
3158
1
1
5628
100
Comment
Concatenation of the string
Many with random char
Random concatenation of strings
String is of the form
All chars are the same
Concatenation
Many with random char
Only one char
with random change
and
with some
Table 1. Test data description
33
MDCS Bubble Cup 7DC
Problem I: Polygons
Problem I: Polygons
Author: Miroslav Bogdanovi
Implementation and analysis: Miroslav Bogdanovi
Statement:
You are given
points with integer coordinates in the plane. After that you are given
queries.
Each query gives you a list of indices in the originally given set of points. The points in this list form a simple
polygon (one that does not intersect itself). For each query you should output how many points from the
original set are on the inside of the given polygon.
Input:
The first line of the input contains two integers and q, separated with an empty space. Next lines each
contain two numbers, and - coordinates of a point. The lines that come after that each start with a
number , the number of points that form that polygon. The rest of the line consists of space-separated
numbers that represent indices (indices are from to
) of originally given points that form the
polygon.
Output:
You should output lines, one for each query. Output for each query should be just one integer number:
the number of points from the original set on the inside of the polygon given in that query.
Example input:
Example output:
7
0
0
4
4
2
3
2
3
3
1
2
2
0
4
0
4
1
2
3
0 1 3
0 2 3
First polygon is a triangle whose vertices are
Second triangle has the vertices
and
and
. There is one point on its inside:
. There are two points on its inside
and
.
.
Figure 1. Visualization of the given example.
MDCS Bubble Cup 7DC
34
Problem I: Polygons
Constraints:
Coordinates of a point are in the segment

.
No two points are the same. Also, no three different points are on the same line.
Vertices of the polygon do not count as being inside of it.

Taking each query and checking each point is on the inside of that polygon in a straightforward manner
would take
time, which is too slow for the given constraints.
We are going to deal with this by precalculating some things, which will allow us to answer each query in
linear time with respect to the number of vertices of the polygon. For each two points from the original set,
we calculate the number of points under the line segment connecting them (that are contained in the
quadriteral formed from the endpoints of the line segment and their projections on the axis; we dont
count points on the edges of this quadriteral). Also, we calculate the number of points directly under each
point from the set (i.e. the ones that have equal and smaller coordinates).
under[A][B] = 3
A
B
directly_under[A] = 1
directly_under[B] = 0
Figure 1. What is precalculated.
First we sort the points by coordinate, sorting points with equal by . The number of points directly
under each point is easily calculated in linear time from this sorted array.
Now for each point (well call it point A) we take all the points after it in this sorted array (those that have
larger , or equal and larger coordinate) and sort them by angle in respect to point A. We go through
these points in this order (well call the current point B). For each point A we keep an array that counts the
number of times each coordinate has appeared in points B that we went through until now. We keep this
array as a cumulative table in order to be able to do insertions and calculations of the sum of the first
elements in
time for each operation, where
is the maximal value of coordinates
among the set of points. For each point B we do the following:
1. We add 1 to the cumulative table in the position of the coordinate of point B.
2. We calculate the number of points under the line segment A-B as sum in cumulative table to the
position of the coordinate of point B 1.
35
MDCS Bubble Cup 7DC
Problem I: Polygons
Not done
Current point
B
A
Done
0 0 1 1 0 1
Figure 2. A typical state of a precalculation step.
We respond to each query in the following way. We go through the polygon in clockwise direction and for
each edge, if it goes to the right (the coordinate of its second point is larger than the coordinate of its
first point) we add the number of points under that edge to the sum, otherwise we substract this number
from the sum. For each vertex, if we go through it going to the right (the edge coming into it and the one
going out of it are both to the right) we add the number of points under it to the sum, if we go through it
going to the left we substract the number from the sum.
Clockwise
direction
Figure 3. Responding to a query.
After going through all edges and vertices of the polygon, each point outside of the polygon is counted zero
times and each point on the inside of the polygon is counted exactly once, which is exactly what we need.
Complexity:
Time complexity of initial calculation is
time. The total complexity is therefore
MDCS Bubble Cup 7DC
. After that each query is resolved in

.
36
Qualifications
Qualification
The qualification rounds were originally intended to have the same format as in the previous years two
rounds with 10 problems each, with each problem in the first round being worth 1 point and each secondround problem being worth 2 points. The most important change was that the Timus online judge system
was no longer used - Sphere Online Judge (www.spoj.pl) provided the problems and the judging system this
year.
BubbleCup has continued getting more and more popular with every year, and this years edition again
broke all the records, with 109 teams submitting at least one correct solution. It also continued spreading
geographically, with teams from countries such as Germany, Poland, Taiwan and Vietnam participating for
the first time and having lots of success as well one German and one Polish team ended up participating
in the finals.
Team results chart [overall]
11
16
21
26
31
36
41
46
51
56
61
66
71
76
81
86
91
96 101 106
The strength of the teams has increased as well. The tasks were not any easier than in the previous
editions, but the results were excellent. This meant that 29 teams solved all problems in the first round,
and 4 of those solved all problems in the second round as well, so for the first time in BubbleCup history
there was a team which got the maximal number of points in the qualifications. This record-breaking team
was Vanja, Nenad and the sandwich maker, and they were quickly followed by S-Force, N0 Ex1t and
koko koko euro spoko.
In the end, the problems from the qualification rounds were solved so well that it was not possible to
separate the teams. So the scientific committee decided to organize a third round for the first time in
BubbleCup history. In the third round, teams with 26 points were called upon to select tasks for each other
to solve, adding yet another strategic dimension to the contest.
The full statistics from the qualification rounds are shown in the tables below:
Num
01
02
03
04
05
06
07
08
09
10
Problem name
November Rain
Ambiguous Permutations
Roll Playing Games
Manhattan Wire
Spheres
Sightseeing
Segment Flip
Building Construction
Its a Murder!
Words on Graphs
Code
RAIN1
PERMUT2
RPGAMES
MMAHWIRE
KULE
GCPC11H
SFLIP
KOPC12A
DCEPC206
AMBIG
Accepted solutions
65
172
50
44
67
58
43
114
104
51
Table 1. Statistics for Round 1
37
MDCS Bubble Cup 7DC
Qualifications
Num
01
02
03
04
05
06
07
08
09
10
Problem name
Zig-Zag Permutation
DEL Command II
Boxes
Cryptography
Slow Growing Bacteria
Reverse the Sequence
Cover the String
Dynamic LCA
Magic Bitwise AND Operation
Contaminated City
Code
ZZPERM
DELCOMM2
BOX
CRYPTO
SBACT
REVSEQ
MAIN8_E
DYNALCA
AND
CONTCITY
Accepted solutions
25
17
4
34
44
35
48
28
30
32

Num
01
02
03
04
05
06
07
08
Problem name
Four Mines
Lost in Madrid
Circles
Bridges! More bridges!
Polynomial f(x) to Polynomial h(x)
Factorial Challenge
Hi6
Frequent Values
Code
MINES4
LIM
MINES4
BRII
MINES4
FUNFACT
HISIX
FREQUENT
Accepted solutions
5
11
9
9
10
10
8
11
The organizers would like to express their gratitude to everyone who participated in writing the
solutions.
MDCS Bubble Cup 7DC
38
Qualifications
Problem R1 01: November Rain (code: RAIN1)

Resource: ACM Central European Programming Contest, Warsaw 2003
Time Limit: 13 second
Contemporary buildings can have very complicated roofs. If we take a vertical section of such a roof it
results in a number of sloping segments. When it is raining the drops are falling down on the roof straight
from the sky above. Some segments are completely exposed to the rain but there may be some segments
partially or even completely shielded by other segments. All the water falling onto a segment as a stream
straight down from the lower end of the segment on the ground or possibly onto some other segment. In
particular, if a stream of water is falling on an end of a segment then we consider it to be collected by this
segment.
For the purpose of designing a piping system it is desired to compute how much water is down from each
segment of the roof. To be prepared for a heavy November rain you should count one liter of rain water
falling on a meter of the horizontal plane during one second.
Write a program that:
reads the description of a roof,
computes the amount of water down in one second from each segment of the roof,
writes the results.
Input
The input begins with the integer t, the number of test cases. Then t test cases follow.
For each test case the first line of the input contains one integer (
being the number of
segments of the roof. Each of the next lines describes one segment of the roof and contains four integers
(
separated by single spaces. Integers
are respectively the horizontal position and the height of the left end of the segment. Integers
are respectively the horizontal position and the height of the right end of the segment. The
segments don't have common points and there are no horizontal segments. You can also assume that there
are at most 25 segments placed above any point on the ground level.
Output
For each test case the output consists of n lines. The -th line should contain the amount of water (in liters)
39
MDCS Bubble Cup 7DC
Qualifications
down from the -th segment of the roof in one second
Sample
input
1
6
13 7 15 6
3 8 7 7
1 7 5 6
5 5 9 3
6 3 8 2
9 6 12 8
output
2
4
2
11
0
3
Solution:
In this task we are asked to compute the amount of water that falls down from each segment of the roof.
First we want to calculate the amount of rain that is falling onto each segment directly from the sky above,
and then add the amount of all the water falling onto each segment from the lower end of some other one.
Notice that the coordinates are nonnegative integers less or equal then one million; this allows us to iterate
through all points on the ground level. While doing so we store the indexes of segments, which are located
somewhere above the current X coordinate on the ground, in a list (there will be at most 25 stored
segments at any moment during the iteration, as given in the task). So, for each step in this iteration we do
the following:
If a left end of a roof is encountered add it to the list. (we are doing this by moving one pointer in
the sorted list of roof segments by X coordinate of left end)
For each segment in the list whose lower end is equal to the current X coordinate determine the
segment under it which will collect the water falling from it. (this can be done by considering Y
coordinates of points located on the current segment and each one in the list, both with the
current X coordinate, in order to find the closest such point with lower Y coordinate than the point
on the current segment)
If a right end of a roof is encountered remove it from the list. (Pass through all list elements and
remove the one with right end equal to the current X coordinate)
Find the topmost segment from the current list and increase the rain counter for it by one. (similar
to the second step, we find the topmost point located on some segment from the list with the
current X coordinate)
Now the only thing left is adding the falling water from the segments above. Lets consider each roof as a
node and each connection between two segments (two segments are connected if water is falling from one
to another) as a directed edge with an end in the one above. We end up with a directed acyclic graph in
which for each node we need to compute the sum of all rain in the nodes reachable from it. This can be
simply done using depth first search, iterate through all nodes and if we dont have wanted information for
the current one calculate it by summing all rain collected in the child nodes recursively.
Solution by:
Name: Dimitrije Dimi
School: School of Computing, Belgrade
E-mail: dimke92@gmail.com
MDCS Bubble Cup 7DC
40
Qualifications
Problem R1 02: Ambiguous Permutations (code: PERMUT2)

Resource: Adrian Kuegel, used in University of Ulm Local Contest 2005
Some programming contest problems are really tricky: not only do they require a different output format
from what you might have expected, but also the sample output does not show the difference. For an
example, let us look at permutations.
A permutation of the integers 1 to n is an ordering of these integers. So the natural way to represent a
permutation is to list the integers in this order. With n = 5, a permutation might look like 2, 3, 4, 5, 1.
However, there is another possibility of representing a permutation: You create a list of numbers where the
i-th number is the position of the integer i in the permutation. Let us call this second possibility an inverse
permutation. The inverse permutation for the sequence above is 5, 1, 2, 3, 4.
An ambiguous permutation is a permutation which cannot be distinguished from its inverse permutation.
The permutation 1, 4, 3, 2 for example is ambiguous, because its inverse permutation is the same. To get
rid of such annoying sample test cases, you have to write a program which detects if a given permutation is
ambiguous or not.
Input
The input contains several test cases.
The first line of each test case contains an integer
. Then a permutation of the integers
to follows in the next line. There is exactly one space character between consecutive integers. You can
assume that every integer between and appears exactly once in the permutation.
The last test case is followed by a zero.
Output
For each test case output whether the permutation is ambiguous or not. Adhere to the format shown in the
sample output.
Sample
input
4
1 4 3 2
5
2 3 4 5 1
1
1
0
output
ambiguous
not ambiguous
ambiguous
Solution:
This was the easiest problem of all bubble cup qualification problems ever. You just need to make
inverse array from array A (defined as inverse[A[i]] = i for each i) and check if A[i] ==
inverse[i] for every i (1
i
N). Its easy to prove that its enough to check only that A[A[i]]
== i for every i (1
i
N, A[i]
i) so you can do this task with only one array and one loop
41
MDCS Bubble Cup 7DC
Qualifications
through the array.
The code for this task is really short, so we can run a shortest code competition . Here is my shortest code
in C, which passed all test cases on SPOJ.
n,i,b;
main() {
while(scanf("%d", &n), n) {
int a[n];
for(b=i=1; i<=n;) scanf("%d", a+i), b &= a[i] > i | a[a[i]]==i++;
puts("not ambiguous" + b*4);
}
return 0;
}
The length of this code is only 135 non-whitespace characters, and I want to thank all the guys who helped
me shortening it.
Solution by:
Name: Duan Zdravkovi
Organization: School of Computing, Belgrade.
E-mail: duxxud@gmail.com
MDCS Bubble Cup 7DC
42
Qualifications
Problem R1 03: Roll Playing Games (code: RPGAMES)

Resource: ACM East Central North America Regional Programming Contest 2004
Phil Kropotnik is a game maker, and one common problem he runs into is determining the set of dice to use
in a game. In many current games, non-traditional dice are often required, that is, dice with more or fewer
sides than the traditional 6-sided cube. Typically, Phil will pick random values for all but the last die, then
try to determine specific values to put on the last die so that certain sums can be rolled with certain
probabilities (actually, instead of dealing with probabilities, Phil just deals with the total number of
different ways a given sum can be obtained by rolling all the dice). Currently he makes this determination
by hand, but needless to say he would love to see this process automated. That is your task.
For example, suppose Phil starts with a 4-sided die with face values 1, 10, 15, and 20 and he wishes to
determine how to label a 5-sided die so that there are a) 3 ways to obtain a sum of 2, b) 1 way to obtain a
sum of 3, c) 3 ways to obtain 11, d) 4 ways to obtain 16, and e)1 way to obtain 26. To get these results he
should label the faces of his 5-sided die with the values 1, 1, 1, 2, and 6. (For instance, the sum 16 may be
obtained as 10 +6 or as 15 +1, with three different 1 faces to choose from on the second die, for a total of
4 different ways.) Note that he sometimes only cares about a subset of the sums reachable by rolling all the
dices (like in the previous example).
Input
Input will consist of multiple input sets. Each input set will start with a single line containing an integer
indicating the number of dice that are already specified. Each of the next lines describes one of these
dice. Each of these lines will start with an integer f (indicating the number of faces on the die) followed by
integers indicating the value of each face. The last line of each problem instance will have the form
where r is the number of faces required on the unspecified die, m is the number of sums of interest,
are these sums, and
are the counts of the desired number of different ways in which
to achieve each of the respective sums.
Input values will satisfy the following constraints:
, and
.
Values on the faces of all dice, both the specified ones and the unknown die, will be integers in the range
, and values for the s and s are all non-negative and are strictly less than the maximum value of
a 32-bit signed integer.
The last input set is followed by a line containing a single 0; it should not be processed.
Output
For each input set, output a single line containing either the phrase Final die face values are followed by
the r face values in non-descending order, or the phrase Impossible if no die can be found meeting the
specifications of the problem. If there are multiple dice which will solve the problem, choose the one
whose lowest face value is the smallest; if there is still a tie, choose the one whose second-lowest face
value is smallest, etc.
43
MDCS Bubble Cup 7DC
Qualifications
Sample
input
1
4
5
1
6
6
4
6
4
3
8
4
0
output
Final die face values are 1 1 1 2 6
Impossible
Final die face values are 3 7 9 9
1 10 15 20
5 2 3 3 1 11 3 16 4 26 1
1 2 3 4 5 6
3 7 6 2 1 13 1
1
1
3
1
4
2 3 4 5 6
2 2 3
7 9
4 5 9 23 24 30 38
48 57 51 37 56 31 63 11
Solution:
Maybe the first impression was that this task is a little bit confusing, but considering the constraints that
were given in the task it turns out that you only needed to find a way to see if it is possible to create the last
die so it fits the conditions, while keeping in mind the time complexity of your algorithm.
First we create a 2D matrix in which we will keep the number of ways in which you could get all sums
with
dice (there are given dice). In this matrix the rows would represent the number of dice, and
the columns would represent the numbers possible to get from the sum of the dice (e.g. if we had
that would mean that we could find 5 ways to achieve the sum 2 with the first four dice). We
would calculate fields in this matrix like this:
for every die (with an index j),
and for all its sides
[
] , where
is be the value of the -th side of the die
Then, for the last die, when we need to find out if we can create it, we can try all possible values for its
sides using brute force. If we have two arrays (like and from the input for the last die) then we would
after performing the operation
(where is any index for the die side)
check if
is negative. If that is the case then we know that we can't make the last die in this way. In the
other case,
is a positive number and we would with a recursion try to find the value for the next side of
the last die. After the recursive call we would set back the value of c[j] so we can do another recursion in
the next iteration.
Next we would check if the combination is ok (just go through the given conditions and see if everything
fits).
After every recursion, if we found a combination of sides for the last die, we still need to check if the array
is empty. If it is, then we have a valid solution, and we are finished. If we went through all combinations
and didn't find a valid one then there is no solution.
Solution by:
Name: Uros Joksimovic, Milos Biljanovic, Dejan Pekter
School: School of Computing, Belgrade.
E-mail: uros.joksimovic92@gmail.com, miloshb92@hotmail.com, deximat@gmail.com
MDCS Bubble Cup 7DC
44
Qualifications
Problem R1 04: Manhattan Wire (code: MMAHWIRE)

Resource: Yokohama 2006
Time Limit: 3.0 second
There is a rectangular area containing
cells. Two cells are marked with 2, and another two with
3. Some cells are occupied by obstacles. You should connect the two 2s and also the two 3s with
non-intersecting lines. Lines can run only vertically or horizontally connecting centers of cells without
obstacles.
Lines cannot run on a cell with an obstacle. Only one line can run on a cell at most once. Hence, a line
cannot intersect with the other line, nor with itself. Under these constraints, the total length of the two
lines should be minimized. The length of a line is defined as the number of cell borders it passes. In
particular, a line connecting cells sharing their border has length 1.
Fig. 1(a) shows an example setting. Fig. 1(b) shows two lines satisfying the constraints above with minimum
total length 18.
Figure 1: An example of setting and its solution
Input
The input consists of multiple datasets, each in the following format.
nm
row1
rown
is the number of rows which satisfies
. is the number of columns which satisfies
Each
is a sequence of m digits separated by a space. The digits mean the following.
0: Empty
1: Occupied by an obstacle
2: Marked with 2
3: Marked with 3
The end of the input is indicated with a line containing two zeros separated by a space.
Output
For each dataset, one line containing the minimum total length of the two lines should be output. If there is
45
MDCS Bubble Cup 7DC
Qualifications
no pair of lines satisfying the requirement, answer 0 instead.
Sample
input
5
0
0
2
1
0
2
2
0
6
2
0
0
1
0
0
0
5
0
0
0
0
0
3
2
3
5
0
3
0
1
0
0
0
0
0
2
1
0
0
3
0
1
0
0
0
0
1
3
0
0
0
0
0
3
0
0
0
0
0
0
output
18
2
17
0
3
0
0
0
1
0
2
Solution:
The approach for this problem is very straight-forward: let's try every possible placement of the line
connecting 2s and then look at the shortest available line between 3s and take the best result.
Of course, that solution is too slow and we need some optimizations to prune the search tree to fit the
time. Let's look at some situations which will surely lead to a suboptimal solution:
a) U-shape turns (see Figure 1) - if there are no obstacles, it can be easily replaced by a shorter
piece of wire. Note: This optimization is the most important one!
b) let's say that we are in field A and there is an adjacent field B that has been visited a long time
ago (meaning not in the previous step) - it's bad, because it would have been better to go straight from B to
A and avoid the loop see Figure 2.
MDCS Bubble Cup 7DC
46
Qualifications
c) suppose that we have constructed some part of the line between 2s. If at this moment there is
no path between 3s (we can check this easily using breadth-first search) we can stop searching, backtrack
and try some different way. It turns out that checking for such situations in every step is quite slow, but if
we do it on every 300th step, for example, it will considerably speed up our program.
We can also deduce some steps in the very beginning as long as there's only one possible movement from
any 2 or 3 - let's do it and mark it on the grid. It will always help our program.
Obviously, many more optimizations can be applied, but an efficient implementation of the
abovementioned ideas make our program easily fit the time limit.
Solution by:
Name: Bartek Dudek
Organization: XIV LO Wrocaw
E-mail: bardek.dudek@gmail.com
47
MDCS Bubble Cup 7DC
Qualifications
Problem R1 05: Spheres (code: KULE)

John has a certain number of spheres. Almost all of them have identical weight apart from one. There are a
lot of them and John cannot say which one differs from the other ones by himself. You can help him to
determine which sphere it is by using the pair of scales.
Input
In the first line of the input there is one integer (
spheres which John has. The spheres are numbered from
that stands for the number of

to .
You can give John two types of orders (just print them to standard output):
Weighting spheres. All numbers should be separated with a space and they stand for: - number
of spheres that should be put on one of the scales (there should be the same amount of spheres on
both of the scales),
- identifiers of spheres that you want John to put on the left scale
and
- identifiers of spheres that you want John to put on the right scale.
After conducting the weighting John will tell you about the outcome (which you will be able to read
from the standard input). Possible answers are LEFT - spheres on the left scale are heavier, RIGHT spheres on the right answer are heavier, EQUAL - spheres on both scales have equal weight.
After conducting the weighting John is ready right away to execute the next order.
However, you should remember that if the weighting's number is too high John can become quite
bored...
Answering. This order is to give information that is the identifier of the searched sphere; however
if the sphere we are looking for is lighter than the other ones you should precede that with a '-'
sign.
John no longer needs you after that command (your program should end).
Output
Output the month number the accountant-robot will rust in. Months are numerated 1 to .
Sample
input / output
John:
You:
John:
You:
John:
You:
3
WEIGHT 1 1 2
LEFT
WEIGHT 1 1 3
EQUAL
ANSWER -2
Remark:
Program should clear the output buffer after printing each line. It can be done using fflush(stdout)
command or you can set the proper type of buffering at the beginning of the execution - setlinebuf(stdout).
MDCS Bubble Cup 7DC
48
Qualifications
Solution:
The problem is one of the variants of the Coin-Weighting problem: Given
coins, one of which is
counterfeit, and a pair of scales (two-pan balance) without weights, what is the minimum number of
weightings needed to find the counterfeit coin? There are variants in which we know/dont know if the
counterfeit is lighter/heavier, in which we are required to only indicate counterfeit/determine its weight, in
which we have/dont have some additional genuine coins etc. The following theorem gives us the required
minimum number of weightings for the corresponding variant of the problem and its constructive proof can
easily be implemented to obtain the required algorithm:
Theorem 1: Given coins, numbered from 1 through ,
of which are genuine and with exactly one
counterfeit among them, the minimum number of weightings needed to determine index of the counterfeit
.
and if its lighter or heavier than the others is
Proof: Let be the optimal number of weightings. Since we have candidates for counterfeit coin, and in
each case the counterfeit can be lighter or heavier than the genuine coin, there are
possible outcomes
in total. On the other hand, let us mark the result of each weighting with a number from set
;
-1 denotes that the left pan of the scales was heavier, 0 denotes that the scales were balanced and 1
denotes that the right pan was heavier. The arrangement of the coins on the scale pans on the -th
weighting depends only on the results of previous weightings and previous rearrangements, which were
themselves induced by the previous weighting results. Therefore, after the arrangement of the coins on the
scale pads for the first weighting is fixed, the subsequent rearrangements depend only on the results of
previous weightings (with if-then conditions for new rearrangements) and the final outcome (counterfeit
coin) depends only on the weighting results. It follows that the outcome of the weightings can be
uniquely described as a sequence
of individual weighting results
.
We just showed that weightings can distinguish between at most
different outcomes; since we must
be able to recognize
outcomes, it follows
. Since
is odd, we can rewrite the inequality as
(instead of the parity argument, we could also notice that weighting sequence
cannot tell whether the counterfeit is lighter or heavier because of that only
sequences are valid).
However, this inequality is a bit weak; we will improve it.
Let be the number of coins which will be put in the first weighing on each pan. If in the first weighting
the pans are balanced, the counterfeit coin is one of
coins not participating in this weighting. The
remaining
weightings must be enough to identify the counterfeit among
coins and to find
out if it is heavier or lighter. As before, it follows
(because of the parity argument).
However, if in the first weighting the pans arent balanced, the counterfeit is among
coins which
participated in this weighting. Unlike the previous case, this time it is enough to find only an index of a
counterfeit coin in the following
weightings; its weight can be determined from the first weighting.
Therefore, we are only interested in
outcomes (not
) and it follows
(parity
argument again). Adding
and doubled
results in
,
which is (using the fact that is an integer) equivalent to
We will now prove that this bound is achievable by explicitly constructing the weightings. It suffices to
construct the required
49
weightings for all
] (for
, less than
weightings are
MDCS Bubble Cup 7DC
Qualifications
needed). It is assumed that
since
gives trivial cases with
coins.
First, let us recall of a method for determining a counterfeit coin among

coins, when it is known
whether the counterfeit is lighter/heavier than others, in weightings: we divide coins into 3 equal groups
of size
and put any two groups on different pans. Since we know if the counterfeit is lighter/heavier,
result of weighting will identify the group with counterfeit and we will apply the same method recursively.
After weightings, the counterfeit will be identified. This also works for any
number of
coins (i.e. weightings suffice): We divide coins into 3 as equal as possible groups:
or
or
(at least 2 of them will be equal) and weight the equal ones. After that, we will narrow
our search to a group of a size at most
have less than or equal to
method the simple method.
(if
) or , if
. In either case, the resulting group will
coins, and we can apply the method recursively again. We will call this
Back to the optimal weighting construction. First, let us assume that

the simplest for construction). We divide
coins
each.
Now,
we
coins into 3 equal groups
(which is an edge case, but is

with
divide
each
group
into
subgroups
subgroups
have
coins each. In the first
weighting, we place group on the left pan and group on the right pan. Regardless of the result, in the
second weighting, we remove subgroup
from the left pan, move subgroup
from the right pan to
the left and put subgroup
to the right pan.
If the result of the second weighting differs from the first one
, then the counterfeit coin belongs
to some of the subgroups
; moreover, from these 2 weightings we can precisely deduce
which of the 3 subgroups contains the counterfeit and if the counterfeit is lighter/heavier than the
others. To see this, it suffices to consider all 6 possibilities (
vs.
vs.
and lighter vs. heavier)
they all give different weighting result sequence
After these 2 weightings, we have a group of
coins with counterfeit coin of known weight we can solve this using the simple method in
weightings, which gives weightings in total.
However, if the result of the second weighting remains the same
, it follows that all the coins
from the subgroups
are genuine. In that case, we repeat the same process as in the
second weighting, only this time with subgroups
If
, we use the simple method on
coins as in the previous paragraph, otherwise we rotate subgroups
etc.
This algorithm always uses weightings for identifying counterfeit and its weight: if counterfeit belongs to
one of the subgroups
, we will use one starting weighting,
subgroup rotations and
simple methods weightings weightings in total, as required.
What if
| |
; if
? Again, we divide
then | |
. In either case, using
MDCS Bubble Cup 7DC
| |
coins into 3 groups

| |
; if
: if
then | |
then | |
| |
| |
| |
, we have
50
Qualifications
| |
Therefore, we can write | | | |
edge
case,
we
divide
each
| |
, where
. Now, just like in an
into
into
subgroups
subgroups
have
coins each, for
, and subgroups
have coins each. Since
, a simple method can handle this
subgroup with at most
weightings. Now, with the edge case algorithm, we are able to determine the
counterfeit coin in weightings.
group
However, note that the group might have fewer coins than the groups
. This is not a problem for
we can leave subgroups
and
one coin short | | | |
; if, during an algorithm, we reach
those subgroups, it means that all coins in subgroups
for
are genuine, and we can use them
to fill those 2 subgroups. For
, in particular for
and
, group division should be
and
, respectively (the only cases with | |
). This completes all steps of the algorithm.
With this, Theorem 1 is proved and the optimal weighting sequence is explicitly constructed.
Implementation:
Direct simulation of a mentioned algorithm with subgroup rotations and the simple method. Since
, we can traverse all the coins during each weighting with a total complexity of
Note:
The online judge system requires a sharp bond on weighting number for this task. If contestants code
exceeds the optimal number of weightings, John will not report the outcome of the weighting and TLE
(time limit exceeded) will occur.
Other variants of the Coin-Weighting problem and some different (and generalized) weighting
constructions can be found in [1].
References:
[1] Marcel Kolodziejczyk, Two-pan balance and generalized counterfeit coin problem
[2] http://www.cut-the-knot.org/blue/OddCoinProblems.shtml
[3] http://www.mathplayground.com/coinweighing.html
Solution by:
Name: Nikola Milosavljevi
School: Faculty of Mathematics, University of Ni
E-mail: nikola5000@gmail.com
51
MDCS Bubble Cup 7DC
Qualifications
Problem R1 06: Sightseeing (code: GCPC11H)

Resource: German Collegiate Programming Contest 2011 (Author: Moritz Kobitzsch)
As a computer science student you are of course very outdoorsie, so you decided to go hiking. For your
vacation this year, you located an island full of nice places to visit. You already identified a number of very
promising tracks, but are still left with some problems. The number of choices is so overwhelming, that you
had to select only a "small" subset of at most 105 sights.
And if that is not enough, you are very picky about the order in which you want to visit the sights. So you
have already decided on an order in which you want to visit the preselected tracks. The problem you are
left with is to decide in which direction to travel along each single track, and whether you may have to
reduce your choice of tracks even further. After identifying the travel time between the endpoints of
different tracks, you decide to write a program to figure out if you can make all your trips within the time
you have planned for your vacation. Since you also do not want to waste any precious time, you only care
about an optimal solution to your problem. Furthermore, the tracks can get pretty challenging. Thats why
you do not want to hike along a track more than once.
Input
The first line of the input gives the number of test cases
. The first line of each such test
case holds two integers
the number of tracks of the current hiker (
) and the maximal
time spent hiking throughout the vacation
. Each of the following N lines holds five integers
and
that describe a track (in order of importance).
gives the length of the track in
minutes.
gives the travel time of the official begin or end of a track to the beginning or end of the next
most important track, where and are either b or e. All values given are non-negative integers not
greater than 106. Since you have to get back to your car, the list is circular. Furthermore, we will ignore the
time it takes you to get to the start of your trip with your car.
Output
For each test case print one line. The output should contain a list of either or for every track (in order)
indicating whether you have to hike the track in forward direction or backward direction. If you cannot
make the full trip within the planned time , you should print IMPOSSIBLE to indicate that these trips are
just too much hiking. You can assume that the optimal solution is always unique.
Sample
input
3
2
4
1
2
4
1
3
1
1
1
100
7 8
4 6
20
2 3
1 2
5
2 2
1 2
2 2
2 3
1 2
output
FF
BB
IMPOSSIBLE
7 8
4 6
2 1
2 2
1 2
MDCS Bubble Cup 7DC
52
Qualifications
Solution:
At the first glance, this appears to be a problem requiring finding the shortest path. The issue is to find the
correct vertices. Obviously, keeping the index of the road is not enough, as there are two ends. Plus, you
need to keep track of whether you have traveled across that road or not.
Thus, define a new graph
, where each vertex is described by a triple
which uniquely identifies your current position:
-
is the index of the track you are currently in.

is a boolean value which describes whether you are at the beginning or the end of the
track.
is a boolean value describing whether you have hiked the corresponding track or not.
The set of edges can be found quite easily. This is left for the readers as an exercise.
A sightseeing tour now becomes a path from the vertex
or false).
to itself. (
can be true
First solution: Dijkstras algorithm

This is the direct way to solve the problem, and the implementation is quite straightforward The time
complexity is
, as the number of edges is proportional to . It should be enough to pass all of
the test cases.
Second solution: Dynamic programming
For readers who dont like slow solutions, there are more to explore.
Its not difficult to recognize that the state
state
is dependent on
depends solely on
, and similarly, the
The DP solution shares the same idea as the first solution. The recursion is not difficult and is performed by
calculating in the following order:
As any state is visited exactly once, the time complexity of the algorithm should be
Solution by:
Name: Linh Nguyen
School: Vietnam National University
E-mail: ll931110@yahoo.com
53
MDCS Bubble Cup 7DC
Qualifications
Problem R1 07: Segment Flip (code: SFLIP)

Resource: Proposed by venkateshb
You are given number
of these numbers, where
. In a segment flip, you can pick a contiguous segment

and negate all the numbers in this segment.
You are permitted at most K segment flip operations overall. Also, no

That is, if you flip
and
then either
or
.
segments that you pick can overlap.
Your aim is to maximize the sum of all the numbers in the resulting sequence by applying appropriate
segment flip operations meeting these constraints.
For instance, suppose the sequence is
and you are allowed a single segment flip. The best sum
you can achieve is , by flipping all numbers as a single segment to
.
Input
The first line contains
.
integers
and
. The next line contains
integers, the initial values of
Output
A single integer denoting the maximum possible sum of the final array.
Constraints
Sample
input
3 1
-5 2 -3
output
6
Solution:
This interesting problem was definitely one of the hardest ones on Round 1, and the fact it had the lowest
amount of correct solutions out of all the problems of the round confirms that. The main idea is not very
hard to conceive but implementing it correctly can get a bit frustrating.
The problem statement sticks to formal mathematics and hence doesnt require any particular decoding:
we are asked to determine the maximal sum of a sequence of integers after performing no more than K
segment flip operations on disjoint segments (where one operation negates an entire range of the
sequence). This problem is not extensively covered in literature, however there exists one paper which
names this kind of problem the Maximal-Scoring Segment K-Set problem. It is a problem that arises
commonly in bioinformatics, most notably DNA and RNA analysis.
Before implementing the main algorithm, its wise to first transform the given sequence into a more special
case, which is equivalent to the initial sequence but will make our calculations simpler. First of all, it is fairly
MDCS Bubble Cup 7DC
54
Qualifications
easy to notice that if there are positive integers on the ends of the sequence, they certainly wont need to
be flipped, hence we can immediately exclude them from the range were observing and add them to the
final solution. That way were left with negatives on both ends of the observed range, and this is a property
we can constantly maintain as we build our set of segments; it will later be clarified how. The next
transformation we can immediately apply is to compress successive runs of positive/negative integers
into a single integer with the value of the sum of all integers in that run. Why can we do this? Lets say a
negative integer is contained in the final set of flipped segments; it is obvious that including all the
negatives adjacent to it can only benefit to the solution. Analogously, the only reason why we would want
to flip a positive integer is to join together two segments of negatives, and we cant do this if we dont flip
all the other positives in that run as well. In the end we are left with an alternating sequence of negative
and positive integers. For visualization, refer to Fig. 1.
Lets say that after the given transformations are applied, there are exactly M negative integers in the
sequence. What is the maximal sum we can obtain with M segment flips? It is obviously the sum obtained
when we flip all the negatives separately. If
, then this is also the optimal solution to the problem.
Otherwise, the solution is derived from the M-segment solution using a theorem that is formally stated
in [1], albeit with its proof omitted. It states that a solution for
segment flips can be obtained from
the solution for segment flips by either merging two segment flips or excluding one. Using this we can
find the solution for segment flips in
iterations.
It is easy to conclude that the segment to be excluded/merged through in any iteration must be the
segment with the minimal absolute value (its removal/flipping would pose minimal damage to the sum
obtained with M flips), so we are required to store segments we are observing in a structure which will
efficiently provide this segment; one of the possible data structures we can use for this is a min-heap.
Now lets discuss the algorithm itself; in every iteration, the algorithm extracts the segment with the
currently minimal absolute value from the heap. In the case that this segment is on one of the ends of the
currently observed range, we know that we have run into a negative segment and that we will never have
to re-include it again; hence, it is optimal to remove both it and the positive run adjacent to it from
consideration, so we are left with a negative segment at both ends again. If the extracted segment is not at
either end, the action taken depends on the sign of the segment:
- If the segment is positive, we flip it to merge the two negative segments adjacent to it;
- If the segment is negative, we exclude it for now; it is possible to re-include it, but only together with
both positive segments adjacent to it.
If we look at this a little closer, we can conclude that same actions can be performed regardless of the
sign: subtract the segments absolute value from the optimal solution obtained in the previous
55
MDCS Bubble Cup 7DC
Qualifications
iteration, remove the segment and its two adjacent segments from the heap and insert a segment which is
obtained by merging those three. With a little optimization to assign an ID to each segment, and to
constantly store the IDs of segments directly to the left and right of them, the updates described above can
be done quite efficiently. This concludes the algorithm description, and it turns out to be fairly short and
easy to code (requiring only ~50 lines of code for the main algorithm).
The time complexity of each iteration of the algorithm is
for updating the heap, hence the overall
asymptotic time complexity of this solution is
. The memory complexity of the solution is
.
For a more in-depth look at the Maximal-Scoring Segment K-Set problem, its generalizations, as well as
formal statements of the theorem and algorithm mentioned here and the algorithms application in
analyzing biomolecules, refer to [1].
References:
[1] Mikls Csrs: Algorithms for Finding Maximal-Scoring Segment Sets (extended abstract), IEEE/ACM
Transactions on Computational Biology and Bioinformatics (2004)
Solution by:
Name: Petar Velikovi
School: Matematika Gimnazija
E-mail: petrovy.velickovic@gmail.com
MDCS Bubble Cup 7DC
56
Qualifications
Problem R1 08: K12 - Building Construction (code: KOPC12A)

Given N buildings of height
, the objective is to make every building has equal height. This
can be done by removing bricks from a building or adding some bricks to a building.Removing a brick or
adding a brick is done at certain cost which will be given along with the heights of the buildings.Find the
minimal cost at which you can make the buildings look beautiful by re-constructing the buildings such that
the
buildings satisfy
( can be any number).
For convenience, all buildings are considered to be vertical piles of bricks, which are of same dimensions.
Input
The first line of input contains an integer which denotes number of test cases .This will be followed by
lines , 3 lines per test case. The first line of each test case contains an integer n and the second line
contains n integers which denotes the heights of the buildings
and the third line contains
n integers
which denotes the cost of adding or removing one unit of brick from the
corresponding building.
Output
The output must contain
lines each line corresponding to a testcase.
Sample
input
1
3
1 2 3
10 100 1000
output
120
Solution:
First, let
be the height of the shortest building, and let
be the height of the tallest building. It isn't
hard to notice that the solution will satisfy the inequality
. This is easy to prove - if
there is a solution smaller than low, then we need to remove bricks from every single building. The
solution is guaranteed not to be optimal because removing a brick from each building will cost less. The
proof of the latter,
, is analogous.
Since the limitations for heights for this problem are quite low, the following algorithm with time
complexity
solves the problem.
|
| . Let
be the cost of changing the height of the i-th building to . Clearly,
be equal to
. Clearly, the total cost to change the heights of all buildings to k will be
.
Now we define
. Similarly, we define
. Notice that this
is also equal to
The reason why we are doing this is because we want to be able to
Let
57
MDCS Bubble Cup 7DC
Qualifications
quickly calculate
if we know
and
, for some x. We can calculate
in
, but, how
can we calculate
for some x? Since
for
and otherwise (in other words, it
decreases by
every time we increase the target height if it's smaller than the original height, and
increases otherwise), we can calculate
from its definition as
. This leads to an
algorithm, which is still too slow.
So, let's revisit the above procedure. Define
as
. Notice that
for
, and 0 otherwise. Now define, yes - you guessed it: D

. We observe that
. Now, if we could quickly calculate
for every x, then we could calculate
in constant time if we knew
and
. Also, we can calculate
in linear time by simply
iterating through all buildings.
Now, back to computing the function
. Initialize the array D to all zeros. Iterating through the
buildings, increase
by
for every building encountered. From all this information, one can
compute
for all and then simply choose the value of where the function has a minimum.
Complexity:
time and
space.
Solution by:
Name: Ivan Stoi
School: Gymnasium Svetozar Markovi, Ni
E-mail: ivan100sic@gmail.com
MDCS Bubble Cup 7DC
58
Qualifications
Problem R1 09: Its a Murder! (code: DCEPC206)

Once detective Saikat was solving a murder case. While going to the crime scene he took the stairs and saw
that a number is written on every stair. He found it suspicious and decides to remember all the numbers
that he has seen till now. While remembering the numbers he found that he can find some pattern in those
numbers. So he decides that for each number on the stairs he will note down the sum of all the numbers
previously seen on the stairs which are smaller than the present number. Calculate the sum of all the
numbers written on his notes diary.
Input
First line gives , number of test cases.
lines follow. First line gives you the number of stairs . Next line
gives you N numbers written on the stairs.
;
; All numbers will be between and
Output
For each test case output one line giving the final sum for each test case.
Sample
input
1
5
1 5 3 6 4
output
15
Solution:
All you needed to do to solve this task is to sum up for every given number all past numbers which are
smaller than that number. Sounds simple enough.
So a naive solution would be that you have an array of numbers so that every given number is added in
time to that array, and after that the required sum can be computed in
time. This algorithm is
slow given the constraints (there can be
numbers per test case) so we need to think of another way to
implement these two operations.
This can be solved by cumulative tables, where cumulative stands for how much so far and that is what
we need. The time complexity for add and sum operations are
, which is fast enough to pass.
The whole idea behind the cumulative tables is if we can represent a number in a binary notation (e.g .
or 1110 in binary) , then we can also represent any sum of numbers as a sum of
specific subtotals.
For an example if we need the sum of numbers that are less than 14, then we would have a dynamic array
where we would keep our subtotals, so for that sum we would only need to look at a few subtotals to get
the result, which can be done in
. Why is the complexity logarithmic? The binary presentation of 14
is 1110, so to get the subtotals, we would delete the rightmost one in binary and with that new number we
would use it as index to get the subtotal from the dynamic array. We would repeat the process until we
59
MDCS Bubble Cup 7DC
Qualifications
delete all ones (get zero as index) and along the way sum up all the subtotals. There are about
operations to execute because there can be at most
digits in the binary representation of .
For adding an element to our dynamic array, so the subtotals that we have are correct, we will do the
opposite of what we were doing when we were getting the required sum. We only need to update
subtotals that depend on the number we are adding so to speak, so there are at most
subtotals that
need to be updated, so the time complexity for adding is
too.
Solution by:
School: Racunarski fakultet (RAF)
MDCS Bubble Cup 7DC
60
Qualifications
Problem R1 10: Words on graphs (code: AMBIG)

Input
The input is a directed (multi)graph. The first line gives the number of edges M and the number of nodes
. Then each edge is described by a line of the form "FROM TO LABEL". Nodes (FROM, TO) are
numbers in the range
integers
and labels are also numbers. All numbers in the input are nonnegative
Output
Print "YES" if there are two distinct walks with the same labelling from node 0 to node 1, otherwise print
"NO".
Sample
input
4 4
0 2 0
0 3 0
2 1 1
3 1 2
10 9
0 2 0
2 1 0
2 3 0
3 4 0
4 2 0
2 5 0
5 6 0
6 7 0
7 8 0
8 2 0
output
NO
YES
Solution:
The problem statement is very brief, but there is a lot of information hidden among the test cases. Lets
first dissect what we should do. We are given a directed labeled multigraph and we need to find out if
there are at least two distinct paths from node 0 to node 1, such that we can only traverse edges with the
same labeling. The previous sentence needs some explanations: when you traverse edges finding requested
paths you need to have the same sequence of edge labelling, e.g. if you have a path that contains edges
with labeling 1-5-10-10, the other path also must have 1-5-10-10 labeling of its edges. The distinction
criteria is based on the visited nodes, so in the above example if we did have two paths with same labeling
but at least one node differs, we do have two distinct paths and the answer is YES.
So now that we understand what we should do, lets talk about possible solutions.
Lets consider a nave solution first. Let us find all the paths, select pairs of paths that have the same
labeling and check if there is a difference in visited nodes. As you may guess this is way too slow, it has
exponential time of execution and for 2000 nodes/edges it wouldnt produce a solution even if we had
1000 years of spare time.
We need to abstract things a bit so that we can prune paths that we dont need.
61
MDCS Bubble Cup 7DC
Qualifications
The question is: Do we even need whole paths?
The answer is: No, well after thinking a bit on this problem you would probably come to the same kind of
abstraction. The key point here is to search for distinct paths in parallel. Lets consider that we have two
paths, but we dont really need all the information: what nodes path contain, what edges path contains,
and so on... We only need to know what are the nodes of path at some point, and if the paths contained
different nodes at some point. Lets define state in two paths after traversing N edges as:
Current node on path 1

Current node on path 2
Did we have a distinction (any state so far has distinct property or if current nodes differ in this
state)
This state can be described as three-parameter function f(node, node, bool), where we have
which is about 8 million at most.
states,
So what you need to do is perform a breadth-first search (or an iterative depth-first search, because
recursive DFS will fail due to stack overflow when it tries to call itself several million times) which is going to
traverse graph in parallel. So the BFS should look like this:
parallel_bfs(0, 0, false)
queue.add(state(0, 0, false));
state = getStateFromQueue();
for every pair of state.node1s and state.node2s neighbor whose edges have same labeling
if ( state (node1, node2, distinct || (node1 != node2) is not visited)
mark state as visited
put that state in the queue
You should keep all the states in a boolean matrix

. In the end the solution
to this problem will be contained in
, if it is true it means that we made it to a state
where we finished both of our paths in node 1 and we did at some point have distinction in nodes (it
doesnt matter where).
This solution has quadratic complexity and should pass the time constraint, but if it is not implemented well
you will need some optimisations, and here is a nice one.
Lets think if there is way not to do all the computation, but to make a conclusion a bit earlier. If we could
transform our graph before all this processing to a graph that always contains the path from every node to
node 1 we could conclude that we found distinct path if we are in state
, where
and
are equal, otherwise there is no
such path. So there is no need to go to node 1 if we know that there is a path from every node to node 1.
When we come to the state with equivalent current nodes and distinct paths we can connect that path
with node 1 in any way we want to.
How to do this transformation?
Pretty easy, we only need to delete all the nodes from which we cant reach node 1. That can be done by
reversing all the edges of the graph, and running regular BFS on that graph. After the BFS is done the visited
nodes are the only ones we are interested in. Our new graph, with only the selected nodes and edges
reversed back, has the property described above. Now we can run our parallel BFS algorithm and break out
from it as soon as we hit the state with the same nodes and the
flag on. This optimisation speeds
up the algorithm a lot, but its complexity is a bit hard to prove.
Solution by:
School: Racunarski fakultet (RAF)
MDCS Bubble Cup 7DC
62
Qualifications
Problem R2 01: Zig-Zag Permutation (code: ZZPERM)

In the following we will deal with nonempty words consists only of lower case letters 'a','b',..., 'j' and we will
use the natural 'a' < 'b' < ... < 'j' ordering. Your task is to write a program that generates almost all zig-zag
words (zig-zag permutations) from a given collection of letters. We say that a word W=W(1)W(2)...W(n) is
zig-zag iff n = 1 or
and
for all odd
and for all even 0 < j < n
or
and
for all even
and for all odd
. For example:
"aabcc" is not zig-zag, "acacb" is zig-zag, "cac" is zig-zag, "abababc" is not zig-zag. If you imagine all possible
zig-zag permutations of a word in increasing lexicographic order, you can assign a serial number (rank) to
each one. For example: the word "aabcc" generates the sequence: 1 <-> "acacb", 2 <-> "acbca", 3 <->
"bacac", 4 <-> "bcaca", 5 <-> "cabac", 6 <-> "cacab".
Input
The input file consists several test cases. Each case contains a word (W) not longer than 64 letters and one
positive number (D). The letters of each word are in increasing order. Input terminated by EOF.
Output
For each case in the input file, the output file must contain all of the zig-zag permutations of W whose zigzag serial is divisible by D, in increasing lexicographic order - one word per line. In the next line you have to
print the total number of zig-zag permutations of W. There is no case that produces more than 365 lines of
output. Print an empty line after each case.
Sample
input
j 1
abc 2
aaabc 1
aaabb 2
aaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbcccdd
123456
output
j
1
bac
cab
4
abaca
acaba
2
1
babacbcabacabadabababababababababadab
213216
Solution:
The first thing you should notice about the problem is that there are at most only |
|
distinct letters in the word W. After that, let's first focus our efforts on solving the first part of the
problem: counting the number of zig-zag permutations of .
The solution will be an application of dynamic programming. Let's say we constructed the first
63
characters
MDCS Bubble Cup 7DC
Qualifications
of a specific zig-zag permutation and we need to construct
more of them. The only things we need
to know are: what's the last ( -th) character, whether the next character should be greater or lesser then
the -th, and how many characters of which kind are remaining. Given that data, we can count the number
of ways we can extend the word to form a complete zig-zag permutation.
For example, let's say we constructed the prefix and the state is now
We can obviously transition from that state to
and
.
Associating the number of zig-zag permutations with the state enables us to calculate the first required
number. The only thing left to do is to pick the first character and the relationship between the first two
characters and sum up the numbers for each choice.
From a complexity point of view, the solution isn't perfect. If the original word
had 6 occurences of each
of the 10 letters, then the number of states would be
, because there are 10 possibilities for
the last character, 2 possible directions and every character can occur from 0 to 6 times, yielding a total of
states. The said number is about
and is generally too big to handle within the time limit. Luckily,
no such test cases exist and the said algorithm is good enough to run within the allowed time.
As for the second part of the problem (finding the -th zig-zag permutation), it's amazingly simple to
implement after we know how to solve the first part via dynamic programming. You can easily find the first
character of the string by counting how many permutations there are with a certain first character and
stopping when the cumulative number exceeds . A similar algorithm can be used to find the second
character, etc. Such an algorithm is sufficient to solve the problem.
Solution by:
Name: Goran ui
School: FER, Zagreb
E-mail: zuza777@gmail.com
MDCS Bubble Cup 7DC
64
Qualifications
Problem R2 02: DEL Command II (code: DELCOMM2)

Resource:Chinese National Olympiad in Informatics 1997,Day 1
It is required to find out what's the maximum number of files that can be deleted from MS-DOS directory
executing the DEL command of MS-DOS operation system only once. There are no nested subdirectories.
DEL command has the following format: DEL wildcard
The actual wildcard as well as a full file name can be made up of a name containing 1 up to 8 case-sensitive
characters. In a wildcard the characters '?' and '*' can be used. A question mark substitutes exactly one
character of the full file name, an asterisk any sequence of characters even empty one.
MS-DOS system can permit maybe other wildcards but they can not be used in this task. File names consist
only of Latin letters and digits.
Input
The first line of the input is an integer M, then a blank line followed by M datasets. There is a blank line
between datasets.
Input data for each dataset contains a list of full file names without any extra empty lines and spaces. Each
name is written in a separate line of input data file and ended with a control sign: '+' for delete or '-' for
keep. Full file names are not repeated. The list comprises at least one file, and at least one file is marked to
be deleted. There are no more than 250 files.
Output
For each dataset, write to the first line of output the maximum number of files one DEL command can
delete.
Sample
input
2
output
2
2
BP +
BPC +
TURBO EXCHANGE +
EXT +
HARDWARE +
MOUSE
NETWORK
For the two tests above,the corresponding DEL commands are DEL BP* and DEL EX*.
Solution:
This problem requires of us to find a wildcard pattern which matches the largest amount of files, but not
any of the files which are marked as need to be saved. It means that we can create a list for each file,
containing all patterns which match it. Then we just need to find the pattern which is contained in the
65
MDCS Bubble Cup 7DC
Qualifications
maximal number of safe lists, but in none of the unsafe ones.
The first problem with this idea is that the list of patterns can get really big, so we have to leave out some
of them. Lets see which patterns can be safely left out. For example, if a pattern contains ** its
equivalent to the pattern where one of the * is left out. Further, a pattern such as ?*?*? is equivalent
to ???***, which is then equivalent to ???*. Generalizing this insight, we conclude that we dont have
to look at any patterns containing consecutive *s or a ? immediately following a *. This gives us a
more manageable list for example, a file named AB is matched by the following list of wildcard
patterns:
??
??*
?B
?B*
?*B
?*B*
?*
A?
A?*
AB
AB*
A*B
A*B*
A*
*A?
*A?*
*AB
*AB*
*A*B
*A*B*
*A*
*B
*B*
*
It can be calculated that the worst case is when we have a file name containing 8 different characters, and
that for this case, taking into account that the maximum allowed length of a pattern is 8 characters as well,
the pattern list contains somewhere around 8000 elements.
To find a pattern which is contained in the maximal number of lists, we will make use of the trie data
structure. Each pattern from each list is added to the trie, and we add 1 to the value of the node in the trie
if the pattern was pulled out from a list corresponding to a file which can be deleted, and a
is added if the list was for a file that is not allowed to be deleted. we
value
In the end we just have to go through the trie and find the node with the maximal value.
The time complexity of inserting a pattern to the trie is
, which gives us the total
time complexity
(where
denotes the number of files (
)
and
the maximal number of wildcard patterns for some file (
, as discussed)). The memory
complexity has the same order as the number of nodes in the trie, so some care has to be taken not to
allocate any unnecessary memory.
Solution by:
Name: Duan Zdravkovi
School: Raunarski fakultet (RAF)
E-mail: duxxud@gmail.com
MDCS Bubble Cup 7DC
66
Qualifications
Problem R2 03: Boxes (code: BOX)

Resource: POI III, stage 3; Special thanks to Lei Huang
Time Limit: 0.5 - 15 second
There are n boxes on the circle. The boxes are numbered from 1 to n in clock wise order. There are balls in
the boxes, and the number of all the balls in the boxes is not greater than n.
The balls should be displaced in such a way that in each box there remains no more than one ball. In one
move we can shift a ball from one box to one of it's neighboring boxes.
Write a program that: reads from the standard input the number of boxes n and the arrangement of balls in
the boxes, computes the minimal number of moves necessary to displace the balls in such a way that in
each box there remains no more than one ball, writes the result in the standard output.
Input
The first line of the input file contains an integer t representing the number of test cases. Then t test cases
follows. Each test case has the following form:
The first line contains one positive integer n - the number of boxes
The second line contains n nonnegative integer separated by single spaces. The i-th number is the
number of balls in the i-th box.
Output
For each test case, output one nonnegative integer - the number of moves necessary to displace the balls in
such a way that in each box there remains no more than one ball.
Sample
input
output
1
12
0 0 2 4 3 1 0 0 0 0 0 1
19
Note
There are two input files. In the first input file, t=19, n<=1000, time limit=0.5 second; In the second input
file, t=3, n<=200000, time limit=15 seconds.
Solution:
In order to solve the problem above, we will first reformulate it.
We number the boxes in a clockwise order from 1 to , beginning from an arbitrary box. Let
denote
the box in which ball number was placed at the beginning. We number the balls so that
. Then we stretch the boxes
into a line and add infinitely many boxes before and after the line
(they are numbered
67
and
respectively).
MDCS Bubble Cup 7DC
Qualifications
We displace the balls so that at most one ball remains in each box. The new position of each ball will be
denoted b0(i). We will call b0(i) for
a solution for balls
. Furthermore, a solution will be
|
| is minimal.
called optimal if its cost
We will call the distance between the first and the last occupied box in a given solution (i.e. the number of
the boxes between them plus 1) span. We want to find the optimal solution for balls 1,...,m with span at
most
.
Before we do that, we will define an operation and introduce four lemmas.
We define an operation push left on a given solution. We take the rightmost ball and move it one box to
the left. If the box is not empty, we take the ball from it and again move one box to the left. We continue
this process until a ball is inserted into an empty box. In other words, we move the rightmost continuous
block of balls one box to the left. This operation changes the cost of the solution by . If
is a negative
number, than the solution is improved. Push right is defined in an analogous way.
Lemma 1 There exists an optimal solution in which

Let us take any optimal solution and assume that there exists such a pair
(1).
that
and
,|
| |
|
|
|
|
|. Therefore we may swap

and
and we obtain another optimal solution. Continuing this process for different pairs, like
during a sorting algorithm, we may finally obtain an optimal solution where (1) is satisfied.
Since
Lemma 2 When we perform subsequent push left operations, each time the change of the cost
greater or equal than the change last time. (The same holds for the push right operation.)
is
Let us assume that in the rightmost continuous block of balls there are balls such that
,
and balls such that
. The push left operation changes the cost of the solution by
MDCS Bubble Cup 7DC
68
Qualifications
After the operation can increase or stay the same and
proves the lemma.
can decrease or stay the same. This
Lemma 3 Let us consider all solutions such that boxes with indices greater than are empty. We choose the
optimal one among them and call it . Now we want to find the optimal solution among all solutions in
which boxes with indices greater than
are empty. If box number was free in solution A, then we
may take
. Else we may obtain by performing push left on . This follows from Lemmas 1 and 2.
Lemma 4 If is the leftmost occupied box and is the rightmost occupied box in an optimal solution with
span
, then there exists an optimal solution with span
such that all occupied boxes are either
in range
or
.
Lemma 4 will be left without a proof. It can be proven by contradiction, when we consider rightmost
continuous blocks of balls in both solutions and estimate their lengths.
Algorithm
We may use these lemmas to construct the algorithm.
1. Firstly, we want to find an optimal solution with any span. We keep in memory an optimal solution
with a cost for the balls

, (if there is more than one, we assume that we have any of them).
Now we consider the ball number . According to (1) we know that it is the rightmost ball in the
optimal solution for the balls
.
If
is free we set
and the new solutions cost is , so it is optimal.
If
is occupied, then we place the ball number to the right of the rightmost ball in the previous
solution. We perform push left as long as it decreases the cost of the solution. According to Lemma
3 this leads to an optimal solution.
2. After adding all
balls we get an optimal solution with span . As long as s is greater than n 1 we

perform either push left or push right, each time we choose the operation that makes a smaller
increase in the cost of the solution. According to the Lemmas 4 it leads to an optimal solution with a
span
.
Implementation
Let us assign the same colour to balls which were in the same box at the beginning (which have the same
). Balls in the same colour form one continuous block in the solution produced by the algorithm this
is an observation based on Lemma 1 and the workflow of the algorithm. The block of balls of the same
colour (from the same box) will be called simply a colour. Each colour in the solution may be characterized
by three parameters:
its leftmost ball,
its rightmost ball and
the primary position
(box) of all the balls in that colour. Instead of considering single balls, we will consider colours. The figure
below shows an example of an initial and final placement of the balls.
Furthermore, we will create a structure which will store information about continuous blocks of balls in the
69
MDCS Bubble Cup 7DC
Qualifications
solution. We will call them large blocks. Large blocks consist of one or more colours.
We will divide colours in each large block into three groups:
colours entirely to the left of their box of origin (

colours entirely to the right of their box of origin (
one of the balls in the colour x is in its box of origin (
),
),
).
When we perform the operation push left, we move the rightmost large block one box to the left. It may
make the colours in the large block change their groups (
).
If there is only a one-box distance between the rightmost and the second rightmost large block, than after
push left we have to merge these two into one large block. In order to make the algorithm sufficiently
fast, we have to concentrate on performing push left, updating the current cost of the solution and
merging large blocks.
When we perform push left, we have to change the cost of the solution by
for each colour in

for each colour in
for each colour in
To update the cost of the solution in a fast way, we remember the sum of the lengths of the colours in in
. Thanks to that, we calculate this part of
in constant time. We calculate the change of the cost for
each colour in separately. This is performed in amortized constant time, because each colour may be
pushed left at most
(its length) times when it is in group , then it will travel left to its primary
position and end up in group . The sum of the lengths of all colours equals .
For each large block, we may store information about colours from L and R in binary search trees (e.g. set
from the C++ STL) and colours from the group M in a dynamic array (e.g. vector from the C++ STL). The
colours in the BST structures are ordered by the number of remaining push left operations which will
make them change their group. If this number for the minimal colour in is equal to the number of
MDCS Bubble Cup 7DC
70
Qualifications
operations performed, than that colour is deleted from and added to . Colours in
are updated
separately after each push left, they are added to when they leave . Colours in cannot change their
group any more after push left. However, it is useful to store information about them in a BST we use
it to construct a similar data structure to enable the push right operation in the second part of the
algorithm.
The last thing that remains to be done is merging two large blocks. When we merge two groups of the same
kind, we always add elements from a smaller container to a larger one. Thanks to this, every element will
be inserted at most
times. The most time-consuming operation in the algorithm is merging binary
search trees, which in total takes
time (insertion of a single element into a BST takes
time).
Solution by:
Name: Bartosz Tarnawski
School: Szramek High School Katowice
E-mail: bartek.tarnawski@gmail.com
71
MDCS Bubble Cup 7DC
Qualifications
Problem R2 04: Cryptography (code: CRYPTO)

Time Limit: 1 11 second
Your task is to work as a cryptographer for some time, the reason is ...
Blue Mary has set a problem using English. Since the problem is too easy and it will be boring when solving
it, she has deleted all the whitespaces and punctuations in the original problem description, and
lowercased all the capital latin letters. Then, she randomly chose a permutation of the English lowercase
letter alphabet, and then used the corresponding letters in place of the letters in the original text.
The encrypted text can be downloaded here.
There is no example for this problem.
Blue Mary's note: some tricky test cases were added on Nov. 25th, 2007 and the time limit has been
changed. Programs have been rejudged and some "accepted" solutions got Wrong Answer. However, this
problem can still be solved by quite clean code with length less than 1KB.
Solution:
This task is a bit different from the others, since we are given an encrypted problem statement. Therefore,
to solve the task, we need to decipher the statement. This also happens to be the main and interesting part
of this problem, since the task itself is rather easy (except for some ambiguity in the real statement).
In the introduction to the task statement, we are provided with some important facts we are dealing with
lowercase Latin letters, the language is English and, the most important fact, the method of encryption is a
form of substitution cipher.
One of the simplest and most commonly used methods for breaking the substitution cipher is frequency
analysis. This method, coupled with some manual tweaking, is enough to decipher the task statement. It
consists of counting the number of occurences of each letter in the ciphertext analysis of the frequency of
each letter in the ciphertext. Then, the more frequent letters in the ciphertext are mapped to the more
frequent letters in the English alphabet, while the less frequent are mapped to the less frequent letters in
the English alphabet. For this, we will, of course, need relative frequencies of letters in the English alphabet.
Then, in the best case, the most frequent letter in our ciphertext will map to the letter e (the most
frequent letter in English language), the second most frequent letter will map to the letter t and so on... Of
course, the process of decryption would be too easy then, so this is not the best case and we will have to
do some guessing. We can start by mapping the most frequent letters in the given text to the most
frequent letters in the alphabet, and then build it up from there by looking at the text we are getting when
applying our partial key, mixing the mappings a little bit, trying to get meaningful words and parts of words.
We can also use the frequency analysis of bigrams (two adjacent letters in the string) or trigrams. For
example, the most frequent trigram in the given text is nte, and it maps to the most frequent trigram in
the English language the. Slowly, by correctly guessing the parts of the needed key (permutation), we will
be getting more and more meaningful words, ultimately leading to this (spaces and punctuation included
additionally to show the real beauty of the statement):
I have told you that this problem is very easy, just like the problem life the universe and everything.
Yes, it's very easy, but you will have some trouble to get accepted if you don't care with the problem
description.
A very easy problem is not always a very boring problem.
MDCS Bubble Cup 7DC
72
Qualifications
Sometimes it will be interesting from the time you try it to the time you solve it because after lots of WA/TLE
you will feel very well.
The sun is shining outside the window. The birds are singing in the tree. The nature is harmonious.
What's the first problem of an online judge?
It's A plus B problem in common except sphere online judge.
This problem will be the first problem of most of the online judges.
The data limitations are multiple test cases.
All the numbers are separated by some whitespaces. A and B are integers and less than MAX_LONG_INT in
C or C++ language.
The input file will less than four megabytes.
I hope you can solve it as fast as possible because it's very very easy and the test cases are very weak. But if
you got WA/TLE you will work for a long time to find the mistake of your program possibly.
Enjoy this problem
Alright, the text may not be so beautiful at the end, and actually, it does not describe the problem very
well. Most of the people probably felt excitement and relief after successfully deciphering the text, but it
was only the beginning of a bumpy road to Accepted. The task is to print the sum of two numbers, but the
format of the input (and output) is still unknown, and the constraints are vague. Therefore, the method of
trial and error would have to continue to find out all the tricks that are hidden in this task. The first, and the
easier problem is to find out how the input looks like. By testing different solutions, it turns out that the
input consists of an array of 2N integers (there is no number in the input that tells us the value of N). Let V
be the given array. You have to print exactly N integers (separated by some whitespace), where each
integer represents the value of expression V[2i-1]+V[2i], for each i=1,,N. The second and more tricky part
of solving this problem is figuring out the constraints. It is stated that all the integers will be less than
MAX_LONG_INT. A lot of people initially assumed that their absolute value is less than MAX_LONG_INT.
But, it is a very wrong assumption, and, as it turns out, there is no lower bound on the value of numbers,
other than the size of the input file. Therefore, big integer arithmetics has to be used to solve the task.
Since the only operation is addition (and subtraction in case of two numbers with different signs), the
implementation is straightforward. Time limit should not be an issue in this task, since the time complexity
of the solution is linear, but reading the input should be done with care.
Solution by:
Name: Vanja Petrovi Tankovi
School: School of Computing, Belgrade
E-mail: vpetrovictankovic@gmail.com
73
MDCS Bubble Cup 7DC
Qualifications
Problem R2 05: Slow Growing Bacteria (code: SBACT)

Resource: MNNIT IOPC 2010, Co-author: jitendra_kumar
Given an n x n grid of cells, a bacteria colony can colonize these cells. Their growth after every second is
governed by the following rules:
1) 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.
2) Already living bacterias do not die.
Given, the initial state of the n x 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 nxn grid of integers, where ith row,jth column
has an integer representing the number of bacteria's present initially at cell(i,j).
; 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).
Sample
input
1
3
0
0
0
output
3
5
0
3
0
15
0
0
5
Solution:
Given an
array of integers called and an integer , find the first moment when the sum of the
elements in the array is greater or equal to a given integer . Each second we apply the rule: if the value in
the cell
or its neighbours is greater or equal to , increase it by one.
Basic idea:
The first thing to notice is that the constraints on are relatively small , while and can be huge. So the
complexity of the solution must not depend on and much (maybe logarithmically proportional, but not
more).
There are two basic ideas on similar problems do a binary search on the answer or just simulate the
process. The binary search doesnt seem to be a good idea because when we fix the answer, there is no
easy way (at least I couldn't find one) to check if the answer is achievable (the only thing which comes to
mind is again simulation). So, our next stop is to think whether simple simulation is possible within the
MDCS Bubble Cup 7DC
74
Qualifications
constraints.
With up to 100 we can easily simulate each step, but the problem is that we may need to simulate billions
of steps. But, many of them will do the same thing in fact we will have only
steps in which
something changes. Really, the only change occurs when the value of a cell becomes greater or equal to
(because it activates its neighbours), and this can happen at most once per cell. This idea must be enough
to solve the problem!
So, we are ready with the basis of the solution group the steps and use a single iteration to simulate the
whole group.
Implementation:
There are different ways to implement the above idea with complexities ranging from
, and maybe even better. I will explain the
solution I used.
to
I maintain three groups of cells:

already with value greater or equal to
With value less then , but increasing
The rest of the cells.
Apparently, the work we do each moment only changes when something from 2) moves to 1). I remember
this (future) moment for each item in 2) and in each step choose the group in 2) with the smallest moment
(I group the elements in 2) with equal "move" times; this is not necessary). Then, for the time from the
previous interesting point (of course, the first interesting point is 0) to this one I know how the total count
has changed because it depends only on the sizes of 1) and 2) and the interval of time between the two
points. After finishing with this, I update the information for the neighbours of the current cells. If I use a
data structure which supports the priority queue operations in
time (for example, set in the C++
STL) , I get the desired complexity.
Also, when 2) becomes empty, nothing will change from then to infinity, so it is easy to count the
remaining time (if any) for the sum to reach . There are some things to be careful about:
1)
2)
3)
4)
5)
6)
Not to forget to use long long (or similar)

If the sum in the table is fine in the beginning, we should just print 0 and stop
If in the beginning we do not have active elements and 2) is not satisfied , print "Not possible"
Be careful in the initialisation it is easy to send an element not in the right group
Also , remember to round up when dividing
One last thing - we must not forget to break the simulation when the sum reaches
A final note about the complexity:

For each of the cells we will look at most once at its four neighbours and maybe put them in the priority
queue (if they are not already there). This takes
time. This time dominates all other steps, so
the total complexity is
as well.
Solution by:
Name: Vladislav Haralampiev
School: SU "St. Kliment Ohridski"
E-mail: vladislav_haralampiev@abv.bg
75
MDCS Bubble Cup 7DC
Qualifications
Problem R2 06: Reverse the sequence (code: REVSEQ)

This is a very ad-hoc problem. Consider a sequence (N, N-1, ..., 2, 1). You have to reverse it, that is, make it
become (1, 2, ..., N-1, N). And how do you do this? By making operations of the following kind.
Writing three natural numbers A, B, C such that 1 A B < C N means that you are swapping the block
(block = consecutive subsequence) of elements occupying positions A...B with the block of elements
occupying positions B+1..C. Of course, the order of elements in a particular block does not change.
This means that you can pick any two adjacent blocks (each of an arbitrary length) and swap them. The
problem can easily be solved in N-1 operations, but to make it more difficult, you must think of a faster
way.
Input
A natural number 1 < N < 100.
Output
Output at most 50 operations, one per line. Each opearations is represented by three numbers as described
above.
Sample
input
5
output
2 3 5
1 2 4
2 3 5
Explanation of the sample output: (5 4 3 2 1) --> (5 2 1 4 3) --> (1 4 5 2 3) --> (1 2 3 4 5)

Solution:
Since the limitations for N are
, and we shouldn't output more than 50 operations, we're
looking for a solution which will take around N/2 steps. We will describe an algorithm which takes N/2 + 1
steps for even N and (N-1)/2 + 1 for odd N (or, simply, N div 2 + 1 steps for all N), except for N=2 where 1
step is sufficient.
Even N
To demonstrate how the algorithm reverses the sequence in the given number of steps, let N=10. The
sequence looks like this at first:
10 , 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1
Phase 1
Starting from the number with the index N/2 - 2, we let the first sequence be that number and the next
one, and we let the second sequence be the following N/2 - 1 numbers. We then swap those two
sequences.
10 , 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 =>
10 , 9 , 6 , 5 , 4 , 3 , 8 , 7 , 2 , 1
Now, we swap the sequences of the same length (two and N/2 - 1), but, this time the starting index will be
N/2 - 3.
MDCS Bubble Cup 7DC
76
Qualifications
10 , 9 , 6 , 5 , 4 , 3 , 8 , 7 , 2 , 1
=>
10 , 5 , 4 , 3 , 8 , 9 , 6 , 7 , 2 , 1
We repeat this procedure - the lengths of the sequences to be taken are not changed, and the index of the
number from the beginning of the first sequence is decreased by 1 until we run out of indices. That means
this phase takes N/2 - 2 steps.
10 , 5 , 4 , 3 , 8 , 9 , 6 , 7 , 2 , 1
=>
4 , 3 , 8 , 9 , 10 , 5 , 6 , 7 , 2 , 1
After these steps the sequence will, in general, look like this:
4 , 3 , N/2 + 3 , N/2 + 4 , N/2 + 5 , ... , N , 5 , 6 , 7 , ... , N/2 + 2 , 2 , 1
For N=10: 4 , 3 , 8 , 9 , 10 , 5 , 6 , 7 , 2 , 1
Phase 2
Now we are just three steps away from reversing the sequence!
First, swap the sequences [2, N/2] and [N/2 + 1 , N] :
4 , 3 , 8 , 9 , 10 , 5 , 6 , 7 , 2 , 1
=>
4 , 5 , 6 , 7 , 2 , 1 , 3 , 8 , 9 , 10
=>
2 , 1 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10
Now, swap [1, N/2 - 1] and [N/2, N/2 + 2] :

4 , 5 , 6 , 7 , 2 , 1 , 3 , 8 , 9 , 10
Now swap the first two numbers, and you're done! The first phase takes N/2 - 2 steps, and the second
phase takes 3 steps, for a total of N/2 + 1 steps.
Odd N
The general idea for odd N is the same as for even N. In phase 1, we start reversing sequences of lengths 2
and (N+1)/2 from the index (N-1)/2 - 1. This takes (N-1)/2 - 1 steps, that is, N div 2 - 1 steps. The sequence
will look like this after phase 1:
3 , 2 , (N-1)/2 + 3 , (N-1)/2 + 4 , ... , N , 4 , 5 , 6 , 7 , ... , (N-1)/2 + 2 , 1
The phase two, however, takes just two steps - swap [2 , (N+1)/2] and [(N+1)/2 + 1 , N] and [1 , (N-1) / 2]
and [(N+1)/2 , (N+1)/2 + 1].
Demonstration of phase 2 for N=11:
3 , 2 , 8 , 9 , 10 , 11 , 4 , 5 , 6 , 7 , 1
=>
3 , 4 , 5 , 6 , 7 , 1 , 2 , 8 , 9 , 10 , 11
3 , 4 , 5 , 6 , 7 , 1 , 2 , 8 , 9 , 10 , 11
=>
1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11
The phase 1 takes (N-1)/2 - 1 steps, and phase two takes 2 steps, for a total of N div 2 + 1 steps.
Small N
For N=3 and N=4, phase 1 is omitted. For N=2, we just swap those two numbers.
Conclusion
The implementation of the algorithm is easy, although reaching it is far more difficult. The complexity of
the program itself is O(N) - it doesn't compute anything, just prints some predetermined numbers.
Solution by:
Name: Ivan Stoi
E-mail: ivan100sic@gmail.com
77
MDCS Bubble Cup 7DC
Qualifications
Problem R2 07: Cover the string (code: MAIN8_E)

Resource:
Mahesh Chandra Sharma, used for NSIT-IIITA Main contest #8

Given two strings A and B. You have to find the length of the smallest substring of A, such that B is the
subsequence of this substing.
Formally speaking: you have to find the length of smallest possible string S such that
S is the substring of A
B is the subsequence S
Note: Subsequence of an string S is obtained by deleting some (possibly none) of the characters from it. for
example "ah" is the subsequence of "aohol"
Input
First line contains T, the number of test cases. Then T test cases follow, 2 lines for each test case, 1st
contains A and 2nd contain B.
|A|<=20000, |B|<=100
Output
For each test case print the answer in a new line. if no such substring exists print -1 instead.
Sample
input
2
aaddddcckhssdd
acs
ghkkhllhjkhthkjjht
hh
output
10
3
Solution:
Since we are looking for the smallest possible string it is quite obvious that will start with the first
character of string and end with the last character of string . Let all strings be zero-indexed and let be
equal to | | and be equal to | |. We will try to build the solution from any occurrence of character
]
in string . Observe that there is no point in skipping characters of string B in string A.
For example, lets say that string is equal to
and string is equal to
. The solution
will of course be
and not
, so we conclude that we need to use some kind of a greedy
algorithm to solve this task. The main idea of the algorithm is that after we have string , which is a
substring of string and has first
characters of string as its subsequence, we try to build string
which will be a substring of string and will have first
characters of string as its subsequence and
string will be prefix of string
.
So how do we do that?
We can expand string to string
string until we reach character
From all strings
by concatenating all characters that come after the last character of

(and that character will be the last character of string
).
the one with the smallest length will be the solution.
MDCS Bubble Cup 7DC
78
Qualifications
Now we just need to find some quick way to expand any string to string
. We will need some matrix
and
will tell us the position of the first occurrence of -th character of the alphabet
(
) after position in string .
How to build matrix
We traverse the string in reverse and we update array

where
i] is equal to the last
position of -th character while traversing the string in reverse and we can see that when we get to position
, the array Last will represent row
.
Now lets summarize the solution:
Build matrix
Try to build string
starting from any occurrence of character
Use matrix
to expand any string to
If we were unable to build any string

string
.
in string
we output , otherwise we output the length of the smallest
Solution by:
Name: Aleksandar Ivanovi
School: Prva kragujevaka gimnazija
E-mail: aleksandar.ivanovic.94@gmail.com
79
MDCS Bubble Cup 7DC
Qualifications
Problem R2 08: Dynamic LCA (code: DYNALCA)

A forest of rooted trees initially consists of N (1 N 100,000) single-vertex trees. The vertices are
numbered from 1 to N.
You must process the following queries, where (1 A, B N) :
link A B : add an edge from vertex A to B, making A a child of B, where initially A is a root vertex, A
and B are in different trees.
cut A : remove edge from A to its parent, where initially A is a non-root vertex.
lca A B : print the lowest common ancestor of A and B, where A and B are in the same tree.
Input
The first line of input contains the number of initial single-vertex trees N and the number of queries M (1
M 100,000). The following M lines contain queries.
Output
For each lca query output the lowest common ancestor (vertex number between 1 and N)
Sample
input
5 9
lca 1 1
link 1 2
link 3 2
link 4 3
lca 1 4
lca 3 4
cut 4
link 5 3
lca 1 5
output
1
2
3
2
Solution:
First of all, if there were no "cut" and "link" operations, and all nodes were connected, how would we solve
the problem? One of the methods to find LCA is this: create an empty array and make a DFS order of the
tree. As we traverse edges (either forwards or backwards), whenever we enter a node, append that node to
the end of the array. This array will contain
elements in the end. Note that this does not mean each
node appears twice in the array! Now to find LCA of nodes A and B, pick any of their occurrences in the
array and find the node with minimal depth between them. This can be done in
using any rangeminimum-query (RMQ) data structure.
Let's see what happens to the array containing nodes in DFS order on operation "cut": if we cut node A, the
interval beginning from the first occurrence of node A and ending at the last occurrence of node A is being
cut from the array and becomes a new array. What about operation "link A B"? The array starting and
ending with node A is plugged in the array containing node B between two consecutive B's. Note that
cutting and linking may require slight modifications like duplicating a node or removing a duplicate to fix
MDCS Bubble Cup 7DC
80
Qualifications
the DFS order.
The last obstacle to solving this problem is making all operations fast. There's an awesome data structure
called the splay tree. Using splay trees we can easily cut and paste intervals and query for minimum in an
interval. The idea is to just naively implement operations, and make sure that we splay any node we were
looking for by traversing any tree from the root. This magically gives
per operation.
Solution by:
Name: Stjepan Glavina
School: FER Zagreb
E-mail: stjepang@gmail.com
81
MDCS Bubble Cup 7DC
Qualifications
Problem R2 09: Magic Bitwise AND Operation (code: AND)

Resource: Fudan University Local Contest #3, by g201513
Given n integers, your task is to pick k out of them so that the picked number are minimum when do
bitwise AND among all of them.
Input
There are multiple test cases for this problem. The first line of the input contains an integer denoting the
number of test cases.
For each test case, there are two integers in the first line: n and k, denoting the number of given integers
and the number of integers you are asked to pick out. (1<= n <=40, 1<= k <= n)
The second line contains the n integers. You may assume that all integers are smaller than 260.
Note: There are about one thousand randomly generated test cases. Fortunately 90% of them are relatively
small.
Output
For each test case, output only one integer - the smallest possible value.
Sample
input
2
3 2
5 6 7
8 2
238 153 223 247 111 252 253 247
output
Case #1: 4
Case #2: 9
Solution:
For solving this task we will require some basic knowledge of binary numbers and bitwise operations. The
solution for this task is some kind of a pruning search. We will use the most basic recursion for finding all
the -combinations of elements and use some optimizations to make it faster. Observe that for all
numbers and
the following inequality holds:
, where represents the bitwise AND
operation. So first of all, we will sort the numbers in non-decreasing order. We set the initial solution to be
some very large number (for the limits in this task
will suffice). We use the following optimizations:
if we select exactly numbers or we reach the end of the array we dont go any further in the recursion.
Also, since we concluded that including larger numbers in the combination will make that combination less
or equal to the previous one, we can check if including all the numbers after the current position will give
us some number that is greater or equal to the solution and if that is the case we dont go further in the
recursion either. For that optimization we will need to use some preprocessed array
, where
is
equal to
(all arrays are zero-indexed). We can preprocess array
in
either linear or quadratic complexity, it doesnt affect the total time that much. One more optimization is to
check in every step if the current combination is smaller than the best solution so far and update the
solution if that is the case. Using all of the above optimizations will be enough to solve the task within the
MDCS Bubble Cup 7DC
82
Qualifications
given time limit. The recursion itself is very simple to code and very short. The implementation follows:
void Solve ( int idx, int Cnt, lld Curr )
{
if ( Curr < Sol ) Sol = Curr;
if ( ( Cnt == K ) || ( idx == N ) ) return;
if ( ( Curr & DP[idx] ) >= Sol ) return;
Solve ( idx + 1, Cnt + 1, Curr & A[idx] );
Solve ( idx + 1, Cnt, Curr );
}
(
represents the current position in the array,
represents the quantity of numbers that we take in
the combination and
represents the value of the combination.)
Solution by:
Name: Aleksandar Ivanovi
School: Prva kragujevaka gimnazija
E-mail: aleksandar.ivanovic.94@gmail.com
83
MDCS Bubble Cup 7DC
Qualifications
Problem R2 10: Contaminated City (code: 1CONTCITY 19)

In a far away country there is a city facing a big problem. The city is plagued by a deadly gas. Many people
have died, but there are groups of survivors at places around the city. Between these places there are roads
connecting two distinct places that can still be traversed safely. These roads can be traversed in both
directions. It's known the number of days necessary to traverse each road and the two places that it
connects. It's also known the number of survivors at each location. Each survivor can get to other places
following a sequence of roads.
The mayor will send several helicopters to rescue these people, each having a capacity, a limit on the
number of crew (people that it can rescue). Each helicopter will land on a certain day and place.
You should answer an important question for the mayor. How many days are needed to rescue all
survivors? If it's not possible to rescue all people you should answer how many of them can be rescued.
Input
The first line of input file have the number of test cases T (T <= 40). The first line of each test case have N,
M, and H, the number of places considered, the number of roads between the places and the number of
helicopters that will be sent, respectively. Each place is uniquely identified by a number between 1 and N.
The next N lines will have N integers, the i-th line have the number of survivors in place i, Xi. Each of next M
lines will have three numbers Aj, Bj and Dj, meaning that there is a way between places Aj and Bj that last
Dj days to traverse. The input can contain several roads between the same pair of places. Each of next H
lines will have three integers Dh, Ph, and Ch (in this order), meaning that a helicopter with capacity Ch will
arrive at place Ph at day Dh. The sum of survivors will not be more than 200. If a survivor can get a
helicopter following a sequence of roads, the total time to get the helicopter will not be more than 1000.
Constraints
Output
For each test case there is one line in output. If all people can be rescued "All people can be rescued in D
day(s) ." should be printed, where D is the minimum number of days to rescue all people. If it is impossible
to rescue all people "X survivor(s) can be rescued." should be printed, where X is the maximum number of
survivors that can be rescued.
MDCS Bubble Cup 7DC
84
Qualifications
Sample
input
2
4
3
4
5
6
1
2
3
4
4
6
5
3
4
2
2
3
1
1
2
2
3
3
4 4
2
3
4
1
4
3
2
1
2
7
3
3
4
7
2
3
6
3
4
3
4
2
3
3
3
2
4
2
output
All people can be rescued in 6 day(s).
7 survivor(s) can be rescued.
Solution:
Lets reformulate this task in graph theory. Cities and helicopters will represent vertices in this graph and
there will be an edge between city and helicopter if there is a path between and the city that
helicopter lands on.
Firstly, lets find the maximum number of people that can be rescued without regard for the time needed.
This subproblem can be easily solved using the well-known max flow algorithm. We can see that costs of
edges and times of helicopter landing dont play any role here, so we can forget about them. Lets create
two new vertices:
and
, with
being connected to each city through an edge with
capacity equal to the number of people in city and
being connected to every helicopter through
an edge with capacity equal to the capacity of helicopter . We will set the capacity of edges between cities
and helicopters to infinity. Now its easy to see that the flow between
and
will be the
maximum number of people that can be rescued.
Now, if not all people can be rescued, we should just output this number. Otherwise we need to find the
minimal time needed to rescue all the people. In order to do that, we will make a use of the previous idea.
Lets try to answer the question whether we can save all the people within time D. If we remove all the
helicopters that land after time D, and if we remove all the edges
between the city and the
helicopter where there is no path of a distance no more than D, then the flow between
and
will tell us maximum number of people that can be rescued within time D.
Finally, lets note that if we can save all the people within time D, then we can save all the people within
time D+1, D+2, as well. Because of this we can do a binary search over time D, and find the minimal time
85
MDCS Bubble Cup 7DC
Qualifications
needed to save all the people.
Time complexity of this algorithm is:
where
is the maximal number of people that can be saved (up to 200), and
is the
maximal time needed to reach a helicopter from a city (no more than 1000). The
factor is there
because we have to find the minimal distance between each two cities, and it can be done using the FloydWarshall algorithm.
Solution by:
Name: Boris Grubi
School: Gimnazija Jovan Jovanovic Zmaj
E-mail: borisgrubic@gmail.com
MDCS Bubble Cup 7DC
86
Qualifications
Problem R3 01: Four Mines (code: MINES4)

Resource: ThreeMines from TopCoder SRM 315 extended
A Company that Makes Everything (ACME) has entered the surface mining business. They bought a
rectangular field which is split into cells, with each cell having a profit value. A mine is a non-empty
rectangular region, and the profit of a mine is equal to the sum of the values of all its cells. ACME wants to
extract ore from four different non-overlapping mines. You are to choose these mines to maximize the total
profit.
Input
The first line contains an integer T (1 T 5), denoting the number of test cases.
For each test case, the first line contains two positive integers R and C (2 R,C 100), denoting the number
of rows and columns of a rectangular field.
Each of next R lines contain C integers between -10000 and 10000, denoting a profit value for each cell in
that row.
Output
For each test case, print a number on its own line, denoting the maximum total profit that can be extracted
from four mines.
Sample
input
2
5 5
10 10
10 -1
-1 -1
-1 -1
10 -1
2 3
-1 -2
-4 -5
output
99
60
-1
-1
-1
-1
-1
-1
-1
-1
10
10
10
10
-1
10
10
-3
66
Solution:
As it turned out, this was the hardest problem in the BubbleCup qualification rounds. Here we are asked to
put four rectangles on a given rectangular field without overlapping such that the sum of values inside
those four rectangles is maximized.
This problem can be solved using dynamic programming. Its easy to see that a state can be easily
represented by 5 numbers
where
represents upper left and
bottom right
corner of a rectangle in a given rectangular field where we are trying to put
number of rectangles such
that we maximize the sum of numbers inside those rectangles. Lets represent these values by a matrix
.
For
we can see that however we set two rectangles, there will always exists such a vertical or
horizontal line that doesnt pass through any rectangle (see figure 1). The same holds for
, as
87
MDCS Bubble Cup 7DC
Qualifications
shown in figure 2. For
there exist only 2 cases where this is not possible and those two cases are
shown in figure 3. Lets first solve the problem not considering those 2 cases.
Figure 1
To solve this we will make a use of this property we have just noted. So, since every case can be
separated by a vertical or horizontal line, we can just simply try every possible way. So, we can derive the
following recurrent equations (for
:
for
and
Figure 2
Figure 3
For
, we can note that we will either take the whole observed rectangle, or we will remove the first
or the last column or the first or the last row. So if we represent the sum of cells in rectangle
MDCS Bubble Cup 7DC
88
Qualifications
by a function
we have:
Please note that in the given equations we should take care of special cases where
or
the former case we should set
and
and in the latter
and
.
. In
Now lets deal with this sum function. This is well known and used really often. Lets represent by
the sum of cells in the rectangle
. How to calculate it? Well its easy to see that the following
holds:
, for
for
, for
, for
where
represents the value of the cell in row column in the given rectangular field.
So, how can we make a use of this matrix to calculate the sum in rectangle
? Well, we
can use the inclusion-exclusion principle and derive the following:
for
, for
, for
, for
Lets analyze the running time of this solution so far One thing to note is that starting from rectangle
, where and represent number of rows and number of columns of a given rectangular
field respectively, in one cut we can get to one of the following rectangles (see figure 4):
,
Note that here we have
states.
Figure 4
Following this, in two cuts we can get into following configurations (see figure 5):
,
89
MDCS Bubble Cup 7DC
Qualifications
Here weve got
different states.
Again in three cuts we can get into following configurations (see figure 6):
,
And finally here we have
different states.
Figure 5
Figure 6
Note that after three cuts we have

and we have pretty nice dynamic there in
(we arent
looping through rows or columns to find a cut line), but in other cases we do have that loop and it takes
time. So the running time is
. This is pretty good, but we can
do better. Note that the only thing that is slowing out program is the case for
and there we
havent used the property that we need only
different states.
How to speed that case up? Here we will solve only for the case
, and the other 3 cases are
solved similarly. Lets represent the solution of this case by dp1[x1][x2][y]. Note that we will either take the
whole rectangle, or we will erase the first or last column or the first or last row. Lets forget for a moment
about erasing the first or the last column. So weve got:
Of course, for case
MDCS Bubble Cup 7DC
, we should set
.
90
Qualifications
Now after weve got this solution, lets get back to erasing columns. After erasing first or last column
multiple times, we will end up with a rectangle of type
. Note that our rows are fixed. So,
the solution will be the sum of consecutive columns where rows are fixed. Lets say
. The sum of rectangle

will be
, and we are looking for
maximum value. This is pretty well known problem. As we increase from to
we keep a track of
maximum sum of consecutive columns ending at . Once this sum goes below 0, we set it to 0. The
following pseudocode describes this fully:
For d->1 to n:
For x1->1 to n-d:
x2 = x1 + d
best = -infinity
sum = 0
For y->1 to m:
sum = sum + p[y]
best = max(best, sum)
dp1[x1][x2][y]= best
if d > 1:
dp1[x1][x2][y]=max(dp1[x1][x2][y],dp1[x1+1][x2][y])
dp1[x1][x2][y]=max(dp1[x1][x2][y],dp1[x1][x2-1][y])
if sum < 0:
sum = 0
endfor
endfor
endfor
Note that the running time of this algorithm is

great.
. So the total running time is
now, which is
Now lets crack those two cases in picture 3. Here we will crack only the first case, because the second
one can be solved similarly. Here we will use more dynamic programming. Lets fix two columns and one
row, like in Figure 7. Now we would like to compute the best way to put the left and the bottom rectangle
such that the sum of cells inside them is maximal, the left rectangle is bounded by column
and the
bottom rectangle is bounded by row and column .
Figure 7
Lets represent this value by

. Its easy to see that
is at least as
.
This is really nice, because the only thing thats left to be checked is if bottom rectangle is as large as
possible. So, we have the following recurrent relation:
91
MDCS Bubble Cup 7DC
Qualifications
Of course, for
we set
, and note that
Figure 8
We are almost there. Now again, fix two columns and a row for the top rectangle, as shown in Figure 8, and
make a use of previously calculated values to calculate best profit. In pseudocode:
res1 = -infinity
For c1 -> 2 to m 1:
For c2 -> c1 to m 1:
For r -> 1 to n 1:
A = dp[1][c1+1][r][m] + dp[r+1][c2+1][n][m]
B = f[c1][c2][r+1]
res1 = max(res, A + B)
The running time of this part of algorithm is
and the whole solution has time complexity of
One last thing to worry about in this problem is the memory limit. Memory complexity in this solution is
, which is too high. But note that we are using
memory only in
matrix, and we know that at
least one of the parameters of
of
has some nice value. Either
or
or
or
, so we can make a use of it, by representing all the states where
by
, all the states where
by
, all the states
where
by
and finally all the states where
by
. Note that in this way we decreased our memory complexity to
, which is
sufficient for this problem and completes the solution.
Solution by:
Name: Boris Grubi
School: Gimnazija Jovan Jovanovic Zmaj
E-mail: borisgrubic@gmail.com
MDCS Bubble Cup 7DC
92
Qualifications
Problem R3 02: Lost in Madrid (code: LIM)

Programming contests can be very exhausting. After five hours of intensive programming, you want to get
some well-deserved rest and make yourself on the way to your hotel. Unfortunately, you don't quite
remember the way to get there... but that doesn't matter: In good spirits (due to a successful contest?) you
set out.
As you don't know the exact way, you decide to walk around in the following fashion: Start at the contest
site (denoted by id 0) and choose a street at random. Follow the street to the next intersection, and choose
another street at random. Every street at an intersection has the same probability of being chosen. You
might even decide to take the street back where you came from. As you're on foot, you can use the streets
in both directions, unlike in "Madrid's One Way Streets".
Your walk stops once you encounter your hotel (id = 300) or one of the tourist information booths (id >
290) where you can ask for the way. You can assume there is at least one path connecting you to either
type of object.
Because you don't speak a lot of spanish (apart from some verbs that you can conjugate thanks to problem
"Spanish Verbs"), you'd like to know the probability that you arrive at your hotel directly, without first
arriving at a tourist information booth.
Input
The input consists of several testcases, separated by an empty line.
Each testcase starts with S, the number of streets. The following S lines contain two numbers 0 A, B 300
each. This means that there is a street connecting intersection A to intersection B. The same street will not
appear multiple times in the input.
The input ends with S=0. This testcase should not be processed.
Output
For each testcase, print the probability to arrive directly at the hotel, rounded to three decimal places.
93
MDCS Bubble Cup 7DC
Qualifications
Sample
input
output
3
0 291
0 292
0 300
0.333
1.000
0.000
0.579
2
0 300
291 300
2
0 291
291 300
7
0 292
0 88
0 14
0 300
292 88
88 300
14 300
0
Solution:
The problem seems to be quite difficult when you look at it for the first time. Nearly instantly, simulation
comes into mind. If we begin at one position of the graph and choose our way according to the probabilities
of the graph randomly the algorithm should work for a small graph. But there are some problems, since we
cannot be sure how often we have to run the algorithm to get good results, especially, because we do not
know very much about the structure of the graph.
So we have to look at the problem differently. Lets call the -th node and the probability that one arrives
at the hostel directly from the -th node
. If the node we look at is the hostel the probability is one and
if it is a tourist information it is zero. For the other nodes, we look at the neighbors. According to the
problem statement, each way has the same probability of being chosen. That is why we can use the
following simple formula:
For each node we get one linear equation. All in all we have equations with at most unknown values.
These equations are always solvable, since it is guaranteed that we can reach either a tourist information or
the hostel from our start position. If we have solved all the equations we know the probability of our start
position.
Figure 1 shows a small example. The graph is taken from the last test case in the problem statement. We
have the following equations which we need to solve.
(
MDCS Bubble Cup 7DC
94
Qualifications
If we solve these equations, we get the required result. The time complexity of the solution is
use the standard Gauss algorithm, which one learns at school.
if we
292
88
14
300
Figure 1: example graph
Solution by:
Name: Patrick Klitzke
School: Saarland University
E-mail: philologos14@googlemail.com
95
MDCS Bubble Cup 7DC
Qualifications
Problem R3 03: Circles (code: CIRCLES)

Resource: POI III, stage 3; Special thanks to Lei Huang
Little Gary plays the following video game. Circles pop up on the screen and disappear from it. When the
screen flashes, Gary can draw a straight line on the screen and win as many points as there are circles
intersected by the line. As a born-to-be-winner, Gary wants to maximize his score. Please, help him, and
write a program that will determine the maximum number of points he can win each time the screen
flashes.
Input
The first line of the input contains M (1 M 1000), the number of events during the game. The next
Mlines contain descriptions of the events, one per line. They can be in one of the following three formats:
1xyr
representing a circle of radius r popping up with the position of its center at (x, y) in the plane
2i
representing a circle i disappearing, where circle i is the ith circle that popped up since the beginning of the
game; and
3
representing the screen flashing.
x, y, and r are real numbers with at most two decimals, -106 < x, y, r < 106, r > 0.
Notes: A line intersects a circle if it has at least two common points with it. At any time, no two Circles on
the screen have a common point. At any time, there is no line that "touches" more than two circles (a line
touches a circle if they have exactly one common point). At any time, there are no more than 100 circles on
the screen. Each i determines a circle that is on the screen at the moment of removal. No circle is removed
twice.
Output
Each time the screen flashes, write an integer to a separate line, which is the maximum number of circles
Gary can intersect.
Sample
input
9
1
1
3
1
3
1
3
2
3
3.00 0.00 1.00

-2.00 0.00 1.00
output
2
2
3
2
2.00 3.00 1.50

2.00 -4.00 1.00
3
MDCS Bubble Cup 7DC
96
Qualifications
Solution:
Here we are presented with a rather interesting problem which is clearly geometric in nature. It doesn't
seem easy at first glance, however its solution is relatively simple to obtain (although formally proving the
mathematics behind it might be tough). Like most geometry-related problems, CIRCLES can be solved in a
number of ways; the approach we will explain here seems intuitively the easiest to comprehend.
Let's first analyze what the problem gives us, and what we must calculate. We are required to support
three kinds of operations: adding/removing a circle from the visible set, and answer queries asking for
the maximal amount of currently visible circles which can be intersected by an arbitrarily drawn straight
line.
Before going any further with the analysis, let's prove a theorem which will be the basis of our solution.
Theorem: For all possible placements of circles (with respect to the task's constraints), at least one of the
lines which intersects the maximal amount of them is infinitesimally close to one of the common
tangents for one of the pairs of circles.
Proof: Let
and let
be an arbitrary line of the form

be a function such that
which intersects the maximal amount of circles,

is true if
is a line which intersects the
maximal amount of circles, and false otherwise. As we start off with

and increase / decrease the
parameter , after some time there will certainly be a value of the parameter, for which
.
Since this function covers the entire real number line (which is continuous by definition), we can
use Dedekind's Axiom (Axiom of Continuity) to deduce that there exists a specific real number where this
function changes its value. It is obvious that this real number marks the moment when
is
a tangent to one of the circles. If we move the parameter infinitesimally in the other direction, we will once
again have a line which intersects the maximal amount of circles. Hence, we have proven that one of the
sought lines must be infinitesimally close to a tangent of one of the circles.
Let be the point of tangency of the line
. If we exclude the circle which this line is a tangent to
(and we can easily re-include it by infinitesimally shifting this line), we still have a line which intersects the
maximal amount of circles. Now, let's shift the point of tangency in one direction (rotate the tangent
around the circle). Analogously as in the first paragraph (by introducing a new function and applying
Dedekind's Axiom to it), we can deduce that at one particular moment this tangent will no longer intersect
the maximal amount of circles. It is obvious that at this point, this line is tangent to another circle, i.e. it is a
common tangent of two circles. If we were to infinitesimally shift/rotate (depending on whether the
common tangent is internal or external) this line in the proper direction, we would again obtain a line which
intersects the maximal amount of circles. This concludes the proof.
This theorem is of great importance, as by proving it we have greatly reduced the amount of lines we need
to consider: when we check for intersections, we will only check the lines which are common tangents to
each pair of circles. Since no pair of circles has common points, each pair will have four common tangents:
two internal and two external ones. Now we have to come up with a correct way of getting those tangents.
Let and be the centers of the circles, and their respective radii, the distance between the
centers, and the points of tangency for one of the common tangents, and the unit vector
perpendicular to that tangent.
In this situation we have the following system of equations:
97
MDCS Bubble Cup 7DC
Qualifications

( is a unit vector)
(radius at point of tangency is parallel to )
(same as prev.)
(orthogonality)
Deducing from this system:

We have obtained a linear equation where the unknown is the vector . Once we obtain it is easy to
obtain the desired points of tangency:
When we have the points of tangency for each of the four possible tangents, it's easy to reformulate each
tangent in the form
, which we can use to handle the lines more easily later on.
A new question arises now: how can we correctly check whether a line intersects a circle? There are many
ways in which this can be done; here we will present a trigonometric approach. What we do essentially is
calculate the distance between the center and the line, and compare it to the radius. If it is lesser, then the
line intersects the circle. To calculate the distance we will construct a right triangle using the distance we
are looking for as one of the catheti, and the vertical distance (following the Y axis) between the center and
the line as the hypotenuse.
The vertical distance can be calculated easily; if we were to draw a line parallel to the given one which
intersects the center, this distance is the change in the y-intercept parameter (since the slope doesn't
change):
And now we involve some trigonometry to calculate the final distance:

(complementary angles)
(definition of slope)
To avoid precision errors with the square root and possible sign issues, it is wise to calculate the square of
this distance instead, and compare it with the square of the radius. When we get the final amount of
MDCS Bubble Cup 7DC
98
Qualifications
intersections, we should return the result plus 2, because as described in the theorem, we can
infinitesimally shift or rotate the tangent to include the two circles it is common to, without excluding any
other circle.
Now the only remaining issue is how to store the circles efficiently. A good structure for this in C++ is
a map, since we can use it to easily assign IDs to circles with insertion and removal times of
. To
avoid calculating tangents each time, we can store their parameters ( and ) in a four-dimensional
array of size
, where
will store the fth (1st is , 2nd is ) parameter of
the zth tangent between circles with IDs and . This narrowly fits our memory limits, so it is a plausible
optimization.
Our algorithm is now easy to construct: when we receive an insertion command we insert a new circle in
the map and store common tangents between this circle and all other currently visible ones. When we
receive a deletion command we simply erase the given ID from the map, and when we are given a query we
calculate the amount of intersected circles for each common tangent of pairs of visible circles, and output
the maximum. An obvious optimization would simply output the previously calculated solution immediately
if we receive two query commands in a row.
The time complexity of extracting common tangents is
, and the time complexity of checking the
amount of intersections for a single line is
. This means that insertion commands are processed in
time, deletion commands in
time, and queries in
time. Hence, the overall asymptotic
time complexity of our algorithm is
, where
is the amount of queries. With the given
constraints, this solves the problem well ahead of the time limit. The memory complexity is
if we opt
to store all the previously calculated tangents, and
otherwise.
Solution by:
Name: Petar Velikovi, Teodor Von Burg
E-mail: petrovy.velickovic@gmail.com, teodor.vonburg@gmail.com
99
MDCS Bubble Cup 7DC
Qualifications
Problem R3 04: Bridges! More bridges! (code: BRII)

Problem BRIDGE has shown that you are able to build the cheap bridge through the river very quickly. Now
you will not have problems with time limit. You will have problems with number of bridges.
Input
There is a single positive integer T on the first line of input. It stands for the number of test cases to follow.
Each test case is exactly five lines, containing description of the route between two cities A and B, located
on opposite sides of the rivers.
n
a0 a1 a2 ... an
h1 h2 ... hn
c
s0 s1 s2 ... sn
Here n is the number of the rivers which are parallel to each other, ai - the distances between rivers or
between rivers and cities, hi - the widths of the rivers, c - the distance between A and B along the axis
parallel to the river, si - the costs of the unit of the bridge through ith river and s0 - the cost of the unit of
the road. Example for n=2 you can see on the picture.
All integers in input are positive and less than 50, except c - it is less than 2000.
Output
For each test case your program should write a single number to the standard output, equal to the minimal
total cost of the route between A and B, accurate up to two digits after the decimal dot.
MDCS Bubble Cup 7DC
100
Qualifications
Sample
input
output
1
2
1 1 1
1 1
1
1 1 1
5.10
Solution:
Lets first denote things differently than in the problem statement in order to simplify the expressions
which come after. Let
stand for costs of building bridges or roads in tracks starting from the upper
one and let
be track widths. Imagine now we've built bridges and roads in each track. Let
denote their projections on horizontal axis. We can observe that
and that there will never
exist a 'zigzag' structure while building the roads (meaning we'll never drive back with respect to the
horizontal axis). It is obvious that
.
Now we can state the problem formally. We want to minimize cost function
given the constraint

.
This problem can be solved by using Lagrange multipliers [1][2]. Lets define Lagrangian function
In a point of optimal solution
as
has to hold.
So lets look at the partial derivative of G with respect to
This has to be zero in a point of optimum so:
Lets use the above observation to express
Note that, in order for

to be real,
must hold for all . One more important fact is that
is a
monotonic function of (if increases the numerator increases and the denominator decreases, so it
follows that increases, and the other way around).
Lets plug in expressions for
101
into
MDCS Bubble Cup 7DC
Qualifications
Now we have a sum of monotonic functions which has to be equal to a constant c. We can simply binary
search and find when the equality holds. From this point on it is trivial to reconstruct the solution - when
we found just calculate all and then the total cost using the expressions given above.
References:
1. http://www.slimy.com/~steuard/teaching/tutorials/Lagrange.html
2. http://en.wikipedia.org/wiki/Lagrange_multiplier
Solution by:
Name: Filip Paveti
School: FER Zagreb
E-mail: fpavetic@gmail.com
MDCS Bubble Cup 7DC
102
Qualifications
Problem R3 05: Polynomial f(x) to Polynomial h(x) (code: POLTOPOL)

Resource: Tjandra Satria Gunawan
Given polynomial of degree
polynomial
such that:
. For each polynomial
there exists
for each integer
Your task is to calculate polynomial

Note : degree of polynomial
= degree of polynomial
Input
The first line of input contain an integer T, T is number of test cases
of 2 lines:
. Each test case consist
First line of the test case contain an integer d, d is degree of polynomial
Next line contains

polynomial
integers
(0 d 18)
separated by space, represent the coefficient of
Output
For each test case, output the coefficient of polynomial h(x) separated by space. Each coefficient of
polynomial h(x) is guaranteed to be an integer.
Sample
input
5
0
13
1
-1 2
1
0 2
2
2 -5 9
3
23 9 21 104
output
13
0 1
1 1
1 2 3
31 41 59 26
Solution:
Since
we have that the free member of the polynomial
and it is obvious that their degrees are equal:
is 0, so
.
Let us define coefficients of the polynomial

respectively with
for every integer we have:
103
is a polynomial,
. Since
MDCS Bubble Cup 7DC
Qualifications
Using the binomial formula

( )
for
, we get that :
((
(( )
( )
for every integer .

Polynomials
and
must be equal for every integer , so their coefficients must be
the equal, therefore it is necessary to hold:
(
(
)
)
( )
(1)
ci = ad+1 (-1)d-i(
)+ ad (-1)d-i-1(
)++ ai+1 (
From the last formula we can easily see that if we know coefficients
calculate coefficient
(
(it is guaranteed that every coefficient is an integer, so
) must be divisible by
From here it is easy to find the polynomial

Since | |
we can easily
(
).
, from formulas (1) we can prove | |
Complexity:
Given the total number of test cases
and
, binomial coefficients must be determined
before calculating the coefficients . Then the overall complexity is
.
Solution by:
Name: Predrag Miloevi
E-mail: predrag_93@live.com
MDCS Bubble Cup 7DC
104
Qualifications
Problem R3 06: Factorial challenge (code: FUNFACT)

ing: Stir, let's go out and play our favorite game.
Stir: I am already having fun with my first factorial program.
Ling: Than I will give you a challenge on factorials. If you fail in it, you will have to come.
Stir: ok..
Ling gives Stir a number x and the challenge is to find the largest value of n such that n! is not greater than
the largest value that can be formed by x digits. Stir is stuck with the problem and needs your help. Now,
it's your turn to make sure that Stir can continue having fun with factorials.
Input
The first line of the input contains a number t (about 10^5), the number of the test cases. The next t lines
contain a number x (1 <= x <= 10^9).
Output
Output a total of t lines with each line containing the value n corresponding to the input case.
Sample
input
output
2
1
7
3
10
Solution:
This problem turned out to be one of the easiest in special round. It is obvious that any iterative calculation
of factorial will time out. We can use Stirlings formula (approximation) to calculate the factorial faster.
Stirling's formula is in fact the first approximation to the following series:
( ) (
Once we can calculate n!, it is easy to calculate number of digits of n! as

(
, so
. The last observation needed is that
is a
monotonically increasing function, so we can use binary search to speed up the solution. A properly
implemented solution should work in time, but there are still some possible mistakes. Pay attention to how
you are rounding. I prefer rounding up. And pay attention to the base case of the binary search. There can
be several numbers such that number of digits of their factorials is the same for those distinct numbers.
This can cause WA.
Solution by:
Name: Danilo Vunjak
School: Faculty of technical science
E-mail: kingarthurie@gmail.com
105
MDCS Bubble Cup 7DC
Qualifications
Problem R3 07: Hi6 (code: HISIX)

Resource: Daniel Ampuero
Time Limit: 7 - 15 second
"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 ll 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> <D>
meaning that person "<name_1>" is connected with the person "<name_2>" by making D connections and
viceversa. 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.
MDCS Bubble Cup 7DC
106
Qualifications
Sample
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
Solution:
This problem is a very fine example of how a seemingly straightforward algorithm fails to perform in time
without some necessary optimization. It did prove to be one of the harder tasks of the round, even though
the ideas behind it are all relatively simple and easy to implement.
First of all let's analyze the problem and reformulate it. The introductory part is backstory and not relevant
to the solution. From the input explanation one can easily conclude that what we are given in the problem's
input is an undirected weighted graph, where each node corresponds to a person, each edge represents a
connection between two people, and its weight is the connection level between them. The output
explanation tells us what we are required to do. The task at hand is to find the lengths of the shortest
paths (smallest degree of separation) for each pair of people, and output the maximal length out of
those (or 'INFINITE' if there exists a disconnected pair).
Before getting to the main algorithm, let's first discuss the way we can easily (and effectively) transform the
input data into a graph. It is clearly inconvenient for the nodes to be stored as strings. So the first thing we
want to do is to transform each string into an integer; to do this we use hashing. The constraints on the
string lengths and the characters it can contain in this problem make hashing an ideal option, because we
can make a perfect hashing function (which is a one-to-one function two different strings can't map into
the same integer). There are at most 10 characters in each name, and they only consist of lowercase
characters of the English alphabet. By observing each character as a number from 1 26 (where 'a'
corresponds to 1, 'b' to 2, etc...) we can observe each string as an integer in base 27. Hence, the largest
mapped integer value we can get, knowing the constraints (if we were to map the string 'zzzzzzzzzz'), is
2710 1. This easily fits in a single 64-bit integer variable, so we have no need for any kind of modular
arithmetic here. It is obvious why the hashing function described here is perfect.
There are numerous ways in which we can use the obtained integers to assign an ID (ranging from 1 to N,
where N is the number of nodes) to each node in the graph. One of the ways is to store all the integers
obtained so far in a binary search tree, while storing the ID within each node of the tree as well as the
integer that represents it. For each new edge we are given, we take the mapped values for the names
involved in that edge and try to insert them in the tree; if they are already inserted then we know which ID
corresponds to them, and if not then they are assigned the first unused ID (for this we can use a variable
which starts off at 1 and increases every time a new leaf is added to the tree). This code can be typed very
quickly in C++ using the map structure, which is essentially a RB-Tree (balanced binary search tree) and
107
MDCS Bubble Cup 7DC
Qualifications
easily maps one value to another. The time complexity of the hashing is linear on the length of the string
(essentially constant with this task's constraints), and the time complexity of each insertion in the tree is
| | . This is done for each edge, so the overall complexity of the input processing is O(|E| log |V|),
where |E| is the amount of edges in the graph.
Now that we have a normalized graph, we can start discussing the solution to the problem. Let's first get
the case when the answer is 'INFINITE' out of the way; this is the answer iff the graph is not
connected. Connectivity can easily be checked in O(|V|) time complexity using a depth-first
search algorithm - a graph is connected iff a depth-first search visits all the nodes in a single
execution. Once we are sure that our graph is connected, we can carry on. There are two algorithms that
come to mind for solving this problem Floyd-Warshall algorithm and Dijkstra's algorithm with a binary
heap-implemented priority queue. Both of these algorithms, in their nave form, will likely fail to solve the
problem in time. Here we will mention a key optimization to Dijkstra's algorithm which makes it
successfully process the given test data a few seconds before the time limit.
Dijkstra's algorithm, unlike Floyd-Warshall, is a single-source shortest path algorithm, meaning that in one
execution it's going to find the shortest paths from one node to all others. It is clear that for this problem
we need to execute Dijkstra's algorithm N 1 times, to get all the possible shortest path lengths. However,
with each next execution we have more information than before, which we can use to lessen the amount
of operations the algorithm will do. When it is executed for the first time, Dijkstra's algorithm will initially
only put one node in the priority queue (the first source we picked), while setting the distances associated
with all others to infinity. When we execute Dijkstra's algorithm for the K-th time, we can use the shortest
path lengths from nodes {1, 2, , K-1} to node K as their initial distance (since the shortest path from node
A to node B in an undirected graph has the same length as the shortest path from B to A), and immediately
insert them in the priority queue and mark them as visited. This will avoid repeating any unnecessary
calculations we have done before while calculating the mentioned path lengths, and is sufficient to pass the
given time limit. It should be noted, however, that this is in no way the only (or the best, for that matter)
optimization which solves this task in time. It is simply one of the most obvious ones and it is very easy to
modify the already-made code for Dijkstra's algorithm to support it.
The asymptotic time complexity of a single execution of Dijkstra's algorithm is O((|E| + |V|) log |V|), and
we have to execute the algorithm once for each node in the graph, which gives the total complexity
of O(|V| (|E| + |V|) log |V|), which dominates the time required for processing the input and checking
for connectivity, so this is the overall asymptotic time complexity of the solution. The memory complexity
(for storing the previously calculated shortest path lengths) is O(|V|2).
Solution by:
Name: Petar Velikovi
E-mail: petrovy.velickovic@gmail.com
MDCS Bubble Cup 7DC
108
Qualifications
Problem R3 08: Frequent values (code: FREQUENT)

Resource: University of Ulm Local Contest 2007
You are given a sequence of n integers a1 , a2 , ... , an in non-decreasing order. In addition to that, you are
given several queries consisting of indices i and j (1 i j n). For each query, determine the most frequent
value among the integers ai , ... , aj.
Input
The input consists of several test cases. Each test case starts with a line containing two integers n and q (1
n, q 100000). The next line contains n integers a1 , ... , an (-100000 ai 100000, for each i {1, ..., n})
separated by spaces. You can assume that for each i {1, ..., n-1}: ai ai+1. The following q lines contain
one query each, consisting of two integers i and j (1 i j n), which indicate the boundary indices for the
query.
The last test case is followed by a line containing a single 0.
Output
For each query, print one line with one integer: The number of occurrences of the most frequent value
within the given range.
Sample
input
output
10 3
-1 -1 1 1 1 1 3 10 10 10
2 3
1 10
5 10
0
1
4
3
Solution:
Its important to notice that the array is in order, so equal values are in a group. Assume we are given from
i to j query. Let
be the number of appearances of the most frequent number in the given interval. We
split the interval into two parts,
and
. Its easy to notice that:
If
If
then
appearances of
then
number of appearances of
in
in
+ number of
Answering the queries can be done using a data structure known as the segment tree. Every node of the
tree will contain the following:
109
Number of appearances of the most frequent number in the nodes interval (

Value and number of appearances of the left end number (
,
)
)
MDCS Bubble Cup 7DC
Qualifications
Value and number of appearances of the right end number (
Also, by
we denote
of the node in the segment tree which contains the interval
. The same goes for other values of nodes (
,
, ...)
Initialization of the tree: For every node which contains the interval
its clear that
,
. If we had initialized nodes which contain intervals
and
, we can initialize a node which contains the interval
. Its obvious that
and
. If
, its clear that all the values from to
are equal (since the array is in order), hence
. If not,
is equal to
. The same
holds for
. Finally, the number of appearances of the most frequent number:
If
(
do not contain the same numbers, hence
) we notice that intervals
and
.
If not,
The only thing left now is answering the queries, which is easy once we have all the information from the
segment tree. All we have to do is to split the interval until we get intervals for which we have information
from the segment tree, and then we combine informations in the same way as we initialize the segment
tree.
Lets summarize:
Initialization of the segment tree takes
time. Answering the queries by going down the
tree and combining the data takes
time per query.
So the time complexity is
. Memory complexity is
Solution by:
Name: Marko Bakovi
School: First gymnasium in Kragujevac
E-mail: markobakovic95@gmail.com
MDCS Bubble Cup 7DC
110
The scientific committee would like to thank everyone

who did important behind-the-scenes work.
We couldn't have done it without you.
For the next year, BubbleCup Crew have many ideas.
A lot of changes will happen. Stay with us and see you next year.
Well be back
Bubble Cup Crew
111
MDCS Bubble Cup 7DC

Booklet 2012 Bubble Cup Serbia

Uploaded by

Copyright:

Available Formats

Booklet 2012 Bubble Cup Serbia

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Booklet 2012 Bubble Cup Serbia

Uploaded by

Copyright:

Available Formats

BUBBLE CUP 7DC

Student programming contest

Problem set & Analysis

MDCS Bubble Cup 7DC

Problem R2 07: Cover the string (code: MAIN8_E) ............................................................................. 78

MDCS Bubble Cup 7DC

About Bubble Cup and MDCS

MDCS Bubble Cup 7DC

Bubble Cup Finals 7DC

MDCS Bubble Cup 7DC

BubbleCup Finals 2012

Figure 1. Number of accepted solutions per problems

Figure 2. Number of submissions per problems

MDCS Bubble Cup 7DC

Problem A: Good sets

ACC/ SUB ratio

Min elapsed until first

Table 1. Statistic for time and accepted / submitted ratio

MDCS Bubble Cup 7DC

BubbleCup Finals 2012

Problem A: Good sets

Implementation and analysis: Milan Vugdelija

is a given natural number. Set B is called good if it has the following

Given positive integer numbers

, and the set

compute the following:

The number of elements in every good set;

Time and memory limit: 0.5s / 64 MB

Solution and analysis:

and contains repeatedly

Problem A: Good sets

Finally, from induction we have that

MDCS Bubble Cup 7DC

Problem B: Wheel Of Fortune

Problem B: Wheel Of Fortune

Implementation and analysis: Draen ari

Time and memory limit: 0.5s / 64 MB

Solution and analysis:

MDCS Bubble Cup 7DC

Problem B: Wheel Of Fortune

stands for the probability of exactly

field in a single spin, so

denotes probability of hitting the

Finally, we can calculate the expected overall prize as:

MDCS Bubble Cup 7DC

Implementation and analysis: Andrija Jovanovi

for which the value

Time and memory limit: 1.0s / 64 MB

Solution and analysis:

MDCS Bubble Cup 7DC

MDCS Bubble Cup 7DC

MDCS Bubble Cup 7DC

Implementation and analysis: Dimitrije Filipovi

Figure 1. Optimal car moves for the given example.

MDCS Bubble Cup 7DC

Time and memory limit: 0.5s / 64 MB

Lets enumerate empty spaces between cars and with numbers

. We will find the first empty

. We will move every car in the direction of