2024 CCPC Liaoning Provincial Contest

news2024/11/13 8:31:43

tot：赛时是6题723罚时，还是差劲了。省赛，特别是这场省赛，难度低很多。前面4，5题都是签到题。第六题是一个关于闰年的容斥，脑子乱了，然后越来越绕。然后就没出。出的是一个诈骗题，题面引导你这是计算几何，但是实际上是简单dp，暴力o(n^2)预处理一下就行了。赛时还想着求凸包然后旋转卡壳求凸包直径来预处理，再dp，但是这样是o(n^3)的，然后过了不知道多久突然才发现完全用不上计算几何，直接最普通的枚举区间取max就可以预处理出来了。然后赛后再补了闰年的容斥和一题挺典型的题目，共计8题。

2024CCPC辽宁省赛.pdf

比分幻术

思路：签到。

string str;
void solve(){
    cin>>str;
    cout<<str[2]<<str[1]<<str[0];
}

爱上字典

思路：签到。

string str;
int n;
string toLower(string s){
    int len=(int)s.size();
    string res="";
    for(int i=0;i<len;i++){
        if(s[i]>='A'&&s[i]<='Z') res+=s[i]+32;
        else res+=s[i];
    }
    return res;
}
void solve(){   //A
    getline(cin,str);
    str=toLower(str);
    cin>>n;
    unordered_map<string,bool> mp;
    for(int i=1;i<=n;i++){
        string s; cin>>s;
        mp[toLower(s)]=true;
    }
    string cur="";
    int ans=0;
    for(int i=0;i<(int)str.size();i++){
        if(str[i]>='a'&&str[i]<='z') cur+=str[i];
        else if(cur!=""){
            if(!mp[cur]) ans++,mp[cur]=true;
            cur="";
        }
    }
    cout<<ans;
}

结课风云

思路：签到。

int n,a,b,c,d;
int x[1003],y[1003];
void solve(){       //J
    cin>>n>>a>>b>>c;
    for(int i=1;i<=n;i++) cin>>x[i]>>y[i];
    cin>>d;
    int ans=0;
    for(int i=1;i<=n;i++){
        if(x[i]+y[i]>=c) continue;
        x[i]=min(a,x[i]+d);
        if(x[i]+y[i]>=c) ans++;
    }
    cout<<ans;
}

插排串联

思路：用multiset存一下每个排插的大小，然后在回溯的时候判断是否有满足条件的排插即可。

int n;
int arr[100005];
vector<int> vct[100005];
multiset<int> st;  //用了set,给去重了。。不能去重。。
bool ans=true;
int dfs(int s){
    if((int)vct[s].size()==0) return arr[s];
    int res=0;
    for(auto v:vct[s]) res+=dfs(v);
    if(s==0&&res>2200) ans=false;
    else if(s==0) return 0;
    auto p=st.lower_bound(res);
    if(p==st.end()) ans=false;
    else st.erase(p);
    return res;
}
void solve(){       //C
    cin>>n;
    for(int i=1;i<=n;i++){
        int x; cin>>x>>arr[i];
        vct[x].emplace_back(i);
    }
    for(int i=1;i<=n;i++) if((int)vct[i].size()!=0) st.emplace(arr[i]);
    dfs(0);
    ans?cout<<"YES":cout<<"NO";
}

都市叠高

思路：题目误导你这题是计算几何，实则只是普通的dp。一开始的确被误导了，很后面才反应过来o(n^2)就能预处理出要的信息了。简单dp。

int n;
typedef struct Point{
    int x,y;
}Point;
Point point[5005];
double dist(Point a,Point b){ return sqrt( (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y) ); }
double dp[5005];
double mx[5005][5005];  //dist[i][j]定义为:从i往后连续j个构成的凸包直径.
void solve(){
    cout<<setprecision(10);
    cin>>n;
    for(int i=1;i<=n;i++) cin>>point[i].x>>point[i].y;
    for(int i=1;i<=n;i++){
        double mx0=0;
        for(int j=i+1;j<=n;j++){
            mx0=max(mx0,dist(point[i],point[j]));
            mx[i][j]=mx0;
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=i;j++){
            dp[i]=max(dp[i],dp[i-j]+mx[i-j+1][i]);
        }
    }
    cout<<dp[n];
}

俄式简餐

思路：队友写的构造。注意判6的情况就行。

