[TJOI2016 & HEOI2016] 字符串

[题目链接]

https://www.lydsy.com/JudgeOnline/problem.php?id=4556

[算法]

不难发现 , 对于每个询问
        ans = max{ min{b - i + 1 , lcp(i , c) } (a <= i <= b)

不妨二分答案mid , 那么问题就转化为求 max{ lcp(i  , c) } (a <= i <= b - mid + 1)

而我们知道 , 所有lcp(i , j) <= k的i是连续的一段区间

可以再次通过二分求出这个区间

问题又转化为判断[a , b - mid + 1]中是否有rank值在区间[L , R]中的数

构建出后缀数组 , 主席树维护rank值即可

时间复杂度 : O(NlogN ^ 2)

[代码]

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int MAXLOG = 17;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;

#define rint register int

int n , m;
int rk[N] , rt[N] , sa[N] , cnt[N] , height[N] , lg[N];
int val[N][MAXLOG];
char s[N];

struct Presitent_Segment_Tree
{
        int sz;
        int lc[N * 40] , rc[N * 40] , cnt[N * 40];
        Presitent_Segment_Tree()
        {
                sz = 0;
        }
        inline void build(int &now , int l , int r)
        {
                now = ++sz;
                if (l == r) return;
                 int mid = (l + r) >> 1;
                 build(lc[now] , l , mid);
                 build(rc[now] , mid + 1 , r);
        }
        inline void modify(int &now , int old , int l , int r , int x , int value)
        {
                now = ++sz;
                lc[now] = lc[old] , rc[now] = rc[old];
                cnt[now] = cnt[old] + value;
                if (l == r) return;
                int mid = (l + r) >> 1;
                if (mid >= x) modify(lc[now] , lc[old] , l , mid , x , value);
                else modify(rc[now] , rc[old] , mid + 1 , r , x , value);
        }
        inline bool query(int rt1 , int rt2 , int l , int r , int ql , int qr)
        {
                if (ql > qr || cnt[rt1] - cnt[rt2] == 0)
                        return false;
                if (l == ql && r == qr)
                        return (cnt[rt1] - cnt[rt2] > 0);
                int mid = (l + r) >> 1;
                if (mid >= qr) return query(lc[rt1] , lc[rt2] , l , mid , ql , qr);
                else if (mid + 1 <= ql) return query(rc[rt1] , rc[rt2] , mid + 1 , r , ql , qr);
                else return query(lc[rt1] , lc[rt2] , l , mid , ql , mid) | query(rc[rt1] , rc[rt2] , mid + 1 , r , mid + 1 , qr);
        }
} PST;
template <typename T> inline void chkmax(T &x,T y) { x = max(x,y); }
template <typename T> inline void chkmin(T &x,T y) { x = min(x,y); }
template <typename T> inline void read(T &x)
{
    T f = 1; x = 0;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == ‘-‘) f = -f;
    for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - ‘0‘;
    x *= f;
}
inline void build_sa()
{
        static int x[N] , y[N];
    memset(cnt , 0 , sizeof(cnt));
    for (rint i = 1; i <= n; i++) ++cnt[(int)s[i]];
    for (rint i = 1; i <= 256; i++) cnt[i] += cnt[i - 1];
    for (rint i = n; i >= 1; i--) sa[cnt[(int)s[i]]--] = i;
    rk[sa[1]] = 1;
    for (rint i = 2; i <= n; i++) rk[sa[i]] = rk[sa[i - 1]] + (s[sa[i]] != s[sa[i - 1]]);
    for (rint k = 1; rk[sa[n]] != n; k <<= 1)
    {
        for (rint i = 1; i <= n; i++)
            x[i] = rk[i] , y[i] = (i + k <= n) ? rk[i + k] : 0;
        memset(cnt , 0 , sizeof(cnt));
        for (rint i = 1; i <= n; i++) ++cnt[y[i]];
        for (rint i = 1; i <= n; i++) cnt[i] += cnt[i - 1];
        for (rint i = n; i >= 1; i--) rk[cnt[y[i]]--] = i;
        memset(cnt , 0 , sizeof(cnt));
        for (rint i = 1; i <= n; i++) ++cnt[x[i]];
        for (rint i = 1; i <= n; i++) cnt[i] += cnt[i - 1];
        for (rint i = n; i >= 1; i--) sa[cnt[x[rk[i]]]--] = rk[i];
        rk[sa[1]] = 1;
        for (rint i = 1; i <= n; i++) rk[sa[i]] = rk[sa[i - 1]] + (x[sa[i]] != x[sa[i - 1]] || y[sa[i]] != y[sa[i - 1]]);
    }
}
inline void get_height()
{
    int k = 0;
    for (rint i = 1; i <= n; i++)
    {
        if (k) --k;
        int j = sa[rk[i] - 1];
        while (s[i + k] == s[j + k]) ++k;
        height[rk[i]] = k;
    }
}
inline void rmq_init()
{
        for (rint i = 1; i <= n; i++)
                val[i][0] = height[i];
        for (rint j = 1; (1 << j) <= n; j++)
        {
                for (rint i = 1; i + (1 << j) - 1 <= n; i++)
                {
                        val[i][j] = min(val[i][j - 1] , val[i + (1 << (j - 1))][j - 1]);
                }
        }
}
inline int query(int x , int y)
{
        if (x > y) return 0;
        int k = lg[y - x + 1];
        return min(val[x][k] , val[y - (1 << k) + 1][k]);
}

