UVa 1450 Airport

原创于 2025-12-16 16:14:01 发布 · 388 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #青少年编程

贪心算法同时被 2 个专栏收录

37 篇文章

订阅专栏

二分搜索

14 篇文章

订阅专栏

问题描述

一个大城市有一个年客流量 $4000$ 万的国际机场，但该机场以世界上最为拥堵的机场之一而臭名昭著。在这个机场，只有一条跑道。因此，跑道上总是挤满了等待起飞的飞机。有两条路可以接近跑道，分别称为西路 $W$ 和东路 $E$ 。飞机在这两条路上等待起飞。

在每个时刻 $t$ ，任意数量的飞机到达西路 $W$ 和东路 $E$ 。每个在时刻 $t$ 到达 $W$ 或 $E$ 的飞机会获得一个等级，该等级等于同一条路上排在它前面的等待飞机的数量。然后，控制塔会选择 $W$ 或 $E$ 之一，让该路上最前面的飞机起飞。给定飞机到达时刻的信息，我们关注控制塔的起飞调度方案，以使所有飞机的最大等级最小化。

输入格式

输入包含 $T$ 个测试用例。测试用例的数量 $T$ 在输入的第一行给出。每个测试用例的第一行包含一个整数 $n$ $\leq n \leq 5000)$ ，表示时刻的数量。在每个测试用例接下来的 $n$ 行中，第 $i$ 行包含两个整数 $a_i$ 和 $b_i$ ，分别表示时刻 $i$ 到达西路 $W$ 和东路 $E$ 的飞机数量，其中 $\leq a_i, b_i \leq 20$ 。

输出格式

为每个测试用例输出一行，包含所有可能起飞调度方案中最大等级的最小值。

题目分析

这是一个经典的调度优化问题，我们需要在满足每时刻只能起飞一架飞机的约束下，最小化所有飞机在所有时刻出现的最大等待等级。

问题转化

首先理解等级的计算方式：一架飞机在时刻 $t$ 到达时，它的等级等于同一条路上排在它前面的飞机数量。注意这个等级是在到达时刻计算的，之后如果前面的飞机起飞了，这架飞机的等级会减小，但我们关心的是 所有飞机在所有时刻曾经达到过的最大等级 。

设：

$t o t a l W [i]$ 表示到时刻 $i$ 为止，西路 $W$ 累计到达的飞机总数
$t o t a lE [i]$ 表示到时刻 $i$ 为止，东路 $E$ 累计到达的飞机总数
$t ak e W [i]$ 表示到时刻 $i$ 为止，从西路 $W$ 起飞的飞机总数
$t ak e E [i]$ 表示到时刻 $i$ 为止，从东路 $E$ 起飞的飞机总数

由于每时刻只能起飞一架飞机，我们有：
$t ak e W [i] + t ak e E [i] = i$

在时刻 $i$ ，西路 $W$ 上等待的飞机数为：
$w ai t W [i] = t o t a l W [i] - t ak e W [i]$

东路 $E$ 上等待的飞机数为：
$w ai tE [i] = t o t a lE [i] - t ak e E [i]$

在时刻 $i$ 新到达的飞机中，最后到达的那架飞机（即等级最高的）的等级为：

西路： $w ai t W [i - 1] + a [i] - 1$
东路： $w ai tE [i - 1] + b [i] - 1$

这里 $w ai t W [i - 1]$ 表示时刻 $i$ 之前已经在等待的飞机数， $a [i] - 1$ 表示在同一时刻到达但排在前面的飞机数。

我们的目标是找到一种调度方案，使得：
$\max_{i} \left( \max(waitW[i-1] + a[i] - 1, \ waitE[i-1] + b[i] - 1) \right)$

最小化。

关键观察

注意到 $w ai t W [i] = t o t a l W [i] - t ak e W [i]$ 且 $t ak e W [i] + t ak e E [i] = i$ ，所以 $w ai tE [i] = t o t a lE [i] - (i - t ak e W [i])$ 。

设最大等待飞机数的上限为 $mi d$ （注意：最大等级 = 最大等待数 - $1$ ），那么我们需要保证在任意时刻 $i$ ：

$\leq mid$
$\leq mid$

这两个不等式可以转化为对 $t ak e W [i]$ 的约束：

$\geq totalW[i] - mid$
$\leq totalE[i] - mid + i$

此外，还有基本约束：

$\geq 0$
$\leq totalW[i]$ （不能起飞超过已到达的飞机数）
$\leq i$ （起飞总数不能超过时刻数）
$\leq totalE[i]$ （东路起飞数不能超过东路到达数）

解题思路

二分答案

由于答案具有单调性（如果最大等级 $k$ 可行，那么 $k + 1$ 也一定可行），我们可以使用二分查找来寻找最小的可行最大等级。

