连连看 DFS

最新推荐文章于 2022-12-11 20:01:50 发布

点点滴滴25

最新推荐文章于 2022-12-11 20:01:50 发布

阅读量167

点赞数

分类专栏：搜索

本文链接：https://blog.csdn.net/qq_41325698/article/details/81910723

版权

搜索专栏收录该内容

14 篇文章 0 订阅

订阅专栏

连连看

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

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

Author

lwg

心中有点小疑惑，他的内存是怎么算的，？为什么一开始一直超内存，

下图的代码9860ms险过

#include<iostream>
#include<algorithm>
#include<string.h> 
using namespace std;
#pragma comment(linker, “/STACK: 1024000000,1024000000 ”)  手动加栈
struct node
{
    int x,y;
};
node s,e,ss;
int n,m,f=0,z=0,a[1001][1001],dir[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
bool vis[1001][1001];
bool isvalid(node d)                            判断你是否在圈内
{
    if(d.x>n||d.x<1||d.y<1||d.y>m)
    return false;
    return true;
}
void DFS(node k,node dr,int d)     k表示当前探索的坐标节点，dr表示当前的方向节点，d表示有几次转折
{
    vis[k.x][k.y]=true;
    if(d>3||f)                          这点d应大于3，因为他把从起点到起点到下一个遍历点也算成一次转折
    return ;
    if(k.x==e.x&&k.y==e.y)          
    {
        f=1;
        return ;
    }
    for(int i=0;i<4;i++)
    {
        node sk;                       血的教训告诉我，一定要新生成节点，一定要
        sk.x=k.x+dir[i][0];
        sk.y=k.y+dir[i][1];
        if(vis[sk.x][sk.y])
        continue;
        if(a[sk.x][sk.y]==0&&isvalid(sk)||(sk.x==e.x&&sk.y==e.y&&isvalid(sk)))
        {
            if(vis[sk.x][sk.y]==true)  
            continue;
            node dd;                         一定要，如果把他置为全局变量，很难控制其状态，保险起见，还是新生成一个节点
            dd.x=dir[i][0];
            dd.y=dir[i][1];
            if(dr.x==dd.x&&dr.y==dd.y)
            {
                //cout<<sk.x<<"  "<<sk.y<<"  "<<d<<endl; 
                DFS(sk,dd,d);
            }
            else
            {
                //cout<<sk.x<<"  "<<sk.y<<"  "<<d+1<<endl;
                DFS(sk,dd,d+1);
            }
            vis[sk.x][sk.y]=false;
        }
    }
}
int main()
{
    int i,j,t;
    //freopen("1.txt","r",stdin);
    while(~scanf("%d%d",&n,&m),n||m)
    {
        memset(vis,false,sizeof(vis));
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=m;j++)
            {
                scanf("%d",&a[i][j]);
            }
        }
        scanf("%d",&t);
        while(t--)
        {
            scanf("%d%d%d%d",&s.x,&s.y,&e.x,&e.y);
            if(a[s.x][s.y]*a[e.x][e.y]==0||a[s.x][s.y]!=a[e.x][e.y]||s.x==e.y&&s.y==e.y)
            {
                printf("NO\n");
                continue;
            }
            
            if(a[s.x][s.y]==a[e.x][e.y])
            {
                f=0;
                ss.x=ss.y=0;
                DFS(s,ss,0);
                vis[s.x][s.y]=false;            这个起点记得要回溯
                if(f==1)
                printf("YES\n");
                else
                printf("NO\n");
            }
        }
    }
    return 0;
}