int main()
{

        scanf("%d%d" , &n , &m);
        scanf("%s" , s + 1);
        build_sa();
        get_height();
        rmq_init();
        PST.build(rt[0] , 1 , n);
        for (rint i = 1; i <= n; i++) PST.modify(rt[i] , rt[i - 1] , 1 , n , rk[i] , 1);
        for (rint i = 1; i <= n; i++) lg[i] = (double)(log(i) / log(2.0));
        while (m--)
        {
                int a , b , c , d;
                read(a); read(b); read(c); read(d);
                int l = 1 , r = min(d - c + 1 , b - a + 1) , ans = 0;
                while (l <= r)
                {
                        int mid = (l + r) >> 1;
                        int ll = 1 , rr = rk[c] - 1 , L = rk[c] , R = rk[c];
                        while (ll <= rr)
                        {
                                int md = (ll + rr) >> 1;
                                if (query(md + 1 , rk[c]) >= mid)
                                {
                                        L = md;
                                        rr = md - 1;
                                } else ll = md + 1;
                        }
                        ll = rk[c] + 1 , rr = n , R = rk[c];
                        while (ll <= rr)
                        {
                                int md = (ll + rr) >> 1;
                                if (query(rk[c] + 1 , md) >= mid)
                                {
                                        R = md;
                                        ll = md + 1;
                                } else rr = md - 1;
                        }
                        if (PST.query(rt[b - mid + 1] , rt[a - 1] , 1 , n , L , R))
                        {
                                l = mid + 1;
                                ans = mid;
                        } else r = mid - 1;
                }
                printf("%d\n" , ans);
        }

        return 0;

}

原文地址:https://www.cnblogs.com/evenbao/p/10459668.html

时间: 2024-08-03 05:33:18

[TJOI2016 & HEOI2016] 字符串的相关文章

Bzoj4556: [Tjoi2016&amp;Heoi2016]字符串 后缀数组

4556: [Tjoi2016&Heoi2016]字符串 Time Limit: 20 Sec  Memory Limit: 128 MBSubmit: 169  Solved: 87[Submit][Status][Discuss] Description 佳媛姐姐过生日的时候,她的小伙伴从某东上买了一个生日礼物.生日礼物放在一个神奇的箱子中.箱子外边写了 一个长为n的字符串s,和m个问题.佳媛姐姐必须正确回答这m个问题,才能打开箱子拿到礼物,升职加薪,出任CE O,嫁给高富帅,走上人生巅峰.

[Tjoi2016&amp;Heoi2016]字符串

[Tjoi2016&Heoi2016]字符串 题目 佳媛姐姐过生日的时候,她的小伙伴从某东上买了一个生日礼物.生日礼物放在一个神奇的箱子中.箱子外边写了一个长为n的字符串s,和m个问题.佳媛姐姐必须正确回答这m个问题,才能打开箱子拿到礼物,升职加薪,出任CEO,嫁给高富帅,走上人生巅峰.每个问题均有a,b,c,d四个参数,问你子串s[a..b]的所有子串和s[c..d]的最长公共前缀的长度的最大值是多少?佳媛姐姐并不擅长做这样的问题,所以她向你求助,你该如何帮助她呢? INPUT 输入的第一行有

[BZOJ4556][TJOI2016&amp;&amp;HEOI2016]字符串(二分答案+后缀数组+RMQ+主席树)

