UVA 1601 Morning after holloween(搜索前的剪枝）

最新推荐文章于 2017-12-15 12:59:00 发布
最新推荐文章于 2017-12-15 12:59:00 发布
阅读量426 收藏 1
点赞数 1
分类专栏： 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/disparity_CJK/article/details/52973940
版权

【题意】

         

               w*h（w、h<=16）网格上有n（n<=3）个小写字母（代表鬼）。要求把他们   分别移动到对应的大写字

      母里。每步可以有多个鬼同时移动（可以往上下左右移动或不动），但每步结束之后任何两个鬼不能占用同

     一个位置，也不能在一步之内交换位置。任意一个2*2子网格中至少有一个‘#’，鬼不能再‘#’上移动。输出最

     少的步数，保证有解。


【分析】

        此题用一般的bfs做肯定超时，刚开始想的有几个鬼就几次bfs，用数组标记每个鬼走的点的步数，最后相

   加。后来仔细想了想这样做是非常麻烦且很难达到目标的。

         1. 题目指出任意一个2*2子网格中最少有一个‘#’，表示这输入的网格中有很多‘#’，真正能走的路很少，所以

  新定义一个数组，用来保存能走的点及其能走到哪几个点。

         2.  表示坐标得用2个变量表示，有点麻烦，将坐标压缩成一个整数，方便使用和移动。

         3. 题目有多个鬼同时移动，因为无法事先知道有几个鬼，不然就令鬼为3个，节约讨论的代码，省掉很多代

   码。

         4. 将3个鬼的坐标通过位运算压缩到1个整数里，方便搜索过程。

  

【代码】      


方法一：单向BFS

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
int n,m,k;
int book[200][200][200],G[200][5];
int deg[200];
int s[3],t[3];
int fang[5][2]={0,0,-1,0,0,-1,0,1,1,0};

inline bool fun(int a,int b,int a2,int b2)
{
    return (a2==b2)||(a==b2&&b==a2); // 判断是否走到同一点或者两点交换了
}

inline int ID(int a,int b,int c)
{
    return (a<<16) | (b<<8) | c; // 将三个坐标合成一个数
}

int BFS()
{
    memset(book,-1,sizeof(book));
    queue<int>p;
    p.push(ID(s[0],s[1],s[2]));
    book[s[0]][s[1]][s[2]]=0;
    while(!p.empty())
    {
        int u=p.front();
        p.pop();
        int a=(u>>16)&0xff,b=(u>>8)&0xff,c=u&0xff; // 将合并的点拆分出来，进行移动
        if(a==t[0]&&b==t[1]&&c==t[2])
            return book[a][b][c];
        for(int i=0;i<deg[a];i++)
        {
            int a2=G[a][i];
            for(int j=0;j<deg[b];j++)
            {
                int b2=G[b][j];
                if(fun(a,b,a2,b2))
                    continue;
                for(int k=0;k<deg[c];k++)
                {
                    int c2=G[c][k];
                    if(fun(a,c,a2,c2)||fun(b,c,b2,c2))
                        continue;
                    if(book[a2][b2][c2]==-1)
                    {
                        book[a2][b2][c2]=book[a][b][c]+1;
                        p.push(ID(a2,b2,c2));
                    }
                }
            }
        }
    }
    return -1;
}

int main()
{
    while(scanf("%d %d %d",&m,&n,&k)&&(n+m+k))
    {
        getchar();
        memset(G,0,sizeof(G));
        memset(deg,0,sizeof(deg));
        char e[20][20];
        for(int i=0;i<n;i++)
            fgets(e[i],18,stdin);
        int cnt=0,id[20][20]={0},x[200]={0},y[200]={0};
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(e[i][j]!='#') // 将不是'#'的数据分离出来，节约搜索时间，不然超时
                {
                    x[cnt]=i;
                    y[cnt]=j;
                    id[i][j]=cnt;
                    if(e[i][j]>='a'&&e[i][j]<='c')
                        s[e[i][j]-'a']=cnt;
                    else if(e[i][j]>='A'&&e[i][j]<='C')
                        t[e[i][j]-'A']=cnt;
                    cnt++;
                }
            }
        }
        for(int i=0;i<cnt;i++) // 进行非‘#’位置的移动，判断可以的的方向的个数及其坐标，节约时间
        {
            deg[i]=0;
            for(int j=0;j<5;j++)
            {
                int tx,ty;
                tx=x[i]+fang[j][0];
                ty=y[i]+fang[j][1];
                if(e[tx][ty]!='#')
                    G[i][deg[i]++]=id[tx][ty];
            }
        }
        // 如果不够3个就补上，方便进行操作，不然还得进行3种讨论
        if(k<=2)
        {
            deg[cnt]=1;
            G[cnt][0]=cnt;
            s[2]=t[2]=cnt++;
        }
        if(k<=1)
        {
            deg[cnt]=1;
            G[cnt][0]=cnt;
            s[1]=t[1]=cnt++;
        }
        printf("%d\n",BFS());
    }
    return 0;
}

