问题描述

题目背景

小 H 同学发现，他维护的存储系统经常出现有人用机器学习的训练数据把空间占满的问题，十分苦恼。
查找了一阵资料后，他想要在文件系统中开启配额限制，以便能够精确地限制大家在每个目录中最多能使用的空间。

文件系统概述

文件系统，是一种树形的文件组织和管理方式。在文件系统中，文件是指用名字标识的文件系统能够管理的基本对象，分为普通文件和目录文件两种，目录文件可以被简称为目录。目录中有一种特殊的目录被叫做根目录。除了根目录外，其余的文件都有名字，称为文件名。合法的文件名是一个由若干数字（[0-9]）、大小写字母（[A-Za-z]）组成的非空字符串。普通文件中含有一定量的数据，占用存储空间；目录不占用存储空间。文件和目录之间存在含于关系。上述概念满足下列性质：

有且仅有一个根目录；
对于除根目录以外的文件，都含于且恰好含于一个目录；
含于同一目录的文件，它们的文件名互不相同；
对于任意不是根目录的文件 $f$ ，若 $f$ 不含于根目录，那么存在有限个目录 $d_{1}, d_{2}, \dots, d_{n}$ ，使得 $f$ 含于 $d_{1}$ ， $d_{1}$ 含于 $d_{2}$ ， $\dots$ ， $d_{n}$ 含于根目录。

结合性质 4 和性质 2 可知，性质 4 中描述的有限多个目录，即诸 $d_{i}$ ，是唯一的。再结合性质 3，我们即可通过从根目录开始的一系列目录的序列，来唯一地指代一个文件。我们记任意不是根目录且不含于根目录的文件 $f$ 的文件名是 $N_{f}$ ，那么 $f$ 的路径是： $‘‘/" + N_{d_{n}} + ‘‘/" + \dots + N_{d_{1}} + ‘‘/" + N_{f}$ 其中符号 $+$ 表示字符串的连接；对于含于根目录的文件 $f$ ，它的路径是： $‘‘/" + N_{f}$ ；根目录的路径是： $‘‘/"$ 。不符合上述规定的路径都是非法的。例如：/A/B 是合法路径，但 /A//B、/A/、A/、A/B 都不是合法路径。若文件 $f$ 含于目录 $d$ ，我们也称 $f$ 是 $d$ 的孩子文件。 $d$ 是 $f$ 的双亲目录。我们称文件 $f$ 是目录 $d$ 的后代文件，如果满足：(1) $f$ 是 $d$ 的孩子文件，或 (2) $f$ 含于 $d$ 的后代文件。

截屏2021-03-21 下午7.50.28.png

如图所示，该图中绘制的文件系统共有 8 个文件。其中，方形表示目录文件，圆形表示普通文件，它们之间的箭头表示含于关系。在表示文件的形状上的文字是其文件名；各个形状的左上方标记了序号，以便叙述。在该文件系统中，文件 5 含于文件 2，文件 5 是文件 2 的孩子文件，文件 5 也是文件 2 的后代文件。文件 8 是文件 2 的后代文件，但不是文件 2 的孩子文件。文件 8 的路径是 /D1/D1/F2。

配额概述

配额是指对文件系统中所含普通文件的总大小的限制。对于每个目录 $d$ ，都可以设定两个配额值：目录配额和后代配额。我们称目录配额 $L D_{d}$ 是满足的，当且仅当 $d$ 的孩子文件中，全部普通文件占用的存储空间之和不大于该配额值。我们称后代配额 $L R_{d}$ 是满足的，当且仅当 $d$ 的后代文件中，全部普通文件占用的存储空间之和不大于该配额值。我们称文件系统的配额是满足的，当且仅当该文件系统中所有的配额都是满足的。
很显然，若文件系统中仅存在目录，不存在普通文件，那么该文件系统的配额一定是满足的。随着配额和文件的创建，某个操作会使文件系统的配额由满足变为不满足，这样的操作会被拒绝。例如：试图设定少于目前已有文件占用空间的配额值，或者试图创建超过配额值的文件。

题目描述

在本题中，假定初始状态下，文件系统仅包含根目录。你将会收到若干对文件系统的操作指令。对于每条指令，你需要判断该指令能否执行成功，对于能执行成功的指令，在成功执行该指令后，文件系统将会被相应地修改。对于不能执行成功的指令，文件系统将不会发生任何变化。你需要处理的指令如下：

创建普通文件

创建普通文件指令的格式如下：

C <file path> <file size>

