第4届华为编程大赛决赛试题解答（棋盘覆盖）

转自：http://blog.csdn.net/zhoujiaxq/article/details/7917071

在http://blog.thpiano.com/?p=579看到有人贴出第四届华为编程大赛决赛试题答案，研究了一下，发现有错误，下面将修改正确的代码贴出。

题目是这样的：

=======================================================================

编程题（共1题，100分。请上机编写程序，按题目要求提交文件。测试用例不对考生公开，凡不满足提交要求导致不能运行或用例不通过，不予评分。）

1. 俄罗斯方块之棋盘覆盖

俄罗斯方块是一款风靡全球的益智类游戏。由俄罗斯人阿列克谢·帕基特诺夫发明，故得此名。俄罗斯方块的基本规则是移动、旋转和摆放游戏自动输出的各种方块，使之排列成完整的一行或多行并且消除得分。由于上手简单、老少皆宜，从而家喻户晓，风靡世界。

本试题是在俄罗斯方块几种常见的方块基础上，在指定大小和障碍的棋盘上，用标准的方块形状，完成对棋盘的覆盖。用于覆盖棋盘的方块可以是下文所给出方块的全集，也可以是其中的任意一个子集，且使用的方块数量不限，形状变化不限。

棋盘大小：

棋盘大小为21行21列的正方形。按照从上到下，从左到右，从1开始，依次进行编号，直到最右下方的格子标识为441。

可选方块：

可选方块为标准的俄罗斯方块形状，包括其标准的旋转变化。基本形状如图所示：

各形状的变化如图所示（字母为方块编号）：

障碍说明：

棋盘上仅有一处障碍无法放置方块，障碍可处于棋盘任意位置。障碍为基本形状a及其所有的旋转变化，如图所示：

输入输出要求：

输入文件名为testin.txt，格式如下所示，各数字用空格隔开，各数字表示棋盘格子编号。

2 3 22 23

该输入表示障碍位于棋盘的左上角。

输出文件名为testout.txt，要求先输出棋盘覆盖结果，再输出未覆盖的格子个数。输出棋盘用21行21列数字/字母表示，其中0表示未覆盖的格子，1表示障碍，字母表示对应方块编号（字母对应关系见“可选方块”一节）。最后输出未覆盖格子个数。这里以6行10列棋盘举例示意输出格式（注意：实际输出应该是21行21列，对应方块形状用对应的字母表示）：

要求：

1、用所提供的方块尽可能覆盖棋盘并输出结果；

2、在（1）的基础上，棋盘上的空格越少越好。

交付件要求：

C/C++：需要提交可执行文件和压缩打包的源代码工程

JAVA：需要提交压缩打包的整个编码工程目录

构造法说起来也很简单，首先利用对称性和可旋转性，将输入缩减为一种（这里都缩减为），之后对输入的位置进行考虑：
若位于左上角，则可以通过如下的方式填充：

剩余的空格就是左上的第一个格子，剩下的21x16区域用长条可以完美填充
（右下角也是完全一样）
若不位于左上角或右下角，则可通过加入两个L，变成或的4x3的障碍。将障碍体积变为4x3后，再用长条填充，可以保证填充至只剩1个格子。
被别人一点拨，感觉真的是醍醐灌顶，如此简易的分析方法自己便就是做不到口牙……！
照着这个思路，自己也大致写了下代码：

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

#define TABLE_SIZE 21

// store the input
int input [ 4 ] = { 0 } ;

// store the hole answer
char table [TABLE_SIZE * TABLE_SIZE ] ;

bool isVertical = false ;

void Initialize ( ) ;
void Output ( FILE * f ) ;
void Construct ( ) ;

int main ( ) {
   FILE * fw = fopen ( "testout.txt", "w" ) ;
   FILE * fp = fopen ( "testin.txt", "r" ) ;
   if ( !fp ) {
   printf ( "file not found!\n" ) ;
   return 0 ;
   }
   // main loop
   while ( ! feof (fp ) ) {
   fscanf (fp, "%d %d %d %d", &input [ 0 ], &input [ 1 ], &input [ 2 ], &input [ 3 ] ) ;
Initialize ( ) ;
Construct ( ) ;
Output (fw ) ;
   }
   fclose (fp ) ;
   fclose (fw ) ;
   return 0 ;
}

