题解 P3693 【琪露诺的冰雪小屋】
知识点: 模拟 , 信仰
原题面
大 型 车 万 众 自 裁 现 场
分析题意:
-
操作: ICE_BARRAGE R C D S
- R:行 , C:列, D:方向 , S:强度
- 在(R,C) 向 D 射线上 发射弹幕, 将 距离 S 格内 的位置 冰冻度 \(+1\)
- 冰冻度 只是 地面的属性 , 冰砖 无冰冻度属性
- 冰冻度 操作前已经为 \(4\) 的方格 冰冻度 不改变
- 遇到冰砖 射线线停止延伸
- 距离 \(=\) 经过方格数量 , 经过格子数量 \(\ge S\) 时 直线停止延伸
输出: CIRNO FREEZED k BLOCK(S)
- k : 冰冻度 \(+1\) 的位置的数量
-
操作: MAKE_ICE_BLOCK
- 将 全地图上 冰冻度 \(= 4\) 的 方格 冰冻度清零, 冰砖库存数 \(+1\)
输出: CIRNO MADE x ICE BLOCK(S),NOW SHE HAS y ICE BLOCK(S)
- x : 本次制造数 , y : 目前库存数
-
操作: PUT_ICE_BLOCK R C H
- R: 行 C:列 H:高
- 库存冰砖数\(-1\) , 在 三维空间中 \((R,C,H)\) 处放置 一个冰砖
- 放置在地面 \(\Rightarrow\) 地面冰冻度清零
输出 :
可能出现多种结果 , 按照输出优先级排列 :- CIRNO HAS NO ICE_BLOCK
- 无库存冰砖
- 阻止操作进行
- BAKA CIRNO,CAN'T PUT HERE
- 冰砖放置位置悬空 / 放置位置已有冰块
- 冰砖悬空 \(\Rightarrow\) 三维空间中 周围六个位置 无冰砖存在
- 对于 放置位置 接触地面的 冰砖 , 不可能悬空
- 阻止操作进行
- 冰砖放置位置悬空 / 放置位置已有冰块
- CIRNO MISSED THE PLACE
- \(\text{R<HR}\ \text{或}\ \text{R>HR+HX-1}\)
\(\text{或} \ \text{C<HC}\ \text{或}\ \text{C>HC+HY-1}\) - 放置在了 房子范围以外的位置
- 不可阻止 操作进行
- \(\text{R<HR}\ \text{或}\ \text{R>HR+HX-1}\)
- CIRNO PUT AN ICE_BLOCK INSIDE THE HOUSE
- \(\text{HR+1}\le \text{R}\le \text{HR+HX-2}\)
\(\text{且}\ \text{HC+1}\le \text{C}\le \text{HC+HY-2}\) - 冰砖放置在了 屋内 本应为空地处
- 不可阻止 操作进行
- \(\text{HR+1}\le \text{R}\le \text{HR+HX-2}\)
- CIRNO SUCCESSFULLY PUT AN ICE_BLOCK,NOW SHE HAS x ICE_BLOCK(S)
- x : 目前 库存冰砖数
- 不考虑 是否堵住了 应该留门的位置
-
操作: REMOVE_ICE_BLOCK R C H
- R: 行 C: 列 H: 高
- 将 \((R,C,H)\) 位置的冰砖取走 , 库存 冰砖数 \(+1\)
- 将 与地面接触的 冰砖取走后 , 地面冰冻度归零
输出:
可能出现多种结果 , 按照输出优先级排列:- BAKA CIRNO,THERE IS NO ICE_BLOCK
- 被操作位置 无冰砖
- 阻止操作进行
- CIRNO REMOVED AN ICE_BLOCK,AND k BLOCK(S) ARE BROKEN
- k: 碎掉冰块数
- 本次操作 导致 一冰砖联通块 悬空 (不与 与地面接触的联通块 联通)
悬空 冰块消失 - 不可阻止 操作进行
- CIRNO REMOVED AN ICE_BLOCK
- 成功取走 , 对其他冰块无影响
-
操作: MAKE_ROOF
- 最后一 条操作 , 只出现一次
- 按照下列顺序进行 子操作, 按照 子操作个指令排列优先级 进行操作 ,
若不满足条件, 子操作无法进行 , 程序终止
子操作:
-
搭建 房顶
- 在 墙壁最高高度 \(+1\) 处 一次性放置 至多 \(\text{HX}\times \text{XY}\) 个冰砖,
- 若 在 MAKE_ROOF 之前此高度处有冰砖 , 已有冰砖位置 不必重复放置
- 比 此时放置的 屋顶的高度 高的 冰砖 视为存在于房外
不满足条件:
可能出现多种结果 , 按照输出优先级排列:- SORRY CIRNO,NOT ENOUGH ICE_BLOCK(S) TO MAKE ROOF
- 按照上述规则 , 库存冰块不足 填满 房顶
- SORRY CIRNO,HOUSE IS TOO SMALL
- 房顶建造完毕后 , 墙高 \(<2\) 或 房屋内部空间 \(<2\)(忽略屋内错放冰砖)
-
移除 多余冰砖:
- 将 不属于 房屋墙壁与 房屋顶部 的冰砖全部移走
- 当 移走某冰砖时 , 可能 会导致 墙壁上 某冰砖 摔碎,
则先将 墙壁上 会摔碎的冰砖 移走 (子任务3 中再进行填补)
再 对原冰砖 进行移除
输出:
k1 ICE_BLOCK(S) INSIDE THE HOUSE NEED TO BE REMOVED
k2 ICE_BLOCK(S) OUTSIDE THE HOUSE NEED TO BE REMOVED- k1 : 房子内部 错误放置的 多余冰砖数
k2 : 房子外部 错误放置的 多余冰砖数
不满足条件 :
- SORRY CIRNO,HOUSE IS BROKEN WHEN REMOVING BLOCKS
- 由于 将墙壁上冰砖移走 , 导致房顶 不 与地面联通 , 使房顶塌陷
-
填补 墙壁残缺:
-
墙壁 有残缺的定义:
- 除 门的候选位置 之外 , 从屋内向外看 还可看到其他 残缺
- \(\color{red}{注意:}\) 当 门不得不 开到 柱子旁时 , 可看到 柱子对应位置 是否残缺
当 一个残缺位置 同时与两柱子相邻时 , 可同时看到 两柱子对应位置的残缺
此过程中填补的所有残缺 都属于墙壁残缺 (包括柱子残缺)
-
对于 高度\(\ge 2\) 的残缺位置 , 一定需要被填补
-
对于 高度 \(< 2\) 的残缺位置 , 需要考虑 成为门的情况 :
对于门的候选位置 , 应按照下列条件进行选择 (按照必要性优先级排序) :-
房屋能够建成 (不出现 冰砖数量不足的情况)
-
对于门的候选位置 的选择 , 需要使填补冰砖数量尽可能 减少
若门候选位置 相邻的柱子残缺 , 会导致 冰砖填补数量增加 -
需填补冰砖数 \(=\) 墙壁残缺数(不包括柱子) \(-\) 候选位置大小 \(+\) 可看到柱子残缺数
应将 门候选位置按照 "可看到柱子残缺数\(-\)候选位置大小" 升序 作为排序第一优先级-
显然 , 可看到的柱子残缺数 \(\le\) 门候选位置大小
-
在此条件下, 可能出现: 选择 大小为 \(1\times 1\) 的残缺 优于 大小为 \(1\times 2\) 的残缺 的情况
-
-
-
存在一 \(1\times 2\) 大小的残缺作为 门
-
满足条件\(1\) 的情况下 ,
优先选择 高度为 \(2\) 的残缺 作为 门的候选位置应将 门候选位置 按照 "残缺 的高度" 降序 作为排序 第二优先级
-
-
门 更靠近 墙壁的正中央
- 满足 条件 \(1,2\) 的情况下
优先选择 更靠近 墙壁正中央的 残缺
为更接近 "CIRNO IS PERFECT!" 的情况 (定义详见 检查 小屋 第\(6\)条)
应将 门候选位置 按照 "与墙壁中间位置的距离" 升序 作为排序 第三优先级
- 满足 条件 \(1,2\) 的情况下
-
不满足条件 :
- SORRY CIRNO,NOT ENOUGH ICE_BLOCKS TO FIX THE WALL
- 经过上述过程, 减少填补冰砖数 后 ,
库存冰砖 还是无法 填补所有的 非门残缺
如果门开在 柱子旁 , 残缺也 包括可看到的柱子 的残缺
- 经过上述过程, 减少填补冰砖数 后 ,
-
-
检查 小屋
-
输出: GOOD JOB CIRNO,SUCCESSFULLY BUILT THE HOUSE
- 庆祝小屋完工
(不愧是琪露诺! 轻易就做到了我们做不到的事)
- 庆祝小屋完工
-
检查是否有 \(1\times 2\) 的门 :
- 无 , 输出 HOUSE HAS NO DOOR
- 有 , 输出 DOOR IS OK
-
检查操作 \(3\) 中是否进行了填补操作
- 否 , 输出 WALL IS OK
- 是 , 输出 WALL NEED TO BE FIXED
-
检查 四角的柱子 是否 有残缺
- 否 , 输出 CORNER IS OK
- 是 , 输出 CORNER NEED TO BE FIXED
- 若此时库存冰砖 \(\ge\) 修复所需要的冰砖数
则 就花费 修复所需冰砖数 个冰砖 - 否则 库存冰砖数置零
- 若此时库存冰砖 \(\ge\) 修复所需要的冰砖数
-
输出: CIRNO FINALLY HAS k ICE_BLOCK(S)
- k: 剩余库存冰砖数
-
若上述检查 的 过程中
- 没有 一个冰砖 需要被移除
- 没有 一个位置 需要被 填补
- 未出现房子没门的情况
- 房角 的四个柱子 在 建造房顶之前便已修好, 未再进行 修补
- 门恰好开在了 某面墙的正中央 (若墙长为偶数, 则两中间位置都合法)
输出 : CIRNO IS PERFECT!
-
对于 \(20\%\) 的数据 : 只有操作 \(1, 2\)
对于 \(30\%\) 的数据 : 只有操作 \(1, 2, 3\)
对于 \(50\%\) 的数据 : 只有操作 \(1, 2, 3, 4\)
对于 \(70\%\) 的数据 : 不会造成任何冰砖摔落 , 也不会造成屋顶塌陷
对于 \(90\%\) 的数据 : 不把门开到四角的柱子旁边。
(保证在所有可能作为门的墙壁空缺中，有一种可能 使得门 不紧贴四角的柱子)
对于 \(100\%\) 的数据 :
\(4\le \text{N}\le 16\ , \ 5\le \text{HM}\le 20 \ ,\ 10\le \text{M}\le 1000\)
保证 不属于冰屋范围内 的 所有空地 至多构成一个连通块。
除 MAKE_ROOF 指令外 , 放置方块 的 高度小于 \(\text{HM}\)
算法实现 :
分析上述过程中 较为复杂的实现 :
-
如何判断 悬空连通块, 并将其消除 \(?\)
可以 以某连通块中的 一个冰砖为起点 , 进行 \(DFS/BFS\)
转移时 向相邻的 冰砖 进行转移如果 可以转移到 一个 与地面接触的 冰砖,
那么 证明此联通块 与地面接触 , 不悬空
否则证明 此联通块悬空 , 需要 被全部消除- 不可 边判断边消除 , 会因为 搜索的 顺序 导致错误
消除一个联通块时 , 也使用 \(DFS/BFS\) ,
对转移到的 冰砖直接消除即可代码如下 :
int DFS1(int R,int C,int H,int FR,int FC,int FH)//dfs 判断某联通块是否悬空 { vis[R][C][H] = 1;//访问过,打标记 if(H == 0) return 1;//此冰砖 与地面接触 , 说明此连通块合法 for(int i = 0; i < 6; i ++)//枚举相邻的 冰砖 if(R + EXX[i] >= 0 && R + EXX[i] <N && C + EXY[i] >= 0) //位置合法 if(C + EXY[i] < N && H + EXZ[i] >= 0 && H + EXZ[i] <=HM) if(R + EXX[i] != FR || C + EXY[i] != FC || H + EXZ[i] != FH)//不与 上一块冰砖位置相同 if(ice_block[R + EXX[i]][C + EXY[i]][H + EXZ[i]])//有冰砖 if(!vis[R + EXX[i]][C + EXY[i]][H + EXZ[i]])//转移 if(DFS1(R + EXX[i],C + EXY[i],H + EXZ[i],R,C,H)) return 1;//连通块 与地面接触 return 0;//悬空 } int DFS2(int R,int C,int H,int FR,int FC,int FH)//dfs 将某联通块 删除 { int ret = 0;//计算 删除的个数 for(int i = 0; i < 6; i ++) if(R + EXX[i] >= 0 && R + EXX[i] < N && C + EXY[i] >= 0) //枚举 合法的相邻冰砖 if(C + EXY[i] < N && H + EXZ[i] >= 0 && H + EXZ[i] <= HM) if(R + EXX[i] != FR || C + EXY[i] != FC || H + EXZ[i] != FH) if(ice_block[R + EXX[i]][C + EXY[i]][H + EXZ[i]]) ret += DFS2(R + EXX[i],C + EXY[i],H + EXZ[i],R,C,H);//dfs深入 return ice_block[R][C][H] = 0, ret + 1;//更新冰砖存在情况,更新删除个数 } -
如何: 表示一门的候选位置相邻的墙角 , 并计算 墙角的残缺大小\(?\)
-
对于 一门的候选位置 相邻的墙角 ,
由于情况较少 , 暴力枚举寻找即可 -
对于一个候选位置 , 其与某墙角关系只有 相邻/不相邻 两种
考虑 对候选位置与各墙角关系 进行状压使用一 长度为\(4\) 的二进制串 , 表示某候选位置 与各墙角关系
如 : \((1001)_2\) 表示此位置 与墙角\(1\) 与 墙角\(4\) 相邻 -
在计算墙角残缺大小时 , 枚举 二进制串上对应位置
根据 门后选位置的高度 进行判断即可
-
-
如何实现 上述 对门的候选位置 的估价过程 \(?\)
-
首先找到 所有 离地高度\(\le 2\) 的残缺位置 ,
对于每一个残缺位置 , 计算出下列各值 :- 保留此残缺 对总填补数的影响 (可看到的柱子残缺数 \(-\) 门候选位置大小)
- 此残缺 的高度
- 此残缺 与墙壁中间位置的距离
-
按照 分析题意 中规定优先级 进行排序
排序后的 第一个残缺 一定使 需要填补冰砖数 最小 -
若第一个残缺 高度为 \(1\), 且所得 需要填补冰砖数 \(<\) 当前库存
说明 可以多消耗 至多一个 冰砖 , 来选择一个 高度为 \(2\) 的残缺作门- 可以 手推 各种类的残缺 , 来得到 消耗 至多一个 冰砖 的结论
则可 在排序后的残缺中 向后寻找第一个 高度为 \(2\) 的残缺
由于 第 \(2,3\) 排序优先级的存在 , 找到的第一个 一定为 最优的
-
一些技巧
-
做题前先写大纲 一定没有错
-
多写子函数 一定没有错
-
有 \(\text{hack}\) 数据提早联系出题人一定没有错
-
有没有 什么方便的方法 可以 减小调试的难度 ?
考虑 使全局的 冰砖摆放情况 可视化-
发现 对于确定的 横纵坐标 , 在此 横纵坐标上的 冰砖 ,
可以按照 存在情况 , 用一个二进制串表示
即: 对 每一个 \(z\) 轴 进行状压例: \(9 = (1001)_2\) , 表示: 在某位置, 高度为 \(0,3\) 处 , 分别有一 冰砖
这样 状压后 输出 每个\((x,y)\) 对应的值
就可以 在 二维平面内 模拟 三维立体图形 , 以便于调试 -
如果您有条件 , 可以用 \(\text{MC}\) 手玩数据
配合上述方法使用 效果更佳
代码如下 :
-
void check()//调试使用, 输出地图 , 以检查合法性
{
for(int x = 0; x < N; putchar('\n'), x ++)
for(int y =0; y < N; y ++)
{
long long sum = 0;//使用 状压思想 , 对每一个二维的 坐标上的冰砖进行状压
for(int z = 0; z <= HM; z ++) sum+= (ice_block[x][y][z]) * (1 << z);
printf("%lld ",sum);
}
printf("\n\n");
}
附完整代码 :
#include<cstdio>
#include<vector>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<string>
#include<ctype.h>
#define min(a,b) (a < b ? a : b)
const int DIR_X[8] = {-1,-1,0,1,1,1,0,-1};//ICE_BARRAGE 操作时的 方向改变量
const int DIR_Y[8] = {0,-1,-1,-1,0,1,1,1};
const int EXX[6] = {0,0,1,-1,0,0};//立体空间内 相邻的冰砖 位置改变量
const int EXY[6] = {0,0,0,0,1,-1};
const int EXZ[6] = {-1,1,0,0,0,0};
//=============================================================
struct alternative_position//门的候选位置
{
int x, y, z, h, wall;//位置信息,
int corner, corner_pos; //可看到的柱子残缺数
int mid1, mid2;//此面墙 中间位置的坐标
};
int N,HM,HR,HC,HX,HY,M;//输入的各常量
int inventory;//库存冰砖数
bool ice_block[17][17][30];//三维空间内某点 是否有冰砖存在
int ground_freeze[17][17];//地面冰冻度 ,当地面有冰砖时为-1
bool vis[17][17][30];//在dfs求 联通块时使用
int max_high;//墙壁最高高度
int doorx, doory, doorz, door_high, door_dis;
int corner_x[20], corner_y[20];
//=========子函数列表:==========================================
inline int read()
{
int s=1, w=0; char ch=getchar();
for(; !isdigit(ch);ch=getchar()) if(ch=='-') s =-1;
for(; isdigit(ch);ch=getchar()) w = w*10+ch-'0';
return s*w;
}
int abs(int x) {return x > 0? x : -x; }
bool cmp(alternative_position fir, alternative_position sec)
{
if(fir.corner - fir.h == sec.corner - sec.h)//第一优先级, 消耗冰砖数 升序排序
{
if(fir.h == sec.h)//第二优先级 门的大小 降序排序
{
int minfir = min(abs(fir.wall - fir.mid1), abs(fir.wall - fir.mid2));
int minsec = min(abs(sec.wall - sec.mid1), abs(sec.wall - sec.mid2));
return minfir < minsec; //第三优先级, 与墙中央位置的距离 升序排序
}
return fir.h > sec.h;
}
return fir.corner - fir.h < sec.corner - sec.h;
}
void ICE_BARRAGE();//操作1,释放弹幕
void MAKE_ICE_BLOCK();//操作2,收集冰砖
void PUT_ICE_BLOCK();//操作3,放置冰砖
bool JUDGE_PUT(int R,int C,int H);//判断 某位置 是否可以放置冰砖
int DFS1(int R,int C,int H,int FR,int FC,int FH);//dfs 判断某联通块是否悬空
int DFS2(int R,int C,int H,int FR,int FC,int FH);//dfs 将某联通块 删除
void REMOVE_ICE_BLOCK();//操作4,移除冰砖
void MAKE_ROOF(); //操作5, 建造房顶, 移除多余,修补残缺,检查房屋
int find_max_high();//寻找 墙壁最高处
void remove_excess(int&,int&);
bool judge_outside(int,int,int);//判断某冰砖 是否位于 房屋内/外
bool judge_inside(int,int,int);
bool fill_high_wall(int);//填补 高度>2的墙壁
int judge_corner(int,int);//判断 一个位置否开在 墙角,并判断 开在哪个墙角
void corner_could_see(int,int,int,int,int&,int&);//计算一个位置 能看到的墙角的残缺数
bool find_door();//在 高度<2的位置 找门 ,并填补非门区域
void check()//调试使用, 输出地图 , 以检查合法性
{
printf("%d \n",inventory);
for(int x=0; x<N; putchar('\n'),x++)
for(int y=0; y<N; y++)
{
long long sum=0;//使用 状压思想 , 对每一个二维的 坐标上的冰砖进行状压
for(int z=0; z<=HM; z++) sum+= (ice_block[x][y][z]) * (1<<z);
printf("%lld ",sum);
}
printf("\n\n\n");
}
//=============================================================
signed main()//sb main函数
{
// freopen("1.in","r",stdin);
// freopen("koishi.txt","w",stdout);
N=read(), HM=read(), HR=read(), HC=read(), HX=read(), HY=read(), M=read();
corner_x[1] = corner_x[2] = HR, corner_x[4] = corner_x[8] = HR + HX - 1;//获得各墙角位置
corner_y[2] = corner_y[8] = HC + HY - 1, corner_y[1] = corner_y[4] = HC;
while(M --)
{
std::string order;
std::cin >> order;
if(order == "ICE_BARRAGE") ICE_BARRAGE();
if(order == "MAKE_ICE_BLOCK") MAKE_ICE_BLOCK();
if(order == "PUT_ICE_BLOCK") PUT_ICE_BLOCK();
if(order == "REMOVE_ICE_BLOCK") REMOVE_ICE_BLOCK();
if(order == "MAKE_ROOF") MAKE_ROOF();
}
}
//=============================================================
void ICE_BARRAGE()
{
int R=read(), C=read(), D=read(), S=read();
int freeze_num = 0, pass_num = 0;//冰冻度改变的格子数 和 经过的格子数(距离
for(int x = R, y = C; ;x += DIR_X[D], y += DIR_Y[D])//枚举射线经过的格子
{
if(x < 0 || x >= N || y < 0 || y >= N || ground_freeze[x][y] == -1) break;//直线不可延伸
if(ground_freeze[x][y] < 4) ground_freeze[x][y]++ , freeze_num ++;//更新 变量
pass_num ++;
if(pass_num > S) break;//直线不可延伸
}
printf("CIRNO FREEZED %d BLOCK(S)\n",freeze_num);
}
void MAKE_ICE_BLOCK()
{
int collect_num = 0;//收集 的冰砖数
for(int x = 0; x < N; x ++)
for(int y = 0; y < N; y ++)
if(ground_freeze[x][y] == 4)//可以进行收集
inventory ++, collect_num ++, //加入库存
ground_freeze[x][y] = 0;//冰冻度清零
printf("CIRNO MADE %d ICE BLOCK(S),NOW SHE HAS %d ICE BLOCK(S)\n",collect_num,inventory);
}
bool JUDGE_PUT(int R,int C,int H)//判断 某位置 是否可以放置冰砖
{
if(ice_block[R][C][H]) return 1;//此位置已被占用
if(H == 0) return 0;//冰砖与地面接触
for(int i = 0; i < 6; i ++) //枚举立体空间内相邻的 位置
if(R + EXX[i] >= 0 && C + EXY[i] >= 0 && H + EXZ[i] >= 0)
if(R + EXX[i] < N && C + EXY[i] < N && H + EXZ[i] < HM)
if(ice_block[R + EXX[i]][C + EXY[i]][H + EXZ[i]]) //有相邻冰砖
return 0; //放置位置合法
return 1;//冰砖悬空
}
void PUT_ICE_BLOCK()
{
int R=read(),C=read(),H=read();
if(! inventory) {printf("CIRNO HAS NO ICE_BLOCK\n"); return ;}//不合法情况
if(JUDGE_PUT(R,C,H)) {printf("BAKA CIRNO,CAN'T PUT HERE\n"); return ;}
ice_block[R][C][H] = 1,inventory --;//放置冰砖
if(H == 0) ground_freeze[R][C] = -1;//与地面接触 ,更改地面冰冻值
if(R < HR || R > HR + HX - 1 || C < HC || C > HC + HY - 1) printf("CIRNO MISSED THE PLACE\n");//按照放置位置 输出
else if(HR + 1 <= R && R <= HR + HX - 2 && HC + 1 <= C && C <= HC + HY - 2) printf("CIRNO PUT AN ICE_BLOCK INSIDE THE HOUSE\n");
else printf("CIRNO SUCCESSFULLY PUT AN ICE_BLOCK,NOW SHE HAS %d ICE_BLOCK(S)\n",inventory);
// check();
}
int DFS1(int R,int C,int H,int FR,int FC,int FH)//dfs 判断某联通块是否悬空
{
vis[R][C][H] = 1;//访问过,打标记
if(H == 0) return 1;//此冰砖 与地面接触 , 说明此连通块合法
for(int i = 0; i < 6; i ++)//枚举相邻的 冰砖
if(R + EXX[i] >= 0 && R + EXX[i] <N && C + EXY[i] >= 0) //位置合法
if(C + EXY[i] < N && H + EXZ[i] >= 0 && H + EXZ[i] <=HM)
if(R + EXX[i] != FR || C + EXY[i] != FC || H + EXZ[i] != FH)//不与 上一块冰砖位置相同
if(ice_block[R + EXX[i]][C + EXY[i]][H + EXZ[i]])//有冰砖
if(!vis[R + EXX[i]][C + EXY[i]][H + EXZ[i]])//转移
if(DFS1(R + EXX[i],C + EXY[i],H + EXZ[i],R,C,H)) return 1;//连通块 与地面接触
return 0;//悬空
}
int DFS2(int R,int C,int H,int FR,int FC,int FH)//dfs 将某联通块 删除
{
int ret = 0;//计算 删除的个数
for(int i = 0; i < 6; i ++)
if(R + EXX[i] >= 0 && R + EXX[i] < N && C + EXY[i] >= 0) //枚举 合法的相邻冰砖
if(C + EXY[i] < N && H + EXZ[i] >= 0 && H + EXZ[i] <= HM)
if(R + EXX[i] != FR || C + EXY[i] != FC || H + EXZ[i] != FH)
if(ice_block[R + EXX[i]][C + EXY[i]][H + EXZ[i]])
ret += DFS2(R + EXX[i],C + EXY[i],H + EXZ[i],R,C,H);//dfs深入
return ice_block[R][C][H] = 0, ret + 1;//更新冰砖存在情况,更新删除个数
}
void REMOVE_ICE_BLOCK()
{
int R = read(), C = read(), H = read();
if(!ice_block[R][C][H]) {printf("BAKA CIRNO,THERE IS NO ICE_BLOCK\n"); return ;}//不合法情况
ice_block[R][C][H] = 0, inventory ++;//移除冰砖, 并 加入库存
if(H == 0) ground_freeze[R][C] = 0;//将地面 冰砖移走,冰冻度置零
int sum_break = 0;//碎掉冰砖个数
for(int i = 0; i < 6; i ++)//枚举被删除位置 相邻的 存在的 冰砖
if(R + EXX[i] >= 0 && R + EXX[i] < N && C + EXY[i] >= 0)
if(C + EXY[i] < N && H + EXZ[i] >= 0 && H + EXZ[i] <= HM)
if(ice_block[R + EXX[i]][C + EXY[i]][H + EXZ[i]])
{
memset(vis,0,sizeof(vis));//dfs判断 相邻冰砖 连通块是否与 地面接触
if(!DFS1(R + EXX[i],C + EXY[i],H + EXZ[i],-1,-1,-1))
sum_break += DFS2(R + EXX[i],C + EXY[i],H + EXZ[i],-1,-1,-1);
}
printf("CIRNO REMOVED AN ICE_BLOCK");//按情况输出
if(sum_break) printf(",AND %d BLOCK(S) ARE BROKEN",sum_break);
printf("\n");
}
void MAKE_ROOF()
{
int remove = 0, filled = 0, corner_filled = 0;//判断 是否移除多余 , 填补残缺 , 墙角残缺
max_high = find_max_high() + 1;//找到 墙壁最高高度
//搭建 房顶:
{
for(int x = HR; x < HR + HX; x ++)//枚举 最高高度处 所有位置
for(int y = HC; y < HC + HY; y ++)
{
inventory -= (!ice_block[x][y][max_high]);//更新
ice_block[x][y][max_high] = 1;
}
if(inventory < 0) {printf("SORRY CIRNO,NOT ENOUGH ICE_BLOCK(S) TO MAKE ROOF\n"); return ;}//不合法情况
if(max_high < 2 || (HX - 2)*(HY - 2)*max_high < 2) {printf("SORRY CIRNO,HOUSE IS TOO SMALL\n"); return ;}
}
//移除 多余冰砖:
{
int inside = 0, outside = 0;
remove_excess(outside,inside);// 移除多余
remove = (inside || outside);//判断是否 移除
printf("%d ICE_BLOCK(S) INSIDE THE HOUSE NEED TO BE REMOVED\n",inside);//按情况输出
printf("%d ICE_BLOCK(S) OUTSIDE THE HOUSE NEED TO BE REMOVED\n",outside);
if(!DFS1(HR + 1,HC + 1,max_high,-1,-1,-1)) {printf("SORRY CIRNO,HOUSE IS BROKEN WHEN REMOVING BLOCKS\n"); return ;}//判断 屋顶连通块是否悬空
}
//填补 墙壁残缺:
{
filled = fill_high_wall(max_high);//填补 高度>=2处
filled += find_door();//在高度 <2处寻找门,并填补
if(inventory < 0) {printf("SORRY CIRNO,NOT ENOUGH ICE_BLOCKS TO FIX THE WALL\n"); return ;}//不合法情况
}
//检查小屋:
{
printf("GOOD JOB CIRNO,SUCCESSFULLY BUILT THE HOUSE\n");
if(door_high == 2) printf("DOOR IS OK\n");//有 高为2的门
else inventory += (2 - door_high), printf("HOUSE HAS NO DOOR\n");//移除冰块建门,库存增加
if(filled) printf("WALL NEED TO BE FIXED\n");//填补过残缺
else printf("WALL IS OK\n");
for(int z = 0; z <= max_high; z ++) //判断 墙角的完整性
for(int x = HR; x < HR + HX; x += HX - 1)
for(int y = HC; y < HC + HY; y += HY - 1)
if(!ice_block[x][y][z]) corner_filled = 1, inventory --;
if(corner_filled) printf("CORNER NEED TO BE FIXED\n");
else printf("CORNER IS OK\n");
printf("CIRNO FINALLY HAS %d ICE_BLOCK(S)\n",inventory >= 0?inventory:0);//最后的冰砖数 (若修复过墙角,会导致 库存<=0,此时还会再制造冰砖并补齐空缺
if((!remove) && (!filled) && door_high == 2 && (!corner_filled) && (!door_dis)) //不愧是琪露诺! 轻易就做到了我们做不到的事
printf("CIRNO IS PERFECT!");
}
}
//MAKE_ROOF 子操作
int find_max_high()//寻找 墙壁最高处
{
for(int i = HM; i >= 0; i --)//自上往下枚举 高度
{
for(int j = HC; j < HC + HY; j ++)//枚举每一面墙
if(ice_block[HR][j][i]) return i;
for(int j = HC; j < HC + HY; j ++)
if(ice_block[HR + HX - 1][j][i]) return i;
for(int j = HR; j < HR + HX; j ++)
if(ice_block[j][HC][i]) return i;
for(int j = HR; j < HR + HX; j ++)
if(ice_block[j][HC + HY - 1][i]) return i;
}
return -1;
}
bool judge_outside(int x,int y,int z)//判断 某位置 是否在房外
{
if(HR <= x && x < HR + HX)
if(HC <= y && y < HC + HY)
if(z <= max_high) return 0;
return 1;
}
bool judge_inside(int x,int y,int z)//判断 某位置 是否在房内
{
if(HR < x && x < HR + HX - 1)
if(HC < y && y < HC + HY - 1)
if(z < max_high) return 1;
return 0;
}
void remove_excess(int &outside,int &inside)//移除 多余方块
{
for(int x = 0; x < N; x ++)//枚举 立体空间内 每一个位置
for(int y = 0; y < N; y ++)
for(int z = 0; z <= HM; z ++)
if(ice_block[x][y][z])//存在冰块
{
if(judge_outside(x,y,z)) inventory ++, outside ++, ice_block[x][y][z] = 0;//在屋外
if(judge_inside(x,y,z)) inventory ++, inside ++, ice_block[x][y][z] = 0;//在屋内
if(!ice_block[x][y][z])//冰块被移除后
for(int i = 0; i < 6; i ++)
if(x + EXX[i] >= 0 && x + EXX[i] < N && y + EXY[i] >= 0) //枚举相邻合法位置的 的 存在的 冰砖
if(y + EXY[i] < N && z + EXZ[i] >= 0 && z + EXZ[i] <= HM)
if(ice_block[x + EXX[i]][y + EXY[i]][z + EXZ[i]])
if(!judge_outside(x + EXX[i],y + EXY[i],z + EXZ[i]) && (!judge_inside(x + EXX[i],y + EXY[i],z + EXZ[i])))//如果在 墙壁上
{
memset(vis,0,sizeof(vis));
if(!DFS1(x + EXX[i],y + EXY[i],z + EXZ[i],-1,-1,-1)) //如果 移除此位置后 墙壁上的 冰砖会摔碎
inventory ++, ice_block[x + EXX[i]][y + EXY[i]][z + EXZ[i]] = 0;//将其移除 ,加入库存
}
}
}
bool fill_high_wall(int max_high)//填补 高度 >= 2处的墙
{
bool filled = 0;
for(int x = HR; x < HR + HX; x ++)//枚举每一个位置
for(int y = HC; y < HC + HY; y ++)
for(int z = 2; z <= max_high; z ++)
if(!judge_outside(x,y,z))//判断 在墙上
if(!judge_inside(x,y,z))
if(!ice_block[x][y][z])
{
if(x == HR && y == HC) continue;//在墙角,则 跳过
if(x == HR && y == HC + HY - 1) continue;
if(x == HR + HX - 1 && y == HC) continue;
if(x == HR + HX - 1 && y== HC + HY - 1) continue;
inventory --, filled = 1, ice_block[x][y][z] = 1;//填补
}
return filled;//返回 是否填补过
}
int judge_corner(int x,int y)//判断位置 (x,y) 是否与墙角相邻
{
int ret = 0; //表示 一门的候选位置相邻的墙角 的 状态
if(x == HR)//枚举并判断 ,
{
if(y == HC + 1) ret += 1;
else if(y == HC + HY - 2) ret += 2;
}
if(x == HR + 1)
{
if(y == HC) ret += 1;
else if(y == HC + HY - 1) ret += 2;
}
if(x == HR + HX - 2)
{
if(y == HC) ret += 4;
else if(y == HC + HY - 1) ret += 8;
}
if(x == HR + HX - 1)
{
if(y == HC + 1) ret += 4;
else if(y == HC + HY - 2) ret += 8;
}
return ret;
}
void corner_could_see(int x,int y,int z,int h,int &corner,int &corner_pos)//计算一个位置(x,y,z) 能看到的墙角的残缺数
{
corner_pos = judge_corner(x, y);//判断 是否哪个墙角, 并获得 此位置相邻的墙角 的 状态
corner = 0;
if(!corner_pos) return;//不与墙角相邻
for(int i = 0; i < 4; i ++)//枚举墙角
if((1 << i )& corner_pos)
{
int x1 = corner_x[1 << i], y1 = corner_y[1 << i];//计算残缺
corner += (!ice_block[x1][y1][z]) + (!ice_block[x1][y1][!z])*(h == 2);
}
}
bool find_door()//在 高度<2的位置 找门 ,并填补非门区域
{
std:: vector <alternative_position> pos;//门的候选位置
int incomplete = 0, filled_sum = 0, corner_filled = 0;//残缺数, 填补数, 墙角位置的填补数
int midX1 = (HX + 1) /2 + HR - 1, midX2 = (HX + 2) /2 + HR - 1;//两墙壁中间位置
int midY1 = (HY + 1) /2 + HC - 1, midY2 = (HY + 2) /2 + HC - 1;
for(int x = HR + 1, corner, corner_pos; x < HR + HX - 1; x ++)//枚举 墙上位置
for(int y = HC; y < HC + HY; y += HY - 1)
if(!ice_block[x][y][0])//根据 残缺的存在情况 进行判断 ,并加入候选位置
{
int z = 0, h = 1 + (!ice_block[x][y][1]); incomplete += h;
corner_could_see(x,y,z,h,corner,corner_pos);
pos.push_back((alternative_position) {x,y,0,h,x,corner,corner_pos,midX1,midX2});
}
else if(!ice_block[x][y][1])
{
corner_could_see(x,y,1,1,corner,corner_pos); incomplete += 1;
pos.push_back((alternative_position) {x,y,1,1,x,corner,corner_pos,midX1,midX2});
}
for(int y = HC + 1, corner, corner_pos; y < HC + HY - 1; y ++)//枚举 墙上位置
for(int x = HR; x < HR + HX; x += HX - 1)
if(!ice_block[x][y][0])//根据 残缺的存在情况 进行判断 ,并加入候选位置
{
int z = 0, h = 1 + (!ice_block[x][y][1]); incomplete += h;
corner_could_see(x,y,z,h,corner,corner_pos);
pos.push_back((alternative_position) {x,y,0,h,y,corner,corner_pos,midY1,midY2});
}
else if(!ice_block[x][y][1])
{
corner_could_see(x,y,1,1,corner,corner_pos); incomplete += 1;
pos.push_back((alternative_position) {x,y,1,1,y,corner,corner_pos,midY1,midY2});
}
std::sort(pos.begin(), pos.end(), cmp);//排序估值
if(pos.size()) //若有候选位置 可以选择 ,选择 最优的 位置
{
filled_sum = incomplete - pos[0].h + pos[0].corner;
doorx = pos[0].x, doory = pos[0].y, doorz = pos[0].z, door_high =pos[0].h;
door_dis = min(abs(pos[0].wall - pos[0].mid1), abs(pos[0].wall - pos[0].mid2));
}
if(door_high == 1 && filled_sum < inventory) //已选择的残缺大小为1, 库存冰块足够选择更大的残缺
for(int i = 1, size = pos.size(); i < size; i ++)//找到 最优的 高度为2的残缺
if(pos[i].h == 2)
{
filled_sum = incomplete - pos[i].h + pos[i].corner;
doorx = pos[i].x, doory = pos[i].y, doorz = pos[i].z, door_high = pos[i].h;
door_dis = min(abs(pos[i].wall - pos[i].mid1), abs(pos[i].wall - pos[i].mid2));
break;
}
inventory -= filled_sum;//更新库存
for(int i = 0, size = pos.size(); i < size; i ++)//填补 非门空缺
if(pos[i].x != doorx && pos[i].y != doory && pos[i].z != doorz)//空缺 不为门
{
int x = pos[i].x, y = pos[i].y, z = pos[i].z;
if(pos[i].h == 2) ice_block[x][y][1] = 1;
ice_block[x][y][z] = 1;
}
else if(pos[i].x == doorx && pos[i].y == doory && pos[i].z == doorz && pos[i].corner_pos)
{
for(int j = 0; j < 4; j ++) //空缺为门 , 填补 可以看到的墙角空缺
if((1 << j) & pos[i].corner_pos)//枚举墙角
{
int x = corner_x[1 << j], y = corner_y[1 << j];//计算答案
corner_filled += (!ice_block[x][y][doorz]);
ice_block[x][y][doorz] = 1;
if(door_high == 2) corner_filled +=(!ice_block[x][y][!doorz]), ice_block[x][y][!doorz] = 1;
}
}
return filled_sum;
}
最后无良宣传一下博客 \(wwwwww\)
文章列表 - 地灵殿 - 洛谷博客
\(\text{Updata on 2019.10.19 :}\)
数据加强后 原题解被卡掉了= =
修改了 对在门与柱子相邻时 对柱子残缺的判断
添加了 算法实现
作者@Luckyblock，转载请声明出处。
