String 最长公共前缀属性

我正在研究后缀数组及其用于计算两个后缀的最长公共前缀的用法

消息人士说,

“两个后缀之间的lcp是数组中它们之间所有相邻后缀对的lcp的最小值”

i、 e.

lcp（x，y）=min{lcp（x，x+1），lcp（x+1，x+2），…，lcp（y-1，y）}

其中x和y是字符串的两个索引，字符串的两个后缀从这里开始

我不相信string

“abca”

示例中的语句

lcp（1,4）=1

（考虑基于1的索引）

但是如果我应用上面的等式

lcp（1,4）=min{lcp（1,2），lcp（2,3），lcp（3,4）}

我认为

lcp（1,2）=0

因此，根据方程式，答案必须是

0

---

我在什么地方弄错了吗？

我认为源引用的索引不是字符串本身的索引，而是排序后缀的索引

a
abca
bca
ca

因此

---

通过简单地计算数组中所有相邻后缀对的LCP的最小值，无法找到任意两个后缀的LCP

我们可以计算任何后缀（i，j）的LCP 在以下方面的帮助下：

LCP(suffix i,suffix j)=LCP[RMQ(i + 1; j)]  

---

另请注意

（我只想确认我在以下问题上是否正确：对于后缀x和y的任何起始索引，lcp（x，y）=min{lcp（x，x+1，）…lcp（y-1，y）}或x和y也应该类似于x'和y'，其中x'是后缀x的排序位置，y'是siffix y的排序位置，即lcp（x'，y'）=min（lcp（x'，x'+1）…lcp（y'-1，y'）}？
LCP(suffix i,suffix j)=LCP[RMQ(i + 1; j)]  

Details:

void calculateadjacentsuffixes(int n)
{
    for (int i=0; i<n; ++i) Rank[suffixArray[i]] = i;
    Height[0] = 0;
    for (int i=0, h=0; i<n; ++i)
    {
        if (Rank[i] > 0)
        {
            int j = suffixArray[Rank[i]-1];
            while (i + h < n && j + h < n && str[i+h] == str[j+h])
            {
                h++;
            }
            Height[Rank[i]] = h;
            if (h > 0) h--;
        }
    }
}

void preprocesses(int N)
{
    int i, j;

    //initialize M for the intervals with length 1
    for (i = 0; i < N; i++)
        M[i][0] = i;

    //compute values from smaller to bigger intervals
    for (j = 1; 1 << j <= N; j++)
    {
        for (i = 0; i + (1 << j) - 1 < N; i++)
        {
            if (Height[M[i][j - 1]] < Height[M[i + (1 << (j - 1))][j - 1]])
            {
                M[i][j] = M[i][j - 1];
            }
            else
            {
                M[i][j] = M[i + (1 << (j - 1))][j - 1];
            }
        }
    }
}  

int LCP(int i,int j)
{
    /*Make sure we send i<j always */
    /* By doing this ,it resolve following
    suppose ,we send LCP(5,4) then it converts it to LCP(4,5)
    */
    if(i>j)
        swap(i,j);

    /*conformation over*/

    if(i==j)
    {
        return (Length_of_str-suffixArray[i]);
    }
    else
    {
        return Height[RMQ(i+1,j)];
        //LCP(suffix i,suffix j)=LCPadj[RMQ(i + 1; j)] 
        //LCPadj=LCP of adjacent suffix =Height.
    }
}

int RMQ(int i,int j)
{
    int k=log((double)(j-i+1))/log((double)2);
    int vv= j-(1<<k)+1 ;
    if(Height[M[i][k]]<=Height[ M[vv][ k] ])
        return M[i][k];
    else
        return M[ vv ][ k];
}