NOIP模拟赛 17.10.10

初次见面（firstmeet）
【题目背景】
雾之湖边，静得可怕。
露米娅出神凝望。黑白连衣裙，像极了绽放的墨黑和洁白的莲。身边的雾之
湖，倒映着血色天空。酒红的双眸，映照一切。低声浅笑，双臂伸直，她悄无声
息地没入一抹黑暗中，纵身一跃，便穿梭在无尽的苍穹之下。漆黑，在她的身
影上缠绕，蔓延......
空中，红白的巫女灵梦正在低低的飞着，享受着清爽的微风。
突然，灵梦的速度放缓，笑意渐渐凝固——灵梦与露米娅就此见面。
灵梦瞳孔骤缩，那嗜血的笑容，无力的啜泣，血红染满的双手，欣慰却又毫
无生机的微笑......一系列画面先潮水般涌入她的脑海，进而又碎得无影无踪。
无助，失落，灵梦攥紧双拳，想要留下些什么，却又真的无能为力。终于，
她厉声向对面喊道：“这红雾是你放的吧！？”话语未落便祭出阴阳玉，摆出阵
法，绚丽的弹幕旋即铺天盖地地扎了过去。
【问题描述】
此次灵梦发动的阵法可以看做是一个n*n的矩阵，阵法的每行都有一个阴阳
玉，矩阵的其余位置为空，保证任意两个阴阳玉不在同一行，不在同一列，想要
成功发动阵法，灵梦必须在阵法中放置n 张符纸。符纸的放置需满足以下要求：
1.有阴阳玉的地方不能放置符纸；
2.每行只能有一张符纸；
3.每列只能有一张符纸。
在满足上述要求下，符纸放置的方案数就为此次阵法的攻击力，求灵梦此次
阵法的攻击力为多少。
【输入格式】
第一行一个n，接下来一个n*n的矩阵。1 表示有阴阳玉，0 表示位置为空。
【输出格式】
一行一个整数，为阵法的攻击力。
【样例1 输入】
2
1 0
0 1
【样例1 输出】
東方模拟赛3
第4 页共12 页
1
【样例1 说明】
仅有(1, 0) , (0 ,1)为一个合法的方案
【样例2 输入】
6
1 0 0 0 0 0
0 0 0 1 0 0
0 0 1 0 0 0
0 1 0 0 0 0
0 0 0 0 1 0
0 0 0 0 0 1
【样例2 输出】
265

【题解】

题目有一个很强大的限制：不能走的格子必须满足不在同一行，不在同一列

可以发现交换行，不影响结果

我们把他们交换到对角线上

就成了一个错排问题

对拍找规律也不难发现

下面这个会T，因为没有压位高精

但是BZOJ4563 不会T

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #define min(a, b) ((a) < (b) ? (a) : (b))
 #define max(a, b) ((a) > (b) ? (a) : (b))

 inline void swap(int &x, int &y)
 {
     int tmp = x;x = y;y = tmp;
 }

 inline void read(int &x)
 {
     x = ;char ch = getchar(), c = ch;
     while(ch < '' || ch > '')c = ch, ch = getchar();
     while(ch <= '' && ch >= '')x = x *  + ch - '', ch = getchar();
     if(c == '-')x = -x;
 }

 const int INF = 0x3f3f3f3f;
 const int MAXN =  + ;

 int n;

 struct BigNum
 {
     int n, data[];
     void put()
     {
         for(register int i = n;i >= ;-- i)
             putchar(data[i] + '');
     }
     void clean()
     {
         n = ;memset(data, , sizeof(data));
     }
 }pre[];

 int pp,p,now;

 void add()
 {
     register int len = pre[pp].n;
     for(register int i = ;i <= len;++ i)
         pre[now].data[i] = pre[pp].data[i] + pre[p].data[i];
     len = pre[p].n;
     for(register int i = pre[pp].n + ; i <= len;++ i)
         pre[now].data[i] = pre[p].data[i];
     for(register int i = ;i < len;++ i)
         if(pre[now].data[i] >= )pre[now].data[i + ] += pre[now].data[i]/, pre[now].data[i] -= ;
     for(;pre[now].data[len] >= ;++ len)
         pre[now].data[len + ] += pre[now].data[len]/, pre[now].data[len] -= ;
     pre[now].n = len;
 }

 void mul(int b)
 {
     for(register int i = ;i <= pre[now].n;++ i)
         pre[now].data[i] *= b;
     for(register int i = ;i < pre[now].n;++ i)
         if(pre[now].data[i] >= )pre[now].data[i + ] += pre[now].data[i]/, pre[now].data[i] %= ;
     register int len = pre[now].n;
     for(;pre[now].data[len] >= ;++ len)
          pre[now].data[len + ] += pre[now].data[len]/, pre[now].data[len] %= ;
     pre[now].n = len;
 }

 int main()
 {
     read(n);
     pp = , p = , now = ;
     pre[pp].n = ;pre[p].n = , pre[p].data[] = ;
     if(n == )pre[pp].put();
     else if(n == )pre[p].put();
     else
     {
         for(register int i = ;i < n;++ i)
         {
             add();
             mul(i);
             if(i != n - )
                 swap(pp, now);swap(pp, p);
         }
         pre[now].put();
     }
     return ;
 }

