hdu-6345 子串查询

子串查询

Accepts: 4117

Submissions: 16906

Time Limit: 3500/3000 MS (Java/Others)

Memory Limit: 262144/262144 K (Java/Others)

Problem Description

度度熊的字符串课堂开始了！要以像度度熊一样的天才为目标，努力奋斗哦！

为了检验你是否具备不听课的资质，度度熊准备了一个只包含大写英文字母的字符串 A[1,n]=a1a2⋯anA[1,n] = a_1 a_2 \cdots a_nA[1,n]=a​1​​a​2​​⋯a​n​​，接下来他会向你提出 qqq 个问题 (l,r)(l,r)(l,r)，你需要回答字符串 A[l,r]=alal+1⋯arA[l,r] = a_l a_{l+1} \cdots a_rA[l,r]=a​l​​a​l+1​​⋯a​r​​ 内有多少个非空子串是 A[l,r]A[l,r]A[l,r] 的所有非空子串中字典序最小的。这里的非空子串是字符串中由至少一个位置连续的字符组成的子序列，两个子串是不同的当且仅当这两个子串内容不完全相同或者出现在不同的位置。

记 ∣S∣|S|∣S∣ 为字符串 SSS 的长度，对于两个字符串 SSS 和 TTT ，定义 SSS 的字典序比 TTT 小，当且仅当存在非负整数 k(≤min(∣S∣,∣T∣))k(\leq \min(|S|,|T|))k(≤min(∣S∣,∣T∣)) 使得 SSS 的前 kkk 个字符与 TTT 的前 kkk 个字符对应相同，并且要么满足 ∣S∣=k|S| = k∣S∣=k 且 ∣T∣>k|T| > k∣T∣>k，要么满足 k<min(∣S∣,∣T∣)k < \min(|S|,|T|)k<min(∣S∣,∣T∣) 且 SSS 的第 k+1k+1k+1 个字符比 TTT 的第 k+1k+1k+1 个字符小。例如 "AA" 的字典序比 "AAA" 小，"AB" 的字典序比 "BA" 小。

Input

第一行包含一个整数 T，表示有 T 组测试数据。

接下来依次描述 T 组测试数据。对于每组测试数据：

第一行包含两个整数 n 和 q，表示字符串的长度以及询问的次数。

第二行包含一个长为 n 的只包含大写英文字母的字符串 A[1,n]A[1,n]A[1,n]。

接下来 q行，每行包含两个整数 li,ril_i,r_il​i​​,r​i​​，表示第 iii 次询问的参数。

保证 1≤T≤10 1 \leq T \leq 101≤T≤10，1≤n,q≤1051 \leq n,q \leq 10^51≤n,q≤10​5​​，1≤li≤ri≤n1 \leq l_i \leq r_i \leq n1≤l​i​​≤r​i​​≤n。

Output

对于每组测试数据，先输出一行信息 "Case #x:"（不含引号），其中 x 表示这是第 xxx 组测试数据，接下来 qqq 行，每行包含一个整数，表示字符串 A[l,r]A[l,r]A[l,r] 中字典序最小的子串个数，行末不要有多余空格。

Sample Input

Copy

1
2 3
AB
1 1
1 2
2 2

Sample Output

Copy

Case #1:
1
1
1

//题目大意：T组数据，每组输入长度为n的字符串，m个询问，在每个询问中求在[l,r]范围内的字典序最小的字串个数

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=400000+5;
char s[maxn];
int n;
int q;
struct node{
	int l;
	int r;
	int cc;
	char val;
}tree[maxn];
void cal(int k)
{
    if(tree[k*2].val<tree[k*2+1].val)
    {
        tree[k].cc=tree[k*2].cc;
        tree[k].val=tree[k*2].val;
    }else if(tree[k*2].val>tree[k*2+1].val)
    {
        tree[k].cc=tree[k*2+1].cc;
        tree[k].val=tree[k*2+1].val;
    }else
    {
        tree[k].cc=tree[k*2+1].cc+tree[k*2].cc;
        tree[k].val=tree[k*2+1].val;
    }
}
void build(int root,int L,int R)
{
    tree[root].l=L;
    tree[root].r=R;
    if(L==R)
    {
        tree[root].val=s[L];
        tree[root].cc=1;
        return ;
    }
    int mid=(L+R)/2;
    build(root*2,L,mid);
    build(root*2+1,mid+1,R);
    cal(root);
}
int query1(int L,int R,int root)
{
	if(L<=tree[root].l&&tree[root].r<=R)
	{
		return tree[root].val;
	}
	int mid=(tree[root].l+tree[root].r)/2;
	int ans=0x3f3f3f3f;
	if(L<=mid)ans=min(ans,query1(L,R,root*2));
	if(R>mid)ans=min(ans,query1(L,R,root*2+1));
	return ans;
}
int query2(int L,int R,int root,int v)
{
	if(L<=tree[root].l&&tree[root].r<=R)
	{
		if(tree[root].val==v)
		return tree[root].cc;
		else return 0;
	}
	int mid=(tree[root].l+tree[root].r)/2;
	int ans=0;
	if(L<=mid)ans+=query2(L,R,root*2,v);
	if(R>mid)ans+=query2(L,R,root*2+1,v);
	return ans;
}
int main()
{
    int t;
    while(~scanf("%d",&t))
    {
        for(int kk=1;kk<=t;kk++)
        {
            int n,q;
            scanf("%d%d",&n,&q);
            scanf("%s",s+1);
            printf("Case #%d:\n",kk);
            build(1,1,n);
            for(int i=0;i<q;i++)
            {
                int l,r;
                scanf("%d%d",&l,&r);
                int minn=query1(l,r,1);
                int ans=query2(l,r,1,minn);
                printf("%d\n",ans);
            }
        }
    }
    return 0;
}