常用算法思想及模板

今天继续整理一些关于算法竞赛中C++适用的一些模板以及思想。

保留x位小数

保留x位小数在C语言中可以使用printf中的"%.xf"来实现，但是很多C++选手由于关闭了同步流，害怕cin、cout与scanf、printf混用容易出错，所以就给大家介绍一个强制保留x位小数的代码格式。

cout<<fixed<<setprecision(x)<<（浮点型变量）;

其中的x可以根据题目中的要求更改，接下来看一道例题来对这个函数加深印象。

排队接水

题目链接：排队接水

排队接水问题是一个非常典型的贪心问题，其中贪心的过程就不过多赘述了，原则就是前面的人消耗的时间越多，后面所有人等待的时间就越多，所以要让耗时小的人在前面，这样来构成全局最优解。可以试想一下，同样是两个人，其中一个人需要1小时，另一个人需要10分钟，如果让耗时多的人先接水的话，总时间就是这个人的耗时 + 后面的人等待其接水的耗时 + 后面的人的耗时，所以要对耗时进行排序，根据贪心原则让耗时少的人先接水。

// Problem: P1223 排队接水
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P1223
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)#include <bits/stdc++.h>
using namespace std;
#define int long long 
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define fi first
#define se second
const int inf = 0x3f3f3f3f;void solve()
{int n;cin>>n;vector<pii> a(n+1);for(int i=1;i<=n;i++){cin>>a[i].fi;a[i].se = i;}sort(a.begin()+1,a.end());//贪心double sum = 0,ans=0;for(int i=1;i<=n;i++){cout<<a[i].se<<' ';if(i==n) break;//因为求的是等待时间 最后一个人不算sum += a[i].fi;ans += sum;}cout<<endl;//保留2位小数!cout<<fixed<<setprecision(2)<<ans/n;
}signed main()// Don't forget pre_handle!
{IOSint T=1;
//	cin>>T;while(T--) solve(); return 0;
}

最长上升子序列

最长上升子序列是dp的一类入门题目，我在前面的博客中有做过对一些常见的线性DP的题型、用法以及模板内容的介绍，对这一块不熟悉的小伙伴可以去看一下：线性DP，对于最长上升子序列，如果求的是长度，可以用遍历 + 二分的方式降低时间复杂度，而如果是需要求出具体的以每一个元素结尾的长度的话就需要用到双重循环来解决了（当然也可以用时间复杂度更低的单调队列来解决，单调队列我也有过总结，感兴趣的小伙伴也可以去看一下总结的模板：入门，推广 具体情况视题目而定），接下来看一道相关的题目。

合唱队形

这道题用到了正向和逆向双向相结合的思路，这种思想特别重要！很多像单调栈、最长子段和之类的题目也会用到这样的思想，对于这道题而言我们需要正向用一遍最长上升子序列求出以每个点结尾的最长上升子序列的长度，然后逆向再跑一遍求出以每个元素开头的最长下降子序列的长度，然后再遍历一遍每个元素求出最大值，就是一共可以留下来的人数，题目中要求的移除的人数只需用总人数减去留下的人数即可得出。

// Problem: P1091 [NOIP 2004 提高组] 合唱队形
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P1091
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)#include <bits/stdc++.h>
using namespace std;
#define int long long 
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define fi first
#define se second
const int inf = 0x3f3f3f3f;void solve()
{int n;cin>>n;vector<int> a(n+1);for(int i=1;i<=n;i++) cin>>a[i];int l[n+1],r[n+1];// for(int i=1;i<=n;i++) l[i] = 1,r[i] = 1;fill(l+1,l+1+n,1);fill(r+1,r+1+n,1);for(int i=2;i<=n;i++)//正序最长上升子序列{for(int j=1;j<i;j++)if(a[j] < a[i]) l[i] = max(l[i],l[j] + 1);}for(int i=n-1;i>=1;i--)//逆序最长上升子序列（正序最长下降子序列）{for(int j=n;j>i;j--)if(a[j] < a[i]) r[i] = max(r[i],r[j] + 1);}int mx = -inf;for(int i=1;i<=n;i++){mx = max(mx,r[i] + l[i] - 1);//减去重复计算的自己}cout<<n - mx<<endl;
}signed main()// Don't forget pre_handle!
{IOSint T=1;
//	cin>>T;while(T--) solve(); return 0;
}

归并排序

