so for every subarray of size mid, smallest elements should be used first to exhaust all ops of type 1, then after that remaining elements<=y.

Sorry for the late reply :(

Lets do a different approach. For each index $$$l$$$, let it be a potential start of our subarray and find $$$f(l)$$$ as the furthest end away from l that we can turn the subarray $$$[l,f(l)]$$$ into zeros

If $$$a[l]==0$$$ and we found a potential end $$$r$$$, we pick $$$x$$$ largest elements in $$$[l,r]$$$ and apply opertaion $$$1$$$ to turn them to zeros, and the other elements we can chip away with operation $$$2$$$. So to be able to turn $$$[l,r]$$$ into zeros, we need to satisfy $$$Sum(l,r)-SumOfBig(l,r)<=y$$$, with $$$SumOfBig$$$ meaning the sum of the X biggest elements in $$$[l,r]$$$

If $$$a[l]!=0$$$,we use up one of the first type operation to make it $$$0$$$, and find $$$f(l)$$$ similarly like case above

$$$Sum(l,r)$$$ can be done in $$$O(1)$$$ with prefix sum; and we can find $$$SumOfBig(l,r)$$$ in $$$O(log(n)^2)$$$ with binary search, combined with Persistent Segment Tree or Persistent Fenwick Tree.

Our complexity for each potential $$$r$$$ is $$$O(log(n)^2)$$$ so we cant afford another binary search. Use 2 pointers instead.

However there's an easy mistake to fall into. Unlike normal 2 pointers, here $$$f(l)$$$ can be less than $$$f(l+1)$$$ because we must waste a first type operation if the second case occurs for $$$l+1$$$. So we need to do 2 pointers seperately for the 2 cases. I guess my explanation for doing the 2 pointers seperately might be unclear, if you are not sure about it you can ask later :D

Edit: just finished dinner :) my solution above is $$$O(n*log^2)$$$ but we can inprove it to $$$O(n*log)$$$

instead of using persistent data structures combined with binary search, as you move the pointers you can insert elements into a BST(for example Treap) or a skiplist