zoukankan      html  css  js  c++  java
  • 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;
    }
    View Code

    然后生气了还是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;
    }
    View Code
  • 相关阅读:
    电信生命周期说明
    find in linux 2 微信公众号
    GDB中应该知道的几个调试方法 2 微信公众号
    linux 下程序员专用搜索源码用来替代grep的软件ack(后来发现一个更快的: rg), 且有vim插件的 2 微信公众号
    linux下的 c 和 c++ 开发工具及linux内核开发工具 2 微信公众号
    linux下命令行发送邮件的软件:mutt 微信公众号
    腺样体肿大的综合治疗考虑 微信公众号
    打呼噜治疗方法 微信公众号
    vim 操作 2 微信公众号
    nginx之外的web 服务器caddy 微信公众号
  • 原文地址:https://www.cnblogs.com/liuweimingcprogram/p/7537989.html
Copyright © 2011-2022 走看看