Sweep over $$$x$$$ from left to right. The events we care about are when a circle 'starts' (its leftmost point) and when it 'ends' (its rightmost point); for $$$2N$$$ events in total.

For a fixed $$$x$$$, process events in increasing order of their $$$y$$$ coordinate, and insertions before deletions. Then,

• If a circle starts, connect it to either the nearest circle above it or the nearest one below it with a vertical line. The closest circle can be found by binary searching on the $$$y$$$-coordinates of the currently active circles.
  Then, add this circle to the active circles.
• When a circle ends, remove it from the active circles.

At the end of this process, you'll be left with several connected components of circles, which can be described by several intervals along the $$$x$$$-axis. To connect everything, draw a line between circles at the endpoint of adjacent intervals.

There's some care needed when implementing here (some of the vertical lines created might overlap, and some vertical lines might have negative $$$x$$$-coordinates). It's not hard to fix those if you work on it a bit.

Author's original solution also sweeps over $$$x$$$ but uses predominantly horizontal segments instead of vertical ones, which is imo a bit harder (and messier) to implement.

First, let's precompute $$$cost(x)$$$, the minimum number of moves needed to delete exactly $$$x$$$ characters from the suffix of a string.

$$$cost(0) = 0$$$, and otherwise:

• If $$$x \geq K$$$, we can try deleting $$$K$$$ characters from the end, for $$$cost(x-K) + 1$$$ moves
• We can try appending one of the strings we have to change the length, then delete from the new suffix. This has a cost of $$$1 + \min(cost(x + L))$$$ across all $$$L$$$ that occur as the length of one of the $$$S_i$$$.

There are $$$\mathcal{O}(\sqrt{sum(|S_i|)})$$$ distinct values of $$$L$$$, so all the relevant values of $$$cost$$$ can be computed using bfs in $$$\mathcal{O}(K\cdot \sqrt{sum(|S_i|)})$$$ time.
(iirc all the teams who submitted during contest only missed this observation, and had $$$\mathcal{O}(K^2)$$$ computation here; however the sum of $$$K$$$ across all tests wasn't bounded while $$$sum(|S_i|)$$$ was bounded)

Now, let $$$dp_i$$$ be the minimum number of moves needed to make exactly the first $$$i$$$ characters of $$$T$$$.

$$$dp_i = \min(dp_j + c(j+1, i))$$$ across all $$$j \lt i$$$, where $$$c(x, y)$$$ is the minimum number of moves required to form the substring $$$T[x\ldots y]$$$ exactly.
$$$c(x, y)$$$ can be found by putting all the $$$S_i$$$ in a trie and using the precomputed $$$cost$$$ to figure out the minimum cost of creating each prefix.

Complexity is $$$\mathcal{O}(K\cdot \sqrt{sum(|S_i|)} + 26\cdot sum(|S_i|) + |T|^2)$$$ for precomputation + trie + dp.