楼教主男人八题(第三题)

按照通过数排序，今天开搞 1743 Musical Theme。

题目链接

http://poj.org/problem?id=1743

题目描述

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 theme, 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!

输入

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.

输出

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.

样例输入

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

样例输出

5

样例解释

本题大意是，给出一个长度为 $n$ 的数组 $seq$，$n\in [1,20000]$，$se{q}_i\in [1,88]$。需要求出两个不重叠的，相似的子数组的最大长度。如果最大长度不小于$5$，则输出最大长度，否则输出 0。

相似的定义是：两个子数组 $A,B$ 长度相等，且存在整数 $x$，将每个 $A_i$ 加上 $x$ 后可以得到 $B$，即$A_i+x=B_i$。

比如样例中的 $34,30,26,22,18$ 和 $82,78,74,70,66$ 就是相似的。前者将每个元素都加上 $48$ 即可得到后者。而且找不到更长的相似子数组，所以输出是 $5$。

题解

主流的解法是利用后缀数组求解答案，今天介绍一个非主流的解法：二分+哈希，时间复杂度$O(n\ast \lg n)$。

首先，讲一下如何利用哈希快速判定两个数组相似。

如果两个数组 $A$ 和 $B$ 相似，设下标从 0 开始，不难发现，对于 $i\ge 1$ 有：
$$B_i-B_{i-1}=A_i-A_{i-1}$$

比如，两个数组 $1,3,4,7,5$ 和 $3,5,6,9,7$ 是相似的，前者加上 $2$ 可以得到后者。

分别求出两数组相邻项作差之后的数组：

• $1,3,4,7,5$ -> $1,2,1,3,-2$
• $3,5,6,9,7$ -> $3,2,1,3,-2$

不难发现，除首位外的其他位均相等。其实相邻项作差描述的是变化的规律。

将 $seq$ 的相邻项作差，得到 $se{q}^{\prime }$，那么问题变成了：在 $se{q}^{\prime }$ 中寻找两个不重叠的且不相邻的且相同的的子数组，其长度加上一，则等价于 $seq$ 中的相似子数组的长度。

加了一个不相邻的限制，是因为相同子数组丢失了相似子数组的首位，所以不能相邻。如果相邻，则相似子数组就重叠了。

先介绍一中线性时间计算 $n-c+1$ 个长度为 $c$ 的子数组的哈希值的计算方法。

不妨设 $h_i$ 是以 $se{q}_i^{\prime }$ 为起始位置的长度 $c$ 的子数组的哈希值。

特殊的，当$i=0$ 时有：
$h_0={\sum }_{j=0}^{c-1}se{q}_j\ast s^{c-j-1}$。

一般的，当 $i\ne 0$ 时有：
$h_i=h_{i-1}\ast s-se{q}_{i-1}\ast s^c+se{q}_{i+c-1}$

$s$ 一般为大素数，比如 $100007$ 等。

关于哈希冲突的问题：本题中$n$的上限为 20000，如果用 用 uint64_t 存储哈希值的话，相当于把两万个球随机分到约$4\ast 10^{10}$个槽里面，一个槽分到多个球的概率还是很小的。

现在我们有了用一个整数表示一个子数组的能力，那么问题就变成了，对于每个 $h_i$ 判断在 $h_0,h_1,...,h_{i-c}$ 中是否出现过。如果出现过则说明在 $seq$ 中存在长度为 $c+1$ 的相似子数组。

还有一个问题，$c$ 的值如何确定呢？那当然是二分咯。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>

using namespace std;

int seq[20000];

typedef unsigned long long uint64_t;

uint64_t seed = 10000007;
uint64_t pow_seed[20001];

struct Node {
  uint64_t hash;
  int pos;
  int next;
}node_pool[20000];

int top;

int head[20000];

bool find(uint64_t hash, int pos, int n, int c) {
  int slot = hash % n;
  for (int i = head[slot]; i != -1; i = node_pool[i].next) {
    if (node_pool[i].hash == hash && node_pool[i].pos + c < pos) {
      return true;
    }
  }
  return false;
}

void insert(uint64_t hash, int pos, int n) {
  int slot = hash % n;
  node_pool[top].hash = hash;
  node_pool[top].pos = pos;
  node_pool[top].next = head[slot];
  head[slot] = top++;
}

bool check(int *seq, int n, int c) {
  memset(head, -1, sizeof(int)*n);
  top = 0;

  uint64_t hash = 0;

  for (int i = 0; i < n; i++) {
    (hash *= seed) += seq[i];
    if (i >= c) {
      hash -= seq[i-c] * pow_seed[c];
      if (find(hash, i, n, c)) {
        return true;
      }
      insert(hash, i, n);
    }
  }

  return false;
}

int main() {
  pow_seed[0] = 1;
  for (int i = 1; i <= 10000; i++) {
    pow_seed[i] = pow_seed[i-1]*seed;
  }
  int n;
  while (scanf("%d", &n) != EOF && n != 0) {
    for (int i = 0; i < n; i++) {
      scanf("%d", seq + i);
    }
    for (int i = n-1; i >= 1; i--) {
      seq[i] -= seq[i-1];
    }
    //check(seq, n, 2);
    int L = 3, R = n/2;
    while (L <= R) {
      int mid = (L+R) >> 1;
      if (check(seq, n, mid)) {
        L = mid+1;
      } else {
        R = mid-1;
      }
    }
    printf("%d\n", L < 4 ? 0 : L);
  }
  return 0;
}