题面解释:

在Linux系统中，用户通过cd命令来切换工作目录。给定一个当前工作目录的绝对路径和一个相对路径命令，要求输出执行该命令后用户的新工作目录，且以最简洁的绝对路径形式表示，同时还需输出在命令执行过程中经过的最深目录层级数。输入包括当前工作目录的绝对路径和cd命令的相对路径，输出则包含用户新目录的绝对路径和最深层级数的两个数值。例如，若输入为/home/hello和cd .././/world/，则输出为/home/world和2，表示最终目录和经过的最深层级数。

思路

使用栈来模拟路径变化是通过利用栈的后进先出（LIFO）特性来实现文件系统的路径导航。首先，将当前路径和目标路径用“/”分割为路径片段，并依次处理。当前路径中的有效目录名依次入栈，表示进入对应的子目录；遇到“..”时，栈顶元素弹出，表示返回上一级目录。对于目标路径的处理，如果是有效目录，则入栈；如果是“..”，则弹出栈顶目录。在操作过程中，栈的最大深度反映了所到达的最大目录层级。

题解

在Linux系统中，路径的管理和切换非常重要。我们可以通过栈结构来模拟路径变化，利用栈的后进先出（LIFO）特性来实现文件系统的路径导航。首先，我们将当前路径和目标路径用“/”进行分割，得到路径片段。对于当前路径中的有效目录名，我们依次入栈，表示进入对应的子目录；遇到“..”时，表示返回上一级目录，因此弹出栈顶元素。对目标路径的处理同样适用：如果是有效目录名，则入栈；如果是“..”，则弹出栈顶目录。在路径操作的过程中，栈的最大深度将反映出用户所到达的最大目录层级数，包括当前目录和最终目录。最终，我们将栈中的内容拼接成绝对路径，并输出最简洁的形式。

代码解读

1. 输入处理：通过 getline 函数读取当前路径和命令输入，并将路径字符串按斜杠“/”分割，得到各个目录名片段。
2. 路径管理：使用栈（这里用向量实现）来处理路径的变化，包括进入新目录和返回上级目录的操作。
3. 层级深度：在处理路径的过程中，通过更新层级深度的变量，记录下路径的最大深度。
4. 最终输出：在处理完成后，将栈中的内容拼接成最简洁的绝对路径，并输出最终的路径和层级深度。

代码

python

# 读取当前路径输入
s = input()
# 将当前路径按 "/" 分割为列表
s = list(s.split("/"))
# 弹出第一个元素（根目录前的空字符串）
s.pop(0)
# 读取需要切换的目标路径，目标路径的前缀忽略
_, ss = input().split()
# 将目标路径按 "/" 分割为列表
ss = ss.split("/")
# 初始化深度为当前路径的层级数
dep = len(s)
# 如果当前路径的第一个元素为空字符串，表示根目录，深度置为 0
if s[0] == "":
    dep = 0
# 遍历目标路径中的每个部分
for x in ss:
    # 跳过空字符串，防止多余的 "/"
    if x == "":
        continue
    # 如果不是当前目录符号 "."
    if x != ".":
        # 如果是返回上一级目录符号 ".."
        if x == "..":
            # 如果栈不为空，弹出栈顶元素（返回上一级目录）
            if len(s) > 0:
                s.pop()
        else:
            # 否则，将该路径部分入栈（进入该目录）
            s.append(x)
        # 更新最大深度为当前栈的最大长度
        dep = max(dep, len(s))

# 初始化结果路径为空字符串
res = ""
# 遍历栈中的路径部分，构造最终路径
for x in s:
    if x != "":
        res = res + "/" + x
# 如果路径为空，表示根目录，设置结果为 "/"
if res == "":
    res = "/"
# 输出最终的路径
print(res)
print(dep)

