## Editorial for DMOPC '20 Contest 4 P3 - Roving Roombas

**only**when stuck, and

**not to copy-paste code from it**. Please be respectful to the problem author and editorialist.

**Submitting an official solution before solving the problem yourself is a bannable offence.**

Author:

#### Subtask 1

We can mark all the squares with the Roombas and then for each cord, check how many squares contain the path of a Roomba.

**Time Complexity**:

#### Subtask 2

We could line sweep, but the easier solution for this subtask is to simply check every Roomba and cord pair and determine if they intersect. A Roomba intersects cord if and .

**Time Complexity**:

#### Subtask 3

If we look at the inequality used for the previous subtask, we note that we benefit greatly from sorting. Let's sort both the cords and the Roombas by . As we walk along the cords from left to right, we know that certain Roombas become irrelevant, since their paths are too short.

If we have a set of Roombas and a given cord, we can determine which Roombas intersect easily with a BIT. As we walk left to right, we remove certain Roombas from the set by updating the BIT. We query for all Roombas with small enough values by querying the BIT.

**Time Complexity**:

#### Subtask 4

We can finish off this solution with a line sweep. Note that any that does not appear for any Roombas nor any cords is irrelevant, and similarly with .

An alternative, very similar solution is to use binary search instead of a BIT. The effect is the same.

**Time Complexity**:

## Comments

How would binary search be used with a line sweep? I was thinking of storing the roombas in a vector, and as I travel from left to right, I erase roombas where because the path is too short to be considered, but erasing elements is ...

Any hints? Thanks.

The line sweep iterates the events sorted by their position. Events are either a cord at or Roomba endpoint. You can store the positions of the Roombas that have not reached their endpoint yet. This means that at the start, all the Roomba positions will be stored.

When you reach a cord event, you can binary search for the amount of Roomba positions less than the cord's position. These are all the Roombas that will intersect the current cord. When you reach a Roomba endpoint, you delete it's position. You can also use a BIT to query the amount of Roomba positions less than a cord position and decrement Roomba values. It's not recommended to use a vector to store values because it's erase is .

What data structure suffices with the binary search option?

Edit: ORZ Lost

A standard C++ set

almostsuffices. It has insert, erase, and an upperbound (binary search) function. The issue is this upperbound function returns an iterator to the element and unlike vector iterators, you can't find the index of this iterator (`it - vectorname.begin()`

). This means you will have to use a set from the gnu pbds library. It has an`order_of_key(k)`

method that finds the number of elements strictly less than . Now you can use`order_of_key(k+1)`

to find the amount of elements , because running over the end of a cord also counts as an intersection.Gnu pbds set: https://www.geeksforgeeks.org/ordered-set-gnu-c-pbds/