HDU

https://vjudge.net/problem/HDU-6208

首先可以知道最长那个串肯定是答案

然后，相当于用n - 1个模式串去匹配这个主串，看看有多少个能匹配。

普通kmp的话，每次都要O(mxLen)的复杂度肯定不行。考虑AC自动机，不说这个算法了都懂。

大概就是，询问主串的时候用Fail指针快速转移到LCP，然后就可以用字典树快速判断其是否一个模式串

可以知道判断过的可以标记下，不需要再判断了（听说很多人TLE在这里了，比赛的时候写歪了也TLE）

#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(false)
using namespace std;
#define inf (0x3f3f3f3f)
typedef long long int LL;
const int maxn = 6e5 + 2, N = 26;
struct node {
    int flag;
    struct node *Fail;    //失败指针，匹配失败，跳去最大前后缀
    struct node *pNext[N];
} tree[maxn];
int t;     //字典树的节点
struct node *create() {   //其实也只是清空数据而已，多case有用，根是0号顶点、
    struct node *p = &tree[t++];
    p->flag = 0;
    p->Fail = NULL;
    for (int i = 0; i < N; i++) {
        p->pNext[i] = NULL;
    }
    return p;
}
void toinsert(struct node **T, char str[], int be, int en) {
    struct node *p = *T;
    if (p == NULL) {
        p = *T = create();
    }
    for (int i = be; i <= en; i++) {
        int id = str[i] - 'a';
        if (p->pNext[id] == NULL) {
            p->pNext[id] = create();
        }
        p = p->pNext[id];
    }
    p->flag++;    //相同的单词算两次
}
struct node *que[maxn + 2]; //这里的t是节点总数，字典树那里统计的，要用G++编译
void BuiltFail(struct node **T) {
    //根节点没有失败指针,所以都是需要特判的
    //思路就是去到爸爸的失败指针那里，找东西匹配，这样是最优的
    struct node *p = *T; //用个p去代替修改
    struct node *root = *T;
    if (p == NULL) return ;
    //树上bfs,要更改的是p->pNext[i]->Fail
    int head = 0, tail = 0;
    que[tail++] = root;
    while (head < tail) {
        p = que[head]; //p取出第一个元素 ★
        for (int i = 0; i < N; i++) { //看看存不存在这个节点
            if (p->pNext[i] != NULL) { //存在的才需要管失败指针。
                if (p == root) { //如果爸爸是根节点的话，根节点没有失败指针
                    p->pNext[i]->Fail = root; //指向根节点
                } else {
                    struct node *FailNode = p->Fail; //首先找到爸爸的失败指针
                    while (FailNode != NULL) {
                        if (FailNode->pNext[i] != NULL) { //存在
                            p->pNext[i]->Fail = FailNode->pNext[i];
                            break;
                        }
                        FailNode = FailNode->Fail; //回溯，根节点的fail是NULL
                    }
                    if (FailNode == NULL) { //如果还是空，那么就指向根算了
                        p->pNext[i]->Fail = root;
                    }
                }
                que[tail++] = p->pNext[i]; //这个id是存在的，入队bfs
            }
        }
        head++;
    }
}
int searchAC(struct node *T, char str[], int be, int en) {
    int ans = 0;
    struct node *p = T;
    struct node *root = T;
    if (p == NULL) return 0;
    for (int i = be; i <= en; i++) { //遍历主串中的每一个字符
        int id = str[i] - 'a';
        p = p->pNext[id]; //去到这个节点，虚拟边也建立起来了，所以一定存在。
        struct node *temp = p; //p不用动，下次for就是指向这里就OK，temp去找后缀串
  //什么叫找后缀串？就是，有单词 she,he 串***she，那么匹配到e的时候，she统计成功
  //这个时候，就要转移去到he那里，也把he统计进去。也就是找等价态
        while (temp != root && temp->flag != -1) { //root没失败指针
            if (temp->flag > 0) {
                ans += temp->flag;
            }
            temp->flag = -1;  //标记，，他们卡在这里吗
            temp = temp->Fail;
        }
    }
    return ans;
}
char str[maxn];
void work() {
    t = 0;
    int n;
    scanf("%d", &n);
    struct node * T = NULL;
    int ansbe = 0, ansen = 0, anslen = 0;
    int pre = 1;
    for (int i = 1; i <= n; ++i) {
        scanf("%s", str + pre);
        int tlen = strlen(str + pre);
        pre += tlen;
        if (tlen > anslen) {
            anslen = tlen;
            ansbe = pre - tlen;
            ansen = pre - 1;
        }
        toinsert(&T, str, pre - tlen, pre - 1);
    }
//    printf("%s
", now + 1);
    BuiltFail(&T);
    if (searchAC(T, str, ansbe, ansen) == n) {
        for (int i = ansbe; i <= ansen; ++i) {
            printf("%c", str[i]);
        }
        printf("
");
    } else printf("No
");
}

int main() {
#ifdef local
    freopen("data.txt", "r", stdin);
//    freopen("data.txt", "w", stdout);
#endif
    int t;
    scanf("%d", &t);
    while (t--) work();
    return 0;
}

然后生气了还是sam吧

对最长的串建立sam

对于每一个串是否其子串，可以O(lensub)判断。

#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(false)
using namespace std;
#define inf (0x3f3f3f3f)
typedef long long int LL;
const int maxn = 1e5 + 2, N = 26;
struct SAM {
    int mxCnt[maxn << 1], son[maxn << 1][N], fa[maxn << 1];
    int root, last, DFN, t;
    int create() {
        ++t;
        mxCnt[t] = fa[t] = NULL;
        for (int i = 0; i < N; ++i) son[t][i] = NULL;
        return t;
    }
    void init() {
        ++DFN;
        t = 0, root = 1;
        last = create();
    }
    void addChar(int x, int _pos, int id) {
        int p = last;
        int np = create();
        last = np;
        mxCnt[np] = mxCnt[p] + 1;
        for (; p && son[p][x] == NULL; p = fa[p]) son[p][x] = np;
        if (p == NULL) {
            fa[np] = root;
            return;
        }
        int q = son[p][x];
        if (mxCnt[q] == mxCnt[p] + 1) {
            fa[np] = q;
            return;
        }
        int nq = create();
        for (int i = 0; i < N; ++i) son[nq][i] = son[q][i];
        fa[nq] = fa[q], mxCnt[nq] = mxCnt[p] + 1;
        fa[q] = nq, fa[np] = nq;
        for (; p && son[p][x] == q; p = fa[p]) son[p][x] = nq;
    }
    bool is(string &str, int tt) {
        int p = root;
        for (int i = 0; i < tt; ++i) {
            if (son[p][str[i] - 'a']) {
                p = son[p][str[i] - 'a'];
            } else return false;
        }
        return true;
    }
} sam;
string str[maxn];
int tt[maxn];
char liu[maxn];
void work() {
    sam.init();
    int n;
    scanf("%d", &n);
    int id = 0, len = 0;
    for (int i = 1; i <= n; ++i) {
        scanf("%s", liu);
        str[i] = string(liu);
        tt[i] = strlen(str[i].c_str());
        if (len < tt[i]) {
            len = tt[i];
            id = i;
        }
    }
    for (int i = 0; i < len; ++i) {
        sam.addChar(str[id][i] - 'a', i, 0);
    }
    for (int i = 1; i <= n; ++i) {
        if (i == id) continue;
        if (!sam.is(str[i], tt[i])) {
            printf("No
");
            return;
        }
    }
    printf("%s
", str[id].c_str());
}

int main() {
#ifdef local
    freopen("data.txt", "r", stdin);
//    freopen("data.txt", "w", stdout);
#endif
    int t;
    scanf("%d", &t);
    while (t--) work();
    return 0;
}