poj-2001

#include <stdio.h>
 #include <string.h>
 #include <vector>
 #include <string>
 #include <cstdlib>
 #include <iostream>

 using namespace std;

 const int CHAR_NUM = 26;

 struct tireNode{
     char val[22];
     struct tireNode * tireChildNode[CHAR_NUM];
     int appearTime;
     int byTime;
     int childNum;
     int index;
 };

 class stringInfo {
 public:
     string orginal;
     string abbv;
     stringInfo(const string & str): orginal(str), abbv("") {
     }
 };
 typedef struct stringInfo stringInfo;
 typedef struct tireNode tireNode;

 vector<stringInfo> V1;

 tireNode * tireTreeHead;

 void buildTireTree(char * word, int index) {
     if (!tireTreeHead) {
         tireTreeHead = (tireNode *)malloc(sizeof(tireNode));
         memset(tireTreeHead, 0, sizeof(tireNode));
     }
     int wordLength = strlen(word);

     tireNode * currentNode = tireTreeHead;

     for (int i = 0; i < wordLength; i++) {
         if (!currentNode->tireChildNode[word[i]-'a']) {
             currentNode->tireChildNode[word[i]-'a'] = (tireNode *)malloc(sizeof(tireNode));
             memset(currentNode->tireChildNode[word[i]-'a'], 0, sizeof(tireNode));
             strcpy(currentNode->tireChildNode[word[i]-'a']->val, currentNode->val);
             currentNode->childNum++;
             currentNode->tireChildNode[word[i]-'a']->val[strlen(currentNode->val)] = word[i];
             currentNode->tireChildNode[word[i]-'a']->index = index;
         }
         currentNode = currentNode->tireChildNode[word[i]-'a'];
         (currentNode->byTime)++;
     }
     (currentNode->appearTime)++;
     // printf("build %s %d\n", currentNode->val, currentNode->appearTime);
 }

 void getShortsetPrefix(tireNode * currentNode) {
     if (!currentNode) {
         return;
     }
     if (currentNode->byTime == 1) {
         // printf("1 %d %s %s\n", currentNode->index, V1.at(currentNode->index).orginal.c_str(), currentNode->val);
         V1.at(currentNode->index).abbv = currentNode->val;
         return;
     }
     // if (currentNode->appearTime) {
     //     // printf("%s %s\n", currentNode->val, possiblePrefix.c_str());
     //     // printf("2 %s %s\n", V1.at(currentNode->index).c_str(), currentNode->val);
     // }

     for (int i = 0; i < CHAR_NUM; i++) {
         if (currentNode->tireChildNode[i]) {
             getShortsetPrefix(currentNode->tireChildNode[i]);
         }
     }
 }

 void printRes(vector<stringInfo> V) {
     if (!V.size()) {
         cout<<endl;
         // printf("\n");
     }
     vector<stringInfo>::iterator it = V.begin();

     for (;it != V.end(); it++) {
         if (it->abbv.empty()) {
             cout<<it->orginal<<" "<<it->orginal<<endl;
         } else {
             cout<<it->orginal<<" "<<it->abbv<<endl;
             // printf("%s %s\n", it->orginal.c_str(), it->abbv.c_str());
         }
     }

 }

 int main() {
         char word[22] = {0};
         tireTreeHead = NULL;
         V1.clear();
         while(scanf("%s", word) != EOF) {
             // if (!strcmp(word, "end")) {
             //     break;
             // }
             V1.push_back(stringInfo(word));
             buildTireTree(word, V1.size()-1);
         }
         getShortsetPrefix(tireTreeHead);
         printRes(V1);
         return 0;
 }

G++ 1224K 47MS

tire树系列题， 这次用的是动态tire树，静态应该更快，这次也让我意识到，tire树建树本身不是题考察的重点，而是在建立好tire树以后，

如何用这棵树得到最后想要的结果。

题意是得到能无疑义表示该单词的缩写， 想了好久，不知道该如何表示这种abbv，

后来才想明白：

tire树其实是一条条字符串 顺序字符分解 所经过的路径的组合， 那么如何唯一的标示一个字符串？ 2种case：

case1： 单词的整个路径都被其他的单词路过，及该单词必是其他单词的前缀，那么唯一表示办法abbv就是单词本身。

case2:  单词在某个字符以后所经过的路径没有被其他单词所经过过，那么唯一标示此单词的abbv就是前面的共享的前缀将上自己独有路径的第一个字符即可.

自己对tire树还是理解不够深入，从路径角度思考，就好理解很多。

