mooyomooyo.txt

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

public class mooyomooyo {
    public static void main(String[] args) throws IOException {
        BufferedReader f = new BufferedReader(new FileReader("mooyomooyo.in"));
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("mooyomooyo.out")),true);

        StringTokenizer st = new StringTokenizer(f.readLine());
        int numrows = Integer.parseInt(st.nextToken());
        int clusterSize = Integer.parseInt(st.nextToken());
        int[][] grid = new int[numrows][10];
        for(int i=0; i<numrows; i++){
            String lol = f.readLine();
            String[] row = lol.split("");
            for(int j=0; j<10; j++){
                grid[i][j]=Integer.parseInt(row[j]);
            }
        }
        while (clearclusters(grid,clusterSize)){
            gravity(grid);
        }
        StringBuilder answer = new StringBuilder();
        for(int[] i:grid){
            for (int j:i){
                answer.append(j);
            }
            answer.append("\n");
        }
        out.print(answer);
        out.close();

    }
    static int count =0;
    public static ArrayList<int[]> findClusters(int[][] grid, int maxsize){
        boolean[][] seen = new boolean[grid.length][grid[0].length];
        ArrayList<int[]> startpoints = new ArrayList<>();
        for(int i=0; i<seen.length; i++){
            for(int j=0; j<seen[0].length;j++ ){
                if(!seen[i][j]){
                    count=0;
                    flood(grid,false,seen,grid[i][j],i,j);
                    if(count>=maxsize){
                        startpoints.add(new int[]{i,j});
                    }
                }
            }
        }
        return startpoints;
    }
    public static void flood(int[][] arr, boolean shouldZero, boolean[][] seen, int searchPart,int startX, int startY){
        if((startX < arr.length && startX > -1)&&(startY < arr[0].length && startY > -1) && arr[startX][startY]== searchPart&&!seen[startX][startY] && searchPart!=0){
            count +=1;
            if(shouldZero) {
                arr[startX][startY] = 0;
            }
            seen[startX][startY]=true;
            flood(arr,shouldZero,seen,searchPart,startX+1,startY);
            flood(arr,shouldZero,seen,searchPart,startX-1,startY);
            flood(arr,shouldZero,seen,searchPart,startX,startY+1);
            flood(arr,shouldZero,seen,searchPart,startX,startY-1);
        }else{
            return;
        }

    }
    public static boolean clearclusters(int[][] grid, int maxsize){
        ArrayList<int[]> targets= findClusters(grid,maxsize);

        if(targets.size()==0){
            return false;
        }
        boolean[][] seen = new boolean[grid.length][grid[0].length];
        for(int[] x: targets){
            Integer count =0;
            int startx = x[0];
            int starty = x[1];
            flood(grid,true,seen,grid[startx][starty],startx,starty);
        }
        return true;


    }
    public static void gravity(int[][] grid){


        for(int i=0; i<grid[0].length; i++){
            int[] meow = new int[grid.length];

            for(int j=0; j<grid.length; j++){
                if(grid[j][i]==0){
                    meow[j]=1;
                }
            }

            for(int j = meow.length-2; j>-1; j--){
                meow[j]=meow[j]+meow[j+1];
            }
            for(int j=grid.length-1; j>-1; j--){
                if(grid[j][i]!=0){
                    if(meow[j]!=0) {
                        grid[j + meow[j]][i] = grid[j][i];
                        grid[j][i] = 0;
                    }
                }

            }

        }

    }
}