UVa1601-The Morning after Halloween

最新推荐文章于 2020-01-16 19:02:27 发布
最新推荐文章于 2020-01-16 19:02:27 发布
阅读量273 收藏 1
点赞数 1
分类专栏： 暴力求解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y1l1x/article/details/51762249
版权

          题意：给出一个最大为16×16的迷宫图和至多3个ghost的起始位置和目标位置，求最少经过几轮移动可以使三个ghost都到达目标位置。每轮移动中，每个ghost可以走一步，也可以原地不动，需要注意的是任意两个ghost不能在相同的位置，因此也不能出现任意两个ghost对穿，也就是原来是ab，移动之后是ba。每个迷宫图'#'表示墙，' '表示空地，小写字母表示ghost的起始位置，大写字母表示对应ghost的目标位置，比如'a'应该走到'A'。保证任意2×2的空间内都有一个'#'。 

  分析：以当前3个小写字母的位置为状态，则问题转化为图的最短路问题。状态总数为256^3，每次转移需要5^3枚举每个小写字母下一步的走法，但是容易超时。

//暴力
#include<cstdio>
#include<cstring>
#include<cctype>
#include<queue>
using namespace std;
const int maxs = 20;
const int maxn = 150;
const int dx[]={1,-1,0,0,0};
const int dy[]={0,0,1,-1,0};
int ID(int a, int b, int c) {
  return (a<<16)|(b<<8)|c;//将状态压缩成一个整数，方便储存
}
int s[3], t[3];//起始状态，目标状态
int A[256];//记录是否为添加的鬼
bool conflict(int a, int b, int a2, int b2) {
  return a2 == b2 || (a2 == b && b2 == a);//判断是否冲突
}
int d[maxn][maxn][maxn];//步数
char maze[20][20];//原图
int cnt, x[maxn], y[maxn], id[maxs][maxs];//图与ID号的映射
int w, h, n;
int bfs() {
    queue<int> q;
    memset(d, -1, sizeof(d));
    q.push(ID(s[0], s[1], s[2]));
    d[s[0]][s[1]][s[2]] = 0;
    while(!q.empty()) {
      int u = q.front();
      q.pop();
      int a = (u>>16)&0xff, b = (u>>8)&0xff, c = u&0xff;
      if(a == t[0] && b == t[1] && c == t[2]){
        return d[a][b][c];
      }
      for(int i = 0; i < 5; i++) {//第一个鬼
        if(x[a]+dx[i]<0||x[a]+dx[i]>=h||y[a]+dy[i]<0||y[a]+dy[i]>=w){//出界
            continue;
        }
        char a3=maze[x[a]+dx[i]][y[a]+dy[i]];
        if(a3=='#'){//有墙
            continue;
        }
        int a2=id[x[a]+dx[i]][y[a]+dy[i]];//下一步的ID号
        for(int j = 0; j < 5; j++) {//第二个鬼
          int b2;
          if(A[b]==1){//判断是否为添加的鬼
            j=5;
            b2=b;
          }
          else{
          if(x[b]+dx[j]<0||x[b]+dx[j]>=h||y[b]+dy[j]<0||y[b]+dy[j]>=w){
                continue;
          }
          char b3=maze[x[b]+dx[j]][y[b]+dy[j]];
          if(b3=='#'){
                continue;
          }
          b2=id[x[b]+dx[j]][y[b]+dy[j]];
          }
          if(conflict(a, b, a2, b2)){//判断是否冲突
            continue;
          }
          for(int k = 0; k < 5; k++) {//第三个鬼
            int c2;
            if(A[c]==1){
                k=5;
                c2=c;
            }
            else{
            if(x[c]+dx[k]<0||x[c]+dx[k]>=h||y[c]+dy[k]<0||y[c]+dy[k]>=w){
                continue;
            }
            char c3=maze[x[c]+dx[k]][y[c]+dy[k]];
            printf("%c\n",c3);
            if(c3=='#'){
                continue;
            }
            c2=id[x[c]+dx[k]][y[c]+dy[k]];
            }
            if(conflict(a, c, a2, c2)){
                continue;
            }
            if(conflict(b, c, b2, c2)){
                continue;
            }
            if(d[a2][b2][c2] != -1){//检查是否已经访问过
                continue;
            }
            d[a2][b2][c2] = d[a][b][c]+1;
            q.push(ID(a2, b2, c2));
          }
        }
      }
    }
  return -1;
}
int main() {
  while(scanf("%d%d%d\n", &w, &h, &n) == 3 && n) {
    memset(A,0,sizeof(A));
    for(int i = 0; i < h; i++){
        fgets(maze[i], 20, stdin);
    }
    cnt = 0;
    //将空地编上ID号
    for(int i = 0; i < h; i++)
      for(int j = 0; j < w; j++)
        if(maze[i][j] != '#') {
          x[cnt] = i; y[cnt] = j;
          id[i][j] = cnt;
          if(islower(maze[i][j])){
            s[maze[i][j] - 'a'] = cnt;
          }
          else if(isupper(maze[i][j])){
            t[maze[i][j] - 'A'] = cnt;
          }
          cnt++;
        }
    //不足三个鬼时添加鬼，方便统一处理
    if(n <= 2){
        A[cnt]=1;
        s[2] = t[2] = cnt++;


    }
    if(n <= 1){
        A[cnt]=1;
        s[1] = t[1] = cnt++;
    }
    printf("%d\n",bfs());
  }
  return 0;
}


