Keywords Search

Keywords Search

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 25356    Accepted Submission(s): 8280

Problem Description

In the modern time, Search engine came into the life of everybody like Google, Baidu, etc. Wiskey also wants to bring this feature to his image retrieval system. Every image have a long description, when users type some keywords to find the image, the system will match the keywords with description of image and show the image which the most keywords be matched. To simplify the problem, giving you a description of image, and some keywords, you should tell me how many keywords will be match.

 

Input

First line will contain one integer means how many cases will follow by. Each case will contain two integers N means the number of keywords and N keywords follow. (N <= 10000) Each keyword will only contains characters 'a'-'z', and the length will be not longer than 50. The last line is the description, and the length will be not longer than 1000000.

 

Output

Print how many keywords are contained in the description.

 

Sample Input

1 5 she he say shr her yasherhs

 

Sample Output

3

text:100万长度，关键字1万，多个测试案例，用Trie匹配必定超时。Trie也可以多模式匹配，不多比AC自动机耗时太多。

Trie 超时代码：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <algorithm>
 #include <string>
 #include <vector>
 #include <stack>
 #include <queue>
 #include <set>
 #include <map>
 #include <iomanip>
 #include <cstdlib>
 using namespace std;
 const int INF=0x5fffffff;
 const int MS=;
 const double EXP=1e-;
 
 struct node
 {
     int have;//根据情况灵活变化
     node * next[];
 }nodes[MS*];   //注意这个大小  尽量大一点
 
 node *root;
 int cnt,ans;
 
 char text[MS*];
 
 node * add_node(int c)
 {
     node *p=&nodes[c];
     for(int i=;i<;i++)
         p->next[i]=NULL;
     p->have=;
     return p;
 }
 
 void insert(char *str)
 {
     node *p=root;
     int len=strlen(str);
     for(int i=;i<len;i++)
     {
         int id=str[i]-'a';
         if(p->next[id]==NULL)
         {
             p->next[id]=add_node(cnt++);
         }
         p=p->next[id];
     }
     p->have++;
 }
 void search(char *str)
 {
     node *p=root;
     int len=strlen(str);
     for(int i=;i<len;i++)
     {
         int id=str[i]-'a';
         p=p->next[id];
         if(p==NULL)
             return ;
         if(p->have)
         {
             ans+=p->have;
             p->have=;
         }
     }
 }
 
 int main()
 {
     int n,i,T;
     scanf("%d",&T);
     while(T--)
     {
         cnt=;
         ans=;
         root=add_node(cnt++);
         scanf("%d",&n);
         for(i=;i<n;i++)
         {
             scanf("%s",text);
             insert(text);
         }
         scanf("%s",text);
         int len=strlen(text);
         for(i=;i<len;i++)
         {
             search(text+i);
         }
         printf("%d\n",ans);
     }
     return ;
 }

这题是AC自动机最经典的入门题。学会了kmp,Trie,就可以学习ac自动机了。

time : 280 ms

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <algorithm>
 #include <string>
 #include <vector>
 #include <stack>
 #include <queue>
 #include <set>
 #include <map>
 #include <iomanip>
 #include <cstdlib>
 using namespace std;
 const int INF=0x5fffffff;
 const int MS=;
 const double EXP=1e-;
 //  AC自动机  KMP  TRIE
 struct node
 {
     bool isbad;
     node *pre;
     node * next[];
     int n;
 }nodes[MS*];   //注意这个大小  个数*每个的长度就不会访问非法内存
 
 node *root;
 int cnt,ans;
 
 char text[MS*];
 
 node * add_node(int c)
 {
     node *p=&nodes[c];
     for(int i=;i<;i++)
         p->next[i]=NULL;
     p->isbad=false;
     p->pre=NULL;
     p->n=;
     return p;
 }
 
 void insert(char *str)
 {
     node *p=root;
     int len=strlen(str);
     for(int i=;i<len;i++)
     {
         int id=str[i]-'a';
         if(p->next[id]==NULL)
         {
             p->next[id]=add_node(cnt++);
         }
         p=p->next[id];
     }
     p->isbad=true;
     p->n++;          //终止节点
 }
 
 void build()
 {                                 // 在trie树上加前缀指针
     for(int i=;i<;i++)
         nodes->next[i]=root;
     nodes->pre=NULL;
     root->pre=nodes;
     deque<node *> dq;
     dq.push_back(root);
     while(!dq.empty())
     {
         node *proot=dq.front();
         dq.pop_front();
         for(int i=;i<;i++)
         {
             node *p=proot->next[i];
             if(p!=NULL)
             {
                 node *pre=proot->pre;
                 while(pre)
                 {
                     if(pre->next[i]!=NULL)   //NULL==0
                     {
                         p->pre=pre->next[i];
                         if(p->pre->isbad)
                             p->isbad=true;
                         break;
                     }
                     else
                         pre=pre->pre;
                 }
                 dq.push_back(p);
             }
         }
     }
 }
 
 void search(char *str)
 {                    //返回值为true，说明包含模式串
     node *p=root;
     int len=strlen(str);
     for(int i=;i<len;i++)
     {
         int id=str[i]-'a';
         while(p!=root&&p->next[id]==NULL)
         {
             p=p->pre;
         }
         p=p->next[id];
         if(p==NULL)
         {
             p=root;
         }
         node *tp=p;
         while(tp!=root&&tp->n!=)
         {
             ans+=tp->n;
             tp->n=;
             tp=tp->pre;
         }
 
         /*
         while(1)   是否包含模式串
         {
            if(p->next[id])
            {
                p=p->next[id];
                if(p->isbad)
                     return true;
                break;
            }
            else
             p=p->pre;
         }
         */
     }
 
     //return false;
 }
 
 int main()
 {
     int n,T;
     scanf("%d",&T);
     while(T--)
     {
         cnt=;
         ans=;
         add_node(cnt++);
         root=add_node(cnt++);
         scanf("%d",&n);
         for(int i=;i<n;i++)
         {
             scanf("%s",text);
             insert(text);
         }
         build();
         scanf("%s",text);
         search(text);
         printf("%d\n",ans);
     }
     return ;
 }
 /*
 节点p的前缀指针定义为：指向树中出现
 过的S的最长的后缀(不能等于S)。
 如果p节点匹配失败，该节点对应c，就沿着它的父节点的前缀指针走，直到某节点，其儿子节点
 对应的字母也为c,把p节点的前缀指针指向该儿子节点。如果走到了root都没有找到，就指向root
 */