相信部分C++选手对排序并不感兴趣，因为STL中有自带的搞笑的sort排序，在nlogn的时间复杂度下满足了很多场景的需要，但是，归并排序的时间复杂度也是nlogn，而且有很多题型都用到了类似于归并排序中的分治思想，即将大问题转化为很多个小问题，然后通过对小问题的高效解决来使得总问题的解决的思想，其中较为典型的就是逆序对问题，这个问题就是在归并排序的合并过程中完成的！下面来回顾一下归并排序的代码以及对逆序对这一问题的高效求解。

逆序对

题目链接：逆序对

我们对逆序对的寻找不需要每次都遍历计数，而是可以先将集合分为两个部分，而这两个部分又是有序的两个集合，我们可以对两个集合的元素进行比较大小的同时用O(1)的方法计算逆序对的数量，在合并的过程中如果左边的集合中的元素小，直接将左边这个元素合并上去，反之如果左边的元素大，就应该将右边的元素合并上去，而此时左边剩余元素的数量就是以右边的这个较小的数位第二个数的逆序对的数量，所以能在归并排序合并过程的同时就将逆序对的数量进行统计了。代码如下所示：

// Problem: P1908 逆序对
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P1908
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)#include <bits/stdc++.h>
using namespace std;
#define int long long 
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define fi first
#define se second
const int inf = 0x3f3f3f3f;
const int N = 5e5+10;
vector<int> a(N,0),b(N,0);
int res=0;
void gb_sort(int l,int r)
{if(l >= r) return ;int mid = (l + r) >> 1;gb_sort(l,mid);gb_sort(mid+1,r);//分治过程int i=l,j=mid+1,k=l;//分治过程while(i <=mid && j <= r)//归并过程{if(a[i] <= a[j]) b[k++] = a[i++];else b[k++] = a[j++],res += mid - i + 1;}while(i <= mid) b[k++] = a[i++];//对剩余元素的处理while(j <= r) b[k++] = a[j++];//对剩余元素的处理for(int i=l;i<=r;i++) a[i] = b[i];//将排序后的数组保存
}
void solve()
{int n;cin>>n;for(int i=1;i<=n;i++) cin>>a[i];gb_sort(1,n);// for(int i=1;i<=n;i++) cout<<a[i]<<' ';cout<<res<<endl;
}signed main()// Don't forget pre_handle!
{IOSint T=1;
//	cin>>T;while(T--) solve(); return 0;
}

高精度运算

C/C++选手的痛！在蓝桥杯等一些赛事中经常出现，高精度和低精度之间的混合运算比较简单，正常模拟即可，我也有过总结，需要的小伙伴可以去主页拿。这里主要整理高精度乘高精度下的快速幂。

麦森数

题目链接：麦森数

这道题的数据范围比较大，不仅仅用到了高精度✖️高精度，还需要用快速幂来优化，因为是2的n次方所以就要想到了以2位初始值的快速幂，又因为数太大了（光看样例就已经很恐怖了）所以就又想到了高精度，这时候整体的代码思路就出来了，实现起来也不难，整理这道题的主要原因就是便于对之后的快速幂以及高精度算法模板的需要，有需要的小伙伴也可以保存起来以后备用。

// Problem: P1045 [NOIP 2003 普及组] 麦森数
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P1045
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)#include <bits/stdc++.h>
using namespace std;
#define int long long 
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define fi first
#define se second
const int inf = 0x3f3f3f3f;
const int N = 505;
vector<int> a(N,0),res(N,0);
void gjc_begin()
{int t=0,c=0;vector<int> temp(1010,0);for(int i=1;i<=500;i++){for(int j=1;j<=500;j++) temp[i+j-1] += a[i] * a[j];}for(int i=1;i<=500;i++){temp[i] += t;a[i] = temp[i] % 10;t = temp[i] / 10;}
}
void gjc_end()
{int t=0,c=0;vector<int> temp(1010,0);for(int i=1;i<=500;i++){for(int j=1;j<=500;j++) temp[i+j-1] += res[i] * a[j];}for(int i=1;i<=500;i++){temp[i] += t;res[i] = temp[i] % 10;t = temp[i] / 10;}
}
void ksm_plus(int x)
{while(x){if(x&1) gjc_end();gjc_begin();x >>= 1;}
}
void solve()
{int n;cin>>n;a[1] = 2,res[1] = 1;//快速幂的初始值位2 因为要求的是2的次方ksm_plus(n);int num=0;//数学公式直接计算2^n的位数cout<<(int)(n*log10(2) + 1)<<endl;int cnt=0;int t = 1;while(res[t] == 0)//对最后的 -1 操作进行计算{res[t] = 9;t++;}res[t]--;for(int i=500;i>0;i--){cout<<res[i];cnt++;if(cnt == 50){cout<<endl;cnt = 0;}}
}signed main()// Don't forget pre_handle!
{IOSint T=1;
//	cin>>T;while(T--) solve(); return 0;
}

