BFS和DFS (java版)

package com.algorithm.test;

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

public class DfsAndBfs {
    
    private static final int[][] dir = {
            {0,1},
            {0,-1},
            {1,-1},
            {1,0},
            {1,1},
            {-1,-1},
            {-1,0},
            {-1,1},
    };
    
    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 == 0 && n == 0) {
                break;
            }
            int ans = 0;
            for(int i = 0; i < m; i++) {
                for(int j = 0; 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 == 0 && n == 0) {
                break;
            }
            int ans = 0;
            for(int i = 0; i < m; i++) {
                for(int j = 0; 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 = 0; i < 8; i ++) {
            int xx = x + dir[i][0];
            int yy = y + dir[i][1];
            if(xx >= 0 && xx < n && yy >= 0 && 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[105][105];
        for(int i = 0; i < 105; i ++) {
            for(int j = 0; j < 105; j++) {
                vis[i][j] = 0;
            }
        }
        que = new ArrayDeque<Node>();
        que.clear();
        pos = new Node();
        q = new Node();
        pos.x = x;
        pos.y = y;
        vis[x][y] = 1;
        que.add(pos);
        while(!que.isEmpty()) {
            pos = que.poll();
            map[pos.x][pos.y] = '*';
            for(int i = 0; i < 8; i++) {
                int next_x = pos.x + dir[i][0];
                int next_y = pos.y + dir[i][1];
                if(next_x >=0 && next_x < m && next_y >= 0 && next_y < n && vis[next_x][next_y] == 0) {
                    q.x = next_x;
                    q.y = next_y;
                    vis[next_x][next_y] = 1;
                    map[next_x][next_y] = '*';
                    que.add(q);
                }
            }
        }
        
    }
    
}
class Node{
    public int x, y;
}