UVALive 3211 Now or later

Now or later

Time Limit: 9000ms

Memory Limit: 131072KB

This problem will be judged on UVALive. Original ID: 3211
64-bit integer IO format: %lld      Java class name: Main

 

As you must have experienced, instead of landing immediately, an aircraft sometimes waits in a holding loop close to the runway. This holding mechanism is required by air traffic controllers to space apart aircraft as much as possible on the runway (while keeping delays low). It is formally defined as a ``holding pattern'' and is a predetermined maneuver designed to keep an aircraft within a specified airspace (see Figure 1 for an example).

Figure 1: A simple Holding Pattern as described in a pilot text book.

 

Jim Tarjan, an air-traffic controller, has asked his brother Robert to help him to improve the behavior of the airport.

 

Input

The Terminal Radar Approach CONtrol (TRACON) controls aircraft approaching and departing when they are between 5 and 50 miles of the airport. In this final scheduling process, air traffic controllers make some aircraft wait before landing. Unfortunately this ``waiting'' process is complex as aircraft follow predetermined routes and their speed cannot be changed. To reach some degree of flexibility in the process, the basic delaying procedure is to make aircraft follow a holding pattern that has been designed for the TRACON area. Such patterns generate a constant prescribed delay for an aircraft (see Figure 1 for an example). Several holding patterns may exist in the same TRACON.

In the following, we assume that there is a single runway and that when an aircraft enters the TRACON area, it is assigned an early landing time, a late landing time and a possible holding pattern. The early landing time corresponds to the situation where the aircraft does not wait and lands as soon as possible. The late landing time corresponds to the situation where the aircraft waits in the prescribed holding pattern and then lands at that time. We assume that an aircraft enters at most one holding pattern. Hence, the early and late landing times are the only two possible times for the landing.

The security gap is the minimal elapsed time between consecutive landings. The objective is to maximize the security gap. Robert believes that you can help.

 

Output

Assume there are 10 aircraft in the TRACON area. Table 1 provides the corresponding early and late landing times (columns ``Early'' and ``Late'').

Table 1: A 10 aircraft instance of the problem.

 

Aircraft	Early	Late	Solution
A1	44	156	Early
A2	153	182	Early
A3	48	109	Late
A4	160	201	Late
A5	55	186	Late
A6	54	207	Early
A7	55	165	Late
A8	17	58	Early
A9	132	160	Early
A10	87	197	Early

The maximal security gap is 10 and the corresponding solution is reported in Table 1 (column ``Solution''). In this solution, the aircraft land in the following order: A8, A1, A6, A10, A3,A9, A2, A7, A5, A4. The security gap is realized by aircraft A1 and A6.

 

Sample Input

 
10
44 156
153 182
48 109
160 201
55 186
54 207
55 165
17 58
132 160
87 197

Sample Output

 
10

Source

Regionals 2004, Europe - Southwestern

 

解题i：二分+2sat

 

#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010;
struct arc {
    int to,next;
    arc(int x = 0,int y = -1) {
        to = x;
        next = y;
    }
};
arc e[maxn*maxn];
int head[maxn],dfn[maxn],low[maxn],belong[maxn];
int tot,cnt,scc,n,m;
bool instack[maxn];
stack<int>stk;
void add(int u,int v) {
    e[tot] = arc(v,head[u]);
    head[u] = tot++;
}
void init() {
    for(int i = 0; i < maxn; i++) {
        belong[i] = 0;
        low[i] = dfn[i] = 0;
        head[i] = -1;
        instack[i] = false;
    }
    while(!stk.empty()) stk.pop();
    tot = cnt = scc = 0;
}
void tarjan(int u) {
    dfn[u] = low[u] = ++cnt;
    instack[u] = true;
    stk.push(u);
    for(int i = head[u]; ~i; i = e[i].next) {
        if(!dfn[e[i].to]) {
            tarjan(e[i].to);
            if(low[e[i].to] < low[u]) low[u] = low[e[i].to];
        } else if(instack[e[i].to] && dfn[e[i].to] < low[u])
            low[u] = dfn[e[i].to];
    }
    if(dfn[u] == low[u]) {
        scc++;
        int v;
        do {
            v = stk.top();
            stk.pop();
            instack[v] = false;
            belong[v] = scc;
        } while(v != u);
    }
}
bool solve() {
    for(int i = 0; i < (n<<1); i++)
        if(!dfn[i]) tarjan(i);
    for(int i = 0; i < n; i++)
        if(belong[i] == belong[i+n]) return false;
    return true;
}
int tim[maxn][2];
bool check(int t) {
    init();
    for(int i = 0; i < n; ++i)
        for(int j = i+1; j < n; ++j) {
            if(abs(tim[i][0] - tim[j][0]) < t) {
                add(i,j+n);
                add(j,i+n);
            }
            if(abs(tim[i][0] - tim[j][1]) < t) {
                add(i,j);
                add(j+n,i+n);
            }
            if(abs(tim[i][1] - tim[j][0]) < t) {
                add(i+n,j+n);
                add(j,i);
            }
            if(abs(tim[i][1] - tim[j][1]) < t) {
                add(i+n,j);
                add(j+n,i);
            }
        }
    for(int i = 0; i < 2*n; ++i)
        if(!dfn[i]) tarjan(i);
    for(int i = 0; i < n; ++i)
        if(belong[i] == belong[i+n]) return false;
    return true;
}
int main() {
    while(~scanf("%d",&n)) {
        int low = 0,high = 0;
        for(int i = 0; i < n; ++i) {
            for(int j = 0; j < 2; ++j) {
                scanf("%d",tim[i]+j);
                high = max(high,tim[i][j]);
            }
        }
        int ret = -1;
        while(low <= high) {
            int mid = (low + high)>>1;
            if(check(mid)) {
                ret = mid;
                low = mid+1;
            } else high = mid-1;
        }
        printf("%d
",ret);
    }
    return 0;
}