POJ 3714 Raid

//POJ 3714 Raid
//AC by warteac
//2013-7-19
/*
    法一：先排序，然后依次向后找最小距离，并且剪枝
         重点是，不需要指定找 人到站点或是站点到人的距离，把所有的都看成点，就找两点最短距离即可
         为了区别用flag标记，求距离时判断flag是否相同。
    6764K 3579MS C++ 2090B 2013-07-19 11:44:37 
    法二：二分是高效算法；
         重点是，合并的时候，求最短距离横跨左右两边的情况，有一个剪枝的动作,不加依然会超时，详见代码
         TLE: 重复调用函数导致超时，不是算法的问题，详见代码
    6768K 2922MS C++ 2725B 2013-07-19 11:46:29 
*/
#include<iostream>
#include<cstdio>
#include<cmath>
#include<vector>
#include <iomanip> 
#include<algorithm>
using namespace std;

const double eps = 1e-5;
const double MAXLEN = 1000000000.0;
struct posi{
    double x;
    double y;
    bool flag;   //0 is agent,1 is raid
};

vector <posi> p;
int num;
double min_length;

double length(posi p1, posi p2){
    if(p1.flag != p2.flag)
    return sqrt((p2.x - p1.x)*(p2.x - p1.x)+(p2.y - p1.y)*(p2.y - p1.y));
    else return MAXLEN;
}
bool cmp(posi p1, posi p2){
    if(fabs(p1.x - p2.x) < eps){
        return p1.y < p2.y;
    }else{
        return p1.x < p2.x;
    }
}
//法一/
/*double getMinLength(int i){
    double min = MAXLEN;
    for(int j = i+1; j < 2*num; j++){
        if(p[i].flag != p[j].flag){
             double temp = length(p[i],p[j]);
        if(temp - min < eps){
            min = temp;
        }
        else if(fabs(p[i].x - p[j].x) > min)//如果不加这句if()，有BUG，但POJ没有检查出来，具体测试数据见下面
                break;
        }
    }
    return min;
}*/
法一结束/

法二
double getMinLength(int x, int y){
    if(y - x <= 2){
        double len,minlen = MAXLEN;
        for(int i = x; i < y; i++)
            for(int j = x+1; j < y; j++){
                len = length(p[i],p[j]);
                //minlen <?= len;
                if(len < minlen) minlen = len;
            }
    return minlen;
    }else{
        double r,result = MAXLEN;
        int i,j;
        int m = (x + y) / 2;//第一步：划分
        //result = getMinLength(x,m) < getMinLength(m,y) ? getMinLength(x,m) : getMinLength(m,y);//第二步：递归解决子问题
        //TLE: 上式中调用getMinLength()四次，在递归次数庞大时就会导致超时了
        //解决办法，用两个变量Llen,Rlen 保存函数的调用值
        double Llen,Rlen;
        Llen = getMinLength(x,m);
        Rlen = getMinLength(m,y);
        result = Llen < Rlen ? Llen : Rlen;//第二步：递归解决子问题
        for(i = m-1; i >= x; i--){//第三步：合并
            if(fabs(p[m].x - p[i].x) > result) break;//剪枝
            for(j = m; j < y; j++){
                if(fabs(p[m].x - p[j].x) > result) break;//剪枝
                r = length(p[i],p[j]);
                //result <?= r;
                if(result > r) result = r;
            }
        } 
       return result;
    }
}
/法二结束///

int main(){
    int n,i,j;
    cin >> n;
    while(n--){
        posi t;
        cin >> num;
        p.clear();
        min_length = MAXLEN;
        for(i = 0; i < num; i++){
            cin >> t.x >> t.y;
            t.flag = 0;//agent
            p.push_back(t);
        }
        for(i = 0; i < num; i++){
            cin >> t.x >> t.y;
            t.flag = 1;//raid
            p.push_back(t);
        }
        sort(p.begin(),p.end(),cmp);
        
        //法一///
        /* for(int k = 0 ;k < p.size();k++){
        }
        for(j = 0; j < 2*num-1; j++){
            double mlen = getMinLength(j);
            if(mlen < min_length) min_length = mlen;
        }*/
        //法一结束/
        
        //法二//
        min_length = getMinLength(0,p.size());
        //法二结束//
        
        cout <<setiosflags(ios::fixed);  
        cout << setprecision(3);
        cout << min_length << endl;
    }
    return 0;
}

/*
测试BUG的数据
INPUT:
1
3
0 0
13 13
15 15
2 5
4 0
4 -6
OUTPUT:(right)
4.000
OUTPUT:(wrong)
5.385    
*/