DFS
1. n-皇后问题
模板题
原题链接
题目描述
\(n-\)皇后问题是指将 \(n\) 个皇后放在 \(n \times n\) 的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。
现在给定整数 \(n\)，请你输出所有的满足条件的棋子摆法。
输入格式
共一行，包含整数 \(n\)。
输出格式
每个解决方案占 \(n\) 行，每行输出一个长度为 \(n\) 的字符串，用来表示完整的棋盘状态。
其中 . 表示某一个位置的方格状态为空，Q 表示某一个位置的方格上摆着皇后。
每个方案输出完成后，输出一个空行。
注意：行末不能有多余空格。
输出方案的顺序任意，只要不重复且没有遗漏即可。
数据范围
\(1≤n≤9\)
输入样例
4
输出样例
.Q..
...Q
Q...
..Q.
..Q.
Q...
...Q
.Q..
算法一 （dfs） \(O(n)\)
算法内容
blabala
C++代码
#include <iostream>
using namespace std;
const int N = 20;
int n;
char g[N][N];
bool col[N], dg[N], udg[N];
/*
用b来表示对角线
正对角线：y = x + b ==> b = y - x（由于可能为负，所以加上一个偏移量n）
反对角线：y = -x + b ==> b = y + x
*/
void dfs(int u) //u代表行数
{
if (u == n)
{
for (int i = 0; i < n; i ++ ) puts(g[i]);
puts("");
return;
}
else
{
for (int i = 0; i < n; i ++ ) //枚举每一列
{
if (!col[i] && !dg[i - u + n] && !udg[i + u])
{
g[u][i] = 'Q';
col[i] = dg[i - u + n] = udg[i + u] = true;
dfs(u + 1);
col[i] = dg[i - u + n] = udg[i + u] = false;
g[u][i] = '.';
}
}
}
}
int main()
{
cin >> n;
for (int i = 0; i < n; i ++ )
for (int j = 0; j < n; j ++ )
g[i][j] = '.';
dfs(0);
return 0;
}
2. 树的遍历
PAT甲级真题1020
原题链接
题目描述
一个二叉树，树中每个节点的权值互不相同。
现在给出它的后序遍历和中序遍历，请你输出它的层序遍历。
输入格式
第一行包含整数 \(N\)，表示二叉树的节点数。
第二行包含 \(N\) 个整数，表示二叉树的后序遍历。
第三行包含 \(N\) 个整数，表示二叉树的中序遍历。
输出格式
输出一行 \(N\) 个整数，表示二叉树的层序遍历。
数据范围
\(1≤N≤30\),
官方并未给出各节点权值的取值范围，为方便起见，在本网站范围取为 \(1∼N\)。
输入样例
7
2 3 1 5 7 6 4
1 2 3 4 5 6 7
输出样例
4 1 6 3 5 7 2
算法一：（DFS）\(O(n)\)
算法内容
-
前置知识：
后序遍历的最后一个点一定为根节点
中序遍历的任意一个点的左侧为它的右子树，右侧为它的左子树 -
算法步骤：
一：建树
1.因为后序遍历的最后一个点为根节点，所以在中序遍历中找到根节点（可以用哈希表），其下标为\(k\)
2.中序遍历中k的左右两侧即为k节点的左右子树，并且满足\(k - 1 - il = x - pl\)
3.我们递归地对k的左右子树再建树即可建完整棵树
二：从根节点开始bfs输出它的层序遍历
C++代码
#include <iostream>
#include <cstring>
#include <algorithm>
#include <unordered_map>
#include <queue>
using namespace std;
const int N = 40;
int n;
int postorder[N]; //后序遍历
int inorder[N]; //中序遍历
unordered_map<int, int> l, r; //记录左右子树
unordered_map<int, int> pos; //记录中序遍历中每个节点的下标
/*
build函数参数介绍
il, ir为中序遍历的左右端点
pl, pr为后序遍历的左右端点
返回值为根节点
*/
int build(int il, int ir, int pl, int pr)
{
int root = postorder[pr]; //根节点为后序遍历的最后一个位置
int k = pos[root]; //在中序遍历中查哈希表得到根节点的下标
if (il < k) l[root] = build(il, k - 1, pl, pl + k - 1 -il);
if (ir > k) r[root] = build(k + 1, ir, pl + k - 1 - il + 1, pr - 1);
return root;
}
void bfs(int root)
{
queue<int> q;
q.push(root);
while (q.size())
{
auto t = q.front();
q.pop();
cout << t << ' ';
if (l.count(t)) q.push(l[t]);
if (r.count(t)) q.push(r[t]);
}
}
int main()
{
cin >> n;
for (int i = 0; i < n; i ++ ) cin >> postorder[i];
for (int i = 0; i < n; i ++ )
{
cin >> inorder[i];
pos[inorder[i]] = i;
}
int root = build(0, n - 1, 0, n - 1);
bfs(root);
return 0;
}
3. 飞机降落
来源：第十四届蓝桥杯省赛C++B组
原题链接
有 $N$ 架飞机准备降落到某个只有一条跑道的机场。
其中第 $i$ 架飞机在 $T_i$ 时刻到达机场上空，到达时它的剩余油料还可以继续盘旋 $D_i$ 个单位时间，即它最早可以于 $T_i$ 时刻开始降落，最晚可以于 $T_i + D_i$ 时刻开始降落。
降落过程需要 $L_i$ 个单位时间。
一架飞机降落完毕时，另一架飞机可以立即在同一时刻开始降落，但是不能在前一架飞机完成降落前开始降落。
请你判断 $N$ 架飞机是否可以全部安全降落。
输入格式
输入包含多组数据。
第一行包含一个整数 $T$，代表测试数据的组数。
对于每组数据，第一行包含一个整数 $N$。
以下 $N$ 行，每行包含三个整数：$T_i$，$D_i$ 和 $L_i$。
输出格式
对于每组数据，输出 YES 或者 NO，代表是否可以全部安全降落。
数据范围
对于 $30\%$ 的数据，$N ≤ 2$。
对于 $100\%$ 的数据，$1 ≤ T ≤ 10$，$1 ≤ N ≤ 10$，$0 ≤ T_i, D_i, L_i ≤ 10^5$。
输入样例：
2
3
0 100 10
10 10 10
0 2 20
3
0 10 20
10 10 20
20 10 20
输出样例：
YES
NO
样例解释
对于第一组数据，可以安排第 $3$ 架飞机于 $0$ 时刻开始降落，$20$ 时刻完成降落。安排第 $2$ 架飞机于 $20$ 时刻开始降落，$30$ 时刻完成降落。安排第 $1$ 架飞机于 $30$ 时刻开始降落，$40$ 时刻完成降落。
对于第二组数据，无论如何安排，都会有飞机不能及时降落。
算法：（贪心 + \(DFS\)）\(O(n! \times nT)\)
算法内容
-
\(dfs\)枚举飞机的降落顺序，对于每两个飞机之间，用贪心的思想，让前一个飞机尽可能早的开始降落，后一个飞机尽可能晚的开始降落，如果在这种最优情况下还不能满足后一个飞机的开始降落时刻大于等于前一个飞机的完成降落的时刻，则此种枚举顺序无解
-
更新\(last\)时为什么\(max(last, t) + l\)
因为是最早完成降落，所以开始降落的时间应是t，但是由于必须在上一驾飞机完成降落之后才能开始降落，所以开始降落的时间为\(max(last, t)\)，那么完成降落的时间就是\(max(last, t) + l\)
C++代码
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 10;
int n;
bool st[N];
struct Plane
{
int t, d, l;
}p[N];
bool dfs(int u, int last) //last表示上一架飞机最早完成降落的时刻
{
if (u == n) return true;
for (int i = 0; i < n; i ++ ) //枚举当前位置选哪个飞机
{
int t = p[i].t, d = p[i].d, l = p[i].l;
//如果当前飞机最晚开始降落的时刻大于等于上一架飞机最早完成降落的时刻
if (!st[i] && t + d >= last)
{
st[i] = true;
if (dfs(u + 1, max(last, t) + l))
return true;
st[i] = false;
}
}
return false;
}
int main()
{
int T;
scanf("%d", &T);
while (T -- )
{
scanf("%d", &n);
for (int i = 0; i < n; i ++ )
{
int t, d, l;
scanf("%d%d%d", &t, &d, &l);
p[i] = {t, d, l};
}
memset(st, 0, sizeof st);
if (dfs(0, 0)) puts("YES");
else puts("NO");
}
return 0;
}
浙公网安备 33010602011771号