第三周练习3

直线

问题

给定平面上n个点。

求两条直线，这两条直线互相垂直，而且它们与x轴的夹角为45度，并且n个点中离这两条直线的曼哈顿距离的最大值最小。

两点之间的曼哈顿距离定义为横坐标的差的绝对值与纵坐标的差的绝对值之和，一个点到两条直线的曼哈顿距离是指该点到两条直线上的所有点的曼哈顿距离中的最小值。

Input

第一行包含一个数n。

接下来n行，每行包含两个整数，表示n个点的坐标（横纵坐标的绝对值小于109）。

Output

输出一个值，表示最小的最大曼哈顿距离的值，保留一位小数。

示例

输入

4
1 0
0 1
2 1
1 2

输出

1.0

思路：由于两条直线和坐标轴夹角为45度，且相互垂直，不妨把坐标系旋转45度，使得直线和坐标轴平行。解决最大值最小这类问题一般用二分来做，二分答案，看能否构造出答案出来。问题转化为能否将所有点分成两个部分，使得其中一部分的x值之差恒小于等于d，另一部分y值之差恒小于等于d，如果能那么答案d/2就存在，否则答案不存在，据此缩小答案范围。在判断答案是否存在的时候，将点按x坐标排序，从小到大枚举x的最小值，那么x的最大值是单调递增的，那么剩下的点由前p和和后q个构成，它们的纵坐标的最大差可以一次性预处理，然后O(1)得到。

代码

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <map>
#include <queue>
#include <cmath>
#include <vector>
#include <ctime>
#define mem0(a) memset(a, 0, sizeof(a))
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define define_m int m = (l + r) >> 1
#define LL long long
#define Rep(a, b) for(int a = 0; a < b; a++)
#define lowbit(x) ((x) & (-(x)))
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, -1, 0, 1};
const int INF = 1e9 + 7;
const double eps = 1e-3;
const double con = sqrt(2.0) / 2;
const double maxd = 1e20;
typedef double db;
using namespace std;
struct Node {
     double x, y;
     void inp() {
         int tx, ty;
         scanf("%d %d", &tx, &ty);
         x = (tx + ty) * con;
         y = (ty - tx) * con;
     }
     bool operator < (const Node &opt) const {
         return x < opt.x || x == opt.x && y < opt.y;
     }
 }
node[100010];
typedef double arr[100010];
arr pre_min, pre_max, suf_min, suf_max;
int n;
void Init() {
     pre_min[0] = pre_max[0] = node[0].y;
     suf_min[n - 1] = suf_max[n - 1] = node[n - 1].y;
     for (int i = 1; i < n; i++) {
         pre_max[i] = max(pre_max[i - 1], node[i].y);
         pre_min[i] = min(pre_min[i - 1], node[i].y);
     }
     for(int i = n - 2; i >= 0; i--) {
         suf_max[i] = max(suf_max[i + 1], node[i].y);
         suf_min[i] = min(suf_min[i + 1], node[i].y);
     }
 }
 bool Check(double d) {
     int pos = 0;
     for (int i = 0; i < n; i++) {
         while (pos < n - 1 && node[pos + 1].x - node[i].x <= d) pos++;
         double tmp1 = 0, tmp2 = maxd;
        if (i) {
             tmp1 = pre_max[i - 1];
             tmp2 = pre_min[i - 1];
        }
         if (pos < n - 1) {
            tmp1 = max(tmp1, suf_max[pos + 1]);
             tmp2 = min(tmp2, suf_min[pos + 1]);
         }
         if (tmp1 - tmp2 <= d) return 1;
     }
     return 0;
}
int main() {
     cin >> n;
     for (int i = 0; i < n; i++) {
         node[i].inp();
     }
     sort(node, node + n);
     Init();
     double l = 0, r = maxd;
     while (fabs(r - l) > eps) {
        double m = (l + r) / 2;
        if (Check(m)) r = m;
        else l = m;
    }
     printf("%.1f\n", l * con);
     return 0;
 }