Codeforces Round #736 (Div. 2) A~D

比赛链接：Here

1549A. Gregor and Cryptography

不难，观察一下就容易得知要想使得 令 即可。

1549B. Gregor and the Pawn Game

一开始想叉了，直接贪心就可以

const int N = 2e5 + 10;
char s[N], s1[N];
int main() {
    // cin.tie(nullptr)->sync_with_stdio(false);
    int _; for (cin >> _; _--;) {
        int n; cin >> n;
        scanf("%s%s", s + 1, s1 + 1);
        int ans = 0;
        for (int i = 1; i <= n; ++i) {
            if (s1[i] == '0') continue;
            if (s[i - 1] == '1') s[i - 1] = '2', ans++;
            else if (s[i] == '0') s[i] = '2', ans++;
            else if (s[i + 1] == '1') s[i + 1] = '2', ans++;
        }
        cout << ans << "\n";
    }
}

1549C. Web of Lies

看过权游的话大概很快就理解题意了（笑

如果一个贵族至少有一个朋友，并且他的朋友都拥有更高的权利时他就会被杀害

给定 种操作：

1. 增加贵族 和 的友谊

2. 减少贵族 和 的友谊

3. 计算以下过程的答案。
   过程：所有易受伤害的贵族同时被杀害，他们的友谊也随之结束。这样，新贵族就有可能变得脆弱。这个过程不断重复，直到没有贵族受到伤害。可以证明，这个过程将在有限的时间内结束。完成此过程后，您需要计算剩余贵族的数量。

看完题，感觉是并查集，不过模拟时发现就是一个 拓扑排序了，输出的答案也是当前 的个数

理解到是这个方面以后代码就很好写了

const int N = 2e5 + 10;
int deg[N];
void solve() {
    int n, m; cin >> n >> m;
    for (int i = 1, x, y; i <= m; ++i) {
        cin >> x >> y;
        if (x > y) swap(x, y);
        deg[x]++;
    }
    int ans = 0;
    for (int i = 1; i <= n; ++i) if (deg[i] == 0) ans ++;
    int q; cin >> q;
    while (q--) {
        int op, x, y; cin >> op;
        if (op == 1) {
            cin >> x >> y;
            if (x > y) swap(x, y);
            deg[x]++;
            if (deg[x] == 1)ans--;
        } else if (op == 2) {
            cin >> x >> y;
            if (x > y) swap(x, y);
            deg[x]--;
            if (deg[x] == 0)ans++;
        } else cout << ans << "\n";
    }
}

1549D.Integers Have Friends

不太会，赛后看了一下社区的解释

这道题的关键在于构建一个大小为 的差分数组 ，#card=math&code=D%5Bi%5D%20%3D%20abs%28a%5Bi%20%2B%201%5D%20-%20a%5Bi%5D%29)

同时如果给定的数组子序列是一个友元序列，每个差就是某个 的倍数（因为 数组每个元素值都不同，所以可以不用管 的情况）

然后针对上面的结论，可以将其转化为 GCD 问题，当且仅当 时， 为友元序列 .

为了解决这个问题，我们可以使用一个稀疏表或一个段树来查找从i开始的最大可能子数组，然后对所有子数组的答案进行最大化以得到最终答案。

【Code】

const int N = 2e5 + 10, LG = 17;
ll a[N], st[N][18], lg[N];
ll gcd(ll a, ll b) {
    if (b == 0)return a;
    else return gcd(b, a % b);
}
ll query(int l, int r) {
    int c = lg[r - l + 1];
    return gcd(st[l][c], st[r - (1 << c) + 1][c]);
}
int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int _; for (cin >> _; _--;) {
        int n; cin >> n;
        for (int i = 1; i <= n; i++) cin >> a[i];
        for (int i = 1; i < n; i++)a[i] = abs(a[i + 1] - a[i]); n--;
        for (int i = 1; i <= n; i++)st[i][0] = a[i];
        for (int j = 1; j <= LG; j++)
            for (int i = 1; i <= n - (1 << j) + 1; i++)
                st[i][j] = gcd(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
        lg[1] = 0; for (int i = 2; i <= n; i++)lg[i] = lg[i >> 1] + 1;
        int l = 1, ans = 0;
        for (int r = 1; r <= n; r++) {
            while (l <= r && query(l, r) == 1)l++;
            ans = max(ans, r - l + 1);
        }
        cout << ans + 1 << "\n";
    }
}

const int inf = 1e9+10;
const ll inf_ll = 1e18+10;
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define cmax(x, y) (x = max(x, y))
#define cmin(x, y) (x = min(x, y))
template<typename it, typename bin_op>
struct sparse_table {
    using T = typename remove_reference<decltype(*declval<it>())>::type;
    vector<vector<T>> t; bin_op f;
    sparse_table(it first, it last, bin_op op) : t(1), f(op) {
        int n = distance(first, last);
        t.assign(32-__builtin_clz(n), vector<T>(n));
        t[0].assign(first, last);
        for (int i = 1; i < t.size(); i++)
            for (int j = 0; j < n-(1<<i)+1; j++)
                t[i][j] = f(t[i-1][j], t[i-1][j+(1<<(i-1))]);
    }
    // returns f(a[l..r]) in O(1) time
    T query(int l, int r) {
        int h = floor(log2(r-l+1));
        return f(t[h][l], t[h][r-(1<<h)+1]);
    }
};
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    int t; cin >> t;
    while (t--) {
        ll n; cin >> n;
        vector<ll> a(n), d(n-1);
        for (int i = 0; i < n; i++)
            cin >> a[i];
        for (int i = 0; i < n-1; i++)
            d[i] = abs(a[i+1]-a[i]);
        sparse_table g(all(d), [](ll x, ll y){
            return __gcd(x, y);
        });
        int j = 0, ans = 1;
        for (int i = 0; i < n-1; i++) {
            while (j <= i && g.query(j, i) == 1) j++;
            cmax(ans, i-j+2);
        }
        cout << ans << "\n";
    }
}