2021牛客多校1——H：Hash Function（FFT）

题面

题意：

• 给定 n 个互不相同的数，找一个最小的模域，使得它们在这个模域下互不相同。
• 简单来说就是对其n个互不相同的数进行哈希，并且不发生哈希冲突。

前置知识：

• 快速傅里叶变化（FFT）
• 快速傅里叶变换 - OI Wiki (oi-wiki.org)

思路:

• 如果$a$​ 与$b$​ 模$m$​的余数相同，当且仅当$|a-b|$​能被$m$​​整除，那么问题就转变为找到最小的$m$​，它不是任意一个$|a_i-a_j|$​的约数。

• 由于$1\le |a_i-a_j|\le 500000$​，如果想知道每一种差值是否存在，只需要枚举每个$m$及其它的倍数就可以在$O(nlogn)$的时间复杂度下找到最优解。​​

• 设 $P_i $为数值 i 是否存在，将 P 与 {P_(500000-0),P_(500000-1),…,P_0} 卷积，判断对应位置是否大于 0 以确认每一种差值是否存在。

  利用 FFT/NTT 加速上述过程。总复杂度 O(Nlog N)。

代码:

//FFT加速多项式乘法

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int Lim = 1 << 20;
const int MAXN = 5e5 + 7;
const int MAXARR = 1 << 21;
const double PI = acos(-1.0);
struct Complex {
    double x, y;
    Complex(double _x = 0.0, double _y = 0.0) {
        x = _x;
        y = _y;
    }
    Complex operator-(const Complex &b) const {
        return Complex(x - b.x, y - b.y);
    }
    Complex operator+(const Complex &b) const {
        return Complex(x + b.x, y + b.y);
    }
    Complex operator*(const Complex &b) const {
        return Complex(x * b.x - y * b.y, x * b.y + y * b.x);
    }
};
/*
 * 进行 FFT 和 IFFT 前的反置变换
 * 位置 i 和 i 的二进制反转后的位置互换
 *len 必须为 2 的幂
 */
void change(Complex y[], int len) {
    int i, j, k;
    for (int i = 1, j = len / 2; i < len - 1; i++) {
        if (i < j) swap(y[i], y[j]);
        // 交换互为小标反转的元素，i<j 保证交换一次
        // i 做正常的 + 1，j 做反转类型的 + 1，始终保持 i 和 j 是反转的
        k = len / 2;
        while (j >= k) {
            j = j - k;
            k = k / 2;
        }
        if (j < k) j += k;
    }
}
/*
 * 做 FFT
 *len 必须是 2^k 形式
 *on == 1 时是 DFT，on == -1 时是 IDFT
 */
void fft(Complex y[], int len, int on) {
    change(y, len);
    for (int h = 2; h <= len; h <<= 1) {
        Complex wn(cos(2 * PI / h), sin(on * 2 * PI / h));
        for (int j = 0; j < len; j += h) {
            Complex w(1, 0);
            for (int k = j; k < j + h / 2; k++) {
                Complex u = y[k];
                Complex t = w * y[k + h / 2];
                y[k] = u + t;
                y[k + h / 2] = u - t;
                w = w * wn;
            }
        }
    }
    if (on == -1) {
        for (int i = 0; i < len; i++) {
            y[i].x /= len;
        }
    }
}

Complex a[MAXARR], b[MAXARR], c[MAXARR];
bool can[MAXARR];
int main() {
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        int x;
        scanf("%d", &x);
        a[x].x = 1;       //把x^i的系数设置为1
        b[MAXN - x].x = 1;//把x^(maxn-x)的系数设置为1
    }
    //当我们把两个多项式相乘,例如第一个多项式中含有1,3,5,第二个多显示为（10-1)  (10-3)   (10-5)
    //当这两个多项式相乘,可以得到
    //(1+10-3) (1+10-3) (1+10-5)
    //(3+10-1) (3+10-3) (3+10-5)
    //(5+10-1) (5+10-3) (5+10-5)
    //这时候我们记录abs(10-(1+10-1))的时候其实就是记录了ai与aj可以构成的差值。这时候我们就可以使用FFT来加速这一过程
    fft(a, Lim, 1);
    fft(b, Lim, 1);
    for (int i = 0; i < Lim; i++) {
        c[i] = a[i] * b[i];
    }
    fft(c, Lim, -1);
    for (int i = 0; i <= Lim; i++) {
        int x = (int) floor(c[i].x + 0.5);
        if (x > 0) {
            can[abs(i - MAXN)] = 1;
        }
    }
    for (int i = n; i <= MAXN; i++) {
        bool isok = true;
        for (int j = i; j <= MAXN; j += i) {
            if (can[j]) {
                isok = false;
                break;
            }
        }
        if (isok) {
            printf("%d\n", i);
            break;
        }
    }
}