2019 GDUT Rating Contest I : Problem C. Mooyo Mooyo

题面：

C. Mooyo Mooyo

Input file: standard input

Output file: standard output

Time limit: 1 second

Memory limit: 256 megabytes

 

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，那么它们就消除掉（变为数字0），直到不能消掉为止。消掉后要遵守“重力下落”的规则：如果一个非零的数字下方为0，那么它就会“掉下去”，直到下方数字不为0；

 

题目分析：

这道题就是用dfs解决图的连通块问题，怎样解决连通的数字超过K个时就消掉？我们可以分别写两个dfs，一个dfs是检测连通的数字是否大于等于K，另一个dfs就是清空操作。在写第一个dfs时，用一个vis数组来检查是否被访问过就可以避免重复计算连通的数字。另一个dfs要注意清空时还能保留要清空的数字，我是通过传入要清空的数字来实现的，这个做法因人而异。最后一个“重力下落”的函数最好从下到上“重力下落”，这样能保证每一次“重力下落”都是下落到最底端。

 

 

AC代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
int n, k;
char s[105][15];
int vis[105][15];  //记录点是否被访问过
int dr[4] = {-1, 1, 0, 0}, dc[4] = {0, 0, -1, 1};  //方向：上下左右
int cnt;  //记录连通的数字

void down(){   //重力下落
    for(int i = n-1; i >= 1; i--){
        for(int j = 0; j < 10; j++){
            for(int k = i; k < n && s[k][j] == '0'; k++){
                s[k][j] = s[k-1][j];
                s[k-1][j] = '0';
            }
        }
    }
}

int check(int r, int c){  //检查函数
    if(r < 0 || r >= n || c < 0 || c >= 10) return 0;
    if(vis[r][c]) return 0;
    return 1;
}

void dfs(int r, int c){

    vis[r][c] = 1;   //每到一个点就标记一下
    cnt++;
    for(int i = 0; i < 4; i++){
        int R = r+dr[i], C = c+dc[i];
        if(check(R, C) && s[R][C] == s[r][c]){
            dfs(R, C);
        }
    }
}

void clear_num(int r, int c, int ch){  //清空操作
    s[r][c] = '0';
    for(int i = 0; i < 4; i++){
        int R = r+dr[i], C = c+dc[i];
        if( (r >= 0 && r < n && c >= 0 && c < 10) && s[R][C] == ch){
            clear_num(R, C, ch);
        }
    }

}


int main(){
    cin >> n >> k;
    for(int i = 0; i < n; i++) cin >> s[i];

    while(1){

    memset(vis, 0, sizeof(vis)); //清空vis数组

    int flag = 1;   //是否有大于等于K的连通数字的标志
    for(int i = 0; i < n; i++){
        for(int j = 0; j < 10; j++){
            if(s[i][j] != '0') {
                cnt = 0;
                dfs(i, j);
                if(cnt >= k) {
                    flag = 0;
                    clear_num(i, j, s[i][j]);
                }
            }
        }
    }

    down();

    if(flag) break;  //没有大于等于K的连通块，结束


    }

    for(int i = 0; i < n; i++){
        for(int j = 0; j < 10; j++){
            cout << s[i][j];
        }
        cout << endl;
    }

    return 0;
}