poj1743 Musical Theme

地址：http://poj.org/problem?id=1743

题目：

Musical Theme

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 28675		Accepted: 9674

Description

A musical melody is represented as a sequence of N (1<=N<=20000)notes that are integers in the range 1..88, each representing a key on the piano. It is unfortunate but true that this representation of melodies ignores the notion of musical timing; but, this programming task is about notes and not timings. 
Many composers structure their music around a repeating &qout;theme&qout;, which, being a subsequence of an entire melody, is a sequence of integers in our representation. A subsequence of a melody is a theme if it: 

• is at least five notes long 
• appears (potentially transposed -- see below) again somewhere else in the piece of music 
• is disjoint from (i.e., non-overlapping with) at least one of its other appearance(s)

Transposed means that a constant positive or negative value is added to every note value in the theme subsequence. 
Given a melody, compute the length (number of notes) of the longest theme. 
One second time limit for this problem's solutions! 

Input

The input contains several test cases. The first line of each test case contains the integer N. The following n integers represent the sequence of notes. 
The last test case is followed by one zero. 

Output

For each test case, the output file should contain a single line with a single integer that represents the length of the longest theme. If there are no themes, output 0.

Sample Input

30
25 27 30 34 39 45 52 60 69 79 69 60 52 45 39 34 30 26 22 18
82 78 74 70 66 67 64 60 65 80
0

Sample Output

5

Hint

Use scanf instead of cin to reduce the read time.

Source

LouTiancheng@POJ

思路：

　　论文上的题目，相邻数做差后对数组求后缀数组（注意此时差可能为负数，所以加上100保证非负）

　　然后二分长度，check时把height分组判断即可

　　

　　补个后缀自动机做法：

　　先明确几点：

　　　　1.每个状态的代表的是endpos集合相同的后缀集合，记max(s)为状态s的endpos集合中长度最长的后缀，min(x)为最小长度的后缀。

　　则endpos集合中的所有后缀都是max(x)的后缀，这说明endpos是长度为一段连续区间的后缀集合。

　　　　2.且endpos(fa[p])是最小的包含endpos(p)，且max(fa[p])=min(p)+1。

　　　　3.从root出发的所能到达的状态都是子串，且最长不相交子串就在某一状态的endpos集合中。

　　所以对于每个状态记录endpos集合中的最大值最小值，用l[p],r[p]代表。

　　拓扑排序后沿反向fa指针dp可以得出每个状态的l[p],r[p]值。

　　如果r[p]-l[p]>len[fa[p]]则说明endpos(p)中存在不相交的字符串，长度为min(r[p]-l[p],len[p])。

　　对所有状态扫一遍求出最大值即可。

 后缀数组做法：

#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <algorithm>

const int N = 20005;
int sa[N],s[N],wa[N], wb[N], ws[N], wv[N];
int rank[N], height[N];

bool cmp(int r[], int a, int b, int l)
{
    return r[a] == r[b] && r[a+l] == r[b+l];
}

void da(int r[], int sa[], int n, int m)
{
    int i, j, p, *x = wa, *y = wb;
    for (i = 0; i < m; ++i) ws[i] = 0;
    for (i = 0; i < n; ++i) ws[x[i]=r[i]]++;
    for (i = 1; i < m; ++i) ws[i] += ws[i-1];
    for (i = n-1; i >= 0; --i) sa[--ws[x[i]]] = i;
    for (j = 1, p = 1; p < n; j *= 2, m = p)
    {
        for (p = 0, 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 < n; ++i) wv[i] = x[y[i]];
        for (i = 0; i < m; ++i) ws[i] = 0;
        for (i = 0; i < n; ++i) ws[wv[i]]++;
        for (i = 1; i < m; ++i) ws[i] += ws[i-1];
        for (i = n-1; i >= 0; --i) sa[--ws[wv[i]]] = y[i];
        for (std::swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; ++i)
            x[sa[i]] = cmp(y, sa[i-1], sa[i], j) ? p-1 : p++;
    }
}

