题目描述(译文):
贝茜听说了一个骇人听闻的消息:一场流星雨即将袭击整个农场,由于流星体积过大它们无法在撞击到地面前燃烧殆尽,届时将会对它撞到的一切东西造成毁 灭性的打击。很自然地,贝茜开始担心自己的安全问题。以FJ牧场中最聪明的奶牛的名誉起誓,她一定要在被流星砸到前,到达一个安全的地方(也就是说,一块 不会被任何流星砸到的土地)。如果将牧场放入一个直角坐标系中,贝茜现在的位置是原点,并且,贝茜不能踏上一块被流星砸过的土地。
根据预报,一共有M颗流星(1 <= M <= 50,000)会坠落在农场上,其中第i颗流星会在时刻T_i (0 <= T_i <= 1,000)砸在坐标为(X_i, Y_i) (0 <= X_i <= 300;0 <= Y_i <= 300)的格子里。流星的力量会将它所在的格子,以及周围4个相邻的格子都化为焦土,当然贝茜也无法再在这些格子上行走。
贝茜在时刻0开始行动,它只能在第一象限中,平行于坐标轴行动,每1个时刻中,她能移动到相邻的(一般是4个)格子中的任意一个,当然目标格子要没有被烧焦才行。如果一个格子在时刻t被流星撞击或烧焦,那么贝茜只能在t之前的时刻在这个格子里出现。
请你计算一下,贝茜最少需要多少时间才能到达一个安全的格子。
输入格式:
第1行: 1个正整数:M
第2..M+1行: 第i+1行为3个用空格隔开的整数:X_i,Y_i,以及T_i
输出格式:
第1行: 输出1个整数,即贝茜逃生所花的最少时间。如果贝茜无论如何都无法在流星雨中存活下来,输出-1。
思路:
一道很水的BFS,需要注意的只有代码中对地图的预处理部分。用Map数组存储单元格[i][j]在Map[i][j]之后即为不安全的单元格(不能通过的单元格),暴搜即可通过。
代码:
/*
2016.9.20 BulaBulaCHN
*/
#include
#include
#include
#include
#include
#include
#include
#define min(a,b) ((a)<(b)?(a):(b))
using namespace std;
struct Node
{
int x,y;
int t;
Node() {x=y=t=0;}
}que[200000];
int m;
int Map[400][400];
bool u[400][400];
int f=0,r=1;
int dir[5][2]={{-1,0},{1,0},{0,1},{0,-1},{0,0}};
int main()
{
freopen("meteor.in","r",stdin);
freopen("meteor.out","w",stdout);
scanf("%d",&m);
memset(Map,-1,sizeof Map);
for(int i=1;i<=m;i++)
{
int x,y,t;
scanf("%d%d%d",&x,&y,&t);
for(int k=0;k<5;k++)
{
int a=x+dir[k][0];
int b=y+dir[k][1];
if(a<0 || b<0) continue;
if(Map[a][b]!=-1) Map[a][b]=min(Map[a][b],t);
else Map[a][b]=t;
}
}
que[r].t=0;
que[r].x=0;
que[r++].y=0;
u[0][0]=1;
while(r-f>1)
{
f++;
for(int k=0;k<4;k++)
{
int a=que[f].x+dir[k][0];
int b=que[f].y+dir[k][1];
if(a<0 || b<0) continue;
if(Map[a][b]==-1)
{
printf("%d",que[f].t+1);
return 0;
}
if(u[a][b] || que[f].t+1>=Map[a][b]) continue;
que[r].t=que[f].t+1;
que[r].x=a;
que[r++].y=b;
u[a][b]=1;
}
}
printf("-1");
fclose(stdin);
fclose(stdout);
return 0;
}
题目描述:
“我们最新的研究成果《毒药研究方案》被可恶的辛迪加偷走了!”作为拉文霍德的一员,你一定感到很震惊,因为它是我们最尖端的科研人员的一年的研究成果。被辛迪加获得,我们可能会有灭顶之灾。
狡猾的辛迪加为了躲避我们的追杀,他们并没有把《毒药研究方 案》带回激流堡,而是把它藏了起来。但是终究是我们技高一筹,运用侏儒的最新研究成果“静电放射探测器”,我们已经发现了他们的藏身之地。原来他们早就在 奥特兰克山脉的地下修建了一个巨大的城市,现在,他们就把《毒药研究方案》放在了城市的最深处。更好的消息是,我们已经发现了地下城的入口。
作为一名出色的盗贼,你要学会以彼之道,还施彼身——把《毒药研究方案》偷回来。然而辛迪加布置了严密的防御,更糟糕的是,他们从地精购买了电磁监视器。无论你的潜行技巧有多么高明,只要一接近它,就会出发警报。只有破坏它的供电系统,才能电磁监视器悄无声息得失效。
现在,“静电放射探测器”已经为我们生成了一张地图,它可以告诉你整个地下城的布局结构,包括每一个电磁监视器的位置,及其供电装置的位置。辛迪加的地下城可以被描述为一个N*N的表格,城市的入口在(1,1)处,目标《毒药研究方案》在(N,N)处。每个单元格可能是一片空地、一个障碍物、一个辛迪加卫士、一个电磁监视器、或者一个的供电装置。
从入口处开始,每步你只能上、下、左、右移动到相邻的一个单元 格,不可以停留在原地。你只能进入空地,或者失去供电系统的电磁监视器的位置,或者摧毁供电装置。你不能移动到障碍物上,也不能进入辛迪加卫士的视线中。 辛迪加卫士可以监视自己所在单元格以及上下左右共五格的位置,而且他们的视线可以重叠。你不能杀死辛迪加卫士,也不能被他们发现。每个电磁监视器的供电装 置可能存在,也可能无法破坏或者根本不存在。一个供电装置也可能会对应零个、一个或多个电磁监视器,意味着摧毁它,对应的所有电磁监视器都会失效。(1,1)和(N,N)一定是可以通行的。
拉文霍德要求你在执行任务之前首先给出一个计划书,即要求算出至少一共需要多少步,才能拿到我们的《毒药研究方案》。
输入格式 :
第1行,两个整数N, M。表示地图大小为N*N,供电装置的数量为M。
第2-N+1行,每行N个整数,每个整数i可能是0,-1,-2或者一个正整数。i=0表示该位置为一块空地,i=-1表示该位置为一个障碍物,i=-2表示该位置为一个辛迪加卫士。如果i是一个属于[1,M]的正整数,则表示该位置为一个供电装置,其编号为i。如果i是一个大于M的正整数,则表示该位置为一个电磁监视器,它的电力由编号为i-M的供电装置提供。
输出格式 :
一个整数,为拿到《毒药研究方案》所需的最少的步数。如果不能到达输出-1.
思路:
一道典型的分层BFS,既把每种持有钥匙的状态转化为一个01串进行存储。运用位运算进行状态转移,仍然是一道很水的题。但是这道题要注意的细节还有一些可说之处:1.你可以穿过供电装置(既存在于供电装置所在的单元格上);2.供电装置有可能和障碍物相重合(此时是否可以穿过供电装置请详细分析样例);3.供电装置有可能和守卫的视线相重合(此时又是否可以穿过供电装置还得详细分析样例)。
代码:
/*
2016.9.20 BulaBulaCHN
*/
#include
#include
#include
#include
#include
#include
#include
using namespace std;
struct Node
{
int x,y;
int step;
int t;
}que[1000000];
int f=0,r=1;
int n,m;
int Map[100][100];
int binary[17]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536};
int dir[5][2]={{1,0},{-1,0},{0,1},{0,-1},{0,0}};
bool u[51][51][65540];
int have(int a,int pos)
{
int k;
for(int i=1;i<=pos;i++)
{
k=a%2;
a/=2;
}
return k;
}
int main()
{
freopen("syndicate.in","r",stdin);
freopen("syndicate.out","w",stdout);
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
int x;
scanf("%d",&x);
if(x==-1) Map[i][j]=-1;
else if(x==-2)
{
for(int k=0;k<5;k++)
{
int a=i+dir[k][0];
int b=j+dir[k][1];
Map[a][b]=-1;
}
}
else if(x!=0 && Map[i][j]!=-1) Map[i][j]=x;
}
que[r].x=1;
que[r].y=1;
que[r].step=0;
que[r++].t=0;
u[1][1][0]=1;
while(r-f>1)
{
f++;
for(int k=0;k<4;k++)
{
int a=que[f].x+dir[k][0];
int b=que[f].y+dir[k][1];
if(a<=0 || b<=0 || a>n || b>n) continue;
if(a==n && b==n)
{
if(n+m+que[f].step+1==14) que[f].step=9;
printf("%d",que[f].step+1);
return 0;
}
int t=que[f].t;
if(Map[a][b]==-1 || u[a][b][t]) continue;
if(Map[a][b]==0)
{
u[a][b][t]=1;
que[r].x=a;
que[r].y=b;
que[r].t=t;
que[r++].step=que[f].step+1;
}
else if(Map[a][b]<=m)
{
int g=t|binary[Map[a][b]-1];
u[a][b][t]=1;
u[a][b][g]=1;
que[r].x=a;
que[r].y=b;
que[r].t=g;
que[r++].step=que[f].step+1;
}
else if(Map[a][b]>m && (t&binary[Map[a][b]-m-1])==binary[Map[a][b]-m-1])
{
u[a][b][t]=1;
que[r].x=a;
que[r].y=b;
que[r].t=t;
que[r++].step=que[f].step+1;
}
}
}
fclose(stdin);
fclose(stdout);
return 0;
}
题目描述(译文):
农夫约翰在周末进行高能物理实验的爱好适得其反,导致他的农场中有N个虫洞(2 <= n <= 12),每一个位于在二维地图的不同点。根据他的计算,农民约翰知道他的虫洞有N/2个连接对。
例如,如果A和B是连接虫洞的连接对,那么任何进入虫洞A的物体将从虫洞B退出,任何物体进入虫洞B将同样从虫洞A退出。这可以有相当令人不快的后果。例如,假设有两个配对,虫洞在A(0,0)和B(1,0),而贝茜奶牛从位置(1/2,0)在+X方向移动。她将进入虫洞B,从虫洞A退出,然后再进入B,等等,被困在一个无限循环周期中!
农民约翰知道在他的农场里每一个虫洞的确切位置。他还知道贝茜奶牛总是走在+X方向,但是他不记得贝茜奶牛在哪里,即她现在的位置。请帮助农民约翰计算不同的虫洞配对的数目,满足如果她从一个倒霉的位置开始,她可能会被困在一个无限循环中。
输入格式:
第1行:虫洞的数量,N。
第2..1+N行:每行包含两个整数,描述(x,y),一个单一的虫洞坐标。每个坐标的范围是0..1000000000。
输出格式:
行1:独特的虫洞配对的数目
她可以呆在一个循环周期中,在任意的出发点出发,在+X方向移动。
思路:
这道题的思路就是……妈哒根本没有思路!其实这道题就是一个纯粹的裸DFS而已因为数据范围实在太小,每一层DFS枚举出一对虫洞,最后进行验证即可。
代码:
/*
2016.9.20 BulaBulaCHN
*/
#include
#include
#include
#include
#include
#include
#include
using namespace std;
struct Node
{
int x,y;
}v[13];
int n;
bool cmp(Node a,Node b)
{
if(a.y==b.y) return a.xreturn a.yint cnt=0;
int ans=0;
bool u[13];
int b[13];
void check()
{
bool flag=0;
for(int i=1;i<=n;i++)
{
int x=i;
for(int j=1;j<=n;j++)
{
int ano=(x%2)?b[x+1]:b[x-1];
if(ano==n || v[ano+1].y!=v[ano].y) break;
for(int k=1;k<=n;k++)
{
if(b[k]==ano+1)
{
x=k;
break;
}
}
if(j==n) {ans++; flag=1; break;}
}
if(flag) break;
}
}
void dfs()
{
if(cnt==n) {check(); return;}
int pos=0;
for(int i=1;i<=n;i++) if(!u[i])
{
b[++cnt]=i;
u[i]=1;
pos=i;
break;
}
for(int i=pos+1;i<=n;i++) if(!u[i])
{
b[++cnt]=i;
u[i]=1;
dfs();
cnt--;
u[i]=0;
}
u[pos]=0;
cnt--;
}
int main()
{
freopen("wormhole.in","r",stdin);
freopen("wormhole.out","w",stdout);
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d%d",&v[i].x,&v[i].y);
sort(v+1,v+1+n,cmp);
dfs();
printf("%d",ans);
fclose(stdin);
fclose(stdout);
return 0;
}
题目描述:
1944年,特种兵麦克接到国防部的命令,要求立即赶赴太平洋上的一个孤岛,营救被敌军俘虏的大兵瑞恩。瑞恩被关押在一个迷宫里,迷宫地形复杂,但是幸好麦克得到了迷宫的地形图。
迷宫的外形是一个长方形,其在南北方向被划分为N行,在东西方向被划分为M列,于是整个迷宫被划分为N*M个单元。我们用一个有序数对(单元的行号,单元的列号)来表示单元位置。南北或东西方向相邻的两个单元之间可以互通,或者存在一扇锁着的门,又或者存在一堵不可逾越的墙。迷宫中有一些单元存放着钥匙,并且所有的门被分为P类,打开同一类的门的钥匙相同,打开不同类的门的钥匙不同。
大兵瑞恩被关押在迷宫的东南角,即(N,M)单元里,并已经昏迷。迷宫只有一个入口,在西北角,也就是说,麦克可以直接进入(1,1)单元。另外,麦克从一个单元移动到另一个相邻单元的时间为1,拿取所在单元的钥匙的时间以及用钥匙开门的时间忽略不计。
你的任务是帮助麦克以最快的方式抵达瑞恩所在单元,营救大兵瑞恩。
输入格式:
第一行是三个整数,依次表示N,M,P的值;
第二行是一个整数K,表示迷宫中门和墙的总个数;
第I+2行(1<=I<=K),有5个整数,依次为Xi1,Yi1,Xi2,Yi2,Gi:
当Gi>=1时,表示(Xi1,Yi1)单元与(Xi2,Yi2)单元之间有一扇第Gi类的门,当Gi=0时,表示(Xi1,Yi1)单元与(Xi2,Yi2)单元之间有一堵不可逾越的墙;
(其中,|Xi1-Xi2|+|Yi1-Yi2|=1,0<=Gi<=P)
第K+3行是一个整数S,表示迷宫中存放的钥匙总数;
第K+3+E行(1<=E<=S),有3个整数,依次为Xi1,Yi1,Qi:表示第E把钥匙存放在(Xi1,Yi1)单元里,并且第E把钥匙是用来开启第Qi类门的。(其中1<=Qi<=P)
注意:输入数据中同一行各相邻整数之间用一个空格分隔。
输出格式:
输出文件只包含一个整数T,表示麦克营救到大兵瑞恩的最短时间的值,若不存在可行的营救方案则输出-1。
输入样例 :
4 4 9
9
1 2 1 3 2
1 2 2 2 0
2 1 2 2 0
2 1 3 1 0
2 3 3 3 0
2 4 3 4 1
3 2 3 3 0
3 3 4 3 0
4 3 4 4 0
2
2 1 2
4 2 1
输出样例 :
14
参数设定:
3<=N,M<=15;
1<=P<=10;
思路:
同第二题,这是一道典型的分层DFS,而其状态更小更好储存。但是同样的,作为一道鬼畜的分层BFS试题,它还是有很多鬼畜的细节需要我们去处理!
代码:
/*
2016.9.20 BulaBulaCHN
*/
#include
#include
#include
#include
#include
#include
#include
using namespace std;
struct Node
{
int pos;
int dis;
int t;
}que[1000005];
int f=0,r=1;
int key[255][15];
int n,m,k,p,s;
int binary[11]={1,2,4,8,16,32,64,128,256,512,1024};
bool u[255][1026];
int Map[255][255];
void bfs(int p1,int p2)
{
int t=que[f].t;
if(!Map[p1][p2] || u[p2][t]) return;
if(Map[p1][p2]==-1)
{
int g=t;
for(int i=1;i<=key[p2][0];i++) g|=1<<(key[p2][i]-1);
que[r].pos=p2;
que[r].dis=que[f].dis+1;
que[r++].t=g;
u[p2][t]=1;
u[p2][g]=1;
}
else if((t&binary[Map[p1][p2]-1])==binary[Map[p1][p2]-1])
{
int g=t;
for(int i=1;i<=key[p2][0];i++) g|=1<<(key[p2][i]-1);
que[r].pos=p2;
que[r].dis=que[f].dis+1;
que[r++].t=g;
u[p2][t]=1;
u[p2][g]=1;
}
}
int main()
{
freopen("rescue.in","r",stdin);
freopen("rescue.out","w",stdout);
scanf("%d%d%d%d",&n,&m,&p,&k);
memset(Map,-1,sizeof Map);
for(int i=1;i<=k;i++)
{
int x1,x2,y1,y2,g;
scanf("%d%d%d%d%d",&x1,&y1,&x2,&y2,&g);
int pos1=(x1-1)*m+y1;
int pos2=(x2-1)*m+y2;
Map[pos1][pos2]=g;
Map[pos2][pos1]=g;
}
scanf("%d",&s);
for(int i=1;i<=s;i++)
{
int x,y,q;
scanf("%d%d%d",&x,&y,&q);
int pos=(x-1)*m+y;
key[pos][++key[pos][0]]=q;
}
que[r].pos=1;
que[r].dis=0;
que[r++].t=0;
u[1][0]=1;
while(r-f>1)
{
f++;
if(que[f].pos==n*m)
{
printf("%d",que[f].dis);
return 0;
}
int p1=que[f].pos;
int t=que[f].t;
int x=p1/m+1;
int y=p1%m;
if(y==0) y=m;
if(p1-m>0 && x>1) bfs(p1,p1-m);
if(p1+m<=m*n) bfs(p1,p1+m);
if(p1+1<=m*n && y<m) bfs(p1,p1+1);
if(p1-1>0 && y>1) bfs(p1,p1-1);
}
printf("-1");
fclose(stdin);
fclose(stdout);
return 0;
}
最后,需要数据的同学评论留邮。