Find the number of "blocks" in the matrix (BFS)

Title Description

Give a mxn Matrix , The elements in the matrix are 0 or 1. Weigh the position （x,y) Instead of four positions up, down, left and right (x,y+1)、(x,y-1)、（x+1,y)、(x-1,y) It's adjacent . If there are several in the matrix 1 It's adjacent （ It doesn't have to be adjacent ）, So call these 1 Make up a “ block ”. Find the matrix in a given matrix “ block ” The number of .

【 sample input 】

6 7
0 1 1 1 0 0 1
0 0 1 0 0 0 0
0 0 0 0 1 0 0
0 0 0 1 1 1 0
1 1 1 0 1 0 0
1 1 1 1 0 0 0

【 sample output 】

4

Their thinking

Use breadth first search to traverse a “ block ”, And mark it as 1, After marking, it will not be traversed again , How many times do you traverse , Just a few “ block ”.

Code implementation

import java.util.*;

public class Main {
    
    // The incremental 
    static int n;
    static int m;
    static int[] X={
    0,0,-1,1};// On   Next   Left   Right 
    static int[] Y={
    -1,1,0,0};// On   Next   Left   Right 
    static int[][] matrix;// matrix 
    static boolean[][] visted;// Used to mark whether a point is accessed 
    public static void main(String[] args) {
    
        Scanner scan=new Scanner(System.in);
        n=scan.nextInt();//n That's ok 
        m= scan.nextInt();//m Column 
        visted=new boolean[n][m];
        matrix=new int[n][m];
        // Input matrix 
        for (int i = 0; i < n; i++) {
    
            for (int j = 0; j < m; j++) {
    
                matrix[i][j]= scan.nextInt();
            }
        }
        // Search each point in the matrix in turn （ Of course, the condition is that it has not been searched before , And this bit is 0）
        int count=0;
        for (int x = 0; x < n; x++) {
    
            for (int y = 0; y < m; y++) {
    
                if(!visted[x][y]&&matrix[x][y]==1){
    
                    bfs(x,y);  // In this question bfs The result is , The next one to meet “1 block ” Marked as accessed 
                    count++;
                }
            }
        }
        System.out.println(count);
        scan.close();
    }
    public static void bfs(int x,int y){
    
        node start=new node(x,y);
        visted[x][y]=true;
        Deque<node> que=new LinkedList<>();
        que.offer(start);
        while(!que.isEmpty()){
    
              node now=que.poll();
              for(int i=0;i<4;i++){
    
                  int newx=now.x+X[i];
                  int newy=now.y+Y[i];
                  if(check(newx,newy)){
    
                      visted[newx][newy]=true;
                      node next=new node(newx,newy);
                      que.offer(next);
                  }
              }
        }
    }
    public static boolean check(int x,int y){
    
        // An array 
        if(x<0||x>=n||y<0||y>=m){
    
            return false;
        }
        // Has been interviewed 
        if(visted[x][y]||matrix[x][y]==0){
    
            return false;
        }
        return true;
    }
}
class node{
    
    int x;
    int y;
    node(){
    }
    node(int x,int y){
    
        this.x=x;
        this.y=y;
    }
}