PAT天梯赛刷题记录(更新中~只记录有思考价值的题)

电子货架标签应用浅析(ESL) ​【 关注与分享,是对原创最大的鼓励 】 年底了,会断续介绍几个主要的BLE的应用及市场情况,这篇文章介绍的是电子货架标签, ESL (Electronic Shelf Label)。 文章将从应用简介,市场规模,产业链,头部玩家及系统框架进行介绍。只对技术感兴趣的可以直接拉到底。 ESL简介 ESL,是一种显示产品,其主要是替代传统的纸质标签,应用于大型商超,... 阅读详情

L1-058 6翻了

if+while循环处理相同字符个数

L1-059 敲笨钟

rfind和erase的妙用

L1-064 估值一亿的AI核心代码

正则表达式

#include<bits/stdc++.h>
using namespace std;
int main(){
    int n;cin>>n;
    string s;getline(cin,s);
    while(n--){
        getline(cin,s);
        cout<<s<<endl;
        s=regex_replace(s,regex(R"(\s+)")," ");
        s=regex_replace(s,regex(R"( \!)"),"!");
        s=regex_replace(s,regex(R"( \?)"),"?");
        s=regex_replace(s,regex(R"( \,)"),",");
        s=regex_replace(s,regex(R"( \.)"),".");
        s=regex_replace(s,regex(R"( \')"),"'");
        if(s[0]==' ')s.erase(0,1);
        if(s.back()==' ')s.pop_back();
        for(auto &i:s){
            if(i!='I')i=tolower(i);
        }
        
        s=regex_replace(s,regex(R"(\bcan you\b)"),"_I can");
        s=regex_replace(s,regex(R"(\bcould you\b)"),"_I could");
        s=regex_replace(s,regex(R"(\bI\b)"),"you");
        s=regex_replace(s,regex(R"(\bme\b)"),"you");
        s=regex_replace(s,regex(R"(\?)"),"!");
        s=regex_replace(s,regex(R"(\b_I\b)"),"I");
        cout<<"AI: "<<s<<endl;
    }
}

L3-001 凑零钱

01背包(先用大物品再用小物品)+输出路径

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) x.begin(),x.end()
#define no cout<<"No"<<endl
#define yes cout<<"Yes"<<endl
#define endl '\n'
// #define x first
// #define y second
typedef pair<int,int> PII;
const int N=200010;
const int mod=998244353;
const int INF=0x3f3f3f3f3f3f3f3f;
int dp[N];
int vis[N][105];
void solve(){
    int n,m;cin>>n>>m;
    vector<int>v(n);
    for(int i=0;i<n;i++)cin>>v[i];
    sort(all(v),greater<int>());
    dp[0]=1;
    for(int i=0;i<n;i++){
        for(int j=m;j>=v[i];j--){
            if(dp[j-v[i]]){
                dp[j]=1;
                vis[i][j]=1;
            }
        }
    }
    vector<int>ans;n--;
    if(dp[m])while(m){
        if(vis[n][m]){
            ans.push_back(v[n]);
            m-=v[n];
        }
        n--;
    }
    if(ans.size()){
        for(int i=0;i<ans.size();i++){
            if(i)cout<<' '<<ans[i];
            else cout<<ans[i];
        }
    }else cout<<"No Solution\n";
}
signed main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int _=1;
    while(_--)solve();
    return 0;
}

L3-002 特殊堆栈

树状数组+二分(求第k小)

#include<bits/stdc++.h>
using namespace std;
#define lowbit(x) (x&(-x))
const int N=1e5+10;
int tr[N];
void add(int t,int val){
    for(int i=t;i<N;i+=lowbit(i)){
        tr[i]+=val;
    }
}
int query(int t){
    int res=0;
    for(int i=t;i;i-=lowbit(i)){
        res+=tr[i];
    }
    return res;
}
int main(){
    int n;cin>>n;
    stack<int>st;
    for(int i=0;i<n;i++){
        string s;cin>>s;
        if(s=="Pop"){
            if(st.empty()){
                cout<<"Invalid\n";
                continue;
            }
            int x=st.top();st.pop();
            add(x,-1);
            cout<<x<<endl;
        }else if(s=="PeekMedian"){
            if(st.empty()){
                cout<<"Invalid\n";
                continue;
            }
            int x=((int)st.size()+1)/2;
            int l=0,r=N;
            while(l+1!=r){
                int mid=l+r>>1;
                if(query(mid)>=x)r=mid;
                else l=mid;
            }
            cout<<r<<endl;
        }else{
            int x;cin>>x;
            st.push(x);
            add(x,1);
        }
    }
}

