个人题解链接，蓝桥杯历届试题，正在更新中~
迷宫与陷阱
题目描述
小明在玩一款迷宫游戏，在游戏中他要控制自己的角色离开一间由NxN个格子组成的2D迷宫。
小明的起始位置在左上角，他需要到达右下角的格子才能离开迷宫。
每一步，他可以移动到上下左右相邻的格子中（前提是目标格子可以经过）。
迷宫中有些格子小明可以经过，我们用’.‘表示；
有些格子是墙壁，小明不能经过，我们用’#'表示。
此外，有些格子上有陷阱，我们用’X’表示。除非小明处于无敌状态，否则不能经过。
有些格子上有无敌道具，我们用’%'表示。
当小明第一次到达该格子时，自动获得无敌状态，无敌状态会持续K步。
之后如果再次到达该格子不会获得无敌状态了。
处于无敌状态时，可以经过有陷阱的格子，但是不会拆除/毁坏陷阱，即陷阱仍会阻止没有无敌状态的角色经过。
给定迷宫，请你计算小明最少经过几步可以离开迷宫
输入
第一行包含两个整数N和K。 (1 <= N <= 1000 1 <= K <= 10)
以下N行包含一个NxN的矩阵。
矩阵保证左上角和右下角是’.’。
输出
一个整数表示答案。如果小明不能离开迷宫，输出-1。
样例输入
5 3
…XX
##%#.
…#.
.###.
…
样例输出
10
思路
bfs，难点在于怎么处理可以重复走的问题，又考虑到可能捡到道具后又要捡到下一个道具才能去到终点，所以又要处理重复走了之后还能重复走的问题。由于题目没有告诉我们道具的数量，所以给每个道具单独开一个标记数组不现实。注意到捡了道具后最多走10步，所以可以开10倍的标记数组，vis[i][j][k] 代表走到了i，j位置还能无视陷阱走k步。这样空间复杂度其实还是依赖于道具的数量。所以只能祈祷道具不多。
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int INF = 0x3f3f3f3f;
const double Pi = acos(-1);
namespace {
template <typename T> inline void read(T &x) {
x = 0; T f = 1;char s = getchar();
for(; !isdigit(s); s = getchar()) if(s == '-') f = -1;
for(; isdigit(s); s = getchar()) x = (x << 3) + (x << 1) + (s ^ 48);
x *= f;
}
}
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define _for(n,m,i) for (register int i = (n); i < (m); ++i)
#define _rep(n,m,i) for (register int i = (n); i <= (m); ++i)
#define _srep(n,m,i)for (register int i = (n); i >= (m); i--)
#define _sfor(n,m,i)for (register int i = (n); i > (m); i--)
#define lson rt << 1, l, mid
#define rson rt << 1 | 1, mid + 1, r
#define lowbit(x) x & (-x)
#define pii pair<int,int>
#define fi first
#define se second
const int N = 1e3+5;
char s[N][N];
bool vis[N][N][11];
int dx[] = {0,0,1,-1};
int dy[] = {1,-1,0,0};
struct node {
int x, y, k, step;
};
int n, k;
void fun(int x, int y) {
for(int i = -k; i <= k; i++) {
for(int j = -k; j <= k; j++) {
if(x + i >= 0 && x + i < n && y + j >= 0 && y + j < n) vis[x+i][y+j][1] = 0;
}
}
}
int bfs() {
queue<node> q;
q.push({0, 0, 0, 0});
while(!q.empty()) {
node now = q.front(); q.pop();
if(now.x == n-1 && now.y == n-1) return now.step;
for(int i = 0; i < 4; i++) {
int fx = now.x + dx[i], fy = now.y + dy[i];
if(fx >= 0 && fx < n && fy >= 0 && fy < n && s[fx][fy] != '#') {
if(s[fx][fy] == '%' && !vis[fx][fy][k]) {
vis[fx][fy][k] = 1;
q.push({fx, fy, k, now.step+1});
} else if(now.k > 0 && !vis[fx][fy][now.k-1]) {
vis[fx][fy][now.k-1] = 1;
q.push({fx, fy, now.k-1, now.step+1});
} else if(s[fx][fy] == '.' && now.k==0 && !vis[fx][fy][0]) {
vis[fx][fy][0] = 1;
q.push({fx, fy, 0, now.step+1});
}
}
}
}
return -1;
}
int main() {
read(n); read(k);
_for(0, n, i) scanf("%s", s[i]);
cout << bfs() << endl;
}
版本分支
小明负责维护公司一个奇怪的项目。这个项目的代码一直在不断分支(branch)但是从未发生过合并(merge)。
现在这个项目的代码一共有N个版本，编号1~N，其中1号版本是最初的版本。
除了1号版本之外，其他版本的代码都恰好有一个直接的父版本；即这N个版本形成了一棵以1为根的树形结构。
如下图就是一个可能的版本树：
1
/
2 3
| /
5 4 6
现在小明需要经常检查版本x是不是版本y的祖先版本。你能帮助小明吗？
输入
第一行包含两个整数N和Q，代表版本总数和查询总数。
以下N-1行，每行包含2个整数u和v，代表版本u是版本v的直接父版本。
再之后Q行，每行包含2个整数x和y，代表询问版本x是不是版本y的祖先版本。
输出
对于每个询问，输出YES或NO代表x是否是y的祖先。
样例输入
6 5
1 2
1 3
2 5
3 6
3 4
1 1
1 4
2 6
5 2
6 4
样例输出
YES
YES
NO
NO
NO
思路
lca裸题，学会了就能写。为了卡卡常，可以特判掉一些情况。
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int INF = 0x3f3f3f3f;
const double Pi = acos(-1);
namespace {
template <typename T> inline void read(T &x) {
x = 0; T f = 1;char s = getchar();
for(; !isdigit(s); s = getchar()) if(s == '-') f = -1;
for(; isdigit(s); s = getchar()) x = (x << 3) + (x << 1) + (s ^ 48);
x *= f;
}
}
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define _for(n,m,i) for (register int i = (n); i < (m); ++i)
#define _rep(n,m,i) for (register int i = (n); i <= (m); ++i)
#define _srep(n,m,i)for (register int i = (n); i >= (m); i--)
#define _sfor(n,m,i)for (register int i = (n); i > (m); i--)
#define lson rt << 1, l, mid
#define rson rt << 1 | 1, mid + 1, r
#define lowbit(x) x & (-x)
#define pii pair<int,int>
#define fi first
#define se second
const int N = 1e5+5;
struct node {
int to, next;
}e[N*2];
int head[N],cnt;
void add(int u, int v) {
e[++cnt] = node {v, head[u]};
head[u] = cnt;
e[++cnt] = node {u, head[v]};
head[v] = cnt;
}
int f[N][25], dep[N];
void dfs(int u, int fa) {
f[u][0] = fa;
dep[u] = dep[fa] + 1;
for(int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if(v == fa) continue;
dfs(v, u);
}
}
int main() {
int n, q, u, v, x;
read(n); read(q);
_for(1, n, i) {
read(u); read(v);
add(u, v);
}
dfs(1, 0);
for(int i = 1; i <= 20; i++) {
for(int j = 1; j <= n; j++) {
f[j][i] = f[f[j][i-1]][i-1];
}
}
while(q--) {
read(u); read(v);
if(dep[u] > dep[v]) puts("NO");
else if(u == v) puts("YES");
else if(dep[u] == dep[v]) puts("NO");
else {
x = dep[v] - dep[u];
for(int i = 0; i <= 20; i++) if(x >> i & 1) v = f[v][i];
if(u == v) puts("YES");
else puts("NO");
}
}
}
自描述序列
题目描述
小明在研究一个序列，叫Golomb自描述序列，不妨将其记作{G(n)}。这个序列有2个很有趣的性质:
- 对于任意正整数n，n在整个序列中恰好出现G(n)次。
- 这个序列是不下降的。
以下是{G(n)}的前几项：
n 1 2 3 4 5 6 7 8 9 10 11 12 13
G(n) 1 2 2 3 3 4 4 4 5 5 5 6 6
给定一个整数n，你能帮小明算出G(n)的值吗？
输入
一个整数n。
输出
一个整数G(n)
样例输入
13
样例输出
6
思路
这题主要是找增长快的函数，设G（n）的反函数为f（n）其表示G（n）相同时最大的n。给出一种生成方式
f[1] = 1;
int l = 1;
for(int i = 1; i < N; i++) {
if(f[l] < i) l++;
f[i] = f[i-1] + l;
}
这样生成的话最多只能找到1e9，空间就会撑不住。我们还得找更快的。发现很大数增长速度是一样的，比如说f[i]-f[i-1]中的所有数每次都是增加i。然后升级版出来了。设F[i]为f[i]的反函数，F[i]表示增长都为i的f[i]表示的最大的值是多少，比如说 F [ 1 ] = 1 , F [ 2 ] = 5 , F [ i ] = F [ i − 1 ] + i ∗ ( f [ i ] − f [ i − 1 ] ) F[1] = 1, F[2] = 5, F[i] = F[i-1] + i * (f[i] - f[i-1]) F[1]=1,F[2]=5,F[i]=F[i−1]+i∗(f[i]−f[i−1])，然后找到第一个大于n的F[i]，然后这个数对应的G(n)是f[i]，注意到每变化i个数才会变化一次G（n），所以看n到F[i]差了多少个i再用f[i]减去即可。
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int INF = 0x3f3f3f3f;
const double Pi = acos(-1);
namespace {
template <typename T> inline void read(T &x) {
x = 0; T f = 1;char s = getchar();
for(; !isdigit(s); s = getchar()) if(s == '-') f = -1;
for(; isdigit(s); s = getchar()) x = (x << 3) + (x << 1) + (s ^ 48);
x *= f;
}
}
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define _for(n,m,i) for (register int i = (n); i < (m); ++i)
#define _rep(n,m,i) for (register int i = (n); i <= (m); ++i)
#define _srep(n,m,i)for (register int i = (n); i >= (m); i--)
#define _sfor(n,m,i)for (register int i = (n); i > (m); i--)
#define lson rt << 1, l, mid
#define rson rt << 1 | 1, mid + 1, r
#define lowbit(x) x & (-x)
#define pll pair<LL,LL>
#define fi first
#define se second
const int N = 2e6+5;
LL f[N];
LL dp[N];
int main() {
f[1] = 1;
int l = 1;
for(int i = 1; i < N; i++) {
if(f[l] < i) l++;
f[i] = f[i-1] + l;
}
for(int i = 1; i < N; i++) {
dp[i] = dp[i-1] + i * (f[i] - f[i-1]);
}
LL n; read(n);
for(int i = 1; i < N; i++) {
if(n < dp[i]) {
cout << f[i] - (dp[i] - n) / i << endl;
break;
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
