Szkopul (rek). Recursive Ant
题目链接
Szkopul Task Recursive Ant (rek)
题目大意
有一张 \(2^n\times2^n\) 的网格图，其中有 \(m\) 的格子有障碍无法到达，从 \((0,0)\) 即左上角的格子开始，每次移动到相邻的一个无障碍且未被访问的格子，移动的路径有以下要求：
对于当前处在的一个 \(2^k\times2^k(k\geq 1)\) 的区块内，它由四个 \(2^{k-1}\times2^{k-1}\) 更小的区块组成，你需要依次把每个块完整访问一遍，即进入一个块之后，需要把其内所有无障碍格子都走一遍，然后才可以离开这个区域。
现在问是否能够最终分别从网格图的四个边界离开网格图，若一个方向可以，则输出一个可行的最终离开格子的坐标，否则输出 NIE（波兰语的 NO）。输出的顺序是 ”上右下左“ 。
\(0\leq n\leq 30\), \(0\leq m\leq 50\)
思路
注意到 \(m\leq 50\) 和 \(2^n\leq 2^{30}\) 的数量级差的很大，那应该就可以想到我们要对 \(m\) 个障碍有关的事物专门处理，而其它没有障碍的部分是可以很快地得到结果的。
先考虑如何快速地得到无障碍部分的结果。
如果直接从左上角进入，可以发现是从「从右上到左下的对角线」的两侧离开该区域的，这一点用数学归纳法的思路很容易进行严谨证明。注意左图中 \(2\times2\) 的基础图形，它只有从上面一格开始走和从下面一格开始走两种情况，如果从 \((1,0)\) 进入，那就是从离对角线（后文的对角线都指之前定义的那个）距离 \(1\) 的格子离开，从而如果我们在左侧从任意一个位置进入网格图，这个位置可以进行类似于二进制拆解的思路，对应到基础情况中的从上面走还是从下面走，最终可以得出一个结论（此处可以手画一画，更明确的感知一下）：当进入的位置离 \((0,0)\) 为 \(d\) 时，我们最终会从离对角线 \(d\) 的地方（共 \(4\) 个）离开此区域。
所以我们知道进入的位置时，可以 \(O(1)\) 地得到它最终所有可以离开的位置。
而对于有障碍物的格子，它们好像很难有什么规律，那么我们对所有包含障碍物的区域都暴力计算即可，这样的区域数量是 \(O(nm)\) 级别的（最多嵌套 \(n\) 层）。于是我们可以递归处理原问题，对于当前 \(2^k\times2^k\) 的块，如果它不包含障碍，直接 \(O(1)\) 返回所有可行的出口（根据之前的分析可以知道这个出口数量 \(\leq 4\)），否则分别递归 \(4\) 个 \(2^{k-1}\times2^{k-1}\) 的块，将块块之间组合，枚举两种遍历方式（即遍历 \(2\times2\) 可以有的那两种），即可以得到当前块的答案了。
时间复杂度：\(O(nm)\)
实现
上面的思路说的轻巧，但这个东西实现起来还挺难的，因此专门讲讲怎么实现。
我们需要实现一个函数 solve(x, y, len, k)，目前在考虑左上角坐标为 \((x,y)\)，边长为 \(len\) 的区域，含有障碍的区域其规律很难把控，我们只求当输入为 \(k\) 时它最终可以离开的格子位置，称其为输出。
输入和输出都是在边界的地方进行的，由之前的分析可以知道它们与「从右上到左下的对角线」有关，这里定义一个结构体 struct io{ int dir, dis; }; 表示这个输入/输出位置的方向为 dir，顺序与最终输出答案的方向顺序相同，这个位置离对角线的距离为 dis，为了方便这里 dis 的范围是 \([1,2^k]\) 。
solve 函数要返回一系列输出，所以输出类型为 vector<io> ，若此区域无障碍，直接计算结果即可。
bool exist(int x0, int y0, int x1, int y1){
rep(i,0,m-1)
if(x[i] >= x0 && x[i] <= x1 && y[i] >= y0 && y[i] <= y1)
return true;
return false;
}
....
vector<io> ret;
if(!exist(x, y, x+len-1, y+len-1)){
rep(i,0,3) ret.push_back({i, len-k.dis+1});
return ret;
}
若此区域全被障碍填满了，那也不需要在讨论了，直接返回空 vector。
bool filled(int a, int b, int len){
if((len >= 8) || len*len > m) return false;
int cnt = 0;
rep(i,0,m-1)
if(x[i] >= a && x[i] < a+len && y[i] >= b && y[i] < b+len) cnt++;
return cnt == len*len;
}
...
if(filled(x, y, len)) return {};
注意 filled 函数要判一下 len 是否 \(\geq 8\)，否则直接相乘可能会 int 溢出。
接下处理一般性的情况，这里我们有两种行走的方式，而不同的方式里小方块之间输入输出不相同，还与传进来的输入有关，如果直接分类讨论，那么可能会非常复杂。考虑这里再实现一个函数 go(x, y, dir, len, k)，表示从 \((x,y,len)\) 的那个方块开始，k 为它的初始输入，按照 dir 的方向进行一系列游走，这里 dir 是一个 vector<int>，在此情况最终的所有输出。
先假设 go 函数已经写好了，这里我们再讨论一下当前是从那个方位的方块开始的，然后把 go 函数两种游走方式下的输出合并即可，由于这里合并要去重，我实现了一个 map<io, bool>，并为 io 定义了大小比较关系：
struct io{
int dir, dis;
bool operator < (const io b) const{
if(dir != b.dir) return dir < b.dir;
return dis < b.dis;
}
};
map<io, bool> vis;
....
vector<io> a, b;
if((k.dir == 0 || k.dir == 3) && k.dis > len/2){
k.dis -= len/2;
a = go(x, y, len/2, {1, 2, 3}, k), b = go(x, y, len/2, {2, 1, 0}, k);
}
else if((k.dir == 0 || k.dir == 1) && k.dis <= len/2)
a = go(x, y+len/2, len/2, {3, 2, 1}, k), b = go(x, y+len/2, len/2, {2, 3, 0}, k);
else if((k.dir == 1 || k.dir == 2) && k.dis > len/2){
k.dis -= len/2;
a = go(x+len/2, y+len/2, len/2, {3, 0, 1}, k), b = go(x+len/2, y+len/2, len/2, {0, 3, 2}, k);
}
else if((k.dir == 2 || k.dir == 3) && k.dis <= len/2)
a = go(x+len/2, y, len/2, {0, 1, 2}, k), b = go(x+len/2, y, len/2, {1, 0, 3}, k);
vis.clear();
for(io p : a) if(!vis[p]) ret.push_back(p), vis[p] = true;
for(io p : b) if(!vis[p]) ret.push_back(p), vis[p] = true;
接下来考虑实现 go(x, y, dir, len, k) ，这里有一个麻烦的地方，就是当这 \(4\) 个方块中有一些被完全填上的时候，我们是不用走它的，这使最终的输出的方向并不好确定，我还需要知道最后一个走的块的方位（\(2\times2\)）是什么。
于是我们先处理出这个起始方块的方位，这一点可以通过 dir 还原出来，看前两步是咋走的即可。
int X[4] = {-1, 0, 1, 0}, Y[4] = {0, 1, 0, -1};
...
int a = 0, b = 0;
rep(i,0,1) a += X[dir[i]], b += Y[dir[i]];
a = (a < 0), b = (b < 0);
然后我们一步步去走，每次把上一步的输出转化成输出传给下一个块的 solve，然后根据游走实际所需的方向，保留那个需要的输出，如果没有则说明此次游走是不可能达成的，直接返回空 vector。而如果发现下一个块被障碍完全填满了，这意味着我们的行程就要到此为止了，检查一下再后面的方块是否也被填满了，没填满（那我们也没法访问了）就返回空 vector。
用 \((a,b)\) 实时记录当前块的方位，最后需要根据这个实际方位去找合适的输出，这个合适的输出为了避免分类讨论，这里用数组预处理出来
int ch[2][2][2] = {
{{0, 3}, {0, 1}},
{{2, 3}, {1, 2}}
};
前两位是方位 \((a,b)\)，第三维放两种可行的方向。
注意最后返回输出的时候，输出要转化成大方块的格式，所以还需根据方位的确定 dis 是否需要加上一个 len 。最终 go 函数的实现如下：
vector<io> go(int x, int y, int len, vector<int> dir, io k){
int a = 0, b = 0;
rep(i,0,1) a += X[dir[i]], b += Y[dir[i]];
a = (a < 0), b = (b < 0);
rep(i,0,2){
vector<io> tmp = solve(x, y, len, k);
bool flag = false;
io tmpk = k;
for(io p : tmp) if(p.dir == dir[i]) k = p, flag = true;
if(!flag) return {};
if(k.dir >= 2) k.dir -= 2;
else k.dir += 2;
k.dis = len-k.dis+1;
x += X[dir[i]]*len, y += Y[dir[i]]*len;
a += X[dir[i]], b += Y[dir[i]];
if(filled(x, y, len)){
int tmpx = x-X[dir[i]]*len, tmpy = y-Y[dir[i]]*len;
rep(j,i+1,2){
x += X[dir[j]]*len, y += Y[dir[j]]*len;
if(!filled(x, y, len)) return {};
}
x = tmpx, y = tmpy, k = tmpk;
a -= X[dir[i]], b -= Y[dir[i]];
break;
}
}
vector<io> tmp = solve(x, y, len, k), ret;
for(io p : tmp)
if(p.dir == ch[a][b][0] || p.dir == ch[a][b][1])
ret.push_back(p);
int id = a^b^1;
rep(i,0,(int)ret.size()-1) ret[i].dis += id*len;
return ret;
}
然而事情还没有结束，回到 solve 函数，由于有大量二选一的操作，边长为 \(2^k\) 的块下面最差要做 \(2^k\) 次决策，但是它们中只有 \(O(1)\) 不同的情况（因为只有方向会有变化，相对对角线的位置是不变的），对 solve 的操作进行记忆化，记 struct state{ int a, b, c; io d; } 为一个状态，给它定义大小比较之后塞 map 里面即可。
然后基本上就可以得到完整的代码了，由于要 map 记忆化，实际实现的时间复杂度是 \(O(nm\log(nm))\) 的，把它换成哈希就可以达到理论复杂度了。
Code
#include<iostream>
#include<vector>
#include<cstring>
#include<map>
#define mem(a,b) memset(a, b, sizeof(a))
#define rep(i,a,b) for(int i = (a); i <= (b); i++)
#define per(i,b,a) for(int i = (b); i >= (a); i--)
#define N 55
using namespace std;
int n, m;
int x[N], y[N];
int X[4] = {-1, 0, 1, 0}, Y[4] = {0, 1, 0, -1};
int ch[2][2][2] = {
{{0, 3}, {0, 1}},
{{2, 3}, {1, 2}}
};
int end_x[4], end_y[4];
struct io{
int dir, dis;
bool operator < (const io b) const{
if(dir != b.dir) return dir < b.dir;
return dis < b.dis;
}
};
struct state{
int a, b, c;
io d;
bool operator < (const state bb) const{
if(d < bb.d || bb.d < d) return d < bb.d;
if(a != bb.a) return a < bb.a;
if(b != bb.b) return b < bb.b;
return c < bb.c;
}
};
map<io, bool> vis;
map<state, vector<io> > f;
bool exist(int x0, int y0, int x1, int y1){
rep(i,0,m-1)
if(x[i] >= x0 && x[i] <= x1 && y[i] >= y0 && y[i] <= y1)
return true;
return false;
}
bool filled(int a, int b, int len){
if((len >= 8) || len*len > m) return false;
int cnt = 0;
rep(i,0,m-1)
if(x[i] >= a && x[i] < a+len && y[i] >= b && y[i] < b+len) cnt++;
return cnt == len*len;
}
vector<io> solve(int x, int y, int len, io k);
vector<io> go(int x, int y, int len, vector<int> dir, io k){
int a = 0, b = 0;
rep(i,0,1) a += X[dir[i]], b += Y[dir[i]];
a = (a < 0), b = (b < 0);
rep(i,0,2){
vector<io> tmp = solve(x, y, len, k);
bool flag = false;
io tmpk = k;
for(io p : tmp) if(p.dir == dir[i]) k = p, flag = true;
if(!flag) return {};
if(k.dir >= 2) k.dir -= 2;
else k.dir += 2;
k.dis = len-k.dis+1;
x += X[dir[i]]*len, y += Y[dir[i]]*len;
a += X[dir[i]], b += Y[dir[i]];
if(filled(x, y, len)){
int tmpx = x-X[dir[i]]*len, tmpy = y-Y[dir[i]]*len;
rep(j,i+1,2){
x += X[dir[j]]*len, y += Y[dir[j]]*len;
if(!filled(x, y, len)) return {};
}
x = tmpx, y = tmpy, k = tmpk;
a -= X[dir[i]], b -= Y[dir[i]];
break;
}
}
vector<io> tmp = solve(x, y, len, k), ret;
for(io p : tmp)
if(p.dir == ch[a][b][0] || p.dir == ch[a][b][1])
ret.push_back(p);
int id = a^b^1;
rep(i,0,(int)ret.size()-1) ret[i].dis += id*len;
return ret;
}
vector<io> solve(int x, int y, int len, io k){
vector<io> ret, a, b;
if(!exist(x, y, x+len-1, y+len-1)){
rep(i,0,3) ret.push_back({i, len-k.dis+1});
return ret;
}
if(filled(x, y, len)) return {};
if(f.count({x, y, len, k})) return f[{x, y, len, k}];
int tmp = k.dis;
if((k.dir == 0 || k.dir == 3) && k.dis > len/2){
k.dis -= len/2;
a = go(x, y, len/2, {1, 2, 3}, k), b = go(x, y, len/2, {2, 1, 0}, k);
}
else if((k.dir == 0 || k.dir == 1) && k.dis <= len/2)
a = go(x, y+len/2, len/2, {3, 2, 1}, k), b = go(x, y+len/2, len/2, {2, 3, 0}, k);
else if((k.dir == 1 || k.dir == 2) && k.dis > len/2){
k.dis -= len/2;
a = go(x+len/2, y+len/2, len/2, {3, 0, 1}, k), b = go(x+len/2, y+len/2, len/2, {0, 3, 2}, k);
}
else if((k.dir == 2 || k.dir == 3) && k.dis <= len/2)
a = go(x+len/2, y, len/2, {0, 1, 2}, k), b = go(x+len/2, y, len/2, {1, 0, 3}, k);
vis.clear();
for(io p : a) if(!vis[p]) ret.push_back(p), vis[p] = true;
for(io p : b) if(!vis[p]) ret.push_back(p), vis[p] = true;
k.dis = tmp;
return f[{x, y, len, k}] = ret;
}
int main(){
cin>>n>>m;
rep(i,0,m-1) cin>>x[i]>>y[i];
vector<io> ans = solve(0, 0, 1<<n, {0, 1<<n});
mem(end_x, -1), mem(end_y, -1);
for(io k : ans){
int a, b;
switch(k.dir){
case 0 : a = 0, b = (1<<n)-k.dis; break;
case 1 : a = k.dis-1, b = (1<<n)-1; break;
case 2 : a = (1<<n)-1, b = k.dis-1; break;
case 3 : a = (1<<n)-k.dis, b = 0; break;
}
end_x[k.dir] = a, end_y[k.dir] = b;
}
rep(i,0,3){
if(~end_x[i]) cout<<end_x[i]<<" "<<end_y[i]<<endl;
else puts("NIE");
}
return 0;
}
