路径打印

利用二维数组的办法，用一个vector数组，数组中每个元素是一个vector<string>数组，存放了每行的各目录，如 a\b\c， 则vector<string> 数组中存放的是 a b c 三个string。
最后存放的结果：
a\b\c
a\d\e
b\cst
d\
{{a, b, c},
{a, d, e},
{b, cst}
{d}
}
当打印出第一行外每行的目录时，判断与前一行是否有相同的根目录，如果有，找到第一个不同的目录，开始打印，它对应的该行的下标控制它前面有多少缩进。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
    int n;
    vector<string> v, vs;
    vector< vector<string> > ve;
    while(cin>>n)
    {
        string str;
        if(n==0) return 0;

        v.clear();  //存放初始的所有行
        for(int i = 0; i<n; i++)
        {
            cin>>str;
            while(str[str.length()-1]!='\\') str+='\\';  //对每行进行处理，处理成最后有\字母的路径形式
            v.push_back(str);
        }
        sort(v.begin(), v.end());  //排序

        ve.clear();  //二维数组初始化
        for(int i = 0; i<v.size(); i++)
        {
            int begin = 0, end = 0;
            vs.clear();  //每个一维数组初始化
            while((end = v[i].find("\\", begin))!=string::npos){
                vs.push_back(v[i].substr(begin, end-begin));
                begin=end+1;
            }
            ve.push_back(vs);  //存放进二维数组中
        }
        for(int i = 0; i<n; i++)
        {
            if(i>0 && ve[i][0] == ve[i-1][0])  //与前一个目录有相同的根目录
            {
                int j = 1;
                while(j<ve[i].size() && ve[i][j]==ve[i-1][j]) j++;  //找到第一个不同的目录
                for(; j<ve[i].size(); j++)
                {
                    for(int k = 0; k<j; k++)
                        cout<<"  ";  //j是该目录在该路径中的下标，控制缩进的次数
                    cout<<ve[i][j]<<endl;
                }
            }
            else{
                for(int j = 0; j<ve[i].size(); j++)
                {
                    for(int k = 0; k<j; k++)
                        cout<<"  ";
                    cout<<ve[i][j]<<endl;
                }
            }
        }
        cout<<endl;  //每个测试用例最后都有一个空行
    }
    return 0;
}

10
N\W\L\R\B\B\M\Q\B\H\C\D\A\R\Z\O\W\K\K\Y
H\I\D\D\Q\S\C\D\X\R\J\M\O\W\F\R\X\S\J\Y\
B\L\D\B\E\F\S\A\R\C\B\Y\N\E\C\D\Y\G\G\X\
X\P\K\L\O\R\E\L\L\N\M\P\A\P\Q\F\W\K\H\O\
P\K\M\C\O\Q\H\N\W\N\K\U\E\W\H\S\Q\M\G\B\
B\U\Q\C\L\J\J\I\V\S\W\M\D\K\Q\T\B\X\I\X\
M\V\T\R\R\B\L\J\P\T\N\S\N\F\W\Z\Q\F\J\M\
A\F\A\D\R\R\W\S\O\F\S\B\C\N\U\V\Q\H\F\F\
B\S\A\Q\X\W\P\Q\C\A\C\E\H\C\H\Z\V\F\R\K\
M\L\N\O\Z\J\K\P\Q\P\X\R\J\X\K\I\T\Z\Y\X\

A
  F
    A
      D
        R
          R
            W
              S
                O
                  F
                    S
                      B
                        C
                          N
                            U
                              V
                                Q
                                  H
                                    F
                                      F
B
  L
    D
      B
        E
          F
            S
              A
                R
                  C
                    B
                      Y
                        N
                          E
                            C
                              D
                                Y
                                  G
                                    G
                                      X
  S
    A
      Q
        X
          W
            P
              Q
                C
                  A
                    C
                      E
                        H
                          C
                            H
                              Z
                                V
                                  F
                                    R
                                      K
  U
    Q
      C
        L
          J
            J
              I
                V
                  S
                    W
                      M
                        D
                          K
                            Q
                              T
                                B
                                  X
                                    I
                                      X
H
  I
    D
      D
        Q
          S
            C
              D
                X
                  R
                    J
                      M
                        O
                          W
                            F
                              R
                                X
                                  S
                                    J
                                      Y
