「NOI2018」你的名字

最新推荐文章于 2022-03-02 12:41:12 发布
最新推荐文章于 2022-03-02 12:41:12 发布
阅读量145 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/mangoyang/p/9334402.html
版权


「NOI2018」你的名字

题目描述

小A 被选为了\(ION2018\) 的出题人，他精心准备了一道质量十分高的题目，且已经 把除了题目命名以外的工作都做好了。

由于\(ION\) 已经举办了很多届，所以在题目命名上也是有规定的，\(ION\) 命题手册规 定：每年由命题委员会规定一个小写字母字符串，我们称之为那一年的命名串，要求每道题的名字必须是那一年的命名串的一个非空连续子串，且不能和前一年的任何一道题目的名字相同。

由于一些特殊的原因，小A 不知道\(ION2017\) 每道题的名字，但是他通过一些特殊 手段得到了\(ION2017\) 的命名串，现在小A 有\(Q\) 次询问：每次给定\(ION2017\) 的命名串和\(ION2018\) 的命名串，求有几种题目的命名，使得这个名字一定满足命题委员会的规定，即是\(ION2018\) 的命名串的一个非空连续子串且一定不会和\(ION2017\) 的任何一道题目的名字相同。

由于一些特殊原因，所有询问给出的\(ION2017\) 的命名串都是某个串的连续子串， 详细可见输入格式。

输入格式：

第一行一个字符串\(S\) ，之后询问给出的\(ION2017\) 的命名串都是\(S\) 的连续子串。 第二行一个正整数\(Q\)，表示询问次数。 接下来\(Q\) 行，每行有一个字符串\(T\) 和两个正整数\(l,r\)，表示询问如果\(ION2017\) 的 命名串是\(S[l..r]\)，\(ION2018\) 的命名串是\(T\) 的话，有几种命名方式一定满足规定。

输出格式：

输出\(Q\)行，第\(i\) 行一个非负整数表示第\(i\) 个询问的答案。

先放一个乱搞一个做法（后面补了正解） :

首先考虑 \(l = 1, r = |S|\) 的部分分，我在同步赛上的乱搞做法是对 \(S\) 建 \(Sam\) ，每次询问往 \(Sam\) 里面插入询问串

取出新增的后缀节点，暴力在 \(parent\) 树上跳父亲，计算在 \(S\) 中出现的不同子串个数，以及总共的不同子串个数，相减就是答案

因为相同的子串只会被算一次，所以每一个节点的贡献只会被算一次，单次复杂度是向上跳的期望节点数，根据 \(Sam\) 的一些奇奇怪怪的性质，复杂度上限是\(O(n\sqrt{n})\) ，但是在实际情况下根本卡不满，这 \(68pt\) 中最慢的点是 \(0.8s\)

讨论有了 \(l, r\) 的限制的情况，在原先的算法基础上还需要求出每个节点在限制下能表示的最长的公共子串长度为 \(maxlen\)

设 \(r\) 在该节点 \(right\) 集合中的前驱是 \(r'\) ，那么 \(mxlen = r' - l + 1\) ，通过这个重新计算公共子串个数即可

考虑求出这个东西只需要在 \(Sam\) 上大力线段树合并即可，但是无论多么不满乘上 \(log\) 都会 \(Tle\)

考虑进行剪枝，对每一个节点维护 \(mx_u\) 和 \(mn_u\) 表示其 \(right\) 集合中在 \(S\) 串中出现的最靠前和最靠后的位置

如果有 \(r < mn_u\) 或者 \(l > mx_u\) 这个节点就不会有贡献，可以剪掉

观察发现，大部分情况下 \(mxlen > dep_u\) ，此时求前驱没有任何用处，本质上是因为 \(mx_u > r\) 的缘故

所以在此可以再加上一个剪枝，这样线段树的查询只会在很深的几个节点被调用了.

测一下最大的数据惊奇的发现只需要\(2.5s\) ，交上去发现用了一个 \(O(n\sqrt{n}logn)\)的乱搞水过了此题，（震惊！）



