深度优先搜索（DFS）之飞机降落

zx_717

已于 2024-02-05 23:04:07 修改

阅读量1.6k

点赞数 34

分类专栏：蓝桥速成文章标签：深度优先算法 c++

于 2024-02-05 17:01:54 首次发布

本文链接：https://blog.csdn.net/ZYFzyf0/article/details/135986775

版权

蓝桥速成专栏收录该内容

6 篇文章 0 订阅

订阅专栏

DFS

1. 用于树或图的染色

算法步骤：

（1）从源节点开始，将其标记为已访问；

（2）对于源节点的每一个未被访问的邻居，递归地调用DFS；

（3）如果所有结点都被访问过，那么结束搜索。

/*伪代码*/
function DFS(node, visited)
    将 node 标记为已访问
    for 每个与 node 相邻的且未被访问过的节点 neighbor
        DFS(neighbor, visited)

/*C++*/
vector<bool> visited;
vector<vector<int>> adj;
// adj = {0: [1, 2], 1: [0, 2], 2: [0, 1]}
void dfs(int node) {
    visited[node] = true;
    for (int neighbor : adj[node]) {
        if (!visited[neighbor]) {
            dfs(neighbor);
        }
    }
}

2. 暴力搜索

2.1 指数型枚举（无序）

遍历一个集合的所有子集，n个元素有 $2^{n}$ 个子集， $2^{n}-1$ 个非空子集， $2^{n}-2$ 个非空真子集。如集合{1, 2}的所有子集：[]、[1]、[2]、[1, 2]。

/*伪代码*/
function DFS(u)
    如果 u 等于 n + 1
        输出 p 中的所有元素
        返回
    在 p 中加入元素 u
    递归调用 DFS(u + 1)
    在 p 中移除元素 u
    递归调用 DFS(u + 1)

/*C++*/
void dfs(int u)
{
    if (u == n + 1)
    {
        for (auto x: p)
            cout << x << ' ';
        cout << endl;
        return;
    }
    
    p.push_back(u);
    dfs(u + 1);
    p.pop_back();
    dfs(u + 1);
}

2.2 组合型枚举（无序）

从n个元素中选取m个元素的所有可能组合。如集合{1, 2, 3}中选2个的所有集合：[1, 2]、[1, 3]、[2, 3]。

/*伪代码*/
function DFS(u)
    如果 p 的大小超过 m 或 p 的大小加上剩余元素数量小于 m
        返回
    如果 u 等于 n + 1
        输出 p 中的所有元素
        返回
    在 p 中加入元素 u
    递归调用 DFS(u + 1)
    在 p 中移除元素 u
    递归调用 DFS(u + 1)

/*C++*/
void dfs(int u)
{
    if (p.size() > m || p.size() + n - u + 1 < m)
        return;
    if (u == n + 1)
    {
        for (auto x: p)
            cout << x << ' ';
        cout << endl;
        return;
    }
    
    p.push_back(u);
    dfs(u + 1);
    p.pop_back();
    dfs(u + 1);
}

2.3 排列型枚举（有序）

列出一个集合的所有排列。如集合{1, 2}的所有子集：[1, 2]、[2, 1]。

/*伪代码*/
function DFS(u)
    如果 u 大于 n
        输出 a 中的所有元素
        返回
    对于每个元素 i，从 1 到 n
        如果 st[i] 为 true
            继续下一次循环
        将 st[i] 设为 true
        将 i 放在 a 的位置 u
        递归调用 DFS(u + 1)
        将 st[i] 设为 false

/*C++*/
void dfs(int u)
{
    if (u > n)
    {
        for (int i = 1; i <= n; i ++ )
            cout << a[i] << ' ';
        cout << endl;
        return;
    }
    
    for (int i = 1; i <= n; i ++ )
    {
        if (st[i])
            continue;
        st[i] = true;
        a[u] = i;
        dfs(u + 1);
        st[i] = false;
    }
}

2.4 全枚举（有序）

穷举所有可能的情况，从中找出满足条件的解。如集合{1, 2}的全枚举结果：[]、[1]、[2]、[1, 2]、[2, 1]。

/*伪代码*/
function DFS(u)
    如果 u 等于 k + 1
        输出 path 中的所有元素
        返回
    对于每个元素 i，从 1 到 k
        如果 st[i] 为 false
            将 st[i] 设为 true
            在 path 的末尾加入元素 i
            递归调用 DFS(u + 1)
            在 path 的末尾移除元素 i
            将 st[i] 设为 false
    递归调用 DFS(k + 1)

/*C++*/
void dfs(int u)
{
    if (u == k + 1)
    {
        print();
        return;
    }
    
    for (int i = 1; i <= k; ++ i )
        if (!st[i])
        {
            st[i] = true;
            path.push_back(i);
            dfs(u + 1);
            path.pop_back();
            st[i] = false;
        }
    
    dfs(k + 1);
}

问题描述

