蓝桥杯C++大学B组一个月冲刺记录2024/3/20
昨日下午去参加算竞校赛了，记录一下我ac的题
昨天出去玩了，今天补个记录
战绩：827.5/1100
由于主办方为了艺术，题目都比较长，而且不好理解。复杂题干的题目我选择直接描述
1.人鼠的游戏
人鼠在地上画了一个 n × m 的格子，其中有些格子站着参与者，然后在之后的 k 秒中，每秒都会有一个随机格子亮起，当参与者所在的格子亮起时，视为被淘汰，现在给你格子以及所有参与者的站位信息以及格子亮起顺序，你需要回答最后剩余多少名参与者没有被淘汰。保证每个格子只能站一个人。
stl
由于数据非常大,（n,m <= 1e9），二维数组模拟肯定不行。官方是拿一个set存储所有出现过的坐标，然后对每个出现过的坐标进行find和erase，单次查询为logp最终时间复杂度为O(nlogp)。
我的想法是将nm看作1e9 + 1进制的数。然后哈希，查找h[find(x,y)]。时间复杂度就降到了O(n)。
(但是：尽管哈希插入的时候没有重复元素，但是在查询的时候有重复元素的查询，所以哈希数组被查询的时候要赋-1)
#include<iostream>
#include<cstring>
using namespace std;
const int N = 1e7 + 3;
typedef long long LL;
LL h[N];
LL query_k(int x,int y){
return x * (1e9 + 1) + y;
}
int find(int x,int y){
LL k = query_k(x,y);
int id = (k%N + N)%N;
while(h[id] != -1 && h[id] != k)
{
id++;
if(id >= N) id = 0;
}
return id;
}
int main(){
memset(h,-1,sizeof(h));
int n,m,p,Q;
cin >> n >> m >> p;
int ans = p;
while(p--){
int x,y;
cin >> x >> y;
h[find(x,y)] = query_k(x,y);
}
cin >> Q;
while(Q--){
int x,y;
cin >> x >> y;
if(h[find(x,y)] != -1){
ans--;
h[find(x,y)] = -1;
}
}
cout << ans << endl;
return 0;
}
2.人兔的游戏
她的游戏场地是一个由n×m个房间组成的迷宫，迷宫中有两类房间，一类是可正常同行的房间，但是需要花费w(i,j)
才能通行，另一类是封锁的房间，表示在初始情况下无法通行，在迷宫中只能向四个相邻的房间移动（每个房间都是一个矩形）。
在游戏开始前，人兔会给你 k 次解锁封锁房间的机会，你可以花费一次机会解锁一个封锁房间，并为你定下起点和终点
注意，花费机会解锁的房间将不会消耗。
现在给你这个迷宫的地图，请你帮小云计算如果花费最少能够到达终点。
dfs + 剪枝
剪枝策略：
（1）判断当前搜到的位置比之前已经搜到的位置花费是否更少，显然如果花费均等甚至
更多没有必要再搜索下去了；
（2）另外就是判断搜到的每个点比当前的答案是否更优，由于花费都是正的，如果已经超出当前答案即使搜到终点结果也一定更差。
（3）但是当k不是0时，因为在当前点之后可以打破封锁的房间并不确定，所以上面的第一个剪枝不再适用。
#include<iostream>
#include<cstring>
using namespace std;
const int N = 55;
int p[N][N];
int res[N][N];
int dist[N][N];
bool st[N][N];
int m,n,k;
int x1,y1,x2,y2;
int ans = 0x3f3f3f3f;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
void dfs(int i,int j,int tot,int chance)
{
if(tot > dist[i][j]&&chance == 0) return;
dist[i][j] = min(dist[i][j],tot);
if(i == x2 && j == y2){
ans = min(tot,ans);
return;
}
if(tot >= ans) return;
for(int k = 0;k < 4; ++k)
{
int x = i + dx[k];
int y = j + dy[k];
if(x < 1 || x > m || y < 1 || y > n ||st[x][y]) continue;
if(p[x][y] == 0)
{
st[x][y] = true;
dfs(x, y, tot + res[x][y],chance);
st[x][y] = false;
}
if(p[x][y] == 1&&chance != 0)
{
st[x][y] = true;
dfs(x,y,tot,chance-1);
st[x][y] = false;
}
}
}
int main(){
memset(dist,0x3f,sizeof(dist));
cin >> m >> n >> k;
for(int i = 1;i <= m; ++i){
for(int j = 1;j <= n; ++j){
cin >> p[i][j];
}
}
for(int i = 1;i <= m; ++i){
for(int j = 1;j <= n; ++j){
cin >> res[i][j];
}
}
cin >> x1 >> y1 >> x2 >> y2;
st[x1][y1] = true;
dfs(x1,y1,0,k);
if(ans==0x3f3f3f3f)cout<<-1<<"\n";
else cout<<ans<<"\n";
return 0;
}
3.人龙的游戏
01背包
dp
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 10000;
int n, m;
int v[N], w[N];
int f[N];
int main()
{
cin >> n >> m;
for (int i = 1; i <= n; i ++ ) cin >> v[i];
for (int i = 1; i <= n; i ++ ) cin >> w[i];
for (int i = 1; i <= n; i ++ )
for (int j = m; j >= v[i]; j -- )
f[j] = max(f[j], f[j - v[i]] + w[i]);
cout << f[m] << endl;
return 0;
}
4.人蛇的问题
求两个值的异或值
模拟/语法
哥们不知道还能这样写啊
我的做法：数组模拟将十进制变成二进制编码，在做高精度(不进位)加法。再将二进制编码转化为十进制数
官方做法：a^b
模拟：
#include<iostream>
#include<vector>
using namespace std;
typedef long long LL;
vector<int>aa;
vector<int>bb;
void make(LL x,int id){
int t = x%2;
if(id == 1) aa.push_back(t);
else bb.push_back(t);
x = x>>1;
if (x != 0) make(x,id);
}
void check(){
vector<int>ans;
int i = 0;
int j = 0;
while(i < aa.size() && j < bb.size()){
if(aa[i] == bb[j]) ans.push_back(0);
else ans.push_back(1);
i++;
j++;
}
while(i < aa.size()){
ans.push_back(aa[i]);
i++;
}
while(j < bb.size()){
ans.push_back(bb[j]);
j++;
}
LL res = 0;
LL h = 1;
for(int k = 0;k < ans.size(); ++k){
res += ans[k] * h;
h = h * 2;
}
cout << res << endl;
return;
}
int main(){
LL a,b;
cin >> a >> b;
make(a,1);
make(b,2);
check();
return 0;
}
语法：
#include<bits/stdc++.h>
int main(){
long long a,b;
std::cin>>a>>b;
std::cout<<(a^b)<<"\n";
}
5.人马的游戏
比大小
签到题
#include<iostream>
using namespace std;
int main(){
int a,b;
cin >> a >> b;
if(a < b) cout << "participant" << endl;
else{
if(a == b) cout << "draw" << endl;
else cout << "horse" << endl;
}
return 0;
}
6.人羊的游戏
最长上升子序列，（但卡了O(n^2)的做法，有二分的方法来优化，时间复杂度优化到O(nlogn)）
线性dp + 二分
#include<iostream>
using namespace std;
const int N = 1e6+10;
int a[N],q[N];
int main(){
int n;
cin >> n;
for(int i = 0;i < n;++i) cin >> a[i];
int len = 0;
for(int j = 0;j < n;++j){
q[0] = 0x3f3f3f3f;
int l = 0;int r = len;
while(l < r){
int mid = (l + r + 1) / 2;
if(q[mid] < a[j]) l = mid;
else r = mid - 1;
}
len = max(r+1,len);
q[r+1] = a[j];
}
cout << len << endl;
return 0;
}
7.人鸡的游戏
鸡，是一种好斗的生物。刚刚当上生肖的人鸡却一直不确定自己的游戏是不是符合规定（参与者能够存活），于是他想找身为白羊的你与他模拟一轮游戏，检查游戏的公平性，他设计的游戏如下：
参与者和人鸡分别决定矩阵的长宽 n,m，在这个 n×m的矩阵中，共有n×m格，每格都放了一个"道"，由参与者和人鸡轮流选定一个格子(i,j)(1≤i≤n,1≤j≤m)，选定一个格子之后需要拿掉位于
(x,y)(1≤x≤i,1≤y≤j)格子中的"道"，要求每轮至少要拿一个"道"，否则视为违规。
假如人鸡在自己的回合拿走矩阵中的最后一个"道"，则视为参与者获胜。
假如参与者在自己的回合拿走矩阵中的最后一个"道"，则视为人鸡获胜。
你和人鸡都不会失误，并且人鸡先手，请你计算出对于给定n,m时的最终获胜者。
数学归纳法
由样例发现：m = 1且n = 1的时候玩家必赢，m = 2且n = 2的时候鸡必赢。另外轻易推出：m = 1且n = 2的时候鸡必赢；m = 2且n = 1的时候鸡必赢。
1.从m = 2且n = 2的时候鸡必赢 这个样例出发，在此地图上加一行：变成m = 3且n = 2的时候，只要鸡拿
（1，1）的格子，那么无论玩家怎么拿，都能回到m = 2且n = 2的时候鸡必赢 这个样例这个情况下。
2.再从m = 3且n = 2这个样例上加一列，变成m = 3且n = 3。同样鸡只要拿（1，2）的格子，那么无论玩家怎么拿，都能回到m = 3且n = 2的时候鸡必赢 这个样例这个情况下。
3.所以可以推出，无论m，n为何值，除了m = 1且n = 1的时候玩家必赢，其余都是鸡必赢
#include<iostream>
using namespace std;
typedef long long LL;
int main(){
LL a,b;
cin >> a >> b;
if(a== 1 && b == 1) cout << "participant" << endl;
else cout << "chicken" << endl;
return 0;
}
8.人狗的游戏
人狗的游戏伤害不高，但是侮辱性极强，你需要听人狗朗读完一篇文章，并在所有"bone"单词后加上“wang”，并在人狗读完文章后将你处理出来的文章读出来。
贴心的人狗怕你记不住文章，保证文章的总长度不会超过1000个字符
换句话说，你要在给定字符串中找到所有子串"bone"并在后面加上"wang"
字符串处理
其实不需要在字符串上进行修改，当遍历字符串的时候，在bone输出完毕后，输出一个wang就可以了
#include<iostream>
using namespace std;
const int N = 1005;
bool f[N];
int n;
string str;
int main()
{
cin >> n;
cin >> str;
for(int i = 0;i + 3 < n;++i){
if(str[i] == 'b' && str[i + 1] == 'o' && str[i + 2] == 'n' && str[i + 3] == 'e'){
f[i + 3] = true;
}
}
for(int i = 0;i < n; ++i){
cout << str[i];
if(f[i]) cout << "wang";
}
return 0;
}
820
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
