now or later

题目链接

• 题意：
  有n架飞机要着陆，每个飞机有两个着陆时间，必须选一个时间。现在要安排各个飞机着陆的时间，使得相邻两个着陆时间间隔的最小值尽量大
  输入：第一行是飞机的数目n；之后n行每行两个整数表示两个着陆时间（早晚时间）；输出：安全间隔的最大值
• 分析：
  根据每个飞机只有两个着陆时间的特点可以想到TwoSAT。但是，对于这个问题，直接使用显然是不行的，TwoSAT只能对于给定的关系来判断解是否存在和输出解。题目中要求的是不定的关系（对于不同的安全间隔，TwoSAT构图结果是不一样的）。对于给定的一个时间间隔，可以判断是否存在这样的一个计划，那么就可以二分时间间隔来解
• 重点：
  用二分处理解集
  采用TwoSAT构图
• 总结：
  这里要用到一个典型的处理方式：二分查找最终答案。分析一下这种问题的特点：满足题意的答案有很多，但是，题目要的是最优的。这就有两种情况：
  1.整个解集都是有解的，不过要求的是最优点（根据特点可以采用三分或者二分来解）
  2.部分解集有解，题目一般要求的都是恰好有解的地方。那么可以采用二分来解决

//2-sat dfs版本
//如果标记了2i表示假,标记了2i+1表示真
//调用solve函数获得整个图的值

//n是点的数量
//vector G存储下一个点的序号
//mark[2 * i] = true表示i点为假,mark[2 * i + 1] = true表示i点为真
//S[]是算法使用的逻辑栈,c是栈计数值
const int MAXV = 2100;
struct TwoSAT
{
    int n;
    vector G[MAXV*2];
    bool mark[MAXV*2];
    int S[MAXV*2], c;

    bool dfs(int x)
    {
        if (mark[x^1]) return false;
        if (mark[x]) return true;
        mark[x] = true;
        S[c++] = x;
        for (int i = 0; i < G[x].size(); i++)
            if (!dfs(G[x][i])) return false;
        return true;
    }

    void init(int n)
    {
        this->n = n;
        for (int i = 0; i < n*2; i++) G[i].clear();
        memset(mark, 0, sizeof(mark));
    }

    // x = xval or y = yval
    void add_clause(int x, int xval, int y, int yval)
    {
        x = x * 2 + xval;
        y = y * 2 + yval;
        G[x^1].push_back(y);
        G[y^1].push_back(x);
    }

    bool solve()
    {
        for(int i = 0; i < n*2; i += 2)
            if(!mark[i] && !mark[i+1])
            {
                c = 0;
                if(!dfs(i))
                {
                    while(c > 0) mark[S[--c]] = false;
                    if(!dfs(i+1)) return false;
                }
            }
        return true;
    }
} tst;

int ipt[MAXV][2];

int main()
{
//    freopen("in.txt", "r", stdin);
    int n;
    while (~RI(n))
    {
        int L = 0, R = 0;
        REP(i, n)
        {
            RII(ipt[i][0], ipt[i][1]);
            R = max(R, ipt[i][1]);
        }
        while (L <= R)
        {
            tst.init(n);
            int M = (L + R) >> 1;
            REP(i, n) FF(j, i + 1, n)
            {
                REP(a, 2) REP(b, 2)
                {
                    if (abs(ipt[i][a] - ipt[j][b]) < M)
                        tst.add_clause(i, a, j, b);
                }
            }
            if (tst.solve())
                L = M + 1;
            else
                R = M - 1;
        }
        WI(R);
    }
    return 0;
}