Codeforces Round #736 (Div. 2) A~D
比赛链接：Here
1549A. Gregor and Cryptography
不难，观察一下就容易得知要想使得 \(p\pmod a = p\pmod b\) 令 \(a = 2,b=p - 1\) 即可。
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
看过权游的话大概很快就理解题意了（笑
\(n\) 个贵族，每个贵族有力量(权力) \(i\) ；
\(m\) 个友谊关系
如果同时满足以下两个条件，则贵族被定义为易受攻击：
- 贵族至少有一个朋友
- 该贵族的所有朋友都拥有更高的权力。
三种操作：
-
增加贵族 \(u\) 和 \(v\)之间的友谊。
-
消除贵族 \(u\) 和 \(v\)之间的友谊。
-
计算以下过程的答案。
过程：所有易受伤害的贵族同时被杀害，他们的友谊也随之结束。这样，剩余贵族就有可能变得脆弱。这个过程不断重复，直到没有贵族受到伤害。可以证明，这个过程将在有限的时间内结束。完成此过程后，您需要计算剩余贵族的数量。
但是该过程的结果不会在查询之间传递，也就是说，每个过程都以所有贵族都处于“活着”的状态！
看完题，感觉是并查集，不过模拟时发现就是一个 拓扑排序了，输出的答案也是当前 \(deg_i = 0\) 的个数
理解到是这个方面以后代码就很好写了
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
不太会，赛后看了一下社区的解释
这道题的关键在于构建一个大小为 \(n\) 的差分数组 \(D\) ，\(D[i] = abs(a[i + 1] - a[i])\)
同时如果给定的数组子序列是一个友元序列，每个差就是某个 \(m\) 的倍数（因为 \(a\) 数组每个元素值都不同，所以可以不用管 \(D[i] = 0\) 的情况）
然后针对上面的结论，可以将其转化为 GCD 问题，当且仅当 \(m = \gcd(D[i,...,j-1] > 1\) 时，\(a[i,...j]\) 为友元序列 .
为了解决这个问题，我们可以使用一个稀疏表或一个段树来查找从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";
}
}