那么在有了上面这个条件以后，就好办了， 只需为每个tire node加上一个byTime 来记录有多少个字符串经过此处，

然后在后面遍历此tire数时，察看当前node的byTime是否为1即可，如果是1，那么必定是某个字符串的独有路径，此node所记录的累加字符串即为该字符串的最短abbv，

并且直接return（这条路已经不需要再check了，可以理解为剪枝），遍历其他的tirenode。

本题比较烦人的是最后的输出，

还要按照原来的顺序输出原字符串与abbv, 及不但要得到abbv，还要能记录该abbv是对应于哪个原字符串。

我搞了一个很麻烦的法子，在原字符串输入时，就俺顺序为其分配相应的index，同时在建立tire树的时候，当有新路径被开辟时，tirenode中的index值会设置为此原字符串的index，这样就建立了起来映射关系，

而为了那些整个路径都被共享的原字符串（不能依靠byTime来区分），index在这种情况下也不能用，因为此公共路径的index在输入的时候会被改写多次。

因此就搞了一个复杂的class，存储orginal和addv， addv默认为空， 而original只有在上面遇到独有路径时才会根据node的index来设置vector中的相应的addv。

这样，最后遍历的时候，如果遇到abbv为空的情况，直接输出orginal orginal即可。

一开始WA了几次，原因是设置node的index的时候给了当前node，其实应该设给新建出来的node。

还要找找更好的办法，这个法子太ugly了.

#include <stdio.h>
 #include <string.h>
 #include <vector>
 #include <string>
 #include <cstdlib>
 #include <iostream>

 using namespace std;

 const int CHAR_NUM = 26;

 struct tireNode{
     char val[22];
     struct tireNode * tireChildNode[CHAR_NUM];
     int appearTime;
     int byTime;
     int childNum;
 };

 typedef struct stringInfo stringInfo;
 typedef struct tireNode tireNode;

 vector<string> V1;

 tireNode * tireTreeHead;

 void buildTireTree(char * word) {
     if (!tireTreeHead) {
         tireTreeHead = (tireNode *)malloc(sizeof(tireNode));
         memset(tireTreeHead, 0, sizeof(tireNode));
     }
     int wordLength = strlen(word);

     tireNode * currentNode = tireTreeHead;

     for (int i = 0; i < wordLength; i++) {
         if (!currentNode->tireChildNode[word[i]-'a']) {
             currentNode->tireChildNode[word[i]-'a'] = (tireNode *)malloc(sizeof(tireNode));
             memset(currentNode->tireChildNode[word[i]-'a'], 0, sizeof(tireNode));
             strcpy(currentNode->tireChildNode[word[i]-'a']->val, currentNode->val);
             currentNode->childNum++;
             currentNode->tireChildNode[word[i]-'a']->val[strlen(currentNode->val)] = word[i];
         }
         currentNode = currentNode->tireChildNode[word[i]-'a'];
         (currentNode->byTime)++;
     }
     (currentNode->appearTime)++;
 }

 void getShortsetPrefix(string word) {
     tireNode * currentNode = tireTreeHead;
     int wordLength = word.size();
     for (int i = 0; i < wordLength; i++) {
         if (currentNode->byTime == 1) {
             cout<<word<<" "<<currentNode->val<<endl;
             return;
         } else {
             if (currentNode->tireChildNode[word[i]-'a']) {
                 currentNode = currentNode->tireChildNode[word[i]-'a'];
             }
         }
     }
     cout<<word<<" "<<word<<endl;
 }

 void printRes(vector<string> V) {
     if (!V.size()) {
         cout<<endl;
     }
     vector<string>::iterator it = V.begin();

     for (;it != V.end(); it++) {
         getShortsetPrefix(*it);
     }

 }

 int main() {
         char word[22] = {0};
         tireTreeHead = NULL;
         V1.clear();
         while(scanf("%s", word) != EOF) {
             // if (!strcmp(word, "end")) {
             //     break;
             // }
             V1.push_back(word);
             buildTireTree(word);
         }
         printRes(V1);
         return 0;
 }

G++ 47ms

果然是我SB了，把问题复杂化了。。。

在用vector记录了输入的字符串以后，在输出的时候，只需遍历此vector，

用vector中保存的orginal 字符串对tire数组进行处理即可：

顺序遍历original的字符， 根据字符值沿着tire树中保存的路径一直向下走，沿路检查每个经过node的byTime，如果遇到=1的就输出此orginal abbv return。

否则，如果遍历完都找不到byTime == 1的node，那么可以就直接输出orginal original。