No Prefix Set(Tire Tree)

Given strings. Each string contains only lowercase letters from (both inclusive). The set of strings is said to be GOOD SET if no string is prefix of another string else, it is BAD SET. (If two strings are identical, they are considered prefixes of each other.)

For example, aab, abcde, aabcd is BAD SET because aab is prefix of aabcd.

Print GOOD SET if it satisfies the problem requirement. Else, print BAD SET and the first string for which the condition fails.

Input Format First line contains , the number of strings in the set. Then next lines follow, where line contains string.

Constraints Length of the string

Output Format Output GOOD SET if the set is valid. Else, output BAD SET followed by the first string for which the condition fails.

Sample Input00

7
aab
defgab
abcde
aabcde
cedaaa
bbbbbbbbbb
jabjjjad

Sample Output00

BAD SET
aabcde

Sample Input01

4
aab
aac
aacghgh
aabghgh

Sample Output01

BAD SET
aacghgh

Explanation aab is prefix of aabcde. So set is BAD SET and it fails at string aabcde.

Code:

  1 #pragma comment(linker, "/STACK:36777216")
  2
  3 #include <bits/stdc++.h>
  4 using namespace std;
  5 #define LSON            id << 1 , l , mid
  6 #define RSON            id << 1 | 1 , mid + 1 , r
  7 #define ROOT            1 , 1 , n
  8 #define CLR(x , y)      memset(x , y , sizeof(x))
  9 #define LOWBIT(x)       x & (-x)
 10 #define FORN(i , a , n)  for(int i = (a) ; i <= (n) ; ++i)
 11 #define FORP(i , n , a)  for(int i = (n) ; i >= (a) ; --i)
 12 #define CASE(x)        printf("Case %d: ", x)
 13 #define SFD(x)      scanf("%lf" , &x)
 14 #define SFC(x)      scanf(" %c" , &x)
 15 #define SFS(x)      scanf(" %s" , x)
 16 #define SFI(x)      scanf("%d" , &x)
 17 #define SFL(x)      scanf("%lld" , &x)
 18 #define SFI64(x)    scanf("%I64d" , &x)
 19 #define PFF(x)         printf("%f" , x)
 20 #define PFD(x)         printf("%lf" , x)
 21 #define PFI(x)         printf("%d" , x)
 22 #define PFC(x)         printf("%c" , x)
 23 #define PFS(x)         printf("%s" , x)
 24 #define PFI64(x)       printf("%I64d" , x)
 25 #define PFL(x)         printf("%lld" , x)
 26 #define SPACE          printf(" ")
 27 #define PUT            puts("")
 28 #define LPUP(i , j , k) for(int i = j ; i <= k ; ++i)
 29 #define LPDW(i , j , k) for(int i = j ; i >= k ; --i)
 30 #define PB(x)          push_back(x)
 31 #define ALL(A)         A.begin(), A.end()
 32 #define SZ(A)          int((A).size())
 33 #define LBD(A, x)      (lower_bound(ALL(A), x) - A.begin())
 34 #define UBD(A, x)      (upper_bound(ALL(A), x) - A.begin())
 35 #define LOCAL
 36 static const double PI = acos(-1.0);
 37 static const double EPS = 1e-8;
 38 static const int INF = 0X3fffffff;
 39 typedef long long LL;
 40 typedef double DB;
 41 template<class T> inline
 42 void read(T &x)
 43 {
 44     x = 0;
 45     int f = 1 ; char ch = getchar();
 46     while (ch < ‘0‘ || ch > ‘9‘) {if (ch == ‘-‘) f = -1; ch = getchar();}
 47     while (ch >= ‘0‘ && ch <= ‘9‘) {x = x * 10 + ch - ‘0‘; ch = getchar();}
 48     x *= f;
 49 }
 50
 51 /************************Little Pea****************************/
 52 static const int MAXN = 80;
 53 int n;
 54 struct Node
 55 {
 56     int v;
 57     Node* next[27];
 58     Node ()
 59     {
 60         v = 0;
 61         CLR(next , NULL);
 62     }
 63 };
 64 Node* root;
 65 bool Insert(char *s , int len)
 66 {
 67     Node* p = root;
 68     bool flag = 1;
 69     for(int i = 0 ; i < len ; ++i)
 70     {
 71         int id = s[i] - ‘a‘;
 72         if(p->next[id] == NULL)
 73         {
 74             p->next[id] = new Node();
 75             flag = 0;
 76         }
 77         p = p->next[id];
 78         if(p->v)
 79             return 0;
 80     }
 81     if(flag)
 82         return 0;
 83     ++(p->v);
 84     return 1;
 85 }
 86 int main()
 87 {
 88 #ifndef ONLINE_JUDGE
 89     //freopen("D:\\系统优化\\Desktop\\littlepea\\in.data" , "r" , stdin);
 90 #endif
 91     read(n);
 92     root = new Node();
 93     bool flag = 1;
 94     char ans[MAXN] = {‘\0‘};
 95     while(n--)
 96     {
 97         char data[MAXN] = {‘\0‘};
 98         SFS(data);
 99         if(flag)
100         {
101             if(!Insert(data , strlen(data)))
102             {
103                 flag = 0;
104                 strcpy(ans , data);
105             }
106         }
107     }
108     if(flag)
109         puts("GOOD SET");
110     else
111     {
112         puts("BAD SET");
113         printf("%s" , ans);
114     }
115
116 #ifndef ONLINE_JUDGE
117     fclose(stdin), fclose(stdout);
118 #endif
119 }

