扫雷

题目描述:

扫雷游戏的玩法是在一个9*9(初级)，16*16(中级)，16*30(高级)，或自定义大小的方块矩阵中随机布置一定量的地雷(初级为10个，中级为40个，高级为99个)。由玩家逐个翻开方块，以找出所有地雷为最终游戏目标。如果玩家翻开的方块有地雷，则游戏结束。  

现在给你一个初级矩阵，我们已经知道了所有地雷的位置，你能将地雷周围所有的提示数字输出么？

提示数字指的是以该数字所在空格为中心的周围8个格子中间的地雷的个数。

 

输入描述:

T组输入（0<=T<=20）。
输入包括9行。
每行只包括空格、下划线、*号：空格无意义、下划线表示一个空格方块（你要填入数字的地方）、*号表示地雷。

输出描述:

输出所有的提示数字，如果提示数字为0，不用输出。
每组测试样例后面输出一行。

样例输入:

1
_ _ _ _ _ _ _ _ *
_ _ _ _ _ _ _ _ _
_ _ * _ _ _ _ _ _
_ _ _ _ * _ _ _ _
_ * _ _ _ _ _ * _
_ _ _ _ * _ _ _ _
_ * _ _ _ * _ _ _
_ _ _ * _ _ _ * _
_ _ _ _ _ _ _ _ _

样例输出:

_ _ _ _ _ _ _ 1 *
_ 1 1 1 _ _ _ 1 1
_ 1 * 2 1 1 _ _ _
1 2 2 2 * 1 1 1 1
1 * 1 2 2 2 1 * 1
2 2 2 1 * 2 2 1 1
1 * 2 2 3 * 2 1 1
1 1 2 * 2 1 2 * 1
_ _ 1 1 1 _ 1 1 1

 

这道题，如果不考虑是否雷的位置在边界的情况下，可以直接用一个二维数组记录周围出现地雷的次数，然后再输出。

对应的AC代码为：

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<math.h>
char a[25][25];
char c[25][25];
int b[25][25];
using namespace std;
int main()
{
    int T;
    scanf("%d ",&T);
    while(T--)
    {
        memset(b,0,sizeof(b));
        for(int i=3;i<=11;++i)

            {
                gets(a[i]);
            }
        for(int i=3;i<=11;++i)
        {
            for(int j=0;j<=16;++j)
            {
                c[i][j+3]=a[i][j];
            }
        }
        for(int i=3;i<=11;++i)
        {
            for(int j=3;j<=19;j+=2)
            {
                if(c[i][j]=='*')
                {
                   b[i-1][j-2]++;
                   b[i-1][j]++;
                   b[i-1][j+2]++;
                   b[i][j-2]++;
                   b[i][j+2]++;
                   b[i+1][j-2]++;
                   b[i+1][j]++;
                   b[i+1][j+2]++;
                }
            }
        }
        for(int i=3;i<=11;++i)
        {
            for(int j=3;j<=19;j++)
            {
                if(c[i][j]=='*')
                    {printf("*");}
                else if(c[i][j]==' ')
                    {printf(" ");}
                else
                    {
                    if(b[i][j]!=0)
                    printf("%d",b[i][j]);
                    else
                    printf("_");
                    }
            }
            printf("\n");
        }
        printf("\n");
    }
    return 0;
}

但是我们如果不想把一个数组中的元素转移到另一个数组中的话，就需要判断这个元素的下标是不是边界的了，如果是边界的话，就要用0来计算了。

 

for(int x=max(i-1,0); x<=min(i+1,8); x++)
                {
                    for(int y=max(j-2,0); y<=min(j+2,17); y+=2)
                    {
                        if(a[x][y]=='*')
                        {
                            sum++;
                        }
                    }
                }

左边去最大值，右边去最小值。

这样保证计算的范围是在9*9的范围内。

#include<algorithm>
#include<stdio.h>
using namespace std;
int main()

{
    int T;
    scanf("%d ",&T);
    while(T--)
    {
      char a[25][25];
      for(int i=0;i<9;++i)
        gets(a[i]);
      for(int i=0;i<9;++i)
      {
          for(int j=0;j<=17;j+=2)
          {
              int num=0;
              if(a[i][j]=='*')
                continue;
                  for(int m=max(i-1,0);m<=min(8,i+1);++m)
                  {
                      for(int n=max(j-2,0);n<=min(17,j+2);n+=2)
                      {
                          if(a[m][n]=='*')
                          ++num;
                      }
                  }
              if(num)
              {
                  a[i][j]=num+'0';
              }
          }
      }
      for(int i=0;i<9;++i)
              printf("%s\n",a[i]);
        if(T)
         printf("\n");
      }
    return 0;
}

这种方法是一个一个数遍历，判断这个数周围是否有地雷，然后再输出相应的元素。