題目分析：我發現我對線段樹合併一無所知QAQ。

先講一種簡單的做法：我們可以將字尾陣列建出來，對於每個詢問二分一個答案mid。然後從Rank[c]往上下兩個方向跳，找到一個區間[L,R]，使得這個區間的字尾和c開頭的字尾的LCP大於等於mid。那麼如果sa[L]~sa[R]中有落在[a,b-mid+1]的數，最終答案就大於等於mid。要判斷區間[L,R]中是否有屬於某個權值區域的數，寫個可持久化的權值線段樹，然後差分一下就行。

上面的做法程式碼很短，但常數偏大。其實還可以把反串的字尾自動機建出來，二分完答案mid後，用樹上倍增跳到Right(c)-mid所對應的節點，然後看這個節點的Right集中是否包含[b+mid-1,a]中的數（上文的a,b,c均指在反串中的位置）。這可以用線段樹合併來實現（當然也可以用DFS序+可持久化線段樹，不過我做這題的主要目的是寫一寫線段樹合併）。

為了在省選的賽場上也能碼出這種超級資料結構題，我特地測試了一下自己寫這題程式碼的時間。結果我用75min寫好了程式碼，交上去WA了一次，然後用一組手造的小資料檢查了一遍，發現有個n+1寫成了n，還有線段樹合併的時候忘了新建節點qaq，然後再交了一次就……

就不停地RE！！！我不停地debug還是沒有發現任何錯。到了第二天中午（也就是今天中午），我迫不得已把網上某位dalao的程式copy下來對拍，還是沒有拍出任何錯QAQ。於是我只好將程式碼一段一段註釋掉，交上BZOJ，看看是哪裡RE了。結果我發現是線段樹合併出錯了。