4556: [Tjoi2016&Heoi2016]字符串 Time Limit: 20 Sec  Memory Limit: 128 MBSubmit: 1360  Solved: 545[Submit][Status][Discuss] Description 佳媛姐姐过生日的时候,她的小伙伴从某东上买了一个生日礼物.生日礼物放在一个神奇的箱子中.箱子外边写了 一个长为n的字符串s,和m个问题.佳媛姐姐必须正确回答这m个问题,才能打开箱子拿到礼物,升职加薪,出任CE O,嫁给高富帅,走上人生巅

[bzoj4556] [Tjoi2016&amp;Heoi2016]字符串

翻转原串,建后缀自动机. 然后先考虑最朴素的思路,找到d所对应的节点,然后一直往上走,并更新答案. 发现由于有a,b的限制,更新答案需要取min,很不爽,不如二分答案. 然后就可以转化为判定性问题,用字符串定位技术找到当前的cd对应的字符串(其实就是倍增+len判定), 判定当前的节点是否有当前a,b范围的right集. 要知道每个节点的right集具体是什么用dfs序建立主席树即可. #include<iostream> #include<cstdio> #include<

bzoj4556: [Tjoi2016&amp;Heoi2016]字符串 (后缀数组加主席树)

题目是给出一个字符串,每次询问一个区间[a,b]中所有的子串和另一个区间[c,d]的lcp最大值,首先求出后缀数组,对于lcp的最大值肯定是rank[c]的前驱和后继,但是对于这个题会出现问题,就是题目中有区间的限制. For example: 5 1 aaaab 1 2 3 5 对于这个样例,如果直接找到aab的前驱是 aaab,然后由于区间的原因答案是1,但是如果我们再往前找的话,找到aaaab,答案会变成2.那就出现了错误.考虑一下怎么做可以去除这种影响呢? 我们可以二分一下,首先对于[a

bzoj 4556: [Tjoi2016&amp;Heoi2016]字符串

二分ans,二分区间长度,st表查,最后主席树判断. 这题最大收获学到了一个nb的卡常技巧,主席树元素个数为0直接返回,不敢相信快了一倍. 1 #include<iostream> 2 #include<cstdio> 3 #include<algorithm> 4 #include<cstring> 5 #define N 200005 6 using namespace std; 7 inline int read() 8 { 9 int p=0;cha

bzoj4556【TJOI2016&amp;HEOI2016】字符串

4556: [Tjoi2016&Heoi2016]字符串 Time Limit: 20 Sec  Memory Limit: 128 MB Submit: 195  Solved: 103 [Submit][Status][Discuss] Description 佳媛姐姐过生日的时候,她的小伙伴从某东上买了一个生日礼物.生日礼物放在一个神奇的箱子中.箱子外边写了 一个长为n的字符串s,和m个问题.佳媛姐姐必须正确回答这m个问题,才能打开箱子拿到礼物,升职加薪,出任CE O,嫁给高富帅,走上人生

BZOJ 4553 Tjoi2016&amp;Heoi2016 序列

Tjoi2016&Heoi2016序列 Description 佳媛姐姐过生日的时候,她的小伙伴从某宝上买了一个有趣的玩具送给他.玩具上有一个数列,数列中某些项的值 可能会变化,但同一个时刻最多只有一个值发生变化.现在佳媛姐姐已经研究出了所有变化的可能性,她想请教你 ,能否选出一个子序列,使得在任意一种变化中,这个子序列都是不降的?请你告诉她这个子序列的最长长度即可 .注意:每种变化最多只有一个值发生变化.在样例输入1中,所有的变化是: 1 2 3 2 2 3 1 3 3 1 1 31 2 4

bzoj4551[Tjoi2016&amp;Heoi2016]树

bzoj4551[Tjoi2016&Heoi2016]树 题意: 给个根节点为1的n点树,初始时节点1标记,Q个操作,每次可以标记一个点或求一个点最近一个标记了的祖先. 题解: 链剖可以写,当正解应该是并查集.离线读入所有操作,累加每个节点的标记次数,之后所有未被标记的节点向其父亲节点连边,然后倒着来,如果操作是询问则输出这个节点在并查集中的根节点,如果是标记则将该节点的标记数减1,一旦这个节点的标记数减到了0,就让它向父亲节点连边. 代码: 1 #include <cstdio> 2