牛客小白月赛21

题号	标题	已通过代码	题解	讨论	通过率	我的状态
A	Audio	点击查看	进入题解	进入讨论	498/1102	通过
B	Bits	点击查看	进入题解	进入讨论	19/39	未通过
C	Channels	点击查看	进入题解	进入讨论	275/1227	通过
D	DDoS	点击查看	进入题解	进入讨论	41/188	未通过
E	Exams	点击查看	进入题解	进入讨论	218/607	通过
F	Fool Problem	点击查看	进入题解	进入讨论	489/1357	通过
G	Game	点击查看	进入题解	进入讨论	207/617	通过
H	”Happy New Year!“	点击查看	进入题解	进入讨论	1120/2908	通过
I	I love you	点击查看	进入题解	进入讨论	172/312	通过
J	Jelly	点击查看	进入题解	进入讨论	174/511	通过

A Audio

链接：https://ac.nowcoder.com/acm/contest/3947/A
来源：牛客网

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述

Nancy很喜欢音乐。
她能同时分辨出三种不同的音乐。恰巧，一座城市中有三处同时有交响音乐会（音源响度相同）。但是Nancy每一场都不想错过，于是她想寻找一个地点，使得三处音乐会声音的响度相同，这样她就可以同时欣赏三场音乐会啦！
（注：假设声音传播过程中不会受障碍物作用，声音传播满足平方反比定律）

输入描述:

共三行：每行两个整数xix_ixi与yiy_iyi，三点不共线。
数据满足：0≤∣xi∣,∣yi∣≤1090 \leq |x_i|, |y_i| \leq 10^{9}0≤∣xi∣,∣yi∣≤109。

输出描述:

共一行：两个实数posx,posypos_x, pos_yposx,posy，表示Nancy欣赏音乐会的地点（保留三位小数）

示例1

输入

