Editorial for TLE '16 Contest 8 P4 - Delivery Service
Submitting an official solution before solving the problem yourself is a bannable offence.
Author:
For the first subtask, we can use recursion to brute force the number of possible paths.
Time Complexity: 
For the second subtask, we can use basic dynamic programming. For each planet, let  be the number of paths to that planet, 
. For the 
 planet from 
 to 
, and some other planet 
 
, 
 if planet 
 can be directly reached from planet 
.
Time Complexity: 
For the third subtask, we optimize the DP algorithm above by using a suffix sum array (similar to a prefix sum array). Now, redefine  to mean the number of paths from planet 
 to planet 
. Now, 
 and we want to find 
. We now note that for a planet 
, if 
 is the furthest planet that can be reached, 
. This is equal to 
, and the suffix sum array stores both of these values. Note that we should now process planets in reverse order.
Time Complexity: 
In the case of , define 
 to mean the number of paths from planet 
 to planet 
. Make sure to code 
 and 
 separately because these are corner cases (in subtasks 5 and 6, it is sufficient to solve for 
).
For the fourth subtask, notice that  is relatively small. It is enough to have 
 planets where every non-starting planet 
 has exactly 
 path to the end, or 
. Next, let Fax initially have 
 units of fuel. Now Fax can first choose any of the planets 
 and for each of these choices, there is 
 way to go to the end.
Complexity of : 
First, notice that  and 
. That means if the array 
 is known, then 
 is a prefix sum of this array. It is pointless to have 
 because 
 fills up valuable space in the array. Given a completed array 
, it is easy to find the amount of fuel from each location (including the starting location) using a naive 
 algorithm. To solve 
, construct this array so that the first element is 
.
For the fifth subtask, notice that the allowed  is quite large. If 
, refer to subtask 4. Otherwise, construct the array so that it contains 
 elements which are all 
's. Then add the element 
 to the array since 
 is a possible prefix sum. While the sum of the elements in the array is less than 
, keep adding another 
. Once the sum of the elements in the array is at least 
, 
 can be constructed. All of the 
's are necessary to get 
, along with some of the 
's. After this array is complete (the first element is 
), the planet's fuels can be calculated in some other step.
In total, .
Complexity of : 
, and 
 is chosen because 
is too lazy to finish the editorial for subtask 6, and has forgotten what the solution was.
Bonus Challenge: Try to solve  with 
.
Comments
Edit: Full Points [Unofficial] Editorial The following solution works for subtasks 4, 5, AND 6. It also uses a completely different idea than what I had before. You can read the older version for your own amusement.
Time Complexity:
Understand that we can always double the number of distinct paths starting at path
, at a new planet 
 (we traverse the planets backward, like in the official solution). So, if 
 is a power of 
, we can easily set up planets in the following sequence:
(This works as the fuel at planet
 is enough to reach all planets ahead of itself.)
Notice that we can build this solution by starting with 
, and dividing by 
 continuously until we reach 
, if 
. But, we cannot do so if 
 is not a power of 
. This is because if we kept dividing by 
, we would eventually reach an odd number before we reach 
.
To accommodate for odd numbers, we need to have a sufficient amount of planets at the end of the sequence with simply
 distinct path - because 
 plus an even number equals an odd number. Take 
 for example.
Planet: 0 1 2 3 4 5 6 7 Paths: 27, 13, 6, 3, 2, 1, 1, 1
Fuel: 7, 5, 3, 2, 2, 1, 1, 0 (planet 7 is the end, thus has 0 fuel)
There are several things to notice from this example. First, the end planet and the second last planet will always have a distinct number of paths equal to
. Second, each planet 
 has paths 
 except for the first (which should have 
 distinct paths). Third, everytime 
, is an odd number, we create another planet at the end of the list (before ending destination) with a distinct path of 
. Fourth, if a planet should have an odd number of paths and is not equal to 
, its fuel equals the fuel of the planet ahead of it plus 
. Otherwise it should have the fuel of the planet ahead of it, plus 
.
It is left to the reader to determine why the statements/patterns above are true, cause I am too lazy to explain. Once all this is understood, the code is fairly simple. All we do is start with
, and keep dividing it by 
. If the current value of 
 happens to be odd, then we subtract 
 first and add a planet with 
 distinct path at the end of our list. We also must remember that this is planet 
, and that it should have either 
 or 
 if it's even or odd, respectively. One way to store this is with a vector of pairs.
Finally, be aware of the edge case of
 and that planet 
 as well as planet 
 always has 
 distinct path.
Oh, if you didn't know, assuming planet 
 has 
 distinct path, then planet 
 can also have 
 distinct path by giving it 
 fuel.