void Initialize ( ) {
   int i, j, x, y ;
   memset (table, 'f', sizeof (table ) ) ;
   for (i = 0 ; i < 4 ; ++i ) {
   if (input [i ] < 1 || input [i ] > TABLE_SIZE * TABLE_SIZE ) {
   printf ( "input number error!\n" ) ;
   exit ( 0 ) ;
   }
   --input [i ] ; // input pos start from 1... but I start from 0
   }

//sort input
   for (i = 1 ; i < 4 ; ++i ) {
   if (input [i ] < input [i - 1 ] ) {
   int temp = input [i ] ;
   for (j = i - 1 ; j >= 0 && input [j ] > temp ; --j ) {
input [j + 1 ] = input [j ] ;
   }
input [j + 1 ] = temp ;
   }
   }

//rotate input to 3x2 if it is 2x3
   if (input [ 1 ] - input [ 0 ] ! = 1 ) {
isVertical = true ;
   for (i = 0 ; i < 4 ; ++i ) {
x = input [i ] % TABLE_SIZE ;
y = input [i ] / TABLE_SIZE ;
input [i ] = x * TABLE_SIZE + TABLE_SIZE - 1 - y ;
   }
input [ 0 ] ^ = input [ 1 ] ;
input [ 1 ] ^ = input [ 0 ] ;
input [ 0 ] ^ = input [ 1 ] ;
   }

}

void Construct ( ) {
   int i, j, x, y ;
x = input [ 0 ] % TABLE_SIZE ;
y = input [ 0 ] / TABLE_SIZE ;
   if (input [ 0 ] == 1 || input [ 0 ] == TABLE_SIZE * TABLE_SIZE - 2 - TABLE_SIZE ) { // in the corner (left-top or right-bottom)
   if (input [ 0 ] == 1 ) {
table [ 0 ] = '0' ;
   } else {
table [TABLE_SIZE * TABLE_SIZE - 1 ] = '0' ;
   }
   for (i = 1 ; i < TABLE_SIZE ; ++i ) {
table [i + y * TABLE_SIZE ] = 'a' ;
table [i - 1 + (y + 1 ) * TABLE_SIZE ] = 'a' ;
   }
   } else {
   //fill it with L in a 4x3 tiny block (3x4 is also useful)
   if (y ! = TABLE_SIZE - 2 && x ! = 1 ) {
   for (i = x - 2 ; i < x + 2 ; ++i ) {
   for (j = y ; j < y + 3 ; ++j ) {
table [i + j * TABLE_SIZE ] = 'c' ;
   }
   }
   } else {
   for (i = x - 1 ; i < x + 3 ; ++i ) {
   for (j = y - 1 ; j < y + 2 ; ++j ) {
table [i + j * TABLE_SIZE ] = 'c' ;
   }
   }
   }
   //leave a hole anywhere
   if (table [ 0 ] == 'f' ) {
table [ 0 ] = '0' ;
   } else {
table [TABLE_SIZE - 1 ] = '0' ;
   }
   }
   // fill the barrier
   for (i = 0 ; i < 4 ; ++i ) {
table [input [i ] ] = '1' ;
   }
}

void Output ( FILE * fp ) {
   int i, j ;
   for (i = 0 ; i < TABLE_SIZE ; ++i ) {
   for (j = 0 ; j < TABLE_SIZE ; ++j ) {
   if (isVertical ) {
   fprintf (fp, "%c ", table [TABLE_SIZE - 1 - i + j * TABLE_SIZE ] ) ;
   } else {
   fprintf (fp, "%c ", table [i * TABLE_SIZE + j ] ) ;
   }
   }
   fprintf (fp, "\n" ) ;
   }
   fprintf (fp, "1\n" ) ;
}

以上是网友给出的代码，有些小错误，把c和g全部当成c使用了。修改后的如下：

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

#define TABLE_SIZE 21
char table[TABLE_SIZE*TABLE_SIZE];
int input[4] = {0};
bool isVertical = false;

