CSP 2020-12

最新推荐文章于 2024-03-08 10:35:43 发布
最新推荐文章于 2024-03-08 10:35:43 发布
阅读量408 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tangtanghhh/article/details/112488756
版权

CSP 2020-12

3 带配额的文件系统

tag:复杂模拟 结构体

题面链接

http://118.190.20.162/view.page?gpid=T121.

题意

  模拟一个文件系统，和我们所用的文件系统类似，是树形结构；不同之处在于，可能会对文件夹有容量限制。对于给定的三种操作：C(存储文件)，R(删除文件)，Q(设定容量限制)，输出操作结果(Y/N)。

思路

   利用结构体进行模拟，每个结点包括：名称(name)、子节点(child)、父节点(parent)、孩子文件配额(ld)、后代文件配额(lr)、孩子文件大小(sizec)、后代文件大小(sizeac)、文件大小(size)、文件类型(type)等属性。
  对于三种操作分别进行模拟，并给出结果。整个程序的思路导图如下图所示。
在这里插入图片描述
  需要特别注意的一点是：当C操作失败时，需要删除新创建的目录文件，否则下次创建同名普通文件时会出错。

附样例的文件系统图：
样例1：
在这里插入图片描述
样例2：
在这里插入图片描述

源码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct node{
    string name="root";//名称
    vector<struct node*> child;//孩子节点指针
    struct node* parent=NULL;//父节点指针
    ll ld=0,lr=0,sizec=0,sizeac=0,size=0;
    // ld:孩子文件配额，lr:后代文件配额，sizec:孩子文件大小,sizeac:后代文件大小，size:普通文件大小
    bool type=false;//文件类型，false：目录文件；true：普通文件。
};

node root;//根节点

//判断p结点及所有祖先结点，后代文件配额是否满足
bool panduan(node *p,ll bianhua){
    if(p==NULL) return true;
    if((p->lr==0 || p->sizeac+bianhua<=p->lr) && panduan(p->parent,bianhua)){//当前结点后代文件配额满足，且所有祖先结点后代文件配额均满足
        p->sizeac+=bianhua;return true;
    }
    else return false;
}

vector<string> v;//保存路径

//C操作
// C /A/B/1 1024
void opec(string s,ll size){
    string dir="";
    //处理字符串,不必考虑v为空的情况
    v.clear();//清空v
    //获取路径
    for(ll i=1;i<s.size();i++){
        if(s[i]=='/'){v.push_back(dir);dir="";continue;}
        dir+=s[i];
    }
    v.push_back(dir);

    node *p=&root;//当前结点指针
    ll len;//长度
    bool isp;//标记
    bool flag=true;//标记目录是否是第一个被创建的
    node *huisu;
    ll ii;
    //处理前面目录
    for(ll i=0;i<v.size()-1;i++){
        len=p->child.size();
        isp=true;
        for(ll j=0;j<len;j++){
            //找到该目录
            if(p->child[j]->name==v[i]){
                //该目录为普通文件，此次操作失败
                if(p->child[j]->type){cout<<"N\n";return;}
                //该目录已存在，进行下层目录查找
                else{
                    p=p->child[j];//修改当前查找结点的指针
                    isp=false;break;
                }
            }
        }
        //没有找到该目录，创建新目录
        if(isp){
            node *n;
            n=new node;
            n->name=v[i];
            n->parent=p;
            //记录新创建目录的起点，以便于删除
            if(flag){
                flag= false;
                huisu=p;
                ii=len;
            }
            p->child.push_back(n);
            p=n;//修改当前查找结点的指针
        }
    }
    //处理最后的普通文件
    len=p->child.size();
    //判断该文件是否已存在
    for(ll i=0;i<len;i++){
        //该文件已存在
        if(p->child[i]->name==v[v.size()-1]){
            //该文件为目录文件，操作失败
            if(p->child[i]->type== false) {cout<<"N\n";return;}
            //该文件为普通文件
            ll bianhua=p->child[i]->size-size;//变化值:旧文件-新文件
            //大小未变化，直接返回
            if(bianhua==0){cout<<"Y\n";return;}
            //新文件大小<旧文件，直接更新
            else if(bianhua>0){
                p->child[i]->size=size;
                p->sizec-=bianhua;//更新父节点的孩子文件大小
                //更新所有祖先节点的后代文件大小
                while(p!=NULL){
                    p->sizeac-=bianhua;
                    p=p->parent;
                }
                cout<<"Y\n";return;
            }
            //新文件大小>旧文件，判断是否超过配额
            else{
                bianhua*=-1;
                //满足配额
                if((p->ld==0 || p->sizec+bianhua<=p->ld) && panduan(p,bianhua)){//孩子文件配额，后代文件配额均满足时
                    p->child[i]->size=size;//更新文件大小
                    p->sizec+=bianhua;//更新父节点，孩子文件大小
                    cout<<"Y\n";return;
                }
                    //不满足
                else{cout<<"N\n";return;}
            }
        }
    }
    //该文件不存在，创建新文件
    //满足配额
    if((p->ld==0 || p->sizec+size<=p->ld) && panduan(p,size)){//孩子文件配额，后代文件配额均满足时
        p->sizec+=size;
        node *n;
        n=new node;
        n->name=v[v.size()-1];
        n->size=size;
        n->type= true;//普通文件
        n->parent=p;
        p->child.push_back(n);
        cout<<"Y\n";return;
    }
    //不满足
    else{
        //删除已创建目录***********************************
        if(flag==false){huisu->child.erase(huisu->child.begin()+ii);}
        cout<<"N\n";return;
    }
}