T1

好久不见（longnosee）
【题目背景】
“那些画面是什么！”灵梦紧紧握着手中的符纸，向露米娅喊道。露米娅并
不答话，只是微笑着，转身便是一袭五彩斑斓的弹幕。
灵梦身形一侧，堪堪躲过，身后两颗浮动的阴阳玉在空中曳出一抹朦胧的暗
红，金色的符纸不断从露米娅的身边擦过，却并未有一张击中她。
心中的直觉让灵梦知道红雾与面前的少女毫无关系，但是那悸动的感觉让她
不愿就此离去，两人的弹幕虽然分外密集，但却根本未伤彼此分毫，灵梦心中的
急躁之感越来越重，露米娅的笑容越来越淡，终于，露米娅停了下来，低低地喃
喃了一句：
暗符「Demarcation」!
【问题描述】
露米娅发出的Demarcation 是她的终符，露米娅会发出一个有n 个点的树形
的弹幕，点之间由能量线相连，Demarcation 的攻击力取决于其树形结构直径。
如果这样完整的一个终符击中灵梦，灵梦就没有能力继续去解决红雾异变
了。但是灵梦有一个办法，她可以用阴阳玉击破能量线，从而使原来整个树形结
构的Demarcation 变成若干个树形结构，此时Demarcation 的攻击力取决于这若
干个树形结构中的最大直径。
可是之前的战斗已经消耗了灵梦不少的体力，所以她最多能够再用出p 个阴
阳玉来击破p 道能量线，灵梦想要使切断能量线后剩余的若干树形弹幕的直径最
大值最小，这样她才能正确估计Demarcation 的攻击力并做出正确的防御，求最
小的攻击力为多少。
【输入格式】
第一行两个正整数n, p。
下面n 1行，每行两个正整数u, v，表示一条u到v的双向边。
【输出格式】
一行一个正整数为最小的攻击力。
【样例1 输入】
5 2
1 2
1 3
3 4
4 5
【样例1 输出】
1
【样例1 说明】
其中一种可行的方案为：
击破能量线13
击破能量线34。
【样例2 输入】
16 4
1 2
1 3
2 4
2 5
3 6
3 7
3 8
6 9
6 10
10 15
10 16
7 11
7 12
12 13
12 14
【样例2 输出】
3
【样例2 说明】
对于样例2 给定的树形弹幕
其中一种可行的方案为：
击破能量线36
击破能量线37
击破能量线38
不必全用完4 个阴阳玉。
東方模拟赛3

【题解】

“最大值最小”显然二分

二分链长，贪心删除子树中通过根节点且链长>mid的最长的一条分链

显然法证明即可。。。