M
  L
    N
      O
        Z
          J
            K
              P
                Q
                  P
                    X
                      R
                        J
                          X
                            K
                              I
                                T
                                  Z
                                    Y
                                      X
  V
    T
      R
        R
          B
            L
              J
                P
                  T
                    N
                      S
                        N
                          F
                            W
                              Z
                                Q
                                  F
                                    J
                                      M
N
  W
    L
      R
        B
          B
            M
              Q
                B
                  H
                    C
                      D
                        A
                          R
                            Z
                              O
                                W
                                  K
                                    K
                                      Y
P
  K
    M
      C
        O
          Q
            H
              N
                W
                  N
                    K
                      U
                        E
                          W
                            H
                              S
                                Q
                                  M
                                    G
                                      B
X
  P
    K
      L
        O
          R
            E
              L
                L
                  N
                    M
                      P
                        A
                          P
                            Q
                              F
                                W
                                  K
                                    H
                                      O

#include <cstdio>
#include <string>
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN=50010;
struct Node
{
    string data;
    vector<int> child;
}node[MAXN];
int index=0;
int newNode(string str)
{
    node[index].data=str;
    node[index].child.clear();
    return index++;
}
int findChild(int parent,string str)
{
    vector<int>::iterator it=node[parent].child.begin();
    while(it!=node[parent].child.end()&&node[*it].data!=str)
        it++;
    if(it==node[parent].child.end())
        return -1;
    else
        return *it;
}
int create(int n)
{
    int root=newNode("");
    while(n--)
    {
        //读入一行路径
        string str,word;
        getline(cin,str);
        //父母、孩子指针
        int parent=root,child;
        //对读入字符串处理
        int pos=0;
        while(pos<str.length())
        {
            //读入一个目录
            word.clear();
            while(pos<str.length()&&str[pos]!='\\')
                word+=str[pos++];
            if(pos<str.length()&&str[pos]=='\\')
                pos++;
            //查找是否存在孩子
            int child=findChild(parent,word);
            //不存在则创建
            if(child==-1)
            {
                child=newNode(word);
                node[parent].child.push_back(child);
            }
            //准备下一个目录
            parent=child;
        }
    }
    return root;
}
bool cmp(int a,int b)
{
    return node[a].data<node[b].data;
}
void DFS(int root,int left)
{
    for(int i=0;i<node[root].child.size();i++)
    {
        //将孩子根据名称从小到大排序
        sort(node[root].child.begin(),node[root].child.end(),cmp);
        int child=node[root].child[i];
        for(int i=0;i<left;i++)
            printf(" ");
        cout<<node[child].data<<endl;
        DFS(child,left+node[child].data.size()+1);
    }
}
int main()
{
    int n;
    while(scanf("%d",&n),n>0)
    {
        getchar();
        //创建目录树
        int root=create(n);
        //排序并打印
        DFS(root,0);
        //每一个测试样例的输出紧跟一个空行（不然不能通过）
        printf("\n");
    }
    return 0;
}

//对于一条目录里的不同文件，先输出前面的空格，再输出文件名，
//注意目录要排序，以及每个每个测试用例之间有一个空行
#include<bits/stdc++.h>
using namespace std;
int main()
{
	string str[11];  
	int i,j,n;
	while(cin>>n){
		if(n==0) break;
		
		for(int l=0;l<n;l++)  //保存测试用例的所有目录
			cin>>str[l];
		sort(str,str+n);    //把测试用例的目录排序 
		 
		string stra,strb;    //父目录和子目录
		for(int l=0;l<n;l++){  //开始打印所有目录 
			strb=str[l];
		int count=0;      //记录空格数，对于目录里的每个文件，先输出前面的空格。
		                  //在一个目录里空格数是累加的 
		for(i=0,j=0;i<stra.size()&&j<strb.size();i++,j++){  //统计子目录和父目录相同的文件，
								//多一个相同的文件就多一个空格 ，包括 \ 
			if(stra[i]==strb[j])
			count++;
			else
			break;    //出现和父目录中不同的文件，跳出，开始打印子目录 
		}
		
		for(;j<strb.size();j++){   //j是在和父目录不同文件处 
			for(int k=0;k<count;k++)   //打印前面的空格 
				cout<<" ";
			while(j<strb.size()&&strb[j]!='\\'){  //文件名多于一个字符的话持续打印 
				cout<<strb[j++];     
				count++;       //空格数随着文件名长度增加 
			}
			count++;    //向右缩进一个空格 
			cout<<endl;  //打印下一个文件 
		}
		stra=strb;   //下一个目录 
		}
		cout<<endl;    //注意每个测试用例间多一个空行 
	}
}