java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 读取当前路径并按 "/" 分割为列表
        String input = sc.nextLine();
        String[] pathSegments = input.split("/");
        List<String> path = new ArrayList<>();

        for (String segment : pathSegments) {
            if (!segment.isEmpty()) {
                path.add(segment);
            }
        }

        // 读取需要切换的目标路径
        input = sc.nextLine();
        int pos = input.indexOf(' ');
        String newPath = input.substring(pos + 1);
        String[] newPathSegments = newPath.split("/");

        // 初始化深度为当前路径的层级数
        int dep = path.size();

        // 遍历目标路径中的每个部分
        for (String x : newPathSegments) {
            if (x.isEmpty()) continue;
            if (x.equals("..")) {
                if (!path.isEmpty()) {
                    path.remove(path.size() - 1);
                }
            } else if (!x.equals(".")) {
                path.add(x);
                dep = Math.max(dep, path.size());
            }
        }

        // 构造最终路径
        StringBuilder res = new StringBuilder();
        for (String x : path) {
            if (!x.isEmpty()) {
                res.append("/").append(x);
            }
        }

        // 如果路径为空，表示根目录
        if (res.length() == 0) {
            res.append("/");
        }

        // 输出最终路径和深度
        System.out.println(res.toString());
        System.out.println(dep);

        sc.close();
    }
}

c++

#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    // 读取当前路径并按 "/" 分割为路径片段
    string input;
    getline(cin, input);  // 获取当前工作目录的绝对路径
    stringstream ss(input);
    vector<string> path;  // 用于存储路径片段
    string segment;

    // 将路径按"/"分割并存入path向量中
    while (getline(ss, segment, '/')) {
        if (!segment.empty()) path.push_back(segment);  // 跳过空段
    }

    // 读取需要切换的目标路径
    getline(cin, input);  // 获取cd命令
    size_t pos = input.find(' ');  // 找到cd和路径之间的空格
    string newPath = input.substr(pos + 1);  // 提取目标路径
    stringstream ssNew(newPath);
    vector<string> ssSegments;  // 存储目标路径的片段

    // 将目标路径按"/"分割并存入ssSegments向量中
    while (getline(ssNew, segment, '/')) {
        ssSegments.push_back(segment);
    }

    // 初始化深度为当前路径的层级数
    int dep = path.size();  // 记录当前路径的层级数
    if (path.size() > 0 && path[0].empty()) dep = 0;  // 特殊情况处理

    // 遍历目标路径中的每个部分
    for (const string &x : ssSegments) {
        if (x.empty()) continue;  // 跳过空段
        if (x != ".") {  // "."表示当前目录，不做处理
            if (x == "..") {  // ".."表示上一级目录
                if (!path.empty()) path.pop_back();  // 弹出栈顶元素
            } else {
                path.push_back(x);  // 有效目录名入栈
            }
            dep = max(dep, (int)path.size());  // 更新最大深度
        }
    }

    // 构造最终路径
    string res;
    for (const string &x : path) {
        if (!x.empty()) res += "/" + x;  // 拼接路径
    }

    // 如果路径为空，表示根目录
    if (res.empty()) res = "/";

    // 输出最终的路径
    cout << res << endl;  // 输出最简洁的绝对路径
    cout << dep << endl;  // 输出最大目录层级数

    return 0;
}

s = input().split('/')
s.pop(0)
__,ss = input().split()
ss = ss.split('/')
dep = len(s)
if s[0]=="":
    dep = 0
for x in ss:
    if x=="":
        continue
    if x!='.':
        if x=='..':
            if dep>0:
                s.pop()
        else:
            s.append(x)
    dep = max(dep,len(s))
res = ""
for x in s:
    if x!="":
        res=res+'/'+x
if res == "":
    res = '/'
print(res)
print(dep)

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    string s;
    getline(cin, s);
    stringstream ss(s);
    string t;
    vector<string> path;
    while (getline(ss, t, '/'))
    {
        if (!t.empty())
            path.push_back(t);
    }
    getline(cin, s);
    stringstream newss(s.substr(3, s.size() - 3));
    int dep = path.size();
    while (getline(newss, t, '/'))
    {
        if (t.empty())
            continue;
        if (t != ".")
        {
            if (t == "..")
            {
                if (!path.empty())
                {
                    path.pop_back();
                }
            }
            else
            {
                path.push_back(t);
                dep = max((int)path.size(), dep);
            }
        }
    }
    string res;
    for (int i = 0; i < path.size(); i++)
    {
        if (!path.empty())
            res += '/' + path[i];
    }
    cout << res << endl;
    cout << dep << endl;
}