方法二：双向BFS 

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
int n,m,k;
int book[200][200][200],vis[200][200][200],G[200][5];
int deg[200];
int s[3],t[3];
int fang[5][2]= {0,0,-1,0,0,-1,0,1,1,0};

inline bool fun(int a,int b,int a2,int b2)
{
    return (a2==b2)||(a==b2&&b==a2); // 判断是否走到同一点或者两点交换了
}

inline int ID(int a,int b,int c)
{
    return (a<<16) | (b<<8) | c; // 将三个坐标合成一个数
}

int BFS()
{
    memset(book,0,sizeof(book));
    memset(vis,0,sizeof(vis));
    queue<int>p,q;
    p.push(ID(s[0],s[1],s[2]));
    q.push(ID(t[0],t[1],t[2]));
    book[s[0]][s[1]][s[2]]=0;
    book[t[0]][t[1]][t[2]]=1;
    vis[s[0]][s[1]][s[2]]=1;
    vis[t[0]][t[1]][t[2]]=2;
    while(!p.empty()||!q.empty())
    {
        int len1=p.size();
        while(len1--)   // 双向BFS是按层搜索的，不然会出错，可能一个环上面要4步，下面要3步，如果正反按步搜索，你走一步我走一步就会出错
        {
            int u=p.front();
            p.pop();
            int a=(u>>16)&0xff,b=(u>>8)&0xff,c=u&0xff; // 将合并的点拆分出来，进行移动
            for(int i=0; i<deg[a]; i++)
            {
                int a2=G[a][i];
                for(int j=0; j<deg[b]; j++)
                {
                    int b2=G[b][j];
                    if(fun(a,b,a2,b2))
                        continue;
                    for(int k=0; k<deg[c]; k++)
                    {
                        int c2=G[c][k];
                        if(fun(a,c,a2,c2)||fun(b,c,b2,c2))
                            continue;
                        if(vis[a2][b2][c2]==0)
                        {
                            vis[a2][b2][c2]=1;   // 正标记
                            book[a2][b2][c2]=book[a][b][c]+1;
                            p.push(ID(a2,b2,c2));
                        }
                        else if(vis[a2][b2][c2]==2) // 如果反向走过此点，就说明构成了最短路
                            return book[a][b][c]+book[a2][b2][c2];
                    }
                }
            }
        }
        int len2=q.size();
        while(len2--)
        {
            int u=q.front();
            q.pop();
            int a=(u>>16)&0xff,b=(u>>8)&0xff,c=u&0xff; // 将合并的点拆分出来，进行移动
            for(int i=0; i<deg[a]; i++)
            {
                int a2=G[a][i];
                for(int j=0; j<deg[b]; j++)
                {
                    int b2=G[b][j];
                    if(fun(a,b,a2,b2))
                        continue;
                    for(int k=0; k<deg[c]; k++)
                    {
                        int c2=G[c][k];
                        if(fun(a,c,a2,c2)||fun(b,c,b2,c2))
                            continue;
                        if(vis[a2][b2][c2]==0)
                        {
                            vis[a2][b2][c2]=2;   // 反标记
                            book[a2][b2][c2]=book[a][b][c]+1;
                            q.push(ID(a2,b2,c2));
                        }
                        else if(vis[a2][b2][c2]==1) // 如果正向走过此点，就说明构成了最短路
                            return book[a][b][c]+book[a2][b2][c2];
                    }
                }
            }
        }
    }
    return -1;
}