#!/usr/bin/python
#-*- coding:utf-8 -*-

#Author: Ben

import sys

def printDegs(degs):
    space = 0
    for deg in degs:
        if deg.strip() != '':
            sys.stdout.write(' '*space)
            sys.stdout.write(deg+'\n')
        space += len(deg)+1

def printSecDegs(degs, upDegs):
    degs = degs.split('\\')
    upDegs = upDegs.split('\\')
    ld = len(degs); lu = len(upDegs)
    lm = min(ld, lu)
    for i in range(lm):
        if degs[i] == upDegs[i]:
            degs[i] = ' '*len(upDegs[i])
        else:
            break
    printDegs(degs)

while True:
    try:
        N = input()
        if N == 0:
            break
        data = []
        for i in range(N):
            degs = raw_input()
            if degs[-1] == '\\':
                degs = degs[:-1]
            data.append(degs)
        data.sort()
        upDegs = ''
        for deg in data:
            printSecDegs(deg, upDegs)
            upDegs = deg
        sys.stdout.write('\n')
    except:
        break 

using namespace std;
#include <iostream>
#include <cstring>
#include <vector>
#include <cstdio>
#include <algorithm>
#include <set>
int main(){
    int n;
    while(scanf("%d", &n) != EOF and n != 0){
        vector< vector <string> > root;
        while(n--){
            string temp;
            cin>>temp;
            vector<string> tmp;
            while(temp.find('\\') != temp.npos){
                tmp.push_back(temp.substr(0, temp.find('\\')));
                temp = temp.substr(temp.find('\\')+1, temp.size());
            }
            if(!temp.empty())tmp.push_back(temp);
            root.push_back(tmp);
        }
        sort(root.begin(), root.end());
        for(int i(0);i<root.size();++i){
            string key = root[i][0];
            cout<<root[i][0]<<endl;
            while(i < root.size() and key == root[i][0]){
                int level = 1;
                for(int j(1);j<root[i].size();++j){
                    for(int k(0);k<level;k++)cout<<"  ";
                    cout<<root[i][j]<<endl;
                    level++;
                }
                ++i;
            }
            --i;
        }
    }
}

#include <stdio.h>
#include <string.h>

int main(){
    int n;
    while(scanf("%d", &n)!=EOF){
        if(n==0)
            break;
        char p[100][100];		// 存放测试集
		int f[100];				// 标记测试路径顺序
        for(int i=0; i<n; i++){ // 循环输入测试路径
            scanf("%s", p[i]);	// 输入一个测试路径数据
			f[i]=i;				// 标记各测试路径的原始顺序
		}

		// 对测试路径排序(根据每个路径根目录字符大小排序)
		for(int i=0; i<n-1; i++){
			for(int j=i+1; j<n; j++){
				int k = 0;
				while(p[f[i]][k]==p[f[j]][k])
					k++;
				if(p[f[i]][k]>p[f[j]][k]){
					int tmp = f[i];
					f[i] = f[j];
					f[j] = tmp;
				}
			}
		}

		// 打印测试路径
		for(int i=0; i<n; i++){
			int num=0;			        // num表示当前路径输出的初始缩进
            for(int j=i-1; j>=0; j--){	// 判断根目录是否在已打印路径中出现过
				int k = 0, l=0;         // k用于遍历一条路径,l用于统计相同目录数
				while(p[f[j]][k]==p[f[i]][k] && p[f[j]][k+1]==p[f[i]][k+1]){
                    if(p[f[j]][k]!='\\')
						l++;
                    k++;
				}
				if(num<2*l)                 // 更新初始缩进
					num = 2*l;
			}
            
            // 设置起始输出下标
			int j;                          // 起始输出目录下标
			if(num!=0){						// 有重复的父目录
				j = num;                    // 起始输出下标=初始缩进
				if(p[i][j]=='\0'){			// 除已出现目录外,无目录访问时
					printf("%c", p[i][0]);	// 需直接输出目录名,无缩进
					num=0;
				}
	            for(int k=0; k<num; k++)	// 后续还有路径,则需先打印初始缩进
					printf(" ");
			}
			else
				j=0;						// 无已出现目录,则从头开始打印

            // 循环输出测试路径
            while(p[f[i]][j]!='\0'){
                if(p[f[i]][j]!='\\'){
                    printf("%c", p[f[i]][j]);
                    num+=2;					// 每输出一个目录,输出下个目录需增加两个右缩进
                }
                else{
					if(p[f[i]][j+1]!='\0')
						printf("\n");      // 每输出完一个目录需换行
                    for(int k=0; k<num; k++)
                        printf(" ");
                }
                j++;
            }
            printf("\n");                  // 换行进行下一个测试路径输出
            if(i+1==n)
                printf("\n");              // 测试集与测试集之间需空一行
        }
    }
    return 0;
}
纯C

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