void solve(){       //E
    int n, m;
    cin >> n >> m;
    vector g(n + 10, vector<int>(m + 10));
    int cnt = 1;
    if (n == 2 && m == 2 || n * m % 4) {
        cout << "NO" << endl;
        return ;
    }
    if (n % 4 == 0) {
        for (int j = 1; j <= m; j ++) {
            for (int i = 1; i <= n; i += 4) {
                g[i][j] = g[i + 1][j] = g[i + 2][j] = g[i + 3][j] = cnt;
                cnt ++;
            }
        }
    } else if (m % 4 == 0) {
        for (int i = 1; i <= n; i ++) {
            for (int j = 1; j <= m; j += 4) {
                g[i][j] = g[i][j + 1] = g[i][j + 2] = g[i][j + 3] = cnt;
                cnt ++;
            }
        }
    } else if ( n % 2 == 0 && m % 2 == 0) {
        if (n % 6 == 0) {
            for (int j = 1; j <= m; j += 2) {
                for (int i = 1; i <= n; i += 6) {
                    g[i][j] = g[i][j + 1] = g[i + 1][j] = g[i + 2][j] = cnt++;
                    g[i + 3][j] = g[i + 4][j] = g[i + 5][j] = g[i + 5][j + 1] = cnt ++;
                    g[i + 1][j + 1] = g[i + 2][j + 1] = g[i + 3][j + 1] = g[i + 4][j + 1] = cnt ++;
                }
            }
        } else if (n % 6 == 4) {
            for (int j = 1; j <= m; j += 2) {
                for (int i = 1; i <= n - 4; i += 6) {
                    g[i][j] = g[i][j + 1] = g[i + 1][j] = g[i + 2][j] = cnt++;
                    g[i + 3][j] = g[i + 4][j] = g[i + 5][j] = g[i + 5][j + 1] = cnt ++;
                    g[i + 1][j + 1] = g[i + 2][j + 1] = g[i + 3][j + 1] = g[i + 4][j + 1] = cnt ++;
                }
            }
            for (int j = 1; j <= m; j ++) {
                g[n][j] = g[n - 1][j] = g[n - 2][j] = g[n - 3][j] = cnt;
                cnt ++;
            }
        } else if (m % 6 == 0) {
            for (int i = 1; i <= n; i += 2) {
                for (int j = 1; j <= m; j += 6) {
                    g[i][j] = g[i + 1][j] = g[i][j + 1] = g[i][j + 2] = cnt++;
                    g[i][j + 3] = g[i][j + 4] = g[i][j + 5] = g[i + 1][j + 5] = cnt ++;
                    g[i + 1][j + 1] = g[i + 1][j + 2] = g[i + 1][j + 3] = g[i + 1][j + 4] = cnt ++;
                }
            }
        } else if (m % 6 == 4) {
            for (int i = 1; i <= n; i += 2) {
                for (int j = 1; j <= m - 4; j += 6) {
                    g[i][j] = g[i + 1][j] = g[i][j + 1] = g[i][j + 2] = cnt++;
                    g[i][j + 3] = g[i][j + 4] = g[i][j + 5] = g[i + 1][j + 5] = cnt ++;
                    g[i + 1][j + 1] = g[i + 1][j + 2] = g[i + 1][j + 3] = g[i + 1][j + 4] = cnt ++;
                }
            }
            for (int i = 1; i <= n; i ++) {
                g[i][m] = g[i][m - 1] = g[i][m - 2] = g[i][m - 3] = cnt;
                cnt ++;
            }
        } else if (n % 4 == 2 && n != 2) {
            for (int j = 1; j <= m; j ++) {
                for (int i = 1; i <= n - 6; i += 4) {
                    g[i][j] = g[i + 1][j] = g[i + 2][j] = g[i + 3][j] = cnt ++;
                }
            }
            for (int j = 1; j <= m; j += 2) {
                g[n - 5][j] = g[n - 4][j] = g[n - 3][j] = g[n - 5][j + 1] = cnt ++;
                g[n - 2][j] = g[n - 1][j] = g[n][j] = g[n][j + 1] = cnt ++;
                g[n - 4][j + 1] = g[n - 3][j + 1] = g[n - 2][j + 1] = g[n - 1][j + 1] = cnt ++;
            }
        } else if (m % 4 == 2) {
//            cout << "------" << endl;
            for (int i = 1; i <= n; i ++) {
                for (int j = 1; j <= m - 6; j += 4) {
                    g[i][j] = g[i][j + 1] = g[i][j + 2] = g[i][j + 3] = cnt;
                    cnt ++;
                }
            }
            for (int i = 1; i <= n; i += 2) {
                g[i][m - 5] = g[i][m - 4] = g[i][m - 3] = g[i + 1][m - 5] = cnt ++;
                g[i][m - 2] = g[i][m - 1] = g[i][m] = g[i + 1][m] = cnt ++;
                g[i + 1][m - 4] = g[i + 1][m - 3] = g[i + 1][m - 2] = g[i + 1][m - 1] = cnt ++;
            }
        }
    }
    cout << "YES" << endl;
//    return ;
    for (int i = 1; i <= n; i ++) {
        for (int j = 1; j <= m; j ++) {
            cout << g[i][j] << ' ';
        }
        cout << endl;
    }
}

