第十四届蓝桥杯省赛C++B组D题【飞机降落】题解（AC）

news2024/10/5 21:16:44

在这里插入图片描述

解题思路

这道题目要求我们判断给定的飞机是否都能在它们的油料耗尽之前降落。为了寻找是否存在合法的降落序列，我们可以使用深度优先搜索（DFS）的方法，尝试所有可能的降落顺序。

首先，我们需要理解题目中的条件。每架飞机在 $T_i$ 时刻到达机场上空，剩余油料可以维持 $D_i$ 个单位时间，降落需要 $L_i$ 个单位时间。这意味着每架飞机可以在 $T_i$ 到 $T_i+D_i$ 的时间段内开始降落。

然后，我们可以按照以下步骤来实现 DFS：

首先，我们初始化一个布尔数组 st[] 来记录每架飞机是否已经降落。
然后，我们对每架飞机尝试进行降落。这里的 “尝试” 意味着我们需要检查该飞机是否可以在当前的时间内开始降落，即它的开始降落时间是否在 $T_i$ 到 $T_i+D_i$ 的时间段内。如果可以，我们就让它降落，并把 st[i] 设置为 true。
在一架飞机降落之后，我们递归地对剩下的飞机进行尝试。这一步就是 DFS 的主要部分，我们需要在所有的可能的降落序列中进行搜索。
如果在某一步我们发现当前的飞机无法在当前的时间内开始降落，我们就返回 false，并在上一层中尝试下一架飞机。
如果所有的飞机都已经降落，我们就返回 true。
最后，我们对所有飞机进行尝试。如果存在至少一个可以让所有飞机都降落的序列，我们就输出 YES，否则输出 NO。

通过以上步骤，我们可以找出是否存在一个合法的降落序列，使得所有的飞机都能在它们的油料耗尽之前降落。

AC_Code

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 15;

int n;
int a[N], b[N], c[N];
bool st[N];

bool dfs(int u, int last, int cnt)
{
    if (b[u] < last)
        return false;
    if (cnt == n)
        return true;
    
    for (int i = 0; i < n; ++ i )
        if (!st[i])
        {
            st[i] = true;
            if (dfs(i, max(a[u], last) + c[u], cnt + 1))
                return true;
            st[i] = false;
        }
    
    return false;
}

int main()
{
    int T;
    cin >> T;
    
    while (T -- )
    {
        memset(st, 0, sizeof st);
        
        cin >> n;
        for (int i = 0; i < n; ++ i )
            cin >> a[i] >> b[i] >> c[i], b[i] += a[i];
        
        bool flag = false;
        for (int i = 0; i < n; ++ i )
        {
            st[i] = true;
            if (dfs(i, 0, 1))
            {
                flag = true;
                break;
            }
            st[i] = false;
        }
        
        cout << (flag? "YES": "NO") << endl;
    }
    
    return 0;
}

Java

import java.util.*;

public class Main {
    static final int N = 15;
    static int n;
    static int[] a = new int[N], b = new int[N], c = new int[N];
    static boolean[] st = new boolean[N];

    static boolean dfs(int u, int last, int cnt) {
        if (b[u] < last) {
            return false;
        }
        if (cnt == n) {
            return true;
        }
        for (int i = 0; i < n; ++i) {
            if (!st[i]) {
                st[i] = true;
                if (dfs(i, Math.max(a[u], last) + c[u], cnt + 1)) {
                    return true;
                }
                st[i] = false;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int T = scanner.nextInt();
        while (T-- > 0) {
            Arrays.fill(st, false);
            n = scanner.nextInt();
            for (int i = 0; i < n; ++i) {
                a[i] = scanner.nextInt();
                b[i] = scanner.nextInt() + a[i];
                c[i] = scanner.nextInt();
            }
            boolean flag = false;
            for (int i = 0; i < n; ++i) {
                st[i] = true;
                if (dfs(i, 0, 1)) {
                    flag = true;
                    break;
                }
                st[i] = false;
            }
            System.out.println(flag ? "YES" : "NO");
        }
        scanner.close();
    }
}

Python

N = 15
a, b, c = [0]*N, [0]*N, [0]*N
st = [False]*N

def dfs(u, last, cnt):
    if b[u] < last:
        return False
    if cnt == n:
        return True
    for i in range(n):
        if not st[i]:
            st[i] = True
            if dfs(i, max(a[u], last) + c[u], cnt + 1):
                return True
            st[i] = False
    return False

T = int(input().strip())
for _ in range(T):
    st = [False]*N
    n = int(input().strip())
    for i in range(n):
        a[i], b[i], c[i] = map(int, input().strip().split())
        b[i] += a[i]
    flag = False
    for i in range(n):
        st[i] = True
        if dfs(i, 0, 1):
            flag = True
            break
        st[i] = False
    print("YES" if flag else "NO")