求位数的高效方法

求x的位数相信很很堵人都会了，用 (int)log10(x) + 1即可，也可转为字符串求长度。

这道题还需要用到的数学知识就是2的n次方的位数，如果用模拟法计算的话还需要用到高精度算法，而如果使用数学方法的话就很方便了，而且时间复杂度也不高，具体实现公式为：

(int)(n*log10(2) + 1)

倍增法

倍增法也是一个常用的算法，其中在求最近共同祖先的时候最为有用，可以将每次的O(N)时间复杂度的查询压缩至单次O(logN)的时间复杂度，适用于多次查询最近共同祖先(LCA)的情况，具体思路如下：其中数组f[n][m]表示n的第2^m级祖先， 最重要的是在dfs求深度时对倍增ST表进行预处理

 图中左侧位预处理阶段，右侧为查询LCA阶段。

LCA最近共同祖先

题目链接：LCA最近共同祖先【模板】

为了方便之后对这一块模板代码的内容进行整理，所以我在这里用一个模版题来对倍增法求LCA做一个记录，如果之后有需要的话可以参考这个模板。

// Problem: P3379 【模板】最近公共祖先（LCA）
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P3379
// Memory Limit: 512 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)#include <bits/stdc++.h>
using namespace std;
#define int long long 
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define fi first
#define se second
const int inf = 0x3f3f3f3f;
const int N = 500010;
int n,m,s;
vector<int> a[N];
int dep[N],fu[N][30];
void dfs(int x,int fa)//深搜预处理阶段
{dep[x] = dep[fa] + 1;fu[x][0] = fa;for(int i=1;i<30;i++) fu[x][i] = fu[fu[x][i-1]][i-1];//祖先预处理阶段for(auto i : a[x]){if(i == fa) continue;//无向边所以都存，防止重复访问父节点dfs(i,x);}
}
int LCA(int x,int y)
{if(dep[x] < dep[y]) swap(x,y);while(dep[x] > dep[y]) x = fu[x][(int)log2(dep[x] - dep[y])];//先移动到同一层if(x == y) return x;//移动到同一层就重合了说明这个就是祖先了for(int i=log2(dep[x]);i>=0;i--)//根据二进制（2的幂次方）分解找到LCA的下一层（子节点）{if(fu[x][i] != fu[y][i])是共同祖先但是要保证是最近的所以在没找到时才更新{x = fu[x][i];y = fu[y][i];}}return fu[x][0];//这一层的上一层就是LCA
}
void solve()
{cin>>n>>m>>s;for(int i=1;i<n;i++){int u,v; cin>>u>>v;a[u].push_back(v);a[v].push_back(u);}dfs(s,0);while(m--){int x,y;cin>>x>>y;cout<<LCA(x,y)<<endl;}
//	cout<<fixed<<setprecision(x)<< ; 
}signed main()// Don't forget pre_handle!
{IOSint T=1;
//	cin>>T;while(T--) solve(); return 0;
}

[eJOI 2020] Fountain (Day1) 

题目链接：[eJOI 2020] Fountain (Day1)

这道题是很好的一道题，他不仅仅考察了对倍增的运用，而且还考察了单调栈。废话不多说，接下来就来看一下这道题的详细解析。

首先看到这到题第一反应就是从这个位置开始一直找后面的比当前元素要大的位置，然后不断的更新value，最后到哪一个地方value小于或等于这里的盘子了就说明找到最终的答案了但是每次都遍历所有的点就会超时，那么我们就开始想怎么去优化，我们首先可以想到用单调栈来记录每一个元素下边的第一个大于他的元素（等于不行!）这样就不用每次都从当前点来事遍历找第一个大于他的点了，只需要O(n)的复杂度就能处理完这一操作，但是这就完了吗，交上去发现只有30分，还能怎么优化呢？我们想既然有了单调性的话，能不能用二分，可是二分还需要知道每一段的容量，也不好求，我们既然是从当前开始一直找到下一个大于当前的点，那我们是否可以跳着找呢，跳着找第2的幂次方个大于他的盘子，用倍增ST表来解决呢？灵感来源于：

