bzoj 3473 字符串

题目传送门

　　传送门

题目大意

　　给定n个字符串，询问每个字符串有多少子串（不包括空串）是所有n个字符串中至少k个字符串的子串

　　先用奇怪的字符把所有字符串连接起来。

　　建后缀树，数每个节点的子树内包含多少属于不同串的后缀。

　　数这个东西，可以将每个串的后缀（被奇怪的字符分割开的地方认为它属于不同后缀）按dfs序排序，然后简单容斥就能统计出来。

　　对于每个后缀，有贡献的是一个前缀，然后直接统计就行了。

Code

/**
 * bzoj
 * Problem#3473
 * Accepted
 * Time: 788ms
 * Memory: 41208k
 */
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
using namespace std;
typedef bool boolean;

template <typename T>
void pfill(T* pst, const T* ped, T val) {
    for ( ; pst != ped; *(pst++) = val);
}

const int N = 2e5 + 5;
const int bzmax = 19;

typedef class SparseTable {
    public:
        int n;
        int *ar;
        int log2[N];
        int f[N][bzmax];

        SparseTable() {    }
        
        void init(int n, int* ar) {
            this->n = n;
            this->ar = ar;
            log2[1] = 0;
            for (int i = 2; i <= n; i++)
                log2[i] = log2[i >> 1] + 1;
            for (int i = 0; i < n; i++)
                f[i][0] = ar[i];
            for (int j = 1; j < bzmax; j++)
                for (int i = 0; i + (1 << j) - 1 < n; i++)
                    f[i][j] = min(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
        }

        int query(int l, int r) {
            int d = log2[r - l + 1];
//            int rt = min(f[l][d], f[r - (1 << d) + 1][d]);
//            cerr << l << " " << r << " " << rt << '
';
            return min(f[l][d], f[r - (1 << d) + 1][d]);
        }
}SparseTable;

typedef class Pair3 {
    public:
        int x, y, id;

        Pair3() {    }
        Pair3(int x, int y, int id):x(x), y(y), id(id) {    }
}Pair3;

typedef class SuffixArray {
    protected: 
        Pair3 T1[N], T2[N];
        int cnt[N];

    public:
        int n;
        char *str;
        int sa[N], rk[N], hei[N];
        SparseTable st;

        void set(int n, char* str) {
            this->n = n;
            this->str = str;
            memset(sa, 0, sizeof(sa));
            memset(rk, 0, sizeof(rk));
            memset(hei, 0, sizeof(hei));
        }

        void radix_sort(Pair3* x, Pair3* y) {
            int m = max(n, 256);
            memset(cnt, 0, sizeof(int) * m);
            for (int i = 0; i < n; i++)
                cnt[x[i].y]++;
            for (int i = 1; i < m; i++)
                cnt[i] += cnt[i - 1];
            for (int i = 0; i < n; i++)
                y[--cnt[x[i].y]] = x[i];

            memset(cnt, 0, sizeof(int) * m);
            for (int i = 0; i < n; i++)
                cnt[y[i].x]++;
            for (int i = 1; i < m; i++)
                cnt[i] += cnt[i - 1];
            for (int i = n - 1; ~i; i--)
                x[--cnt[y[i].x]] = y[i];
        }

        void build() {
            for (int i = 0; i < n; i++)
                rk[i] = str[i];
            for (int k = 1; k <= n; k <<= 1) {
                for (int i = 0; i + k < n; i++)
                    T1[i] = Pair3(rk[i], rk[i + k], i);
                for (int i = n - k; i < n; i++)
                    T1[i] = Pair3(rk[i], 0, i);
                radix_sort(T1, T2);
                int diff = 1;
                rk[T1[0].id] = 1;
                for (int i = 1; i < n; i++)
                    rk[T1[i].id] = (T1[i].x == T1[i - 1].x && T1[i].y == T1[i - 1].y) ? (diff) : (++diff);
                if (diff == n)
                    break;
            }
            for (int i = 0; i < n; i++)
                sa[--rk[i]] = i;
        }

        void get_height() {
            for (int i = 0, j, k = 0; i < n; i++, (k) ? (k--) : (0)) {
                if (rk[i]) {
                    j = sa[rk[i] - 1];
                    while (i + k < n && j + k < n && str[i + k] == str[j + k])    k++;
                    hei[rk[i]] = k;
                }
            }        
        }

        void init_st() {
            st.init(n, hei);
        }

        int lcp(int x1, int x2) {
            if (x1 == x2)
                return n - x1 + 1;
            x1 = rk[x1], x2 = rk[x2];
            if (x1 > x2)
                swap(x1, x2);
            return st.query(x1 + 1, x2);
        }
        
        int compare(int l1, int r1, int l2, int r2) {
            int len_lcp = lcp(l1, l2);
            int len1 = r1 - l1 + 1, len2= r2 - l2 + 1;
            if (len_lcp >= len1 && len_lcp >= len2)
                return 0;
            if (len_lcp < len1 && len_lcp < len2)
                return (str[l1 + len_lcp] < str[l2 + len_lcp]) ? (-1) : (1);
            return (len_lcp >= len1) ? (-1) : (1);
        }

        int query(int u, int v) {    // u, v -> sa
            if (u == v)
                return n - sa[u];
            return st.query(u + 1, v);
        }

        const int& operator [] (int p) {
            return sa[p];
        }

        const int& operator () (int p) {
            return hei[p];
        }
} SuffixArray;

typedef class IndexedTree {
    public:
        int s;
        int *a;

        IndexedTree() {    }
        IndexedTree(int n) : s(n) {
            a = new int[(s + 1)];
            pfill(a + 1, a + n + 1, 0);            
        }
        ~IndexedTree() {
            delete[] a;
        }

        void add(int idx, int val) {
            for ( ; idx <= s; idx += (idx & (-idx)))
                a[idx] += val;
        }

        int query(int idx) {
            int rt = 0;
            for ( ; idx; idx -= (idx & (-idx)))
                rt += a[idx];
            return rt;
        }

        int query(int l, int r) {
            return query(r) - query(l - 1);
        }
} IndexedTree;

typedef class Graph {
    protected:
        int dfs_clock;
    public:
        vector<int>* g;
        int *fa;
        int *in, *out;
        int *sz, *zson;
        int *dep, *top;

        Graph() {    }
        Graph(vector<int>* g, int n) : dfs_clock(0), g(g) {
            fa = new int[(n + 1)];
            in = new int[(n + 1)];
            out = new int[(n + 1)];
            sz = new int[(n + 1)];
            zson = new int[(n + 1)];
            dep = new int[(n + 1)];
            top = new int[(n + 1)];
            dfs1(1, 0);
            dfs2(1, true);
        }
        ~Graph() {
#define rem(__) delete[] __;        
            rem(fa) rem(in) rem(out) rem(sz) rem(zson) rem(dep) rem(top)
        }

        void dfs1(int p, int fa) {
            dep[p] = ((fa) ? (dep[fa] + 1) : (1));
            in[p] = ++dfs_clock;
            this->fa[p] = fa;
            sz[p] = 1;
            int mx = -1, id = -1, e;
            for (unsigned i = 0; i < g[p].size(); i++) {
                e = g[p][i];
                dfs1(e, p);
                sz[p] += sz[e];
                if (sz[e] > mx)
                    mx = sz[e], id = e;
            }
            out[p] = dfs_clock;
            zson[p] = id;
        }

        void dfs2(int p, boolean ontop) {
            top[p] = ((ontop) ? (p) : (top[fa[p]]));
            if (~zson[p])
                dfs2(zson[p], false);
            for (int i = 0, e; i < (signed) g[p].size(); i++) {
                e = g[p][i];
                if (e == zson[p])
                    continue;
                dfs2(e, true);
            }
        }

        int lca(int u, int v) {
            while (top[u] ^ top[v]) {
                if (dep[top[u]] < dep[top[v]])
                    swap(u, v);
                u = fa[top[u]];
            }
            return (dep[u] < dep[v]) ? (u) : (v);
        }
} Graph;

#define pii pair<int, int>

int n, L, K;
int id[N];
char str[N];
SuffixArray sa;
int endp[N >> 1];
char _str[N >> 1];
vector<int> endpos[N >> 1];

inline void init() {
    L = 0;
    scanf("%d%d", &n, &K);
    for (int i = 1; i <= n; i++) {
        scanf("%s", _str);
        if (i > 1) {
            id[L] = -1;
            str[L] = '#'; //"!@#$%^&*()-+"[i % 11];
            L += 1;
        }
        for (char* p = _str; *p; p++) {
            id[L] = i;
            str[L] = *p;
            L++;
        }
        endp[i] = L; 
    }
    sa.set(L, str);
    sa.build();
    sa.get_height();
    sa.init_st();
}

int cnt_node;
vector<int> g[N << 1];
int d[N << 1];

int build_suffix_tree(int l, int r) {
    int curid = ++cnt_node;
    d[curid] = sa.query(l, r);
    if (l == r) {
        int p = sa[l];
        if (id[p] > 0)
            endpos[id[p]].push_back(curid);
        return curid;
    }
    for (int p = l, j, L, R, mid; p <= r; p = j + 1) {
        L = p, R = r;
        char x = str[sa[p] + d[curid]];
        while (L <= R) {
            mid = (L + R) >> 1;
            if (str[sa[mid] + d[curid]] == x)
                L = mid + 1;
            else
                R = mid - 1;
        }
        j = L - 1;
        L = build_suffix_tree(p, j);
        g[curid].push_back(L);
    }
    return curid;
}

int res[N << 1];
void dfs(int p, Graph& G, IndexedTree& it) {
    res[p] = (it.query(G.in[p], G.out[p]) >= K) ? (d[p]) : (res[G.fa[p]]);
    for (int i = 0; i < (signed) g[p].size(); i++) {
         dfs(g[p][i], G, it);        
    }
}

inline void solve() {
    while (cnt_node)
        g[cnt_node--].clear();
    build_suffix_tree(0, L - 1);

    IndexedTree it (cnt_node);
    Graph graph (g, cnt_node);
    for (int i = 1; i <= n; i++) {
        it.add(graph.in[endpos[i][0]], 1);        
        for (int j = 1; j < (signed) endpos[i].size(); j++) {
            it.add(graph.in[endpos[i][j]], 1);
            int g = graph.lca(endpos[i][j], endpos[i][j - 1]);
            it.add(graph.in[g], -1);
        }
    }
    
    dfs(1, graph, it);
    for (int i = 1, p, l; i <= n; i++) {
        long long ans = 0;
        for (int j = 0; j < (signed) endpos[i].size(); j++) {
            p = endpos[i][j], l = d[p];
            ans += min(endp[i] - (L - l), res[p]);        
        }
        printf("%lld ", ans);
    }
}

int main() {
    init();
    solve();
    return 0;
}