LA 3211

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.

The
TRACON area

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.

Example

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.

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: A₈, A₁, A₆, A₁₀, A₃, A₉, A₂, A₇, A₅, A₄. The security gap is realized by
aircraft A₁ and A₆.

Input

The input file, that contains all the relevant data, contains several test
cases

Each test case is described in the following way. The first line contains the
number n of aircraft ( 2n2000). This line is followed by n lines. Each of these lines contains two
integers, which represent the early landing time and the late landing time of an
aircraft. Note that all times t are
such that 0t10⁷.

Output

For each input case, your program has to write a line that conttains the
maximal security gap between consecutive landings.

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

Note: The input file corresponds to Table 1.

Robert‘s Hints

Optimization vs. Decision

Robert advises you to work on the decision variant of the problem. It can
then be stated as follows: Given an integer p, and an instance of the optimization problem,
the question is to decide if there is a solution with security gap p or not. Note that, if you know how to
solve the decision variant of an optimization problem, you can build a binary
search algorithm to find the optimal solution.

On decision

Robert believes that the decision variant of the problem can
be modeled as a very particular boolean satisfaction problem.
Robert suggests to associate a boolean variable per aircraft stating whether
the aircraft is early (variable takes value ``true‘‘) or late (value
``false‘‘). It should then be easy to see that for some aircraft to land at
some time has consequences for the landing times of other aircraft. For
instance in Table 1 and with a delay of 10, if aircraft A₁ lands
early, then aircraft A₃has
to land late. And of course, if aircraft A₃ lands early, then
aircraft A₁ has to
land late. That is, aircraft A₁ and A₃ cannot both land early and
formula (A₁  ?A₃)  (A₃  ?A₁) must
hold.

And now comes Robert‘s big insight: our problem has a solution, if and
only if we have no contradiction. A contradiction being something
like A_i  ?A_i.

二分答案走2 - sat

  1 #include <iostream>

  2 #include <cstdio>

  3 #include <cstring>

  4 #include <algorithm>

  5 #include <stack>

  6 #include <vector>

  7 #include <cmath>

  8

  9 using namespace std;

 10

 11 const int MAX_N = 4005;

 12 int N,dfs_clock,scc_cnt;

 13 int low[MAX_N],pre[MAX_N],cmp[MAX_N];

 14 int E[MAX_N],L[MAX_N];

 15 stack<int> S;

 16 vector<int> G[MAX_N];

 17

 18 void dfs(int u) {

 19         low[u] = pre[u] = ++dfs_clock;

 20         S.push(u);

 21         for(int i = 0; i < G[u].size(); ++i) {

 22                 int v = G[u][i];

 23                 if(!pre[v]) {

 24                         dfs(v);

 25                         low[u] = min(low[u],low[v]);

 26                 } else if(!cmp[v]) {

 27                         low[u] = min(low[u],pre[v]);

 28                 }

 29         }

 30

 31         if(pre[u] == low[u]) {

 32                 ++scc_cnt;

 33                 for(;;) {

 34                         int x = S.top(); S.pop();

 35                         cmp[x] = scc_cnt;

 36                         if(x == u) break;

 37                 }

 38         }

 39 }

 40

 41 void scc() {

 42         dfs_clock = scc_cnt = 0;

 43         memset(cmp,0,sizeof(cmp));

 44         memset(pre,0,sizeof(pre));

 45

 46         for(int i = 1; i <= 2 * N; ++i){

 47                 if(!pre[i]) dfs(i);

 48         }

 49 }

 50

 51 bool check(int x) {

 52        for(int i = 1; i <= 2 * N; ++i) G[i].clear();

 53

 54        for(int i = 1; i <= N; ++i) {

 55             for(int j = 1; j <= N; ++j) {

 56                     if(i == j) continue;

 57                     if(abs(E[i] - E[j]) < x) {

 58                             G[i].push_back(j + N);

 59                             G[j].push_back(i + N);

 60                     }

 61                     if(abs(E[i] - L[j]) < x) {

 62                             G[i].push_back(j);

 63                             G[j + N].push_back(i + N);

 64                     }

 65                     if(abs(L[i] - E[j]) < x) {

 66                             G[i + N].push_back(j + N);

 67                             G[j].push_back(i);

 68                     }

 69                     if(abs(L[i] - L[j]) < x) {

 70                             G[i + N].push_back(j);

 71                             G[j + N].push_back(i);

 72                     }

 73

 74             }

 75        }

 76

 77        scc();

 78        for(int i = 1; i <= N; ++i) if(cmp[i] == cmp[i + N]) return false;

 79        return true;

 80 }

 81

 82 void solve() {

 83         int l = 0,r = 0;

 84         for(int i = 1; i <= N; ++i) {

 85                 r = max(r,E[i]);

 86                 r = max(r,L[i]);

 87         }

 88

 89         while(l < r) {

 90                 int mid = (l + r + 1) / 2;

 91                 if(check(mid)) l = mid;

 92                 else r = mid - 1;

 93         }

 94

 95         printf("%d\n",l);

 96

 97 }

 98

 99 int main()

100 {

101     //freopen("sw.in","r",stdin);

102     while(~scanf("%d",&N)) {

103             for(int i = 1; i <= N; ++i) {

104                     scanf("%d%d",&E[i],&L[i]);

105             }

106

107             solve();

108     }

109     //cout << "Hello world!" << endl;

110     return 0;

111 }

LA 3211,码迷,mamicode.com