POJ 3714 Raid

#include <stdio.h>
#include <math.h>

#define MAX 100001
#define INF (1e+11)

struct POINT{
double x;
double y;
int isAgent;
};

int numOfStationsOrAgents;

POINT pointArray[MAX * 2];
int numOfPoints;
int indexOfPoint;

POINT leftMidPointArray[MAX];
int numOfLeftMidPoints;
int indexOfLeftMidPoint;

POINT rightMidPointArray[MAX];
int numOfRightMidPoints;
int indexOfRightMidPoint;

void pointCopy(POINT *to, POINT *from){
to->x = from->x;
to->y = from->y;
to->isAgent = from->isAgent;
}
void sortPointsAccordingToX(int start, int end){
if (start >= end){
return;
}

while (start < end){
int left = start;
int right = end;
POINT pivotPoint;
pointCopy(&pivotPoint, &pointArray[start]);
double pivotX = pivotPoint.x;
while (left < right){
while (left < right && pointArray[right].x >= pivotX){
right--;
}
pointCopy(&pointArray[left], &pointArray[right]);
while (left < right && pointArray[left].x <= pivotX){
left++;
}
pointCopy(&pointArray[right], &pointArray[left]);
}
pointCopy(&pointArray[left], &pivotPoint);
int pivot = left;
sortPointsAccordingToX(start, pivot - 1);
start = pivot + 1;
}
}

double getDist(POINT from, POINT to){
if (from.isAgent == to.isAgent){
return INF;
}
double deltaX = from.x - to.x;
double deltaY = from.y - to.y;
return sqrt(deltaX * deltaX + deltaY * deltaY);
}
double getMinDist(int left, int right){
double minDist = INF;
if (left == right){
return minDist;
}
if (left + 1 == right){
return getDist(pointArray[left], pointArray[right]);
}

int mid = (left + right) >> 1;
double leftMinDistSquare = getMinDist(left, mid);
double rightMinDistSquare = getMinDist(mid + 1, right);
minDist= (leftMinDistSquare < rightMinDistSquare ? leftMinDistSquare : rightMinDistSquare);

numOfLeftMidPoints = 0;
for (indexOfPoint = mid; indexOfPoint >= left; indexOfPoint--){
double deltaX = pointArray[mid].x - pointArray[indexOfPoint].x;
if ( deltaX < minDist){
++numOfLeftMidPoints;
pointCopy(&leftMidPointArray[numOfLeftMidPoints], &pointArray[indexOfPoint]);
}
}
numOfRightMidPoints = 0;
for (indexOfPoint = mid; indexOfPoint <= right; indexOfPoint++){
double deltaX = pointArray[indexOfPoint].x - pointArray[mid].x;
if ( deltaX < minDist){
++numOfRightMidPoints;
pointCopy(&rightMidPointArray[numOfRightMidPoints], &pointArray[indexOfPoint]);
}
}

for (indexOfLeftMidPoint = 1; indexOfLeftMidPoint <= numOfLeftMidPoints; indexOfLeftMidPoint++){
for (indexOfRightMidPoint = 1; indexOfRightMidPoint <= numOfRightMidPoints; indexOfRightMidPoint++){
double dist = getDist( leftMidPointArray[indexOfLeftMidPoint], rightMidPointArray[indexOfRightMidPoint]);
if (dist < minDist){
minDist = dist;
}
}
}

return minDist;
}

int main(){
//freopen("input.txt", "r", stdin);

int numOfTestCases;
scanf("%d", &numOfTestCases);
while (numOfTestCases--){
scanf("%d", &numOfStationsOrAgents);
numOfPoints = numOfStationsOrAgents * 2;
for (indexOfPoint = 1; indexOfPoint <= numOfStationsOrAgents; indexOfPoint++){
scanf("%lf %lf", &pointArray[indexOfPoint].x, &pointArray[indexOfPoint].y);
pointArray[indexOfPoint].isAgent = 0;
}
for (  ; indexOfPoint <= numOfPoints; indexOfPoint++){
scanf("%lf %lf", &pointArray[indexOfPoint].x, &pointArray[indexOfPoint].y);
pointArray[indexOfPoint].isAgent = 1;
}

sortPointsAccordingToX(1, numOfPoints);

printf("%.3f\n", getMinDist(1, numOfPoints) );

}
return 0;
}