L3-003 社交集群

稍微有点思维的并查集

#include<bits/stdc++.h>
using namespace std;
const int N=1005;
int root[N];
int sz[N];
int find(int a){
    if(a==root[a])return a;
    return root[a]=find(root[a]);
}
void merge(int a,int b){
    int ra=find(a),rb=find(b);
    if(ra>rb)swap(ra,rb);
    sz[ra]+=sz[rb];
    root[rb]=ra;
}
int main(){
    int n;cin>>n;
    for(int i=0;i<N;i++)root[i]=i;
    for(int i=0;i<n;i++){
        string s;cin>>s;
        string t;
        for(auto i:s){if(i==':')break;
            t+=i;             
        }
        int k=stoi(t);
        int a;cin>>a;
        sz[find(a)]++;
        for(int j=0;j<k-1;j++){
            int b;cin>>b;
            merge(a,b);
        }
    }
    vector<int>ans;
    for(int i=1;i<N;i++){
        if(sz[find(i)])
        if(i==find(i))
        ans.push_back(sz[find(i)]);
    }
    sort(ans.begin(),ans.end(),greater<int>());
    cout<<ans.size()<<endl;
    for(int i=0;i<ans.size();i++){
        if(i)cout<<' ';
        cout<<ans[i];
    }
}

L3-004 肿瘤诊断

三维bfs

#include<bits/stdc++.h>
using namespace std;
int dir[6][3]={0,0,1,0,0,-1,0,1,0,0,-1,0,-1,0,0,1,0,0};
int g[1300][130][70];
int book[1300][130][70];
int main(){
    int m,n,l,t;cin>>m>>n>>l>>t;
    for(int i=0;i<l;i++){
        for(int j=0;j<m;j++){
             for(int k=0;k<n;k++){
                 cin>>g[j][k][i];
             }
        }
    }
    int ans=0;
    for(int i=0;i<l;i++){
        for(int j=0;j<m;j++){
             for(int k=0;k<n;k++){
                 if(!book[j][k][i]&&g[j][k][i]==1){
                     int cnt=1;
                     book[j][k][i]=1;
                     queue<array<int,3>>q;
                     q.push({j,k,i});
                     while(q.size()){
                         auto [a,b,c]=q.front();
                         q.pop();
                         for(int p=0;p<6;p++){
                             int tx=a+dir[p][0],ty=b+dir[p][1],tz=c+dir[p][2];
                             if(tx<0||ty<0||tz<0||tx>=m||ty>=n||tz>=l||book[tx][ty][tz]||g[tx][ty][tz]==0)continue;
                             book[tx][ty][tz]=1;
                             cnt++;
                             q.push({tx,ty,tz});
                         }
                     }
                     if(cnt>=t)ans+=cnt;
                 }
             }
        }
    }
    cout<<ans<<endl;
}

L3-005 垃圾箱分布

刚开始理解错题意了,就是个裸的Dijkstra

O(m*n+klogn)

L3-007 天梯地图

经典Dijkstra+dfs

