題目大意：某人在山上種了 N 棵小樹苗。冬天來了，溫度急速下降，小樹苗脆弱得不堪一擊，他決定用 3 個 L * L 的正方形塑料薄膜將小樹遮起來。
我們將山建立一個平面直角座標系，設第 i 棵小樹的座標為（Xi , Yi），3 個 L * L 的正方形的邊要求平行與座標軸，一個點如果在正方形的邊界上，也算作被覆蓋。當然，我們希望塑料薄膜面積越小越好，即求 L 最小值。

題目分析：

這道題的解題思路比較容易想到。不過我用的搜尋，對於這種型別嘛……我一向做搜尋題都做得——超超超超超級複雜，在此表示如果有神犇或 dalao 覺得我程式碼醜的請輕噴╮(╯▽╰)╭

首先，看到“求薄膜能夠覆蓋完所有樹苗的面積的最小值”時，直接想到二分膜的面積。我們把每棵樹看成一個點，先用一個矩形將所有的點包圍起來，這樣便確定了二分上界。

判斷時，首先我們將第一個薄膜放在四個角中的一個角上（這樣可以保證放的是最優的，因為這樣能儘量多地覆蓋位於矩形邊上的點）。在放第二塊薄膜時，我們以同樣的操作，先用一個矩形將剩下未被覆蓋的點包圍起來，然後像之前那樣，將第二塊薄膜放在新矩形四個角中的一個角上。對於第三塊膜，我們直接判斷最後所有剩下的點的橫縱座標能否被第三塊膜覆蓋完，如果能，則將面積縮小並繼續查詢；否則增大膜的面積。

.

Orz…

這道題我寫了 240 行，5000 多位元組的程式碼……
看到其他好多人 80 行解決問題……
果然我搜索還是寫的不好……不過還是跑得比較快……

下面附上程式碼：

#include<cstdio>
 

#include<iostream>
#include<algorithm>
using namespace std;
const int MX=20005;
const int INF=0x3f3f3f3f;

struct Point{
    int x,y;
    int vis;
    Point(){x=y=0,vis=0;}
};
Point map[MX];                              //儲存每個點的座標以及是否被覆蓋 
int n;

