(洛谷 P1429 平面最近点对（加强版） || 洛谷 P1257 || Quoit Design HDU - 1007 ) && Raid POJ - 3714

这个讲的好：

https://phoenixzhao.github.io/%E6%B1%82%E6%9C%80%E8%BF%91%E5%AF%B9%E7%9A%84%E4%B8%89%E7%A7%8D%E6%96%B9%E6%B3%95/

分治法

先空着

---

看一下这个第三个方法（随机增量哈希，O(n)）

1.千万不要用unordered_map/hash_map！T飞是肯定的；要手写哈希表，所以码量就很大；手写哈希表方法记一下

2.事实上以d为边长画格子，每次遍历相邻的9个格子，常数要比以d/2边长画格子，每次遍历相邻25个格子要好（当然此时每个格子里面不一定只有一个数了）；不知道为什么

3.注意，用此方法时，如果距离已经为0了，那么就马上跳出循环（不然可能由于除以0或很接近0的数产生非常大的格子编号，产生不好的事情）

4.常数似乎较大，比一些分治法要慢

别人的代码！跑的飞快（交洛谷）

 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include <string.h>
 #include <math.h>
 #define MAXN 201000
 #define DUBF 999999999.9
 #define INF 201007
 struct NODE
 {
     int to;
     int next;
 };
 struct NODE1
 {
     double x, y;
 };
 int direction[][] = {, , -, -, -, , -, , , , , , , , , -, , -};
 NODE1 point[MAXN];
 NODE edges[MAXN];
 int ad;
 int map[INF];
 int HASH(int x, int y)
 {
     return ((x * MAXN + y) % INF + INF) % INF;
 }
 double len(int i, int j)
 {
     return sqrt((point[i].x - point[j].x) * (point[i].x - point[j].x) + (point[i].y - point[j].y) * (point[i].y - point[j].y));
 }
 void Into_Hash(int i, double r)
 {
     edges[ad].to = i;
     edges[ad].next = map[HASH( (int)(point[i].x/r), (int)(point[i].y/r) )];
     map[HASH( (int)(point[i].x/r), (int)(point[i].y/r) )] = ad ++;
 }
 void Renew_Hash(int n, double r)
 {
     ad = ;
     memset(map, -, sizeof(map));
     for(int i = ; i <= n; i ++)
         Into_Hash(i, r);
 }
 double Get_len_around(int p, double r)
 {
     int x = (int) (point[p].x / r), y = (int) (point[p].y / r), i, j;
     double s = DUBF;
     for(int k = ; k < ; k ++)
     {
         i = x + direction[k][], j = y + direction[k][];
         for(int q = map[HASH(i, j)]; ~q; q = edges[q].next)
             s = s < len(edges[q].to, p) ? s : len(edges[q].to, p);
     }
     return s;
 }
 double Get_R(int n)
 {
     double r = len(, ), s;
     int i;
     if(r -  < 1e- || n < )
         return ;
     Renew_Hash(, r);
     for(i = ; i < n; i ++)
         if((s = Get_len_around(i, r)) < r)
         {
             r = s;
             if(r -  < 1e-)
                 return ;
             Renew_Hash(i, r);
         }
         else
             Into_Hash(i, r);
     return r;
 }
 void swap(int i, int j)
 {
     NODE1 t = point[i];
     point[i] = point[j];
     point[j] = t;
 }
 int main()
 {
     int n, i;
     while(scanf("%d", &n)==)
     {
         for(i = ; i < n; i ++)
             scanf("%lf %lf", &point[i].x, &point[i].y);
         srand((unsigned)time(NULL));
         for(i = ; i < n; i ++)
             swap(i, rand() % n);
         printf("%.4lf\n", Get_R(n));
     }
     return ;

 }

自己的代码（跑的慢不少，找不出来原因）（交洛谷）

 #pragma GCC optimize("Ofast")
 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 #include<ctime>
 using namespace std;
 #define fi first
 #define se second
 #define mp make_pair
 #define pb push_back
 typedef long long ll;
 typedef unsigned long long ull;
 typedef pair<int,int> pii;
 typedef unsigned ul;
 typedef pair<ul,ul> puu;
 struct P
 {
     double x,y;
     P():x(),y(){}
     P(double a,double b):x(a),y(b){}
 }p[];
 double sqr(double x){return x*x;}
 double dis(const P &a,const P &b)
 {
     return sqrt(sqr(a.x-b.x)+sqr(a.y-b.y));
 }
 //int dx[]={-2,-2,-2,-2,-2,-1,-1,-1,-1,-1,0,0,0,0,0,1,1,1,1,1,2,2,2,2,2,};
 //int dy[]={-2,-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2,};
 int dx[]={-,-,-,,,,,,};
 int dy[]={-,,,-,,,-,,};

 const ul N=;
 const ul md=;
 ul calc_hash(const puu &x)    {return (ull(x.fi)*N%md+x.se)%md;}
 template<typename T1,typename T2>
 struct hmap
 {
 struct Node{T1 k;T2 v;int nxt;}e[N+];
 int f1[md+],ne;
 void ins(const T1 &x,const T2 &y)
 {
     ul t=calc_hash(x);
     e[++ne].k=x;e[ne].v=y;e[ne].nxt=f1[t];f1[t]=ne;
 }
 };

 hmap<puu,P> ma;
 int n;
 double d;
 const double MINX=-1e10,MINY=-1e10;
 puu gblock(const P &x)
 {
     return puu((x.x-MINX)/d,(x.y-MINY)/d);
 }
 void clr(int n)
 {
     for(int i=;i<=n;i++)    ma.f1[calc_hash(gblock(p[i]))]=;
     ma.ne=;
 }
 void rebuild(int n)
 {
     for(int i=;i<=n;i++)    ma.ins(gblock(p[i]),p[i]);
 }
 int main()
 {
     int i,j,k;puu lst,now;double td;
     srand(time());
     scanf("%d",&n);
     for(i=;i<=n;i++)    scanf("%lf%lf",&p[i].x,&p[i].y);
     random_shuffle(p+,p+n+);
     d=dis(p[],p[]);rebuild();
     for(i=;i<=n;i++)
     {
         if(d<1e-)    {d=;break;}
         lst=gblock(p[i]);td=1e18;
         for(j=;j<;j++)
         {
             now=mp(lst.fi+dx[j],lst.se+dy[j]);
             for(k=ma.f1[calc_hash(now)];k;k=ma.e[k].nxt)
                 if(ma.e[k].k==now)
                     td=min(td,dis(ma.e[k].v,p[i]));
         }
         if(td<d)    {clr(i-);d=td;rebuild(i-);}
         ma.ins(gblock(p[i]),p[i]);
     }
     printf("%.4f",d);
     return ;
 }

