连连看(hdu1175 bfs+方向记录+贪心剪枝)

最新推荐文章于 2020-12-30 14:43:47 发布

原创最新推荐文章于 2020-12-30 14:43:47 发布 · 981 阅读

1 ·

CC 4.0 BY-SA版权

bfs搜索专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了游戏连连看的规则及背后的算法实现过程，包括如何通过鼠标操作匹配相同棋子并消除它们，以及如何在游戏环境中进行复杂的路径搜索以判断棋子是否能被消除。文章深入探讨了算法设计、优化剪枝策略以及实现细节。

连连看

Time Limit: 20000/10000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 13007 Accepted Submission(s): 3404

Problem Description

“连连看”相信很多人都玩过。没玩过也没关系，下面我给大家介绍一下游戏规则：在一个棋盘中，放了很多的棋子。如果某两个相同的棋子，可以通过一条线连起来（这条线不能经过其它棋子），而且线的转折次数不超过两次，那么这两个棋子就可以在棋盘上消去。不好意思，由于我以前没有玩过连连看，咨询了同学的意见，连线不能从外面绕过去的，但事实上这是错的。现在已经酿成大祸，就只能将错就错了，连线不能从外围绕过。
玩家鼠标先后点击两块棋子，试图将他们消去，然后游戏的后台判断这两个方格能不能消去。现在你的任务就是写这个后台程序。

Input

输入数据有多组。每组数据的第一行有两个正整数n,m(0<n<=1000,0<m<1000)，分别表示棋盘的行数与列数。在接下来的n行中，每行有m个非负整数描述棋盘的方格分布。0表示这个位置没有棋子，正整数表示棋子的类型。接下来的一行是一个正整数q(0<q<50)，表示下面有q次询问。在接下来的q行里，每行有四个正整数x1,y1,x2,y2,表示询问第x1行y1列的棋子与第x2行y2列的棋子能不能消去。n=0,m=0时，输入结束。
注意：询问之间无先后关系，都是针对当前状态的！

Output

每一组输入数据对应一行输出。如果能消去则输出"YES",不能则输出"NO"

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstdlib>
#include<cstring>
using namespace std;
int n,m;
int map[1005][1005];
int visit[1005][1005];
int hash[1005][1005];/*因为要回搜，记录所有点的最少转弯次数，剪枝使用，比如搜到i点最少转1次，当又回搜改点时转弯是2次
果断减掉该点，因为1次都不能到那2次就更不能到了，如果1次到了，那2次都不用找了，如果不剪枝白白邮费大量时间搜索无用区域，不信可以去掉hash数组试试，会超时的10000ms啊，以后根据题目招剪枝的条件，条件都在题目中啊*/

struct point
{
      int x;
      int y;
      int de;//记录放向
      int con;//记录转弯次数
};
int dect[4][2] = {1,0,0,-1,-1,0,0,1};
int bfs(point start,point end)
{
    queue<point> q;
    q.push(start);
    visit[start.x][start.y] = 1;
    while(!q.empty())
    {
        point g = q.front();
        q.pop();
        int i;
        for(i = 0; i < 4; i++)
        {
              point t ;
              t.x = g.x + dect[i][0];
              t.y = g.y + dect[i][1];
              if(g.de == -1)
              {
                   t.de = i;t.con = g.con;
              }
              else if(g.de != i)
              {
                   t.de = i;
                   t.con = g.con + 1;
              }
              else
              {
                  t.de = i;t.con = g.con;//转弯次数，转弯方向一样，次数不变，否则次数+1，四个方向分别为1,2,3,4
              }
              if(t.x >= 1 && t.x <= n && t.y >= 1 && t.y <= m&& t.con <= 2&&t.con <= hash[t.x][t.y])
              {
                     if(map[t.x][t.y] == 0 )
                     {    
                          hash[t.x][t.y] = t.con;                      
                          q.push(t);             
                     }
                     if(t.x == end.x && t.y == end.y)
                     {   
                         hash[t.x][t.y] = t.con;                     
                         if(t.con <= 2)
                         {
                          // map[start.x][start.y] = 0;map[end.x][end.y] = 0;
                           return 1;     
                         }       
                     }
              }           
        }
    }
    return -1;
}
int main()
{
    while(scanf("%d%d",&n,&m) != EOF)
    {
        int i,j;
        if(n == 0 && m == 0)
             break;
        memset(visit,0,sizeof(visit));
        for(i = 1; i <= n; i++)
        {
              for(j = 1; j <= m; j++)
              {
                    scanf("%d",&map[i][j]);
              }
        }
        int k;
        point start,end;
        scanf("%d",&k);
        while(k--)
        {
            memset(visit,0,sizeof(visit));
            memset(hash,0x3f,sizeof(hash));
            scanf("%d%d%d%d",&start.x,&start.y,&end.x,&end.y);
            start.con = 0,start.de = -1;
            int num = bfs(start,end);
            if(map[start.x][start.y] == map[end.x][end.y] && map[start.x][start.y])
            {
                 if(num != -1)
                 {   printf("YES\n");}
                else
                       printf("NO\n");
            }
            else
            {
                printf("NO\n");
            }
        }
        
    }
    return 0;    
}