int main()
{
    while(scanf("%d %d %d",&m,&n,&k)&&(n+m+k))
    {
        getchar();
        memset(G,0,sizeof(G));
        memset(deg,0,sizeof(deg));
        char e[20][20];
        for(int i=0; i<n; i++)
            fgets(e[i],18,stdin);
        int cnt=0,id[20][20]= {0},x[200]= {0},y[200]= {0};
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<m; j++)
            {
                if(e[i][j]!='#') // 将不是'#'的数据分离出来，节约搜索时间，不然超时
                {
                    x[cnt]=i;
                    y[cnt]=j;
                    id[i][j]=cnt;
                    if(e[i][j]>='a'&&e[i][j]<='c')
                        s[e[i][j]-'a']=cnt;
                    else if(e[i][j]>='A'&&e[i][j]<='C')
                        t[e[i][j]-'A']=cnt;
                    cnt++;
                }
            }
        }
        for(int i=0; i<cnt; i++) // 进行非‘#’位置的移动，判断可以的的方向的个数及其坐标，节约时间
        {
            deg[i]=0;
            for(int j=0; j<5; j++)
            {
                int tx,ty;
                tx=x[i]+fang[j][0];
                ty=y[i]+fang[j][1];
                if(e[tx][ty]!='#')
                    G[i][deg[i]++]=id[tx][ty];
            }
        }
        // 如果不够3个就补上，方便进行操作，不然还得进行3种讨论
        if(k<=2)
        {
            deg[cnt]=1;
            G[cnt][0]=cnt;
            s[2]=t[2]=cnt++;
        }
        if(k<=1)
        {
            deg[cnt]=1;
            G[cnt][0]=cnt;
            s[1]=t[1]=cnt++;
        }
        printf("%d\n",BFS());
    }
    return 0;
}


【收获】

           

            1. 当无用数据很多时，可以选择重新构建数组，只保存有用数据，节约搜索时间。

           2. 搜索保存周围能走的点，结尾搜索时间，不过得用一个数组保存每个点能走到几个点，对可走方向比较少的数据用，否则此方法没太大作用。

           3. 数据有部分关系，且范围不是太大，可以选择压缩到一个数据里面。

           4. 双向BFS，双向BFS必须按层走，正向走完所有当前一步，再反向走完所以当前一步，不然会出错，例如S-->T,从上面走需要过3个点、4步，从下面走需要过2个点、3步，如果按点走的话，如果先从上面走就会出现错误。



