AGC047 简要题解
A - Integer Product
注意精度问题即可
B - First Second
建颗 trie 树搞一搞即可
C - Product Modulo
考虑用原根解决此问题，乘法变为了加法，因此用桶记录一下 FFT 即可
D - Twin Binary Trees
观察题目性质容易发现树高事 (log n) 的，即使是暴力枚举第一棵树最浅的点复杂度也正确。
因此就暴力枚举，那么一条合法的路径肯定是分别走向两个儿子的，考虑从左儿子走到第二棵树每个节点的贡献，然后再走右儿子找交集即可，注意在更深处有了交集要把父亲的贡献减掉。
E - Product Simulation
好题！用两个简单运算构建起更复杂到操作！
首先你只能有 加 和 比较 两种运算，实现乘法运算。
首先造出 1，(1 = 0 < (A+B)) 如果 (A = B = 0) 显然数组所有的数都是 0，没有影响的。
计算机是怎样的系统？二进制！所以考虑二进制下的一些运算，有些函数可能与本题无关
And 运算
A & B = 1 < (A + B)
Or 运算
A | B = 0 < (A + B)
Xor 运算
(A < B) + (B < A)
二的整次幂
a[0] = 1;
for (int i = 1;i <= k; i++)
add(a[0], a[0], 0)
二的整次幂乘 0/1（知道幂的大小）
(ans = (x>0)<<k)
二进制拆分
倒着枚举最高位，如果当前数 (x) 比 (2^i) 大，那么让 (x -= 2^i)。
减法显然可以移过去变成加法，然后就是一个整次幂乘 0/1 的问题。
乘法操作
先将 A，B 二进制拆分，然后直接乘就行了。
for(int k = 58; k >= 0; k--) {
answer *= 2;
for(int i = 0; i <= k; i++){
int j = k - i;
if(i < 30 && j < 30) {
answer += 1<(a_bits[i]+b_bits[j]);
}
}
}
这样这道题就已经做完了，我们想想其他的操作。
减法操作
显然我们不可能得出负数，所以实际得出的是 (max(0,x-y))
将 (x-y) 二进制拆分式的枚举，然后就是二的整次幂乘 0/1
除法操作
还是二进制拆分式的枚举即可
F - Rooks
也是 nb 题
按照题解的说法，我们分三步走
第一步：考虑 (Theta(n^2)) 算法
先按 x 排序，对于一个点来说，显然能走到的区域是一个区间 ([L,R])，考虑区间 dp，首先枚举位置 t，(dp[l][r][0/1]) 表示从位置 t 开始，已经走过区间 ([l,r])，目前在左右端点的最小代价是多少，转移显然。
容易发现从一个位置有大量的走不到区间，且两个位置有大量的公共区间。考虑倒着 dp，设 (dp[l][r][0/1]) 表示从 ([l, r]) 开始，已经解决了 ([1,l)cup(r,n]) 这部分能到的地方的最小代价。这样就是 (Theta(n^2)) 的了。
第二步：考虑横坐标单调且纵坐标单调
从任意一点出发，显然只有两种情况，走到最右边再回来和走到最左边再回来。
第三步：正解
从中间那个举行出发，只有这两种情况是合法的，手玩一下可以发现其他的情况都会被挡住，这样就转化为了内部是 (subtask2)，整体做 (subtask1) 了
看代码会清楚些
const int N = 200500, M = 1000050;
int t[M], x[N], y[N], tx[N], ty[N];
int lt[N], rt[N], n;
void rankit(int *x) {
memset(t, 0, sizeof(t));
for (int i = 1;i <= n; i++) t[x[i]]++;
for (int i = 1;i <= 1000000; i++) t[i] += t[i-1];
for (int i = 1;i <= n; i++) x[i] = t[x[i]];
}
struct node {
int x, y, id;
bool operator < (const node &i) const {
return x < i.x;
}
}p[N];
#include <map>
map<pair<int, int> , ll> f[2];
inline int abs(int x) { return x > 0 ? x : -x; }
inline int dis(int a, int b) {
int dx = abs(x[p[a].id] - x[p[b].id]);
int dy = abs(y[p[a].id] - y[p[b].id]);
return dx + dy;
}
const ll inf = 1e18;
ll ans[N];
ll DP(int U, int D, int l, int r, int k) {
if (f[k].count(MP(l, r))) return f[k][MP(l, r)];
int L = lt[l-1], R = rt[r+1]; ll ans = inf;
if (l > 1 && (p[l-1].y == D - 1 || p[l-1].y == U + 1)) {
ll t = dis(L, k == 0 ? l : r);
Mn(ans, DP(max(p[L].y, U), min(p[L].y, D), L, r, 0) + t);
}
if (r < n && (p[r+1].y == D - 1 || p[r+1].y == U + 1)) {
ll t = dis(R, k == 0 ? l : r);
Mn(ans, DP(max(p[R].y, U), min(p[R].y, D), l, R, 1) + t);
}
return f[k][MP(l, r)] = (ans == inf ? l - r : ans);
}
int main() {
read(n);
for (int i = 1;i <= n; i++) read(x[i]), read(y[i]), tx[i] = x[i], ty[i] = y[i];
rankit(tx), rankit(ty);
for (int i = 1;i <= n; i++) p[tx[i]] = (node) {tx[i], ty[i], i};
sort(p + 1, p + n + 1);
lt[1] = 1, rt[n] = n;
for (int i = 2;i <= n; i++)
lt[i] = abs(p[i].y - p[i-1].y) == 1 ? lt[i-1] : i;
for (int i = n - 1; i; i--)
rt[i] = abs(p[i+1].y - p[i].y) == 1 ? rt[i+1] : i;
for (int i = 1;i <= n; i++)
ans[p[i].id] = DP(p[i].y, p[i].y, i, i, 0);
for (int i = 1;i <= n; i++) write(ans[i]);
return 0;
}