Topic 1：kotori和气球(快速幂算法)
B-kotori和气球_北京信息科技大学第十一届程序设计竞赛（重现赛）
稍微枚举一下找个规律出来：
得到公式 res = n * (n - 1)^(m-1)
通常来说应该是取模10的9次方，这里为啥是109，不过也能跑倒是
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long n, m; cin >> n >> m;
m -= 1;
long long res = n;// 增加m的数量，枚举得到公式res = n * (n-1)^(m-1)
while(m--) res = res * (n - 1) % 109;
cout << res;
return 0;
}这么写倒是能过，不过有要更深层的理解；我第一次使用了int res = n * pow(n - 1, m - 1)，pow来求平方发现通过率只有80，因为pow是浮点数运算，在大数计算时会有很大的误差；
其次是%109这个问题，一般是%10^9, 或者%10^7这种数字，不知道这题是不是笔误，把10^9打成了109，但是%109确实也能过;
然后要注意范围，int不行，得long long;
但是更正统更底层应该是这样写
#include<bits/stdc++.h>
using namespace std;
const int MOD = 109;//1e9; // 通常是10^9 = 1000000000 1e9 这题是109
// 快速幂函数，计算 a^b % MOD
long long fast_pow(long long a, int b)
{
long long res = 1; // 初始结果为1（幂的“单位元素”，*任何数都等于任何数）
while (b) // 当指数 b > 0 时循环
{// 如果当前 b 的最低位是1（有效数字）
if (b & 1) res = res * a % MOD; // 将当前底数 a 乘到结果中
a = a * a % MOD; // 底数平方，准备处理下一个更大的位数
b >>= 1; // 指数右移1位（相当于 b /= 2 or 理解成二进制向右移了一位，把最右边的垫掉了）
}
return res;
}
int main()
{
int n, m;
cin >> n >> m;
long long res = n * fast_pow(n-1, m-1) % MOD;
cout << res << endl;
return 0;
}自己写一个快速幂算法，快速幂算法是什么意思——比如算 3^13，正常来乘的话需要13次，如果3^100，那得100次，意味着复杂度是O(n)级别，但是如果我们把3^13 拆成3^8 * 3^4 * 3^1,只用乘3次，方数越大，优化效果越明显，而这种方式刚好能和二进制对应起来，比如13的二进制——1101，每一位刚好对应十进制：8 4 0 1，那么返回来看看代码
需要处理b次，所以b作为while的循环条件，res初始化为1，来统计最后的结果，b & 1用我们上面的例子就是1101&0001，其本质就是对比你的最地位要不要计算，是1就计算，0就不算；然后把计算的结果*到res里，然后接下来1101最右边的1算完了，要处理0了，我需要把基数增大到对应的量级，也就是a = a*a，这里可能有点难理解，画个图就明白了
处理完之后再让b >>= 1，位右移1位，相当于1101变成了0110（最左边补了一个0）也可以理解成110；0变成了最右的位置，然后继续循环处理；这样就实现了快速幂算法
Topic 2：走迷宫(BFS)
经典的搜索类题目，尝试用DFS来解决，写半天写出来总有点缺陷，用gpt改了一些错误点之后时间还是爆炸，所以采用BFS再试试
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> dir = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 上下左右
int minSteps = INT_MAX;
void DFS(const vector<vector<string>>& grid, vector<vector<bool>>& vd,
int x, int y, int Xt, int Yt, int steps, int n, int m)
{
// 越界或已访问或是障碍物
if (x < 1 || x > n || y < 1 || y > m || !vd[x][y] || grid[x][y] == "*") return;
// 到终点了，更新最小步数
if (x == Xt && y == Yt) {
minSteps = min(minSteps, steps);
return;
}
// 剪枝：如果当前路径已不可能比最优路径短
if (steps >= minSteps) return;
vd[x][y] = false; // 标记为访问
for (auto [dx, dy] : dir) {
int nx = x + dx;
int ny = y + dy;
DFS(grid, vd, nx, ny, Xt, Yt, steps + 1, n, m);
}
vd[x][y] = true; // 回溯，恢复访问状态
}
int main()
{
int n, m;
cin >> n >> m;
int Xs, Ys, Xt, Yt;
cin >> Xs >> Ys >> Xt >> Yt;
vector<vector<string>> grid(n + 1, vector<string>(m + 1, "*"));
vector<vector<bool>> vd(n + 1, vector<bool>(m + 1, true));
for (int i = 1; i <= n; ++i)
{
string row;
cin >> row;
for (int j = 1; j <= m; ++j)
{
grid[i][j] = row[j - 1];
if (grid[i][j] == "*") vd[i][j] = false;
}
}
DFS(grid, vd, Xs, Ys, Xt, Yt, 0, n, m);
cout << (minSteps == INT_MAX ? -1 : minSteps) << endl;
return 0;
}
BFS 是天然适合找最短路径的算法，尤其在无权图中，
#include <bits/stdc++.h>
using namespace std;
// 四个方向：上 下 左 右
vector<pair<int, int>> dir = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
// BFS：计算从 (Xs, Ys) 到 (Xt, Yt) 的最短路径
int BFS(const vector<vector<string>>& grid, vector<vector<bool>>& vd, int Xs, int Ys, int Xt, int Yt, int n, int m)
{
queue<pair<int, int>> q; // 队列用于 BFS
vector<vector<int>> dist(n + 1, vector<int>(m + 1, -1)); // 记录最短距离，全初始化为-1
q.push({Xs, Ys}); // 起点入队
vd[Xs][Ys] = false; // 起点标记为已访问
dist[Xs][Ys] = 0; // 起点距离:呆在原地，为 0步
while (!q.empty())// 如果队列不为空，还有可遍历的元素，意味着没走完
{
auto [x, y] = q.front(); // c++17新语法，结构化绑定，把pair的first给x，second给y
q.pop();
if (x == Xt && y == Yt) return dist[x][y];// 到达终点，返回距离
// 遍历四个方向
for (auto [dx, dy] : dir)
{
int nx = x + dx, ny = y + dy;
// 判断是否越界、未访问、非障碍
if (nx >= 1 && nx <= n && ny >= 1 && ny <= m &&
vd[nx][ny] && grid[nx][ny] == ".")
{
vd[nx][ny] = false; // 标记为不用再访问
dist[nx][ny] = dist[x][y] + 1; // 在之前统计步数的基础上更新距离
q.push({nx, ny}); // 将新位置入队
}
}
}
return -1; // 循环结束都没return终点的dist，证明无法到达终点
}
int main()
{
int n, m, Xs, Ys, Xt, Yt;
cin >> n >> m >> Xs >> Ys >> Xt >> Yt;
// grid 存地图，vd 表示是否未访问
vector<vector<string>> grid(n + 1, vector<string>(m + 1));
vector<vector<bool>> vd(n + 1, vector<bool>(m + 1, true));
// 输入
for (int i = 1; i <= n; ++i)
{
string row; cin >> row;
for (int j = 1; j <= m; ++j)
{
grid[i][j] = row[j - 1];
if (grid[i][j] == "*") vd[i][j] = false; // 遇到障碍，不能访问
}
}
// 输出从起点到终点的最短距离
cout << BFS(grid, vd, Xs, Ys, Xt, Yt, n, m) << endl;
return 0;
}
搜索算法的整体思路都比较简单，难点在于代码的实现，要反复多写写，多练习，注意各种细节，考试面试的时候才能不怯
Topic 3：主持人调度(二)(贪心，堆性质)
之前做过调度一，首先还是按活动开始时间排序，然后采用priority_queue，做个小根堆排序，遍历总时间表，与堆中的活动结束时间相比较，结束时间<下一场开始时间则一个主持人就能搞定，否则就新增主持人来做，之后循环统计主持人最后一场活动的结束时间来比较，输出priority_queue的size就是所需主持人数量
#include <bits/stdc++.h>
using namespace std;
class Solution
{
// struct compare
// {
// bool operator()(vector<int>& x, vector<int>& y)
// {
// return x[0] < y[0];
// }
// };
public:
int minmumNumberOfHost(int n, vector<vector<int> >& startEnd)
{
//sort(startEnd.begin(), startEnd.end(), compare());// 自己写个仿函数通过活动开始时间来排序
//当然这里用lambda来写更好
sort(startEnd.begin(), startEnd.end(), [](const vector<int>& x, const vector<int>& y) {
return x[0] < y[0];
});
// 小根堆，保存每个主持人当前正在进行活动的结束时间
priority_queue<int, vector<int>, greater<int>> minHeap;
for (int i = 0; i < n; ++i)
{
int start = startEnd[i][0];
int end = startEnd[i][1];
// 如果有主持人可以接下一个活动（他之前的活动已经结束）
if (!minHeap.empty() && minHeap.top() <= start)
{
minHeap.pop(); // 当前最早结束的主持人空出来了
}
// 分配当前活动，增加主持人，并记录要忙到 end 时间
minHeap.push(end);
}
return minHeap.size();// 堆中主持人的数量就是最少主持人数
}
};
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