所以我们可以先用单调栈（因为是右边第一个大于他的元素，所以用逆序遍历的单调递减栈来实现，对单调栈这一方面不熟悉的小伙伴可以去看我的单调栈知识点的总结：单调栈详解）来处理每一段单调递增的盘子，然后将他们建树，这样就可以用倍增法来实现跳着找了。

将🌳建起来大概是这样，相信大家能够更形象地理解：

代码如下：

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define pii pair<int,int>
#define fi first  
#define se second
const int inf = 0x3f3f3f3f3f3f3f3f;  // 无穷大
const int N = 1e5 + 10;
// 定义各数组和变量
vector<int> a(N,0),v(N,0),r(N,0);  // a存储直径，v存储容量，r存储右侧第一个大于当前直径的喷泉编号
stack<int> st;       // 单调栈
int n,m;             // n个喷泉，m次查询
vector<int> e[N];    // 邻接表存储树结构
vector<int> dep(N,0); // 存储每个节点的深度
int fu[N][30],g[N][30]; // fu[i][j]表示i节点向上2^j层的祖先，g[i][j]表示i节点向上2^j层的容量和// DFS预处理倍增数组
void dfs(int x,int fa)
{dep[x] = dep[fa] + 1;  // 计算当前节点深度fu[x][0] = fa,g[x][0] = v[fa];  // 初始化直接父节点和容量// 预处理倍增数组for(int i=1;i<30;i++) {fu[x][i] = fu[fu[x][i-1]][i-1];// 计算祖先g[x][i] = g[fu[x][i-1]][i-1] + g[x][i-1];// 计算容量和}// 递归处理子节点for(auto i : e[x]) dfs(i,x);
}
void solve()
{cin>>n>>m;// 设置哨兵节点a[n+1] = inf,v[n+1] = inf;  // 第n+1个喷泉作为边界// 输入每个喷泉的直径和容量for(int i=1;i<=n;i++) cin >> a[i] >> v[i];// 单调栈处理，找到每个喷泉右侧第一个直径大于它的喷泉for(int i=n;i>=1;i--){// 维护单调递减栈while(!st.empty() && a[st.top()] <= a[i]) st.pop();// 如果栈空则指向哨兵，否则指向栈顶r[i] = (st.empty() ? n+1 : st.top());st.push(i);  // 当前喷泉入栈} // 构建树结构for(int i=n;i>=1;i--) e[r[i]].push_back(i);// 从哨兵节点开始DFS预处理dfs(n+1,0);// 处理查询for(int i=1;i<=m;i++){int index,value; cin>>index>>value;// 如果当前喷泉容量足够if(v[index] >= value){cout<<index<<endl;continue;}// 否则减去当前喷泉的容量value -= v[index];int x=index;int ans=0;// 倍增查找能容纳剩余水量的最低祖先for(int i=25;i>=0;i--){if(g[x][i] <= value && (1LL<<i) <= dep[x]){value -= g[x][i];x = fu[x][i];}if(value == 0) ans = x;}// 如果还有剩余水量，再向上走一步if(ans == 0) ans = fu[x][0];// 输出结果，如果是哨兵则输出0if(ans == n+1) cout<<0<<endl;else cout<<ans<<endl;}
}signed main()
{IOS  // 加速输入输出int T=1;while(T--) solve(); return 0;
}

之后的算法思维以及解题方法总结都会在本文进行更新，有兴趣对这一块内容进行整理的小伙伴可以保存起来。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.pswp.cn/news/916967.shtml
繁体地址，请注明出处：http://hk.pswp.cn/news/916967.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

GitLab 仓库 — 常用的 git 命令

GitLab 仓库 — 常用的 git 命令

在公司的 gitlab 公共仓库中写代码做项目时&#xff0c;主要涉及以下常用 git 命令&#xff1a;一、单个命令讲解1. 拉取代码&#xff08;1&#xff09;git clone [仓库 URL]‌克隆远程仓库到本地&#xff08;需确保 URL 正确&#xff09; ‌&#xff08;‌2&#xff09;git pu…
阅读更多...
【28】C# WinForm入门到精通 ——多文档窗体MDI【属性、方法、实例、源码】【多窗口重叠、水平平铺、垂直平铺、窗体传值】

