【CSP】2020-12-3 带配额的文件系统 100分完整代码 最长的大模拟 使用指针优化数据结构

最新推荐文章于 2024-05-04 22:53:51 发布
最新推荐文章于 2024-05-04 22:53:51 发布
阅读量2k 收藏 52
点赞数 41
文章标签： 数据结构 c++ stl 学习 算法 CSP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65708726/article/details/136960185
版权

2020-12-3 带配额的文件系统 最长的大模拟 使用指针优化数据结构

索引

历年CSP认证考试真题题解总汇持续更新

2020-12-3 带配额的文件系统 最长的大模拟 使用指针优化数据结构

这题可以说是最长第三题了， 但是逻辑并不是非常的复杂，关键是使用一个好的数据结构和编程的思想，越是复杂的题就越是要暴力，这种情况下即使有一些重复的计算也没关系，有一个简洁清晰的逻辑最为重要。 这种情况下就是要用时间换取逻辑的清晰了。

写这题的经历非常曲折差不多写了快三版才写到100分，而且其中的一些问题还是没有找到，如果有大神有思路希望告知，最后是参考了别人的代码，修改了最后一版，才拿到100分，考试遇到了这题基本上就g了。

可能做题的意义就是见识这些大风大浪。

思路

除去题目给出要求，还要注意一下几点

新建文件的指令

  1. 指令执行不成功，文件系统不能有变化
  2. 新建文件要在路径上所有的目录增加大小
  3. 注意新建文件的时候要看，原本的文件有没有存在，目录增加的大小要根据原本的文件大小算

删除文件的指令

  1. 如果删除的是文件夹 则上级的目录的大小要删除文件夹的所有后代大小

配额指令

这个没啥比较简单，按题目来就行

遇到的问题(学到的东西)

  1. 数据结构选取的有问题，导致逻辑异常复杂

一开始想着用一个邻接表存文件之间的关系，然后用数组存文件的数据，然后用索引来建立两者的关系，然后我虽然清楚其中的逻辑，但是写代码异常的难受，就是每个模块之间耦合性非常的强，导致出问题，一出一长串，最后出现的错误，没有很长的测试数据，都找不到bug出在哪里，所以以后要尽量避免这种复杂逻辑的，用一些直观的数据结构更好。

总共写了250行。

如果代码写了超过了200行那么一定是逻辑有问题。

最后这一版过了acwing 7/15个测试数据，在官网拿到了40分

在这里插入图片描述

image-20240322213821258

  1. 看了别人的思路，使用了指针的数据结构

改用了指针的数据结构，但是判断逻辑几乎没有改。使用了指针的结构方便了不少，比之前的数据结构方便不少。但是尤其是新建文件的逻辑，耦合度非常的高，要是修一个bug得好久，并且就像是的机器学习过拟合一样，只能适用于特殊情况，出了问题还得再加特殊情况，一直打补丁真的很恶心，最后这一版也是改到了

acwing 15/15个测试点 csp官网40分

在这里插入图片描述

在这里插入图片描述

期间也是出现了一些问题

  • 使用指针怎么申请空间（不能是直接用声明变量的形式声明）

