LOJ 2720 & UOJ 395 & BZOJ 5417 「NOI2018」你的名字 后缀自动机 线段树合并

最新推荐文章于 2019-09-14 22:55:00 发布
最新推荐文章于 2019-09-14 22:55:00 发布
阅读量103 收藏
点赞数
原文链接：http://www.cnblogs.com/CMXRYNP/p/9736025.html
版权

LOJ #2720 UOJ #395 BZOJ 5417

题意

给出字符串S，有Q次询问，每次给出字符串T和整数\(l,r\)满足\(1\le l\le r\le|S|\)

求T有多少个本质不同的(连续)子串满足不是\(S[l..r]\)的(连续)子串

只含小写字母

68%：没有l,r的限制

同步赛时这都不会

对S建SAM，对每个T建SAM

对于SAM上一个节点u，令\(len_u\)表示这个节点能表示的最长的字符串，\(fa_u\)表示u在parent树上的父亲/fail指针，\(g_u\)表示节点u的right集合中的任意一个位置。令\(d_i\)表示\(T[1..i]\)的极长的在S中出现的后缀的长度。

T含有的本质不同的子串数是\(\sum len_u-len_{fa_u}\)，但是由于不能在S中出现，通过观察可以知道所求即为\(\sum max(0,len_u-max(len_{fa_u},d_{g_u}))\)。因为节点u能表示的字符串长度要大于\(len_{fa_u}\)，而且这些字符串是后缀关系，有且仅有长度\(\le d_{g_u}\)的串在S中出现。

\(d\)可以由把T放到S的SAM上跑一下得到，具体是没有转移就跳fail直到有转移，同时维护匹配长度，即\(d\)。

之后枚举T的SAM上的点就可以计算了

时间复杂度\(O(\sum|T|+|S|)\)，代码在下方

100%

现在有了一个区间的限制，这只会影响\(d\)的求解

有转移不能直接走，而需要判断转移后的节点是否可以在[l..r]内完整表示新匹配串

这里需要每次将匹配长度-1，而不是每次跳一下fail（我没这么写过）

设当前匹配长度为k，问题可以转化为判断转移后的节点的right集合中是否有[l+k,r]中的元素，使用线段树合并实现。

时间复杂度\(O((\sum|T|+|S|)log|S|)\)

68%

#include<cstdio>
#include<algorithm>
#include<ctype.h>
#include<string.h>
#include<math.h>

using namespace std;
#define ll long long

