poj 1979 简单的搜索

与迷宫问题类似 用BFS或者DFS都可以

 

 

BFS和DFS的简单区别在于 当产生新的结点时DFS先从新的结点开始拓展，而BFS从先产生该结点的结点开始拓展

 

 

 

题目大意：给定一组数据，其中'.'代表黑色瓦片，'#'代表红色瓦片，'@'为当前位置，从当前位置出发只能够经过黑色瓦片，求能经过的不重复的瓦片的最大数量

 

广度优先搜索：

#include<iostream>
#include<queue>
#define MAX 25
using namespace std;
int dirx[4] = {0,0,1,-1},diry[4] = {1,-1,0,0};
char maze[MAX][MAX];
int w,h;
int visited[MAX][MAX];
struct node{

 int x,y;
 int nextx,nexty;
};
node dir;
void init(){

 int i,j;
 for(i = 1;i <= h;i++)
  for(j = 1;j <= w;j++){
  
   cin>>maze[i][j];
   if(maze[i][j] == '@'){
   dir.x = i;
   dir.y = j;
   }
  }
}
void BFS(){

 node t,s;
 int i,count = 1;
 queue<node> que;
 memset(visited,0,sizeof(visited));
 que.push(dir);
 visited[dir.x][dir.y] = 1;
 while(!que.empty()){

  t = que.front();
  que.pop();
  for(i = 0;i < 4;i++){

   if(t.x+dirx[i] >= 1&&t.x+dirx[i] <= h&&t.y+diry[i] >= 1&&t.y+diry[i] <= w&&
    maze[t.x+dirx[i]][t.y+diry[i]] == '.'&&visited[t.x+dirx[i]][t.y+diry[i]] == 0){
   
    count++;
    t.nextx = t.x+dirx[i];
    t.nexty = t.y+diry[i];
    s.x = t.nextx;
    s.y = t.nexty;
    visited[s.x][s.y] = 1;
    que.push(s);
   }
  }
 }

 cout<<count<<endl;
}
int main(){

 while(cin>>w>>h&&w&&h){
 
  init();
  BFS();
 }
 return 0;
}

 

深度优先搜索：

#include<iostream>
#define MAX 25
using namespace std;
int count,visited[MAX][MAX],h,w;
char maze[MAX][MAX];
int dirx[4] = {1,-1,0,0},diry[4] = {0,0,1,-1};
void DFS(int i,int j){

 count++;
 visited[i][j] = 1;
 for(int k = 0;k < 4;k++){
 
  int nextx = i+dirx[k];
  int nexty = j+diry[k];
  if(nextx >= 1&&nextx <= h&&nexty >= 1&&nexty <= w&&maze[nextx][nexty] == '.'&&visited[nextx][nexty] == 0)
   DFS(nextx,nexty);
 }
}
int main(){

 while(cin>>w>>h&&w&&h){
 
  int i,j,begin_i,begin_j;
  memset(visited,0,sizeof(visited));
  for(i = 1;i <= h;i++)
   for(j = 1;j <= w;j++){
    cin>>maze[i][j];
    if(maze[i][j] == '@'){
    
     begin_i = i;
     begin_j = j;
    }
   }
   count = 0;
   DFS(begin_i,begin_j);
   cout<<count<<endl;
 }
 return 0;
}