codeforces C. Mooyo Mooyo(dfs)

C. Mooyo Mooyo

time limit per test:1 second
memory limit per test:256 megabytes
input:standard input
output:standard output

With plenty of free time on their hands (or rather, hooves), the cows on Farmer John’s farm often pass the time by playing video games. One of their favorites is based on a popular human video game called Puyo Puyo; the cow version is of course called Mooyo Mooyo. The game of Mooyo Mooyo is played on a tall narrow grid N cells tall (1≤N≤100) and 10 cells wide. Here is an example with N=6:

0000000000
0000000300
0054000300
1054502230
2211122220
1111111223

Each cell is either empty (indicated by a 0), or a haybale in one of nine different colors (indicated by characters 1…9). Gravity causes haybales to fall downward, so there is never a 0 cell below a haybale.

Two cells belong to the same connected region if they are directly adjacent either horizontally or vertically, and they have the same nonzero color. Any time a connected region exists with at least K cells, its haybales all disappear, turning into zeros. If multiple such connected regions exist at the same time, they all disappear simultaneously. Afterwards, gravity might cause haybales to fall downward to fill some of the resulting cells that became zeros. In the resulting configuration, there may again be connected regions of size at least K cells. If so, they also disappear (simultaneously, if there are multiple such regions), then gravity pulls the remaining cells downward, and the process repeats until no connected regions of size at least K exist.

Given the state of a Mooyo Mooyo board, please output a final picture of the board after these operations have occurred.

Input

The first line of input contains N and K(1≤K≤10N). The remaining N lines specify the initial state of the board.

Output

Please output N lines, describing a picture of the final board state.

Example

input

6 3
0000000000
0000000300
0054000300
1054502230
2211122220
1111111223

output

0000000000
0000000000
0000000000
0000000000
1054000000
2254500000

Note

In the example above, if K=3, then there is a connected region of size at least K with color 1 and also one with color 2. Once these are simultaneously removed, the board temporarily looks like this:

0000000000
0000000300
0054000300
1054500030
2200000000
0000000003
Then, gravity takes effect and the haybales drop to this configuration:

0000000000
0000000000
0000000000
0000000000
1054000300
2254500333
Again, there is a region of size at least K (with color 3). Removing it yields the final board configuration:

0000000000
0000000000
0000000000
0000000000
1054000000
2254500000

分析

消消乐；
只能消去连通数量大于k的四向连通块，全图消一遍后，悬空的数块会下落，并持续消去到没办法消去为止；输出这个最终的图；
因为宽度只有10，而且n还小于等于100；
只需要扫一下连通块数是不是比k要小，如果不是就消去；每次扫的时候记录一下避免重复就行了。

代码

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
#define MS(X) memset(X,0,sizeof(X))
#define MSC(X) memset(X,-1,sizeof(X))
typedef long long LL;
using namespace std;
char cut[11];
int nx[4]={1,0,-1,0};
int ny[4]={0,1,0,-1};
int st[101][11],save[101][11],drop[105],n,k,cnt;
void cunt(int x,int y,int ck){
    if(save[x][y]==-1){
        save[x][y]=0;
        cnt++;
    }
    else return;
    for(int i=0;i<4;i++){
        int mx=x+nx[i];int my=y+ny[i];
        if(0<=mx&&mx<n&&0<=my&&my<10&&st[mx][my]==ck) cunt(mx,my,ck);
    }
}
void kill(int x,int y,int ck){
    st[x][y]=0;
    for(int i=0;i<4;i++){
        int mx=x+nx[i];int my=y+ny[i];
        if(0<=mx&&mx<n&&0<=my&&my<10&&st[mx][my]==ck) kill(mx,my,ck);
    }
}
void fall(){
    int have=0;
    for(int j=0;j<10;j++){
        for(int i=n-1;i>=0;i--){
            if(st[i][j]!=0){
                drop[have++]=st[i][j];
                st[i][j]=0;
            }
        }
        int hs=have;
        for(int i=n-1;have!=0;i--){
            st[i][j]=drop[hs-have];
            have--;
        }
    }
}
int main(){
    scanf("%d%d",&n,&k);
    MS(st);
    for(int i=0;i<n;i++){
        scanf("%s",cut);
        for(int j=0;j<10;j++){
            st[i][j]=cut[j]-'0';
        }

    }
    int fg=1;
    while(fg){
        MSC(save);fg=0;
        for(int i=n-1;i>=0;i--)
            for(int j=0;j<10;j++)
                if(st[i][j]!=0){
                    cnt=0;
                    cunt(i,j,st[i][j]);
                    if(cnt>=k){
                        kill(i,j,st[i][j]);
                        fg=1;
                    }
                }
        fall();
    }

     for(int i=0;i<n;i++){
        for(int j=0;j<10;j++)
            printf("%d",st[i][j]);
        puts("");
    }
    return 0;
}