A. Li Hua and Maze
给出两个不相邻的点，最少需要堵上几个方格，才能使得两个方格之间不能互相到达。
思路：显然，对于不邻任何边界的方格来说，最少需要的是4，即上下左右都堵上；邻一个边界就-1，两个方格取一下最小值即可。
AC Code：
#include <bits/stdc++.h>
typedef long long ll;
const int N = 2e5 + 5;
int t, n, m, x1, y1, x2, y2;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
std::cin >> t;
while(t --) {
std::cin >> n >> m;
std::cin >> x1 >> y1 >> x2 >> y2;
int ans1 = 4, ans2 = 4;
if(x1 == 1 || x1 == n) ans1 --;
if(y1 == 1 || y1 == m) ans1 --;
if(x2 == 1 || x2 == n) ans2 --;
if(y2 == 1 || y2 == m) ans2 --;
std::cout << std::min(ans1, ans2) << '\n';
}
return 0;
}B. Li Hua and Pattern
给出一个n*n的矩阵，操作k次，判断能否使得当前矩形和旋转180°后的图形完全相同。每次操作是将格子的颜色翻转。
思路：显然，将格子分为四部分，对角的两两都应该中心对称。对于两两方格的两个坐标有相加等于n+1的关系，判断一下即可。注意，对于奇数时的中心那一条，应该等于同一条线上的另一部分。对于操作次数k，如果小于不同的方格数，则一定不满足条件；若是大于k，n是偶数时，k-cnt必须是偶数。
AC Code：
#include <bits/stdc++.h>
typedef long long ll;
const int N = 1e3 + 5;
int t, n, k;
int a[N][N];
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
std::cin >> t;
while(t --) {
std::cin >> n >> k;
for(int i = 1; i <= n; i ++) {
for(int j = 1; j <= n; j ++) {
std::cin >> a[i][j];
}
}
int m = (n + 1) / 2;
int cnt = 0;
for(int i = 1; i <= m; i ++) {
for(int j = 1; j <= m; j ++) {
if(a[i][j] != a[1 + n - i][1 + n - j])
cnt ++;
}
}
for(int i = m + 1; i <= n; i ++) {
for(int j = 1; j <= n / 2; j ++) {
if(a[i][j] != a[1 + n - i][1 + n - j])
cnt ++;
}
}
if(k < cnt || (k - cnt) % 2 && n % 2 == 0)
std::cout << "NO" << '\n';
else
std::cout << "YES" << '\n';
}
return 0;
}C. Li Hua and Chess
在n*m的方格中猜一个确定位置。每次可以询问目标位置和询问位置的距离，注意，距离是指经过八个方向移动的最小距离，在三次询问之内找到答案。
思路：观察移动方式，我们可以发现对于一个位置来说，向外扩展x圈上的点到中心点的距离都是x。那么我们可以先询问(1, 1)点，然后再问(1 + len, 1 + len)点，当然，注意和边界的判断。那么答案位置必然在第二次询问的点的正上方或者正左方。
AC Code：
#include <bits/stdc++.h>
typedef long long ll;
const int N = 1e3 + 5;
int t, n, m;
int ask(int x, int y) {
std::cout << "? " << x << ' ' << y << '\n';
std::cout.flush();
int dis;
std::cin >> dis;
return dis;
}
void work() {
int a = 1, b = 1;
int len = ask(a, b);
if(!len) {
std::cout << "! " << a << ' ' << b << '\n';
return;
}
a = std::min(a + len, n), b = std::min(b + len, m);
len = ask(a, b);
if(!len) {
std::cout << "! " << a << ' ' << b << '\n';
return;
}
if(len >= a && len < b) {
std::cout << "! " << a << ' ' << b - len << '\n';
return;
}
else if(len >= b && len < a) {
std::cout << "! " << a - len << ' ' << b << '\n';
return;
}
int aa = a, bb = b, ll = len;
a -= len;
len = ask(a, b);
if(!len) {
std::cout << "! " << a << ' ' << b << '\n';
return;
}
std::cout << "! " << aa << ' ' << bb - ll << '\n';
}
int main() {
// std::ios::sync_with_stdio(false);
// std::cin.tie(0);
// std::cout.tie(0);
std::cin >> t;
while(t --) {
std::cin >> n >> m;
work();
std::cout.flush();
}
return 0;
}D. Li Hua and Tree
给出一棵树，进行k次操作，操作1是计算x的子树权值的和，操作2是交换x和x的重子，即断开x和x的父节点之间的边，链接x的重子和x的父节点之间的边。定义重子是x中具有最大子树的子节点，若有多个点满足条件，则重子是索引最小的那个点。
思路：模拟整个过程即可，注意细节。
AC Code：
#include <bits/stdc++.h>
typedef long long ll;
#define int long long
const int N = 1e5 + 5;
int n, m;
std::vector<int> vec[N];
int a[N], w[N], fa[N], val[N];
struct node{
int w, id;
bool operator<(const node &a) const{
if (w != a.w) return w > a.w;
return id < a.id;
}
};
std::set<node> s[N];
void DFS(int u, int f){
val[u] = a[u];
w[u] = 1;
for(auto v : vec[u]){
if (v == f) continue;
fa[v] = u;
DFS(v, u);
val[u] += val[v];
w[u] += w[v];
s[u].insert({w[v], v});
}
}
signed main(){
std::cin.tie(0);
std::cout.tie(0);
std::ios::sync_with_stdio(0);
std::cin >> n >> m;
for(int i = 1; i <= n; i ++) {
std::cin >> a[i];
}
for(int i = 1; i < n; i ++) {
int u, v;
std::cin >> u >> v;
vec[u].push_back(v);
vec[v].push_back(u);
}
DFS(1, -1);
while(m --){
int op, x;
std::cin >> op >> x;
if(op == 1)
std::cout << val[x] << '\n';
else {
if (s[x].empty()) continue;
int son = s[x].begin() -> id;
s[fa[x]].erase({w[x], x});
s[x].erase(s[x].begin());
int big = w[son];
int value = val[son];
w[son] = w[x];
w[x] -= big;
val[son] = val[x];
val[x] -= value;
s[fa[x]].insert({w[son], son});
s[son].insert({w[x], x});
fa[son] = fa[x];
fa[x] = son;
}
}
return 0;
}