/*pragram by mangoyang*/
#include<bits/stdc++.h>
#define inf (0x7f7f7f7f)
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
typedef long long ll;
using namespace std;
template <class T>
inline void read(T &x){
    int f = 0, ch = 0; x = 0;
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = 1;
    for(; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    if(f) x = -x;
}
const int N = 3500005, MAXN = 1500005;
char s[N]; int rt[N], buf[N], n;
struct SegmentTree{
    int lc[MAXN*25], rc[MAXN*25], sz[MAXN*25], size;
    inline SegmentTree(){ size = 1; }
    inline void ins(int &u, int l, int r, int pos){
        if(!u) u = ++size;
        if(l == r) return (void) (sz[u]++);
        int mid = l + r >> 1; 
        if(pos <= mid) ins(lc[u], l, mid, pos);
        else ins(rc[u], mid + 1, r, pos); 
        sz[u] = sz[lc[u]] + sz[rc[u]];
    }
    inline int merge(int x, int y, int l, int r){
        if(!x || !y) return x + y;
        int mid = l + r >> 1, o = ++size;
        if(l == r) sz[o] = sz[x] + sz[y];
        else{
            lc[o] = merge(lc[x], lc[y], l, mid);
            rc[o] = merge(rc[x], rc[y], mid + 1, r);
            sz[o] = sz[lc[o]] + sz[rc[o]];
        }
        return o;
    }
    inline int query(int u, int l, int r, int pos){
        if(!sz[u]) return 0;
        if(l == r) return l;
        int mid = l + r >> 1;
        if(pos <= mid) return query(lc[u], l, mid, pos);
        int rans = query(rc[u], mid + 1, r, pos);
        return rans ? rans : query(lc[u], l, mid, pos);
    }
}Seg;
struct SuffixAutomaton{
    vector<int> g[N], v; ll dep[N];
    int ch[N][26], fa[N], vis[N], mx[N], mn[N], tail, size;
    inline SuffixAutomaton(){ size = tail = 1, rt[1] = 1; }
    inline int newnode(int x){ return dep[++size] = x, size; }
    inline void ins(int c, int ff, int pos){
        int p = tail, np = newnode(dep[p] + 1);
        if(ff) v.push_back(np); else{
            Seg.ins(rt[np], 1, n, pos);
            mx[np] = mn[np] = pos;
        }
        for(; p && !ch[p][c]; p = fa[p]) ch[p][c] = np;
        if(!p) return (void) (fa[np] = 1, tail = np);
        int q = ch[p][c];
        if(dep[q] == dep[p] + 1) fa[np] = q;
        else{
            int nq = newnode(dep[p] + 1);
            fa[nq] = fa[q], fa[np] = fa[q] = nq;
            if(ff) rt[nq] = rt[q], mx[nq] = mx[q], mn[nq] = mn[q];
            for(int i = 0; i < 26; i++) ch[nq][i] = ch[q][i];
            for(; p && ch[p][c] == q; p = fa[p]) ch[p][c] = nq; 
        }tail = np;
    }
    inline void addedge(){
        for(int i = 2; i <= size; i++) g[fa[i]].push_back(i);
    }
    inline void dfs(int u){
        for(int i = 0; i < g[u].size(); i++){
            int v = g[u][i];
            dfs(v), rt[u] = Seg.merge(rt[u], rt[v], 1, n);  
            mx[u] = Max(mx[u], mx[v]), mn[u] = Min(mn[u], mn[v]);
        }
    }
    inline void prepare(char *s){
        for(int i = 0; i < n; i++) ins(s[i] - 'a', 0, i + 1);
        addedge(), dfs(1);
    }   
    inline ll calc(char *s, int l, int r){
        tail = 1; v.clear(); 
        ll len = strlen(s), ans = 0, all = 0;
        for(int i = 0; i < len; i++) ins(s[i] - 'a', 1, 0);
        for(int i = 0; i < v.size(); i++){
            int u = v[i];
            for(int p = u; p > 1; p = fa[p]) {
                if(vis[p]) break; int OK = 0;
                all += dep[p] - dep[fa[p]], vis[p] = 1;
                if(rt[p]){
                    if((l == 1 && r == n) || OK)
                        { ans += dep[p] - dep[fa[p]]; continue; }
                    if(mx[p] < l || mn[p] > r) continue;
                    int mxlen = mx[p] <= r ? mx[p] - l + 1 : Seg.query(rt[p], 1, n, r) - l + 1;
                    if(mxlen > dep[fa[p]]) 
                        ans += Min(dep[p], mxlen) - dep[fa[p]];
                    if(mxlen >= dep[p]) OK = 1;
                }
            }
        }
        for(int i = 0; i < v.size(); i++){
            int u = v[i];
            for(int p = u; p > 1; p = fa[p]){
                if(!vis[p]) break; vis[p] = 0;
            }
        }
        return all - ans;
    }   
}van;
int main(){
    scanf("%s", s); n = strlen(s);
    int Q; read(Q), van.prepare(s);
    while(Q--){
        int l, r;
        scanf("%s", s), read(l), read(r);
        printf("%lld\n", van.calc(s, l, r));
    }
}


正解

补集转换一步，问题变成求 \(T\) 与 \(S[l_i:r_i]\) 的本质不同的公共子串数，考虑让 \(T\) 在 \(S\) 的 \(sam\) 上匹配，双指针找出每一个前缀能在 \(S[l_i:r_i]\) 中能匹配上的后缀长度 \(len[i]\)，然后在 \(T\) 的 \(sam\) 上统计答案，对于每一个节点随便找一个出现的前缀，拿这个前缀的 \([0,len[i]]\) 和其所能表示的字符串长度区间取交集即可。

求 \(len[i]\) 可以先找到第一个能接收当前字符 \(c\) 的节点，然后不断删去首字母，直到能在 \([l_i:r_i]\) 放下，也就是找到当前匹配节点的 \(right\) 集合，判断一段区间内是否有元素，这个用随便维护一下就好了，线段树合并蛮好写的。

/*program by mangoyang*/
#include <bits/stdc++.h>
#define inf (0x7f7f7f7f)
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
typedef long long ll;
using namespace std;
template <class T>
inline void read(T &x){
    int ch = 0, f = 0; x = 0;
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = 1;
    for(; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    if(f) x = -x;
}
const int N = 2000005;
char s[N];
int res[N], n, q;
namespace Seg{
    #define mid ((l + r) >> 1)
    int lc[N*25], rc[N*25], sz[N*25], size;
    inline void ins(int &u, int l, int r, int pos){
        if(!u) u = ++size;
        if(l == r) return (void) (sz[u]++);
        if(pos <= mid) ins(lc[u], l, mid, pos);
        else ins(rc[u], mid + 1, r, pos); 
        sz[u] = sz[lc[u]] + sz[rc[u]];
    }
    inline int merge(int x, int y, int l, int r){
        if(!x || !y) return x + y;
        int o = ++size;
        if(l == r) sz[o] = sz[x] + sz[y];
        else{
            lc[o] = merge(lc[x], lc[y], l, mid);
            rc[o] = merge(rc[x], rc[y], mid + 1, r);
            sz[o] = sz[lc[o]] + sz[rc[o]];
        }
        return o;
    }
    inline int query(int u, int l, int r, int L, int R){
        if(l >= L && r <= R) return sz[u];
        int res = 0;
        if(L <= mid) res += query(lc[u], l, mid, L, R);
        if(mid < R) res += query(rc[u], mid + 1, r, L, R);
        return res;
    }
    #undef mid
}
vector<int> vec[N];
namespace SAM1{
    vector<int> g[N];
    int ch[N][26], rt[N], fa[N], len[N], size = 1, tail = 1;
    inline int newnode(int x){ return len[++size] = x, size; }
    inline void ins(int c, int x){
        int p = tail, np = newnode(len[p] + 1);
        Seg::ins(rt[np], 1, n, x);
        for(; p && !ch[p][c]; p = fa[p]) ch[p][c] = np;
        if(!p) return (void) (fa[np] = 1, tail = np);
        int q = ch[p][c];
        if(len[q] == len[p] + 1) fa[np] = q;
        else{
            int nq = newnode(len[p] + 1);           
            fa[nq] = fa[q], fa[q] = fa[np] = nq;
            for(int i = 0; i < 26; i++) ch[nq][i] = ch[q][i];
            for(; p && ch[p][c] == q; p = fa[p]) ch[p][c] = nq;
        }tail = np;
    }
    inline void addedge(){
        for(int i = 2; i <= size; i++) g[fa[i]].push_back(i);
    }
    inline void dfs(int u){
        for(int i = 0; i < (int) g[u].size(); i++)
            dfs(g[u][i]), rt[u] = Seg::merge(rt[u], rt[g[u][i]], 1, n);
    }
    inline void solve(char *s, int L, int R){
        int lenth = strlen(s + 1);
        for(int i = 1, p = 1, now = 0; i <= lenth; i++){
            int c = s[i] - 'a';
            while(!ch[p][c] && p) p = fa[p], now = len[p];
            if(!p){ p = 1, now = 0; continue; };
            p = ch[p][c], now++;
            while(p > 1){
                if(Seg::query(rt[p], 1, n, L + now - 1, R)) break;
                if(--now == len[fa[p]]) p = fa[p];
            }
            if(p == 1) continue;
            for(int j = 0; j < (int) vec[i].size(); j++)
                res[vec[i][j]] = max(res[vec[i][j]], now);
        }
    }
}
namespace SAM2{
    int fa[N], len[N], ch[N][26], size, tail;
    inline void Clear(){
        for(int i = 1; i <= size; i++){
            fa[i] = len[i] = res[i] = 0;
            memset(ch[i], 0, sizeof(ch[i]));
        }
        size = tail = 1;
    }
    inline int newnode(int x){ return len[++size] = x, size; }
    inline void ins(int c, int x){
        int p = tail, np = newnode(len[p] + 1);
        vec[x].push_back(np);
        for(; p && !ch[p][c]; p = fa[p]) ch[p][c] = np;
        if(!p) return (void) (fa[np] = 1, tail = np);
        int q = ch[p][c];
        if(len[q] == len[p] + 1) fa[np] = q;
        else{
            int nq = newnode(len[p] + 1);           
            vec[x].push_back(nq);
            fa[nq] = fa[q], fa[q] = fa[np] = nq;
            for(int i = 0; i < 26; i++) ch[nq][i] = ch[q][i];
            for(; p && ch[p][c] == q; p = fa[p]) ch[p][c] = nq;
        }tail = np;
    }
    inline ll solve(){
        ll ans1 = 0, ans2 = 0;
        for(int i = 1; i <= size; i++){
            if(res[i] > len[fa[i]])
                ans2 += 1ll * min(res[i], len[i]) - len[fa[i]];
            ans1 += 1ll * len[i] - len[fa[i]];
        }
        return ans1 - ans2;
    }
}
int main(){
    scanf("%s", s + 1), n = strlen(s + 1);
    for(int i = 1; i <= n; i++) SAM1::ins(s[i] - 'a', i);
    SAM1::addedge(), SAM1::dfs(1);
    read(q); int L, R;
    while(q--){
        scanf("%s", s + 1); int m = strlen(s + 1);
        read(L), read(R);
        for(int i = 1; i <= m; i++) vec[i].clear();
        SAM2::Clear();
        for(int i = 1; i <= m; i++) SAM2::ins(s[i] - 'a', i);
        SAM1::solve(s, L, R);
        printf("%lld\n", SAM2::solve());
    }
    return 0;
}

转载于:https://www.cnblogs.com/mangoyang/p/9334402.html

weixin_30689307
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
NOI2018全国第一试.pdf
07-31
NOI 2018全国信息学奥林匹克竞赛开赛第一天试题
NOI2018day2后面两个题的题解pdf
07-22
《NOI2018day2后面两个题的题解pdf》是一份针对全国青少年信息学奥林匹克竞赛（NOI）2018年第二天比赛的深度解析文档，由出题人亲自讲解，旨在帮助参赛者理解和掌握比赛中的关键知识点。这份资源包含两个部分：...
[NOI2018]你的名字
weixin_33889665的博客
01-18 84
SAM写的太不熟练了~~SAM上的线段树合并也不熟练~~~ 调了半天样例 题目大意： 给定一个S，Q次询问，每次给出T，l,r, 求对于S[l,r]，属于T的子串却不属于S[l,r]的子串有多少个 看上去挺简洁的一个问题。。。 暴力68pts 对于S[1,n]68pts？ 如果做过 [HEOI2015]最短不公共子串 就好做多了！ 可以对A，B分别建SAM 拓扑排序找到A...
【NOI2018】你的名字（后缀自动机，线段树合并）
ez_lcw的博客
03-02 357
题意： 给定一个字符串 SSS，qqq 次询问 T,l,rT,l,rT,l,r，求 TTT 和 S[l,r]S[l,r]S[l,r] 的本质不同公共子串数目。 ∣S∣≤5×105|S|\leq 5\times 10^5∣S∣≤5×105，q≤105q\leq 10^5q≤105，∑∣T∣≤106\sum |T|\leq 10^6∑∣T∣≤106。 题解： 首先看一个弱化版的问题：给出两个串 S,TS,TS,T，求 S,TS,TS,T 的本质不同公共子串数目。 由于要求本质不同，所以思路是建出 TTT 的后缀
「NOI2018」你的名字——后缀自动机
ylsoi的博客
02-20 353
题目大意： 给定一个母串和若干个询问串，求每个询问串有多少个本质不同的子串没有在母串中出现过。 思路： ION2017的串我们称为S串，ION2018的串我们称为T串。 先考虑68pts怎么去做。 考虑T串有多少个子串未在S串中出现过，于是将S建立SAM，然后将T丢进S的SAM里跑子串匹配，这样我们可以得到T的每一个结束位置的最大匹配长度，所有长度大于这个长度的子串都是符合要求的子串。 上述方法对...
【LuoguP4770】[NOI2018] 你的名字
Yu Gi Oh!
04-03 249
题目链接 题意简述 给定一个串 SSS 多组询问 , 每次给定一个串 TTT 和一个 区间 [l,r][l,r][l,r] 求串TTT 有多少个本质不同的子串 满足不是 S[l...r]S[l...r]S[l...r] 的子串 Sol 首先显然要么 SAMSAMSAM 要么 SASASA。 这种带区间还要求本质不同的的一般用 SAMSAMSAM 好做些吧。 先考虑每次询问的区间就是整个串我们怎么做...
NOI2018全国第二试.pdf
07-31
NOI 2018全国信息学奥林匹克竞赛开赛第二天试题
NOI2018笔试题库
08-08
绝对正版的noi2018笔试题库，适合参加noi的dalao们复习用11111111111111111111
NOI2018冬令营报名通知
02-27
NOI2018冬令营报名通知。在2018年举行的清华和北大冬令营的集训通知。
【NOI2018】你的名字
Cold_Chair的博客
03-04 949
题目大意： 一开始给出字符串S。 Q次询问，每次给出l,r和字符串T。 问T有多少不同子串不是S[l…r]的子串。 ∑∣T∣&amp;lt;=1e6,∣S∣,∣T∣&amp;lt;=5e5\sum|T|&amp;lt;=1e6,|S|,|T|&amp;lt;=5e5∑∣T∣&lt;=1e6,∣S∣,∣T∣&lt;=5e5 题解： 不同子串一类问题优先考虑SAM。 感觉这题考的更多是对SAM的理解。...
[NOI2018] 你的名字
dieyi9889的博客
04-12 176
[NOI2018] 你的名字 该来的总归还是会来的…… 题意： 题目传送门 一句话题意：给出一个字符串\(T\)，\(Q\)组询问，每次询问字符串\(S\)中有多少个本质不同的子串在\(T[l..r]\)中没有出现。（我们用\(T[l..r]\)表示截取\(T\)中\([l, r]\)区间内的字符得到的字符串） 题解： 真的是对\(SAM\)的科技一无所知…… 首先，做出这道题需要对\(...
[NOI2018]你的名字(68pts)
weixin_30430169的博客
12-23 77
SAM真让人头秃。 题面 https://www.luogu.org/problemnew/show/P4770 首先考虑 l=1,r=∣S∣的做法 如果对于ION2018的子串不用判重的话,对ION2017建SAM跑一遍就好了. 此时ION2018的每一个前缀对答案的贡献为前缀长度-匹配长度。 考虑怎么去重。 这应该算是SAM比较常用去重的一种套路。 对ION2018建出SAM。 原本就算答案的...
[UOJ#395][NOI2018]你的名字
时光真疯狂, 我一路执迷于匆忙.
10-24 795
Description 给出字符串S，每次询问字符串T有多少本质不同的子串不是S[l…r]的子串 |S|,|T|&lt;=10^5 Solution 我太菜了考场68分都写挂了_ (:з」∠) _ 其实这道题并没有看上去那么难 预处理出lim[i]表示T的前缀i的最长后缀，满足T[i-lim[i]+1,i]是S的子串 考虑询问是1~n的情况，我们只需要在S的SAM上跑就可以得出这个东西 如果询问是...
[LOJ2720] 「NOI2018」你的名字（后缀自动机+线段树合并）
lunch__的博客
03-05 524
题意 给你一个字符串S\rm SS，q\rm qq次询问一个区间[l,r]\rm[l,r][l,r]，与一个字符串T\rm TT，求T\rm TT有多少个本质不同的子串没在S[l,r]\rm S[l,r]S[l,r]中出现过。 首先求的东西可以转化成T\rm TT中本质不同的子串减去S[l,r]\rm S[l,r]S[l,r]与T\rm TT的本质不同的公共子串数，T\rm TT中本质不同的子...
[NOI2018]你的名字 题解
weixin_42465242的博客
08-14 459
题目链接 先考虑68分的做法： 求在A串中出现，且在B串中没出现的串的数量。 使用容斥，用A的不同子串数减去A，B的不同公共子串数。 先用双指针，求出A的每个位置开始，在B中最多能向后匹配多远。 然后，问题变为，给你一些区间，问它们的子区间中有多少不同的串。 因为每个串，都是原区间\([l,r]\)中\([l,i]\)的后缀。\((l<=i<=r)\) 而后缀就是在前面去掉一...
NOI2018 你的名字
qq_29361257的博客
02-15 338
题解 首先转化题意，未出现过的子串个数=总的本质不同的子串个数-出现过的子串个数，前面随便维护一下，重点求后面： 优先考虑 68pts68pts68pts，如何求 TTT 中在 SSS 中出现过的本质不同的子串个数呢？ 一个常见套路：对于每一个 TTT 的前缀 T1…iT_{1 \dots i}T1…i​，求其前缀在 SSS 中出现过的本质不同的子串的个数。 先把 SSS 的 samsamsam 建出来，然后把 TTT 中新加入的字符放进 SSS 的 samsamsam 中匹配，若当前状态有向该字符的转移，
noi wc2018 资源
最新发布
12-31
noi wc2018 是全国青少年信息学奥林匹克联赛的一项国际比赛，是全球青少年程序员的高水平对抗赛事。首先，作为一个国际赛事，noi wc2018 提供了一个国际化的交流平台，可以让参赛选手之间，不同国家之间进行技术、文化的交流和碰撞。其次，noi wc2018 也为年轻的程序员提供了一个成长和施展才华的机会，可以通过比赛的形式来检验自己的实力，并与其他国家的优秀选手一较高下。再者，noi wc2018 也为全国青少年信息学奥林匹克联赛提供了一个更高的竞技平台，可以对本国的选手选材和技术水平进行更高标准的考核。最后，noi wc2018 的资源也可以用来推动国内青少年信息学水平的提高，可以激励更多的年轻人投身到信息学领域，从而推动本国信息产业的发展。因此，noi wc2018 的资源对于国际交流、选手成长、国内推动都有着重要的意义。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值