[UVA1449] Dominating Patterns（AC自动机，STL，计数，神坑）

题目链接：https://vjudge.net/problem/UVA-1449

题意：给一个词典和一个字符串，找出字符串里出现次数最多的单词，如果有出现次数相同的，要按照输入顺序输出。

坑点好多，或许是因为自己实现得比较挫所以坑才多。

用一个map<string,int>计数，map<string,vector<int>>记录同样的字符串出现的位置，map<string,int> p记录id，string数组记录对应id下的字符串。

查询的时候注意假如字符串中并没有出现词典中的单词，输出0，要按顺序把所有字符串打印出来。

太菜了，这个坑WA了十发。

#include <bits/stdc++.h>
using namespace std;


typedef pair<int, int> pii;
typedef pair<int, string> pis;
const int maxn = 155;
const int maxm = 1000100;
map<string, int> vis;
map<string, vector<int>> id;
map<string, int> p;
string qq[maxn];
int pcnt;

typedef class Node {
public:
    Node *next[26];
    Node *fail;
    int flag;
    int id;
    Node() {
        memset(next, 0, sizeof(next));
        fail = NULL;
        flag = 0;
        id = -1;
    }
}Node;

class AC_Automation {
public:
    Node *root;
    queue <Node*> q;
    AC_Automation() {
        root = new Node();
        while(!q.empty()) q.pop();
    }
    void insert(string s) {
        Node *cur = root;
        int len = s.length();
        for(int i = 0; i < len; i++) {
            int index = s[i] - 'a';
            if(cur->next[index] == NULL) {
                cur->next[index] = new Node();
            }
            cur = cur->next[index];
        }
        cur->id = p[s]; cur->flag = 1;
    }
    void BuildAC() {
        Node *cur, *tmp;
        q.push(root);
        while(!q.empty()) {
            cur = q.front();
            q.pop();
            for(int i = 0; i < 26; i++) {
                if(!cur->next[i]) continue;
                if(cur == root) {
                    cur->next[i]->fail = root;
                }
                else {
                    tmp = cur->fail;
                    while(tmp != NULL) {
                        if(tmp->next[i]) {
                            cur->next[i]->fail = tmp->next[i];
                            break;
                        }
                        tmp = tmp->fail;
                    } 
                    if(tmp == NULL) {
                        cur->next[i]->fail = root;
                    }
                }
                q.push(cur->next[i]);
            }
        }
    }
    void query(string s) {
        Node *cur = root, *tmp;
        int len = s.length();
        for(int i = 0; i < len; i++) {
            int index = s[i] - 'a';
            while(cur->next[index] == NULL && cur != root) {
                cur = cur->fail;
            }
            cur = cur->next[index];
            if(cur == NULL) {
                cur = root;
                continue;
            }
            tmp = cur;
            while(tmp != root) {
                if(tmp->flag) vis[qq[tmp->id]]++;
                tmp = tmp->fail;
            }
        }
        int maxx = 0;
        vector<pis> ret;
        for(auto it : vis) maxx = max(maxx, it.second);
        for(auto it : vis) {
            if(it.second == maxx) {
                for(auto itt : id[it.first]) {
                    ret.push_back(pis(itt, it.first));
                }
            }
        }
        sort(ret.begin(), ret.end());
        printf("%d
", maxx);
        if(maxx != 0) {
            for(auto it : ret) {
                printf("%s
", it.second.c_str());
            }
        }
        else {
            for(int i = 0; i < pcnt; i++) {
                printf("%s
", qq[i].c_str());
            }
        }
    }
};

char pat[maxn], tar[maxm];
int n;

int main() {
    // freopen("in", "r", stdin);
    while(~scanf("%d", &n) && n) {
        id.clear(); p.clear(); vis.clear();
        pcnt = 0;
        AC_Automation ac = AC_Automation();
        for(int i = 1; i <= n; i++) {
            scanf("%s", pat);
            if(p.find(pat) == p.end()) {
                qq[pcnt] = pat;
                p[pat] = pcnt++;
            }
            id[pat].push_back(i);
            ac.insert(pat);
        }
        ac.BuildAC();
        scanf("%s", tar);
        ac.query(tar);
    }
    return 0;
}