BZOJ2097

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #define max(a, b) ((a) > (b) ? (a) : (b))
 #define min(A, b) ((a) < (b) ? (a) : (b))

 const int INF = 0X3f3f3f3f;
 const int MAXN =  + ;

 inline void read(int &x)
 {
     x = ;char ch = getchar(), c = ch;
     while(ch < '' || ch > '')c = ch, ch = getchar();
     while(ch <= '' && ch >= '')x = x *  + ch - '', ch = getchar();
     if(c == '-')x = -x;
 }

 struct Edge
 {
     int u,v,next;
     Edge(int _u,int _v,int _next){u = _u;v = _v;next = _next;}
     Edge(){}
 }edge[MAXN << ];
 int head[MAXN], cnt;
 inline void insert(int a, int b)
 {
     edge[++cnt] = Edge(a,b,head[a]);
     head[a] = cnt;
 }

 int n,p,mid,ans;

 int tmp[MAXN],f[MAXN];

 void dfs(int u, int fa)
 {
     for(register int pos = head[u];pos;pos = edge[pos].next)
     {
         int v = edge[pos].v;
         if(v == fa)continue;
         dfs(v, u);
     }
     int cnt = ;
     for(register int pos = head[u];pos;pos = edge[pos].next)
     {
         int v = edge[pos].v;
         if(v == fa)continue;
         tmp[++ cnt] = f[v] + ;
     }
     std::sort(tmp + , tmp +  + cnt);
     for(;cnt;-- cnt)
     {
         if(tmp[cnt] + tmp[cnt - ] > mid) ++ ans;
         else break;
     }
     f[u] = tmp[cnt];
 }

 int main()
 {
     read(n), read(p);
     int tmp1,tmp2;
     for(register int i = ;i < n;++ i)
     {
         read(tmp1), read(tmp2);
         insert(tmp1, tmp2);
         insert(tmp2, tmp1);
     }
     int l = , r = n, answer = ;
     while(l <= r)
     {
         memset(f, , sizeof(f));
         ans = ;
         mid = (l + r) >> ;dfs(, );
         if(ans <= p)answer = mid, r = mid - ;
         else l = mid + ;
     }
     printf("%d", answer);
     return ;
 }

T2

好久不见（longnosee）
【题目背景】
“那些画面是什么！”灵梦紧紧握着手中的符纸，向露米娅喊道。露米娅并
不答话，只是微笑着，转身便是一袭五彩斑斓的弹幕。
灵梦身形一侧，堪堪躲过，身后两颗浮动的阴阳玉在空中曳出一抹朦胧的暗
红，金色的符纸不断从露米娅的身边擦过，却并未有一张击中她。
心中的直觉让灵梦知道红雾与面前的少女毫无关系，但是那悸动的感觉让她
不愿就此离去，两人的弹幕虽然分外密集，但却根本未伤彼此分毫，灵梦心中的
急躁之感越来越重，露米娅的笑容越来越淡，终于，露米娅停了下来，低低地喃
喃了一句：
暗符「Demarcation」!
【问题描述】
露米娅发出的Demarcation 是她的终符，露米娅会发出一个有n 个点的树形
的弹幕，点之间由能量线相连，Demarcation 的攻击力取决于其树形结构直径。
如果这样完整的一个终符击中灵梦，灵梦就没有能力继续去解决红雾异变
了。但是灵梦有一个办法，她可以用阴阳玉击破能量线，从而使原来整个树形结
构的Demarcation 变成若干个树形结构，此时Demarcation 的攻击力取决于这若
干个树形结构中的最大直径。
可是之前的战斗已经消耗了灵梦不少的体力，所以她最多能够再用出p 个阴
阳玉来击破p 道能量线，灵梦想要使切断能量线后剩余的若干树形弹幕的直径最
大值最小，这样她才能正确估计Demarcation 的攻击力并做出正确的防御，求最
小的攻击力为多少。
【输入格式】
第一行两个正整数n, p。
下面n 1行，每行两个正整数u, v，表示一条u到v的双向边。
【输出格式】
一行一个正整数为最小的攻击力。
【样例1 输入】
5 2
1 2
1 3
3 4
4 5
【样例1 输出】
1
【样例1 说明】
其中一种可行的方案为：
击破能量线13
击破能量线34。
【样例2 输入】
16 4
1 2
1 3
2 4
2 5
3 6
3 7
3 8
6 9
6 10
10 15
10 16
7 11
7 12
12 13
12 14
【样例2 输出】
3
【样例2 说明】
对于样例2 给定的树形弹幕
其中一种可行的方案为：
击破能量线36
击破能量线37
击破能量线38
不必全用完4 个阴阳玉。