Test data:

  1 Input:
  2 100
  3 hgiiccfchbeadgebc
  4 biiga
  5 edchgb
  6 ccfdbeajaeid
  7 ijgbeecjbj
  8 bcfbbacfbfcfbhcbfjafibfhffac
  9 ebechbfhfcijcjbcehbgbdgbh
 10 ijbfifdbfifaidje
 11 acgffegiihcddcdfjhhgadfjb
 12 ggbdfdhaffhghbdh
 13 dcjaichjejgheiaie
 14 d
 15 jeedfch
 16 ahabicdffbedcbdeceed
 17 fehgdfhdiffhegafaaaiijceijdgbb
 18 beieebbjdgdhfjhj
 19 ehg
 20 fdhiibhcbecddgijdb
 21 jgcgafgjjbg
 22 c
 23 fiedahb
 24 bhfhjgcdbjdcjjhaebejaecdheh
 25 gbfbbhdaecdjaebadcggbhbchfjg
 26 jdjejjg
 27 dbeedfdjaghbhgdhcedcj
 28 decjacchhaciafafdgha
 29 a
 30 hcfibighgfggefghjh
 31 ccgcgjgaghj
 32 bfhjgehecgjchcgj
 33 bjbhcjcbbhf
 34 daheaggjgfdcjehidfaedjfccdafg
 35 efejicdecgfieef
 36 ciidfbibegfca
 37 jfhcdhbagchjdadcfahdii
 38 i
 39 abjfjgaghbc
 40 bddeejeeedjdcfcjcieceieaei
 41 cijdgbddbceheaeececeeiebafgi
 42 haejgebjfcfgjfifhihdbddbacefd
 43 bhhjbhchdiffb
 44 jbbdhcbgdefifhafhf
 45 ajhdeahcjjfie
 46 idjajdjaebfhhaacecb
 47 bhiehhcggjai
 48 bjjfjhiice
 49 aif
 50 gbbfjedbhhhjfegeeieig
 51 fefdhdaiadefifjhedaieaefc
 52 hgaejbhdebaacbgbgfbbcad
 53 heghcb
 54 eggadagajjgjgaihjdigihfhfbijbh
 55 jadeehcciedcbjhdeca
 56 ghgbhhjjgghgie
 57 ibhihfaeeihdffjgddcj
 58 hiedaegjcdai
 59 bjcdcafgfjdejgiafdhfed
 60 fgdgjaihdjaeefejbbijdbfabeie
 61 aeefgiehgjbfgidcedjhfdaaeigj
 62 bhbiaeihhdafgaciecb
 63 igicjdajjdegbceibgebedghihihh
 64 baeeeehcbffd
 65 ajfbfhhecgaghgfdadbfbb
 66 ahgaccehbgajcdfjihicihhc
 67 bbjhih
 68 a
 69 cdfcdejacaicgibghgddd
 70 afeffehfcfiefhcagg
 71 ajhebffeh
 72 e
 73 hhahehjfgcj
 74 ageaccdcbbcfidjfc
 75 gfcjahbbhcbggadcaebae
 76 gi
 77 edheggceegiedghhdfgabgcd
 78 hejdjjbfacggdccgahiai
 79 ffgeiadgjfgecdbaebagij
 80 dgaiahge
 81 hdbaifh
 82 gbhccajcdebcig
 83 ejdcbbeiiebjcagfhjfdahbif
 84 g
 85 ededbjaaigdhb
 86 ahhhcibdjhidbgefggdjebfcf
 87 bdigjaehfchebiedajcjdh
 88 fjehjgbdbaiifi
 89 fbgigbdcbcgffdicfcidfdafghajc
 90 ccajeeijhhb
 91 gaaagfacgiddfahejhbgdfcfbfeedh
 92 gdajaigfbjcdegeidgaccjfi
 93 fghechfchjbaebcghfcfbdicgaic
 94 cfhigaciaehacdjhfcgajgbhhgj
 95 edhjdbdjccbfihiaddij
 96 cbbhagjbcadegicgifgghai
 97 hgdcdhieji
 98 fbifgbhdhagch
 99 cbgcdjea
100 dggjafcajhbbbaja
101 bejihed
102 eeahhcggaaidifdigcfjbficcfhjj
103 OutPut:
104 BAD SET
105 d

