Crossword Answers UVA - 232

   A crossword puzzle consists of a rectangular grid of black and white squares and two lists of definitions (or descriptions).

  One list of definitions is for “words” to be written left to right across white squares in the rows and the other list is for words to be written down white squares in the columns. (A word is a sequence of alphabetic characters.)

  To solve a crossword puzzle, one writes the words corresponding to the definitions on the white squares of the grid.

  The definitions correspond to the rectangular grid by means of sequential integers on “eligible” white squares. White squares with black squares immediately to the left or above them are “eligible.” White squares with no squares either immediately to the left or above are also “eligible.” No other squares are numbered. All of the squares on the first row are numbered.

  The numbering starts with 1 and continues consecutively across white squares of the first row, then across the eligible white squares of the second row, then across the eligible white squares of the third row and so on across all of the rest of the rows of the puzzle. The picture below illustrates a rectangular crossword puzzle grid with appropriate numbering.

  An “across” word for a definition is written on a sequence of white squares in a row starting on a numbered square that does not follow another white square in the same row.

  The sequence of white squares for that word goes across the row of the numbered square, ending immediately before the next black square in the row or in the rightmost square of the row.

  A “down” word for a definition is written on a sequence of white squares in a column starting on a numbered square that does not follow another white square in the same column.

  The sequence of white squares for that word goes down the column of the numbered square, ending immediately before the next black square in the column or in the bottom square of the column.

  Every white square in a correctly solved puzzle contains a letter.

  You must write a program that takes several solved crossword puzzles as input and outputs the lists of across and down words which constitute the solutions.

Input

  Each puzzle solution in the input starts with a line containing two integers r and c (1 ≤ r ≤ 10 and 1 ≤ c ≤ 10), where r (the first number) is the number of rows in the puzzle and c (the second number) is the number of columns.

  The r rows of input which follow each contain c characters (excluding the end-of-line) which describe the solution. Each of those c characters is an alphabetic character which is part of a word or the character ‘*’, which indicates a black square.

  The end of input is indicated by a line consisting of the single number ‘0’.

Output

  Output for each puzzle consists of an identifier for the puzzle (puzzle #1:, puzzle #2:, etc.) and the list of across words followed by the list of down words. Words in each list must be output one-per-line in increasing order of the number of their corresponding definitions.

  The heading for the list of across words is ‘Across’. The heading for the list of down words is ‘Down’.

  In the case where the lists are empty (all squares in the grid are black), the ‘Across’ and ‘Down’ headings should still appear.

  Separate output for successive input puzzles by a blank line.

Sample Input

2 2
AT
*O
6 7
AIM*DEN
*ME*ONE
UPON*TO
SO*ERIN
*SA*OR*
IES*DEA
0

Sample Output

puzzle #1:
Across
1.AT
3.O
Down
1.A
2.TO
puzzle #2:
Across
1.AIM
4.DEN
7.ME
8.ONE
9.UPON
11.TO
12.SO
13.ERIN
15.SA
17.OR
18.IES
19.DEA
Down
1.A
2.IMPOSE
3.MEO
4.DO
5.ENTIRE
6.NEON
9.US
10.NE
14.ROD
16.AS
18.I
20.A

HINT

   这道题看起来很长好像很是麻烦，但真正写起来并不算麻烦。题目的大意是让我们按照两个规则输出结果，一个是横着输出，另一个是竖着输出，但无论是横着还是竖着输出，输出的其实位置是按照编号从小到大的顺序排列的，而编号的排列时按照行优先从左往右排列。输出的时候每一组数据和另一组数据之间有一个空行，最后一组数据之后没有空行。其中“Across”的输出时横着输出知道这一行的最后一个元素位置或者遇到‘*’截止，然后按照编号从小到大找到最近的未被输出的字符开始再次输出。而“Down”的输出时按照列方向来输出，同样输出到列的最后一个元素或者遇到 ‘ *’为止。然后按照编号从小到大的顺序找到最近的未被访问过的字符开始输出。

这里字符数组我采用的两个相同的，因为第一开始写的时候思路错误造成，实际写一个就可以，有访问数组就可以了。

Accepted

#include<stdio.h>
#include<stdlib.h>
#include<string.h>



int main()
{
	char arr1[15][15];
	char arr2[15][15];
	int r, c;
	int sum = 0,flag=0;
	while (1)
	{
		
		int visit1[15][15] = { 0 };				//访问标记数组
		scanf("%d", &r);
		if (r == 0)break;
		else
		{
			scanf("%d", &c);
			getchar();
			for (int h = 0;h < r;h++)
			{
				for (int k = 0;k < c;k++)
				{
					scanf("%c", &arr1[h][k]);
					arr2[h][k] = arr1[h][k];		//两个数组分别对应Across和Down。
				}
				arr2[h][c] = arr1[h][c] = '\0';
				getchar();
			}
			if (flag == 0)flag++;
			else printf("\n");
			printf("puzzle #%d:\n", ++sum);
			printf("Across\n");
			int sums = 0;
			for (int h = 0;h < r;h++)				//对每一个字符进行判断
				for (int k = 0;k < c;k++)
				{
					
					if (arr1[h][k] != '*')			// ‘*’不可以输出
					{
						if (!h || !k || arr1[h - 1][k] == '*' || arr1[h][k - 1] == '*')	//符合编号规则的才可以输出
						{
							sums++;
							if (!visit1[h][k])
							{
								printf("%3d.", sums);				//输出第一个字符的编号，输出格式为“%3d"
								for (int j = k;j < c && arr1[h][j] != '*';j++)
								{
									putchar(arr1[h][j]);
									visit1[h][j] = 1;				//标记已经访问
								}
								printf("\n");
							}
						}
						
							
					}
				}
			printf("Down\n");
			int visit2[15][15] = { 0 };
			sums = 0;
			for (int h = 0;h < r;h++)
				for (int k = 0;k < c;k++)
				{
					if (arr2[h][k] != '*')
					{
						if (!h || !k || arr1[h - 1][k] == '*' || arr1[h][k - 1] == '*')
						{
							sums++;
							if (!visit2[h][k])
							{
								printf("%3d.", sums);
								for (int j = h;j < r && arr1[j][k] != '*';j++)
								{
									putchar(arr1[j][k]);
									visit2[j][k] = 1;
								}
								printf("\n");
							}
						}

					}
				}
		}
	}

}