由条件“任何一个2×2子网格中至少有一个障碍格”暗示着很多格子都是障碍，并且大部分空地都和障碍相邻，因此不是所有4个方向都能移动，因此可以把所有空格提出来建一个图。这里将原图中的空白点映射为编号，再将三个点的编号合一。预处理可以把每个空白格子的5个方向的下个格子的编号算出来。这样就可以AC了。

//暴力+优化，单向BFS
#include<cstdio>
#include<cstring>
#include<cctype>
#include<queue>
using namespace std;
const int dx[]={1,-1,0,0,0};
const int dy[]={0,0,1,-1,0};
int s[3],t[3];//起始状态，目标状态
int deg[256], G[256][5];
int ID(int a,int b,int c)
{
    return (a<<16)|(b<<8)|c;//将状态压缩成一个整数，方便储存
}
bool conflict(int a, int b, int a2, int b2)
{
  return a2 == b2 || (a2 == b && b2 == a);//判断是否冲突
}
int d[256][256][256];//步数
int bfs() {
    queue<int> q;
    memset(d, -1, sizeof(d));
    q.push(ID(s[0], s[1], s[2]));
    d[s[0]][s[1]][s[2]] = 0;
    while(!q.empty()){
      int u = q.front();
      q.pop();
      int a = (u>>16)&0xff, b = (u>>8)&0xff, c = u&0xff;
      if(a == t[0] && b == t[1] && c == t[2]){
        return d[a][b][c];
      }
      for(int i = 0; i < deg[a]; i++) {//第一个鬼
        int a2 = G[a][i];//下一步的ID号
        for(int j = 0; j < deg[b]; j++) {//第二个鬼
          int b2 = G[b][j];
          if(conflict(a, b, a2, b2)){//判断是否冲突
            continue;
          }
          for(int k = 0; k < deg[c]; k++) {//第三个鬼
            int c2 = G[c][k];
            if(conflict(a, c, a2, c2)){
                continue;
            }
            if(conflict(b, c, b2, c2)){
                continue;
            }
            if(d[a2][b2][c2] != -1){//检查是否已经访问过
                continue;
            }
            d[a2][b2][c2] = d[a][b][c]+1;
            q.push(ID(a2, b2, c2));
          }
        }
      }
    }
  return -1;
}
int main()
{
    int w,h,n;
    while(scanf("%d%d%d\n",&w,&h,&n)==3&&n!=0){
        char maze[20][20];
        for(int i=0;i<h;i++){
            fgets(maze[i],20,stdin);
        }
        int cnt=0,x[256],y[256],id[20][20];
        //将空地编上ID号
        for(int i=0;i<h;i++){
            for(int j=0;j<w;j++){
                if(maze[i][j]!='#'){
                    x[cnt]=i;
                    y[cnt]=j;
                    id[i][j]=cnt;
                    if(islower(maze[i][j])){
                        s[maze[i][j] - 'a'] = cnt;
                    }
                    else if(isupper(maze[i][j])){
                        t[maze[i][j] - 'A'] = cnt;
                    }
                    cnt++;
                }
            }
        }
        //建图
        for(int i=0;i<cnt;i++){
            deg[i]=0;
            for(int j=0;j<5;j++){
                int nx = x[i]+dx[j], ny = y[i]+dy[j];
                if(maze[nx][ny]!='#'){
                    G[i][deg[i]++]=id[nx][ny];
                }
            }
        }
        //不足三个鬼时添加鬼，方便统一处理
        if(n<=2){
            deg[cnt]=1;
            G[cnt][0]=cnt;
            s[2]=t[2]=cnt++;
        }
        if(n<=1){
            deg[cnt]=1;
            G[cnt][0]=cnt;
            s[1]=t[1]=cnt++;
        }
        printf("%d\n",bfs());
    }
    return 0;
}
当然，也可以用 双向BFS。 双向BFS的好处，就是避免了单向BFS步数太多产生的组合性爆炸的情况，从而降低时间复杂度。 
//双向BFS
#include<cstdio>
#include<cstring>
#include<cctype>
#include<queue>
#include <iostream>
using namespace std;
const int N    = 20;
const int maxn = 200;
const int dx[] = {1,0,-1,0,0};
const int dy[] = {0,-1,0,1,0};
int n,m,k;
char maze[N][N];
int x[maxn],y[maxn],cnt,G[maxn][5],deg[maxn],id[maxn][maxn];
int s[3],t[3];
int d[maxn][maxn][maxn],bd[maxn][maxn][maxn];
int ID(int a,int b,int c)
{
    return (a<<16)|(b<<8)|c;//将状态压缩成一个整数，方便储存
}
void Memset(){
    memset(d,-1,sizeof(d));
    memset(bd,-1,sizeof(bd));
}
bool conflict(int a, int b, int a2, int b2) {
  return a2 == b2 || (a2 == b && b2 == a);//判断是否冲突
}
queue<int> q;
bool bfs()//正向BFS
{
    int value;
    int uu=q.front();
    int aa=(uu>>16)&0xff,bb=(uu>>8)&0xff,cc=uu&0xff;
    value=d[aa][bb][cc];
    while(!q.empty())
    {
        int u=q.front();
        int a=(u>>16)&0xff,b=(u>>8)&0xff,c=u&0xff;
        if(d[a][b][c]!=value) return false;
        if(bd[a][b][c]!=-1) return true;
        for(int i=0; i<deg[a]; i++)
        {
            int na=G[a][i];
            for(int j=0; j<deg[b]; j++)
            {
                int nb=G[b][j];
                for(int k=0; k<deg[c]; k++)
                {
                    int nc=G[c][k];
                    if(conflict(a,b,na,nb)) continue;
                    if(conflict(a,c,na,nc)) continue;
                    if(conflict(b,c,nb,nc)) continue;
                    if(d[na][nb][nc]==-1)
                    {
                        d[na][nb][nc]=d[a][b][c]+1;
                        q.push(ID(na,nb,nc));
                    }
                }
            }
        }
        q.pop();
    }
    return false;
}
queue<int> p;
int back_bfs(){//反向BFS
    int value;
    int uu=p.front();
    int aa=(uu>>16)&0xff,bb=(uu>>8)&0xff,cc=uu&0xff;
    value=bd[aa][bb][cc];
    while(!p.empty())
    {
        int u=p.front();
        int a=(u>>16)&0xff,b=(u>>8)&0xff,c=u&0xff;
        if(bd[a][b][c]!=value) return false;
        if(d[a][b][c]!=-1) return true;
        for(int i=0; i<deg[a]; i++)
        {
            int na=G[a][i];
            for(int j=0; j<deg[b]; j++)
            {
                int nb=G[b][j];
                for(int k=0; k<deg[c]; k++)
                {
                    int nc=G[c][k];
                    if(conflict(a,b,na,nb)) continue;
                    if(conflict(a,c,na,nc)) continue;
                    if(conflict(b,c,nb,nc)) continue;
                    if(bd[na][nb][nc]==-1)
                    {
                        bd[na][nb][nc]=bd[a][b][c]+1;
                        p.push(ID(na,nb,nc));
                    }
                }
            }
        }
        p.pop();
    }
    return false;
}
int BFS(){
while(!q.empty()) q.pop();
while(!p.empty()) p.pop();
q.push(ID(s[0],s[1],s[2]));
p.push(ID(t[0],t[1],t[2]));
Memset();
d[s[0]][s[1]][s[2]]=0; bd[t[0]][t[1]][t[2]]=0;
int step=0,ok=0;
while(!p.empty()&&!q.empty()){//正向BFS与反向BFS交替进行，同时统计步数
        if(bfs()){
            ok=1;
            break;
        }
        else step++;
        if(back_bfs()){
            ok=1;
            break;
        }
        else step++;
}
return ok ? step:-1;
}
int main()
{
    int w,h,n;
    while(scanf("%d%d%d\n",&w,&h,&n)==3&&n!=0){
        char maze[20][20];
        for(int i=0;i<h;i++){
            fgets(maze[i],20,stdin);
        }
        int cnt=0,x[256],y[256],id[20][20];
        //将空地编上ID号
        for(int i=0;i<h;i++){
            for(int j=0;j<w;j++){
                if(maze[i][j]!='#'){
                    x[cnt]=i;
                    y[cnt]=j;
                    id[i][j]=cnt;
                    if(islower(maze[i][j])){
                        s[maze[i][j] - 'a'] = cnt;
                    }
                    else if(isupper(maze[i][j])){
                        t[maze[i][j] - 'A'] = cnt;
                    }
                    cnt++;
                }
            }
        }
        //建图
        for(int i=0;i<cnt;i++){
            deg[i]=0;
            for(int j=0;j<5;j++){
                int nx = x[i]+dx[j], ny = y[i]+dy[j];
                if(maze[nx][ny]!='#'){
                    G[i][deg[i]++]=id[nx][ny];
                }
            }
        }
        //不足三个鬼时添加鬼，方便统一处理
        if(n<=2){
            deg[cnt]=1;
            G[cnt][0]=cnt;
            s[2]=t[2]=cnt++;
        }
        if(n<=1){
            deg[cnt]=1;
            G[cnt][0]=cnt;
            s[1]=t[1]=cnt++;
        }
        printf("%d\n",BFS());
    }
    return 0;
}