#include<bits/stdc++.h>
using namespace std;
const int N=550;
const int INF=0x3f3f3f3f;
vector<array<int,3>>v[N];
int d1[N];
int d2[N];
int n,m;
int st,ed;
void Dijkstra1(){
    for(int i=0;i<n;i++)d1[i]=INF;
    vector<int>book(n);
    d1[st]=0;
    for(int i=0;i<n;i++){
        int mn=INF,t;
        for(int j=0;j<n;j++){
            if(!book[j]&&mn>=d1[j]){
                mn=d1[j];
                t=j;
            }
        }
        if(book[t])continue;
        book[t]=1;
        for(auto [j,w1,w2]:v[t]){
            if(book[j])continue;
            d1[j]=min(d1[j],w1+mn);
        }
    }
}
void Dijkstra2(){
    for(int i=0;i<n;i++)d2[i]=INF;
    vector<int>book(n);
    d2[st]=0;
    for(int i=0;i<n;i++){
        int mn=INF,t;
        for(int j=0;j<n;j++){
            if(!book[j]&&mn>=d2[j]){
                mn=d2[j];
                t=j;
            }
        }
        if(book[t])continue;
        book[t]=1;
        for(auto [j,w1,w2]:v[t]){
            if(book[j])continue;
            d2[j]=min(d2[j],w2+mn);
        }
    }
}
int cnt=INF;
vector<int>ans1;
vector<int>ans2;
vector<int>tmp;
void dfs1(int t,int fa,int ndist,int ncnt){
    if(ndist>d1[t])return;
    if(t==ed){
        if(ncnt<cnt){
            ans1=tmp;
            cnt=ncnt;
        }
        return;
    }
    for(auto [j,a,b]:v[t]){
        if(j==fa)continue;
        tmp.push_back(j);
        dfs1(j,t,ndist+a,ncnt+1);
        tmp.pop_back();
    }
}
int dist=INF;
void dfs2(int t,int fa,int nTm,int ndist){
    if(nTm>d2[t])return;
    if(t==ed){
        if(ndist<dist){
            ans2=tmp;
            dist=ndist;
        }
        return;
    }
    for(auto [j,a,b]:v[t]){
        if(j==fa)continue;
        tmp.push_back(j);
        dfs2(j,t,nTm+b,ndist+a);//这里的参数一定要用对啊,一直忘
        tmp.pop_back();
    }
}
int main(){
    cin>>n>>m;
    for(int i=0;i<m;i++){
        int a,b,c,d,e;cin>>a>>b>>c>>d>>e;
        v[a].push_back({b,d,e});
        if(!c)v[b].push_back({a,d,e});
    }
    cin>>st>>ed;
    Dijkstra1();
    Dijkstra2();
    tmp.push_back(st);
    dfs1(st,st,0,0);
    dfs2(st,st,0,0);
    if(ans1==ans2){
        printf("Time = %d; Distance = %d: %d",d2[ed],d1[ed],st);
        for(int i=1;i<ans1.size();i++){
            printf(" => %d",ans1[i]);
        }
    }else{
        printf("Time = %d: %d",d2[ed],st);
        for(int i=1;i<ans2.size();i++){
            printf(" => %d",ans2[i]);
        }cout<<'\n';
        printf("Distance = %d: %d",d1[ed],st);
        for(int i=1;i<ans1.size();i++){
            printf(" => %d",ans1[i]);
        }
    }
}

L3-011 直捣黄龙

经典Dijkstra+dfs

#include<bits/stdc++.h>
using namespace std;
#define PII pair<int,int>
unordered_map<string,int>mp;
unordered_map<int,string>mp2;
const int N=220;
const int INF=0x3f3f3f3f;
int val[N];
vector<PII>v[N];
int idx=0;
int d[N];
string st,ed;
int n,k;
void Dijkstra() {
	for(int i=0; i<n; i++)d[i]=INF;
	d[mp[st]]=0;
	vector<int>book(n);
	for(int i=0; i<n; i++) {
		int mn=INF,t;
		for(int j=0; j<n; j++) {
			if(!book[j]&&mn>=d[j]) {
				mn=d[j];
				t=j;
			}
		}
		if(book[t])continue;
		book[t]=1;
		for(auto [j,w]:v[t]) {
			if(book[j])continue;
			if(d[j]>mn+w) {
				d[j]=mn+w;
			}
		}
	}
}
vector<int>ans;
vector<int>tmp;
int ans2,cnt,sum,dist;
void dfs(int t,int fa,int nsum,int ncnt,int ndist) {
	if(ndist>d[t])return;
	if(t==mp[ed]) {
		ans2++;
		if(ncnt>cnt) {
			ans=tmp;
			cnt=ncnt;
			sum=nsum;
		} else if(ncnt==cnt&&nsum>sum) {
			ans=tmp;
			cnt=ncnt;
			sum=nsum;
		}
		return;
	}
	for(auto [j,w]:v[t]) {
		if(j==fa)continue;
		tmp.push_back(j);
		dfs(j,t,nsum+val[j],ncnt+1,ndist+w);
		tmp.pop_back();
	}
}
int main() {
	cin>>n>>k;
	cin>>st>>ed;
	mp[st]=idx;mp2[idx++]=st;
	mp[ed]=idx;mp2[idx++]=ed;
	for(int i=0; i<n-1; i++) {
		string a;int b;
		cin>>a>>b;
		if(!mp.count(a)) {
			mp[a]=idx;
			mp2[idx++]=a;
		}
		val[mp[a]]=b;
	}
	for(int i=0; i<k; i++) {
		string a,b;int c;
		cin>>a>>b>>c;
		v[mp[a]].push_back({mp[b],c});
		v[mp[b]].push_back({mp[a],c});
	}
	Dijkstra();
	tmp.push_back(mp[st]);
	dfs(mp[st],mp[st],0,0,0);
	for(int i=0; i<ans.size(); i++) {
		if(i)cout<<"->";
		cout<<mp2[ans[i]];
	}cout<<endl;
	cout<<ans2<<' '<<d[mp[ed]]<<' '<<sum;
}

 L3-022 地铁一日游

