WHU---1084 - 连续技 (后缀数组+二分)

Description

不管是什么武功,多少都会有一或两个连续技多次出现,这些连续技常常是发明该武功的人的习惯性动作,如果这些动作被对手分析出来了,就很容易被对手把握住先机。比如松风剑谱里面有一式叫做迎风傲骨是如下的动作:

劈 刺 削 刺 削 踢 刺 削 刺 削

很明显 刺-削 这个连续动作出现了4次,而 刺-削-刺-削 这个连续动作则出现了两次。

现在刘白宇弄到了一本魔教的掌法,想让你帮忙来分析其中最长的且出现尽量多的连续技,当然,他不好意思麻烦你太久,只想让你告诉它这个连续技有多长并且出现了多少次即可。

注意:只有一个动作或者只出现了一次的连续动作都不能被认为是连续技。

Input

输入包含多组数据,每组数据包含两行,第一行是一个数字N(1<=N<=1000),第二行有N个数字,每个数字代表了掌法里的一个基本动作,如劈、震、拍、点等等。

Output

对于输入的每个掌法,输出其中最长的连续技的长度以及出现的次数。如果不存在这样的连续技,就输出-1。

Sample Input

1

2

10

4 1 2 1 2 5 1 2 1 2

8

1 2 1 2 1 2 1 2

Sample Output

-1

4 2

4 2

Hint

Source

Gardon - DYGG’s contest 4

后缀数组+二分能够求出最长的重复子串,然后对于每一组的后缀,选取第一个或者最后一个后缀(按位置来说的先后关系)一定是最优的,所以遍历一遍就可以知道最多重复次数了

/*************************************************************************
    > File Name: WHU1084.cpp
    > Author: ALex
    > Mail: [email protected]
    > Created Time: 2015年04月10日 星期五 16时39分10秒
 ************************************************************************/

#include <functional>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <queue>
#include <stack>
#include <map>
#include <bitset>
#include <set>
#include <vector>

using namespace std;

const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const double eps = 1e-15;
typedef long long LL;
typedef pair <int, int> PLL;

int arr[1200];
int xis[1200];
int cnt;

int search(int val)
{
    int l = 1, r = cnt, mid;
    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (xis[mid] == val)
        {
            break;
        }
        else if (xis[mid] > val)
        {
            r = mid - 1;
        }
        else
        {
            l = mid + 1;
        }
    }
    return mid;
}

class SuffixArray
{
    public:
        static const int N = 1200;
        int init[N];
        int X[N];
        int Y[N];
        int Rank[N];
        int sa[N];
        int height[N];
        int buc[N];
        int LOG[N];
        int dp[N][20];
        int size;
        vector <int> task;

        void clear()
        {
            size = 0;
        }

        void insert(int n)
        {
            init[size++] = n;
        }

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

        void getsa(int m = 256) //m一般为最大值+1
        {
            init[size] = 0;
            int l, p, *x = X, *y = Y, n = size + 1;
            for (int i = 0; i < m; ++i)
            {
                buc[i] = 0;
            }
            for (int i = 0; i < n; ++i)
            {
                ++buc[x[i] = init[i]];
            }
            for (int i = 1; i < m; ++i)
            {
                buc[i] += buc[i - 1];
            }
            for (int i = n - 1; i >= 0; --i)
            {
                sa[--buc[x[i]]] = i;
            }
            for (l = 1, p = 1; l <= n && p < n; m = p, l *= 2)
            {
                p = 0;
                for (int i = n - l; i < n; ++i)
                {
                    y[p++] = i;
                }
                for (int i = 0; i < n; ++i)
                {
                    if (sa[i] >= l)
                    {
                        y[p++] = sa[i] - l;
                    }
                }
                for (int i = 0; i < m; ++i)
                {
                    buc[i] = 0;
                }
                for (int i = 0; i < n; ++i)
                {
                    ++buc[x[y[i]]];
                }
                for (int i = 1; i < m; ++i)
                {
                    buc[i] += buc[i - 1];
                }
                for (int i = n - 1; i >= 0; --i)
                {
                    sa[--buc[x[y[i]]]] = y[i];
                }
                int i;

                for (swap(x, y), x[sa[0]] = 0, p = 1, i = 1; i < n; ++i)
                {
                    x[sa[i]] = cmp(y, sa[i - 1], sa[i], l) ? p - 1 : p++;
                }
            }
        }

        void getheight()
        {
            int h = 0, n = size;
            for (int i = 0; i <= n; ++i)
            {
                Rank[sa[i]] = i;
            }
            height[0] = 0;
            for (int i = 0; i < n; ++i)
            {
                if (h > 0)
                {
                    --h;
                }
                int j =sa[Rank[i] - 1];
                for (; i + h < n && j + h < n && init[i + h] == init[j + h]; ++h);
                height[Rank[i] - 1] = h;
            }
        }   

        bool check(int k)
        {
            int l = sa[1], r = sa[1];
            for (int i = 1; i < size; ++i)
            {
                if (height[i] >= k)
                {
                    l = min(l, sa[i + 1]);
                    r = max(r, sa[i + 1]);
                }
                else
                {
                    if (r - l >= k)
                    {
                        return 1;
                    }
                    l = r = sa[i + 1];
                }
            }
            return 0;
        }