y1l1x
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
UVa 1601 - The Morning after Halloween（双向BFS版）
_____
01-13 4098
继续上次UVA 1601这道题单向BFS的版本，接下来向双向BFS的方向优化。
UVA1601 The Morning after Halloween
WedsonLin的博客
07-18 211
UVA1601 The Morning after Halloween 本题型属于搜索题，通过bfs去枚举状态，从而找到解。然而该题的状态数上限是256的三次方，状态转移有5的3次方个方法，转移代价高。解决方法： 1、因为题目保证每2×2个方格一定有一个障碍，所以可以将所有空格提取出来。目的是在状态转移时不用每次去判断条件（越界、有障碍）。 2、双向bfs，将起点和终点同时放进队列。 3、A*算法。 锦上添花之举： 1、用编码(encoding)的方法将每个状态（节点的位置）压缩成一个整数再放进队列；取出来
1601:The Morning after Halloween（经典）
Jingwang Li
12-05 383
The Morning after Halloween 直接BFS会超时，题目中提示过墙壁很多，那么可以将所有的空格提取出来做张图，然后记录每个空格周围的邻居，这样就不用每次都判断能不能走了。优化的话可以使用双向BFS，从每次正向（从开始位置搜索）搜索一次，反向（从目标位置搜索）搜索一次，如果有相同状态则找到最短路径。 BFS（800ms）: #include&lt;bits/stdc++...
Uva1601 The Morning after Halloween 双向bfs，建图
秋叶红于二月花
11-05 237
题目链接 16*16的网格上最多有3个小写字母，把它们移动到各自的目标位置处。每步可以移动多个字母（上下左右走一格或者不走），但字母不能占用同一位置，也不能在一步以内交换两个字母的位置。 输入保证所有空格连通，障碍连通，且任何2*2的子网格中至少有一个障碍格。输出最少的移动步数。 本题收录于《编码的艺术》。 ...
The Morning after Halloween
叶子心情你不懂
04-14 362
You are working for an amusement park as an operator of an obakeyashiki, or a haunted house, in which guests walk through narrow and dark corridors. The house is proud of their lively ghosts, which ar
UVa 1601 万圣节后的早晨（The morning after Halloween）
Inuyasha__的博客
09-04 361
题目： w*h 网格上有n (n<=3) 个小写字母，要求把他们分别移动到对应的大写字母里。每步可以有多个鬼同时移动（往上下左右移动，也可以不动，移动是独立的），每步结束后两个鬼不能占用同一个位置，也不能在一步之内交换位置。 要点: 建立新的有向图 下面给出两种做法，在UVA上分别以 1000ms 和 750ms 左右通过， 双向bfs快了不多。 bfs: #include<bit...
例题7-9　万圣节后的早晨（The Morning after Halloween, Japan 2007, UVa1601）
%%%
10-18 768
思路：同为bfs求解最少步数，问题在于状态如何更好地枚举。 无法开256^3的数组，利用题中2*2格中必有*的条件，改矩阵图为存边的图，点则变为144个，可存数组。#include #include #include #include #include #include #include #include #include #include #include #includ
UVa1601 万圣节后的早晨(The Morning after Halloween)
Where_tonight的博客
06-25 809
终于学到搜索了。。学完BFS，就遇到这道题 不会！！！，不过仔细研究了书上的讲解，又加了一番冥思苦想，也算是写出了代码 代码中注释写的比较清楚，这里也没有必要解释什么 #include #include #include #include #include using namespace std; const int maxs = 20;//矩形地图，最大16，这里设置大点，20吧
uva 1601 The Morning after Halloween
iwi
08-18 557
题目：The Morning after Halloween 题意：有n个用小写字母表示的鬼和一张地图，每个鬼都要移动到对应的大写字母，两个鬼的位置不能在一次移动中交换，问最少步数。 思路： bfs。 1、先将地图用图的方法表示，即在每一个空白（包括大小写字母）和四周的空白连上一条边，用单个整数表示一个空白。 2、在图上进行bfs。注意只有一个鬼的情况，此时鬼b和鬼c所在
UVa1601 - The Morning after Halloween(单向+双向BFS)
Dosth_Magic
04-29 945
给出一个最大为16×16的迷宫图和至多3个ghost的起始位置和目标位置，求最少经过几轮移动可以使三个ghost都到达目标位置。每轮移动中，每个ghost可以走一步，也可以原地不动，需要注意的是任意两个ghost不能在相同的位置，因此也不能出现任意两个ghost对穿，也就是原来是ab，移动之后是ba。每个迷宫图'#'表示墙，' '表示空地，小写字母表示ghost的起始位置，大写字母表示对应ghos
The Morning after Halloween（UVA - 1601）
不知所云的博客
01-16 325
The Morning after Halloween 这道题可以用bfs做，但是前期处理比较复杂，主要分为以下几步： 1.建图； 题目给的‘#’太多，一个状态有三个字符，相当于我们每次一个状态到下一个状态都要判断三次，每次呢又有5种不同的走法，相当于每次转状态都要枚举5^3个； 我们可以单独把空格进行编号，根据空格的连接关系，连成一张图，然后遍历这张图就可以了；我用的是链式前向星进行连接； 2....
1601 - The Morning after Halloween
Switch的博客
05-28 1028
PS：因为该题排版较麻烦，这里给出OJ网址：UVa 1601 - The Morning after Halloween w*h（w,h≤16）网格上有n（n≤3）个小写字母（代表鬼）。要求把它们分别移动到对应的大写字母里。每步可以有多个鬼同时移动（均为往上下左右4个方向之一移动），但每步结束之后任何两个鬼不能占用同一个位置，也不能在一步之内交换位置。 输入保证所有空格连通，所有障碍格也
UVa OJ 1601 - The Morning after Halloween
Yuuki_Dach's Blog
08-04 493
UVa OJ 1601-The Morning after HalloweenProblemYou are working for an amusement park as an operator of an obakeyashiki, or a haunted house, in which guests walk through narrow and dark corridors. The ho
【UVa】【BFS】1601 The Morning after Halloween
IDDFS
08-23 186
UVa 1601 The Morning after Halloween 题目 ◇题目传送门◆（由于UVa较慢，这里提供一份vjudge的链接） ◇题目传送门（vjudge）◆ 题目大意 在一个W×HW×HW\times H的网格上有N(N≤3)N(N≤3)N(N\le3)个鬼，用小写字母表示。要求将所有鬼移动到对应的大写字母处。每步可以有多个鬼移动（均为上下左右四个方向之一），但每...
The Morning after Halloween UVA - 1601
Mrhanice的博客
11-19 325
状态空间搜索 题目描述：把图中的小写字母，移动到对应的大写字母处，这些小写字母可以同时移动，而且只能通过空白处移动，两个字母之间不可以互换位置，也不可以在同一个位置。 解题分析：直接暴力bfs的话，状态数目是256*256*256，状态数目不是很多，但是每一个状态的转移需要5*5*5的次数，这样的话时间复杂度就大了去了。注意到，题目中并不全是空白处，而是充满了大量的墙壁，所以以对所有的空白处建
UVA 1601 The Morning after Halloween [DBFS]
C'est la vie.
10-09 392
The Morning after Halloween Time Limit: 12000MS 64bit IO Format: %lld & %llu 直接搜索时间过不了。 可以先把底图抽出来，这样的话就不用O(maxn*maxn*5)来判断是否可以转移了。 另外，用双向BFS可以减少一半深度的搜索，meet in the middle，另外用hash加速进
UVa #1601 The Morning after Halloween （例题7-9）
专攻挖掘机炒鸡蛋算法的专栏
01-05 1881
状态空间搜索。。不过状态数量比较多，很容易TLE 优化的方法： 1、使用邻接表 如果每次都使用“尝试走一步看看行不行”的方法，会重复很多次无用的判断。所以用一个vector来保存每个空地相邻的空地，每次走路就遍历这个vector 2、判重的方法 一开始我用了State类型的map来判重，速度很慢。而将坐标hash为一个整数后，存在一个三维数组里（因为最多有三个ghost）进行判重
【Jason's_ACM_解题报告】The Morning after Halloween
DoriLeigh的专栏
02-23 489
The Morning after Halloween 解题报告
Vienna LTE-Advanced模拟器中的期权计算函数详解
在这个关于"期权函数-the vienna lte-advanced simulators"的文章中，主要讨论的是量化交易中的期权定价和隐含波动率计算。文章首先介绍了期权理论的基础，特别是Black-Scholes-Merton (BSM)模型，它是金融衍生品...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值