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;
}