【UVA】232 Crossword Answers

题目链接：https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=168

目录

题目：

Input

Output

Sample Input

Sample Output

分析：

代码：

最初：

最终：

---

 

题目：

题目文字如下，本题还有一示例图，图见题目链接。 

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 

分析：

题目大体意思是说，在c x r的网格中，有白格或黑格。每个白格中填字母。其中一个格的左或上边 没有格或有黑格，则这样的格为起始格。此外，一个词为从一个起始格 到一个黑格之前的词 或 到网格行列末尾处（across为一行内的词，down为一列内的词）。输入中，黑格用*表示。输入r、c（行、列），当r=0时结束输入测试样例。输出Across和down的词。

另外注意输出要求，输出每组数据结果间，包含一个空行。还有，输出down时，并非按照一列列的顺序，而是按照一行行格为起始格的方式排列。

我采用的方式直接设grid[10][10]存网格。因为输出的序号是按照起始格顺序来的，可以用数组a[i][j]先存放序号。先存储起始格的序号数字（后来发现别人用20x20的数组，初始全都赋值为 " * "，然后输入时从数组每行第1个元素开始，这样判断起始格等，都直接判断是否为 * 即可，方便简单很多。）因为处理across和down的方式我前后有些变化差异，所以具体放到 代码部分（代码：） 分析。

代码：

最初我想到的处理across的方式是，使用word变量表示当前是否在进行读取词输出。因水平读取，可以使用循环，按序一个个读取词，可能情况如下：

1.状态为未读到词时（0），遇到字母，输出第几个，并输出当前位
2.状态为正在读词（1），遇到字母输出
3.当遇到‘*’或为一行中最后一个字母格则，输出最后一个不为*的，再输出\n，将状态改为0

但到处理down时，就变得不那么方便。想来想去没什么好办法，于是，又去了解了一下别人的代码思路。从而借鉴了一下思路（思路来源网络），从而写出了down。最终代码又将处理across的方式也改为处理down的方式。

最初：

#include <stdio.h>
#include <string.h>
int main()
{
	char grid[10][10];
	int a[10][10];
	int r,c;
	int i,j,kase=0,num,word,k;
	while (scanf("%d",&r)&&r)
	{
		scanf("%d",&c);
		kase++;
		num=0;
		memset(a,0,sizeof(a));
		getchar();//获取\n
		for (i=0; i<r; i++)//输入网格内容，并对起始格标序号
		{
			for (j=0; j<c; j++)
			{
				grid[i][j]=getchar();
				if (grid[i][j]!='*' && (i==0||j==0))a[i][j]=(++num);
				else if (grid[i][j]!='*' && (grid[i-1][j]=='*'||grid[i][j-1]=='*'))
					a[i][j]=(++num);
			}
			getchar();
		}
		word=0;//是否在读单词
		if (kase-1)printf("\n");
		printf("puzzle #%d:\n",kase);
		printf("Across\n");
		for (i=0;i<r;i++)
		{
			for (j=0; j<c;j++)
			{
				if (!word && grid[i][j]!='*')//当前未读词且遇到词
				{ 
					word=1; 
					printf("%3d.",a[i][j]); 
					printf("%c",grid[i][j]);
					if (j == c-1) { word=0;printf("\n");}
				}
				else if (word && grid[i][j]=='*'){word=0; printf("\n");}
				else if (word && grid[i][j] != '*')
				{
					printf("%c",grid[i][j]);
					if (j == c-1) { word=0;printf("\n");}
				}
			}
		}
		printf("Down\n");
		word=0;
		for (i=0; i<r; i++)
		{
			for (j=0; j<c; j++)
			{
				if ((i==0||grid[i-1][j]=='*') && grid[i][j]!='*')//起始格
				{
					word=1;
					if (a[i][j])printf("%3d.",a[i][j]);
					for (k=0; k<r-i && grid[i+k][j]!='*'; k++)
					{
						printf("%c",grid[i+k][j]);
					}
					if (k==r-i || grid[i+k][j]=='*')printf("\n");
				}
			}
		}
	}
	return 0;
}

最终：

思路：判断起始格为满足一行（across的起始格）的还是一列的（down的起始格）。

因起始格是按行顺序，所以先按行找满足across或down的起始格，再设k作为单词长度，用k控制循环，使得能够找到横排或竖排的词。 

#include <stdio.h>
#include <string.h>
int main()
{
	char grid[10][10];
	int a[10][10];
	int r,c;
	int i,j,kase=0,num,k;
	while (scanf("%d",&r)&&r)
	{
		scanf("%d",&c);
		kase++;
		num=0;
		memset(a,0,sizeof(a));
		getchar();//获取\n
		for (i=0; i<r; i++)//输入网格内容，并对起始格标序号
		{
			for (j=0; j<c; j++)
			{
				grid[i][j]=getchar();
				if (grid[i][j]!='*' && (i==0||j==0))a[i][j]=(++num);
				else if (grid[i][j]!='*' && (grid[i-1][j]=='*'||grid[i][j-1]=='*'))
					a[i][j]=(++num);
			}
			getchar();
		}
		if (kase-1)printf("\n");
		printf("puzzle #%d:\n",kase);
		printf("Across\n");
		for (i=0;i<r;i++)
		{
			for (j=0; j<c;j++)
			{
				if (a[i][j] && (j==0||grid[i][j-1]=='*'))//Across起始格
				{
					printf("%3d.",a[i][j]);
					for (k=0; k<c-j && grid[i][j+k]!='*'; k++)
					{
						printf("%c",grid[i][j+k]);
					}
					if (k==c-j || grid[i][j+k]=='*')printf("\n");
				}
			}
		}
		printf("Down\n");
		for (i=0; i<r; i++)
		{
			for (j=0; j<c; j++)
			{
				if (a[i][j] && (i==0||grid[i-1][j]=='*'))//Down起始格
				{
					printf("%3d.",a[i][j]);
					for (k=0; k<r-i && grid[i+k][j]!='*'; k++)
					{
						printf("%c",grid[i+k][j]);
					}
					if (k==r-i || grid[i+k][j]=='*')printf("\n");
				}
			}
		}
	}
	return 0;
}