ural(Timus) 1067. Disk Tree

数据结构：暴力（可用哈希优化）+建树+前序遍历

题意：输入行数n，下面n行是一下文件的路径（和平常使用的电脑一样），一整行数据中没有空格（还好，别有搞些空格出来），要你整理好所有文件的路径，从根开始，输出所有的文件夹名

首先一点，我们要名字，在同一个文件夹下，是不会有重名的文件夹的

即

a\b

a\b

这种是非法的（和电脑一样），但是输入中可以有，有的话只是一种重复输入，不是代表a下面真的有两个b

然后不同文件夹下可以由相同的名字，就好比你D盘和E盘都有一个文件夹叫“电影”

例如

a\b

d\b

这种是合法的在输入中也是会出现的，看case就知道。

另外，每个文件夹都只有一个双亲

好像a\b\c\d , 你要找d，输入中会不会出现 a\d 或者 a\b\d  a\c\d 呢？ 是不会的！因为这题是严格按照电脑的模式来搞的，在电脑中你要找d，其路径必定是a\b\c\d

这就可以保证每个文件夹的双亲是唯一的，就是它前面那个文件夹

最后最重要的一点：

a\b

d\b

这里的b是两个不同的b，虽然名字一样，所以我们确定一个文件夹，是怎么确定，首先看名字，名字不同，一定是不同的文件夹，名字相同，看它的双亲（唯一的），如果双亲不同它们不是同一个人文件夹，如果相同，那么是同一个文件夹。

所以我们没读入一个文件夹，就给它映射成一个标号，每个不同的文件夹对应一个不同的标号，然后用这些标号来建树即可，建完数，将每个节点的孩子名字按字典序排序再前序遍历输出

关键是怎么映射标号，用哈希就是个不错的选择，而且题目说了，每个文件夹的名字长度为1-8。

不过我这里是用暴力，直接O(n)扫描给每个文件夹名字标号

这题应该来说是用哈希做的，或者什么其他方法，但是我是用暴力，时间比较糟糕1.1s，不过还是过，整个题目的关键是怎么给文件夹的表示，即怎么映射地好，然后建树，前序遍历整个树输出即可

 

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 550 //500行输入
#define M 20100 //最多文件夹数

char name[M][20];
int par[M];
int sonnum[M];
struct Son
{
    int son[110]; //10000在test#10爆内存，改为1000还爆，改到100就AC了，所以孩子数最多就100
}s[M];
int n,namenum,root;

int search(char *str , int p)
{
    for(int i=0; i<namenum; i++)
        if(!strcmp(name[i] , str) && par[i]==p)
            return i;
    strcpy(name[namenum] , str);
    par[namenum]=p;
    sonnum[namenum]=0; //记得
    return namenum;
}

void input()
{
    namenum=0;
    memset(par,-1,sizeof(par));
    for(int nn=1; nn<=n; nn++)
    {
        char str[110],tmp[20];
        int i,j,k,len,PAR,SON;
        scanf("%s",str);
        len=strlen(str);
        for(i=0,j=0; i<len && str[i]!='\\'; i++,j++)
            tmp[j]=str[i];
        tmp[j]='\0'; i++;
        PAR=search(tmp,-1);
        if(PAR==namenum) namenum++;
        while(i<len)
        {
            for(j=0; i<len && str[i]!='\\'; i++,j++)
                tmp[j]=str[i];
            tmp[j]='\0'; i++;
            SON=search(tmp,PAR);
            if(SON==namenum) //说明是一个新单词
            {
                namenum++;
                int sn = sonnum[PAR]++; //PAR这个节点的孩子要增加
                s[PAR].son[sn] = SON;
            }
            PAR=SON;
        }
    }
    root=namenum++;
    sonnum[root]=0;
    for(int i=0; i<root; i++)
        if(par[i]==-1)
        {
            par[i]=root;
            int sn=sonnum[root]++;
            s[root].son[sn]=i;
        }
}

int cmp_str(int a ,int b)
{
    char name_1[20] , name_2[20];
    strcpy(name_1 , name[a]);
    strcpy(name_2 , name[b]);
    return strcmp(name_1 , name_2)<0 ;
}

void SORT()
{
    for(int i=0; i<namenum; i++)
    {
        int sn=sonnum[i];
        sort(s[i].son , s[i].son+sn , cmp_str);
    }
}

void travel(int rt , int level)
{
    for(int i=0; i<level; i++) 
        printf(" ");
    printf("%s\n",name[rt]);
    for(int i=0; i<sonnum[rt]; i++)
    {
        int son=s[rt].son[i];
        travel(son,level+1);
    }
}

int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        input();
        SORT(); //对所有节点的孩子按字典序排序
        for(int i=0; i<sonnum[root]; i++)
        {
            int son=s[root].son[i];
            travel(son,0);
        }
    }
    return 0;
}