飘扬的旗帜

我也不知道哪里蒯来的题。反正二分 + 2-sat + 线段树优化连边就完事了。

注意答案可能为0..

#include <bits/stdc++.h>

const int N = 100010;

struct Edge {
    int nex, v;
}edge[3000010]; int tp;

struct Node {
    int x, f;
    Node(int X = 0, int F = 0) {
        x = X;
        f = F;
    }
};

int e[N], num, dfn[N], low[N], X[N], xx, tot, n, fr[N], scc_cnt, ls[N], rs[N];
std::vector<Node> v[N];
int stk[N], top, rt, A[N],  B[N];

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

inline void clear() {
    memset(e + 1, 0, tot * sizeof(int));
    memset(dfn + 1, 0, tot * sizeof(int));
    memset(fr + 1, 0, tot * sizeof(int));
    tp = top = num = scc_cnt = 0;
    return;
}

void tarjan(int x) {
    low[x] = dfn[x] = ++num;
    stk[++top] = x;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(!dfn[y]) {
            tarjan(y);
            low[x] = std::min(low[x], low[y]);
        }
        else if(!fr[y]) {
            low[x] = std::min(low[x], dfn[y]);
        }
    }
    if(low[x] == dfn[x]) {
        ++scc_cnt;
        int y;
        do {
            y = stk[top];
            top--;
            fr[y] = scc_cnt;
        } while(y != x);
    }
    return;
}

void Add(int L, int R, int v, int l, int r, int &o) {
    if(!o) o = ++tot;
    if(L <= l && r <= R) {
        add(v, o);
        return;
    }
    int mid = (l + r) >> 1;
    if(L <= mid) Add(L, R, v, l, mid, ls[o]);
    if(mid < R) Add(L, R, v, mid + 1, r, rs[o]);
    return;
}

void build(int f, int l, int r, int &o) {
    if(!o) o = ++tot;
    if(f) add(f, o);
    if(l == r) {
        for(int i = 0; i < (int)v[r].size(); i++) {
            if(v[r][i].f) {
                add(o, v[r][i].x);
            }
            else {
                add(o, v[r][i].x + n);
            }
        }
        return;
    }
    int mid = (l + r) >> 1;
    build(o, l, mid, ls[o]);
    build(o, mid + 1, r, rs[o]);
    return;
}

inline bool check(int k) {

    clear();
    for(int i = 1; i <= n; i++) {
        int l = std::lower_bound(X + 1, X + xx + 1, X[A[i]] - k) - X;
        int r = std::upper_bound(X + 1, X + xx + 1, X[A[i]] + k) - X - 1;
        int mid = A[i];
        if(l < mid) {
            Add(l, mid - 1, i, 1, xx, rt);
        }
        if(mid < r) {
            Add(mid + 1, r, i, 1, xx, rt);
        }
        for(int j = 0; j < (int)v[mid].size(); j++) {
            if(v[mid][j].x == i) continue;
            if(v[mid][j].f) {
                add(i, v[mid][j].x);
            }
            else {
                add(i, v[mid][j].x + n);
            }
        }
        l = std::lower_bound(X + 1, X + xx + 1, X[B[i]] - k) - X;
        r = std::upper_bound(X + 1, X + xx + 1, X[B[i]] + k) - X - 1;
        mid = B[i];
        if(l < mid) {
            Add(l, mid - 1, i + n, 1, xx, rt);
        }
        if(mid < r) {
            Add(mid + 1, r, i + n, 1, xx, rt);
        }
        for(int j = 0; j < (int)v[mid].size(); j++) {
            if(v[mid][j].x == i) continue;
            if(v[mid][j].f) {
                add(i + n, v[mid][j].x);
            }
            else {
                add(i + n, v[mid][j].x + n);
            }
        }
    }
    build(0, 1, xx, rt);
    for(int i = 1; i <= tot; i++) {
        if(!dfn[i]) {
            tarjan(i);
        }
    }
    for(int i = 1; i <= n; i++) {
        if(fr[i] == fr[i + n]) return 0;
    }
    return 1;
}

int main() {

    scanf("%d", &n);
    tot = n << 1;
    for(int i = 1; i <= n; i++) {
        scanf("%d%d", &A[i], &B[i]);
        X[++xx] = A[i]; X[++xx] = B[i];
    }
    std::sort(X + 1, X + xx + 1);
    xx = std::unique(X + 1, X + xx + 1) - X - 1;
    for(int i = 1; i <= n; i++) {
        A[i] = std::lower_bound(X + 1, X + xx + 1, A[i]) - X;
        B[i] = std::lower_bound(X + 1, X + xx + 1, B[i]) - X;
        v[A[i]].push_back(Node(i, 0));
        v[B[i]].push_back(Node(i, 1));
    }

    int l = -1, r = X[xx] - X[1];
    while(l < r) {
        int mid = (l + r + 1) >> 1;
        if(check(mid)) {
             l = mid;
         }
         else {
             r = mid - 1;
         }
    }

    printf("%d
", r + 1);
    return 0;
}

我这个写法不对，如果离散化了就不能暴力处理单个位置的其他边，因为可能会被卡成n²。正确的方法是不离散化或者对每个位置再用一个前后缀优化连边。