题意太抽象

Floyd写错了

#include<bits/stdc++.h>
using namespace std;
const int N=220;
const int INF=0x3f3f3f3f;
int d[N][N];
set<int>st[N];
int ru[N];
string line;
vector<int>v;
vector<int>book(N);
void dfs(int t){
	for(auto j:st[t]){
		if(book[j])continue;
		book[j]=1;
		v.push_back(j);
		dfs(j);
	}
}
int main(){
    int n,m,k;cin>>n>>m>>k;getline(cin,line);
    for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)d[i][j]=INF,d[i][i]=0;
    for(int i=0;i<m;i++){
        getline(cin,line);
        stringstream ssin(line);
        string s;vector<int>tmp;
        while(ssin>>s)tmp.push_back(stoi(s));
        for(int i=0;i<tmp.size();i+=2){
        	if(i==0)ru[tmp[i]]=1;
            if(i==tmp.size()-1){ru[tmp[i]]=1;break;}
            d[tmp[i]][tmp[i+2]]=min(d[tmp[i]][tmp[i+2]],tmp[i+1]);
            d[tmp[i+2]][tmp[i]]=min(d[tmp[i+2]][tmp[i]],tmp[i+1]);
        }
    }
    
    for(int k = 1; k <= n; k++)//Floyd
		for(int i = 1; i <= n; i++)
			for(int j = 1; j <= n; j++)
				if(i!=j)d[i][j] = min(d[i][j],d[i][k]+d[k][j]);
    
    for(int i=1;i<=n;i++){
        map<int,int>mp;
        st[i].insert(i);
        for(int j=1;j<=n;j++){
            if(d[i][j]==INF)continue;
            mp[2+d[i][j]/k]=max(mp[2+d[i][j]/k],d[i][j]);
        }
        for(int j=1;j<=n;j++){
            if(d[i][j]==INF)continue;
            if(d[i][j]==mp[2+d[i][j]/k]||ru[j]==1){
                st[i].insert(j);
            }
        }
    }
    
    int q;cin>>q;
    while(q--){
        int x;cin>>x;
        v.clear();
        book.assign(N,0);
        book[x]=1;
        dfs(x);
        for(auto i:v){
            st[x].insert(i);
        }
        int fir=1;
        for(auto i:st[x]){
            if(fir){cout<<i;fir=0;}
            else cout<<' '<<i;
        }cout<<endl;
    }
}

L3-025 那就别担心了

dfs逆向思维(一直误以为是拓扑排序)

L3-031 千手观音

离散化+优先队列+拓扑排序

L3-032 关于深度优先搜索和逆序对的题应该不会很难吧这件事

树状数组求树上逆序对

基于MATLAB的Hough变换指针式仪表识别 综上所述,本文介绍了如何使用MATLAB中的Hough变换算法来实现指针式仪表的自动识别和读数。通过图像预处理、Hough变换和直线提取,我们可以准确地检测指针的位置,并进一步进行仪表读数。本文将介绍如何使用MATLAB中的Hough变换算法来实现指针式仪表的自动识别和读数。在指针式仪表识别中,我们可以利用Hough变换来检测仪表盘上的指针。以上是基于MATLAB的Hough变换指针式仪表识别的详细步骤和源代码示例。根据指针在仪表盘上的位置,我们可以进行角度计算或使用其他技术来获取准确的读数。 阅读详情

相关推荐

实战ByteTrack:用C++手把手教你实现多目标跟踪(附完整代码解析)