假設線段樹的葉子節點有N個，那麼線段樹合併的總空間應該是2Nlog(

那為什麼對拍不出錯呢？因為我的字串是隨機生成的，導致建出來的SAM狀態數很少。而線段樹的葉子節點個數等於SAM的狀態數，所以不會爆。我將空間改成2Nlog(N)之後MLE了，於是我稍微調小了點空間，終於過了。然後我就對著這道題花掉了75min寫程式碼+一箇中午debug的時間……

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=100100;
const int maxm=7000000;
const int maxl=20;
const int maxc=26;

struct Seg
{
    int sum;
    Seg *lson,*rson;
} tree[maxm];
int Tcur=-1;

struct Tnode;

struct edge
{
    Tnode *obj;
    edge *Next;
} e[maxn<<1];
int Ecur=-1;

struct Tnode
{
    int val,Right;
    edge *head;
    Seg *Seg_Root;
    Tnode *son[maxc],*Fa[maxl],*parent;
} SAM[maxn<<1];
Tnode *Last[maxn];
Tnode *Root;
int cur=-1;

int a[maxn];
char s[maxn];
int n,m;
int A,b,c,d;

Seg *New_Seg()
{
    Tcur++;
    tree[Tcur].sum=0;
    tree[Tcur].lson=tree[Tcur].rson=tree;
    return tree+Tcur;
}

Tnode *New_node(int v,int c)
{
    cur++;
    SAM[cur].val=v;
    SAM[cur].Right=c;
    SAM[cur].parent=NULL;
    SAM[cur].head=NULL;
    SAM[cur].Seg_Root=tree;
    for (int i=0; i<maxc; i++) SAM[cur].son[i]=NULL;
    for (int i=0; i<maxl; i++) SAM[cur].Fa[i]=NULL;
    return SAM+cur;
}

void Add(Tnode *x,Tnode *y)
{
    Ecur++;
    e[Ecur].obj=y;
    e[Ecur].Next=x->head;
    x->head=e+Ecur;
}

void Update(Seg *&root,int L,int R,int x)
{
    if (root==tree) root=New_Seg();
    if (L==R) root->sum=1;
    else
    {
        int mid=(L+R)>>1;
        if (x<=mid) Update(root->lson,L,mid,x);
        else Update(root->rson,mid+1,R,x);
        root->sum=root->lson->sum+root->rson->sum;
    }
}

void Merge(Seg *&x,Seg *y)
{
    if (y==tree) return;
    if (x==tree)
    {
        x=y;
        return;
    }

    Seg *z=x;
    x=New_Seg();
    (*x)=(*z); //要記得新開節點！！！
    Merge(x->lson,y->lson);
    Merge(x->rson,y->rson);
    x->sum=x->lson->sum+x->rson->sum;
}

void Dfs(Tnode *node)
{
    Update(node->Seg_Root,1,n+1,node->Right);
    for (edge *p=node->head; p; p=p->Next)
    {
        Tnode *to=p->obj;
        Dfs(to);
        Merge(node->Seg_Root,to->Seg_Root);
//我這裡的線段樹合併要兩倍SAM節點數*log(n)的空間，也就是maxn*maxl<<2（注意被卡空間）！！！
    }
}

void Build_SAM()
{
    Root=New_node(0,n+1);
    Last[0]=Root;
    for (int i=1; i<=n; i++)
    {
        Tnode *P=Last[i-1],*NP=New_node(i,i);
        Last[i]=NP;
        int to=a[i];
        while ( P && !P->son[to] ) P->son[to]=NP,P=P->parent;
        if (!P) NP->parent=Root;
        else
        {
            Tnode *Q=P->son[to];
            if (P->val+1==Q->val) NP->parent=Q;
            else
            {
                Tnode *NQ=New_node(P->val+1,n+1);
                for (int i=0; i<maxc; i++) NQ->son[i]=Q->son[i];
                NQ->parent=Q->parent;
                NP->parent=Q->parent=NQ;
                while ( P && P->son[to]==Q ) P->son[to]=NQ,P=P->parent;
            }
        }
    }

    for (int i=0; i<=cur; i++)
    {
        Tnode *P=SAM+i;
        P->Fa[0]=P->parent;
    }
    for (int j=1; j<maxl; j++)
        for (int i=0; i<=cur; i++)
        {
            Tnode *P=SAM+i;
            if (P->Fa[j-1]) P->Fa[j]=P->Fa[j-1]->Fa[j-1];
        }

    for (int i=1; i<=cur; i++)
    {
        Tnode *P=SAM+i;
        Add(P->parent,P);
    }
    Dfs(Root);
}

Tnode *Jump(int x,int y)
{
    Tnode *P=Last[x];
    for (int j=maxl-1; j>=0; j--)
        if ( P->Fa[j] && P->Fa[j]->val>=y ) P=P->Fa[j];
    return P;
}

bool Query(Seg *root,int L,int R,int x,int y)
{
    if ( y<L || R<x || root==tree ) return false;
    if ( x<=L && R<=y ) return root->sum;

    int mid=(L+R)>>1;
    bool fL=Query(root->lson,L,mid,x,y);
    bool fR=Query(root->rson,mid+1,R,x,y);
    return ( fL || fR );
}

bool Judge(int len)
{
    Tnode *node=Jump(c,len);
    return Query(node->Seg_Root,1,n+1,b+len-1,A);
}

int Binary()
{
    int L=0,R=min(A-b+1,c-d+1)+1;
    while (L+1<R)
    {
        int mid=(L+R)>>1;
        if ( Judge(mid) ) L=mid;
        else R=mid;
    }
    return L;
}

int main()
{
    freopen("4556.in","r",stdin);
    freopen("4556.out","w",stdout);

    scanf("%d%d",&n,&m);
    scanf("%s",&s);
    for (int i=1; i<=n; i++) a[i]=s[i-1]-'a';
    for (int i=1; i<=(n>>1); i++) swap(a[i],a[n-i+1]);

    New_Seg();
    Build_SAM();

    for (int i=1; i<=m; i++)
    {
        scanf("%d%d%d%d",&A,&b,&c,&d);
        A=n-A+1;
        b=n-b+1;
        c=n-c+1;
        d=n-d+1;
        int ans=Binary();
        printf("%d\n",ans);
    }

    return 0;
}