HDU 1175 连连看(bfs + 剪枝)

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"。

Sample Input:

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

Sample Output:

YES

NO

NO

NO

NO

YES

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#define LL long long
using namespace std;
const int MAXN = 1000 + 10;
int n, m;
int M[MAXN][MAXN], vis[MAXN][MAXN];
struct Point
{
    int x, y;
    int dir, change;
};
Point S, E;
int dir[][2] = {{0,-1},{0,1},{-1,0},{1,0}};//上下左右四个方向
bool bfs()
{
    queue<Point>Q;
    S.dir = -1, S.change = 0;//起点方向设为-1
    Q.push(S);
    while(!Q.empty())
    {
        Point pre = Q.front();
        Q.pop();
        if(pre.x == E.x && pre.y == E.y)//已经和终点相连
            return true;
        for(int i=0;i<4;i++)
        {
            Point cnt;
            cnt.x = pre.x + dir[i][0];
            cnt.y = pre.y + dir[i][1];
            cnt.dir = i;
            cnt.change = pre.change;
            if(cnt.dir != pre.dir && pre.dir != -1) cnt.change++;
            if(cnt.x < 0 || cnt.x >= n || cnt.y < 0 || cnt.y >= m || cnt.change > 2)//判断是否越界和转弯次数
                continue;
            if(M[cnt.x][cnt.y] != 0 && !(cnt.x == E.x && cnt.y == E.y))//当前位置不为空
                continue;
            if(cnt.change < vis[cnt.x][cnt.y])
            {
                vis[cnt.x][cnt.y] = cnt.change;
                Q.push(cnt);
            }
        }
    }
    return false;
}
int main()
{
    while(scanf("%d%d", &n, &m)!=EOF)
    {
        if(n == 0 && m == 0)
            break;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
                scanf("%d", &M[i][j]);
        }
        int Q;
        scanf("%d", &Q);
        //Point S, E;
        while(Q--)
        {
            scanf("%d%d%d%d", &S.x, &S.y, &E.x, &E.y);
            S.x--;S.y--;E.x--;E.y--;
            if(S.x == E.x && S.y == E.y)//若起点和终点相同则输出NO
            {
                printf("NO\n");
                continue;
            }
            if(M[S.x][S.y] != M[E.x][E.y] || M[S.x][S.y] == 0 || M[E.x][E.y] == 0)
            {//起点和终点不同或者起点和终点有一个为空则输出NO
                printf("NO\n");
                continue;
            }
            for(int i=0;i<n;i++)
                for(int j=0;j<m;j++)
                    vis[i][j] = INT_MAX;
            if(bfs()) printf("YES\n");
            else printf("NO\n");
        }
    }
    return 0;
}
时间: 2024-10-12 18:57:46

HDU 1175 连连看(bfs + 剪枝)的相关文章

HDU 1175 连连看 (BFS带方向的判定)

连连看 Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 23172    Accepted Submission(s): 5710 Problem Description “连连看”相信很多人都玩过.没玩过也没关系,下面我给大家介绍一下游戏规则:在一个棋盘中,放了很多的棋子.如果某两个相同的棋子,可以通过一条线连起来(这条线不能经过其

HDU 1175 连连看(BFS)

题意解析:其实就是判断起始点能否到达终止点.如果起始点和终止点值不同,直接输出NO.bfs,dfs都行. 附加条件:①不能出边界 ②不能走值为0的点 ③路径不能转向两次以上 节点需要记录该点的坐标,方向,转向次数.下面是BFS代码(注意剪枝:超过两次的就不要再加入队列了) #include<iostream> #include<cstdio> #include<queue> #define M 1005 using namespace std; int G[M][M];

HDU - 1175 连连看 DFS (记录方向)

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

【dfs】hdu 1175 连连看

[dfs]hdu 1175 连连看 题目链接:hdu 1175 连连看 题目大意 连连看,问能否成功? 题意很简单,就是我们平时玩的连连看的游戏规则,貌似dfs和bfs都能做,笔者就做了个dfs(好想),超时了好几次,原因是dfs(int d)与终点的d重载矛盾了,所以还是要小心. 说一下思路 神器的剪枝:if(t==2&&x!=c&&y!=d) return;这一部剪枝妙笔回春,9000+MS优化到100+MS啊:如果转了2次,但是目标与当前位置不在同一行或同一列就不满足

hdu 1175 连连看(模拟循环队列)

连连看 Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 18149    Accepted Submission(s): 4741 Problem Description "连连看"相信很多人都玩过.没玩过也没关系,下面我给大家介绍一下游戏规则:在一个棋盘中,放了很多的棋子.如果某两个相同的棋子,可以通过一条线连起来(这条

hdu 1175 连连看 (深搜)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1175 题目大意:如果某两个相同的棋子,可以通过一条线连起来(这条线不能经过其它棋子)这样的两个棋子可以消掉.还有一个要注意的地方的就是转弯.转弯的次数不超过两次,这两个棋子才可以在棋盘上消去~ 1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 using namespace std; 5 int

hdu - 1728逃离迷宫 &amp;&amp; hdu - 1175 连连看 (普通bfs)

http://acm.hdu.edu.cn/showproblem.php?pid=1728 这两道题花了一下午的时候调试,因为以前做过类似的题,但是判断方向的方法是错的,一直没发现啊,真无语. 每个状态除了坐标外还需要记录步数,和方向.还要注意输入格式. 并且每一个点并不是走过了就不能在走,只要到达这个点的时候转向次数少的就可以更新这个点,可以等于.千万注意这个坑. 1 #include <cstdio> 2 #include <cstring> 3 #include <q

HDU 1175 连连看(BFS)

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

HDU 1175 连连看【BFS】

题意:给出起点和终点的棋子,不能经过别的棋子,而且转弯的次数不能超过2次,问能否消除 和逃离迷宫一样,每个节点记录下来它的当前的方向和转弯的次数,再搜 注意特判起点的棋子和终点的棋子为0或者不一样的情况,这样的话就不用搜了,直接输出NO 1 #include<iostream> 2 #include<cstdio> 3 #include<cstring> 4 #include <cmath> 5 #include<stack> 6 #includ