//R操作
// R /A/B
void oper(string s){
    string dir="";
    //处理字符串,不必考虑v为空的情况
    v.clear();//清空v
    //获取路径
    for(ll i=1;i<s.size();i++){
        if(s[i]=='/'){v.push_back(dir);dir="";continue;}
        dir+=s[i];
    }
    v.push_back(dir);

    node *p=&root;//当前结点指针
    ll len;//长度
    bool isp;//标记
    //处理前面目录
    for(ll i=0;i<v.size()-1;i++){
        len=p->child.size();
        isp=true;
        for(ll j=0;j<len;j++){
            //找到该目录
            if(p->child[j]->name==v[i]){
                //该目录为普通文件，返回
                if(p->child[j]->type){cout<<"Y\n";return;}
                //该目录存在，进行下层目录查找
                else{
                    p=p->child[j];//修改当前查找结点的指针
                    isp=false;break;
                }
            }
        }
        //没有找到该目录，返回
        if(isp){cout<<"Y\n";return;}
    }
    //处理最后的普通文件 or 目录文件
    len=p->child.size();
    //判断该文件是否存在
    for(int i=0;i<len;i++){
        //该文件存在
        if(p->child[i]->name==v[v.size()-1]){
            //该文件为目录
            if(p->child[i]->type== false){
                ll size=p->child[i]->sizeac;//目录的所有后代文件大小
                p->child.erase(p->child.begin()+i);//删除此节点
                //所有祖先结点的后代文件大小减去size
                while(p!=NULL){
                    p->sizeac-=size;
                    p=p->parent;
                }
                cout<<"Y\n";return;
            }
            //该文件为普通文件
            else{
                ll size=p->child[i]->size;
                p->child.erase(p->child.begin()+i);//删除此节点
                p->sizec-=size;//父结点的孩子文件大小减去size
                //所有祖先结点的后代文件大小减去size
                while(p!=NULL){
                    p->sizeac-=size;
                    p=p->parent;
                }
                cout<<"Y\n";return;
            }
        }
    }
    //该文件不存在，返回
    cout<<"Y\n";return;
}