N 架飞机准备降落到某个只有一条跑道的机场。其中第 i 架飞机在 Ti 时刻到达机场上空，到达时它的剩余油料还可以继续盘旋 Di 个单位时间，即它最早可以于Ti 时刻开始降落，最晚可以于 Ti+Di 时刻开始降落。降落过程需要 Li 个单位时间。

一架飞机降落完毕时，另一架飞机可以立即在同一时刻开始降落，但是不能在前一架飞机完成降落前开始降落。

请你判断 N 架飞机是否可以全部安全降落。

输入格式

输入包含多组数据。

第一行包含一个整数 T，代表测试数据的组数。

对于每组数据，第一行包含一个整数 N。

以下 N 行，每行包含三个整数：Ti，Di 和 Li。

输出格式

对于每组数据，输出 YES 或者 NO，代表是否可以全部安全降落。

样例输入

样例输出

YES
NO

样例说明

对于第一组数据，可以安排第 3 架飞机于 0 时刻开始降落，20 时刻完成降落。安排第 2 架飞机于 20 时刻开始降落，30 时刻完成降落。安排第 1 架飞机于 30 时刻开始降落，40 时刻完成降落。

对于第二组数据，无论如何安排，都会有飞机不能及时降落。

评测用例规模与约定

对于 30% 的数据，N≤2。

对于 100% 的数据，1≤T≤10，1≤N≤10，0≤Ti,Di,Li≤ $10^{5}$ 。

运行限制

语言	最大运行时间	最大运行内存
C++	2s	256M
C	2s	256M
Java	3s	256M
Python3	4s	256M

思路

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

首先，根据题目中的条件。每架飞机在 Ti 时刻到达机场上空，且剩余油料可以盘旋维持 Di 个单位时间，降落需要 Li 个单位时间。即飞机可以在 Ti ~ Ti+Di 的时间段内开始降落。

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

1. 首先，我们初始化一个布尔数组 st[ ] 来记录每架飞机是否已经降落。

2. 然后，我们对每架飞机尝试进行降落。“尝试”意味着我们需要检查该飞机是否可以在当前的时间内开始降落，即它的开始降落时间是否在 Ti ~ Ti+Di 的时间段内。如果可以，我们就让它降落，并把 st[i] 设置为 true。

3. 在一架飞机降落后，我们递归地对剩下的飞机进行尝试。这一步就是DFS的主要部分，我们需要在所有的可能的降落序列中进行搜索。

4. 如果在某一步我们发现当前的飞机无法再当前的时间内开始降落，我们就返回 false，并在上一层中尝试下一架飞机。

5. 如果所有的飞机都已经降落，我们就返回 true。

6. 最后，我们对所有飞机进行尝试。如果存在至少一个可以让所有飞机都降落的序列，我们就输出 YES，否则输出 NO。

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

代码

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

using namespace std;

const int N = 15;
int T, n, a[N], b[N], c[N];
bool st[N];

//深搜
bool dfs(int u, int last, int cnt){
  //出口/停止条件
  if(a[u]+b[u] < last) //当前飞机燃油耗尽时间--当前飞机最早可降落时间
    return false;
  //当前飞机可降落，计数
  if(cnt == n)//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(){
  cin >> T;

  while(T--){
    memset(st, 0, sizeof st);//每一次更新st标志
    cin >> n;
    for(int i = 0; i < n; i++)
      cin >> a[i] >> b[i] >> c[i];
    
    bool flag = false;
    for(int i = 0; i < n; i++){
      st[i] = true;//以i为第一次降落查找合理顺序
      if(dfs(i, 0, 1)){//飞机序号、上一架降落结束时、计数
        flag = true;
        break;//结束
      }
      st[i] = false;//无合理顺序，将i设为未降落
    }
    cout << (flag?"YES":"NO") << endl;
  }
  return 0;
}

总结：DFS的前置知识是递归（自己调用自己），在DFS函数形参中，设置了变量last，表示上一架飞机降落结束（当前飞机可降落的最早时间），初始化为0，而后是上一架飞机等待时间与降落时间之和。特别地每一组飞机降落循环中，memset函数对bool类型数组st[]进行初始化，表示设置为false。

zx_717

关注

34
点赞
踩
42

收藏

觉得还不错? 一键收藏
0
评论
深度优先搜索（DFS）之飞机降落

DFS的前置知识是递归（自己调用自己），在DFS函数形参中，设置了变量last，表示上一架飞机降落结束（当前飞机可降落的最早时间），初始化为0，而后是上一架飞机等待时间与降落时间之和。其中第 i 架飞机在 Ti 时刻到达机场上空，到达时它的剩余油料还可以继续盘旋 Di 个单位时间，即它最早可以于Ti 时刻开始降落，最晚可以于 Ti+Di 时刻开始降落。“尝试”意味着我们需要检查该飞机是否可以在当前的时间内开始降落，即它的开始降落时间是否在 Ti ~ Ti+Di 的时间段内。
复制链接

扫一扫