[ACM_其他] Square Ice (poj1099 规律）

Description

Square Ice is a two-dimensional arrangement of water molecules H2O, with oxygen at the vertices of a square lattice and one hydrogen atom between each pair of adjacent oxygen atoms. The hydrogen atoms must stick out on the left and right sides but are not allowed to stick out the top or bottom. One 5 x 5 example is shown below. 

Note that each hydrogen atom is attached to exactly one of its neighboring oxygen atoms and each oxygen atom is attached to two of its neighboring hydrogen atoms. (Recall that one water molecule is a unit of one O linked to two H's.)

It turns out we can encode a square ice pattern with what is known as an alternating sign matrix (ASM): horizontal molecules are encoded as 1, vertical molecules are encoded as -1 and all other molecules are encoded as 0. So, the above pattern would be encoded as: 

An ASM is a square matrix with entries 0, 1 and -1, where the sum of each row and column is 1 and the non-zero entries in each row and in each column must alternate in sign. (It turns out there is a one-to-one correspondence between ASM's and square ice patterns!)

Your job is to display the square ice pattern, in the same format as the example above, for a given ASM. Use dashes (-) for horizontal attachments and vertical bars (|) for vertical attachments. The pattern should be surrounded with a border of asterisks (*), be left justified and there should be exactly one character between neighboring hydrogen atoms (H) and oxygen atoms (O): either a space, a dash or a vertical bar.

Input

Input consists of multiple cases. Each case consists of a positive integer m (<= 11) on a line followed by m lines giving the entries of an ASM. Each line gives a row of the ASM with entries separated by a single space. The end of input is indicated by a line containing m = 0.

Output

For each case, print the case number (starting from 1), in the format shown in the Sample Output, followed by a blank line, followed by the corresponding square ice pattern in the format described above. Separate the output of different cases by a blank line.

Sample Input

2
0 1
1 0
4
0 1 0 0
1 -1 0 1
0 0 1 0
0 1 0 0
0

Sample Output

Case 1:

***********
*H-O H-O-H*
*  |      *
*  H   H  *
*      |  *
*H-O-H O-H*
***********

Case 2:

*******************
*H-O H-O-H O-H O-H*
*  |       |   |  *
*  H   H   H   H  *
*      |          *
*H-O-H O H-O H-O-H*
*      |   |      *
*  H   H   H   H  *
*  |           |  *
*H-O H-O H-O-H O-H*
*      |          *
*  H   H   H   H  *
*  |       |   |  *
*H-O H-O-H O-H O-H*
*******************

Source

East Central North America 2001

 

题目的大致意思就是给你一个矩阵，里面包含有1，-1，或者0，分别代表三种水分子的排列方式，现在要求根据矩阵来还原水分子的排列，并在周围加上一圈的“*”。仔细观察会发现其实H和O的分布是不变的，唯一不同的是氢氧建的位置，我首先把H和O的位置放好，然后分别根据横竖排列限制确定某些H(这里游离H用4表示，非游离的用5来表示），然后针对非竖非横的排列情况单独分析该氧元素周围4个氢原子的情况。（特别说明：这里用square[i][j]来标记(i,j)位置的对应符号，最后才把结果输出来）

 #include<iostream>
 #include<string.h>
 using namespace std;
 int n,ASM[][],square[][];//square[][]用来存放结果符号映射，其中set[square[i][j]]即为i,j位置的符号
 char set[]={' ','-','|','O','H','H'};//4代表游离H,5代表固定H
 bool Valid(int i,int j){return (<=i&&i<*n-&&<=j&&j<*n+);}
 void output(){
     for(int i=;i<*n+;i++) cout<<'*';cout<<'\n';//输出第一行的4n+3个*
     for(int i=;i<*n-;i++){//中间图像
         cout<<'*';
         for(int j=;j<*n+;j++)cout<<set[square[i][j]];
         cout<<'*'<<'\n';
     }
     for(int i=;i<*n+;i++) cout<<'*';cout<<'\n';//输出最后一行的4n+3个*
 }
 void solve(){
     memset(square,,sizeof(square));
     for(int i=;i<n;i++){
         for(int j=;j<n;j++){
             square[*i][*j+]=;square[*i][*j+]=;
             if(j==) square[*i][*j]=;
             if(i<n-) square[*i+][*j+]=;    //氧氢位置是固定的，变化的是连线!!!

             if(ASM[i][j]==){//横着
              square[*i][*j+]=square[*i][*j+]=;
              square[*i][*j]=square[*i][*j+]=;
             }
             else if(ASM[i][j]==-){//竖着(不用考虑越界因为i不可能为0)
              square[*i-][*j+]=square[*i+][*j+]=;
              square[*i-][*j+]=square[*i+][*j+]=;
             }
         }
     }
     for(int i=;i<n;i++){//其他情况配对
         for(int j=;j<n;j++){
             if(ASM[i][j]==){//对i,j周围4个H进行判断，并固定其中游离的H
                 if(Valid(*i,*j)&&square[*i][*j]!=)
                     square[*i][*j]=, square[*i][*j+]=;
                 else if(Valid(*i,*j+)&&square[*i][*j+]!=)
                     square[*i][*j+]=, square[*i][*j+]=;
                 if(Valid(*i-,*j+)&&square[*i-][*j+]!=)
                     square[*i-][*j+]=, square[*i-][*j+]=;
                 else if(Valid(*i+,*j+)&&square[*i+][*j+]!=)
                     square[*i+][*j+]=, square[*i+][*j+]=;
             }
         }
     }
 }
 int main(){
     int casee=;
     while(cin>>n && n>){
         for(int i=;i<n;i++)
             for(int j=;j<n;j++)
                 cin>>ASM[i][j];
         cout<<(casee== ? "":"\n");
         cout<<"Case "<<casee++<<":\n\n";
         solve();
         output();
     }return ;
 }
 //poj1099