P8809 [蓝桥杯 2022 国 C] 近似 GCD - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)
思路：1.首先近似gcd已知，所以若是一个子数组的近似gcd为g，那么这个子数组中的所有数都要满足a[i] % g == 0。考虑到在子数组中有一个数可修改，那么长度为n的数组中，只需要有n - 1个数满足上述条件即可
2.那么我们要考虑的就是如何快速算出每个子数组中有多少个数满足a[i] % g == 0，只要有n - 1数满足(即小于等于1个数不满足)，那么这个子数组就是有贡献的。显然可以考虑用01前缀和快速算出区间中有多少数满足，用双指针来o(n)枚举所有子数组
#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int, int> PII;
const int N = 1e5 + 10;
int a[N];
void solve()
{
int n, g;
cin >> n >> g;
for(int i = 1; i <= n; i ++ ) cin >> a[i];
vector<int> sum(n + 10);
for(int i = 1; i <= n; i ++ )
if(a[i] % g) sum[i] = sum[i - 1] + 1; //01前缀和，不满足条件就置1，满足就置0
else sum[i] = sum[i - 1];
//双指针算连续的区间个数基本都要以左端点或者右端点为基准
int ans = 0;
//枚举左端点，区间长度要大于等于2，j从2开始即可
for(int i = 1, j = 2; i < n; i ++ )
{
while(j <= n && sum[j] - sum[i - 1] <= 1) j ++;
//o(1)算贡献，i到j这一段有j - (i + 1)个子区间
ans += j - (i + 1);
}
cout << ans << endl;
}
signed main()
{
int t = 1;
//cin >> t;
while(t -- ) solve();
return 0;
}P8673 [蓝桥杯 2018 国 C] 迷宫与陷阱 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)
bfs + 剪枝
题意：加了无敌道具的bfs板子，无敌道具的效果，可以踩陷阱（就是可以回去踩陷阱），即如果踩到无敌陷阱就可以折返搜索
思路：1.用一个结构体（node）存坐标，步数，以及无敌步数，这样bfs时比较好处理
2.因为可以折返搜索，那么直接用bool st[]数组来判断某点是否访问过显然是不合理的，那么就开成int st[]数组，用来存每个格子是否访问过及经过当前格子时剩余的无敌步数，再加入剪枝，即显然经过某个格子时无敌步数剩的越多越优，所以当某个格子再次搜到时，若剩余的无敌步数不如之前优就直接剪掉即可
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e3 + 10;
int n, k;
char g[N][N];
int step[N][N]; //因为本题可以折返搜索，故只用bool st显然很蠢不好控制；
//记录每个格子可行的最大无敌步数来判断是否要去搜！！
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int ans = -1;
bool flag;
struct node
{
int x, y, d, re;
};
void bfs()
{
queue<node> q;
q.push({1, 1, 0, 0});
while(q.size())
{
auto u = q.front();
q.pop();
if(u.x == n && u.y == n)
{
ans = u.d;
break;
}
for(int i = 0; i < 4; i ++ )
{
int a = u.x + dx[i], b = u.y + dy[i];
if(a < 1 || a > n || b < 1 || b > n) continue;
if(g[a][b] == 'X' && u.re == 0) continue; //碰到陷阱且无敌步数为0时走不了
if(g[a][b] == '#') continue;
int re = max(0ll, u.re - 1); //当前的无敌步数等于上一步的无敌步数减一
if(g[a][b] == '%') //踩到无敌格子，更新步数
re = k;
if(step[a][b] < re) //剪枝，也顺路保证了每个无敌格子只会被搜到一次
{
step[a][b] = re;
q.push({a, b, u.d + 1, re});
}
}
}
}
void solve()
{
cin >> n >> k;
for(int i = 1; i <= n; i ++ )
for(int j = 1; j <= n; j ++ )
cin >> g[i][j];
memset(step, -1, sizeof step); //初始化
bfs();
cout << ans << endl;
}
signed main()
{
int t = 1;
//cin >> t;
while(t -- ) solve();
return 0;
}P8685 [蓝桥杯 2019 省 A] 外卖店优先级 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)
思路：1.首先可以发现每家外卖店的订单都是相互独立的，各自订单什么的互不影响，所以可以考考虑为每一家外卖店开一个存时间的优先队列，然后对每一家外卖店的情况单独处理
2.在处理的过程中不停判断是不是会加入优先缓存，是不是会清出，可以想到最快的模拟方式就是直接开一个bool st数组记录某家外卖店是否再优先缓存中，加入就标记为1，清空就标记为0，全部处理完后在st就是1，不在st就是0
3.剩下的就是模拟的过程了，记录一个上一次订单到达的时间s，和当前的优先级now，优先级减少的量就是当前订单到达的时间和上一次订单到达的时间的差值和0取一个max，增加的数量就是2，特判边界
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e5 + 10;
priority_queue<int, vector<int>, greater<int>> q[N];
bool st[N]; //表示每个点是否在优先缓冲中
void check_now(int id, int va)
{
if(va > 5) st[id] = 1;
if(va <= 3) st[id] = 0;
}
void solve()
{
int n, m, ed;
cin >> n >> m >> ed;
for(int i = 1; i <= m; i ++ )
{
int ts, id;
cin >> ts >> id;
q[id].push(ts); //每个队列单独算然后去模拟即可
}
for(int i = 1; i <= n; i ++ ) //对于每个节点单独处理
{
if(!q[i].size()) continue;
int s = 0, now = 0; //s为上一个订单到来的时间
while(q[i].size())
{
int ts = q[i].top();
q[i].pop();
//第一个订单到来的时候和前后两个订单到来时间相同时就不会发生优先级的减少
if(s != ts && s != 0) now -= (ts - s - 1);
now = max(0ll, now);
check_now(i, now);
now += 2; //要先减掉前面的时间再加！！！！注意顺序
s = ts;
check_now(i, now);
}
if(ed > s) //单独处理最后一段
{
now -= (ed - s);
check_now(i, now);
}
}
int ans = 0;
for(int i = 1; i <= n; i ++ )
if(st[i]) ans ++;
cout << ans << endl;
}
signed main()
{
int t = 1;
//cin >> t;
while(t -- ) solve();
return 0;
}P8744 [蓝桥杯 2021 省 A] 左孩子右兄弟 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)
难点在题干：
左孩子右兄弟表示法：每个节点的所有子节点链接起来作为该节点的左孩子，该节点右兄弟作为该节点的右孩子（多叉树转化为二叉树）
具体转化方式如下：
思路：由题意可知，通过这种表示方法，对于每个节点来说它的子节点的链接方式是任意的，可可以发现每个节点的所有子节点链接起来是一定会造成高度贡献的（有几个子节点高度就增加几），题目要求最大，显然答案就是ans = 根节点儿子数 + 儿子中的最大高度
根节点的儿子数直接用一个变量size维护，儿子中的最大高度用树形dp来求
#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int, int> PII;
const int N = 1e5 + 10;
vector<int> g[N];
int s[N];
void dfs(int u) //有向图dfs本身就是有限次的 ！！不需要出口也可以
{
int size = 0;
for(int i = 0; i < g[u].size(); i ++ )
{
size ++;
dfs(g[u][i]);
s[u] = max(s[u], s[g[u][i]]); //求儿子中的最大高度
}
s[u] += size;
}
void solve()
{
int n;
cin >> n;
for(int i = 2; i <= n; i ++ ) //图是多叉树
{
int v;
cin >> v;
g[v].push_back(i);
}
dfs(1);
cout << s[1] << endl;
}
signed main()
{
int t = 1;
//cin >> t;
while(t -- ) solve();
return 0;
}P8736 [蓝桥杯 2020 国 B] 游园安排 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)
题干太长（）
题意：就是说给出一行由一堆客人名字构成的序列，找出客人名字的最长上升子序列
思路：就是求一个字符串的最长上升子序列，看代码
#include<bits/stdc++.h>
//#define int long long
using namespace std;
typedef pair<int, int> PII;
const int N = 1e6 + 10;
//str存分割出的名字字符串，tmp暂存的当前能接的字符串，ans存拼接起来的答案
string str[N], tmp[N], ans[N];
void solve()
{
string s;
cin >> s;
int cnt = 0;
for(int i = 0; i < s.size(); i ++ ) //很妙的按大写字母分割字符串
{
if(isupper(s[i]))
cus[++ cnt] = s[i];
else
cus[cnt] += s[i];
}
int len = 0;
for(int i = 1; i <= cnt; i ++ )
{
int l = 0, r = len;
while(l < r) //二分当前能接的字符串的位置
{
int mid = l + r + 1 >> 1;
if(tmp[mid] < str[i]) l = mid;
else r = mid - 1;
}
len = max(len, r + 1); //更新长度
tmp[r + 1] = str[i];
ans[r + 1] = ans[r] + str[i]; //当前字符串接到r位置后面
}
cout << ans[len] << endl;
}
int main()
{
int t = 1;
while(t -- ) solve();
return 0;
}P8782 [蓝桥杯 2022 省 B] X 进制减法 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)
这里只介绍每一个数位上进制都不同的话，这个数是怎么转换为十进制数的
最低位每有两个1，向次高位进1，次高位每有10个1，向最高位进1
显然最高位每有一个1，相当于有10 * 2个1， 依次类推
故321转换成65的过程为 3 * 10 * 2 + 2 * 2 + 1 = 65
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