【28】C# WinForm入门到精通 ——多文档窗体MDI【属性、方法、实例、源码】【多窗口重叠、水平平铺、垂直平铺、窗体传值】

文章目录1多文档窗体MDI2 基本设置3 实例&#xff1a;多窗口重叠、水平平铺、垂直平铺3.1 主窗口属性设置3.2 主窗口3.3 主窗口窗口添加MenuStrip菜单3.4 添加处理函数3.5 测试效果4 利用窗体参数定义进行传值4.1 在Form2、Form3添加相关控件4.2 Form3 定义函数public Form3(st…
阅读更多...
【计算机科学与应用】基于Session欺骗攻击的Web应用程序防护

【计算机科学与应用】基于Session欺骗攻击的Web应用程序防护

导读&#xff1a; 本文对Web应用程序开发中的Session欺骗攻击进行了阐述&#xff0c;详细讲解了防范Session欺骗攻击的三种传统方法&#xff0c;并给出了防范代码&#xff0c;分析了三种传统防范方法的不足&#xff0c;新设计了一种通过Referer信息验证来加强对Session欺骗的防…
阅读更多...
yolo8+阿里千问图片理解（华为简易版小艺看世界）

yolo8+阿里千问图片理解（华为简易版小艺看世界）

✅ 实现目标 按下空格键 → 获取摄像头当前画面&#xff1b; 将图片上传给 大模型 接口&#xff0c;让其“看图说话”&#xff1b; 获取返回描述后&#xff0c;以字幕形式展示在图像画面上&#xff1b; 持续显示识别结果&#xff0c;直到下次按空格。 &#x1f9e0; 需要准…
阅读更多...
【ee类保研面试】数学类---线性代数

【ee类保研面试】数学类---线性代数

25保研er&#xff0c;希望将自己的面试复习分享出来&#xff0c;供大家参考 part0—英语类 part1—通信类 part2—信号类 part3—高数类 part100—self项目准备 文章目录线性代数知识点大全**1. 余子式与代数余子式****2. 行列式的含义****3. 矩阵的秩&#xff08;Rank&#xf…
阅读更多...
在 Scintilla 中为 Squirrel 语言设置语法解析器的方法

在 Scintilla 中为 Squirrel 语言设置语法解析器的方法

Scintilla 作为一个强大的开源文本编辑控件&#xff0c;通过配置语法解析器&#xff0c;能够对多种编程语言实现语法高亮、代码折叠等实用功能。若要为新语言 Squirrel 设置语法解析器&#xff0c;可参考以下步骤&#xff1a;​创建 Lexer 源文件&#xff1a;Scintilla 通过 Le…
阅读更多...
Go语言核心知识点补充

Go语言核心知识点补充

Go语言核心知识点补充 make函数、for循环与输入处理详解 在前几章的内容中&#xff0c;我们介绍了Go语言的基础语法、变量声明、切片、循环等核心概念。但在实际开发中&#xff0c;一些细节性的知识点往往决定了代码的健壮性与效率。 本文将针对前几章涉及到的变量声明与初始化…
阅读更多...
AI服务器中，EEPROM有哪些部件使用，需要存储哪些信息？

AI服务器中，EEPROM有哪些部件使用，需要存储哪些信息？

在AI服务器中&#xff0c;EEPROM&#xff08;电可擦可编程只读存储器&#xff09;主要用于存储关键组件的配置数据、身份信息和校准参数。以下是主要组件及其存储内容&#xff1a; 一、核心组件及存储数据主板&#xff08;Baseboard Management Controller, BMC&#xff09; FR…
阅读更多...
It学习资源下载

It学习资源下载

一.UI 8个高质量UI设计网站&#xff0c;灵感收集必备&#xff01;
阅读更多...
Docker Compose ：从入门到企业级部署

Docker Compose ：从入门到企业级部署

Docker Compose &#xff1a;从入门到企业级部署1. Docker Compose 核心概念1.1 Compose 架构全景图2. 完整开发工作流2.1 典型开发流程2.2 多服务示例项目结构3. 核心配置详解3.1 服务配置矩阵3.2 网络拓扑示例4. 企业级部署方案4.1 多环境配置管理4.2 扩展部署架构5. 高级技巧…
阅读更多...
1.2.vue插值表达式

1.2.vue插值表达式