data

时间: 2024-10-10 14:34:17

No Prefix Set(Tire Tree)的相关文章

HDU 1251 统计难题(Tire tree)

统计难题 Problem Description Ignatius最近遇到一个难题,老师交给他很多单词(只有小写字母组成,不会有重复的单词出现),现在老师要他统计出以某个字符串为前缀的单词数量(单词本身也是自己的前缀). Input 输入数据的第一部分是一张单词表,每行一个单词,单词的长度不超过10,它们代表的是老师交给Ignatius统计的单词,一个空行代表单词表的结束.第二部分是一连串的提问,每行一个提问,每个提问都是一个字符串. 注意:本题只有一组测试数据,处理到文件结束. Output

[LeetCode][JavaScript]Implement Trie (Prefix Tree)

Implement Trie (Prefix Tree) Implement a trie with insert, search, and startsWith methods. https://leetcode.com/problems/implement-trie-prefix-tree/ 实现字典树,每个节点至多有26个子孙,代表26个字母. 每个节点都有三个属性,key, isWord以及字典(哈希表,提高访问速度,也可以用数组),因为JS可以扩展实例化的对象,直接用下标访问对象,不需

Trie Tree的c++实现

问题描述: 1.Tire tree 是一种用来存储字符串的高效的数据结构.它的插入和查询的时间复杂度为O(string length).用self balance tree 存储字符串的 时间复杂度为O(length(string)*lgN),N是树的节点树.Trie tree的查询和存储优势是很显然的: 2.它的缺点是树的存储空间变大,需要更多的内存: 3.它的每个节点会有多个孩子节点,同一节点下的孩子共享相同的前缀串(从根节点到父节点的字符串): 4.详细可见下图: 程序代码: #ifnde

IK分词器原理与源码分析

原文:http://3dobe.com/archives/44/ 引言 做搜索技术的不可能不接触分词器.个人认为为什么搜索引擎无法被数据库所替代的原因主要有两点,一个是在数据量比较大的时候,搜索引擎的查询速度快,第二点在于,搜索引擎能做到比数据库更理解用户.第一点好理解,每当数据库的单个表大了,就是一件头疼的事,还有在较大数据量级的情况下,你让数据库去做模糊查询,那也是一件比较吃力的事(当然前缀匹配会好得多),设计上就应当避免.关于第二点,搜索引擎如何理解用户,肯定不是简单的靠匹配,这里面可以加

剑指Offer——Trie树(字典树)

剑指Offer--Trie树(字典树) Trie树 Trie树,即字典树,又称单词查找树或键树,是一种树形结构,是一种哈希树的变种.典型应用是统计和排序大量的字符串(但不仅限于字符串),所以经常被搜索引擎系统用于文本词频统计.它的优点是:最大限度地减少无谓的字符串比较,查询效率比哈希表高. Trie的核心思想是空间换时间.利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的. Trie树也有它的缺点,Trie树的内存消耗非常大.当然,或许用左儿子右兄弟的方法建树的话,可能会好点.可见,优

字典树模板(java)

class Trie{ private int SIZE=26; private TrieNode root;//字典树的根 Trie(){//初始化字典树 root=new TrieNode(); } private class TrieNode{//字典树节点 private int num;//有多少单词通过这个节点,即节点字符出现的次数 private TrieNode[] son;//所有的儿子节点 private boolean isEnd;//是不是最后一个节点 private c

Mapreduce-Partition分析(转)

http://blog.oddfoo.net/2011/04/17/mapreduce-partition%E5%88%86%E6%9E%90-2/ Partition所处的位置 Partition位置 Partition主要作用就是将map的结果发送到相应的reduce.这就对partition有两个要求: 1)均衡负载,尽量的将工作均匀的分配给不同的reduce. 2)效率,分配速度一定要快. Mapreduce提供的Partitioner Mapreduce默认的partitioner是H

树结构—Trie树

很有段时间没写此系列了,今天我们来说Trie树,Trie树的名字有很多,比如字典树,前缀树等等. 一:概念 下面我们有and,as,at,cn,com这些关键词,那么如何构建trie树呢? 从上面的图中,我们或多或少的可以发现一些好玩的特性. 第一:根节点不包含字符,除根节点外的每一个子节点都包含一个字符. 第二:从根节点到某一节点,路径上经过的字符连接起来,就是该节点对应的字符串. 第三:每个单词的公共前缀作为一个字符节点保存. 二:使用范围 既然学Trie树,我们肯定要知道这玩意是用来干嘛的

Codeforces Round #260 (Div. 1)

大三目标把codeforces打成黄色以上! 从div1下手,每次做前三道题. A 一道简单的DP. #include<iostream> #include<algorithm> #include<cstring> #include<cstdio> #include<cstdlib> #include<string> #include<cmath> #include<vector> #define LL lon