codeforces C Balanced Removals

Easy

可以发现数据是支持$n^2$的做法。
我们可以发现，不合法的情况是两个点形成的正方体中有其他点，等价于我们需要去选取一个尽可能近的，因为不合法的时候其他点离这两个点一定更近。
所以暴力查找即可。

Hard

对于二维的时候：
如果我们仔细画一张图，可以发现，正常的排序过后选是可以解决大多数情况。
但是对于：

这种情况我们就会发生错误。
实际上，这种错误只会发生在存在$x$相同的情况。【按$x$为第一关键字排序的时候】

所以对于二维的情况，我们需要现对于各自相同$x$的情况先进行一遍一维的筛选，最后只会剩下0或者1个。
接下来剩下来的都是$x$不相同的，按照一维的继续即可。

三维的情况同理：
先处理相同$x$的，再筛选一遍二维的$(y,z)$。
剩下的都是不同$x$的，直接一维处理即可。

我用的是$map$处理，因为之后处理的时候都是相对关系，所以只用在一开始排序即可。

#include<bits/stdc++.h>
using namespace std;
vector<int> v;

typedef long long ll;

const int maxn = 1e5+500;

struct node{
    int x,y,z;
    int id;
    friend bool operator < (node a,node b){
        if(a.x==b.x&&a.y==b.y)return a.z<b.z;
        if(a.x==b.x)return a.y<b.y;
        return a.x<b.x;
    }
}A[maxn];

bool vis[maxn];

map<int,vector<node> >mp1;
map<int,vector<node> >mp2;
vector<node>ooxx;

int main(){
    int n;cin>>n;
    for(int i=1;i<=n;i++){
        scanf("%d%d%d",&A[i].x,&A[i].y,&A[i].z);
        A[i].id=i;
    }
    sort(A+1,A+1+n);
    for(int i=1;i<=n;i++){
        mp1[A[i].x].push_back(A[i]);
    }
    for(auto def:mp1){
        mp2.clear();
        auto it=def.second;
        for(int i=0;i<it.size();i++){
            mp2[it[i].y].push_back(it[i]);
        }
        for(auto df:mp2){
            auto iter=df.second;
            for(int i=0;i+1<iter.size();i+=2){
                printf("%d %d\n",iter[i].id,iter[i+1].id);
                vis[iter[i].id]=vis[iter[i+1].id]=1;
            }
        }
        ooxx.clear();
        for(auto df:mp2){
            auto iter=df.second;
            node tmp=iter.back();
            if(vis[tmp.id])continue;
            ooxx.push_back(tmp);
        }
        for(int i=0;i+1<ooxx.size();i+=2){
            printf("%d %d\n",ooxx[i].id,ooxx[i+1].id);
            vis[ooxx[i].id]=vis[ooxx[i+1].id]=1;
        }
    }
    ooxx.clear();
    for(int i=1;i<=n;i++){
        if(vis[A[i].id])continue;
        ooxx.push_back(A[i]);
    }
    for(int i=0;i<ooxx.size();i+=2){
        printf("%d %d\n",ooxx[i].id,ooxx[i+1].id);
    }
}