hdoj 5008 后缀数组+RMQ+二分

hdoj 5008

题意：给一个字符串，问该字符串第k个子串的最小字典序位置。其中k需要L xor R xor V求得，L R是前一个询问的子串位置，说白了就是强制在线。

思路：先是后缀数组处理出子串去重后的编号，然后先求得第k个子串的位置i，因为这个位置只是后缀数组中第一次出现的位置，而不一定是原字符串中最左边的位置，所以真正的位置可能在i的左边或右边。如果遍历去找肯定会超时，但是我们可以二分。

假设第k个子串的长度为d，起始下标为i，真实下标为j，那么i到j的公共前缀一定大于等于d，即height[i] >= d, height[i + 1] >=d ....height[j]>=d（j也可能在i的左边），那么我们只要保证min（height[i],height[i + 1]...height[j]）>= d就可以了，这就用到了RMQ，我这里是用线段树实现的。

这样就可以求出含有公共前缀的最大范围L和R（L<=i, R>=i）。

然后只要求出[L,R]中最小的sa就可以了，这里就用到了另一个RMQ。

所以我们一共需要两个RMQ，一个用来查询区间最小公共前缀长度（height），一个用来查询区间最小后缀起始位置（sa）。

另外还有一些细节，后缀数组得到的答案L，R是以0开始的，xor和输出答案的时候记得加1（我就这里wa了好多次。。。TAT），还有k、v是long long。

#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;

const int MAXN = 100010;
int sa[MAXN];
int t1[MAXN],t2[MAXN],c[MAXN];
int Rank[MAXN],height[MAXN];
void build_sa(int s[],int n,int m)
{
    int i,j,p,*x=t1,*y=t2;
    for(i=0;i<m;i++)c[i]=0;
    for(i=0;i<n;i++)c[x[i]=s[i]]++;
    for(i=1;i<m;i++)c[i]+=c[i-1];
    for(i=n-1;i>=0;i--)sa[--c[x[i]]]=i;
    for(j=1;j<=n;j<<=1)
    {
        p=0;
        for(i=n-j;i<n;i++)y[p++]=i;
        for(i=0;i<n;i++)if(sa[i]>=j)y[p++]=sa[i]-j;
        for(i=0;i<m;i++)c[i]=0;
        for(i=0;i<n;i++)c[x[y[i]]]++;
        for(i=1;i<m;i++)c[i]+=c[i-1];
        for(i=n-1;i>=0;i--)sa[--c[x[y[i]]]]=y[i];
        swap(x,y);
        p=1;x[sa[0]]=0;
        for(i=1;i<n;i++)
            x[sa[i]]=y[sa[i-1]]==y[sa[i]] && y[sa[i-1]+j]==y[sa[i]+j]?p-1:p++;
        if(p>=n)break;
        m=p;
    }
}
void getHeight(int s[],int n)
{
    int i,j,k=0;
    for(i=0;i<=n;i++)Rank[sa[i]]=i;
    for(i=0;i<n;i++)
    {
        if(k)k--;
        j=sa[Rank[i]-1];
        while(s[i+k]==s[j+k])k++;
        height[Rank[i]]=k;
    }
}

int seq[MAXN];
void suffix_array(char str[]){
    int len = strlen(str);
    for(int i = 0; i <= len; i++) seq[i] = str[i];
    seq[len] = 0;
    build_sa(seq, len + 1, 128);
    getHeight(seq, len);
}
char str[MAXN];
//==================================================================================
long long sum[MAXN], len;
struct Tree{
    int l, r, val[2];
}tree[MAXN * 4];//0 height 1 sa
int cnt = 0;
void buildtree(int rt, int l, int r) {
    tree[rt].l = l, tree[rt].r = r;
    if(l == r) {
        tree[rt].val[0] = height[cnt];
        tree[rt].val[1] = sa[cnt++];
        return ;
    }
    int mid = (l + r) / 2;
    buildtree(rt * 2, l, mid);
    buildtree(rt * 2 + 1, mid + 1, r);
    tree[rt].val[0] = min(tree[rt * 2].val[0], tree[rt * 2 + 1].val[0]);
    tree[rt].val[1] = min(tree[rt * 2].val[1], tree[rt * 2 + 1].val[1]);
}
int query(int rt, int l, int r, int id) {
    if(tree[rt].l == l && tree[rt].r == r) {
        return tree[rt].val[id];
    }
    int mid = (tree[rt].l + tree[rt].r) / 2;
    if(l > mid) return query(rt * 2 + 1, l, r, id);
    else if(r <= mid) return query(rt * 2, l, r, id);
    else {
        return min(query(rt * 2, l, mid, id), query(rt * 2 + 1, mid + 1, r, id));
    }
}
int bsl(int x, int LEN) {
    int l = 1, r = x - 1, mid, ret = x;
    while(l <= r) {
        mid = (l + r) >> 1;
        if(query(1, mid + 1, x, 0) >= LEN) {
            ret = mid, r = mid - 1;
        }
        else l = mid + 1;
    }
    return ret;
}
int bsr(int x, int LEN) {
    int l = x + 1, r = len, mid, ret = x;
    while(l <= r) {
        mid = (l + r) >> 1;
        if(query(1, x + 1, mid, 0) >= LEN) {
            ret = mid, l = mid + 1;
        }
        else r = mid - 1;
    }
    return ret;
}
main() {
    int n;
    while(~scanf("%s", str)) {
        len = strlen(str);
        suffix_array(str);
        memset(tree, 0, sizeof tree);
        cnt = 1;
        buildtree(1, 1, len);
        for(int i = 1; i <= len; i++) {
            sum[i] = sum[i - 1] + len - sa[i] - height[i];
        //    printf("sa[%d] = %d height[%d] = %d\n", i, sa[i], i, height[i]);

        }
        long long l = 0, r = 0, v, k;
        scanf("%d", &n);
        while(n--) {
            scanf("%I64d", &v);
            v ^= l ^ r;
            k = v + 1;
    //        printf("k = %I64d\n", k);
            if(k > sum[len]) {
                puts("0 0");
                l = r = 0;
                continue;
            }
            int t = lower_bound(sum + 1, sum + 1 + len, k) - sum;
            l = sa[t], r = len - (sum[t] - k + 1);
            int d = r - l + 1;
            int L = bsl(t, d), R = bsr(t, d);
      //      printf("L = %d R = %d\n", L, R);
            int ans = query(1, L, R, 1);
      //      printf("l = %d\n", ans);
            l = ans + 1, r = l + d - 1;
            printf("%I64d %I64d\n", l, r);
        }
    }
}