Upload
ying-xuan-eng
View
16
Download
0
Embed Size (px)
DESCRIPTION
MCO P And S
Citation preview
3rd MCO 2015Problems & Solutions
BadmintonProposed 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 - Pseudocodepoints = 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
HoneyProposed 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;
BitcoinProposed 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 2 3 4 5 6
1
2
3
4
5
● 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
Bitcoin - AlgorithmHigh 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 row’s 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
SecretProposed 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 Substringmutated_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
TrainsProposed 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 Solution1. Start from a starting point2. 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 DemoPotential Points
Cost Coordinates
99 1,3
Begin at point (1,3) and end at point (4,5)
Trains - Graphical DemoPotential Points
Cost Coordinates
Traverse point (1,3)
Trains - Graphical DemoPotential Points
Cost Coordinates
119 1,2
119 1,4
119 2,3
Add all potential points to a list
Trains - Graphical DemoPotential Points
Cost Coordinates
Traverse lowest potential point.In this case, all 3 points have the lowest cost. Traverse all...
Trains - Graphical DemoPotential Points
Cost Coordinates
129 1,1
139 2,2
139 2,2
129 2,4
129 2,4
129 1,5
Keep on adding potential points. Note that the points with ‘-1’ are not considered
Trains - Graphical DemoPotential Points
Cost Coordinates
129 1,1
139 2,2
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
From (1,2):
From (2,3):
Trains - Graphical DemoPotential Points
Cost Coordinates
129 1,1
139 2,2
139 2,2
129 2,4
129 2,4
129 1,5
Pick lowest cost
Trains - Graphical DemoPotential Points
Cost Coordinates
139 2,2
139 2,2
Traverse lowest cost
Trains - Graphical DemoPotential Points
Cost Coordinates
139 2,2
139 2,2
139 2,5
139 2,5
159 2,1
Add potential points
Trains - Graphical DemoPotential Points
Cost Coordinates
159 2,1
169 2,1
Traverse and add potential points
Trains - Graphical DemoPotential Points
Cost Coordinates
159 2,1
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.
From (1,1):
From (2,2):
Trains - Graphical DemoPotential Points
Cost Coordinates
The lowest cost (159) is chosen.
Trains - Complete SolutionAlgorithm goes on until the ending point is reached…..
Trains - Complexity (Subtask 2)Let number of nodes = VFor 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²)