Yes. 5 minutes will be added to your time. (But only if you end up solving that question. Wrong submissions on problems, that you don't solve, won't give you any penalties).

How you solved F? what was the check function in binary search?

First,find the minimum value of right hand side then find value of x accordingly.

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define sor(vec) sort(vec.begin(),vec.end())
#define rev(vec) reverse(vec.begin(),vec.end())
#define pb push_back
const int mod = 998244353;

#ifdef LOCAL
#include "debug.cpp"
#else
#define deb(...)
#endif

signed main(){
    ios::sync_with_stdio(false); cin.tie(NULL);
    #ifndef ONLINE_JUDGE
    freopen("error.txt", "w", stderr);
    #endif
    int TC=1;
    while(TC--){
        int n,l,r;cin>>n>>l>>r;
        
        vector<int>v;for(int i=0;i<n;i++){
        	int x;cin>>x;v.pb(x);
        }
        
        int mini=-1;
        
        vector<int> ans;
        for(auto it:v){
        	if(it<l){
        		mini=l-it;
        		ans.pb(it+mini);
        	}else if(it>=l && it<=r){
        		mini=min(it-l,r-it);
        		ans.pb(it);
        	}else{
        		mini=it-r;
        		ans.pb(abs(mini-it));
        	}
        	
        }
        for(auto it:ans) cout<<it<<" ";
        cout<<endl;
    }
}

if A-i < L, print L

if A-i > R, print R

if A-i is in range [L, R], print A-i

I am in the same situation, have you resolved it?

If I understand correctly, you're considering the interval can start at some $$$a_i$$$ and finish at $$$a_i + x$$$, but you may be missing the cases where it can finish at some $$$a_i$$$ and start at $$$a_i - x$$$.

To handle this I used a copy of the array with the reversed sign, and then you can take the min between both cases. Code

I have solved this problem, you can try this data： 5 5 3 2 2 1 2 4 0 1 0 2

Yes.

My submission [](https://atcoder.jp/contests/abc330/submissions/47945295) my code even change from WA to AC after switch to clang C++,literally don't know what's going on.

precalculate all squares of num till 4e6 and store them in vec. iterate for all possible x values (<=sqrt(d)) . Then rem=d-x*x. find min possible y less than rem using binary search in vec for y and update ans. Link

Wow that's a really smart solution. Considering only the $$$x$$$-cordinate ($$$x,y$$$ are independent), I think the intuition here is that you examine all the possible problematic pairs that create the $$$\max_{i}X_{i}-\min_{i}X_{i}$$$ difference.

Assuming you sort $$$X$$$, at first you look at $$$X_{1}$$$ and $$$X_{N}$$$ (which are the min, max). No matter how you choose the optimal square with side $$$\ell$$$, it will be inside $$$[X_{1},X_{N}]$$$ so you will always just have make $$$X_{1}$$$ bigger to match the left side of the square and $$$X_{N}$$$ smaller to match the right side of the square, in total $$$X_{N}-X_{1}-\ell$$$ times.

After you handle $$$X_{1},X_{N}$$$ change them so they fit the square. Now the min/max pair that will be problematic is $$$X_{2},X_{N-1}$$$, so you continue using the same logic if it is actually problematic, i.e if $$$X_{N-1}-X_{2} >\ell$$$ (notice that if $$$X_{N-1}-X_{2}>\ell$$$ you can also be sure that the square will lie inside $$$[X_{2},X_{N-1}]$$$). Also you don't really have to stop the loop since any pair afterwards will still have a smaller difference than $$$\ell$$$.