bool check(int s){
    for (int i=1;i<=n;i++){                 //初始化 
 

        map[i].vis=0;
    }
/***************************第一層開始***************************************/
    int mr=-INF,ml=INF,mu=-INF,md=INF;
    //mr:右邊的界限 right        ml:左邊的界限 left 
    //mu:上邊的界限 up            md:下邊的界限 down 

    for (int i=1;i<=n;i++){
        if (map[i].x > mr) mr=map[i].x;
        if (map[i].x < ml) ml=map[i].x;
        if (map[i].y > mu) mu=map[i].y;
        if (map[i].y < md) md=map[i].y;
    }
    for (int i=1;i<=4;i++){                         //放置第一塊，列舉四個角 
        switch (i){
            case 1:{
                for (int j=1;j<=n;j++){
                    if (map[j].x >= ml && map[j].x <= ml+s
                     && map[j].y <= mu && map[j].y >= mu-s){
                        map[j].vis++;
                    }
                }
                break;
            }
            case 2:{
                for (int j=1;j<=n;j++){
                    if (map[j].x <= mr && map[j].x >= mr-s
                     && map[j].y <= mu && map[j].y >= mu-s){
                        map[j].vis++;
                    }
                }
                break;
            }
            case 3:{
                for (int j=1;j<=n;j++){
                    if (map[j].x >= ml && map[j].x <= ml+s
                     && map[j].y >= md && map[j].y <= md+s){
                        map[j].vis++;
                    }
                }
                break;
            }
            case 4:{
                for (int j=1;j<=n;j++){
                    if (map[j].x <= mr && map[j].x >= mr-s
                     && map[j].y >= md && map[j].y <= md+s){
                        map[j].vis++;
                    }
                }
                break;
            }
        }
/*--------------------------第二層開始--------------------------------------*/
        int mmr=-INF,mml=INF,mmu=-INF,mmd=INF;
        for (int k=1;k<=n;k++){
            if (!map[k].vis){
                if (map[k].x > mmr) mmr=map[k].x;
                if (map[k].x < mml) mml=map[k].x;
                if (map[k].y > mmu) mmu=map[k].y;
                if (map[k].y < mmd) mmd=map[k].y;
            }
        }
        for (int j=1;j<=4;j++){                     //放置第二塊
            switch (j){
                case 1:{
                    for (int p=1;p<=n;p++){
                        if (map[p].x >= mml && map[p].x <= mml+s
                         && map[p].y <= mmu && map[p].y >= mmu-s){
                            map[p].vis++;
                        }
                    }
                    break;
                }
                case 2:{
                    for (int p=1;p<=n;p++){
                        if (map[p].x <= mmr && map[p].x >= mmr-s
                         && map[p].y <= mmu && map[p].y >= mmu-s){
                            map[p].vis++;
                        }
                    }
                    break;
                }
                case 3:{
                    for (int p=1;p<=n;p++){
                        if (map[p].x >= mml && map[p].x <= mml+s
                         && map[p].y >= mmd && map[p].y <= mmd+s){
                            map[p].vis++;
                        }
                    }
                    break;
                }
                case 4:{
                    for (int p=1;p<=n;p++){
                        if (map[p].x <= mmr && map[p].x >= mmr-s
                         && map[p].y >= mmd && map[p].y <= mmd+s){
                            map[p].vis++;
                        }
                    }
                    break;
                }
            }
/*==========================第三層開始======================================*/
            int mmmr=-INF,mmml=INF,mmmu=-INF,mmmd=INF;
            bool no_others=true;
            for (int q=1;q<=n;q++){                 //放置第三塊
                if (!map[q].vis){
                    no_others=false;
                    if (map[q].x > mmmr) mmmr=map[q].x;
                    if (map[q].x < mmml) mmml=map[q].x;
                    if (map[q].y > mmmu) mmmu=map[q].y;
                    if (map[q].y < mmmd) mmmd=map[q].y;
                }
            }
            if ((abs(mmmr-mmml) <= s && abs(mmmu-mmmd) <= s) || no_others)
                return true;
/*==========================第三層結束======================================*/
            switch (j){
                case 1:{
                    for (int p=1;p<=n;p++){
                        if (map[p].x >= mml && map[p].x <= mml+s
                         && map[p].y <= mmu && map[p].y >= mmu-s){
                            map[p].vis--;
                        }
                    }
                    break;
                }
                case 2:{
                    for (int p=1;p<=n;p++){
                        if (map[p].x <= mmr && map[p].x >= mmr-s
                         && map[p].y <= mmu && map[p].y >= mmu-s){
                            map[p].vis--;
                        }
                    }
                    break;
                }
                case 3:{
                    for (int p=1;p<=n;p++){
                        if (map[p].x >= mml && map[p].x <= mml+s
                         && map[p].y >= mmd && map[p].y <= mmd+s){
                            map[p].vis--;
                        }
                    }
                    break;
                }
                case 4:{
                    for (int p=1;p<=n;p++){
                        if (map[p].x <= mmr && map[p].x >= mmr-s
                         && map[p].y >= mmd && map[p].y <= mmd+s){
                            map[p].vis--;
                        }
                    }
                    break;
                }
            }
/*--------------------------第二層結束--------------------------------------*/
        }
        switch (i){
            case 1:{
                for (int j=1;j<=n;j++){
                    if (map[j].x >= ml && map[j].x <= ml+s
                     && map[j].y <= mu && map[j].y >= mu-s){
                        map[j].vis--;
                    }
                }
                break;
            }
            case 2:{
                for (int j=1;j<=n;j++){
                    if (map[j].x <= mr && map[j].x >= mr-s
                     && map[j].y <= mu && map[j].y >= mu-s){
                        map[j].vis--;
                    }
                }
                break;
            }
            case 3:{
                for (int j=1;j<=n;j++){
                    if (map[j].x >= ml && map[j].x <= ml+s
                     && map[j].y >= md && map[j].y <= md+s){
                        map[j].vis--;
                    }
                }
                break;
            }
            case 4:{
                for (int j=1;j<=n;j++){
                    if (map[j].x <= mr && map[j].x >= mr-s
                     && map[j].y >= md && map[j].y <= md+s){
                        map[j].vis--;
                    }
                }
                break;
            }
        }
    }
/***************************第一層結束***************************************/
    return false;
}

int main(){
    int pa,pb,mr=0,mu=0,ml=0,md=0,lf=0,rt=0,mid=0;  //rt:上界    lf:下界 
    cin>>n;
    for (int i=1;i<=n;i++){
        cin>>pa>>pb;
        map[i].x=pa,map[i].y=pb;
        if (i>=2){
            if (pa>mr) mr=pa;
            if (pa<ml) ml=pa;
            if (pb>mu) mu=pb;
            if (pb<md) md=pb;
        } else {
            ml=mr=pa,mu=md=pb;
        }
    }
    rt=max(abs(mr-ml),abs(mu-md));
    while (rt-lf>=1){
        mid=(lf+rt)/2;
        if (check(mid)){
            rt=mid;
        } else {
            lf=mid+1;
        }
    }
    printf("%d",lf);
    return 0;
}