BFS和DFS (java版)

 package com.algorithm.test;

 import java.util.ArrayDeque;
 import java.util.Scanner;

 public class DfsAndBfs {

     private static final int[][] dir = {
             {,},
             {,-},
             {,-},
             {,},
             {,},
             {-,-},
             {-,},
             {-,},
     };

     private static int[][] vis;
     private static char[][] map = {
             {'*','*','*','*','@'},
             {'*','@','@','*','@'},
             {'*','@','*','*','@'},
             {'@','@','@','*','@'},
             {'@','@','*','*','@'},
     };

     private static Node q;

     private static Node pos;

     private static ArrayDeque<Node> que;

     private static Scanner cin;

     public static void main(String[] args) {
         cin = new Scanner(System.in);
 //        cinDataForBfs();
         cinDataForDfs();
     }

     public static void cinDataForBfs() {
         while(cin.hasNext()) {
             int m = cin.nextInt();
             int n = cin.nextInt();
             if(m ==  && n == ) {
                 break;
             }
             int ans = ;
             for(int i = ; i < m; i++) {
                 for(int j = ; j < n; j++) {
                     if(map[i][j] == '@') {
                         ans++;
                         bfs(i,j,m,n);
                     }
                 }
             }
             System.out.println(ans);
         }
     }

     public static void cinDataForDfs() {
         while(cin.hasNext()) {
             int m = cin.nextInt();
             int n = cin.nextInt();
             if(m ==  && n == ) {
                 break;
             }
             int ans = ;
             for(int i = ; i < m; i++) {
                 for(int j = ; j < n; j++) {
                     if(map[i][j] == '@') {
                         ans++;
                         dfs(i,j,m,n);
                     }
                 }
             }
             System.out.println(ans);
         }
     }

     public static void dfs(int x, int y, int m, int n) {
         for(int i = ; i < ; i ++) {
             int xx = x + dir[i][];
             int yy = y + dir[i][];
             if(xx >=  && xx < n && yy >=  && yy < m && map[xx][yy] == '@'){
                 map[xx][yy] = '*';
                 dfs(xx,yy,m,n);
             }
         }
     }

     public static void bfs(int x, int y,int m, int n) {
         vis = new int[][];
         for(int i = ; i < ; i ++) {
             for(int j = ; j < ; j++) {
                 vis[i][j] = ;
             }
         }
         que = new ArrayDeque<Node>();
         que.clear();
         pos = new Node();
         q = new Node();
         pos.x = x;
         pos.y = y;
         vis[x][y] = ;
         que.add(pos);
         while(!que.isEmpty()) {
             pos = que.poll();
             map[pos.x][pos.y] = '*';
             for(int i = ; i < ; i++) {
                 int next_x = pos.x + dir[i][];
                 int next_y = pos.y + dir[i][];
                 if(next_x >= && next_x < m && next_y >=  && next_y < n && vis[next_x][next_y] == ) {
                     q.x = next_x;
                     q.y = next_y;
                     vis[next_x][next_y] = ;
                     map[next_x][next_y] = '*';
                     que.add(q);
                 }
             }
         }

     }

 }
 class Node{
     public int x, y;
 }