[复制](javascript:void(0)

0 0
1 3
4 2

输出

[复制](javascript:void(0)

2.000 1.000

解析

根据题意，需要找到三点距离相等的点，数学上即外心，亦称外圆圆心。输入的三个点不共线，这个条件能保证外心的存在。

计算三角形两边中垂线交点是外心的常用求解方法。首先我们需要中垂线的直线方程表达出来，这里涉及到的是高中知识,直线方程如下，

给定三角形三个顶点的坐标，如何求三角形的外心的坐标呢？
例如 ：给定a（x1,y1） b（x2,y2） c（x3,y3）求外接圆心坐标O（x，y）
1. 首先，外接圆的圆心是三角形三条边的垂直平分线的交点，我们根据圆心到顶点的距离相等，可以列出以下方程：
       (x1-x)*(x1-x)+(y1-y)*(y1-y)=(x2-x)*(x2-x)+(y2-y)*(y2-y);
       (x2-x)*(x2-x)+(y2-y)*(y2-y)=(x3-x)*(x3-x)+(y3-y)*(y3-y);
2.化简得到：
        2*(x2-x1)*x+2*(y2-y1)y=x2^2+y2^2-x1^2-y1^2;
        2*(x3-x2)*x+2*(y3-y2)y=x3^2+y3^2-x2^2-y2^2;
        令A1=2*(x2-x1)；
            B1=2*(y2-y1)；
            C1=x2^2+y2^2-x1^2-y1^2;
            A2=2*(x3-x2)；
            B2=2*(y3-y2)；
            C2=x3^2+y3^2-x2^2-y2^2;
            即
                A1*x+B1y=C1;
                A2*x+B2y=C2;
3.最后根据克拉默法则：
          x=((C1*B2)-(C2*B1))/((A1*B2)-(A2*B1))；
          y=((A1*C2)-(A2*C1))/((A1*B2)-(A2*B1))；
因此，x，y为最终结果；
对于空间中的三角形，只不过最后解方程组的时候是三元方程组
Ps：克拉默法则可以用向量积和数量积的方法证明，也可以用高等代数的知识证明

代码

import sys
sys.setrecursionlimit(10 ** 9)
IA = lambda: map(eval, input().split())
IAL = lambda: list(map(eval, input().split()))
IM = lambda N: [IA() for _ in range(N)]
# !/usr/bin/env python3
# -*- coding: utf-8 -*-
N = 100005
a = [int(0) for i in range(N)]
x1,y1=IA()
x2,y2=IA()
x3,y3=IA()
a=((y2-y1)*(y3*y3-y1*y1+x3*x3-x1*x1)-(y3-y1)*(y2*y2-y1*y1+x2*x2-x1*x1))/(2.0*((x3-x1)*(y2-y1)-(x2-x1)*(y3-y1)))
b=((x2-x1)*(x3*x3-x1*x1+y3*y3-y1*y1)-(x3-x1)*(x2*x2-x1*x1+y2*y2-y1*y1))/(2.0*((y3-y1)*(x2-x1)-(y2-y1)*(x3-x1)))
print('%.3f' %a,end=" ")
print('%.3f' %b)
#print("%.3lf %.3lf"%(a,b))

C Channels

链接：https://ac.nowcoder.com/acm/contest/3947/C
来源：牛客网

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述

Nancy喜欢学习，也喜欢看电视。
为了想了解她能看多长时间的节目，不妨假设节目从时刻1开始，一直播放到时刻6×101006 \times 10^{100}6×10100。每个节目持续50个时刻，节目与节目间会有10个时刻的广告时间。
然而，Nancy实在是太忙了，她从t1t_1t1​时刻开始观看，观看至t2t_2t2​时刻，请你帮忙计算她有多少个时刻能欣赏到电视节目。

输入描述:

若干行：每行两个整数t1t_1t1与t2t_2t2。
数据满足：1≤t1≤t2≤10181 \leq t_1 \leq t_2 \leq 10^{18}1≤t1≤t2≤1018。

输出描述:

若干行：每行一个整数，表示能品味电视节目的时刻数。

示例1

输入

[复制](javascript:void(0)

1 61

输出

[复制](javascript:void(0)

51

示例2

输入

[复制](javascript:void(0)

116969978 507978500
180480072 791550396
139567120 655243745
1470545 167613747
57644034 176077476
44676 56984808
215706822 369042088
108368065 320914746

输出

[复制](javascript:void(0)

325840433
509225275
429730516
138452673
98694536
47450113
127779387
177122232

分析

前缀和+容斥：统计[L,R]中60的个数：num=R/60-(L-1)/60。（注意num先-1，因为首个60可能不完整）

然后计算端点L,R的贡献

多组输入

代码

import sys
sys.setrecursionlimit(10 ** 9)
IA = lambda: [int(x) for x in input().split()]
IM = lambda N: [IA() for _ in range(N)]
# !/usr/bin/env python3
# -*- coding: utf-8 -*-
N = 100005
a = [int(0) for i in range(N)]
while True:
    try:
        x,y=IA()
        n=y//60-(x-1)//60
        n-=1
        add1=min(y%60,50)
        add2=max(60-(x-1)%60-10,0)
        #print(add2)
        ans=n*50+add1+add2
        print(ans)
    except EOFError:
        break

---

D DDoS

链接：https://ac.nowcoder.com/acm/contest/3947/D
来源：牛客网

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述

Nancy的男朋友喜欢网络安全！
最近，一种新的DDoS——脉冲波悄然来临。其基本原理是利用不同线路服务器的延时，使得Request同时到达目标服务器，以堵塞其它正常的通讯。
不妨假设攻击者在1号节点，目标服务器在nnn号节点，其余节点（2到n-1号节点）为中继服务器。
攻击者可以在任意时间发送一个定向数据包（即规定其经过中继服务器的路线，但不同数据包的路线不能完全相同），目标服务器对这种数据包具有100%的识别率，一旦识别到这种数据包，则会屏蔽这一时刻后的所有数据包。
Nancy好奇，攻击者在最优策略下，目标服务器能够收到多少份数据包呢？

输入描述:

第一行：两个整数n,m。
接下来m行：每行三个整数x,y,z，表示节点x与y可以单向通信（x到y），耗时为z。
数据满足：3≤n≤100000,1≤m≤2000003 \leq n \leq 100000, 1 \leq m \leq 2000003≤n≤100000,1≤m≤200000，0≤z≤⌊10πe⌋0 \leq z \leq \lfloor10^{\pi e}\rfloor0≤z≤⌊10πe⌋，图为拓扑图（有向无环图）。

输出描述:

共一行：表示攻击者在最优策略下，目标服务器能够收到数据包的数量。
由于数量可能会很大，你只需要输出答案对20010905取模后的值。

示例1

输入

[复制](javascript:void(0)

4 4
1 2 3
1 3 1
2 4 1
3 4 3

输出

[复制](javascript:void(0)

2

说明

显然，攻击者在0时刻发送两个定向数据包（1-2-4和1-3-4），它们同时在第4时刻到达目标服务器。

分析

官方题解：

不易观察、挺难发现、较难得到攻击者可以通过调整发送数据包的时间来使得所有数据包同时到达服务器(想打出题人），故原题意转化为求1到n的路径条数，拓扑图上DP即可。

注意定向的含义是规定路线及经过的中继节点，所以重边的时候格外小心（需要算两倍）。

边权无用（其实这里给了个奇怪的数据范围是在暗示呢QwQ）

代码

python（超时）

import sys
import queue
sys.setrecursionlimit(10 ** 9)
IA = lambda: map(eval, input().split())
IAL = lambda: list(map(eval, input().split()))
IM = lambda N: [IA() for _ in range(N)]
# !/usr/bin/env python3
# -*- coding: utf-8 -*-
N = 100005
MOD = 20010905
tot = int(0)

class Edge:
    def  __init__(self,to,next):
        self.to=to
        self.next=next

e=[]
e.append(Edge(-1,-1))



a = [int(0) for i in range(N)]
ru = [int(0) for i in range(N)]
head = [int(-1) for i in range(N)]
dp = [int(0) for i in range(N)]
q = queue.Queue(maxsize = N)


def add(x,y):
    global tot
    tot=tot+1
    e.append(Edge(y,head[x]))
    head[x]=tot


def query_num(st, en):
    q.put(1)
    dp[1]=1
    while q.empty() == False:
        now = q.get()
        #print(now)
        i=head[now]
        while i!=-1:
            ru[e[i].to]-=1;
            #print(e[i].to)
            dp[e[i].to]=(dp[e[i].to]+dp[now])%MOD
            if ru[e[i].to]==0:
                q.put(e[i].to)
            i=e[i].next





n,m=IA()
for i in range(m):
    x,y,z=IA()
    add(x,y)
    ru[y]+=1


query_num(1,n)
print(dp[n])

C++

#include 
using namespace std;
 
const int N = 100010;
const int mod = 20010905;
int num[N], w[N];
int en, head[N];
struct Edge {
    int to, nxt;
} e[N << 1];
 
queueq;
 
inline void add(int x, int y)
{
    e[++en].to = y;
    e[en].nxt = head[x];
    head[x] = en;
}
 
int main()
{
    register int n, m;
    scanf("%d %d", &n, &m);
    for (register int i = 1, x, y, z; i <= m; ++i) {
        scanf("%d %d %d", &x, &y, &z);
        add(x, y);
        ++num[y];
    }
    q.push(1);
    w[1] = 1;
    while (q.size()) {
        register int now = q.front(); q.pop();
        for (register int i = head[now]; i; i = e[i].nxt) {
            --num[e[i].to];
            w[e[i].to] = (w[e[i].to] + w[now]) % mod;
            if (!num[e[i].to]) {
                q.push(e[i].to);
            }
        }
    }
    printf("%d\n", w[n]);
    return 0;
}

---

E Exams

链接：https://ac.nowcoder.com/acm/contest/3947/E
来源：牛客网

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述

Nancy是老师的小帮手！
众所周知，大学的学分绩点十分难以计算 。
一门课程，有必修、限选、任选之分，而其成绩，又由平时成绩、期中考试、期末考试之分，最后还要对总分数进行四舍五入。
具体的，一名同学的学分绩点是这样计算的：

• 计算且仅计算必修和限选课程
• 根据平时成绩、期中成绩、期末成绩对应的不同比例求和，并四舍五入到整数
• 学分绩点为各门课成绩乘以学分占总学分的比例
• 对计算结果进行四舍五入（保留两位小数）

下面你知道了Nancy的成绩单，请你计算其最终学分绩点。

输入描述:

第一行：一个整数n，表示Nancy本学期修读了n门课程
接下来n行：每行一个整数和七个实数，表示课程性质（0为必修，1为限选，2为任选），学分，平时成绩及其比例，期中考试及其比例，期末考试及其比例，保证比例之和为1，且实数最多有一位小数。
数据满足1≤n≤641 \leq n \leq 641≤n≤64，课程性质∈{0,1,2}\in\{0,1,2\}∈{0,1,2}，学分∈[1,16]\in[1,16]∈[1,16]成绩∈[0,100]\in[0, 100]∈[0,100]，比例∈[0,1]\in[0,1]∈[0,1]，数据保证至少有一门必修或限选课。

输出描述:

共一行：表示Nancy的学分绩点。

示例1

输入

[复制](javascript:void(0)

5
0 1 97 1 0 0 0 0
0 2.5 98 0.3 0 0 92 0.7
0 4 100 0.3 0 0 100 0.7
0 1 0 0 0 0 74 1
0 2 94 1 0 0 0 0

输出

[复制](javascript:void(0)

94.67

分析

模拟即可，注意四舍五入

代码

import sys
sys.setrecursionlimit(10 ** 9)
IA = lambda: [float(x) for x in input().split()]
IM = lambda N: [IA() for _ in range(N)]
# !/usr/bin/env python3
# -*- coding: utf-8 -*-
N = 100005
x = [float(0) for i in range(N)]
sum1 = [int(0) for i in range(N)]
xue = [float(0) for i in range(N)]
n=int(input())

sum=float(0)
sum2=float(0)
for i in range(0,n):
    x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7] = IA()
    if (x[0] == 2): continue
    sum1[i]=int(x[2]*x[3]+x[4]*x[5]+x[6]*x[7]+0.5)
    sum2+=x[1]
    xue[i]=x[1]
for i in range(0,n):
    sum+=sum1[i]*(xue[i]/sum2)
print('%.2f' %sum)

---

F Fool Problem

链接：https://ac.nowcoder.com/acm/contest/3947/F
来源：牛客网

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述

Nancy喜欢斐波那契数列！

若f0=0,f1=1,f2=1f_0=0,f_1=1,f_2=1f0=0,f1=1,f2=1，请求：fn+1fn−1−fn2(n≥2)f_{n+1}f_{n-1}-f_n^2(n\geq2)fn+1fn−1−fn2(n≥2)，其中fif_ifi表示斐波那契数列第i项。

输入描述:

共一行：一个整数n。
数据满足：2≤n≤1020202 \leq n \leq 10^{2020}2≤n≤102020。

输出描述:

共一行：表示表达式的值。

示例1

输入

[复制](javascript:void(0)

2

输出

[复制](javascript:void(0)

1

代码

import sys
sys.setrecursionlimit(10 ** 9)
IA = lambda: [int(x) for x in input().split()]
IM = lambda N: [IA() for _ in range(N)]
# !/usr/bin/env python3
# -*- coding: utf-8 -*-
N = 100005
a = [int(0) for i in range(N)]
n=IA()
if n[0]%2==0:
    print(1)
else:
    print(-1)

---

G Game

链接：https://ac.nowcoder.com/acm/contest/3947/G
来源：牛客网

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述

Nancy喜欢博弈！
Johnson和Nancy得到了一个神奇的多重集合，仅包含一个正整数n，两个人轮流进行操作。
一次操作可以将集合中一个数字分解为它的任意两个非1的因数，并加入集合中。
他们想知道，在Johnson和Nancy绝顶聪明的情况下，如果Nancy先手进行操作，最后谁没有办法继续操作了呢？

输入描述:

第一行：一个整数n。
数据满足：1≤n≤957181 \leq n \leq 957181≤n≤95718。

输出描述:

共一行：一个字符串，表示最后谁（Johnson或者Nancy）无法进行操作。

示例1

输入

[复制](javascript:void(0)

4

输出

[复制](javascript:void(0)

Johnson

分析

不难发现某一个数字的质因子个数是一定的，计算其质因子个数来探究可分解的步数进行博弈即可。

其实最后只需要考虑质因子个数的奇偶性。

代码

import sys
import queue
sys.setrecursionlimit(10 ** 9)
IA = lambda: map(int, input().split())
IAL = lambda: list(map(int, input().split()))
IM = lambda N: [IA() for _ in range(N)]
# !/usr/bin/env python3
# -*- coding: utf-8 -*-
N = 100005
def f(n):
    num = int(0)
    i = int(2)
    temp=int(n)
    while i*i <=temp:
        if(temp%i==0):
            while temp % i==0:
                temp/=i
                num+=1
        i+=1

    if temp >1:
        num+=1
    return num
n=int(input())
if n == 1  or n == 2:
    print("Johnson")
elif f(n)%2 == 0:
    print("Johnson")
else:
    print("Nancy")

#include
using namespace std;
#define  LL long long

LL f(LL m)
{
    LL sum = 0;
    LL tmp = m;
    for(LL i = 2; i*i<=tmp; i++)    
        if(tmp%i==0)
        {
           
            while(tmp%i==0)
            {
                tmp /=  i;
                sum++;
            }
        }
    if(tmp>1)
        sum++;
    return sum;
}

int main()
{
    LL n;
    cin>>n;
    //cout<

---

I、I love you

链接：https://ac.nowcoder.com/acm/contest/3947/I
来源：牛客网

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述

此时相望不相闻，愿逐月华流照君。

一纸情书，到底蕴含了多少倍的爱情呢？

I love you, not only for what you are, but for what I am when I am with you.

输入描述:

共一行：一封若干个字符的情书（大小写不敏感）。
情书不会超过684594个字符（大写、小写字母）。

输出描述:

共一行：包含一个整数，即iloveyou在情书中作为子序列出现的次数。
由于答案可能很大，请输出对20010905取模后的值。

示例1

输入

[复制](javascript:void(0)

IloveyouNotonlyforwhatyouareButforwhatIamWhenIamwithyouIloveyouNotonlyforwhatYouhavemadeofyourselfButforwhatYouaremakingofme

输出

[复制](javascript:void(0)

2864

分析

小思维

代码

import sys
sys.setrecursionlimit(10 ** 9)
IA = lambda: [int(x) for x in input().split()]
IM = lambda N: [IA() for _ in range(N)]
# !/usr/bin/env python3
# -*- coding: utf-8 -*-
N = 100005
a = [int(0) for i in range(N)]
str=input().lower()
l=len(str)
a=int(0)
b=int(0)
c=int(0)
e=int(0)
f=int(0)
g=int(0)
h=int(0)
d=int(0)

MOD = int(20010905)
for i in range(0,l):
    if str[i]=='i':a=(a+1)%MOD
    if str[i]=='l':b=(b+a)%MOD
    if str[i] == 'o': c = (c + b) % MOD
    if str[i] == 'v': d=(d+c)%MOD
    if str[i] == 'e': e=(e+d)%MOD
    if str[i] == 'y': f=(f+e)%MOD
    if str[i] == 'o': g=(g+f)%MOD
    if str[i] == 'u': h=(h+g)%MOD



print(h)

#I love you Notonlyforwhat you areButforwhat I amWhen I amwith you I love you Notonlyforwhat You havemadeof your selfButforwhat You aremakingofme

---

J Jelly

链接：https://ac.nowcoder.com/acm/problem/201613
来源：牛客网

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述

Nancy喜欢吃果冻！

Nancy钻进了一个n×n×nn \times n \times nn×n×n的果冻里，她想从(1,1,1)一路上、下、左、右、前、后六个方向吃到(n,n,n)。

但果冻毕竟是有许多口味的，标记为*的口味是Nancy不愿意吃的，其余的果冻均标记为.。

Nancy不想吃坏肚子，于是她想尽可能少的吃果冻。
下面给出果冻的情况，请你帮忙计算一下她能吃多少块果冻叭！

输入描述:

第一行：一个整数n。
接下来n层，每组n行，每行n列，表示果冻(i,j,k)的情况（如题目描述所述）。
数据满足：1≤n≤1001 \leq n \leq 1001≤n≤100，保证果冻(1,1,1)不是Nancy不愿意吃的。

输出描述:

如果可以到达(n,n,n)，请输出路上吃的果冻数量，否则请输出-1。

示例1

输入

[复制](javascript:void(0)

2
.*
..
*.
..

输出

[复制](javascript:void(0)

4

分析

bfs即可，不过python依旧超时

代码

import sys
import queue
sys.setrecursionlimit(10 ** 9)
IA = lambda: map(int, input().split())
IAL = lambda: list(map(int, input().split()))
IM = lambda N: [IA() for _ in range(N)]
# !/usr/bin/env python3
# -*- coding: utf-8 -*-
class Node:
    def __init__(self,x,y,z,step):
        self.x=0
        self.y=0
        self.z=0
        self.step=0

dx=[0,0,0,0,1,-1]
dy=[0,0,1,-1,0,0]
dz=[1,-1,0,0,0,0]
N = 105
n=int(input())
mp = [[[int(0) for i in range(n)] for i in range(n)] for i in range(n)]
vis = [[[int(0) for i in range(n)] for i in range(n)] for i in range(n)]

for i in range(0,n):
    for j in range(0,n):
        s=input()
        for k in range(0,n):
            if s[k]=='*':
                mp[i][j][k]=-1


q=queue.Queue()
q.put(Node(0,0,0,0))
vis[0][0][0]=1
ans=int(1e9)
flag=int(0)
while q.empty()==False :
    a=q.get()
    for i in range(0,6):
        b = Node(0, 0, 0, 0)
        b.x=a.x+dx[i]
        b.y=a.y+dy[i]
        b.z=a.z+dz[i]
        b.step=a.step+1
        #print(str(b.x) + " " + str(b.y) + " " + str(b.z)+" "+str(mp[b.x][b.y][b.z]))
        if(b.x>=0 and b.x<n and b.y>=0 and b.y<n and b.z>=0 and b.z<n and mp[b.x][b.y][b.z]!=-1 and vis[b.x][b.y][b.z]==0):
            q.put(b)
            vis[b.x][b.y][b.z]=1
            #print(str(b.x)+" "+str(b.y)+" "+str(b.z))
            if(b.x==n-1 and b.y==n-1 and b.z==n-1):
                ans=b.step
                flag=1
                break
    if flag==1:break
if ans==1e9:print(-1)
else:print(ans+1)

#include
#define ll long long
const ll mod=20010905;
using namespace std;
const int maxn=100+10;
int mp[maxn][maxn][maxn];
bool vis[maxn][maxn][maxn];
int dx[]={1,-1,0,0,0,0};
int dy[]={0,0,1,-1,0,0};
int dz[]={0,0,0,0,1,-1};
struct Node
{
    int x,y,z;
    int step;
    Node(int x,int y,int z,int step):x(x),y(y),z(z),step(step){}
};
int n;
void f()
{
	for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
            for(int k=1; k<=n; k++)
            {
                char a;
                cin>>a;
                if(a=='.')
                    mp[i][j][k]=1;
                else
                    mp[i][j][k]=0;
            }
    queueQ;
    Q.push(Node(1,1,1,1));
    vis[1][1][1]=1;
    int ans=1e9+1;
    while(!Q.empty())
    {
        Node node=Q.front();
        Q.pop();
        int x=node.x,y=node.y,z=node.z;
        int step=node.step;
        if(x==n&&y==n&&z==n)
        {
            ans=min(ans,step);
            continue;
            
        }
        for(int i=0;i<6;i++)
        {
            int nx=x+dx[i];
            int ny=y+dy[i];
            int nz=z+dz[i];
            if(nx<1||nx>n) continue;
            if(ny<1||ny>n) continue;
            if(nz<1||nz>n) continue;
            if(vis[nx][ny][nz]) continue;
            if(mp[nx][ny][nz]==0) continue;

            vis[nx][ny][nz]=1;
            Q.push(Node(nx,ny,nz,step+1));

        }
    }
    if(ans==1e9+1)
        cout<<"-1"<>n;
    f();
    return 0;
    
}