错误的：

	if (i >= fs.size() - 1) // 还未创建
        {
            struct dfile temp;
            if (i == path.size() - 1)
            {
                temp.size = file_size;
                temp.type = 0;
            }
            else
            {
                temp.child_size += t_file_size;
                temp.dir_size += i == path.size() - 2 ? t_file_size : 0;
                temp.type = 1;
           }
        // 建立索引
        fs.back()->child[path[i]] = &temp;

这样申请空间会导致，下次temp再用的时候这个就会被释放，建立了索引也没用，数据也会丢失

正确的：使用new申请空间

        if (i >= fs.size() - 1) // 还未创建
        {
            struct dfile *temp = new dfile(1);
            if (i == path.size() - 1)
            {
                temp->size = file_size;
                temp->type = 0;
            }
            else
            {
                temp->child_size += t_file_size;
                temp->dir_size += i == path.size() - 2 ? t_file_size : 0;
                temp->type = 1;
            }
            // 建立索引
            fs.back()->child[path[i]] = temp;
  • 初值的问题

虽然设置的结构体是全局变量，但是结构体内部的变量的值还是需要设置初值的。

struct dfile
{
    long long size = 0;
    long long dir_size = 0;    //
    long long child_size = 0;  // 后代大小
    long long dir_limit = 0;   // 目录配额
    long long child_limit = 0; // 孩子配额
    bool isDir = 0;            // 1是目录 0是文件
    map<string, struct dfile *> child;
    dfile(int t) : isDir(t) {}
};
  1. 优化了新建文件的逻辑

使用了耦合度比较低的逻辑，虽然要多花一些时间，但是逻辑非常清晰，然后过了样例后，直接就100分了。
在这里插入图片描述

这里面也学会了一些用法

  • string的一些方法
vector<string> split(const string &s, const string &c = "")
{
    vector<string> res;
    for (long long i = 0, j = 0; i < s.size(); i = j + 1)
    {
        j = s.find(c, i);
        if (j == -1)
            j = s.size();
        res.push_back(s.substr(i, j - i));
    }
    return res;
}

从i开始找到c字符串的下标，如果没有找到则返回-1

s.find(c,i)

分割字符串 从i开始返回j-i个长度的字符串

s.substr(i,j-i)
  • 空指针是nullptr
    for (int i = 1; i < path.size() && p; i++)
    {
        // 向前判断判断i-1的时候的p 不会判断最后一个p（文件的指针）
        if (!p->isDir or (p->child_limit && p->child_size + sz > p->child_limit) or (i == path.size() - 1 && p->dir_limit && p->dir_size + sz > p->dir_limit))
            return false;
        p = p->child.count(path[i]) ? p->child[path[i]] : nullptr;
    }

可以直接判断 &&p 判断p为不为空

  • c++可以直接使用 and or等

在C语言ios646.h头文件种定义了关于and、or、not逻辑运算符。

and可以代替&&

or可以替代||

not可以替代!

40分stl代码

#include <bits/stdc++.h>
using namespace std;
struct file
{
    string name;
    long long size;

    long long dir_size;
    long long child_size;
    long long dir_limit;
    long long child_limit;
    int type = -1; // 0是普通文件 1是目录文件
    int to_paths;  // 用于寻找文件内的索引
} f[2000001];
long long top;
map<long long, vector<long long>> paths;
long long indexes; // 提供一个不重复的索引
vector<string> convert_string_path(string file_path)
{
    vector<string> res;
    string temp = "";
    for (int i = 1; i < file_path.size(); i++)
    {
        if (file_path[i] != '/')
        {
            temp += file_path[i];
        }
        else
        {
            res.push_back(temp);
            temp.clear();
        }
    }
    if (!temp.empty())
        res.push_back(temp);
    return res;
}
int find_file_from_dir(long long dir, string name) // 返回文件位置
{
    vector<long long> temp = paths[f[dir].to_paths];
    for (int i = 0; i < temp.size(); i++)
    {
        if (name == f[temp[i]].name)
        {
            return temp[i];
        }
    }
    return -1;
}
bool deal_creat(string file_path, long long file_size) // 创建普通文件
{
    vector<string> path = convert_string_path(file_path);
    vector<long long> real_path;
    bool exist = false; // 这个文件是不是已经存在

    if (f[0].child_limit && f[0].child_size + file_size > f[0].child_limit)
        return false;
    if (f[0].dir_limit && path.size() == 1 && f[0].dir_size + file_size > f[0].dir_limit)
        return false;

    long long dir = 0; // 先从根目录开始
    for (int i = 0; i < path.size(); i++)
    {
        long long file_locate = find_file_from_dir(dir, path[i]);
        if (file_locate == -1)
        {
            // 先申请一个目录的位置
            dir = top;
            real_path.push_back(top++);
        }
        else
        {
            if (i == path.size() - 1) // 如果是最后一个 则是文件不是目录
            {
                if (f[file_locate].type == 1)
                {
                    return false;
                }
                else // 替换这个文件
                {
                    exist = true;
                    real_path.push_back(file_locate);
                }
            }
            else // 找到了文件看看是不是目录
            {
                if (f[file_locate].type == 0) // 如果是普通文件
                {
                    return false;
                }
                else // 如果该目录存在
                {
                    real_path.push_back(file_locate);
                    dir = file_locate;
                }
            }
        }
    }
    long long t_file_size = file_size;
    if (exist)
        t_file_size = file_size - f[real_path[real_path.size() - 1]].size;
    for (int i = 0; i < real_path.size() - 1; i++)
    {
        if (f[real_path[i]].child_limit && f[real_path[i]].child_size + t_file_size > f[real_path[i]].child_limit)
            return false;
        if (f[real_path[i]].dir_limit && i == real_path.size() - 2 && f[real_path[i]].dir_size + t_file_size > f[real_path[i]].dir_limit)
            return false;
    }
    dir = 0;
    if (path.size() == 1)
        f[0].dir_size += t_file_size;
    f[0].child_size += t_file_size;
    for (int i = 0; i < path.size(); i++)
    {
        if (f[real_path[i]].type == -1) // 还未创建
        {
            f[real_path[i]].name = path[i];
            if (i == path.size() - 1)
            {
                f[real_path[i]].size = file_size;
                f[real_path[i]].type = 0;
            }
            else
            {
                f[real_path[i]].child_size += t_file_size;
                f[real_path[i]].dir_size += i == path.size() - 2 ? t_file_size : 0;

                f[real_path[i]].to_paths = indexes++; // 为这个文件构建索引
                f[real_path[i]].type = 1;
            }
            // 建立索引
            paths[dir].push_back(real_path[i]);
        }
        else // 如果已经创建了
        {
            if (i == path.size() - 1)
            {
                f[real_path[i]].size = file_size;
            }
            else
            {
                f[real_path[i]].child_size += t_file_size;
                f[real_path[i]].dir_size += i == path.size() - 2 ? t_file_size : 0;
            }
        }
        dir = f[real_path[i]].to_paths;
    }
    return true;
}
bool deal_remove(string file_path)
{
    vector<string> path = convert_string_path(file_path);
    vector<long long> real_path;
    real_path.push_back(0); // 把根目录添加
    int dir = 0;
    for (int i = 0; i < path.size(); i++)
    {
        long long file_locate = find_file_from_dir(dir, path[i]);
        if (file_locate == -1)
        {
            return true;
        }
        real_path.push_back(file_locate);
        dir = file_locate;
    }

    // 删去索引
    int file_locate = f[real_path[real_path.size() - 2]].to_paths;
    vector<long long> temp = paths[file_locate];
    for (int i = 0; i < temp.size(); i++)
    {
        if (temp[i] == real_path[real_path.size() - 1])
        {
            paths[file_locate].erase(paths[file_locate].begin() + i);
            break;
        }
    }
    int type = f[real_path[real_path.size() - 1]].type;
    if (type == 1)
    {
        paths.erase(f[real_path[real_path.size() - 1]].to_paths);
        // 删除占用
        long long file_size = f[real_path[real_path.size() - 1]].child_size;
        for (int i = 0; i < real_path.size() - 1; i++)
        {
            f[real_path[i]].child_size -= file_size;
        }
    }
    else
    {
        // 删除占用
        long long file_size = f[real_path[real_path.size() - 1]].size;
        for (int i = 0; i < real_path.size() - 1; i++)
        {
            f[real_path[i]].child_size -= file_size;
            if (i == real_path.size() - 2)
                f[real_path[i]].dir_size -= file_size;
        }
    }
    return true;
}
long long get_sum_size(int dir)
{
    vector<long long> temp = paths[f[dir].to_paths];
    long long sum = 0;
    for (auto item : temp)
    {
        if (f[item].type == 0)
        {
            sum += f[item].size;
        }
        else if (f[item].type == 1)
        {
            sum += get_sum_size(item);
        }
    }
    return sum;
}
bool deal_q(string file_path, long long ld, long long lr)
{
    long long dir = 0;
    vector<string> path = convert_string_path(file_path);
    vector<long long> real_path;
    real_path.push_back(0);
    for (int i = 0; i < path.size(); i++)
    {
        long long file_locate = find_file_from_dir(dir, path[i]);
        if (file_locate == -1)
            return false;
        if (f[file_locate].type == 0) // 如果不是目录文件
            return false;
        real_path.push_back(file_locate);
        dir = file_locate;
    }
    long long pos = real_path[real_path.size() - 1];
    if (ld != 0) // 检查孩子文件的大小是不是超过限制了
    {
        vector<long long> temp = paths[f[pos].to_paths];
        long long sum = 0;
        for (int i = 0; i < temp.size(); i++)
        {
            if (f[temp[i]].type == 0)
            {
                sum += f[temp[i]].size;
            }
        }
        if (sum > ld) // 检查后代文件的总和是不是超过了限制
            return false;
    }
    if (lr != 0)
    {
        long long sum = get_sum_size(pos);
        if (sum > lr)
            return false;
    }
    f[pos].child_limit = lr;
    f[pos].dir_limit = ld;
    return true;
    // f[real_path[real_path.size() - 1]].child_limit
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    // freopen("1.txt", "r", stdin);
    int n;
    cin >> n;
    // 初始化根目录
    f[0].name = "";
    f[0].type = 1;
    f[0].to_paths = indexes++;
    top++;
    for (int i = 0; i < n; i++)
    {
        string type;
        cin >> type;
        if (type == "C")
        {
            string file_path;
            long long file_size;
            cin >> file_path >> file_size;
            if (deal_creat(file_path, file_size))
                cout << "Y" << endl;
            else
                cout << "N" << endl;
        }
        if (type == "R")
        {
            string file_path;
            cin >> file_path;
            if (deal_remove(file_path))
                cout << "Y" << endl;
        }
        if (type == "Q")
        {
            string file_path;
            long long ld, lr;
            cin >> file_path >> ld >> lr;
            if (deal_q(file_path, ld, lr))
                cout << "Y" << endl;
            else
                cout << "N" << endl;
        }
    }
    return 0;
}

acwing 15/15 csp官网40分代码

#include <bits/stdc++.h>
using namespace std;
struct dfile
{
    long long size;
    long long dir_size = 0;
    long long child_size = 0;
    long long dir_limit = 0;
    long long child_limit = 0;
    int type = -1; // 0是普通文件 1是目录文件
    map<string, struct dfile *> child;
    dfile(int t) : type(t) {}
};
struct dfile root(1);
vector<string> convert_string_path(string file_path)
{
    vector<string> res;
    string temp = "";
    for (int i = 1; i < file_path.size(); i++)
    {
        if (file_path[i] != '/')
        {
            temp += file_path[i];
        }
        else
        {
            res.push_back(temp);
            temp.clear();
        }
    }
    if (!temp.empty())
        res.push_back(temp);
    return res;
}
bool deal_creat(string file_path, long long file_size) // 创建普通文件
{
    vector<string> path = convert_string_path(file_path);
    bool exist = false; // 这个文件是不是已经存在

    struct dfile *p = &root;
    vector<struct dfile *> fs;
    fs.push_back(p);
    bool newdir = false; // 记录有没有新的文件夹产生
    // 检查目录是不是被文件占用
    for (int i = 0; i < path.size() - 1; i++)
    {
        if (p->child.count(path[i]))
        {
            // 找到了文件看看是不是目录
            struct dfile *temp = p->child[path[i]];
            if (temp->type == 0) // 如果是普通文件
                return false;
            p = temp;
            fs.push_back(p);
        }
        else
            newdir = true;
    }
    // 文件名是不是被目录占用
    // 只有没有新建文件夹的时候才检查
    if (!newdir)
    {
        struct dfile *last = fs.back();
        if (last->child.count(path.back()))
        {
            if (last->child[path.back()]->type == 1)
                return false;
            exist = true;
            fs.push_back(last->child[path.back()]);
        }
        else
        {
            fs.push_back(new dfile(0));
        }
    }
    // 判断大小限制是不是符合
    long long t_file_size = file_size;
    if (exist)
        t_file_size = file_size - fs.back()->size;

    for (int i = 0; i < fs.size(); i++)
    {
        if (fs[i]->type == 1 && fs[i]->child_limit && fs[i]->child_size + t_file_size > fs[i]->child_limit)
            return false;
        if (fs[i]->type == 1 && !newdir && fs[i]->dir_limit && i == fs.size() - 2 && fs[i]->dir_size + t_file_size > fs[i]->dir_limit)
            return false;
    }

    // 给路径上的文件夹增加大小
    fs[0]->child_size += t_file_size;
    if (path.size() == 1)
        fs[0]->dir_size += t_file_size;
    for (int i = 0; i < path.size(); i++)
    {
        if (i >= fs.size() - 1) // 还未创建
        {
            struct dfile *temp = new dfile(1);
            if (i == path.size() - 1)
            {
                temp->size = file_size;
                temp->type = 0;
            }
            else
            {
                temp->child_size += t_file_size;
                temp->dir_size += i == path.size() - 2 ? t_file_size : 0;
                temp->type = 1;
            }
            // 建立索引
            fs.back()->child[path[i]] = temp;
            fs.push_back(temp);
        }
        else // 如果已经创建了
        {
            if (i == path.size() - 1)
            {
                fs[i + 1]->size = file_size;
                fs[i]->child[path[i]] = fs[i + 1];
            }
            else
            {
                fs[i + 1]->child_size += t_file_size;
                fs[i + 1]->dir_size += i == path.size() - 2 ? t_file_size : 0;
            }
        }
    }
    return true;
}
bool deal_remove(string file_path)
{
    vector<string> path = convert_string_path(file_path);
    vector<struct dfile *> fs;
    fs.push_back(&root);

    // 判断路径存不存在
    struct dfile *p = &root;
    for (int i = 0; i < path.size(); i++)
    {
        if (!p->child.count(path[i]))
            return true;
        p = p->child[path[i]];
        fs.push_back(p);
    }

    // 删去索引
    fs[fs.size() - 2]->child.erase(path.back());
    // 删除占用
    int type = fs.back()->type;
    if (type == 1) // 如果是文件夹
    {
        // 删除文件夹占用
        long long file_size = fs.back()->child_size;
        for (int i = 0; i < fs.size() - 1; i++)
        {
            fs[i]->child_size -= file_size;
        }
    }
    else
    {
        // 删除文件占用
        long long file_size = fs.back()->size;
        for (int i = 0; i < fs.size() - 1; i++)
        {
            fs[i]->child_size -= file_size;
            if (i == fs.size() - 2)
                fs[i]->dir_size -= file_size;
        }
    }
    return true;
}
bool deal_q(string file_path, long long ld, long long lr)
{

    vector<string> path = convert_string_path(file_path);
    struct dfile *p = &root;
    vector<struct dfile *> fs;
    fs.push_back(p);
    for (int i = 0; i < path.size(); i++)
    {
        if (!p->child.count(path[i])) // 如果没有找到
            return false;
        if (p->child[path[i]]->type == 0) // 如果不是目录文件
            return false;
        p = p->child[path[i]];
        fs.push_back(p);
    }
    struct dfile *dir = fs.back();
    if (ld != 0) // 检查孩子文件的大小是不是超过限制了
    {
        if (dir->dir_size > ld)
            return false;
    }
    if (lr != 0) // 检查后代文件的总和是不是超过了限制
    {
        if (dir->child_size > lr)
            return false;
    }
    dir->child_limit = lr;
    dir->dir_limit = ld;
    return true;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    // freopen("1.txt", "r", stdin);
    int n;
    cin >> n;
    // 初始化根目录
    root.type = 1;

    for (int i = 0; i < n; i++)
    {
        string type;
        cin >> type;
        if (type == "C")
        {
            string file_path;
            long long file_size;
            cin >> file_path >> file_size;
            if (deal_creat(file_path, file_size))
                cout << "Y" << endl;
            else
                cout << "N" << endl;
        }
        if (type == "R")
        {
            string file_path;
            cin >> file_path;
            if (deal_remove(file_path))
                cout << "Y" << endl;
        }
        if (type == "Q")
        {
            string file_path;
            long long ld, lr;
            cin >> file_path >> ld >> lr;
            if (deal_q(file_path, ld, lr))
                cout << "Y" << endl;
            else
                cout << "N" << endl;
        }
    }
    return 0;
}

100分完整代码

#include <bits/stdc++.h>
using namespace std;
struct dfile
{
    long long size = 0;
    long long dir_size = 0;    //
    long long child_size = 0;  // 后代大小
    long long dir_limit = 0;   // 目录配额
    long long child_limit = 0; // 孩子配额
    bool isDir = 0;            // 1是目录 0是文件
    map<string, struct dfile *> child;
    dfile(int t) : isDir(t) {}
};
struct dfile root(1);
vector<string> split(const string &s, const string &c = "")
{
    vector<string> res;
    for (long long i = 0, j = 0; i < s.size(); i = j + 1)
    {
        j = s.find(c, i);
        if (j == -1)
            j = s.size();
        res.push_back(s.substr(i, j - i));
    }
    return res;
}
int get_file_size(vector<string> path)
{
    struct dfile *p = &root;
    for (int i = 1; i < path.size() && p; i++)
    {
        p = p->child.count(path[i]) ? p->child[path[i]] : nullptr;
    }
    return p and !p->isDir ? p->size : 0;
}
bool can_create(vector<string> path, long long sz)
{
    struct dfile *p = &root;
    for (int i = 1; i < path.size() && p; i++)
    {
        // 向前判断判断i-1的时候的p 不会判断最后一个p（文件的指针）
        if (!p->isDir or (p->child_limit && p->child_size + sz > p->child_limit) or (i == path.size() - 1 && p->dir_limit && p->dir_size + sz > p->dir_limit))
            return false;
        p = p->child.count(path[i]) ? p->child[path[i]] : nullptr;
    }
    return !p or !p->isDir; // 如果没有文件、文件夹占用文件名 或者 是文件占用文件名
}
bool deal_creat(vector<string> path, long long file_size) // 创建普通文件
{
    int sz = file_size - get_file_size(path);

    if (!can_create(path, sz))
        return false;
    struct dfile *p = &root;
    for (int i = 1; i < path.size() - 1 /*剩下最后一个是文件*/; i++)
    {
        p->child_size += sz;
        if (!p->child.count(path[i]))
            p->child[path[i]] = new dfile(1);
        p = p->child[path[i]];
    }
    // p是文件的上一级
    p->child_size += sz, p->dir_size += sz;
    // 判断文件是不是存在
    if (!p->child.count(path.back()))
        p->child[path.back()] = new dfile(0);

    // 设置大小 注意这里不管是新建的还是覆盖的都是+=sz
    p->child[path.back()]->size += sz;
    return true;
}
bool deal_remove(vector<string> path)
{
    vector<struct dfile *> fs;
    fs.push_back(&root);

    // 判断路径存不存在
    struct dfile *p = &root;
    for (int i = 1; i < path.size(); i++)
    {
        if (!p->child.count(path[i]))
            return true;
        p = p->child[path[i]];
        fs.push_back(p);
    }

    // 删去索引
    fs[fs.size() - 2]->child.erase(path.back());
    // 删除占用
    bool type = fs.back()->isDir;
    if (type) // 如果是文件夹
    {
        // 删除文件夹占用
        long long file_size = fs.back()->child_size;
        for (int i = 0; i < fs.size() - 1; i++)
        {
            fs[i]->child_size -= file_size;
        }
    }
    else
    {
        // 删除文件占用
        long long file_size = fs.back()->size;
        for (int i = 0; i < fs.size() - 1; i++)
        {
            fs[i]->child_size -= file_size;
            if (i == fs.size() - 2)
                fs[i]->dir_size -= file_size;
        }
    }
    return true;
}
bool deal_q(vector<string> path, long long ld, long long lr)
{
    struct dfile *p = &root;
    for (int i = 1; i < path.size(); i++)
    {
        if (!p->child.count(path[i])) // 如果没有找到
            return false;
        if (p->child[path[i]]->isDir == 0) // 如果不是目录文件
            return false;
        p = p->child[path[i]];
    }
    struct dfile *dir = p;
    if (ld && dir->dir_size > ld) // 检查孩子文件的大小是不是超过限制了
        return false;
    if (lr && dir->child_size > lr) // 检查后代文件的总和是不是超过了限制
        return false;
    dir->child_limit = lr;
    dir->dir_limit = ld;
    return true;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    // freopen("1.txt", "r", stdin);
    int n;
    cin >> n;

    for (int i = 0; i < n; i++)
    {
        string type, file_path;
        cin >> type >> file_path;
        vector<string> path = split(file_path, "/");
        if (type == "C")
        {
            long long file_size;
            cin >> file_size;
            cout << (deal_creat(path, file_size) ? "Y" : "N") << endl;
        }
        if (type == "R")
        {
            deal_remove(path);
            cout << "Y" << endl;
        }
        if (type == "Q")
        {
            long long ld, lr;
            cin >> ld >> lr;
            cout << (deal_q(path, ld, lr) ? "Y" : "N") << endl;
        }
    }
    return 0;
}
to be a question
关注
  • 41
    点赞
  • 踩
  • 52
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2020 CSP-J1 CSP-S1答案解析及总结(C)-2020.10.12.pdf
10-13
2020 CSP-J1 CSP-S1答案解析及总结(C)-2020.10.12 2020 CSP-J1 CSP-S1答案解析及总结(C)-2020.10.12 2020 CSP-J1 CSP-S1答案解析及总结(C)-2020.10.12 2020 CSP-J1 CSP-S1答案解析及总结(C)-2020.10.12 2020 CSP-J1 ...
带配额的文件系统 CSP 202012-3
m0_46342462的博客
01-19 1964
带配额的文件系统 CSP 202012-3 由于学校的课程设计，需要我们写csp上面的题目，作为一名从来没有刷过算法题的小白，分享以下自己的解题思路，就当笔记了，使用python实现。因为学的是C语言的数据结构，没有学过python版的，可能很多地方不对，希望大家能够指出我的不足之处。 题目的大致意思就是我们要创建一个文件系统，用来管理文件，等于很简单的模拟了我们平时用过的文件系统。 结构 题目给了三种结构： 根目录 目录文件 普通文件 路径命名也和平时用的一样，例如：/A/B/1，根目录就是‘/’。
CSP202012-3 带配额的文件系统
qq_43381135的博客
01-21 4294
CSP202012-3 带配额的文件系统算法思想代码详解1、文件节点的数据结构2、召回操作3、主函数4、创建普通文件5、移除文件6、设置配额值7、感想8、完整代码 算法思想 这道题是一个比较复杂的模拟题，难度不是很大，只要耐心地将每一种情况都考虑到，还是很容易100分的。想练习大模拟的朋友，可以耐下心来做一下这个题，这道题的细节还是很多的。 依据题目，可以主要有三种操作，分别为创建普通文件、移除文件和设置配额值这三个操作。通过对文件系统的了解，可以判断出采用的数据结构是树，我之前也写了一个关于树的数据结构
2020年CSP-J2 CSP-S2 复赛题解
青少年趣味编程
06-16 2942
2020年CSP-J2 CSP-S2 复赛题解
洛谷2020、2021、2022、2023 CSP-J1 CSP-S1 第1轮 初赛模拟
青少年趣味编程
08-23 6934
洛谷2020、2021、2022、2023 CSP-J1 CSP-S1 第1轮 初赛模拟
CSP-J CSP-S 初赛模拟题
青少年趣味编程
05-20 7049
2019 CSP-J/S第一轮各省分数线统计与分析(含浙江省) 家长帮 CSP-J/S2019第二轮入门级一等各省评级分数线 CSP-J/S2019第二轮入门级一等各省评级分数线_自主选拔在线 CSP-J/S2019第二轮提高级一等各省评级分数线 CSP-J/S2019第二轮提高级一等各省评级分数线_自主选拔在线 第二十六届全国青少年信息学奥林匹克联赛初赛模拟试题 滑动验证页面 2019CFS-S/J第一轮测试（真题模拟）（初赛一、基础、20题） 滑动验证页面 NOI
CSP-J CSP-S初赛模拟题_PDF(2020.10.09).rar
10-09
CSP-J CSP-S初赛模拟题_PDF(2020.10.09) CSP-J CSP-S初赛模拟题_PDF(2020.10.09) CSP-J CSP-S初赛模拟题_PDF(2020.10.09) CSP-J CSP-S初赛模拟题_PDF(2020.10.09) CSP-J CSP-S初赛模拟题_PDF(2020.10.09)
CSP-2020J3答案
10-04
https://blog.csdn.net/m0_45682806/article/details/108909553，试题
CSP2020-senior初赛-C-A.pdf
10-11
CSP2020-senior初赛-C-A.pdf
CSP-2020J1
10-04
一、单项选择题（共15题，每题2分，共计30分；每题有且仅有一个正确选项） 二、阅读程序（程序输入不超过数组或字符串自定义的范围，判断题正确填T，错误填F，除特殊说明外，判断题1.5分，选择题3分，共计40分） 三...
排序算法之选择排序
snow_feather的博客
05-04 236
选择排序的讲解，时间空间复杂度，内含动态视图方便理解
[数据结构]——非递归排序总结——笔试爱考
小李很执着的博客
05-04 663
创建一个栈ST，并初始化为空。将结束索引end和开始索引开始依次入栈ST。进入循环，直到栈ST为空： a. 从栈ST中弹出两个索引，分别赋值给left和right。b. 调用PartSort3函数，将数组a在[left， right]范围内进行三路划分，返回划分后的基准元素的索引keyi。c. 如果left < keyi - 1，则将keyi - 1和left依次入栈ST，用于后续处理[left， keyi-1]范围内的子数组。
线性数据结构-手写队列-Queue
CSDN_LiMingfly的博客
05-03 629
将元素添加到队列后的操作称为入队，从队列中移除元素的操作称为出队。但剩余接下里的步骤才是复杂的，因为需要在根元素迁移走后，寻找另外的最小元素迁移到对头。延迟队列的实现，主要为在优先队列的基础上，添加可重入锁 ReentrantLock 对阻塞队列的实现。首先将元素2挂到队列尾部，之后通过 (k - 1) >>> 1 计算父节点位置，与对应元素进行比对和判断交换。在存放元素时，以遵循它的特点，会在存存放过程中，通过队尾元素向上比对迁移。1：单端队列和双端队列，分别对应的实现类是哪个？
数据结构-二叉树结尾+排序
m0_67635008的博客
05-04 650
最开始存0 - 9，进行单趟排，左区间是0 4，有区间是[ 6 ,9] 可以把这两个区间入栈，每次入栈如此反复。我们可以找到最大的交换到右边和最小的交换到左边，但是如果left == maxi，一交换mini和left的值就会把maxi里的值交换到mini上。我们可以使用层序遍历的思路，利用一个队列，去完成层序遍历，但是这里会有些许的不同，我们需要让空也进队列。左边做key，右边先走（相遇后，相遇位置正好是小的），右边找比key小的。上面的排序除了归并排序外，都是内排序，也就是在内存中排序。
【算法与数据结构】哈希表
最新发布
weixin_54383080的博客
05-04 1031
数据结构之哈希表，从生活实例引入哈希表存在的意义，重点讲述了哈希函数的意义以及如何应对哈希冲突。
数据结构概述
weixin_54140739的博客
05-04 456
1.数据结构学习方法：心态勇于直面问题，多听多练，主动思考，多尝试2.数据的逻辑结构线性结构、层次结构、网状结构3.数据结构的意义提升自己的编程能力可复用性高、可读性好、效率高、可维护性好4.数据结构的基本概念（1）数据数据即信息的载体，是能够输入到计算机中被计算机识别、存储和处理的符号的总称（2）数据元素数据元素是数据的基本单位，又称为记录，数据元素由若干基本项（或称字段、域、属性）组成5.数据的逻辑结构集合、线性结构、树形结构、图状结构6.存储结构顺序存储、索引存储、链式存储、散列存储7.线性表包含若干
数据结构：单链表
hyh20051101的博客
05-04 554
SL;链表由两部分组成：存储的数据以及指向下一个节点的指针。定义和重命名完成之后，就要开始在.c文件中操作链表进行增删查改的工作了。
【数据结构】顺序表的基本操作实现
炸掉地球的博客
05-04 505
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，这种存储结构称为顺序存储结构。顺序表一般情况下采用数组存储，在数组上完成数据的增删查改等基本操作。
数据结构（十）----图
weixin_69884785的博客
05-04 516
数据结构（十）----图 一.图的概念 1.图的定义 2.图的类别 3.图的性质 4.几种特殊形态的图 二.图的存储结构 1.邻接矩阵（顺序存储） 2.邻接表（顺序+链式存储） 3.十字链表 4.邻接多重表 四.图的遍历 1.广度优先遍历（BFS） •广度优先生成树 •广度优先生成森林 2.深度优先遍历（DFS） •深度优先生成树 •深度优先生成森林
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":...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值