int main() {
    int n;
    string s;
    while (cin >> n) {
        if (n == 0)break;
        auto* arr = new string[n];
        for (int i = 0; i < n; ++i) {
            cin >> s;
            arr[i] = s;
        }
        // 题目的注说了同一级的需要按字母顺序排列，不能乱。
        sort(arr, arr + n);
        for (int i = 0; i < n; ++i) {
            string space;
            bool flag = true;// 标记这一串跟上一串前j-1处是否相同
            // 处理输入的每一个串（也就是每一条路径）
            for (int j = 0; j < arr[i].size(); ++j) {
                //这一串跟上一串的j处是否相等，并且前j-1处是否相等
                if (i != 0 && arr[i - 1][j] == arr[i][j] && flag) {
                    //如果是字母
                    if (arr[i - 1][j] != '\\') {
                        //因为不用输出父目录，所以直接过滤
                        for (int k = j; arr[i][k] != '\\' && k < arr[i].size(); k++, j++);
                        //上面的for循环退出条件是==\或者是数组越界，所以得--让改575行的for循环++j指向\，并且让他不越界
                        j--;
                        //不输出父目录，只需要添加空格
                        space.append("  ");
                    }
                } else {
                    flag = false;//如果进来了这里，则说明这一串跟上一串前j-1处已经不相同了
                    //是字母的话，则输出空格并且回车
                    if (arr[i][j] != '\\') {
                        cout << space;
                        //输出该层目录的名字如例子中的cst
                        for (int k = j; arr[i][k] != '\\' && k < arr[i].size(); k++, j++) {
                            cout << arr[i][k];
                        }
                        // 输入的式子中，最后一个字符是字母（j==arr[i].size())还是\((j + 1) == arr[i].size())都不需要回车
                        if (j != arr[i].size() && (j + 1) != arr[i].size())
                            cout << endl;
                        //同上
                        j--;

                    } else {
                        space.append("  ");
                    }

                }
            }
            // 如果是多次输入，得换行
            if (i == n - 1)
                cout << endl;
            cout << endl;
        }
    }
}

while True:
    try:
        num = int(input())
        if not num:
            break
        trees = []
        for i in range(num):
            trees.append(input().strip('\\').split('\\'))
        trees.sort()                 #先把树进行排序
        #初始化一个未在目录出现的字符当做上一个目录
        lastSign = ['#','#']         
        for i in range(num):
            beginIndex = 0           #该目录开始输出的子目录索引
            blackNum = 0             #输出空格数
            while beginIndex < len(trees[i]) and beginIndex < len(lastSign) and trees[i][beginIndex] == lastSign[beginIndex]:
                blackNum += 2        #每增加一层加两个索引
                beginIndex += 1
            for j in range(beginIndex, len(trees[i])):
                print(" "*blackNum + trees[i][j])
                blackNum += 2
            lastSign = trees[i]
        print()
    except Exception:
        break

class TreeNode:
    def __init__(self):
        self.children = {}  # 存储子目录

def insert_path(root, path):
    # 按'\'分割路径
    dirs = path.strip('\\').split('\\')
    current = root
    
    # 将路径插入到树中
    for d in dirs:
        if d:  # 忽略空目录名
            if d not in current.children:
                current.children[d] = TreeNode()
            current = current.children[d]

def print_tree(node, prefix="", is_root=True):
    # 获取并排序子目录
    dirs = sorted(node.children.keys())
    
    # 打印每个子目录
    for d in dirs:
        print(f"{prefix}{d}")
        # 递归打印子目录，增加缩进
        print_tree(node.children[d], prefix + "  ", False)

def main():
    while True:
        n = int(input())
        if n == 0:
            break
            
        # 创建根节点
        root = TreeNode()
        
        # 读取并处理所有路径
        for _ in range(n):
            path = input().strip()
            insert_path(root, path)
        
        # 打印目录树
        print_tree(root)
        print()  # 每个测试用例后打印空行

if __name__ == "__main__":
    main()