disparity_CJK
关注
专栏目录
Holloweeniebats
10-25
在IT行业中，字体设计是视觉传达的关键组成部分，尤其在网页设计、图形设计、软件界面以及数字出版等领域。"Holloweeniebats"这个标题暗示我们可能正在处理一种与万圣节主题相关的特殊字体，可能是为了营造节日氛围...
irjs-thingiverse:用于搜索、上传、获取 3D 模型的 thingiverse api
05-30
thing#:65432 Pumpkin holloween ... pumpkin spice latte.zip saved Makerbot Pumkin.zip saved Pumpkin holloween.zip saved ... $ thing search -t robot thing#:12345 Hanbot thing#:98766 Pumpkinbot ... $ ...
UVa1601 Morning after holloween 单向BFS方法
weixin_30692143的博客
12-15 49
　　紫书上的题，一开始全用stl容器结果tle，于是重写一遍全换成自己手写的容器。另外重写判重和互穿的时候还将n=1,2,3时的情况单独分类。AC代码如下。这道题给的内存还是很充足的。 1 #include<iostream> 2 #include<memory.h> 3 #include<string> 4 #define IN...
UVa1601 Morning after holloween 解题分析
weixin_34008784的博客
02-03 44
只有思路还没有实践 这个题一眼看上去就是典型的状态空间搜索问题，a,b,c的每一个不同摆放位置都是一个状态，每一个状态都可以看成无权有向无环状图上的一个节点。又是找移动步数最少的走法，很自然就会想到用BFS。 细想上去，这个题稍微麻烦的地方是，如何从一个状态扩展到下一个状态。每个状态有2个或者3个字母需要考虑。如果是3个字母，似乎应该用一个三重循环来枚举每个字母的5种移动方向，上下左右和不动，...
uva 1601 poj 3523 Morning after holloween 万圣节后的早晨 （经典搜索，双向bfs+预处理优化+状态压缩位运算）
LjcoderDCC的博客
06-25 891
直接上代码，注释在代码里，注意巧妙地数据规模256 #include #include #include #include #include using namespace std; const int maxn=150,maxs=20; const int dx[]={-1,1,0,0,0}; const int dy[]={0,0,1,-1,0}; inline int ID(int a,i
UVA 1412 Fund Management （预处理+状压dp）
weixin_33827590的博客
08-22 138
状压dp，每个状态可以表示为一个n元组，且上限为8，可以用一个九进制来表示状态。但是这样做用数组开不下，用map离散会T。 而实际上很多九进制数很多都是用不上的。因此类似uva 1601 Morning after holloween的思想，先dfs预处理出所有状态，用map将状态离散， 预处理出算出状态的转移DAG，而不是转移的时候在解码编码判断是否可行，然后一层一层bfs就行了。 附上测...
黑白图像—————— 八连块
disparity_CJK的博客
05-06 1603
八连块 【题目】：              输入一个n*n的黑白图像（1表示黑色，0表示白色），任务是统计其中八连块的个数。如果两个黑格子有        公共边或者公共顶点，就说它们属于同一个八连块。如下图6-11表示3个八连块。 【分析】             通过题目要求，定义8方向数组，运用搜索来确定有几个八连块，搜索查找，     查找过的进行标记，保证不会重复查
八数码问题
disparity_CJK的博客
05-04 920
八数码问题 题意：          编号为1~8的8个正方形滑块被摆成3行3列（有一个格子留空），如下图所示       每次可以把与空格相邻的滑块（有公共边才算相邻）移到空格中，而他原来的位置   就成为了新的空格。如果无法到达目标局面，则输出-1 。       2         6        4         1       3    7
UVA 12558 埃及分数（迭代搜索）
disparity_CJK的博客
11-12 860
【题意】         把a/b写成不同分数之和，且分数分子必须为1，要求项数尽量小，在此前提下最小的分数尽量大，然后第     二小的分数尽量大……另外有k（0             输入保证2 【分析】        通过之前看的简单的埃及分数，知道了大体的求解步骤。        1.  此题需要用迭代加深搜索，如果只dfs，是一个没有下界的搜索，死递归；如果bfs，
UVA 1599 Ideal Path (理想路径）
disparity_CJK的博客
10-25 682
【题意】            给一个n个点m条边（2 【分析】  1.      本题是不错的bfs题，因为数据太大，如果直接找绝对超时。   2.       题目给的n小于等于100000，所以不能用邻接矩阵来保存，只能通过邻接表，用邻接表保存还方便进              行遍历，用结构体保存邻接表，同时记录颜色的数值。  3.       题目中无向图可能有自环和重
蓝桥杯---剪邮票---DFS的适用范围
disparity_CJK的博客
04-06 629
剪邮票 【题意】 如【图1.jpg】, 有12张连在一起的12生肖的邮票。 现在你要从中剪下5张来，要求必须是连着的。 （仅仅连接一个角不算相连） 比如，【图2.jpg】，【图3.jpg】中，粉红色所示部分就是合格的剪取。 请你计算，一共有多少种不同的剪取方法。 请填写表示方案数目的整数。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
UVA 10603 Fill（倒水问题）
disparity_CJK的博客
10-29 521
Fill There are three jugs with a volume of a, b and c liters. (a, b, and c are positive integers not greater than 200). The first and the second jug are initially empty, while the third is c
HDU 1175 练练看
disparity_CJK的博客
05-12 499
连连看                                                              Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
POJ 3083 Children of the Candy Corn（ BFS + DFS ）有意思的题目
disparity_CJK的博客
09-12 444
Children of the Candy Corn Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 13022   Accepted: 5623 Description The cornfield maze is a popular Halloween tre
基于大模型技术的算力产业监测服务平台设计
09-17
内容概要：本文提出了一种新型算力产业监测服务平台的设计理念，运用国内自主研发的大模型技术支持，通过对传统技术的改进和完善，提出了三层架构的设计方法，即基础设施层（含向量数据库和模型训练）、大模型应用框架层（强化数据处理与多维关系挖掘）及业务层（如智能分析助手）。这种设计方案旨在提高算力产业发展监测与决策制定的质量。 适合人群：电信行业的从业人员及研究人员；算力产业链各环节管理者；政府相关机构和政策决策者。 使用场景及目标：在多种算力相关的应用场景（如云计算中心管理，数据中心监测，政策分析）中辅助决策者进行快速有效的信息获取和技术选择；助力算力产业发展方向的精确把控和战略调整。 其他说明：随着大模型技术的日臻成熟，该算力产业监测服务平台预计将进一步丰富自身的应用领域和服务深度，以促进算力行业更智慧化发展。
This_honeypot_supports_Telnet_and_SSH_two_protocol_FF-Pot.zip
最新发布
09-17
This_honeypot_supports_Telnet_and_SSH_two_protocol_FF-Pot
吉他谱_What I've Done - Linkin Park.pdf
09-17
初级入门吉他谱 guitar tab
吉他谱_Too sweet - Hozier.pdf
09-17
初级入门吉他谱 guitar tab
Linux使用的一些笔记，包括shell命令，软件，一些实用的网站的整理_Linux_note.zip
09-17
Linux使用的一些笔记，包括shell命令，软件，一些实用的网站的整理_Linux_note
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值