Here I am sharing how I approached and solved the problems of the recently held Round 55 (DIV 2)
This was an extremely simple problem. Simply count the number of upper case latin letters. If that is strictly greater than number of lower case letters convert the word to upper case other wise convert it to lower case.
B. Fortune Telling
For this problem all you need to do is store the smallest odd number of petals and also the sum of all the petals. It is quite obvious that only if the number of petals is odd the result would be "Loves". So if the sum is even print sum - smallest odd, otherwise print the sum.
This was a very nice problem. My approach was to first flag all the letters which have already appeared. Notice, that we have to output the lexicographically smallest palindrome. So, start from the middle of the letter and iterate one side...
If you get a '?' stop and check if the corresponding position on the other side also has a '?'. If yes, then fill both with the lexicographically biggest letter which hasn't appeared yet in the word and also flag that letter.
Once you have exhausted all the letters and there are still '?' left then simply fill them with 'a'.
Now simply iterate over the word again and see if there are any question marks left, if yes copy the values in the corresponding block on the other side. At the same time check if at any time the two opposite values match or not. If they do throughout then it is a valid plaindrome which is also the lexicographically smallest palindrome.
Here is a slightly messy implementation of the same: http://codepad.org/Fr7NYqYT
Complexity: O(wordlength + k)
D. Team Arrangement
This was in my opinion was the toughest problem. However once you get the logic, its pretty obvious. However, it was a slightly challenging implementation for me as the structure of the data to be stored was sort of complex.
The basic idea was simply that if we have to find the preference list of a number 'p' then two things might happen:
Case 1: p is the most skilled in his team and thus he chose the team. In this case we know that all the members of the teams coming after p's team are less preferred than p's team mates. Let p's team mates be 'm' and 'n' such that m > n.
To get the lexicographically smallest preference list, we will divide all the programmers into two lists. The first list will contain all members (ai) from teams which were chosen before p's team such that ai < m. It will also contain m and n.
The second list will contain all the left over members.
The separation can be done in O(n) time. Now all we need to do is sort the first list, print it, sort the second list, print it!
Complexity: O(nlogn)... It can be reduced to O(n) also but the constant will be pretty high and will give almost the same result as O(nlogn).
Case 2: p is not the leader of the team. Then you just have to output all number except 'p' from 1 to 3 * n.
As for the last problem, I do not have a solution. I do not have much experienced with implementing graphs unfortunately.
Please point out any optimizations to the above or mistakes which I might have made in the above.