3rd MCO 2015

Problems & Solutions

Badminton
Proposed by Mohd Suhaimi Ramly

Badminton
Task: (i) keep track of badminton scores and
(ii) determine the winner of the match.
Goal: test (simple) logic programming skills.
At the end, need to determine winner.
Keep track of games won?
Winner of last point is winner of the match!

Badminton - Pseudocode
points = ABAAABBB...
score_A = score_B = 0 // set scores to 0-0
for each point points:
if point = A then score_A++
if point = B then score_B++
if score_A = 21 or score_B = 21: // game is won
print score_A + - + score_B
score_A = score_B = 0 // reset scores to 0-0
print point // winner of last point is winner of the match

Honey
Proposed by Lim Yun Kai

Honey
Task: Collect maximum amount of honey
from N place using pot of size M in at most K
steps.
Solution: Greedy.

Honey - Solution

Greedily take honey from hive with largest amount of honey.

Can be achieve using a priority queue.

The naive way involved actual simulating of K steps.

Complexity: O(N log N + K log N), fails on subtask 3.

A better way is to collect as many full pot as possible while taking the
input.

Then sort the rest, and take from largest to smallest.

Complexity: O(N log N),

Honey - Pseudocode (C++ style)

vector<int> honey(n);
fullpot = 0;
for i = 0 -> n-1:
cin >> honey[i];
fullpot += honey[i]/M;
honey[i] %= M;

if fullpot >= K:

output K*M; end;

else:

K -= fullpot; ans = fullpot*M;

sort(honey, largest to smallest);

for i = 0 -> min(K, N)-1:
ans += honey[i];

output ans; end;

Bitcoin
Proposed by Quah Fu Yong

Bitcoin
Task: Given a grid of known size and a
number of points, compute the maximum
squared distance between the points in the
grid
Test precomputation skills

Bitcoin - Key Observation

1

Think : Compare the distance of the

green box with all the box in all the
colored boxes in row 1

Distance with the blue squares are

definitely not the maximum distance as
there are still better boxes besides them

Hence, comparisons with the middle (i.e.

non-sidemost) points are redundant

We can do precompute the leftmost &

rightmost points or every row

1
2
3
4
5

Bitcoin - Algorithm
High level description:
-

left = [], right = []

find the leftmost and rightmost points for every row,
store relevant information in left and right
Evaluate the maximum distance between all the points in
the array
Implementing precomputation naively, however, fails
Subtask 3

Bitcoin - Algorithm
-

It is not necessary to compare the distance between all

the leftmost points themselves (similar for right ones)
The only comparisons we need to make are:
- distance between all left and right [ (M-1) * M ]
- distance between every rows left and right [ M ]
As there are negative coordinates, C++ implementation
needs to take array indexing problems into account
Problem can be solved by offsetting the index (i.e. :
instead of arr[i] = x, do arr[i+M] = x) This works so
long the offset value is large enough

Secret
Proposed by Quah Fu Yong

Secret
Task: Given two strings, find if it is possible
to rotate one of the string to obtain the other
string
Test dynamic programming skills

Secret - Common Substring

mutated_first = first + first // concat it
if first.len == second.len && hasSubString(mutated_first, second):
print YES
else:
print NO
def hasSubString(first, second):
// run any reasonble string searching algorithm
// Since first and second are array / vectors, cannot run strstr
directly without manipulation
// Simple string searching algorithm : KMP algorithm

Secret - Standard Library Soln

-

Represent mutated_first and second the string as a

series of char (Using base encoding)
check if second is a substring of mutated_first using
strstr(const char *, const char*) [ from <string.h>
library ] (http://www.cplusplus.
com/reference/cstring/strstr/)
Requires knowledge of base encoding or padding, and
standard library

Trains
Proposed by Ng Jia Jen

Trains
Task: To find a path that requires the least
amount of cost from a certain point A to point
B
Graph problem
Solved by Dijkstra's shortest path algorithm

Trains - Naive Solution

- Try every permutation of paths that connects both
points
- Among all permutations, pick the one with the least cost
- However will not suffice (obviously) due to too many
permutations that a potential path can take from Point A
to Point B

Trains - Complete Solution

1. Start from a starting point
2. Add reachable points from currently traversed points
along with the total cost of traversing those points to a
list
3. From that list of potential points, pick the point with the
lowest cost and traverse there
4. Repeat Step 2 and 3 until ending point is reached

Trains - Graphical Demo

Potential Points

Begin at point (1,3) and end at point (4,5)

Cost

Coordinates

99

1,3

Trains - Graphical Demo

Potential Points
Cost

Traverse point (1,3)

Coordinates

Trains - Graphical Demo

Potential Points

Add all potential points to a list

Cost

Coordinates

119

1,2

119

1,4

119

2,3

Trains - Graphical Demo

Potential Points
Cost

Traverse lowest potential point.In this case, all 3

points have the lowest cost. Traverse all...

Coordinates

Trains - Graphical Demo

Potential Points

Keep on adding potential points. Note that the points

with -1 are not considered

Cost

Coordinates

129

1,1

139

2,2

139

2,2

129

2,4

129

2,4

129

1,5

Trains - Graphical Demo

Potential Points
Cost

Coordinates

129

1,1

From (1,2):

139

2,2

From (2,3):

139

2,2

129

2,4

129

2,4

129

1,5

Also notice that some points (ex. (2,2)) overlap which

demonstrates that some points can be reached from
2 or more different points

Trains - Graphical Demo

Potential Points

Pick lowest cost

Cost

Coordinates

129

1,1

139

2,2

139

2,2

129

2,4

129

2,4

129

1,5

Trains - Graphical Demo

Potential Points

Traverse lowest cost

Cost

Coordinates

139

2,2

139

2,2

Trains - Graphical Demo

Potential Points

Add potential points

Cost

Coordinates

139

2,2

139

2,2

139

2,5

139

2,5

159

2,1

Trains - Graphical Demo

Potential Points

Traverse and add potential points

Cost

Coordinates

159

2,1

169

2,1

Trains - Graphical Demo

Potential Points
Cost

Coordinates

From (1,1):

159

2,1

From (2,2):

169

2,1

Notice that (2,1) can be reached from either (1,1) with

a cost of 159 or (2,2) with a cost of 169.

Trains - Graphical Demo

Potential Points
Cost

The lowest cost (159) is chosen.

Coordinates

Trains - Complete Solution

Algorithm goes on until the ending point is reached..

Trains - Complexity (Subtask 2)

Let number of nodes = V
For every node we visit, we need to insert its potential points ( O(1) ) and also
we would have to find the minimum cost potential point in the list.
Assuming worst case, the list would have a maximum size of (4*V), where 4 is
for the 4 adjacent nodes that are beside a certain node.
To find the minimum point, a linear search can be utilised for a complexity of O
(4*V) = O(V).
Since for every node we would need to search the list for the minimum point
and add the potential points, complexity would be O(V) * O(V) + O(1) = O(V).
Since V = N as the map is a square grid, overall complexity = O(N).

Trains - Complexity (Subtask 3)

This can be speeded up by utilising a priority queue to speed up the linear
search from O(V) to O(log V).
However, insertion of new nodes would also take O(log V) instead of O(1) as in
linear search.
Nevertheless, it is still faster as for every node, we insert a new potential nodes
( O(log V) ) and select the minimum cost node ( still O(log V) ) with complexity
of O(log V) + O(log V) = O(log V) for a certain node.
Since there are V nodes, complexity = O(V * log V).
V = N, hence overall complexity = O(N * log N)