C++ 算法竞赛STL以及常见模板
目录
STL
/*═══════════════ Vector ═══════════════*/
/*════════════════ Pair ════════════════*/
/*══════════════ String ════════════════*/
/*══════════════ Queue ═════════════════*/
/*═════════ Priority Queue ════════════*/
/*═══════════════ Stack ════════════════*/
/*════════════════ Set ═════════════════*/
/*════════════════ Map ═════════════════*/
/*════════════ Algorithm ══════════════*/
/*═════════════ 竞赛技巧 ═══════════════*/
其他算法
DFS BFS
试除法求所有约数
快速排序算法模板
Dp
高精度除以低精度
埃氏筛
并查集
试除法求所有约数
位运算
gcd() / lcm()
STL
/*═══════════════ Vector ═══════════════*/
● size(): v.size() // 元素数量
● empty(): if (v.empty()) // 判空
● clear(): v.clear() // 清空
● front / back: v.front() = 5; v.back() = 10;
● push_back / pop_back: v.pb(1); v.pop_back();
● []: v[0] = 5; // 随机访问
● 迭代器: for (auto it = v.begin(); it != v.end(); ++it)
▲ 例子：
vector<int> v {1,2,3}; // 初始化
v.reserve(100); // 预分配
v.pb(4); // 添加元素
sort(all(v)); // 排序
v.erase(unique(all(v)), v.end()); // 去重
--------------------------------------------------------------------
vector<int> ssr(10, 10086);//（长度，数值）
ssr.push_back(1);//开销大
ssr.pop_back();//删除尾部
ssr.clear();
ssr.empty();
ssr.size();//返回size_t,在相乘可能溢出
int num1=100;
ssr.resize(num1);//大补0，小就删
//一些如条件限制n*m的题目，用普通数组不好判断大小，就要使用vector限制
vector<vector<int> > ssr1(100, vector<int>());//行，列
for (auto& tonum : ssr)//auto
{
cout << tonum << endl;
}
/*════════════════ Pair ════════════════*/
● first / second: pair<int, string> p = { 1, "a" }; p.first++;
● 比较运算: if (p1 < p2) // 先比first后second
▲ 例子：
pair<int, int> a {3,4}, b
{ 3,5};
cout << (a < b); // 输出1（3相等，比较4<5）
--------------------------------------------------------------------
int num[10] = { 1,2,3,4,5,6,7,8,9,10 };
reverse(num, num + 10);
for (int tonum : num)
{
cout << tonum << endl;
}
pair<int, int> par1 = make_pair(1, 2);
pair<int, int> par2 = { 1,2 };
if (par1 == par2)
{
cout << "YES" << endl;
}
/*══════════════ String ════════════════*/
● substr(3, 2): s.substr(3, 2) // 从下标3取2字符
● c_str(): printf("%s", s.c_str());
● find: if (s.find("abc") != string::npos)
▲ 例子：
string s = "ABCDEF";
cout << s.substr(1, 3); // 输出"BCD"
s += to_string(123); // 拼接字符串
--------------------------------------------------------------------
string s1(10, '0');//第一个个数，第二个赋值
string s2(10, '1');
s1[0] = '1';
string s3 = "12345678";
//out << s1 + s2 << endl;
cout << s3.substr(3,2) << endl;//第一个定位从下标3开始，第二个是子串长度，用来截取子串
if (s1.find("101")!=string::npos)
{
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
cout << (s1.find(100)) << endl;
s1.find(100);
int ssr = stoi(s1);
string s = to_string(ssr);
//注意，尾接字符串用+=
//find效率不高
/*══════════════ Queue ═════════════════*/
● push: q.push(1);
● front / back: int x = q.front();
● pop: q.pop(); // 弹出队头
▲ 例子：
queue<int> q;
q.push(1); q.push(2);
cout << q.front(); // 1
q.pop(); // 队列变[2]
--------------------------------------------------------------------
queue <int> quq;
quq.size();
quq.empty();
quq.push(11);
quq.push(22);
quq.push(33);
cout << quq.front() << " " << quq.back() << endl;
/*═════════ Priority Queue ════════════*/
● 大根堆: priority_queue<int> pq; pq.push(3);
● 小根堆: priority_queue<int, vector<int>, greater<>> pq;
● top / pop: int x = pq.top(); pq.pop();
▲ 例子：
pq.push(2); pq.push(1);
cout << pq.top(); // 大根堆输出2，小根堆输出1
--------------------------------------------------------------------
struct game
{
int year;
int money;
};
struct compare_outbig {
bool operator()(const game& game1, const game& game2)
{
return game1.money < game2.money;//钱少的在堆下，多的在顶部，输出最大的
}
};
struct compare_outsmall {
bool operator()(const game& game1, const game& game2)
{
return game1.money > game2.money;//钱多的在堆下，少的在顶部，输出最小的
}
};
int solve1() {
priority_queue<int> out_big;
priority_queue<int, vector<int>, greater<int> >out_small;
priority_queue<game, vector<game>, compare_outbig> struct_out_big;
priority_queue<game, vector<game>, compare_outsmall>struct_out_small;
int n=1;
while(n)
{
cin >> n;
out_big.push(n);
out_small.push(n);
}
cout << "out_big" << endl;
while (!out_big.empty())
{
cout << out_big.top() << endl;
out_big.pop();
}
cout << "out_small" << endl;
while (!out_small.empty())
{
cout << out_small.top() << endl;
out_small.pop();
}
int m = 1;
while (m)
{
cin >> n >> m;
game sample1;
sample1.year = n;
sample1.money = m;
struct_out_big.push(sample1);
struct_out_small.push(sample1);
}
cout << "struct_out_big" << endl;
while (!struct_out_big.empty())
{
game sample1 = struct_out_big.top();
cout <<"game_money:"<< sample1.money <<"game_:" <<sample1.year << endl;
struct_out_big.pop();
}
cout << "struct_out_small" << endl;
while (!struct_out_small.empty())
{
game sample1 = struct_out_small.top();
cout << "game_money:" << sample1.money << "game_:" << sample1.year << endl;
struct_out_small.pop();
}
/*═══════════════ Stack ════════════════*/
● push: stk.push(10);
● top: int x = stk.top();
● pop: stk.pop();
▲ 例子：
stack<int> s;
s.push(1); s.push(2);
cout << s.top(); // 2
s.pop(); // 栈变[1]
--------------------------------------------------------------------
stack<int> stk;
//我用的比较少，不如直接用vector
stk.push(111);
stk.push(222);
stk.push(333);
cout << stk.size() << endl;
stk.empty();
/*for (auto& tonum : stk) //不可以直接访问
cout << tonum <<endl;*/
cout<<stk.top();
stk.pop();
cout<<stk.top();
/*════════════════ Set ═════════════════*/
● insert: s.insert(3);
● find: if (s.find(3) != s.end())
● lower_bound: auto it = s.lower_bound(2);
▲ 例子：
set<int> s {3,1,2};
cout << *s.lower_bound(2); // 2
s.erase(2); // 删除元素
--------------------------------------------------------------------
//一个集合,在找特别分散但是数量不多的数字特别好用
//set 一个元素要么在集合中，要么不在，出现一次，有序，默认从小到大
//multiset 一个元素要么在集合中，要么不在，可以出现多次，有序，默认从小到大
//unordered_set 一个元素要么在集合中，要么不在，出现一次，无序
set<int> st;
set<int, greater<int> >st1;//从大到小
//通用st.size();st.clear();st.empty();
st.insert(1);
st.insert(2);
st.insert(1);
for (auto& tonum : st)
{
cout << tonum << endl;
}
//for(set<int>::iterator it=st.begin();it!=st.end();++it)cout<<*it<<endl;
st.erase(1);
cout << st.count(1)<<endl;
cout << st.count(2) << endl;
auto so = st.find(2);//返回迭代器
cout << *so;
//unorder_set<int> st2 无序
//multiset_set<int> st3 多个数
/*════════════════ Map ═════════════════*/
● 插入: mp["key"] = 5; 或 mp.insert({ "key",5});
● 遍历: for (auto &[k, v] : mp)
▲ 例子：
map<string, int> mp;
mp["apple"] = 3;
if (mp.count("apple")) cout << mp["apple"]; // 3
---------------------------------------------------------------------------
//一个映射,
//map 一个元素仅出现一次，有序，默认从小到大
//multimap 一个元素可以出现多次，有序，默认从小到大
//unordered_map 一个元素仅出现一次，无序
map<string, int> mp1;
if (mp1.find("1") != mp1.end())
{
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
mp1.erase("1");
mp1.clear();
mp1["a"] = 1;
mp1["b"] = 2;
for (map<string, int>::iterator it = mp1.begin();it != mp1.end();it++)
{
cout << it->first << " " << it->second << endl;
}
for (auto &tonum : mp1)
{
cout << tonum.first << " " <<tonum.second<< endl;
}
/*════════════ Algorithm ══════════════*/
● sort: sort(all(v), greater<>()); // 降序
● reverse: reverse(all(v));
● unique: v.erase(unique(all(v)), v.end());
● lower_bound: int pos = lower_bound(all(v), 5) - v.begin();
▲ 例子：
vector<int> v {3,1,4,1};
sort(all(v)); // [1,1,3,4]
auto it = lower_bound(all(v), 2); // 指向3
/*═════════════ 竞赛技巧 ═══════════════*/
▲ 加速cin: ios::sync_with_stdio(0); cin.tie(0);
▲ 宏:
#define all(x) (x).begin(), (x).end()
▲ 位运算: cout << __builtin_ctz(8); // 3（末尾0个数）
其他算法
DFS BFS
/*═══════════════ DFS 核心模板 ═══════════════*/
// 递归式（适用：排列/组合/树遍历）
void dfs(当前状态)
{
if (终止条件)
{
记录结果;
return;
}
for (所有分支选择)
{
if (剪枝条件) continue;
更新状态;
dfs(下一状态);
恢复状态; // 回溯
}
}
// 示例：矩阵搜索
int dx[] = { -1, 0, 1, 0 }, dy[] = { 0, 1, 0, -1 }; // 方向数组
void dfs(int x, int y, vector<vector<int>>& grid)
{
if (x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() || grid[x][y] == 0)
return;
grid[x][y] = 0; // 标记访问
for (int i = 0; i < 4; ++i)
dfs(x + dx[i], y + dy[i], grid);
}
/*═══════════════ BFS 核心模板 ═══════════════*/
// 标准层序（适用：最短路径/扩散问题）
int bfs(起始状态)
{
queue<StateType> q;
unordered_set<StateType> vis; // 或二维vis数组
q.push(初始状态);
vis.insert(初始状态);
int step = 0;
while (!q.empty())
{
int sz = q.size();
for (int i = 0; i < sz; ++i)
{ // 层序遍历关键
auto cur = q.front(); q.pop();
if (终止条件) return step;
for (所有扩展状态)
{
if (!vis.count(新状态))
{
vis.insert(新状态);
q.push(新状态);
}
}
}
step++;
}
return -1; // 未找到
}
// 示例：二叉树层序遍历
vector<vector<int>> bfs(TreeNode* root)
{
queue<TreeNode*> q;
vector<vector<int>> res;
if (root) q.push(root);
while (!q.empty())
{
res.push_back({ });
for (int i = q.size(); i > 0; --i)
{
auto node = q.front(); q.pop();
res.back().push_back(node->val);
if (node->left) q.push(node->left);
if (node->right) q.push(node->right);
}
}
return res;
}
/*═══════════════ 高频变种与优化 ═══════════════*/
// 双向BFS模板（优化搜索空间）
int twoWayBFS(begin, end)
{
unordered_set<State> q1{ begin}, q2{ end}, visited{ begin};
int step = 0;
while (!q1.empty() && !q2.empty())
{
if (q1.size() > q2.size()) swap(q1, q2); // 扩展较小队列
unordered_set<State> temp;
for (auto cur : q1) {
for (新状态 : 生成下一状态(cur))
{
if (q2.count(新状态)) return step + 1; // 相遇
if (!visited.count(新状态))
{
visited.insert(新状态);
temp.insert(新状态);
}
}
}
q1 = temp;
step++;
}
return -1;
}
// 记忆化DFS（树形DP/剪枝）
vector<int> memo; // memo数组记录中间结果
int dfs(State s)
{
if (终止条件) return 0;
if (memo[s] != -1) return memo[s];
int res = 初始值;
for (所有子问题)
{
res = max / min(res, dfs(子状态) + 增量计算);
}
return memo[s] = res;
}
/*═══════════════ 参数说明与替换指南 ═══════════════*/
■ 状态表示：
-矩阵问题：pair<int, int> 坐标 或 压缩为int编码
- 树问题：TreeNode* 节点指针
- 图问题：节点编号int
■ 终止条件：根据题意调整判断位置
- 在BFS弹出时判断（保证最短路径）
- 在DFS递归入口判断（允许完整路径记录）
■ 状态扩展：
- 树：left/right子节点
- 图：邻接表遍历
- 矩阵：方向数组遍历
■ 记录路径：
- BFS：使用pre数组记录前驱节点
- DFS：用path数组记录当前路径
快速幂
求 m^k mod p，时间复杂度 O(logk)。
int qmi(int m, int k, int p)
{
int res = 1 % p, t = m;
while (k)
{
if (k&1) res = res * t % p;
t = t * t % p;
k >>= 1;
}
return res;
}
线性筛法求素数
int primes[N], cnt; // primes[]存储所有素数
bool st[N]; // st[x]存储x是否被筛掉
void get_primes(int n)
{
for (int i = 2; i <= n; i ++ )
{
if (!st[i]) primes[cnt ++ ] = i;
for (int j = 0; primes[j] <= n / i; j ++ )
{
st[primes[j] * i] = true;
if (i % primes[j] == 0) break;
}
}
}
试除法求所有约数
vector<int> get_divisors(int x)
{
vector<int> res;
for (int i = 1; i <= x / i; i ++ )
if (x % i == 0)
{
res.push_back(i);
if (i != x / i) res.push_back(x / i);
}
sort(res.begin(), res.end());
return res;
}
快速排序算法模板
void quick_sort(int q[], int l, int r)
{
if (l >= r) return;
int i = l - 1, j = r + 1, x = q[l + r >> 1];
while (i < j)
{
do i ++ ; while (q[i] < x);
do j -- ; while (q[j] > x);
if (i < j) swap(q[i], q[j]);
}
quick_sort(q, l, j), quick_sort(q, j + 1, r);
}
Dp
/*════════════ 动态规划核心模板 ════════════*/
// === 一维线性DP ===
// 例：斐波那契/爬楼梯
vector<int> dp(n+1, 0);
dp[0] = 1; dp[1] = 1;
for (int i = 2; i <= n; ++i)
dp[i] = dp[i - 1] + dp[i - 2];
// === 二维矩阵DP ===
// 例：最小路径和/最长公共子序列
vector<vector<int>> dp(m, vector<int>(n, 0));
for (int i = 0; i < m; ++i)
for (int j = 0; j < n; ++j)
dp[i][j] = grid[i][j] + min(dp[i - 1][j], dp[i][j - 1]);
// === 01背包问题 ===
vector<int> dp(cap+1, 0);
for (int i = 0; i < n; ++i)
for (int j = cap; j >= w[i]; --j)
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
// === 完全背包问题 ===
vector<int> dp(cap+1, 0);
for (int i = 0; i < n; ++i)
for (int j = w[i]; j <= cap; ++j)
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
// === 区间DP ===
// 例：最长回文子序列
vector<vector<int>> dp(n, vector<int>(n, 0));
for (int len = 2; len <= n; ++len)
for (int i = 0; i + len - 1 < n; ++i)
{
int j = i + len - 1;
if (s[i] == s[j]) dp[i][j] = dp[i + 1][j - 1] + 2;
else dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
}
// === 状态压缩DP ===
// 例：TSP问题
vector<vector<int>> dp(1<<n, vector<int>(n, INF));
dp[1][0] = 0; // 从0号点出发
for (int mask = 1; mask < (1 << n); ++mask)
for (int u = 0; u < n; ++u)
if (mask & (1 << u))
for (int v = 0; v < n; ++v)
if (!(mask & (1 << v)))
dp[mask | (1 << v)][v] = min(dp[mask | (1 << v)][v], dp[mask][u] + g[u][v]);
// === 树形DP（记忆化）===
// 例：打家劫舍III
unordered_map<TreeNode*, int> memo;
function < int(TreeNode *) > dfs = [&](TreeNode * root) {
if (!root) return 0;
if (memo.count(root)) return memo[root];
int rob = root->val + dfs(root->left->left) + dfs(...);
int not_rob = dfs(root->left) + dfs(root->right);
return memo[root] = max(rob, not_rob);
};
/*═══════════ 优化技巧 ═══════════*/
// 空间优化：滚动数组（fib用prev,curr变量）
// 降维：背包问题压至一维（注意遍历顺序）
// 剪枝：提前终止无效状态
// 记忆化：unordered_map记录子问题
// 预处理：排序/前缀和加速状态转移
高精度除以低精度
// A / b = C ... r, A >= 0, b > 0
vector<int> div(vector<int> &A, int b, int &r)
{
vector<int> C;
r = 0;
for (int i = A.size() - 1; i >= 0; i -- )
{
r = r * 10 + A[i];
C.push_back(r / b);
r %= b;
}
reverse(C.begin(), C.end());
while (C.size() > 1 && C.back() == 0) C.pop_back();
return C;
}
埃氏筛
#include<bits/stdc++.h>
using namespace std;
bool is_prime[100005];
//true表示是质数
//false表示不是质数
int main()
{
memset(is_prime, true, sizeof(is_prime));
int n;
cin >> n;
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= sqrt(n); i++)
{
if (is_prime[i])
{
for (int j = 2; i * j <= n; j++)
{
is_prime[i * j] = false;
}
}
}
//x 是不是质数
if (is_prime[n]) cout << "is_prime";
else cout << "not_prime";
return 0;
}
并查集
const int N=1005 // 指定并查集所能包含元素的个数（由题意决定）
int pre[N]; // 存储每个结点的前驱结点
int rank[N]; /*非必要 */ // 树的高度
void init(int n) // 初始化函数，对录入的 n 个结点进行初始化
{
for(int i = 0; i < n; i++){
pre[i] = i; // 每个结点的上级都是自己
rank[i] = 1; // 每个结点构成的树的高度为 1
}
}
int find(int x) // 改进查找算法：完成路径压缩，将 x 的上级直接变为根结点，那么树的高度就会大大降低
{
if(pre[x] == x) return x; // 递归出口：x 的上级为 x 本身，即 x 为根结点
return pre[x] = find(pre[x]); // 此代码相当于先找到根结点 rootx，然后 pre[x]=rootx
}
bool isSame(int x, int y) // 判断两个结点是否连通
{
return find(x) == find(y); // 判断两个结点的根结点（即代表元）是否相同
}
bool join(int x,int y)
{
x = find(x); // 寻找 x 的代表元
y = find(y); // 寻找 y 的代表元
if(x == y) return false; // 如果 x 和 y 的代表元一致，说明他们共属同一集合，则不需要合并，返回 false，表示合并失败；否则，执行下面的逻辑
if(rank[x] > rank[y]) pre[y]=x; // 如果 x 的高度大于 y，则令 y 的上级为 x
else // 否则
{
if(rank[x]==rank[y]) rank[y]++; // 如果 x 的高度和 y 的高度相同，则令 y 的高度加1
pre[x]=y; // 让 x 的上级为 y
}
return true; // 返回 true，表示合并成功
}
试除法求所有约数
vector<int> get_divisors(int x)
{
vector<int> res;
for (int i = 1; i <= x / i; i ++ )
if (x % i == 0)
{
res.push_back(i);
if (i != x / i) res.push_back(x / i);
}
sort(res.begin(), res.end());
return res;
}
位运算
求n的第k位数字: n >> k & 1
返回n的最后一位1：lowbit(n) = n & -n
gcd() / lcm()
（C++17）返回最大公因数 / 最小公倍数
int x = gcd(8, 12); // 4int y = lcm(8, 12); // 24
- lower_bound(): 寻找 ≥ 的第一个元素的位置
- upper_bound(): 寻找 > 的第一个元素的位置
vector<int> arr {0, 1, 1, 1, 8, 9, 9};
idx = lower_bound(arr.begin(), arr.end(), 7) - arr.begin(); // 4
idx = lower_bound(arr.begin(), arr.end(), 8) - arr.begin(); // 4
idx = upper_bound(arr.begin(), arr.end(), 7) - arr.begin(); // 4
idx = upper_bound(arr.begin(), arr.end(), 8) - arr.begin(); // 5
next_permutation(a,a+n)全排列函数，a为数组首地址，执行一次往下排列一次，不能排之后返回false。
优先队列priority_queue<int,vector<int>,greater<int> >p;//总是输出小的p.top()
priority_queue<int> p//总是输出大的p.top()输出方法
priority_queue<string,vector<string>,cmp> q;
struct cmp {
bool operator()(const string& s1, const string& s2) {
return s1 < s2; // 倒序排列
}
};
无序集合unordered_set<int>(candyType.begin(),candyType.end()).size();//求candytype数组中数据种类
for (int i = 0; i < n; i++) {
if (intSet.find(arr[i]) == intSet.end())//如果find不到就返回end()
intSet.insert(arr[i]);
else
duplicate.insert(arr[i]);
}
相关文章：
C++ 算法竞赛STL以及常见模板
目录 STL /*═══════════════ Vector ═══════════════*/ /*════════════════ Pair ════════════════*/ /*══════════════ String ════════════════*/ /*══════════…...
微信小程序将markdown内容转为pdf并下载
要在微信小程序中将Markdown内容转换为PDF并下载，您可以使用以下方法： 方法一：使用第三方API服务 选择第三方API服务： 可以选择像 Pandoc、Markdown-PDF 或 PDFShift 这样的服务，将Markdown转换为PDF。例如，PDFShift 提供了一个API接口，可以将Markdown内容转换为PDF格式…...
AI绘画软件Stable Diffusion详解教程（7）：图生图基础篇（改变图像风格）
我们在使用AI魔盒不停的绘制一幅幅图像时，会有这样的疑问：为什么生成的图像随机性这么强？我们如何按照自己的构图创作作品？为什么提示词生成的图像细节不够？如何把手绘的风格转换成另一种风格，或者说把自己…...
ES映射知识
映射 映射类似于关系型数据库的Schema（模式）。 映射来定义字段列和存储的类型等基础信息。 {"mappings": {"properties": {"username": {"type": "keyword","ignore_above": 256 // 忽略…...
蓝桥杯嵌入式组第七届省赛题目解析+STM32G431RBT6实现源码
文章目录 1.题目解析1.1 分而治之，藕断丝连1.2 模块化思维导图1.3 模块解析1.3.1 KEY模块1.3.2 ADC模块1.3.3 IIC模块1.3.4 UART模块1.3.5 LCD模块1.3.6 LED模块1.3.7 TIM模块 2.源码3.第七届题目 前言：STM32G431RBT6实现嵌入式组第七届题目解析源码&…...
SpringBoot项目配置文件
SpringBoot项目提供了多种属性配置方式（properties、yaml、yml） yml配置文件 使用Apifox可以方便开发接口、前端测试等 工程搭建： 1.创建SpringBoot工程，并引入web开发起步依赖、mybatis、mysql驱动、lombok 2.创建数据库表&am…...
PythonWeb开发框架—Flask框架之flask-sqlalchemy、序列化和反序列化使用详解
1.安装依赖库 pip install flask-sqlalchemy pip install pymysql 2.连接数据库配置 from flask import Flask from flask_sqlalchemy import SQLAlchemyapp Flask(__name__) #创建 Flask 应用实例#配置数据库连接 app.config[SQLALCHEMY_DATABASE_URI]mysql://root:stud…...
如何监控 Pod 的 CPU/内存使用率，prometheus+grafana
一、监控 Pod 的 CPU/内存使用率的方法 1. 使用 kubectl top 命令（临时检查） # 查看所有 Pod 的资源使用率（需安装 Metrics Server） kubectl top pods --all-namespaces # 查看指定命名空间的 Pod kubectl top pods -n <n…...
Spring Batch 概览
Spring Batch 是什么？ Spring Batch 是 Spring 生态系统中的一个轻量级批处理框架，专门用于处理大规模数据任务。它特别适合企业级应用中需要批量处理数据的场景，比如数据迁移、报表生成、ETL（Extract-Transform-Load）…...
用Deepseek写一个五子棋微信小程序
在当今快节奏的生活中，休闲小游戏成为了许多人放松心情的好选择。五子棋作为一款经典的策略游戏，不仅规则简单，还能锻炼思维。最近，我借助 DeepSeek 的帮助，开发了一款五子棋微信小程序。在这篇文章中，我将…...
AF3 squeeze_features函数解读
AlphaFold3 data_transforms 模块的 squeeze_features 函数的作用去除 蛋白质特征张量中不必要的单维度（singleton dimensions）和重复维度，以使其适配 AlphaFold3 预期的输入格式。 源代码： def squeeze_features(protein):&qu…...
Python 远程抓取服务器日志最后 1000行
哈喽，大家好，我是木头左！ 一、神奇的 Python 工具箱 1. SSH 连接的密钥——paramiko paramiko 库提供了丰富的方法来处理 SSH 连接的各种细节。从创建连接对象，到执行远程命令，再到获取命令输出，它都能有…...
vue3+screenfull实现部分页面全屏（遇到的问题会持续更新）
需求：除了左侧菜单，右侧主体部分全部全屏 首先下载screenfull全屏插件 npm install screenfull --save页面引入 import screenfull from screenfull;我这里是右上角全屏图标 <el-iconref"elIconRef"color"#ffffff"size"2…...
)
Ubuntu 下 nginx-1.24.0 源码分析 (1)
main 函数在 src\core\nginx.c int ngx_cdecl main(int argc, char *const *argv) {ngx_buf_t *b;ngx_log_t *log;ngx_uint_t i;ngx_cycle_t *cycle, init_cycle;ngx_conf_dump_t *cd;ngx_core_conf_t *ccf;ngx_debug_init(); 进入 main 函数 最…...
2025数据存储技术风向标：解析数据湖与数据仓库的实战效能差距
一、技术演进的十字路口 当前全球数据量正以每年65%的复合增长率激增，IDC预测到2027年企业将面临日均处理500TB数据的挑战。在这样的背景下，传统数据仓库与新兴数据湖的博弈进入白热化阶段。Gartner最新报告显示，采用混合架构的企业数据运营效…...
探索高性能AI识别和边缘计算 | NVIDIA Jetson Orin Nano 8GB 开发套件的全面测评
随着边缘计算和人工智能技术的迅速发展，性能强大的嵌入式AI开发板成为开发者和企业关注的焦点。NVIDIA近期推出的Jetson Orin Nano 8GB开发套件，凭借其40 TOPS算力、高效的Ampere架构GPU以及出色的边缘AI能力，引起了广泛关注。本文将从配置性…...
数据结构 常见的排序算法
🌻个人主页：路飞雪吖~ 🌠专栏：数据结构 目录 🌻个人主页：路飞雪吖~ 一、插入排序 🌟直接插入排序 🌟希尔排序 二、选择排序 🌟选择排序 🌟堆排序…...
ES索引知识
索引是数据的载体，存储了文档和映射的信息 索引是具有相同结构的文档的合集体。 设置索引，不仅仅是设置索引名字，还有索引的一些配置，比如：分片和副本，刷新频率，搜索结果的最大参数，…...
FreeRTOS第17篇：FreeRTOS链表实现细节05_MiniListItem_t：FreeRTOS内存优化
文/指尖动听知识库-星愿 文章为付费内容，商业行为，禁止私自转载及抄袭，违者必究！！！ 文章专栏：深入FreeRTOS内核：从原理到实战的嵌入式开发指南 1 为什么需要迷你列表项？ 在嵌入式系统中，内存资源极其宝贵。FreeRTOS为满足不同场景需求，设计了标准列表项（ListItem_…...
Golang | Gin（简洁版）
文章目录 安装使用RESTful API响应页面获取请求参数路由讲解中间件 安装使用 Gin 是一个 golang 的微框架，封装比较优雅，API 友好，源代码比较明确。具有快速灵活，容错方便等特点。其实对于 golang 而言，web 框架的依赖…...
css实现圆环展示百分比，根据值动态展示所占比例
代码如下 <view class""><view class"circle-chart"><view v-if"!!num" class"pie-item" :style"{background: conic-gradient(var(--one-color) 0%,#E9E6F1 ${num}%),}"></view><view v-else …...
【OSG学习笔记】Day 18: 碰撞检测与物理交互
物理引擎（Physics Engine） 物理引擎 是一种通过计算机模拟物理规律（如力学、碰撞、重力、流体动力学等）的软件工具或库。 它的核心目标是在虚拟环境中逼真地模拟物体的运动和交互，广泛应用于 游戏开发、动画制作、虚…...
【Oracle APEX开发小技巧12】
有如下需求： 有一个问题反馈页面，要实现在apex页面展示能直观看到反馈时间超过7天未处理的数据，方便管理员及时处理反馈。 我的方法：直接将逻辑写在SQL中，这样可以直接在页面展示 完整代码： SELECTSF.FE…...
连锁超市冷库节能解决方案：如何实现超市降本增效
在连锁超市冷库运营中，高能耗、设备损耗快、人工管理低效等问题长期困扰企业。御控冷库节能解决方案通过智能控制化霜、按需化霜、实时监控、故障诊断、自动预警、远程控制开关六大核心技术，实现年省电费15%-60%，且不改动原有装备、安装快捷、…...
【AI学习】三、AI算法中的向量
在人工智能（AI）算法中，向量（Vector）是一种将现实世界中的数据（如图像、文本、音频等）转化为计算机可处理的数值型特征表示的工具。它是连接人类认知（如语义、视觉特征）与…...
[Java恶补day16] 238.除自身以外数组的乘积
给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。 题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。 请 不要使用除法，且在 O(n) 时间复杂度…...
docker 部署发现spring.profiles.active 问题
报错： org.springframework.boot.context.config.InvalidConfigDataPropertyException: Property spring.profiles.active imported from location class path resource [application-test.yml] is invalid in a profile specific resource [origin: class path re…...
Go 语言并发编程基础：无缓冲与有缓冲通道
在上一章节中，我们了解了 Channel 的基本用法。本章将重点分析 Go 中通道的两种类型 —— 无缓冲通道与有缓冲通道，它们在并发编程中各具特点和应用场景。 一、通道的基本分类 类型定义形式特点无缓冲通道make(chan T)发送和接收都必须准备好࿰…...
Go 并发编程基础：通道（Channel）的使用
在 Go 中，Channel 是 Goroutine 之间通信的核心机制。它提供了一个线程安全的通信方式，用于在多个 Goroutine 之间传递数据，从而实现高效的并发编程。 本章将介绍 Channel 的基本概念、用法、缓冲、关闭机制以及 select 的使用。 一、Channel…...
热烈祝贺埃文科技正式加入可信数据空间发展联盟
2025年4月29日，在福州举办的第八届数字中国建设峰会“可信数据空间分论坛”上，可信数据空间发展联盟正式宣告成立。国家数据局党组书记、局长刘烈宏出席并致辞，强调该联盟是推进全国一体化数据市场建设的关键抓手。 郑州埃文科技有限公司&am…...