龙之研习

思路：

        n 整除 4×100^p 但不整除 100^(p+1);
        式子①:x/4*100^p;
        式子②:x/100^(p+1);
        这里①是:x整除4*100^p的都是闰年,但是其中②是平年,所以要减去.
        同时,②还有去重的作用,因为下一个p是:x/4*100^(p+1),这里的x/4*100^(p+1)按理来说已经被上一个算过了
        但是因为上一个同时还有②,那么会把属于x/4*100(p+1)的部分给减去了,同时更高次方的也会减去..
        其他的次方是同理的,如此下来,是没有算重算漏的.

int n;
inline int cal(int x){  //计算2025~x的平年的个数
    int run=0,run0=0,x0=2024,q=1;
    for(int p=0;p<=8;p++){
        // n 整除 4×100^p 但不整除 100^(p+1);
        //式子①:x/4*100^p;
        //式子②:x/100^(p+1);
        //这里①是:x整除4*100^p的都是闰年,但是其中②是平年,所以要减去.
        //同时,②还有去重的作用,因为下一个p是:x/4*100^(p+1),这里的x/4*100^(p+1)按理来说已经被上一个算过了
        //但是因为上一个同时还有②,那么会把属于x/4*100(p+1)的部分给减去了,同时更高次方的也会减去..
        //其他的次方是同理的,如此下来,是没有算重算漏的.
        run+=x/(4*q)-x/(q*100);
        run0+=x0/(4*q)-x0/(q*100);
        q*=100;
    }
    return (x-run)-(x0-run0);
}
void solve(){
    cin>>n;
    int l=2025,r=4e18,ans=-1;
    while(l<=r){
        int mid=(l+r)>>1ll;
        if(cal(mid)>=n){  //这里得是>=号,不然可能取不到最小值..也不能直接对(ans,mid)取min.
            ans=mid;
            r=mid-1;
        }
        else l=mid+1;
    }
    cout<<ans<<endl;
}

顾影自怜

思路：

不懂不懂..没思路...一开始想着很混乱,最大值是不同数字,又是隔开的,又是区间的,还要满足k个..晕..
key:这个时候就要考虑,需要什么信息?可以预处理出来吗?
①也不难..可以"预处理"之后,o(1)知道每个数字左边和右边第一个比它大的位置.
②也可以o(1)知道每个数字从此位置起,往右直至其出现k次的位置在哪里.
③还可以维护每个数字,上一次出现的位置.
有了以上三个信息,可以枚举"每个位置作为第一个最大值"时,可以得到的贡献.
即合法的左区间为(max(lmx,last),i],合法的右区间为[nex,rmx). last为上一个当前数字的位置,nex第k次出现当前数字的位置.
key:其实以前做过类似的题,应该是st表写的.也是只考虑每个点,对全部右区间的贡献,而对于左区间,只考虑到上一个当前数字为止.
这样就不会算重算漏.
ps:这题的官方题解是有问题的..

