【gym 101991 E】(ACPC 2018) E. Exciting Menus 题解

题意

• 给 $N$ 个字符串，第 $i$ 个字符串的第 $k$ 个位置（从 $1$ 开始）都有权值 $A_k^i$。
• 定义 $Q(i,j,k)=popularity(S_{j,k}^i)\times A_k^i\times |S_{j,k}^i|$
  • $popularity(str)$ 表示字符串 $str$ 是这 $N$ 个字符串中多少个的前缀
  • $S_{j,k}^i$ 为第 $i$ 个字符串的 $j$ 到 $k$ 的子串
  • $|str|$ 表示字符串 $str$ 的长度
• 求 $Q(i,j,k)$ 的最大值

$1\le N\le 10^5$，字符串长度之和 $\le 10^5$，$0\le A_k^i\le 10^9$

题解

对着 N 个串建立 AC自动机。一个节点的 $popularity(S_{j,k}^i),|S_{j,k}^i|$ 值是固定的。
在 fail 树上，一个节点的所有父亲节点的都会对当前匹配的字符串产生贡献，所以沿着 fail 树，预处理每一个节点到根的 $popularity(S_{j,k}^i)\times |S_{j,k}^i|$ 的最大值。
这样把这 $N$ 个串分别在 AC 自动机上匹配一遍，顺便统计答案即可。

代码

#include 

#define mem(f, v) memset(f,v,sizeof(f))
#define file(x) freopen(x".in","r",stdin);freopen(x".out","w",stdout);

typedef long long ll;
const int maxn = 100010;
const int inf = ~(1u << 31u);
const ll linf = ~(1llu << 63u);

using namespace std;

vector<vector<int>> va;
vector<string> s;

struct ACAM_node {
    ll val;
    int num, dep;
    vector<ACAM_node *> ch;
    ACAM_node *fail;

    ACAM_node(int chSZ = 26) : num(0), val(0), fail(nullptr) {
        ch.resize(chSZ, nullptr);
    }
} po[maxn];

ACAM_node *get(int idx) {
    po[idx].val = po[idx].num = po[idx].dep = 0;
    po[idx].ch.clear(), po[idx].fail = nullptr;
    po[idx].ch.resize(26, nullptr);
    return po + idx;
}

struct ACAM {
    ACAM_node *root;
    int cnt;

    ACAM() : cnt(0) {
        root = get(cnt++);
    }

    void add(const string &str) {
        ACAM_node *now = root;
        for (auto c:str) {
            int idx = c - 'a';
            if (now->ch[idx] == nullptr) now->ch[idx] = get(cnt++);
            now->ch[idx]->num++;
            now = now->ch[idx];
        }
    }

    void build() {
        queue<ACAM_node *> q;
        root->fail = nullptr;
        for (auto &x: root->ch)
            if (x) {
                x->fail = root;
                x->dep = 1;
                x->val = (ll)x->dep * x->num;
                q.push(x);
            }else x = root;
        while (!q.empty()) {
            auto u = q.front();
            q.pop();
            for (int i = 0; i < u->ch.size(); i++) {
                auto &x = u->ch[i];
                if (x) {
                    x->fail = u->fail->ch[i];
                    x->dep = u->dep + 1;
                    x->val = max(x->fail->val, (ll) x->dep * x->num);
                    q.push(x);
                } else x = u->fail->ch[i];
            }
        }
    }

    ll query(const string &str, int index) {
        ACAM_node *now = root;
        ll mx = 0;
        for (int i = 0; i < str.length(); i++) {
            int idx = str[i] - 'a';
            now = now->ch[idx];
            mx = max(mx, now->val * va[index][i]);
        }
        return mx;
    }
};

int main() {
    ios::sync_with_stdio(false);
    freopen("exciting.in", "r", stdin);
    int T;
    cin >> T;
    while (T--) {
        s.clear(), va.clear();
        int n;
        cin >> n;
        for (int i = 0; i < n; i++) {
            string str;
            cin >> str;
            s.emplace_back(str);
        }
        for (int i = 0; i < n; i++) {
            vector<int> d;
            for (int j = 0, x; j < s[i].length(); j++) {
                cin >> x;
                d.emplace_back(x);
            }
            va.emplace_back(d);
        }
        ACAM acam;
        for (auto &x:s) acam.add(x);
        acam.build();
        ll res = 0;
        for (int i = 0; i < n; i++)
            res = max(res, acam.query(s[i], i));
        cout << res << "\n";
    }
    return 0;
}