愿你安好（blessyou）
【题目背景】
死一般的寂静。被击破的露米娅无力的躺在地上，脸上挂着的还是那亘古不
变的微笑。
灵梦缓缓地落下，地上是素未谋面却又感觉无比熟悉的露米娅，不知怎么，
她总觉得那笑容，不是自己所熟悉的笑容。
“你。。是不会笑而在笑吗？”露米娅怔住了，晶莹的泪珠开始从两颊划过。
她闭上了眼，不再看向灵梦。
久驻无语，灵梦裙角轻轻飞舞，她后退一步，转而飞向了远方，脑海中一个
朦胧的倩影，金色的发丝上绑着的红缎带，渐渐的与露米娅的身影重合，只是笑
容比她真实，年龄比她更大。
留在原地的原地的露米娅无神的双眼望向天空，喃喃道：“不是我不会笑啊。。
我只是不能对你笑啊。因为我是——
宵暗的妖怪啊！”
【问题描述】
失落的灵梦无助地向着红雾的源头飞去，可是在飞过一片绿地时，突然一片
漆黑大雾笼罩住了她，霎时灵梦的眼前一片黑暗，身体无法动弹，渐渐地她感到
身体的力气一点一点地在流逝，想要反抗的灵梦却发现根本是徒劳。她想要呐喊
却发现什么也做不到。黑雾可以看做是一个n m z的立方体，灵梦此时处于其
中的某个位置上，可以把黑雾看做是一个三维坐标系，分X , Y , Z 轴。
这时，绝望的灵梦突然听到了漆黑中传来了异样的声音，她万念俱灰，闭上
眼睛，任凭身体缓缓躺平，放弃了挣扎。。。
“我将会尽我最后的力量，为你准备一个逃生的宵暗隧道，但是我的力量已
经不多了，隧道的形状与数量，已经不是我能够掌控的了。”露米娅那柔和的声
音在灵梦耳边响起。
灵梦猛的睁开眼，发现眼前虽仍是黑暗，但是自己却可以清楚的感知到整片
黑雾的内部构造，在黑雾的某些地方，有些不知为何物的银色立方体，正在发着
幽幽的光芒，灵梦的直觉告诉她这些东西一定非常危险。
“为什么要帮我！”灵梦问道。
“我的时间已经不多了，听我的话！感受它，控制它！”露米娅并不答话，
而是这样说道。
这时，12 个一模一样的小小的隧道已经悬浮在了灵梦身边，虽然也是黑色的，
却与身边的黑雾有着本质的区别，并且，给了灵梦一种莫名的安心之感。
露米娅的隧道可以看做是由几个空心的立方体组成，形状如下图所示。
其中内部为空，且可以从白面出入，只可以将白面拼接。
“小灵梦，黑雾的出口我已经探查清楚了，我会用意念传达给你。”依旧是
那温和的声音，只不过声音已经比上次虚弱太多了。
一丝光点出现在灵梦的脑海中，突然光明驱散了面前无尽的黑暗，她此时正
置身于一个封闭的空间中，脚下是一望无尽的虚空，抬头望去，一个散发着无限
曙光的出口赫然摆在那里！。
“你可以用意念驱散这些隧道组合成不同的形状，使得互相两个隧道的入口
（白面）相接，这样你就可以从隧道中逃出去了。。。小灵梦，我能帮你的。。
也就只有这些了。不过要注意，千万不要让这些隧道伸到这片空间的外面，隧道
也不能够彼此相交，也不要将隧道放置在那些银色的立方体上，否则你会被时空
逆流给撕成碎片的。切记。”
灵梦能用意念控制隧道，使得白面相互连接，如下图所示。
露米娅的声音就此消失。灵梦没有隧道无法在空间内移动，她想要成功逃出
去，只有用这12 个隧道（可以不全用），拼出一套从灵梦当前位置到出口的通
道，且灵梦的初始位置与某隧道的白面相接，出口与某隧道的白面相接，且隧
道与隧道之间白面相接，灵梦才能获救。
由于这12 个隧道都是耗费的露米娅的生命力量，所以用隧道越少越好，否则
灵梦将再也无法得知那种熟悉的感觉从何而来，求最少需要几个隧道才能联通灵
梦现在的位置与出口，若无法联通，输出"Dream Battle"。
【输入格式】
输入的第一行包含4个正整数n , m , z , p表示黑雾的长，高，宽和银色立方
体的数量。
输入的第二行包含三个正整数s s s x , y , z 和一个字符c，其中( , , ) s s s x y z 是灵
梦初始位置，c的值为' x' , ' y'或' z',用于指示入口所在的面。
当c为' x'时，表示灵梦初始位置所在的面与YZ坐标平面平行。
当c为' y'时，表示灵梦初始位置所在的面与XZ 坐标平面平行。
当c为' z'时，表示灵梦初始位置所在的面与XY 坐标平面平行。
输入保证灵梦初始位置所在的面在黑雾表面（即一个立方体的表面）。
数字和数字，数字和字符之间用一个空格隔开。
输入的第三行包含三个正整数t t t x , y , z 和一个字符c，其中( , , ) t t t x y z 是出
口位置，意义同上。
接下来p 行，每行包含三个正整数i i i x , y , z ，表示在( , , ) i i i x y z 的位置有银
色立方体。
【输出格式】
输出包含一个1个正整数，表示最少使用的隧道的数量，如果灵梦不能成功
逃脱（即无法通过接隧道来使隧道的某一开口与出口恰好相接），
输出"Dream Battle"。
【样例1 输入】
5 4 3 1
3 1 1 z
1 4 3 x
2 3 3
【样例1 输出】
2
【样例2 输入】
10 10 10 7
4 10 1 z
9 3 10 z
1 8 3
9 6 8
7 4 2
4 1 6
3 5 10
5 4 6
9 9 8
【样例2 输出】
7
数据保证初始位置与出口在黑雾的表面上
灵梦最终也未知道为何露米娅会带给她如此安心，熟悉的感觉。
在灵梦成功逃脱出黑雾后，露米娅的身影已经消失的无影无踪，是生是死也未曾得知。
只剩一条红色的缎带在地上孤独的存在着。