（相关：

http://blog.sina.com.cn/s/blog_6fa65cf90100ol2p.html，

http://blog.sina.com.cn/s/blog_aa74c5380101gv0v.html，

https://rjlipton.wordpress.com/2009/03/01/rabin-flips-a-coin/）

---

Raid POJ - 3714

求两个点集间点距离最小值

开两个哈希表，每次在一个哈希表中查询，然后插入另一个哈希表即可

常数挺大，没有分治快

注意要用%f输出double

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 #include<ctime>
 #include<cmath>
 using namespace std;
 #define fi first
 #define se second
 #define mp make_pair
 #define pb push_back
 typedef long long ll;
 typedef unsigned long long ull;
 typedef pair<int,int> pii;
 typedef unsigned ul;
 typedef pair<ul,ul> puu;
 struct P
 {
     double x,y;bool type;
     P():x(),y(){}
     P(double a,double b):x(a),y(b){}
 }p[];
 double sqr(double x){return x*x;}
 double dis(const P &a,const P &b)
 {
     return sqrt(sqr(a.x-b.x)+sqr(a.y-b.y));
 }
 //int dx[]={-2,-2,-2,-2,-2,-1,-1,-1,-1,-1,0,0,0,0,0,1,1,1,1,1,2,2,2,2,2,};
 //int dy[]={-2,-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2,};
 int dx[]={-,-,-,,,,,,};
 int dy[]={-,,,-,,,-,,};

 const ul N=;
 const ul md=;
 ul calc_hash(const puu &x)    {return (ull(x.fi)*N%md+x.se)%md;}
 template<typename T1,typename T2>
 struct hmap
 {
 struct Node{T1 k;T2 v;int nxt;}e[N+];
 int f1[md+],ne;
 void ins(const T1 &x,const T2 &y)
 {
     ul t=calc_hash(x);
     e[++ne].k=x;e[ne].v=y;e[ne].nxt=f1[t];f1[t]=ne;
 }
 };

 hmap<puu,P> ma1,ma2;
 int n;
 double d;
 const double MINX=-1e10,MINY=-1e10;
 puu gblock(const P &x)
 {
     return puu((x.x-MINX)/d,(x.y-MINY)/d);
 }
 void clr(int n)
 {
     for(int i=;i<=n;i++)
         if(p[i].type)
             ma2.f1[calc_hash(gblock(p[i]))]=;
         else
             ma1.f1[calc_hash(gblock(p[i]))]=;
     ma1.ne=ma2.ne=;
 }
 void rebuild(int n)
 {
     for(int i=;i<=n;i++)
         if(p[i].type)
             ma2.ins(gblock(p[i]),p[i]);
         else
             ma1.ins(gblock(p[i]),p[i]);
 }
 int main()
 {
     int i,j,k,T;puu lst,now;double td;
     hmap<puu,P> *nm1,*nm2;
     srand();
     scanf("%d",&T);
     while(T--)
     {
     scanf("%d",&n);
     for(i=;i<=*n;i++)    scanf("%lf%lf",&p[i].x,&p[i].y),p[i].type=(i<=n);
     if(n==)
     {
         printf("%.3f\n",dis(p[],p[]));
         goto xxx;
     }
     swap(p[n+],p[]);
     random_shuffle(p+,p+*n+);
     d=dis(p[],p[]);rebuild();
     for(i=;i<=*n;i++)
     {
         if(d<1e-)    {d=;break;}
         nm1=p[i].type?&ma1:&ma2;nm2=p[i].type?&ma2:&ma1;
         lst=gblock(p[i]);td=1e18;
         for(j=;j<;j++)
         {
             now=mp(lst.fi+dx[j],lst.se+dy[j]);
             for(k=nm1->f1[calc_hash(now)];k;k=nm1->e[k].nxt)
                 if(nm1->e[k].k==now)
                     td=min(td,dis(nm1->e[k].v,p[i]));
         }
         if(td<d)    {clr(i-);d=td;rebuild(i-);}
         nm2->ins(gblock(p[i]),p[i]);
     }
     printf("%.3f\n",d);
     clr(*n);
     xxx:;
     }
     return ;
 }

---

upd：这个基于哈希表的随机增量好像不是很对？哈希表的空间开不到O(n^2)啊，冲突概率怕是会很高？（然而实测还行啊？）