本文通过C++实战教程,手把手教你实现ByteTrack多目标跟踪算法。文章详细解析了算法核心,包括利用卡尔曼滤波进行状态预测、匈牙利算法完成数据关联,以及ByteTrack独特的三次匹配策略来有效处理低置信度检测框,并提供了完整的项目架构、代码实现与性能优化指南。

yolo5detector的博客 299

智能对话日志脱敏架构:从合规需求到工程实践

在数据处理领域,数据脱敏是一项基础且关键的技术,旨在保护敏感信息的同时保留数据的分析价值。其核心原理是通过替换、掩码、哈希或加密等技术手段,将原始数据中的个人标识符或敏感内容转换为非敏感形式,从而实现“数据可用不可见”。这项技术的核心价值在于平衡数据利用与隐私保护,满足GDPR等法规的合规要求,并维系用户信任。在智能对话、金融风控、医疗健康等涉及大量用户交互数据的应用场景中,实时、精准的日志脱敏成为系统设计的刚需。本文聚焦于智能对话引擎场景,深入探讨如何构建一套贯穿数据全生命周期的分层分级脱敏流水线,其中涉

banshen0201的博客 438

(超全面,超基础)Kriging插值推导理论笔记,算法,普通克里金

最近老师让我再重新推导一下克里金插值的方法如何求出预测结果,于是我又无数次地打开了大神的推导原理过程链接????:克里金(Kriging)插值的原理与公式推导 作者:xg1990,但是不可避免地在推导过程中,数学知识基础薄弱的我卡住在一些公式推导的步骤中。 所以就想基于上面大神的推导过程,将里面的推导写得更具体些,当然觉得毫不吃力可以进行推导的大神们可以不看我的注释,直接点开链接看就好。 我看到csdn中很多关于克里金推导的博客里面的内容直接截屏或者复制了上面链接里大神发表的内容,也不注

Olivel1997的博客 1万+

团体程序设计天梯赛刷题记录

更新了视频讲解的连接~

麒麟001号的博客 668

区域法(zonal method)重构波前

目的:实现区域法的Matlab代码 1.理论介绍 区域法波前重构即从波前探测器测得的波前斜率中恢复出波前的相位值,其分为:休晋模型(Hudgin)[90]、绍契威尔模型(Southwell)[40]和弗雷德模型(Fried)[48]。 1.1 Fried模型,对于N×N微透镜阵列构成的网格: 以3*3的子透镜为例,解释上式,对其展开 改写为矩阵形式: 记作:S=AΦ,A根据N而确定。S是波前探测器测得的斜率,Φ是重构矩阵的相位值。 1.2 而Southwel...

EyRe1的博客 8196

Ubuntu22.04通过DKMS包安装Intel WiFi系列适配器(网卡驱动)

Ubuntu安装Intel WiFi系列适配器(网卡驱动)

lu_linux的博客 2601

PAT 天梯赛 L3-001. 凑零钱 【DP】【DFS】

题目链接 https://www.patest.cn/contests/gplt/L3-001 思路 DP【I】【J】 I 表示第几个物品 J 表示多少钱 dp[i][j] 为 bool 值 表示 当前状态是否能满足 对于一个物品 有两个选择 一个是选 当 arr[i] < j 的时候 dp[i - 1][j - arr[i]] =...

banshen0201的博客 117

用树莓派搭建全功能NAS服务器(01):树莓派基础操作&OMV搭建

写在前面 对于文件互传来说,局域网和云盘的操作总是独立的,而且很难将两者的优势合为一体。如果想要集多种优势为一体,那么NAS应该就是较为完美的解决方案了。 在这个系列中我们尽量跳过一些枯燥的理论知识,专注于说明两件事:   1.NAS是什么&能做什么 2.搭建思路&怎么做   这中间也会涉及到一些方案的选择,同类方案我也会列出来和大家分享我已知的优缺点,有兴趣可以多种尝试。(侧重于软件) 虽然是用树莓派搭建的,但是对于debian linux系统下的NAS搭建有着很好的参

斯塔克家的真维斯的工作间 2万+

PAT天梯赛练习题——L3-008. 喊山(邻接表+BFS)

L3-008. 喊山 时间限制 150 ms 内存限制 65536 kB 代码长度限制 8000 B 判题程序 Standard 作者 陈越 喊山,是人双手围在嘴边成喇叭状,对着远方高山发出“喂—喂喂—喂喂喂……”的呼唤。呼唤声通过空气的传递,回荡于深谷之间,传送到人们耳中,发出约定俗成的“讯号”,达到声讯传递交流的目的。原来它是彝族先民用来求援呼救的“讯号”,慢慢地人们在生活