【题解】

爆搜即可

用类似A*的思想加一点剪枝即可

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 //#define abs(a) ((a) < 0 ? (-1 * (a)) : (a))
 //#define ok(x, y, a) ((x) >= 1 && (y) >= 1 && (a) >= 1 && (x) <= n && (y) <= m && (a) <= z && !b[x][y][a])
 #define min(a, b) ((a) < (b) ? (a) : (b))
 #define max(a, b) ((a) > (b) ? (a) : (b))

 const int INF = 0X3f3f3f3f;
 const int dx[] = {,-,,,,};
 const int dy[] = {,,,-,,};
 const int dz[] = {,,,,,-};

 inline void read(int &x)
 {
     x = ;char ch = getchar(), c = ch;
     while(ch < '' || ch > '')c = ch, ch = getchar();
     while(ch <= '' && ch >= '')x = x *  + ch - '', ch = getchar();
     if(c == '-')x = -x;
 }

 int n,m,t,p,b[][][],sx,sy,sz,ex,ey,ez,ans,sdir,edir;
 char sc,ec;

 inline int abs(int a)
 {
     return a <  ? -a : a;
 }

 inline int ok(int x, int y, int z)
 {
     return x >  && y >  && z >  && x <= n && y <= m && z <= t && (!b[x][y][z]);
 }

 struct Node
 {
     int num,dir;
     Node(int _num, int _dir){num = _num;dir = _dir;}
     Node(){}
 }fangan[],xuelie[];
 int tot;

 //表示当前格子x,y,z已经放了，尝试放到dir方向， 已经放了num个
 void dfs(int x, int y, int z, int dir, int num)
 {
     if(num + (abs(ex - x) + abs(ey - y) + abs(ez - z))/ >= ans)return;
     if(x == ex && y == ey && z == ez && dir == edir)
     {
         ans = min(ans, num);
         return;
     }
     //走两步，然后四个方向走两步
     if(ok(x + dx[dir], y + dy[dir], z + dz[dir]) && ok(x + dx[dir] * , y + dy[dir] * , z + dz[dir] * ))
     {
         b[x + dx[dir]][y + dy[dir]][z + dz[dir]] = b[x + dx[dir] * ][y + dy[dir] * ][z + dz[dir] * ] = ;
         x += (dx[dir] * ), y += (dy[dir] * ), z += (dz[dir] * );
         for(register int i = ;i < ;++ i)
         {
             if((i | ) == (dir | ))continue;
             if(ok(x + dx[i], y + dy[i], z + dz[i]) && ok(x + dx[i] * , y + dy[i] * , z + dz[i] * ))
             {
                 b[x + dx[i]][y + dy[i]][z + dz[i]] = b[x + dx[i] * ][y + dy[i] * ][z + dz[i] * ] = ;
                 fangan[++tot] = Node(, dir);
                 fangan[++tot] = Node(, i);
                 dfs(x + dx[i] * , y + dy[i] * , z + dz[i] * , i, num + );
                 tot -= ;
                 b[x + dx[i]][y + dy[i]][z + dz[i]] = b[x + dx[i] * ][y + dy[i] * ][z + dz[i] * ] = ;
             }
         }
         x -= (dx[dir] * ), y -= (dy[dir] * ), z -= (dz[dir] * );
         b[x + dx[dir]][y + dy[dir]][z + dz[dir]] = b[x + dx[dir] * ][y + dy[dir] * ][z + dz[dir] * ] = ;
     }

     //走三步，然后四个方向走一步
     if(ok(x + dx[dir], y + dy[dir], z + dz[dir]) && ok(x + dx[dir] * , y + dy[dir] * , z + dz[dir] * ) && ok(x + dx[dir] * , y + dy[dir] * , z + dz[dir] * ))
     {
         b[x + dx[dir]][y + dy[dir]][z + dz[dir]] = b[x + dx[dir] * ][y + dy[dir] * ][z + dz[dir] * ] = b[x + dx[dir] * ][y + dy[dir] * ][z + dz[dir] * ] = ;
         x += (dx[dir] * ), y += (dy[dir] * ), z += (dz[dir] * );
         for(register int i = ;i < ;++ i)
         {
             if((i | ) == (dir | ))continue;
             if(ok(x + dx[i], y + dy[i], z + dz[i]))
             {
                 b[x + dx[i]][y + dy[i]][z + dz[i]] = ;
                 fangan[++tot] = Node(, dir);
                 fangan[++tot] = Node(, i);
                 dfs(x + dx[i], y + dy[i], z + dz[i], i, num + );
                 tot -= ;
                 b[x + dx[i]][y + dy[i]][z + dz[i]] = ;
             }
         }
         x -= (dx[dir] * ), y -= (dy[dir] * ), z -= (dz[dir] * );
         b[x + dx[dir]][y + dy[dir]][z + dz[dir]] = b[x + dx[dir] * ][y + dy[dir] * ][z + dz[dir] * ] = b[x + dx[dir] * ][y + dy[dir] * ][z + dz[dir] * ] = ;
     }
 } 

 int main()
 {
     freopen ("blessyou.in", "r", stdin); freopen ("blessyou.out", "w", stdout);
     read(n), read(m), read(t), read(p);
     read(sx), read(sy), read(sz);scanf("%c", &sc);
     read(ex), read(ey), read(ez);scanf("%c", &ec);
     for(register int i = ;i <= p;++ i)
     {
         int tmp1,tmp2,tmp3;
         read(tmp1), read(tmp2), read(tmp3);
         b[tmp1][tmp2][tmp3] = ;
     }
     ans = ;
     if(sc == 'x')
     {
         if(sx == ) sdir = , sx -= ;
         else sdir = , sx += ;
     }
     else if(sc == 'y')
     {
         if(sy == ) sdir = , sy -= ;
         else sdir = , sy += ;
     }
     else
     {
         if(sz == ) sdir = , sz -= ;
         else sdir = , sz += ;
     }
     if(ec == 'x')
     {
         if(ex == n) edir = ;
         else edir = ;
     }
     else if(ec == 'y')
     {
         if(ey == m) edir = ;
         else edir = ;
     }
     else
     {
         if(ez == t) edir = ;
         else edir = ;
     }
     dfs(sx,sy,sz,sdir,);
     if(ans == )printf("Dream Battle");
     else printf("%d", ans);
     return ;
 }

T3