        void solve()
        {
            int l = 1, r = size / 2, mid;
            int ans = -1;
            while (l <= r)
            {
                mid = (l + r) >> 1;
                if (check(mid))
                {
                    l = mid + 1;
                    ans = mid;
                }
                else
                {
                    r = mid - 1;
                }
            }
            if (ans == -1)
            {
                printf("-1\n");
                return;
            }
            task.clear();
            task.push_back(sa[1]);
            int ret = 0;
            for (int i = 1; i < size; ++i)
            {
                if (height[i] >= ans)
                {
                    task.push_back(sa[i + 1]);
                }
                else
                {
                    sort(task.begin(), task.end());
                    int tmp1 = 1, tmp2 = 1, isize = task.size(), last = task[0];
                    for (int j = 1; j < isize; ++j)
                    {
                        if (task[j] - last >= ans)
                        {
                            ++tmp1;
                            last = task[j];
                        }
                    }
                    last = task[isize - 1];
                    for (int j = isize - 2; j >= 0; --j)
                    {
                        if (last - task[j] >= ans)
                        {
                            ++tmp2;
                            last = task[j];
                        }
                    }
                    ret = max(ret, max(tmp1, tmp2));
                    task.clear();
                    task.push_back(sa[i + 1]);
                }
            }
            printf("%d %d\n", ans, ret);

        }
}SA;

int main()
{
    int n;
    while (~scanf("%d", &n))
    {
        SA.clear();
        cnt = 0;
        for (int i = 0; i < n; ++i)
        {
            scanf("%d", &arr[i]);
            xis[++cnt] = arr[i];
        }
        sort (xis + 1, xis + 1 + cnt);
        cnt = unique(xis + 1, xis + 1 + cnt) - xis - 1;
        for (int i = 0; i < n; ++i)
        {
            int val = search(arr[i]);
            SA.insert(val);
        }
        SA.getsa(cnt + 1);
        SA.getheight();
        SA.solve();
    }
    return 0;
}
时间: 2024-10-25 23:15:24

WHU---1084 - 连续技 (后缀数组+二分)的相关文章

hdu 5030 Rabbit&#39;s String(后缀数组&amp;二分)

Rabbit's String Time Limit: 40000/20000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 288    Accepted Submission(s): 108 Problem Description Long long ago, there lived a lot of rabbits in the forest. One day, the

BZOJ 3230: 相似子串( RMQ + 后缀数组 + 二分 )

二分查找求出k大串, 然后正反做后缀数组, RMQ求LCP, 时间复杂度O(NlogN+logN) --------------------------------------------------------------------- #include<cstdio> #include<algorithm> #include<cstring> #include<cctype> using namespace std; typedef long long

hdu 5008(2014 ACM/ICPC Asia Regional Xi&#39;an Online ) Boring String Problem(后缀数组&amp;二分)

Boring String Problem Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 219    Accepted Submission(s): 45 Problem Description In this problem, you are given a string s and q queries. For each que

【bzoj4310】跳蚤 后缀数组+二分

题目描述 很久很久以前,森林里住着一群跳蚤.一天,跳蚤国王得到了一个神秘的字符串,它想进行研究. 首先,他会把串分成不超过 k 个子串,然后对于每个子串 S,他会从S的所有子串中选择字典序最大的那一个,并在选出来的 k 个子串中选择字典序最大的那一个.他称其为“魔力串”. 现在他想找一个最优的分法让“魔力串”字典序最小. 输入 第一行一个整数 k. 接下来一个长度不超过 105 的字符串 S. 输出 输出一行,表示字典序最小的“魔力串”. 样例输入 13 bcbcbacbbbbbabbacbcb

poj 3261 Milk Patterns 后缀数组+二分

1 /*********************************************************** 2 题目: Milk Patterns(poj 3261) 3 链接: http://poj.org/problem?id=3261 4 题意: 给一串数字,求这些数字中公共子串个数大于k的 5 最长串. 6 算法: 后缀数组+二分 7 ***********************************************************/ 8 #incl

POJ1743---Musical Theme(后缀数组+二分)

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 music

POJ 1743 Musical Theme(后缀数组+二分答案)

[题目链接] http://poj.org/problem?id=1743 [题目大意] 给出一首曲子的曲谱,上面的音符用不大于88的数字表示, 现在请你确定它主旋律的长度,主旋律指的是出现超过一次, 并且长度不小于5的最长的曲段,主旋律出现的时候并不是完全一样的, 可能经过了升调或者降调,也就是说, 是原来主旋律所包含的数字段同时加上或者减去一个数所得, 当然,两段主旋律之间也是不能有重叠的,现在请你求出这首曲子主旋律的长度, 如果不存在请输出0. [题解] 首先要处理的是升调和降调的问题,由

POJ 3080 Blue Jeans(后缀数组+二分答案)

[题目链接] http://poj.org/problem?id=3080 [题目大意] 求k个串的最长公共子串,如果存在多个则输出字典序最小,如果长度小于3则判断查找失败. [题解] 将所有字符串通过拼接符拼成一个串,做一遍后缀数组,二分答案,对于二分所得值,将h数组大于这个值的相邻元素分为一组,判断组内元素是否覆盖全字典,是则答案成立,对于答案扫描sa,输出第一个扫描到的子串即可. [代码] #include <cstdio> #include <cstring> #inclu

HDU5008 Boring String Problem(后缀数组 + 二分 + 线段树)

题目 Source http://acm.hdu.edu.cn/showproblem.php?pid=5008 Description In this problem, you are given a string s and q queries. For each query, you should answer that when all distinct substrings of string s were sorted lexicographically, which one is