Codeforces celebrates 10 years! We are pleased to announce the crowdfunding-campaign. Congratulate us by the link https://codeforces.com/10years. ×

### Geothermal's blog

By Geothermal, history, 4 weeks ago, ,

# A — Serval vs Monster

Unpacking the problem, we need to find the least multiple of $A$ that is greater than $H$. This is equal to $H$ divided by $A$, rounded up, or $\lceil \frac{H}{A} \rceil$. Using the integer division provided by most programming languages, we can compute this as $\frac{H + A - 1}{A}$, rounded down. (This is correct because when $H$ is equal to $0$ mod $A$, the $A-1$ component will be discarded, but otherwise, adding $A-1$ will be enough to push $H$ to the next multiple of $A$, effectively adding $1$ to the result similarly to rounding up.)

Runtime: $O(1)$. Click here for my submission.

# B — Common Raccoon vs Monster

Given that we can't use the same move twice, our best option is to just use all the moves once, so the amount of damage we can deal is the sum of $A_i$ over all $i$. We can compute this sum and then compare it to $H$, printing Yes if the sum is at least $H$ and No otherwise.

Runtime: $O(N)$. Click here for my submission.

# C — Fennec vs Monster

First, we claim that we should use the special move on the $K$ monsters with the greatest $H_i$. To prove this, note that we should never attack a monster and then use the special move on it (it'd be pointless--we could save a move just by not attacking beforehand), so the special move will always save us exactly $H_i$ attacks when used on monster $i$. Thus, since we want to save as many attacks as possible, we should use the special move on the monsters with the $K$ greatest values of $H_i$.

Now, we need to attack the remaining $N-K$ monsters. We sort the data and take the sum of the $N-K$ (or $0$, if $N < K$) monsters with the lowest $H_i$. We can then print this sum as our answer.

Runtime: $O(N \log N)$. Click here for my submission.

# D — Caracal vs Monster

We claim that the answer is $2^{\lfloor \log_2 H \rfloor + 1} - 1$. We will prove this by strong induction on $H$. The base case, $N = 1$, is trivial: $2^{0 + 1} - 1 = 2 - 1 = 1$, and indeed, we need to use only a single attack to kill the monster, as desired.

Now, for our inductive step, we prove that this answer is correct for some $H$ given that it works for all other values. First, notice that the answer for $H$ is equal to one more than twice the answer for $\lfloor \frac{H}{2} \rfloor$, since after our first attack, we have two independent subproblems with value $\lfloor \frac{H}{2} \rfloor$. Thus, our answer for $H$ is

$2(2^{\lfloor \log_2 \lfloor \frac{H}{2} \rfloor \rfloor + 1} - 1) + 1.$

We can observe that $\lfloor \log_2 \lfloor \frac{H}{2} \rfloor \rfloor = \lfloor \log_2 H \rfloor - 1$. The intuition comes from a basic application of logarithm rules, but we can also prove this formally: note that if $H$ is an odd number greater than $1$, then $\lfloor \log_2 H \rfloor = \lfloor \log_2 (H-1) \rfloor$ and $\lfloor \frac{H}{2} \rfloor = \lfloor \frac{H-1}{2} \rfloor$, so subtracting $1$ from $H$ won't change the result on either side of the equation. Thus, if $H$ is odd, we can subtract $1$ from it, so we can assume $H$ is even. Then, $\lfloor \frac{H}{2} \rfloor = \frac{H}{2}$, and $\lfloor \log_2 \frac{H}{2} \rfloor = \lfloor \log_2 H \rfloor - 1$, as desired, where this final step comes from our logarithm rules.

$2(2^{\lfloor \log_2 H \rfloor} - 1) + 1 = \boxed{2^{\lfloor \log_2 H \rfloor + 1} - 1},$

as desired.

Now, we can simply implement this formula and output its value for our $H$.

Runtime: $O(1)$ if you use a native function to compute logarithms, or $O(\log H)$ if you do it yourself. Click here for my submission.

# E — Crested Ibis vs Monster

Though it initially might seem like this problem demands some sort of greedy solution, the problem is fraught with edge cases, so coming up with a correct greedy approach is more difficult than it looks (maybe even impossible). Luckily, the constraints are low enough that $O(HN)$ solutions are admitted, motivating a dynamic programming approach.

Let $dp[i]$ be the fewest MP necessary to deal $i$ damage. Of course, we are looking for $dp[H]$. To start off, note that $dp[0] = 0$, and initialize all other $dp[i]$ to $\infinity$. Then, our transitions are our spells--for each $i$ and $j$, we take $dp[i] = min(dp[i], dp[i-A_j] + B_j)$, raising $i-A_j$ to zero if it is negative. The intuition is that we're transitioning from the state $i-A_j$, since that's the damage we had dealt before casting this spell, and then we add $B_j$, the cost of this spell.

Our answer is then $dp[H]$.

Runtime: $O(HN)$. Click here for my submission.

# F — Silver Fox vs Monster

My solution essentially overkills this problem with a lazy segment tree. Of course, this problem can be solved via several simpler approaches, most of which implement the same general idea using prefix sums or a BIT (or any other structure that can support range updates and point queries), but the asymptotic complexity is the same either way, and I found this solution easiest to write quickly since I had an easily accessible template I could use.

We start by sorting the monsters by location and creating a map from monster locations to their indices in the sorted list. We then create a lazy segment tree, where the value at position $i$ represents the health of monster $i$, where monsters are indexed based on their position in the sorted list. We initialize all of these values to $H_i$.

Then, we proceed through the monsters in increasing order of location. Our basic idea is to continually drop bombs whose leftmost position is the position of the leftmost remaining monster. We can prove that this will lead to an optimal solution because any bombs with positions further to the right will avoid killing the leftmost remaining monster, and this configuration kills the leftmost monster while maximizing damage to monsters further to the right.

For each monster $i$, we start by querying the segment tree for its health. Then, we compute the number of bombs $B$ necessary to kill it, similarly to our approach to problem A. We also compute, using the map created beforehand, the highest index $j$ whose monster is at a position less than or equal to $X_i + 2D$, since this will be the furthest monster to the right that we can reach. Finally, we update the segment tree by subtracting $AB$ over the range $[i, j]$ and add $B$ to our answer. Then, we move on to the next monster.

Runtime: $O(N \log N)$, due to sorting, our maps, and $O(N)$ segment tree operations. Click here for my submission.

• +23

 » 4 weeks ago, # |   0 I also used lazy segtree for F. ugh
 » 4 weeks ago, # |   +5
 » 4 weeks ago, # |   +4 For solving question F, we could simply use a binary search and an array.(without using BIT or segment trees). First of all we need to sort the location of monsters and thenfor each location count the number of bombs needed to kill the monster at xi and then apply binary search from xi+d to look upto what further index that bomb(s) will cover (can be easily done with a binary search) and store it in an array for further propagation. Here is the link to the solution
 » 4 weeks ago, # | ← Rev. 2 →   +1 Epic solutions! For D, I visualized the monsters and their offspring as a complete binary tree of depth $\lfloor\log_2 H\rfloor$, and every node needed exactly one attack to eliminate, so the answer became $2^0 + 2^1 + \dots + 2^{\lfloor\log_2 H\rfloor}$, and by the geometric sequence formula, also results in the general formula $2^{\lfloor\log_2 H\rfloor+1}-1$. However, I implemented it using purely bitwise operations: https://atcoder.jp/contests/abc153/submissions/9738416
•  » » 4 weeks ago, # ^ |   +1 Isn't it simpler to follow the problem definition: ll ans(ll h) { if (h == 1) return 1; ll a = ans(h / 2); return 1LL + a + a; } 
 » 3 weeks ago, # | ← Rev. 3 →   0 I did F using a queue instead of a lazy segment tree. I kept track of "damage to the current coordinate" and used a queue to store the right endpoints of the bomb ranges. (I went left-to-right as well, the main idea is the same -- just implemented differently).Click here for my submission.