创建普通文件的指令有两个参数，是空格分隔的字符串和一个正整数，分别表示需要创建的普通文件的路径和文件的大小。对于该指令，若路径所指的文件已经存在，且也是普通文件的，则替换这个文件；若路径所指文件已经存在，但是目录文件的，则该指令不能执行成功。当路径中的任何目录不存在时，应当尝试创建这些目录；若要创建的目录文件与已有的同一双亲目录下的孩子文件中的普通文件名称重复，则该指令不能执行成功。另外，还需要确定在该指令的执行是否会使该文件系统的配额变为不满足，如果会发生这样的情况，则认为该指令不能执行成功，反之则认为该指令能执行成功。

移除文件

移除文件指令的格式如下：

R <file path>

移除文件的指令有一个参数，是字符串，表示要移除的文件的路径。若该路径所指的文件不存在，则不进行任何操作。若该路径所指的文件是目录，则移除该目录及其所有后代文件。在上述过程中被移除的目录（如果有）上设置的配额值也被移除。该指令始终认为能执行成功。

设置配额值

Q <file path> <LD> <LR>

设置配额值的指令有三个参数，是空格分隔的字符串和两个非负整数，分别表示需要设置配额值的目录的路径、目录配额和后代配额。该指令表示对所指的目录文件，分别设置目录配额和后代配额。若路径所指的文件不存在，或者不是目录文件，则该指令执行不成功。若在该目录上已经设置了配额，则将原配额值替换为指定的配额值。特别地，若配额值为 0，则表示不对该项配额进行限制。若在应用新的配额值后，该文件系统配额变为不满足，那么该指令执行不成功。

输入格式

从标准输入读入数据。
输入的第一行包含一个正整数 $n$ ，表示需要处理的指令条数。
输入接下来会有 $n$ 行，每一行一个指令。指令的格式符合前述要求。输入数据保证：对于所有指令，输入的路径是合法路径；对于创建普通文件和移除文件指令，输入的路径不指向根目录。

输出格式

输出到标准输出。
输出共有 $n$ 行，表示相应的操作指令是否执行成功。若成功执行，则输出字母 Y；否则输出 N。

样例 1 输入

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

样例 1 输出

Y
Y
N
N
Y
N
Y
Y
Y
Y

样例 1 解释

输入总共有 10 条指令。其中前两条指令可以正常创建两个普通文件。第三条指令试图创建 /A/B/1/3，但是 /A/B/1 已经存在，且不是目录，而是普通文件，不能再进一步创建孩子文件，因此执行不成功。第四条指令试图创建 /A，但是 /A 已经存在，且是目录，因此执行不成功。第五条指令试图删除 /A/B/1/3，由于该文件不存在，因此不对文件系统进行修改，但是仍然认为执行成功。第六条指令试图在根目录增加后代配额限制，但此时，文件系统中的文件总大小是 2048，因此该限制无法生效，执行不成功。第七条指令试图创建文件 /A/B/1，由于 /A/B/1 已经存在，且是普通文件，因此该指令实际效果是将原有的该文件替换。此时文件总大小是 1124，因此第八条指令就可以执行成功了。第九条指令递归删除了 /A/B 目录和它的所有后代文件。此时文件系统中已经没有普通文件，因此第十条命令可以执行成功。

样例 2 输入

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

样例 2 输出

N
Y
Y
Y
Y
N
Y
N
N

样例 2 解释

输入共有 9 条指令。第一条指令试图为 /A/B 创建配额规则，然而该目录并不存在，因此执行不成功。接下来的两条指令创建了两个普通文件。再接下来的两条指令分别在目录 /A/B 和 /A/C 创建了两个配额规则。其中前者是目录配额，后者是后代配额。接下来的两条指令，创建了两个文件。其中，/A/B/3 超出了在 /A/B 的目录配额，因此执行不成功；但 /A/B/D/3 不受目录配额限制，因此执行成功。最后两条指令，创建了两个文件。虽然在 /A/C 没有目录配额限制，但是无论是 /A/C 下的孩子文件还是后代文件，都受到后代配额的限制，因此两条指令执行都不成功。

数据范围

本题目各个测试点的数据规模如下：

测试点	操作数	单个文件大小	路径长度	目录层次	没有操作 $Q$
1,2	$\leq 100$	$\leq 1 0^{9}$	$\leq 100$	$\leq 20$	是
3,4	$\leq 100$	$\leq 1 0^{9}$	$\leq 100$	$\leq 20$	否
5,6,7	$\leq 1 0^{5}$	$\leq 1 0^{9}$	$\leq 100$	$\leq 20$	是
8,9,10	$\leq 1 0^{5}$	$\leq 1 0^{9}$	$\leq 100$	$\leq 20$	否

算法分析

不考虑配额：50分
考虑配额：100分

这题就是模拟，按照题目描述逐条实现需求即可。

AC代码