void calheight(int r[], int sa[], int n)
{
    int i, j, k = 0;
    for (i = 1; i <= n; ++i) rank[sa[i]] = i;
    for (i = 0; i < n; height[rank[i++]] = k)
        for (k?k--:0, j = sa[rank[i]-1]; r[i+k] == r[j+k]; k++);
}
bool check(int len,int x)
{
    int mx=sa[1],mi=sa[1];
    for(int i=2;i<=len;i++)
    {
        if(height[i]<x)
        {
            if(mx-mi>=x)
                return 1;
            mx=mi=sa[i];
        }
        else
        {
            mx=std::max(sa[i],mx);
            mi=std::min(sa[i],mi);
        }
    }
    return mx-mi>=x;
}
int main()
{
    int n;
    while(scanf("%d",&n)&&n)
    {
        int x,ls,len=0;
        scanf("%d",&ls);
        for(int i=0;i<n-1;i++)
            scanf("%d",&x),s[len++]=x-ls+100,ls=x;
        s[len]=0;
        da(s,sa,len+1,200);
        calheight(s,sa,len);
        int l=5,r=n/2,ans=0;
        while(l<=r)
        {
            int mid=l+r>>1;
            if(check(len,mid-1))
                ans=mid,l=mid+1;
            else
                r=mid-1;
        }
        printf("%d
",ans);
    }
    return 0;
}

 sam做法：

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;



struct SAM
{
    static const int MAXN = 20002<<1;//大小为字符串长度两倍
    static const int LetterSize = 180;

    int tot, last, ch[MAXN][LetterSize], fa[MAXN], len[MAXN];
    int sum[MAXN], tp[MAXN], cnt[MAXN]; //sum,tp用于拓扑排序，tp为排序后的数组
    int l[MAXN],r[MAXN];
    void init( void)
    {
        last = tot = 1;
        len[1] = 0;
        memset(ch,0,sizeof ch);
        memset(fa,0,sizeof fa);
        memset(cnt,0,sizeof cnt);
        memset(l,0x3f3f3f,sizeof l);
        memset(r,0,sizeof r);
    }

    void add( int x)
    {
        int p = last, np = last = ++tot;
        l[np] = r[np] = len[np] = len[p] + 1, cnt[last] = 1;
        while( p && !ch[p][x]) ch[p][x] = np, p = fa[p];
        if( p == 0)
            fa[np] = 1;
        else
        {
            int q = ch[p][x];
            if( len[q] == len[p] + 1)
                fa[np] = q;
            else
            {
                int nq = ++tot;
                memcpy( ch[nq], ch[q], sizeof ch[q]);
                len[nq] = len[p] + 1, fa[nq] = fa[q], fa[q] = fa[np] = nq;
                while( p && ch[p][x] == q)  ch[p][x] = nq, p = fa[p];
            }
        }
    }

    void toposort( void)
    {
        for(int i = 1; i <= len[last]; i++)   sum[i] = 0;
        for(int i = 1; i <= tot; i++)   sum[len[i]]++;
        for(int i = 1; i <= len[last]; i++)   sum[i] += sum[i-1];
        for(int i = 1; i <= tot; i++)   tp[sum[len[i]]--] = i;
        for(int i = tot; i; i--)
        {
            l[fa[tp[i]]]=min(l[fa[tp[i]]],l[tp[i]]);
            r[fa[tp[i]]]=max(r[fa[tp[i]]],r[tp[i]]);
        }
        int ans=0;
        for(int i = 1; i <= tot; i++)
        if(r[i]-l[i]>len[fa[i]])
            ans=max(min(r[i]-l[i],len[i]),ans);
        if(ans<4) ans=-1;
        printf("%d
",ans+1);
    }
} sam;


int main(void)
{
    int n,pre;
    while(scanf("%d",&n)&&n)
    {
        sam.init();
        scanf("%d",&pre);
        for(int i=2,now;i<=n;i++)
            scanf("%d",&now),sam.add(now-pre+87),pre=now;
        sam.toposort();
    }
    return 0;
}