You should never remove candies from the last box because it doesn't help in making a sequence increasing. You must remove some candies from the second box if there isn't fewer of them that in the last box — you must decrease their number from b to c - 1. Finally, maybe you must remove candies from the first box, depending on the new number of candies in the second box. See my implementation for details.

You can either try to find a formula or write a binary search. I recommend the latter approach because it requires less thinking. For fixed number of days you should calculate how many extra fruits you must buy (if any) and how much money it would cost you. Finally you should check if you have enough money to live that fixed number of days after buying extra fruits.

This is an easier version of div1-med. In div1 version N was up to 3000 instead of 50. In a sequence that has "ABC" as subsequence there must be the first place (index) with letter 'A', the first place with 'B' after that, and the first place with 'C' after that. You can iterate over those three indices and for each of O(N³) cases compute the number of matching strings in O(N). For fixed three indices a string is divided into four parts. The first part (before first 'A') can't contain any 'A' (because otherwise the first 'A' would be earlier). The second part can't contain any 'B', and the third part can't contain any 'C'. You should apply those conditions and for every number check to how many letters it can be transformed. For example, if a number 10 appeared in the first part and in the second part, it can be transformed to 'C' only. Multiply numbers of ways to choose a letter for each number, and add it to the answer. See my code (given at the top of this comment) for details.

There is a known problem: for given grid how many cells we should change to allowed, to make it possible to traverse between some two cells. It can be solved with something similar to BFS: create an array int dp[row][col] — for each cell compute the smallest cost to get to this cell (from the starting cell). But in this problem we can make a cell allowed only by making some other cell forbidden. Clearly, the final path between two corners can't exceed the total number of allowed cells in the initial grid. The problem turns out to be equivalent to: how many cells should we mark allowed so that there will be a path between corners of length not exceeding some number (initial number of allowed cells). Now it's enough to add one dimension to our previous BFS/dynamicProgramming, for example use an array int dp[row][col][len] — for each cell compute the smallest cost to get to this cell with a path of length at most len. Since len is up to h·w, this gives us solution. In the code above you can see an alternative, slightly easier approach in O((h·w)³) with an array bool reachable[row][col][len][cost].

Find an O(n⁴) solution first (see div2-hard editorial). First try to decrease complexity to O(n³) — when we iterate over three indices, we don't have to recompute everything in O(n) each time. When we move the index of "first C after the two first fixed indices", only O(1) things change.

Getting O(n²) is a bit trickier. This time iterate over only two indices: first 'A', and first 'B' after that. Let X denote the number of strings with "AB" subsequence matching those two fixed indices, and let Y denote the number of strings satisfying an additional condition that there should be no 'C' after our fixed 'B'. Then we should add X - Y to the answer because it's the number of matching strings with "ABC" subsequence. So now we can iterate over two indices only and apply a trick that allowed us to get O(n³) complexity. The final complexity is O(n²).

A tester (bmerry) found a deterministic solution but let me describe my intended randomized solution. Let's use x = 32 primes and let's say that every element of the sequence will be the product of exactly y = 11 primes. I create a sequence from left to right, randomly choosing every new element so that everything will be good so far (it should be coprime with a previous element and not coprime with other ones). For every new element I find x - y primes that aren't divisors of a previous element (I can't use them) and in a loop I try the following. I choose y of those x - y primes and compute the product of them. If the product exceeds 10¹⁸ or it's coprime with one of previous elements (I check that in O(n)), I repeat. It turns out that with well chosen values of x and y this solution doesn't repeat generating new numbers a lot — it computes a whole sequence under 1 second in my computer. You may wonder that new numbers will often be not coprime with any previous elements. Assuming that each number is chosen independently (they aren't obviously, but we only talk about the intuition) then the probability of two numbers being coprime is equal to the probability that two sets of y elements from the set of x elements are disjoint — you can check that this probability isn't much bigger than 1 / n so we can hope that new numbers will often be fine with all O(n) previous elements.