Leftmost Below

The operation is annoying because it chooses the leftmost element below $x$. So if we want to increment position $i$, all earlier positions must already be at least $x$.

That is the whole problem. Everything else is just making that sentence stop looking suspicious.

The Key Constraint

Suppose position $i$ gets incremented by value $x$ during some operation.

Right before that operation:

• $a_i < x$, because position $i$ itself must be below $x$.
• For every $j<i$, $a_j \ge x$, otherwise some earlier position would be chosen instead.

Now focus on the last operation ever applied to position $i$.

Let the value of $a_i$ before that last operation be $s$. After adding $x$, it becomes the final target value:

$s+x=b_i.$

But the operation requires:

$s<x.$

So:

$b_i=s+x < 2x,$

which means:

$x > \frac{b_i}{2}.$

Since $x$ is an integer, the smallest possible value for this last jump is:

$\left\lfloor\frac{b_i}{2}\right\rfloor+1.$

And because every earlier position must be at least $x$ before this last jump, every earlier final value must also be at least $x$. Values only increase, so final values cannot be smaller than what they were at that moment.

Therefore, for every $i>1$, we must have:

$\min(b_1,b_2,\dots,b_{i-1}) \ge \left\lfloor\frac{b_i}{2}\right\rfloor+1.$

Equivalently:

$\min(b_1,b_2,\dots,b_{i-1}) > \left\lfloor\frac{b_i}{2}\right\rfloor.$

If this fails for some $i$, then position $i$ would need a final jump larger than all the previous values can support. No amount of clever operation ordering saves it. The leftmost rule is brutal like that.

Why The Condition Is Enough

Now we need to prove this condition is not just necessary, but also sufficient.

Assume for every $i>1$:

$p_i = \min(b_1,\dots,b_{i-1}) > \left\lfloor\frac{b_i}{2}\right\rfloor.$

We can build the target array from left to right.

For position $1$, there are no earlier positions blocking us. Just choose $x=b_1$, and $a_1$ becomes $b_1$.

Now suppose we have already built positions $1$ through $i-1$ exactly. Let:

$p=\min(b_1,\dots,b_{i-1}).$

By the condition:

$p > \left\lfloor\frac{b_i}{2}\right\rfloor.$

We want to make $a_i=b_i$ without touching earlier positions.

If $b_i \le p$, choose $x=b_i$. All earlier positions are at least $p$, so they are at least $x$. Since $a_i=0<x$, the operation hits position $i$ and sets it to $b_i$.

If $b_i>p$, use two operations:

• First choose $x=b_i-p$.
• Then choose $x=p$.

The first operation hits position $i$ because $b_i-p \le p$, so all earlier positions are still at least that much.

After that, $a_i=b_i-p$. The second operation with $x=p$ is valid for position $i$ because:

$b_i-p < p,$

which is the same as:

$b_i < 2p.$

This follows from:

$p>\left\lfloor\frac{b_i}{2}\right\rfloor.$

So position $i$ can always be completed using either one operation or two operations, while earlier positions remain untouched.

That proves the condition is sufficient.

Algorithm

Scan the array left to right while maintaining:

$mn=\min(b_1,\dots,b_{i-1}).$

For each $i$ from $2$ to $n$, check:

$mn > \left\lfloor\frac{b_i}{2}\right\rfloor.$

If not, print NO. Otherwise keep scanning and update:

$mn=\min(mn,b_i).$

If all checks pass, print YES.

Complexity

Each test case is linear:

$O(n)$

Total complexity over all tests is:

$O\left(\sum n\right),$

which is easily fine.