int Initialize()
{
int i,j;
unsigned int Xaxis,Yaxis;
char chTmp = 0;
//首先全部初始化为'f'
memset(table, 'f', sizeof(table));
//检查输入合法性，并将输入都减1，起始为0
for (i = 0; i < 4; ++i){
  if (input[i] < 1 || input[i] > TABLE_SIZE * TABLE_SIZE){
   printf("input number error!\n");
   return -1;
  }
  --input[i];
}
//升序排列
for (i = 0;i < 3;i++){
  for (j = i+1;j < 4;j++){
   if (input[i] > input[j]){
    chTmp = input[i];
    input[i] = input[j];
    input[j] = chTmp;
   }
  }
}
//若障碍是2x3，则旋转成3x2
if (input[1] - input[0] == TABLE_SIZE){
  isVertical = true;
  for (i = 0;i < 4;i++){
   Xaxis = input[i] % TABLE_SIZE;
   Yaxis = input[i] / TABLE_SIZE;
   input[i] = Xaxis * TABLE_SIZE + TABLE_SIZE - Yaxis - 1;
  }
  input[0] ^= input[1];//交换input[0]和input[1]的位置
  input[1] ^= input[0];
  input[0] ^= input[1];
}
return 0;
}

void Construct()
{
unsigned int Xaxis = input[0] % TABLE_SIZE;
unsigned int Yaxis = input[0] / TABLE_SIZE;
int i,j;
//首先处理位于左上角和右下角的情况
if (input[0] == 1 || input[0] == (TABLE_SIZE-1)*TABLE_SIZE-2){
  if (input[0] == 1)//标示出未覆盖的地方
   table[0] = '0';
  else
   table[TABLE_SIZE*TABLE_SIZE-1] = '0';
  for (i = 1;i < TABLE_SIZE;i++){
   table[Yaxis*TABLE_SIZE+i] = 'a';
   table[(Yaxis+1)*TABLE_SIZE+i-1] = 'a';
  }
}
//障碍物位于最上一行，左侧填充g，右侧填充c
else if (Yaxis == 0){
  table[TABLE_SIZE*TABLE_SIZE-1] = '0';
  table[input[0]-1] = 'g';
  table[input[0]-2] = 'g';
  table[input[0]+TABLE_SIZE-2] = 'g';
  table[input[0]+TABLE_SIZE*2-2] = 'g';

table[input[0]+TABLE_SIZE+1] = 'c';
  table[input[0]+TABLE_SIZE*2-1] = 'c';
  table[input[0]+TABLE_SIZE*2] = 'c';
  table[input[0]+TABLE_SIZE*2+1] = 'c';
}
//障碍物位于最下一行，左侧填充g，右侧填充c
else if (Yaxis == TABLE_SIZE-2){
  table[0] = '0';
  table[input[0]-TABLE_SIZE+2] = 'g';
  table[input[0]+2] = 'g';
  table[input[0]+TABLE_SIZE+1] = 'g';
  table[input[0]+TABLE_SIZE+2] = 'g';

table[input[0]-1] = 'c';
  table[input[0]-TABLE_SIZE] = 'c';
  table[input[0]-TABLE_SIZE-1] = 'c';
  table[input[0]-TABLE_SIZE+1] = 'c';
}
//障碍物位于中间，周围填充c
else{
  table[TABLE_SIZE*TABLE_SIZE-1] = '0';
  for (i = 0;i < 3;i++){
   for (j = 0;j < 4;j++){
    table[(Yaxis+i-1)*TABLE_SIZE+Xaxis+j-1] = 'c';
   }
  }
}
//标示出障碍物的位置
for (i = 0;i < 4;i++){
  table[input[i]] = '1';
}
}

void Output(FILE* fp)
{
int i,j;

for (i = 0; i < TABLE_SIZE; ++i){
  for (j = 0; j < TABLE_SIZE; ++j){
   if (isVertical){
    fprintf(fp, "%c ", table[TABLE_SIZE - 1 - i + j * TABLE_SIZE]);
   }else{
    fprintf(fp, "%c ", table[i * TABLE_SIZE + j]);
   }
  }
  fprintf(fp, "\n");
}
fprintf(fp, "1\n");
}

int main()
{
FILE *fI,*fO;

fI = fopen("testin.txt","r");
if (!fI)
{
  printf("testin.txt does not exist!\n");
  return -1;
}
fO = fopen("testout.txt","w");
fscanf(fI,"%d %d %d %d", &input[0], &input[1], &input[2], &input[3]);
if (Initialize())
{
  printf("Initialize failed!\n");
  return -1;
}
Construct();
Output(fO);

fclose(fO);
fclose(fI);
return 0;
}