hiho232周 拆字游戏

时间限制:10000ms

单点时限:1000ms

内存限制:256MB

描述

小Kui喜欢把别人的名字拆开来，比如“螺”就可以拆成“虫田糸”，小Kui的语文学的不是很好，于是她决定使用编程的方式来解决这个问题。

给出一个01矩阵，1占据的部分即为需要拆的字，如果两个1分享一条边，那么它们连通。连通具有传递性，即如果a、b连通，b、c连通，则a、c连通。

连通的一系列1被看做可以拆出的一块，现在小Kui需要输出这些拆出的块（用一个01矩阵表示，并且要求矩阵的大小尽可能的小）。

为了确保输出的顺序尽可能的和书写的顺序一致，小Kui从每个块中选出最左上角的点（最左侧的点中，最靠上的）作为代表点，然后按照代表点从左到右（若相同则按从上到下）的顺序输出所有拆出的块。

输入

输入的第一行为两个正整数N、M，表示01矩阵的大小。

接下来N行，每行M个01字符，描述一个需要拆的字。

对于40%的数据，满足1<=N,M<=10。

对于100%的数据，满足1<=N,M<=500。

输出

按照代表点从左到右（若相同则按从上到下）的顺序输出所有拆出的块。

对于每个块，先输出其大小，然后用对应的01矩阵表示这个块。

额外的样例

样例输入	样例输出
11 17 00000000000000000 00001111111100000 00000000000000000 00111111111111100 00000000100000000 00000010101110000 00000110100011000 00011100100001000 00000010100000000 00000001100000000 00000000000000000	7 13 1111111111111 0000001000000 0000001000000 0000001000000 0000001000000 0000001000000 0000011000000 3 4 0001 0011 1110 1 8 11111111 1 1 1 3 4 1110 0011 0001

样例输入

14 22
0000000000001111111100
0000000000001101101100
0000110000001111111100
0000110000001101101100
0111111110001111111100
0110110110000000000000
0110110110000011000000
0111111110001111111000
0000110000000001100000
0000110110001111111100
0111111111000111111000
0000000010001101101100
0000000000000001100000
0000000000000011100000

样例输出

10 9
000110000
000110000
111111110
110110110
110110110
111111110
000110000
000110110
111111111
000000010
5 8
11111111
11011011
11111111
11011011
11111111
8 8
00110000
11111110
00011000
11111111
01111110
11011011
00011000
00111000

1. import java.util.*;
2. public class Main {
3.     int[][] board;
4.     int row;
5.     int col;
6.     int upmost = row;
7.     int downmost = -1;
8.     int leftmost = col;
9.     int rightmost = -1;
10.     int flag = 2;
11.     public Main() {
12.     }
13.     public void init() {
14.         upmost = row;
15.         downmost = -1;
16.         leftmost = col;
17.         rightmost = -1;
18.     }
19.     public boolean visited(int i, int j) {
20.         if (board[i][j] == 0 || board[i][j] == 1) return false;
21.         return true;
22.     }
23.     public void solution() {
24.         Scanner sc = new Scanner(System.in);
25.         row = sc.nextInt();
26.         col = sc.nextInt();
27.         board = new int[row][col];
28.         for (int i = 0; i < row; i++) {
29.             String str = sc.next();
30.             for (int j = 0; j < col; j++) {
31.                 board[i][j] = str.charAt(j)-'0';
32.             }
33.         }
34.         for (int j = 0; j < col; j++) {
35.             for (int i = 0; i < row; i++) {
36.                 if (board[i][j] == 1) {
37.                     init();
38.                     dfs(i, j);
39.                     print();
40.                     flag++;
41.                 }
42.             }
43.         }
44.     }
45.     public boolean isValid(int i, int j) {
46.         if (i < 0 || i >= row || j < 0 || j >= col ) return false;
47.         return true;
48.     }
49.     public void dfs(int i, int j) {
50.         //System.out.println(i+" "+j);
51.         if (i < upmost) upmost = i;
52.         if (i > downmost) downmost = i;
53.         if (j < leftmost) leftmost = j;
54.         if (j > rightmost) rightmost = j;
55.         board[i][j] = flag;
56.         if (isValid(i-1,j) && board[i-1][j] == 1) dfs(i-1, j);
57.         if (isValid(i+1,j) && board[i+1][j] == 1) dfs(i+1, j);
58.         if (isValid(i,j-1) && board[i][j-1] == 1) dfs(i, j-1);
59.         if (isValid(i,j+1) && board[i][j+1] == 1) dfs(i, j+1);
60.     }
61.     public void print() {
62.         System.out.println((downmost-upmost+1)+" "+(rightmost-leftmost+1));
63.         for (int i = upmost; i <= downmost; i++) {
64.             for (int j = leftmost; j <= rightmost; j++) {
65.                 if (board[i][j] == flag)
66.                     System.out.print("1");
67.                 else
68.                     System.out.print("0");
69.             }
70.             System.out.println();
71.         }
72.     }
73.     public static void main(String[] args) {
74.         Main main = new Main();
75.         main.solution();
76.       
77.         //System.out.println(t);
78.     }
79. }