int n,k;
int arr[1000006];
vector<int> vct[1000006];
vector<int> mp(1000006,0);
vector<bool> vis(1000006,false);
int last[1000006]; //上一个当前数字出现的位置.
int nex[1000006];  //下一个出现k次当数字的位置.
int lmx[1000006];  //左边第一个大于当前数字的位置.
int rmx[1000006];  //右边第一个大于当前数字的位置.
//不懂不懂..没思路...一开始想着很混乱,最大值是不同数字,又是隔开的,又是区间的,还要满足k个..晕..
//key:这个时候就要考虑,需要什么信息?可以预处理出来吗?
//①也不难..可以"预处理"之后,o(1)知道每个数字左边和右边第一个比它大的位置.
//②也可以o(1)知道每个数字从此位置起,往右直至其出现k次的位置在哪里.
//③还可以维护每个数字,上一次出现的位置.
//有了以上三个信息,可以枚举"每个位置作为第一个最大值"时,可以得到的贡献.
//即合法的左区间为(max(lmx,last),i],合法的右区间为[nex,rmx). last为上一个当前数字的位置,nex第k次出现当前数字的位置.
key:其实以前做过类似的题,应该是st表写的.也是只考虑每个点,对全部右区间的贡献,而对于左区间,只考虑到上一个当前数字为止.
这样就不会算重算漏.
//顾影自怜--这题官方题解是有问题的..
//https://codeforces.com/group/L9GOcnr1dm/contest/564037/attachments/download/28062/statements.pdf
void solve(){       //G
    cin>>n>>k;
    for(int i=1;i<=n+2;i++) vct[i].clear(),mp[i]=0,vis[i]=false,last[i]=0,nex[i]=0,lmx[i]=0,rmx[i]=0;
    for(int i=1;i<=n;i++) {
        cin>>arr[i];
        last[i]=mp[arr[i]];
        mp[arr[i]]=i;
        vct[arr[i]].emplace_back(i); //可知第k个arr[i]的位置.
    }
    if(k==1){} //最多的情况是(n+(1+n))/2,爆int...一开始没开longlong,怕MLE.然后wa2了,但是实际上完全不会MLE..也不用特判.
    stack<int> stk; //单调栈.
    for(int i=1;i<=n;i++){
        while(!stk.empty()&&arr[i]>=arr[stk.top()]) stk.pop();
        if(!stk.empty()) lmx[i]=stk.top();
        stk.emplace(i);  //这里不用判条件了,直接入栈
    }
    while(!stk.empty()) stk.pop();
    for(int i=n;i>=1;i--){
        while(!stk.empty()&&arr[i]>=arr[stk.top()]) stk.pop();
        if(!stk.empty()) rmx[i]=stk.top();
        else rmx[i]=n+1;
        stk.emplace(i); //这里不用判条件了,直接入栈
    }
    for(int i=1;i<=n;i++){
        if(vis[arr[i]]) continue;
        vis[arr[i]]=true;
        for(int j=0;j+k-1<(int)vct[arr[i]].size();j++){
            nex[vct[arr[i]][j]]=vct[arr[i]][j+k-1];
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++){
        if(!nex[i]||nex[i]>rmx[i]) continue;
        int l=max(lmx[i],last[i])+1;
        int r=rmx[i]-1;
        ans+=(i-l+1)*(r-nex[i]+1);
    }
    cout<<ans<<endl;
}

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

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

相关文章

最新三维视觉下的扩散模型综述——Diffusion Models in 3D Vision: A Survey

最新三维视觉下的扩散模型综述——Diffusion Models in 3D Vision: A Survey

目录 摘要 一、引言 二、扩散模型简介 A.扩散模型的介绍 B.扩散模型的数学基础 C.扩散模型的变体 D.三维视觉中的生成过程 三、三维视觉基础 A.三维表示 B.三维视觉中的深度学习方法 C.3D视觉中的挑战 四、三维扩散生成任务 A.无条件生成 B.图像到三维 C.文本到…
阅读更多...
JavaSE：运算符 (学习笔记)

JavaSE：运算符 (学习笔记)

目录 一&#xff0c;算术运算符 【1】 共同点&#xff1a; 【2】 不同点&#xff1a; 二&#xff0c;关系运算符 三&#xff0c;逻辑运算符 2&#xff0c;&和&&的区别和联系 { |和||的区别和联系 }---两题类似 四&#xff0c;赋值运算符 五&#xff0c;拓展…
阅读更多...
strtok函数详解

strtok函数详解

strtok函数 strtok 函数是一个字符串分割函数&#xff0c;用于将字符串分割成一系列的标记。这个函数通过一组分隔符字符来确定标记的边界&#xff0c;每次调用都会返回字符串中的下一个标记&#xff0c;并且将原始字符串中的分隔符替换为空字符‘\0’&#xff0c;从而实际上是…
阅读更多...
题目练习之二叉树那些事儿（续集）

题目练习之二叉树那些事儿（续集）

♥♥♥~~~~~~欢迎光临知星小度博客空间~~~~~~♥♥♥ ♥♥♥零星地变得优秀~也能拼凑出星河~♥♥♥ ♥♥♥我们一起努力成为更好的自己~♥♥♥ ♥♥♥如果这一篇博客对你有帮助~别忘了点赞分享哦~♥♥♥ ♥♥♥如果有什么问题可以评论区留言或者私信我哦~♥♥♥ ✨✨✨✨✨✨个人…
阅读更多...
【入门篇】确定字符串是否包含唯一字符——多语言版本

【入门篇】确定字符串是否包含唯一字符——多语言版本

题目跳转&#xff1a;确定字符串是否包含唯一字符 题目解析 这个问题要求我们判断一个字符串中的字符是否唯一&#xff08;忽略字母的大小写&#xff09;&#xff0c;并输出相应的结果。如果字符串中所有的字符都是唯一的&#xff0c;输出 YES&#xff1b;否则&#xff0c;输…
阅读更多...
ConcurrentModificationException：检测到并发修改完美解决方法

ConcurrentModificationException：检测到并发修改完美解决方法

&#x1f6a6; ConcurrentModificationException&#xff1a;检测到并发修改完美解决方法 &#x1f4a1; &#x1f6a6; ConcurrentModificationException&#xff1a;检测到并发修改完美解决方法 &#x1f4a1;摘要1. 什么是ConcurrentModificationException&#xff1f;&…
阅读更多...
并查集 How many tables(hdu 1213) How many answers are wrong(hdu 3038)

并查集 How many tables(hdu 1213) How many answers are wrong(hdu 3038)

目录 前言 并查集 并查集的初始化 并查集的合并 并查集合并的优化&#xff0c;路径压缩 How many tables(hdu 1213) 问题描述 输入 输出 问题分析 代码 带权并查集 How many answers are wrong(hdu 3038) 问题描述 输入 输出 问题分析 代码 前言 感觉并查集总共有两个应…
阅读更多...
JavaScript day01 笔记

JavaScript day01 笔记

一、引入方式 JavaScript 程序不能独立运行&#xff0c;它需要被嵌入 HTML 中&#xff0c;然后浏览器才能执行 JavaScript 代码。通过 script 标签将 JavaScript 代码引入到 HTML 中 1️⃣内部 通过 script 标签包裹 JavaScript 代码&#xff08;一般就写在</script>的…
阅读更多...
Notepad++ 最新官网中文版在线下载 附文本编辑器安装与基础使用教程

Notepad++ 最新官网中文版在线下载 附文本编辑器安装与基础使用教程

Notepad &#xff08;记事本&#xff09;是一个简单的文本编辑器&#xff0c;预装在所有版本的 Microsoft Windows 操作系统中。它的主要功能是创建、编辑和存储纯文本文件&#xff0c;通常以 .txt 格式保存。Notepad 的设计旨在提供一个轻量级的文本处理工具&#xff0c;适合快…
阅读更多...
使用C语言进行信号处理：从理论到实践的全面指南

使用C语言进行信号处理：从理论到实践的全面指南

1. 引言 在现代操作系统中&#xff0c;信号是一种进程间通信机制&#xff0c;它允许操作系统或其他进程向一个进程发送消息。信号可以用来通知进程发生了一些重要事件&#xff0c;如用户请求终止进程、硬件异常、定时器超时等。掌握信号处理技术对于开发健壮、高效的系统程序至…
阅读更多...
大数据入门-什么是HBase

大数据入门-什么是HBase

目录 一、概念 二、架构 1.Client 2.Zookeeper 3.HMaster 4.HRegionServer 三、特性 1.数据存储庞大 2.支持随机读写 3.轻松融入生态 4.数据强一致性 5.性能足够高效 四、适用场景 五、其他事宜 1.权益备注 2.支持博主 大数据入门系列文章 这里简单介绍的HBas…
阅读更多...
【笔记】自动驾驶预测与决策规划_Part6_不确定性感知的决策过程

【笔记】自动驾驶预测与决策规划_Part6_不确定性感知的决策过程

文章目录 0. 前言1. 部分观测的马尔可夫决策过程1.1 POMDP的思想以及与MDP的联系1.1.1 MDP的过程回顾1.1.2 POMDP定义1.1.3 与MDP的联系及区别POMDP 视角MDP 视角决策次数对最优解的影响 1.2 POMDP的3种常规解法1.2.1 连续状态的“Belief MDP”方法1. 信念状态的定义2. Belief …
阅读更多...
Vue2中使用firefox的pdfjs进行文件文件流预览

Vue2中使用firefox的pdfjs进行文件文件流预览

文章目录 1.使用场景2. 使用方式1. npm 包下载,[点击查看](https://www.npmjs.com/package/pdfjs-dist)2. 官网下载1. 放到public文件夹下面2. 官网下载地址[点我,进入官网](https://github.com/mozilla/pdf.js/tags?afterv3.3.122) 3. 代码演示4. 图片预览5. 如果遇到跨域或者…
阅读更多...
MFC图形函数学习06——画椭圆弧线函数

MFC图形函数学习06——画椭圆弧线函数

绘制椭圆弧线函数是MFC基本绘图函数&#xff0c;这个函数需要的参数比较多&#xff0c;共四对坐标点。前两对坐标点确定椭圆的位置与大小&#xff0c;后两对坐标确定椭圆弧线的起点与终点。 一、绘制椭圆弧线函数 原型&#xff1a;BOOL Arc(int x1,int y1,int x2,int y2…
阅读更多...
新版 idea 编写 idea 插件时，启动出现 ClassNotFound

新版 idea 编写 idea 插件时，启动出现 ClassNotFound

IntelliJ IDEA 2024.1.6 (Ultimate Edition) Build #IU-241.19072.14, built on August 8, 2024 Licensed to Sophia Tout Subscription is active until June 29, 2025. For educational use only. Runtime version: 17.0.111-b1207.30 amd64 Kotlin: 241.19072.14-IJ 新版本…
阅读更多...
信息安全工程师（83）Windows操作系统安全分析与防护

信息安全工程师（83）Windows操作系统安全分析与防护

一、Windows操作系统安全分析 系统漏洞&#xff1a; Windows操作系统由于其复杂性和广泛使用&#xff0c;可能存在一些已知或未知的漏洞。这些漏洞可能会被黑客利用&#xff0c;进行恶意攻击。微软会定期发布系统更新和补丁&#xff0c;以修复这些漏洞&#xff0c;提高系统的安…
阅读更多...
【嵌入式开发——ARM】1ARM架构

【嵌入式开发——ARM】1ARM架构

嵌入式领域&#xff0c;使用ARM架构的芯片公司可不占少数吧&#xff0c;intel的x86架构主要占据PC、服务器市场&#xff0c;ARM架构主要占据移动市场。x86架构和ARM架构不同的主要原因&#xff0c;是背后使用的计算机指令集不同。计算机有自己的语言系统&#xff08;汇编&#…
阅读更多...
31-自定义地图：分层地图

31-自定义地图：分层地图

利用自定义地图中的级别&#xff0c;可以让多个人同时在一张地图上工作。它还允许您在仿真过程中使用Python API在地图上加载和卸载层&#xff0c;就像分层的CARLA地图一样(layered CARLA maps)。 本指南将解释如何添加新级别&#xff0c;如何向级别添加资产&#xff0c;以…
阅读更多...
操作系统-磁盘

操作系统-磁盘

文章目录 磁盘的结构一、磁盘的物理结构二、磁盘的逻辑结构 磁盘的调度算法磁盘时间算法先来先服务&#xff08;FCFS - First-Come, First-Served&#xff09;最短寻道时间优先&#xff08;SSTF - Shortest Seek Time First&#xff09;扫描算法&#xff08;SCAN&#xff0c;也…
阅读更多...
【Linux】【信号操作】汇总整理

【Linux】【信号操作】汇总整理

信号&#xff08;Signals&#xff09;是操作系统中用于通知进程发生特定事件的一种机制。信号可以由软件或硬件触发&#xff0c;并且可以被进程捕获和处理。以下是信号的相关概念、常见信号列表、信号处理以及相关API的汇总整理。 信号概述 信号是操作系统向进程发出的通知&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023