截屏2021-03-21 下午8.14.39.png

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String buf = scan.nextLine();
        int m = Integer.valueOf(buf);
        FileSystem fsys = new FileSystem();
        HashMap<Boolean, String> map = new HashMap<>();
        map.put(true, "Y");
        map.put(false, "N");
        for (int i = 0; i < m; ++ i) {
            buf = scan.nextLine();
            String[] temp = buf.split(" ");
            if (temp[0].equals("C")) {
                System.out.println(map.get(fsys.createFile(temp[1], Long.valueOf(temp[2]))));
            } else if (temp[0].equals("R")) {
                System.out.println(map.get(fsys.removeFile(temp[1])));
            } else {
                long x = Long.valueOf(temp[2]);
                long y = Long.valueOf(temp[3]);
                System.out.println(map.get(fsys.setDir(temp[1], x, y)));
            }
        }
    }
}

class FileSystem {
    FileNode root;

    public FileSystem() {
        root = new FileNode(FileNode.DIR);
    }

    private long findFile(String[] path) {
        int n = path.length;
        FileNode cnt = root;
        for (int i = 1; i < n-1; ++ i) {
            if (cnt.H.containsKey(path[i])) {
                cnt = cnt.H.get(path[i]);
                if (cnt.type == FileNode.FILE) return -2;
            } else {
                return -1;
            }
        }
        if (cnt.H.containsKey(path[n-1])) {
            cnt = cnt.H.get(path[n-1]);
            if (cnt.type == FileNode.DIR) return -2;
            return cnt.uml;
        } else {
            return -1;
        }
    }

    private boolean checkPE(String[] path, long sz) {
        int n = path.length;
        FileNode cnt = root;
        for (int i = 1; i < n; ++ i) {
            if (cnt.hd-cnt.uhd < sz) return false;
            if (i == n-1) break;
            if (cnt.H.containsKey(path[i])) {
                cnt = cnt.H.get(path[i]);
            } else {
                return true;
            }
        }
        if (cnt.ml-cnt.uml < sz) return false;
        return true;
    }

    private void create(String[] path, long sz) {
        int n = path.length;
        FileNode cnt = root;
        for (int i = 1; i < n; ++ i) {
            cnt.uhd += sz;
            if (i == n-1) break;
            if (cnt.H.containsKey(path[i])) {
                cnt = cnt.H.get(path[i]);
            } else {
                FileNode temp = new FileNode(FileNode.DIR);
                cnt.H.put(path[i], temp);
                cnt = temp;
            }
        }
        cnt.uml += sz;
        if (cnt.H.containsKey(path[n-1])) {
            cnt = cnt.H.get(path[n-1]);
            cnt.uml += sz;
        } else {
            FileNode temp = new FileNode(FileNode.FILE);
            cnt.H.put(path[n-1], temp);
            temp.uml += sz;
        }
    }

    public boolean createFile(String x, long size) {
        String[] path = x.split("/");
        long old = findFile(path);
        if (old == -2) return false;
        if (old > 0) size -= old;
        if (checkPE(path, size)) {
            create(path, size);
            return true;
        }
        return false;
    }

    private void remove(String[] path) {
        int n = path.length;
        FileNode cnt = root;
        for (int i = 1; i < n; ++ i) {
            if (cnt.H.containsKey(path[i])) {
                cnt = cnt.H.get(path[i]);
            } else {
                return;
            }
        }
        FileNode tar = cnt;
        long dec = Math.max(cnt.uml, cnt.uhd);
        cnt = root;
        for (int i = 1; i < n; ++ i) {
            cnt.uhd -= dec;
            if (i == n-1) break;
            cnt = cnt.H.get(path[i]);
        }
        if (tar.type == FileNode.FILE) cnt.uml -= dec;
        cnt.H.remove(path[n-1]);
    }

    public boolean removeFile(String x) {
        remove(x.split("/"));
        return true;
    }

    private boolean setPE(String[] path, long x, long y) {
        int n = path.length;
        FileNode cnt = root;
        for (int i = 1; i < n; ++ i) {
            if (cnt.H.containsKey(path[i])) {
                cnt = cnt.H.get(path[i]);
            } else {
                return false;
            }
        }
        if (cnt.type == FileNode.FILE) return false;
        if (cnt.uml>x || cnt.uhd>y) return false;
        cnt.ml = x;
        cnt.hd = y;
        return true;
    }

    public boolean setDir(String x, long a, long b) {
        if (a == 0) a = FileNode.INF;
        if (b == 0) b = FileNode.INF;
        return setPE(x.split("/"), a, b);
    }
}

class FileNode {
    static boolean FILE = true;
    static boolean DIR = false;
    static long INF = Long.MAX_VALUE >> 2;

    long ml, hd;
    long uml, uhd;
    boolean type;
    HashMap<String, FileNode> H;

    public FileNode(boolean _type) {
        ml = INF;
        hd = INF;
        uml = 0;
        uhd = 0;
        type = _type;
        H = new HashMap<>();
    }
}