how did you arrive at x-y-2?

Using binary search can be a possible soln.

#include<bits/stdc++.h>
using namespace std;

#define ll long long
#define endl "\n"

bool check(ll n,ll x, ll y, ll mid){
	if((mid<(x-1))||(mid<(n-y)))return false;
	ll rem_x = mid-(x-1);
	ll cover_x = x;
	if(x==1)rem_x++;
	if(rem_x>=1)cover_x += (rem_x-1);
	ll rem_y = mid-(n-y);
	ll cover_y = y;
	if(y==n)rem_y++;
	if(rem_y>=1)cover_y -= (rem_y-1);
	if((cover_x+1)>=cover_y)return true;
	return false;
}

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	int tc = 1; 
	// cin>>tc;
	// cin.ignore();
	while(tc--){	
		ll n,x,y;
		cin>>n>>x>>y;

		if(x>y)swap(x,y);

		ll low = 0, high = n+1;
		ll ans = 0;
		while(low<=high){
			ll mid = (low+high)/2;
			if(check(n,x,y,mid)){
				high = mid-1;
				ans = mid;
			}
			else{
				low = mid+1;
			}
		}
		cout<<ans<<endl;
	}
 	
		
}

let a be the number of houses left to the left person,

b be the number of houses right to the right person,

and c be the number of houses in between those 2

if(a+c+c>b) return b

if(b+c+c>a) return a

return min( ceil((a+b+c+c)/2) , ceil((4b+2c+a)/3) , ceil((b+2c+4a)/3) , ceil((2a+2b+c)/2) )

each expression is related to some scenario

Try this.

#include <iostream>
#define ll long long
using namespace std;

int main(){
  int t; cin>>t;
  while(t-->0){
    ll n, x, y; cin>>n>>x>>y;
    x--; y--;
    // i consider indexes of houses are 0-based
    if(x>y){swap(x, y);}
    ll a = 2*x - 1;
    ll b = y-x+1;
    ll c = 2*(n-y-1) - 1;
    if(abs(c-a)>=b){
      cout<<max(a, c)<<endl;
    }
    else{
      b -= 1;
      b -= (abs(c-a));
      cout<<max(a, c)+(b+1)/2<<endl;
    }
  }
  return 0;
}

Binary search the minimum number of minutes.

— — — — A — — — — — — — B — — — — -

Lets say you are B, you have 2 options:

• Fill right then switch to the left

• Go to the left and then fill the right

Check both to see wich one covers more houses, do the same with A and check if you covered all the houses

The other 2 cases are more trivial(also included in the binary search aproach)

A — — — — — — — — B

— — — — A B — — — —

Let's assume that x<y, then the image of the scenario can be drawn like this, ---(Left)---A----(Middle)----B----(Right)---- we know that Alice will take care of the left houses and Bob will take care of the right houses. The only thing we can do is to find the number of middle houses such that maximum time taken by Alice and Bob is minimum. To do this, we can simply iterate from 0 to "number of the middle houses" and find out the minimum time taken.

hi, can you please share the 4th question of this set in which this question was 1st?

This is my code , i tried it on so many test cases , please prove me wrong if i am.1. —

// JAI SHREE KALYAN 
#include <bits/stdc++.h>
#include<iostream>
using namespace std;
#define ll long long
#define pl pair<long long , long long>

void solve(){
  ll n , x , y ; 
  cin >> n >> x >> y ; 
  if(x > y )swap(x , y) ;
  ll ans = max(n-x,y-1);
// 1 a 3 4 5 6 b 8 9 10 11 
// 
  if((x-1) > (n-y)){
    ans  = min(ans , max((y-x-1) + 2*(n-y) , x-1)); 
  }else{
    ans = min(ans , max(n-y,  y-x-1 + 2*(x-1))) ; 
  }

  cout << ans << endl ; 
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

   
        solve();
    

    return 0;
}

This code is working check it out.

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 1000000007

void solve()
{
}

int main()
{
    ll test = 1;
    cin >> test;
    while (test--)
    {
        ll n, x, y;
        cin >> n >> x >> y;

        if (x < y)
        {
            ll dxy = abs(y - x) - 1;
            ll dx1 = abs(x - 1) - 1;
            ll dyn = abs(n - y) - 1;
            ll ans = min((2 * dxy) + dyn + dx1, min(dxy + (2 * dyn) + dx1, dxy + dyn + (2 * dx1)));
            cout << ans << endl;
        }
        else
        {
            ll dxy = abs(y - x) - 1;
            ll dy1 = abs(y - 1) - 1;
            ll dxn = abs(n - x) - 1;
            ll ans = min((2 * dxy) + dy1 + dxn, min(dxy + (2 * dy1) + dxn, dxy + dy1 + (2 * dxn)));
            cout << ans << endl;
        }
        solve();
    }
    return 0;
}

1488C - Two Policemen Here is the question, if anyone is still searching