对于给定的 $mi d$ ，我们需要判断是否存在一个调度方案，使得所有时刻的等待飞机数都不超过 $mi d$ 。

贪心验证

验证函数 check(mid) 的核心思想是维护 $t ak e W$ 的可能取值范围 $[L, R]$ ，然后逐时刻更新这个范围。

初始化： $\ R = 0$ （第 $0$ 时刻未起飞任何飞机）

对于每个时刻 $i$ ：

更新累计到达飞机数： $\ totalE += b[i]$
由于必须起飞一架飞机， $t ak e W$ 最多可以增加 $1$ ： $R = R + 1$
应用基本约束： $\min(R, \ totalW)$ （不能起飞超过已到达的飞机数）
应用等待数约束：
- 从不等式 $\geq totalW - mid$ 得： $\max(L, \ totalW - mid)$
- 从不等式 $\leq totalE - mid + i$ 得： $\min(R, \ totalE - mid + i)$
应用其他边界约束：
- $\max(L, \ 0)$
- $\max(L, \ i - totalE)$ （确保 $\leq totalE$ ）
- $\min(R, \ i)$
- $\min(R, \ totalW)$
如果 $L > R$ ，则当前 $mi d$ 不可行

如果处理完所有时刻后 $\leq R$ ，则 $mi d$ 可行。

算法复杂度

二分查找： $O(log⁡M)O(\log M)$ ，其中 $M$ 是飞机总数的上界，最大为 $5000 \times 20 \times 2 = 200000$
每次验证： $O (n)$ ， $\leq 5000$
总复杂度： $\times n \times \log M)$ ，在题目限制下完全可行

代码实现

// Airport
// UVa ID: 1450
// Verdict: Accepted
// Submission Date: 2025-12-16
// UVa Run Time: 0.010s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

#include <bits/stdc++.h>
using namespace std;

const int N = 5005;

int t, n, a[N], b[N];

// 检查最大等待数不超过 mid 是否可行
bool check(int mid) {
    int an = 0, bn = 0, have = 0;  // an: W路累计等待数, bn: E路累计等待数, have: 可用起飞时隙
    for (int i = 0; i < n; i++) {
        an += a[i];  // 更新W路累计等待数
        bn += b[i];  // 更新E路累计等待数
        
        // 计算至少需要从各条路起飞的飞机数
        int needa = max(an - mid, 0);
        int needb = max(bn - mid, 0);
        
        // 如果需要的起飞数超过可用时隙，则不可行
        if (needa + needb > have) return false;
        
        // 更新可用起飞时隙和等待数
        if (an == 0 && bn > 0) bn--;           // 只能从E路起飞
        else if (bn == 0 && an > 0) an--;      // 只能从W路起飞
        else if (an > 0 && bn > 0 && an + bn > have) have++;  // 两条路都有飞机，增加起飞机会
    }
    return true;
}

// 二分查找最小可行最大等待数
int solve() {
    int left = 0, right = 100000;  // 等待数上界
    while (left < right) {
        int mid = (left + right) / 2;
        if (check(mid)) right = mid;
        else left = mid + 1;
    }
    // 最大等级 = 最大等待数 - 1
    return left == 0 ? 0 : left - 1;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    cin >> t;
    while (t--) {
        cin >> n;
        for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
        cout << solve() << "\n";
    }
    
    return 0;
}

代码解析

输入处理 ：使用 cin 读取输入，关闭同步以提高效率。
验证函数 check(mid) ：实现上述贪心验证逻辑。
- an 和 bn 分别记录两条路的累计等待飞机数
- have 记录可用的起飞时隙数（即已过去的时间）
- needa 和 needb 分别表示为了保持等待数不超过 $mi d$ ，至少需要从各条路起飞的飞机数
二分查找 ：在范围 $[0, 100000]$ 内查找最小可行最大等待数。
输出处理 ：注意最大等级 = 最大等待数 - 1 ，所以最终答案为 left - 1 。

样例分析

样例输入

样例输出

0
3
5

解释

第一个测试用例：只有 $1$ 个时刻，两条路各到达 $1$ 架飞机。最优调度是立即从任意一条路起飞一架飞机，最大等级为 $0$ 。
第二个测试用例：需要仔细调度才能得到最大等级 $3$ ，如题目中的示例所示。
第三个测试用例：通过合理调度，可以使得最大等级为 $5$ 。

总结

本题的关键在于将问题转化为对最大等待飞机数的约束，然后使用二分答案和贪心验证的方法求解。贪心验证的核心是维护 $t ak e W$ 的可能取值范围，通过逐时刻更新约束条件来判断可行性。这种解法既高效又易于实现，能够处理题目中的最大数据规模。

算法的时间复杂度为 $\times n \times \log M)$ ，空间复杂度为 $O (n)$ ，完全满足题目要求。