在 Vue.js 中&#xff0c;插值表达式是用于在模板中显示数据的一种方式。它使用双大括号语法 {{ }} 来包裹需要输出的变量或表达式的值。Vue 会自动将这些表达式的值插入到 HTML 文档中相应的位置。插值表达式基本用法最基本的插值表达式形式就是直接在模板中引用 Vue 实例中的…
阅读更多...
Python数据处理基础（学习笔记分享）

Python数据处理基础（学习笔记分享）

Python数据处理入门 常用库学习 numpy NumPy&#xff08;Numerical Python&#xff09; 是 Python 中用于高效数值计算的库&#xff0c;核心是提供一个强大的 ndarray​&#xff08;多维数组&#xff09;对象&#xff0c;类似于 C/C 中的数组&#xff0c;但支持更丰富的操作&a…
阅读更多...
力扣面试150题--颠倒二进制位

力扣面试150题--颠倒二进制位

Day 89 题目描述思路 二进制的算法&#xff0c;将十进制转化为二进制&#xff0c;有一点需要注意&#xff0c;直接采取库函数转化为二进制再反转会出现问题&#xff08;这也是为什么我要补0的原因&#xff09;&#xff0c;因为转化过去不满足32位的二进制&#xff0c;前面不会当…
阅读更多...
【ResNet50图像分类部署至RK3588】模型训练→转换RKNN→开发板部署

【ResNet50图像分类部署至RK3588】模型训练→转换RKNN→开发板部署

已在GitHub开源与本博客同步的ResNet50v2_RK3588_Classificationt项目&#xff0c;地址&#xff1a;https://github.com/A7bert777/ResNet50v2_RK3588_Classification 详细使用教程&#xff0c;可参考README.md或参考本博客第八章 模型部署 文章目录一、项目回顾二、模型选择介…
阅读更多...
C# _泛型

C# _泛型

目录 泛型是什么? 泛型的主要优势 创建一个泛型类 泛型方法 泛型是什么? 泛型是通过参数化来实现同一份代码上操作多种数据类型 利用参数类型将参数的类型抽象化 从而实现灵活的复用 总结: 通过泛型可以实现在同一份代码上操作多种数据类型的逻辑 将类和类中的成员定义…
阅读更多...
Vue路由钩子完全指南

Vue路由钩子完全指南

Vue.js中的路由导航钩子&#xff08;Navigation Guards&#xff09;主要用于在路由导航过程中进行拦截和处理&#xff0c;确保访问控制和状态管理。以下是主要分类及使用方法&#xff1a; 1. 全局钩子函数 作用于整个路由实例&#xff0c;需在路由配置外定义&#xff1a; befor…
阅读更多...
RAGFlow 登录界面点击登录无反应，控制台报错 502 Bad Gateway 解决方法

RAGFlow 登录界面点击登录无反应，控制台报错 502 Bad Gateway 解决方法

遇到的问题 在使用RAGFlow的时候&#xff0c;登录不进去&#xff0c;但是之前能登录。 还出现了输入地址直接进入工作界面&#xff0c;但是进行不了任何操作的bug&#xff1b;以及无法上传文档的问题&#xff08;其实都是因为没登录&#xff09;。 登陆界面报错如图显示。 …
阅读更多...
数据结构第3问：什么是线性表？

数据结构第3问：什么是线性表？

线性表 线性表由具有相同数据类型的n个元素构成&#xff0c;这些元素之间存在一一对应的线性关系。其中n为表长&#xff0c;当n0的时候线性表是一个空表。简单来说&#xff0c;线性表中的元素排列成一条线&#xff0c;每个元素最多有一个直接的前驱和后继&#xff08;除第一个和…
阅读更多...
常见CMS 靶场复现

常见CMS 靶场复现

一、wordpass1.修改模版文件getshell搭建网站登录网站后台更改网站模版的相关文件写入一句话木马凭借路径访问/wp-content/themes/twentyfifteen/404.php/?aphpinfo();2.上传夹带木马的主题getshell外观-->主题-->添加-->上传-->浏览-->安装-->访问木马文件…
阅读更多...
Elasticsearch - 倒排索引原理和简易实现

Elasticsearch - 倒排索引原理和简易实现

倒排索引的功能设计倒排索引&#xff08;Inverted Index&#xff09;是一种高效的数据结构&#xff0c;常用于全文搜索和信息检索系统。它的核心思想是将文档中每个关键字&#xff08;term&#xff09;与包含该关键字的文档列表进行映射。以下是实现倒排索引功能的设计步骤和代…
阅读更多...
最新文章

Copyright @ 2022~2023