HDU 1175 连连看 （bfs dfs）

-->>题目链接

题意：连连看，对除0之外的数字，如果某两个相同的数字，可以通过一条线连起来（这条线不能经过其它数字），而且线的转折次数不超过两次，那么这两个数字就可以在数字上消去。

注：对于一组棋盘的q次询问，每次询问棋盘都不变。

思路：广搜或深搜一直搜下去，找到答案，退出。

方法1：dfs （要剪枝，一开始没剪枝一直超时）

            

 

#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
int map[1100][1100];
int dx[]={0,1,0,-1},dy[]={1,0,-1,0};
bool vis[1100][1100];               //数组标记走过的坐标
int x2,y2,x1,y1,n,m;
bool flag;
void dfs(int x,int y,int  t,int time)
{
    vis[x][y]=1;                     //把起点标记
    if(x==x2&&y==y2){           //找到目标，flag赋为1
        flag=1;
        return;
    }
    if(time==2&&x-x2!=0&&y-y2!=0)           //剪枝（之前少了这一步一直超时）
        return;
        if(time>2)
            return;
      for(int i=0;i<4;i++ ){            
        if(flag)
            return;
        int a=x+dx[i];
        int b=y+dy[i];
            if(a<1||a>n||b<1||b>m)              //边界条件，这个连连看不能从外面绕
                continue;
        if(map[a][b]==0||(a==x2&&b==y2)&&!vis[a][b]){           //当走的路为0时可以走，或者找到目标
        if(t==-1||t==i)
                dfs(a,b,i,time);            //用i标记点走的方向，如果t==i及方向相同，则没有转折
            else
            dfs(a,b,i,time+1);
            vis[a][b]=0;
      }
    }
        return;
}
int main()
{

   while(cin>>n>>m&&n&&m){
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){            
        cin>>map[i][j];             //输出数据
    }
    int q;
    cin>>q;
    for(int i=0;i<q;i++){
         flag=0;            //用flag标记dfs是否找到目标
        memset(vis,0,sizeof(vis));
        cin>>x1>>y1>>x2>>y2;        
        if(map[x1][y1]==map[x2][y2]&&map[x1][y1]!=0)        //要找的两个数必须相同，且数字不能为0
        dfs(x1,y1,-1,0);        //（传入起点，方向，和转折次数）
        
        if(flag)                        //flag==1，则找到了目标，输出“YES”
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
   }

    return 0;
}

 

 

方法2：dfs  （不需要剪枝）

#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
int map[1100][1100];
int dx[]={0,1,0,-1},dy[]={1,0,-1,0};
bool vis[1100][1100];
int x2,y2,x1,y1,n,m,v;
struct node {
int x,y,time,t;             //结构体存坐标x,y.time为转折次数（乱写的），t为方向；
}q;

int bfs()
{
    vis[x2][y2]=1;
    q.x=x2;
    q.y=y2;
    q.time=0;
    q.t=-1;
    queue<node>p;           
    p.push(q);
    node k;
    while(!p.empty())
    {
        k=p.front();
        p.pop();
        if(k.time>2)
            continue;
        if(k.x==x1&&k.y==y1){
            return 1;
        }
        for(int i=0;i<4;i++){
            if(k.t!=i&&k.t!=-1)         //同样标记方向，如果方向不同则转折+1；
                q.time=k.time+1;
            else 
                q.time=k.time;
            q.x=k.x+dx[i];
            q.y=k.y+dy[i];
            q.t=i;
                if(q.x<1||q.x>n||q.y<1||q.y>m)
                    continue;
                if(map[q.x][q.y]==0&&!vis[q.x][q.y]||q.x==x1&&q.y==y1){
                    vis[q.x][q.y]=1;
                    p.push(q);
                }
        }
    }
    return -1;
}      
 //标准的bfs模板，找到目标返回1，否则返回-1；
int main()
{
   while(cin>>n>>m&&n&&m){
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
        cin>>map[i][j];
        }
        int k;
        cin>>k;
        for(int i=0;i<k;i++){
        memset(vis,0,sizeof(vis));
        cin>>x2>>y2>>x1>>y1;
        v=0;
        if(map[x2][y2]==map[x1][y1]&&map[x2][y2]!=0)
            v=bfs();
        if(v==1)
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
     }
}
    return 0;
}
​