inline char read() {
    static const int IN_LEN = 1000000;
    static char buf[IN_LEN], *s, *t;
    return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin), (s == t ? -1 : *s++) : *s++);
}
template<class T>
inline void read(T &x) {
    static bool iosig;
    static char c;
    for (iosig = false, c = read(); !isdigit(c); c = read()) {
        if (c == '-') iosig = true;
        if (c == -1) return;
    }
    for (x = 0; isdigit(c); c = read()) x = ((x + (x << 2)) << 1) + (c ^ '0');
    if (iosig) x = -x;
}
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {
    if (ooh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
    *ooh++ = c;
}
template<class T>
inline void print(T x) {
    static int buf[30], cnt;
    if (x == 0) print('0');
    else {
        if (x < 0) print('-'), x = -x;
        for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
        while (cnt) print((char)buf[cnt--]);
    }
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
const int N = 500005;
int n, m, q, d[N];
char s[N], t[N];
struct sam{
    int n, cnt, last, g[N<<1], fa[N<<1], len[N<<1], ch[N<<1][26];
    sam(){ n=0, cnt=last=1;}
    inline void extend(int c){
        int p=last, np=++cnt;
        last=np, len[np]=len[p]+1;
        while(p && !ch[p][c]) ch[p][c]=np, p=fa[p];
        if(!p) fa[np]=1;
        else{
            int q=ch[p][c];
            if(len[q]==len[p]+1) fa[np]=q;
            else{
                int nq=++cnt;
                len[nq]=len[p]+1, memcpy(ch[nq], ch[q], 26<<2);
                fa[nq]=fa[q], fa[q]=fa[np]=nq;
                while(ch[p][c]==q) ch[p][c]=nq, p=fa[p];
            }
        }
        g[np]=++n;
    }
    inline void clear(){
        memset(fa+1, 0, cnt<<2), memset(len+1, 0, cnt<<2), memset(g+1, 0, cnt<<2);
        for(int i=1; i<=cnt; ++i) memset(ch[i], 0, 26<<2);
        n=0, cnt=last=1;
    }
    inline ll solve(int *d){
        static int b[N], a[N<<1];
        memset(b+1, 0, n<<2);
        for(int i=1; i<=cnt; ++i) ++b[len[i]];
        for(int i=1; i<=n; ++i) b[i]+=b[i-1];
        for(int i=1; i<=cnt; ++i) a[b[len[i]]--]=i;
        ll ans=0;
        for(int i=cnt; i; --i){
            int u=a[i];
            g[fa[u]]=g[u];
            ans+=max(0, len[u]-max(len[fa[u]], d[g[u]]));
        }
        return ans;
    }
}S, T;
int main() {
    while(isalpha(s[++n]=read()));
    --n;
    for(int i=1; i<=n; ++i) S.extend(s[i]-'a');
    read(q);
    while(q--){
        while(isspace(t[1]=read()));
        m=1;
        while(isalpha(t[++m]=read()));
        --m;
        int tmp;
        read(tmp), read(tmp);
        for(int i=1, p=1, len=0; i<=m; ++i){
            int c=t[i]-'a';
            T.extend(c);
            if(S.ch[p][c]) p=S.ch[p][c], ++len;
            else{
                while(p && !S.ch[p][c]) p=S.fa[p];
                if(!p) p=1, len=0;
                else len=S.len[p]+1, p=S.ch[p][c];
            }
            d[i]=len;
        }
        print(T.solve(d)), print('\n');
        T.clear();
    }
    return flush(), 0;
}

100%

#include<cstdio>
#include<algorithm>
#include<ctype.h>
#include<string.h>
#include<math.h>

using namespace std;
#define ll long long

inline char read() {
    static const int IN_LEN = 1000000;
    static char buf[IN_LEN], *s, *t;
    return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin), (s == t ? -1 : *s++) : *s++);
}
template<class T>
inline void read(T &x) {
    static bool iosig;
    static char c;
    for (iosig = false, c = read(); !isdigit(c); c = read()) {
        if (c == '-') iosig = true;
        if (c == -1) return;
    }
    for (x = 0; isdigit(c); c = read()) x = ((x + (x << 2)) << 1) + (c ^ '0');
    if (iosig) x = -x;
}
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {
    if (ooh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
    *ooh++ = c;
}
template<class T>
inline void print(T x) {
    static int buf[30], cnt;
    if (x == 0) print('0');
    else {
        if (x < 0) print('-'), x = -x;
        for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
        while (cnt) print((char)buf[cnt--]);
    }
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
const int N = 500005, M = N*21*2;
int n, m, q, cnt, d[N], b[N], a[N<<1], rt[N<<1], lson[M], rson[M];
char s[N], t[N];
void insert(int l, int r, int &t, int x){
    if(!t) t=++cnt;
    if(l==r) return;
    int mid=l+r>>1;
    if(x<=mid) insert(l, mid, lson[t], x); else insert(mid+1, r, rson[t], x);
}
int Merge(int x, int y){
    if(!x || !y) return x|y;
    int tmp=++cnt;
    lson[tmp]=Merge(lson[x], lson[y]), rson[tmp]=Merge(rson[x], rson[y]);
    return tmp;
}
bool exist(int l, int r, int t, int L, int R){
    if(!t) return 0;
    if(L<=l && r<=R) return 1;
    int mid=l+r>>1;
    if(L<=mid && exist(l, mid, lson[t], L, R)) return 1;
    return R>mid && exist(mid+1, r, rson[t], L, R);
}
struct sam{
    int n, cnt, last, g[N<<1], fa[N<<1], len[N<<1], ch[N<<1][26];
    sam(){ cnt=last=1;}
    inline void extend(int c){
        int p=last, np=++cnt;
        last=np, len[np]=len[p]+1;
        while(p && !ch[p][c]) ch[p][c]=np, p=fa[p];
        if(!p) fa[np]=1;
        else{
            int q=ch[p][c];
            if(len[q]==len[p]+1) fa[np]=q;
            else{
                int nq=++cnt;
                len[nq]=len[p]+1, memcpy(ch[nq], ch[q], 26<<2);
                fa[nq]=fa[q], fa[q]=fa[np]=nq;
                while(ch[p][c]==q) ch[p][c]=nq, p=fa[p];
            }
        }
        g[np]=++n;
    }
    inline void clear(){
        memset(fa+1, 0, cnt<<2), memset(len+1, 0, cnt<<2), memset(g+1, 0, cnt<<2);
        for(int i=1; i<=cnt; ++i) memset(ch[i], 0, 26<<2);
        n=0, cnt=last=1;
    }
    inline ll solve(int *d){
        memset(b+1, 0, n<<2);
        for(int i=1; i<=cnt; ++i) ++b[len[i]];
        for(int i=1; i<=n; ++i) b[i]+=b[i-1];
        for(int i=1; i<=cnt; ++i) a[b[len[i]]--]=i;
        ll ans=0;
        for(int i=cnt; i; --i){
            int u=a[i];
            g[fa[u]]=g[u];
            ans+=max(0, len[u]-max(len[fa[u]], d[g[u]]));
        }
        return ans;
    }
    inline void init(){
        memset(b+1, 0, n<<2);
        for(int i=1; i<=cnt; ++i) ++b[len[i]];
        for(int i=1; i<=n; ++i) b[i]+=b[i-1];
        for(int i=1; i<=cnt; ++i) a[b[len[i]]--]=i;
        for(int i=cnt; i; --i){
            int u=a[i];
            if(g[u]) insert(1, n, rt[u], g[u]);
            rt[fa[u]]=Merge(rt[fa[u]], rt[u]);
        }
    }
}S, T;
int main() {
    while(isalpha(s[++n]=read()));
    --n;
    for(int i=1; i<=n; ++i) S.extend(s[i]-'a');
    S.init();
    read(q);
    while(q--){
        while(isspace(t[1]=read()));
        m=1;
        while(isalpha(t[++m]=read()));
        --m;
        int l, r;
        read(l), read(r);
        for(int i=1, p=1, len=0; i<=m; ++i){
            int c=t[i]-'a';
            T.extend(c);
            while(1){
                if(S.ch[p][c] && exist(1, n, rt[S.ch[p][c]], l+len, r)){
                    p=S.ch[p][c], ++len;
                    break;
                }
                if(!len) break;
                if(--len==S.len[S.fa[p]]) p=S.fa[p];
            }
            d[i]=len;
        }
        print(T.solve(d)), print('\n');
        T.clear();
    }
    return flush(), 0;
}

转载于:https://www.cnblogs.com/CMXRYNP/p/9736025.html

a550593503
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
blog原题整理
Elijahqi
07-20 1729
NOI复习计划 idea&amp;amp;考试策略 不管是什么考试都需要先把暴力分写满 即使发现正解就在身边（必须督促自己完成 知识点：线段树分治（填坑，天坑 线段树分治大约看了看 没写题 很虚毕竟自己菜 仔细阅读题面 不懂提问 如果发现需要spj的题目需要手写 请仔细检查spj是否写挂 有关数据边界如0 一定特判！ 思考题目 如果没有做法 捡分一定写 在思考的时候 如果有一些条件没...
Loj X:创建逻辑电路-开源
07-04
Loj X 使创建真正的计算单元甚至小型完整处理器成为可能。 除了逻辑门，存储盒和程序阅读器可以集成到电路中。
[LOJ 2720][BZOJ 5417][UOJ 395][NOI 2018]你的名字
weixin_30908707的博客
04-27 103
[LOJ 2720][BZOJ 5417][UOJ 395][NOI 2018]你的名字 题意 给定一个大串 \(S\) 以及 \(q\) 次询问, 每次询问给定一个串 \(T\) 和区间 \([l,r]\), 求 \(T\) 中有多少本质不同的子串不是 \(S[l:r]\) 的子串. \(|S|\le 5\times 10^5,q\le 10^5,\sum|T|\le10^6\). 题...
NOI前训练记录
weixin_30614109的博客
05-21 109
从今年年初开始就没怎么碰oi，学了三个月文化课，然后就是省选到处跑(浪)，进了省队后又去北京打(浪)了波(七)铁(天)，回家后又生了一星期病，感觉自己noi凉透了。。。 ctsc因为运气的原因有人放弃D3自己才拿到au，apio什么牌都没拿到，自己这么菜的主要原因可能还是没怎么做题吧，五个月不碰oi，已经连dfs都不会了，还有两个月就noi了，再不训练又要为JS丢脸了，自己拿不到au却占了个省队名...
2018十二月刷题列表
weixin_30487701的博客
12-01 397
Preface \(2018\)年的尾巴，不禁感慨自己这一年的蜕变只能用蜕变来形容了。 而且老叶说我们今年没的参加清北冬令营可以参加CCF在广州二中举办的冬令营，只要联赛\(390+\)就应该可以报。 想都不要想啊当然是要去的啦，可以跑到这么远的地方交流一下还可以逃过一月月考（\(2019.1.24\to2019.1.31\)） 瞬间感觉有了点实质性的东西刺激一下自己了，而且离\(ZJO...
停课刷题总结
weixin_30895603的博客
05-11 409
*号表示没有写**号表示没有解决cnt=162/174bzoj 1192: [HNOI2006]鬼谷子的钱袋 二进制，思维bzoj 1191: [HNOI2006]超级英雄Hero 网络流，残量网络bzoj 1179: [Apio2009]Atm tarjan，缩点，最长路，水题bzoj 1143: [CTSC2008]祭祀river 二分图，最大独立集*bzoj 1101: [POI2007]...
蒟蒻的做题记录
weixin_30832983的博客
05-26 140
这里面大部分的题在UOJ/LOJ上面有（包括没有超链接的） 　　感觉我做的题真的是少得可怜。。。比日切十题的 4+7 大佬少多了。。。人也不知道比 4+7 大佬菜到哪里去了。。。 　　智商正在缓慢恢复中持续下降。 2018.5.26 　　【THUWC 2017】随机二分图 2018.5.27 　　【ZJOI2018】历史 　　【XSY2300】好题 　　【JXOI2018】守卫 　　【JXOI20...
2019-9-14做题记录
weixin_30362233的博客
09-14 229
1、【BZOJ1493】【NOI2007】项链工厂 已经是十二年之前的$NOI$了，现在看来古人们学的东西我都不会。 一个环，每个元素有颜色，六种操作。 $Rotate\ k$：将项链顺时针旋转$k$个单位。即原$i$位置变成现在$i+k$位置。 $Flip$：将项链沿指定对称轴翻转，即将项链的$i$位置和$n+2-i$位置互换。 $Swap\ i\ j$：将项链的$i$位...
退役前的做题记录1.0
abcyan1235的博客
09-29 269
退役前的做题记录1.0 租酥雨最近很懒qwq，具体表现在写题的时候不想发题解了。 但是想想这样也不太好，就决定发个一句话（半句话到几句话不等）题解上来。 2018-09.18-2018-09.28 [BZOJ3613][HEOI2014]南园满地堆轻絮 可以证明答案就是差最大的逆序对的差的一半。 [BZOJ3612][HEOI2014]平衡 相当于是要选k个不同的数使它们和为0.正负分开...
[OI笔记]每周刷题记录
11-29 2467
一些题库： bzoj、uoj、luogu（洛谷）、CF、loj、hdu、poj、51nod 下面是一些近期的做题记录 省选爆炸…然后大概就先这样了，要回去读一段时间文化课，如果文化课还不错的话也许还会回来… 2018.2.25 ·【bzoj1257】余数之和-数学（根号求和） ·【loj6006】「网络流 24 题」试题库-最大流 ·【bz...
基于UOJ开发的在线评测系统
05-19
【作品名称】：基于UOJ开发的在线评测系统 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：更人性化的后台界面，更...
log4j配置，jar包
06-01
log4j配置文档，jar包
up_717085_google-api-php-client_71loj.rar
12-22
使用php做的，google的API客户端的连接程序的例子代码，主要是调用google的API的连接程序，简单全面供给各类学习参考
mybaits 架包
01-30
包含 mybatis-3.3.0；log4j-1.2.17；junit-4.12；javassist-3.4.GA；hamcrest-all-1.3
###对华为OD分布式操作系统的详细介绍
05-22
华为OD
2110220116吴骏博.py
最新发布
05-22
2110220116吴骏博.py
基于Java的ApplicationPower快速项目生成脚手架设计源码
05-22
ApplicationPower项目生成脚手架设计源码：该项目基于Java开发，包含284个文件，主要使用Java和Shell语言。ApplicationPower是一个快速的项目生成脚手架，旨在帮助开发者快速搭建项目框架，包括创建项目结构、配置文件、开发环境等，提高开发效率。
基于MATLAB实现的OFDM经典同步算法之一Park算法仿真，附带Park算法经典文献+代码文档+使用说明文档.rar
05-22
CSDN IT狂飙上传的代码均可运行，功能ok的情况下才上传的，直接替换数据即可使用，小白也能轻松上手 【资源说明】 基于MATLAB实现的OFDM经典同步算法之一Park算法仿真，附带Park算法经典文献+代码文档+使用说明文档.rar 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2020b；若运行有误，根据提示GPT修改；若不会，私信博主（问题描述要详细）； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可后台私信博主； 4.1 期刊或参考文献复现 4.2 Matlab程序定制 4.3 科研合作 功率谱估计： 故障诊断分析： 雷达通信：雷达LFM、MIMO、成像、定位、干扰、检测、信号分析、脉冲压缩 滤波估计：SOC估计 目标定位：WSN定位、滤波跟踪、目标定位 生物电信号：肌电信号EMG、脑电信号EEG、心电信号ECG 通信系统：DOA估计、编码译码、变分模态分解、管道泄漏、滤波器、数字信号处理+传输+分析+去噪、数字信号调制、误码率、信号估计、DTMF、信号检测识别融合、LEACH协议、信号检测、水声通信 5、欢迎下载，沟通交流，互相学习，共同进步！
LOJ6354 & 洛谷4366：[Code+#4]最短路——题解
05-17
这道题需要使用 Dijkstra 算法来解决。 Dijkstra 算法是一种贪心算法，用于解决没有负权边的单源最短路径问题。算法的基本思想是：从源点开始，每次选择当前最短路径的节点，并更新其周围节点的距离。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值