Frozen_Forest 2636

lammps建模(电解液)opls-aa力场的基本流程

lammps建模(电解液)opls-aa力场的基本流程

syj0922的博客 2134

2026软件测试面试题全解析:从用例设计到接口自动化与性能实战

在软件测试岗位的招聘考察中,面试官越来越看重候选人解决实际问题的工程能力,而不仅仅是背诵概念。从最基础的测试用例设计出发,覆盖功能测试、接口测试、自动化测试、性能测试、数据库与Redis一致性等核心知识体系,是应对中高级岗位面试的关键路径。理解Postman抓包、Python脚本、Pytest框架、JMeter压测指标背后的原理,能帮助测试人员构建完整的质量保障思维。当AI辅助测试成为行业新趋势时,掌握数据校验链路与风险识别意识,更能体现资深测试工程师的竞争力。本文围绕2026年高频软件测试面试题,梳理了从

weixin_28676289的博客 245

CCCC 题目集 L3 001 凑零钱 【背包 + 记录路径 + 思维】

传送门 // 题意: 给定n枚硬币的价值, 给出一个容量m, 问能否恰好在这n个中选择一些硬币使得其价值和加起来等于m, 并输出你选择的这些硬币的价值, 如果有多种选择, 输出字典序最小的那种. 思路: 首先肯定是01背包没错, 但是同时我们要注意几个点, 一个是要恰好构成, 所以dp初始化时除0外都初始化为-inf, dp[0] = 0. 也就是恰好装满背包的最优解. 同时更新的是还要同时记...

Anxdada -- 我等风来也等你 814

YOLOv13改进策略【特征提取层】| CVPR-2024 PKI Module 获取多尺度纹理特征,适应尺度变化大的目标

PKI Module是。

Limiiiing的博客 276

【数据结构-5】单链表的实现

单链表,具体来说是单向的、不带头的、不循环的链表。链表由一个一个节点组成,每个节点分为数据域和指针域,数据域存放数据,指针域存放下一节点的地址。这样,就可以根据指针域中的地址找到下一个节点,节点就串起来了构成了单链表。

weixin_44218929的博客 197

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

【数据结构】基于比较的排序算法 - 交换排序

本文介绍交换排序中的冒泡排序与快速排序。冒泡排序通过相邻元素比较交换,实现升序,时间复杂度最坏为O(N²),空间复杂度O(1),稳定且适合小规模有序数据。快速排序采用分治思想,以基准值划分区间,平均时间复杂度O(N log N),空间复杂度O(log N),但不稳定,实际应用中性能优异,可通过随机基准、小区间优化等提升效率。

careathers的博客 357

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

pandas 深度入门:从数据结构到一份真实销售报表

本文系统讲解Pandas核心应用,从三分钟安装到完整月度报表生成,涵盖数据读取、清洗、筛选、分组聚合、表连接、透视表与时间序列等13个关键环节。强调“先看数据再动手”,掌握Series/DataFrame/Index结构本质,熟练运用loc/iloc、merge校验、agg/transform区别,通过真实案例实现高效报表自动化,告别手动Excel操作。最后提供性能优化与高频报错解决方案,助力读者快速上手,真正实现“写二十行代码,跑三秒出结果”。

信息安全领域优质创作者|操作系统领域专家 293

C# 数据结构和特殊类型

.NET Core(现称.NET)提供丰富数据结构,优化性能与开发效率。日常开发首选List<T>和Dictionary<TKey,TValue>;高性能场景推荐Span<T>与Memory<T>减少内存分配;并发环境使用ConcurrentDictionary等线程安全集合;避免非泛型集合如ArrayList。

cccloveforever的博客 690

数据结构的基本概念和算法的初步认识

本文系统阐述数据结构与算法的基础概念,涵盖数据、数据元素、数据对象的层次关系,数据结构的三要素(逻辑结构、存储结构、数据运算),以及抽象数据类型。重点解析算法的特性与设计要求,并深入讲解时间复杂度分析的核心——大O表示法,通过“只保留最高阶项、忽略常数系数、取最坏情况”三大原则,结合实例剖析O(1)、O(n)等常见时间复杂度,揭示算法效率的本质评估方法。

