Code chef problem solved but need to optimise due to TLE .

See more:

C++

Chef has N axis-parallel rectangles in a 2D Cartesian coordinate system. These rectangles may intersect, but it is guaranteed that all their 4N vertices are pairwise distinct.

Unfortunately, Chef lost one vertex, and up until now, none of his fixes have worked (although putting an image of a point on a milk carton might not have been the greatest idea after all…). Therefore, he gave you the task of finding it! You are given the remaining 4N−1 points and you should find the missing one.

Input
The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains a single integer N.
Then, 4N−1 lines follow. Each of these lines contains two space-separated integers x and y denoting a vertex (x,y) of some rectangle.
Output
For each test case, print a single line containing two space-separated integers X and Y ― the coordinates of the missing point. It can be proved that the missing point can be determined uniquely.

Constraints
T≤100
1≤N≤2⋅105
|x|,|y|≤109
the sum of N over all test cases does not exceed 2⋅105
Subtasks
Subtask #1 (20 points):

T=5
N≤20
Subtask #2 (30 points): |x|,|y|≤105
Subtask #3 (50 points): original constraints

Example Input
1
2
1 1
1 2
4 6
2 1
9 6
9 3
4 3
Example Output
2 2
Explanation
The original set of points are:
fig1

Upon adding the missing point (2,2), N=2 rectangles can be formed:
fig1

What I have tried:

#include <iostream>
using namespace std;
void quicksort(long int number[],long int n)
{
    int i,j,a;
       for (i = 0; i < n; ++i) 
        {
 
            for (j = i + 1; j < n; ++j)
            {
 
                if (number[i] > number[j]) 
                {
 
                    a =  number[i];
                    number[i] = number[j];
                    number[j] = a;
 
                }
 
            }
    }
}
int main(void) {
	// your code goes here
	long int n,i,j,k,rx,ry;
	cin>>n;
	for(i=0;i<n;i++)
	{
	    cin>>k;
	    long int x[4*k-1],y[4*k-1];
	    for(j=0;j<4*k-1;j++)
	    {
	        cin>>x[j]>>y[j];
	    }
	    quicksort(x,4*k-1);
	    quicksort(y,4*k-1);
	    int flagx=0,flagy=0;
	    for(j=0;j<4*k-1;j=j+2)
	    {
	        if(!flagx||!flagy)
	        {
	            if(!flagx)
	            {
            if(x[j]!=x[j+1])
            {
                rx=x[j];
                flagx=1;
            }}
             if(!flagy)
            {
            if(y[j]!=y[j+1])
            {
                ry=y[j];
                flagy=1;
            }}
            }
             else
            {break;}
	        }
	    	cout<<rx<<" "<<ry<<endl;
	}
	return 0;
}