//Q操作
//Q / 0 1
void opeq(string s,ll ld,ll lr){
    string dir="";
    //处理字符串,需要考虑v为空的情况
    v.clear();//清空v
    //获取路径
    for(ll i=1;i<s.size();i++){
        if(s[i]=='/'){v.push_back(dir);dir="";continue;}
        dir+=s[i];
    }
    v.push_back(dir);

    node* p=&root;//当前结点指针
    if(v[0]==""){//对根节点的操作
        //满足配额
        if((ld==0 || p->sizec<=ld) && (lr==0 || p->sizeac<=lr)){
            p->ld=ld;p->lr=lr;
            cout<<"Y\n";return;
        }
        //不满足
        else{cout<<"N\n";return;}
    }
    int len;//长度
    bool isp;//标记
    //处理目录
    for(ll i=0;i<v.size();i++){
        len=p->child.size();
        isp=true;
        for(ll j=0;j<len;j++){
            //找到该目录
            if(p->child[j]->name==v[i]){
                //该目录为普通文件，此次操作失败
                if(p->child[j]->type){cout<<"N\n";return;}
                //该目录已存在，进行下层目录查找
                else{
                    p=p->child[j];//修改当前查找结点的指针
                    //最后一个文件时，进行配额判断
                    if(i==v.size()-1){
                        //满足配额
                        if((ld==0 || p->sizec<=ld) && (lr==0 || p->sizeac<=lr)){
                            p->ld=ld;p->lr=lr;
                            cout<<"Y\n";return;
                        }
                        //不满足
                        else{cout<<"N\n";return;}
                    }
                    isp=false;break;
                }
            }
        }
        //没有找到该目录，此次操作失败
        if(isp){cout<<"N\n";return;}
    }
}
int main() {
    ll n;
    string s;
    ll size1,size2;
    char c;
    cin>>n;
    while(n--){
        cin>>c;
        switch(c){
            case 'C':
                cin>>s>>size1;
                opec(s,size1);
                break;
            case 'R':
                cin>>s;
                oper(s);
                break;
            case 'Q':
                cin>>s>>size1>>size2;
                opeq(s,size1,size2);
                break;
        }
    }
    return 0;
}
/*
10
C /A/B/1 1024
C /A/B/2 1024
C /A/B/1/3 1024
C /A 1024
R /A/B/1/3
Q / 0 1500
C /A/B/1 100
Q / 0 1500
R /A/B
Q / 0 1

9
Q /A/B 1030 2060
C /A/B/1 1024
C /A/C/1 1024
Q /A/B 1024 0
Q /A/C 0 1024
C /A/B/3 1024
C /A/B/D/3 1024
C /A/C/4 1024
C /A/C/D/4 1024

10
C /A/B 1
Q /A 2 2
C /A/C/D 1024
C /A/C 1
Q /A 0 0
C /A/C 1

*/
琅歌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【CCF CSP 2020-12】第21次CCF计算机软件能力认证
CUMT_William_Liu的博客
04-06 716
1.期末预测之安全指数 2.期末预测之最佳阈值 3.带配额的文件系统   非常非常非常巨大的 大模拟。分析一下题意，这个题主要包括三个操作：创建文件、删除文件、修改目录文件配额。而且每个文件应该包含了一些信息，可以考虑结构体，但主要问题都是如何通过一个文件名找到记录改文件存储信息的内存空间。这里需要注意的是：文件名可能不唯一（如给出的样例图），但带上路径的文件名一定是唯一的！可以利用这个特点去使用unordered_map记录。   创建文件的时候需要注意的一点是：一个操作如果不成功是不会对文件系统产生任何
2020年十二月ccf-csp认证总结（内附个人题解）
热门推荐
qq_44109982的博客
12-13 1万+
吐槽一下这个在线评测功能，平均四十分钟才能看到提交结果。。 本次成绩还没出，结束的时候第五题还没出分，所以是230分 第一题送分题，输入俩数组a[n],b[n]，求a[i]*b[i]从1-n的求和 第二题有点小坑，是说在第一题的基础上，求一个最优阙值，本着前两题很简单的原则写了两层循环，过了好久才发现只得了70分。。 ...
CCF CSP 202012-3 带配额的文件系统 详解100分
最新发布
jokerMingge的博客
03-08 447
本题细节较多，但本题解思路清晰，代码简洁，实际代码量不超过150行。思路：从根节点向下构建多叉树，建立结构体如下，随后根据题目操作对多叉树进行操作。
CSP 2020-12-3 化学方程式（C++满分）
Tilbur的博客
04-02 476
CSP 2020-12-3 化学方程式（C++满分）题目一、思路二、全部代码总结 <font color=#999AAA 开个贴记录一下自己写过的代码，苦逼大三csp想考300 文章目录题目一、思路二、全部代码总结 题目 一、思路 1.切割“=”左右，用String字符串来保存等式左右； 2.同样步骤对“+”切割，计算每个元素的出现次数； 切割示例代码 vector<string> split(string s){ vector<string> data
举步维艰——回顾CSP2020
Bell的博客
12-05 818
举步维艰——回顾CSP2020 复出 7.20 上一年CSP-J水过一等奖之后真丢人 ，转身跳进文化课，结果中考还是炸裂，自主招生也没有过，只有综能保底进了SMMS。 7.25~7.30 参加夏令营的集训，学了一波Treap，接触树链剖分。 后来还有一次夏令营没有去，在家里做了几道往年NOIP的题。 9.1 SMMS高一信息学竞赛班组建完毕，开始正式训练，至此，我算是正式复出了。 从此以后，每周有三晚晚修到机房套题训练，周六讲评试题。 初赛 Sept.~Oct. 某天想起初赛的事情，每天中午开始练习初赛
CSP2020-senior初赛-C-A.pdf
10-11
CSP2020-senior初赛-C-A.pdf
2020 CSP-J 入门级 初赛 第一轮 试题与解析 PDF.rar
09-08
"CSP2020-senior初赛-C-A.pdf"和"CSP2020-junior初赛真题-C++-B.pdf"分别代表了高级组和初级组的C语言和C++语言的初赛试题。"CSP2020-junior-C++-B.pdf"可能是初级组C++语言的试题，这些试题通常包含多个编程题目，...
CSP-2020J1答案
10-04
https://blog.csdn.net/m0_45682806/article/details/108909527，试题
信息学奥赛入门组复赛CSP 2020-J2题目详解.pdf
07-13
【信息学奥赛入门组复赛CSP 2020-J2题目详解】 本资料主要涉及的信息学竞赛是CCF非专业级软件能力认证（CSP-J/S），特别是2020年第二轮认证的入门组（CSP 2020-J2）。这个竞赛旨在培养青少年的计算机科学能力，通过...
CSP（共同空间模式）matlab代码
10-22
关于CSP（共同空间模式）算法的代码。 共空间模式（CSP）是一种对两分类任务下的空域滤波特征提取算法，能够从多通道的脑机接口数据里面提取出每一类的空间分布成分。公共空间模式算法的基本原理是利用矩阵的对角化，找到一组最优空间滤波器进行投影，使得两类信号的方差值差异最大化，从而得到具有较高区分度的特征向量。
CCF/CSP2013-2019第一题C++，JAVA源码
07-17
这是一份CCF/CSP从2013-2019年第一题所有答案，答案全部是自己写的都已经运行到100分，里面包含CPP和JAVA的源码，有需要的大家自行下载参考吧
2020-12 CSP真题
xxayt的博客
11-30 168
2020-12 CSP真题 1. 期末预测之安全指数 思路： #include<bits/stdc++.h> using namespace std; #define maxn 100005 int n, w[maxn], s[maxn], sum = 0; int main(){ cin >> n; for(int i = 1; i <= n; i++){ cin >> w[i] >> s[i]; s
带配额的文件系统
qq_54256430的博客
09-12 1020
题目背景 小 H 同学发现，他维护的存储系统经常出现有人用机器学习的训练数据把空间占满的问题，十分苦恼。 查找了一阵资料后，他想要在文件系统中开启配额限制，以便能够精确地限制大家在每个目录中最多能使用的空间。 文件系统概述 文件系统，是一种树形的文件组织和管理方式。在文件系统中，文件是指用名字标识的文件系统能够管理 的基本对象，分为普通文件和目录文件两种，目录文件可以被简称为目录。目录中有一种特殊的目录被叫做根目录。 除了根目录外，其余的文件都有名字，称为文件名。合法的文件名是一个由若干数字（[0..
CCF-CSP 202012-3 带配额的文件系统
想买很多漂亮衣服但是买不起的博客
06-04 996
CCF
ccf 202012-3 带配额的文件系统
qq_34857620的博客
02-20 1750
这是CSP认证 第三题的模拟题 题目背景 小 H 同学发现，他维护的存储系统经常出现有人用机器学习的训练数据把空间占满的问题，十分苦恼。 查找了一阵资料后，他想要在文件系统中开启配额限制，以便能够精确地限制大家在每个目录中最多能使用的空间。 文件系统概述 文件系统，是一种树形的文件组织和管理方式。在文件系统中，文件是指用名字标识的文件系统能够管理 的基本对象，分为普通文件和目录文件两种，目录文件可以被简称为 目录。目录中有一种特殊的目录被叫做根目录 。 除了根目录外，其余的文件都有名字，称为文件名。合法的文
CCF-202012-3-带配额的文件系统
qq_39507939的博客
03-27 544
题意： 给你n条指令，三种操作。1.创建普通文件。2.删除普通文件后目录。3.给目录设置配额。判断每条指令是否执行成功 题解： 将数据以树的形式存储下来，在创建普通文件时，注意祖先节点的配额是否超出。 代码如下： #include<bits/stdc++.h> using namespace std; typedef long long ll; const int maxn=2e6+10; int n,lenP,tot; struct node{ ll LD,LR,curLD,cur
CCF 202012-3 带配额的文件系统 //大模拟 100%
Rshs
01-06 2945
题目 题意 模拟一个文件系统，要求此文件系统实现目录功能，创建文件功能，删除文件功能，以及对子树的文件大小之和配置限额。 思路 大模拟，注意到文件系统树的高度小于20，那么可以记录每个节点的父亲节点，暴力往上跳修改每个结点的子树的文件大小和。注意开long long，注意在创建文件时产生的目录要回溯删除掉。 我好像从来没有写过这种正经的大模拟题，写了两个半小时才满分。。。 /* Author : Rshs */ #include<bits/stdc++.h> using namespac
CCF 202012-3 带配额的文件系统 大模拟 100分
weixin_44142774的博客
03-04 738
本题参考了一位大哥的代码，可以说是拍案叫绝！ 一 题目描述： 二 代码：感觉写的比较清晰了 #include <iostream> #include <map> #include <string> #include <algorithm> #include <sstream> #include <vector> #include <limits.h> using namespace std; const int max
csp2020csp-j复赛答案
07-27
很抱歉，我无法提供csp2020csp-j复赛的答案。 #### 引用[.reference_title] - *1* [CSP-J2020复赛题解](https://blog.csdn.net/qq_53804631/article/details/112719966)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [2020CSP复赛赛试题答案](https://blog.csdn.net/JUNSON818/article/details/119962012)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值