ACH_YYX的博客 191

【数据结构】堆(Heap):堆的实现、建堆与堆排序

堆是一种特殊的完全二叉树,分为大堆(父节点≥孩子)和小堆(父节点≤孩子),可快速获取最值。堆通常用数组存储,通过下标计算父子关系。核心操作为向上调整(插入时)和向下调整(删除或建堆时),时间复杂度均为O(log N)。建堆可采用从后往前的向下调整法,整体复杂度为O(N)。基于堆的堆排序通过反复提取最大值实现升序排列,总时间复杂度为O(N log N),空间复杂度O(1),是高效稳定的排序算法。

2501_93577780的博客 349

Redis 数据结构、单线程架构与 String 字符串详解

Redis采用单线程架构,通过事件循环(Event Loop)高效处理I/O事件,避免阻塞。其核心优势在于内存操作快、无上下文切换开销。数据结构支持多种内部编码(如ziplist、quicklist),自动根据场景优化存储与性能。字符串类型是基础且灵活,可存文本、数字或二进制数据,最大512MB,支持原子操作。命令如SET、GET、MGET、MSET等实现高效读写,适用于缓存、计数、会话管理等场景。

2303_77004089的博客 356

笔记-论数据结构3(算法分析-时间复杂度)

i <= n;s = 0;次数1234ti1248?i2^02^12^22^32^t-1在遍历的过程中,2^t-1次方的增长率肯定大于n,可得出结论2^t-1 > n那么,为了得出t和n的关系,我们可以运用对数关系:log2为底2^t-1 > log2为底n消掉log2为底2t-1 > log2为底nt > log2为底n+1于是可以得出。

fish_zzzz的博客 234

J1939 DM1 报文数据结构详解:单帧、BAM、CMDT 逐字节拆解与 DTC 跨包问题

1. 一条报文,两套字节结构 DM1 装的是灯具状态加一串 DTC,而串的长度决定哪一种字节结构上线。 8 字节以内是一帧 :两个灯具字节,之后每 DTC 四字节,末尾补齐。超过 8 字节就变成 的一帧 TP.CM 声明

废柴程序员-熊熊的博客 118

Vue3 低代码移动表单设计器实战(二):缩放画布下的拖拽系统与树状级联数据结构

本文深入剖析Vue3低代码表单设计器在缩放画布下的拖拽失效问题,揭示SortableJS在CSS Transform下坐标崩溃的数学根源。通过自研独立视觉克隆壳层与逆向几何补偿算法,实现精准拖拽;采用扁平数据存储+运行时树状计算结构,解决级联依赖与深克隆难题,确保逻辑一致性与性能优化,为复杂低代码系统提供可复用的工程范式。

NanChen的博客 344

排序算法深度笔记(上):比较类排序的思想演进与代码实现

与。本文聚焦前者 —— 也就是通过元素间两两比较来确定相对顺序的排序算法,从最朴素的 O (n²) 基础排序,到工业级主流的 O (nlogn) 进阶排序,逐层拆解设计思想、带注释的代码实现与边界细节。当我们理解了比较排序的性能边界,也就自然引出了非比较排序的存在意义。所有代码均遵循统一的实现规范:入口函数前置空数组与单元素边界校验,基于数组原地修改,主函数附带可直接运行的测试用例,与练习代码风格完全对齐。

2401_87069538的博客 628

CF2283F[数据结构]

首先考虑一种暴力解法,当我们建好i之前的图后,当我们添加i的时候,区间[li,ri]中的点都会向i建边,但是这些点中,如果有某两个顶点l,r,满足l<r,那么l就可以通过r间接到达i,因此可以删除l到i的边;初始时我们令所有点放入set中,然后对于每一个i的处理,我们将集合中仍在[l,r]的范围的点弹出,并且将f设置为i,这样我们就得到了所有点的最小跳板;对于每个区间[l,r] 我们要计算这下下标中的f(v)中大于r的数目有多少个;我们令f(v)表示顶点v可到达的最小的顶点;

蒟蒻 145
上一篇: 牛客小白G-小苯的逆序对(树状数组+DP/莫比乌斯函数)
下一篇: 2024牛客暑期多校训练营4 —— J Zero
Perfect_Life_
博客等级 码龄5年 54粉丝 20原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值