uvalive 3211 Now Or Later

题意：

一座飞机场要降落飞机，每架飞机有两种降落方式：早降落和晚降落。

现在要安排飞机的降落使得两个飞机降落时间的最小值最大。

输出这个最小值。

思路：

最小值最大化，可以想到答案需要二分。

然后就是如何判断一个时间是否满足条件。一个飞机要么早降落，要么晚降落，所以就是一个为真，另一个一定为假，这就是著名的2-SAT问题（lrj的dfs模板）。

枚举两架飞机，假设有|Li – Ej|小于当前枚举的时间，那么两个不能同时满足，即进行加边。

每两架飞机要枚举四次，早早，早晚，晚早，晚晚。

代码：

#include <stdio.h>
#include <string.h>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;

const int maxn = 2005;

struct twosat
{
    int n;
    vector<int> g[maxn*2];
    bool mark[maxn*2];
    int s[maxn*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));
    }
    
    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;
    }
} twosat;

struct node
{
    int x,y;
    
    node(int x,int y)
    {
        this -> x = x;
        this -> y = y;
    }
};

vector<node> v;

int mabs(int x)
{
    return x >= 0 ? x : -x;
}

bool meet(int k,int n)
{
    twosat.init(n);
    
    for (int i = 0;i < n;i++)
    {
        for (int j = i + 1;j < n;j++)
        {
            //if (i == j) continue;
            if (mabs(v[i].x - v[j].x) < k)
            {
                twosat.add_clause(i,0,j,0);
            }
            if (mabs(v[i].x - v[j].y) < k)
            {
                twosat.add_clause(i,0,j,1);
            }
            if (mabs(v[i].y - v[j].y) < k)
            {
                twosat.add_clause(i,1,j,1);
            }
            if (mabs(v[i].y - v[j].x) < k)
            {
                twosat.add_clause(i,1,j,0);
            }
        }
    }
    
    return twosat.solve();
}


int main()
{
    int n;
    
    while (scanf("%d",&n) != EOF)
    {
        v.clear();
        
        for (int i = 0;i < n;i++)
        {
            int x,y;
            
            scanf("%d%d",&x,&y);
            
            v.push_back(node(x,y));
        }
        
        int l = 0,r = 1e7;
        
        while (r - l > 1)
        {
            int mid = (l + r) >> 1;
            
            if (meet(mid,n)) l = mid;
            else r = mid;
        }
        
        while (meet(l+1,n)) l++;
        
        printf("%d
",l);
    }
    
    return 0;
}