12.9

include

include

include

include <unordered_map>

include

using namespace std;

// 节点结构体
struct TreeNode {
int id;
string name;
int size; // 文件大小，目录大小为0
TreeNode* left;
TreeNode* right;

TreeNode(int id, string name, int size) 
    : id(id), name(name), size(size), left(nullptr), right(nullptr) {}

};

class FileSystem {
private:
unordered_map<int, TreeNode> nodes; // 通过ID快速查找节点
TreeNode root = nullptr;
int totalSize = 0;
TreeNode* largestFile = nullptr;

// 递归计算目录大小
int calculateSize(TreeNode* node) {
    if (!node) return 0;
    
    // 如果是文件，直接返回大小
    if (node->size > 0) {
        totalSize += node->size;
        
        // 更新最大文件
        if (!largestFile || node->size > largestFile->size) {
            largestFile = node;
        }
        return node->size;
    }
    
    // 如果是目录，递归计算子节点大小
    int leftSize = calculateSize(node->left);
    int rightSize = calculateSize(node->right);
    
    return leftSize + rightSize;
}

// 递归显示目录结构
void displayStructure(TreeNode* node, int depth = 0) {
    if (!node) return;
    
    // 打印缩进
    for (int i = 0; i < depth; i++) {
        cout << "  ";
    }
    
    // 打印节点信息
    if (node->size > 0) {
        // 文件
        cout << node->name << " (" << node->size << " bytes)" << endl;
    } else {
        // 目录
        cout << node->name << " ([DIR])" << endl;
    }
    
    // 递归显示子节点
    displayStructure(node->left, depth + 1);
    displayStructure(node->right, depth + 1);
}

// 构建二叉树
void buildTree() {
    for (auto& pair : nodes) {
        TreeNode* node = pair.second;
        // 找到根节点（没有父节点的节点）
        bool isRoot = true;
        for (auto& otherPair : nodes) {
            TreeNode* other = otherPair.second;
            if (other->left == node || other->right == node) {
                isRoot = false;
                break;
            }
        }
        if (isRoot) {
            root = node;
            break;
        }
    }
}

public:
// 添加节点
void addNode(int id, const string& name, int size, int leftId, int rightId) {
TreeNode* node = new TreeNode(id, name, size);
nodes[id] = node;
}

// 建立节点之间的连接
void connectNodes() {
    for (auto& pair : nodes) {
        int id = pair.first;
        TreeNode* node = pair.second;
        
        // 建立左右子节点连接
        for (auto& otherPair : nodes) {
            if (otherPair.second->id == node->left) {
                node->left = otherPair.second;
            }
            if (otherPair.second->id == node->right) {
                node->right = otherPair.second;
            }
        }
    }
    
    // 构建树
    buildTree();
}

// 计算并输出总大小
void calculateTotalSize() {
    totalSize = 0;
    largestFile = nullptr;
    calculateSize(root);
    cout << "Total size: " << totalSize << " bytes" << endl;
}

// 输出最大文件
void displayLargestFile() {
    if (!largestFile) {
        cout << "No files found" << endl;
    } else {
        cout << "Largest file: " << largestFile->name 
             << " (" << largestFile->size << " bytes)" << endl;
    }
}

// 显示目录结构
void displayDirectoryStructure() {
    cout << "Directory structure:" << endl;
    displayStructure(root);
}

~FileSystem() {
    for (auto& pair : nodes) {
        delete pair.second;
    }
}

};

int main() {
int N;
cin >> N;

FileSystem fs;
vector<tuple<int, string, int, int, int>> nodeInfo;

// 读取所有节点信息
for (int i = 0; i < N; i++) {
    int id, size, leftId, rightId;
    string name;
    cin >> id >> name >> size >> leftId >> rightId;
    
    // 处理-1表示空节点
    if (leftId == -1) leftId = -1;
    if (rightId == -1) rightId = -1;
    
    nodeInfo.emplace_back(id, name, size, leftId, rightId);
    
    // 添加节点，先不连接子节点
    fs.addNode(id, name, size, -1, -1);
}

// 建立节点之间的连接
for (const auto& info : nodeInfo) {
    int id, size, leftId, rightId;
    string name;
    tie(id, name, size, leftId, rightId) = info;
    
    // 这里我们需要在FileSystem中添加一个方法来建立连接
    // 为了简化，我们在FileSystem类中添加连接逻辑
}

// 建立连接并构建树
fs.connectNodes();

// 计算并输出结果
fs.calculateTotalSize();
fs.displayLargestFile();
fs.displayDirectoryStructure();

return 0;

}