Codeforces 338D 对线性同余方程组的一点理解

题意有个大小n*m（两个数都不大于10的12次幂）的表格，table[i][j]的值为gcd(i, j)。给出k（<=10000)个数

判断这个序列是否在表格中的某一列出现过

考虑解满足的条件

显然行必须为序列中所有数的倍数，那么我们先考虑最小公倍数

此时对于列，有

y % a1 == 0;

(y + 1) % a2 == 0;

...

(y + k - 1) % ak == 0;

那么我们可以求解线性同余方程组，得到一个最小的满足条件的y（或无解）

有解的情况下，我们还需要检验对应位置是否有table[x][y] == gcd(x, y)

那如果检验结果为假呢，我们要怎么考虑改变x或y去获得答案呢

由于特别的，每个方程的变量y的系数都为1，那么最终得到答案形式中y≡b(mod m) 中的m必然为序列a的最小公倍数。

考虑只不改变行，只改变列的起始位置是否有解呢？不行，因为为了满足方程组的解，新的y必然与当前y相差m（也等同与最小公倍数）的整数倍，

根据辗转相处法我们知道gcd(x, y) == gcd(x, y + x);

考虑只改变行，不改变列呢。答案也是否定的，因为如果改变某位置的gcd变为k倍，那么之前的行必然不是a序列的最小公倍数（反证即可）

最后同时增加行和列的情况，可以逐步转为到只增加行或列的情况，所以也无需判断

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;
const int maxn = 1e4 + 10;

LL M[maxn];
LL n, m, k;
LL lcm;

LL gcd(LL x, LL y) {return y == 0 ? x : gcd(y, x % y);}

LL extgcd(LL a, LL b, LL &x, LL &y) {
    LL d = a;
    if (b) {
        extgcd(b, a % b, y, x);
        y -= (a / b) * x;
    } else {
        x = 1; y = 0;
    }
    return d;
}

LL mod_inverse(LL a, LL m) {
    LL x, y;
    extgcd(a, m, x, y);
    return (m + x % m) % m;
}

pair<LL, LL> LC(LL M[]) {
    LL x = 0, m = 1;
    for (int i = 0; i < k; i++) {
        LL a = m;
        LL b = (-i) - x;
        LL d = gcd(M[i], a);
        if (b % d != 0) return make_pair(LL(-1), -1);
        LL t = b / d * mod_inverse(a / d, M[i] / d) % (M[i] / d);
        x = x + m * t;
        m *= M[i] / d;
    }
    return make_pair((m + x % m) % m, m);
}

bool solve() {
    pair<LL, LL> P = LC(M);
    LL res = P.first;

//    printf("lcm: %lld
", lcm);
//    printf("CRT: %lld %lld
", P.first, P.second);

    if (res == 0) res += P.second;
    if (res < 0 || res + k - 1 > m) {
        return false;
    }
    bool flag = true;
    for (int i = 0; i < k && flag; i++) {
        if (gcd(lcm, res + i) != M[i]) flag = false;
    }
    return flag;
}

int main() {
    
    scanf("%lld%lld%lld", &n, &m, &k);
    lcm = 1;
    for (int i = 0; i < k; i++) {
        scanf("%lld", &M[i]);
        lcm = lcm / gcd(lcm, M[i]) * M[i];
    }
    if (lcm > n) {
        puts("NO");
    } else {
        if (solve()) {
            puts("YES");
        } else {
            puts("NO");
        }
    }
    return 0;
}