OpenJudge NOI 1.8 16:矩阵剪刀石头布

【题目链接】

OpenJudge NOI 1.8 16:矩阵剪刀石头布

【题目考点】

1. 二维数组

2. 方向数组

在一个矩阵中，当前位置为(sx, sy)，将下一个位置与当前位置横纵坐标的差值记到一个数组中，即为方向数组。
方向数组有一维数组和二维数组两种写法，效果是等同的。
以遍历上下左右四个方向为例：

• 一维数组写法

int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
for(int i = 0; i < 4; ++i)
{
	int x = sx + dx[i], y = sy + dy[i];
	//(sx,sy)周围的一个新的位置为(x, y)
}

• 二维数组写法

int dir[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
for(int i = 0; i < 4; ++i)
{
	int x = sx + dir[i][0], y = sy + dir[i][1];
	//(sx,sy)周围的一个新的位置为(x, y)
}

3. memcpy数组拷贝函数(扩展)

头文件：<cstring>
memcpy(目标数组, 原数组, 拷贝字节);

【解题思路】

如果一个位置的周围四个格子中，有能胜过当前位置的出拳，那么在下一个周期总，该位置的出拳形式会发生改变。

例：
一个位置是石头，如果它周围的位置中有布，那么下一周期这里就变成了布，否则这里还是石头。

输入初始状态到数组a，

• 循环n次
  • 遍历在数组a每个位置，查看该位置周围是否有胜过当前位置的出拳
    • 如果有，将能胜过该位置的出拳赋值给数组b的对应位置。
    • 如果没有，则将当前位置出拳赋值给数组b的对应位置。
  • 把数组b拷贝给数组a
• 最后输出数组a

【题解代码】

解法1：二维方向数组

#include <bits/stdc++.h>
using namespace std;
#define N 105
int dir[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
int main()
{
    int r, c, n;
    char a[N][N], b[N][N];
    cin >> r >> c >> n;
    for(int i = 1; i <= r; ++i)
        for(int j = 1; j <= c; ++j)
            cin >> a[i][j];
    for(int k = 1; k <= n; ++k)
    {
        for(int i = 1; i <= r; ++i)
        {
            for(int j = 1; j <= c; ++j)
            {
                b[i][j] = a[i][j];//默认和原来位置的一样 
                for(int d = 0; d < 4; ++d)//看(i,j)周围有没有能胜过a[i][j]的出拳 
                {
                    int x = i + dir[d][0], y = j + dir[d][1];
                    if(a[x][y] == 'R' && a[i][j] == 'S')
                        b[i][j] = 'R'; 
                    else if(a[x][y] == 'S' && a[i][j] == 'P')
                        b[i][j] = 'S';
                    else if(a[x][y] == 'P' && a[i][j] == 'R')
                        b[i][j] = 'P';
                }
            }
        }
        for(int i = 1; i <= r; ++i)//复制b到a 
            for(int j = 1; j <= c; ++j)
                a[i][j] = b[i][j]; 
    }
    for(int i = 1; i <= r; ++i)
    {
        for(int j = 1; j <= c; ++j)
            cout << a[i][j];
        cout << endl;
    }
    return 0;
}

解法2：一维方向数组 + 使用memcpy

#include <bits/stdc++.h>
using namespace std;
#define N 105
int dx[4] = {0,0,1,-1}, dy[4] = {1,-1,0,0};
int main()
{
    int r, c, n;
    char a[N][N], b[N][N];
    cin >> r >> c >> n;
    for(int i = 1; i <= r; ++i)
        for(int j = 1; j <= c; ++j)
            cin >> a[i][j];
    for(int k = 1; k <= n; ++k)
    {
        for(int i = 1; i <= r; ++i)
        {
            for(int j = 1; j <= c; ++j)
            {
                b[i][j] = a[i][j];//默认和原来位置的一样 
                for(int d = 0; d < 4; ++d)//看(i,j)周围有没有能胜过a[i][j]的出拳 
                {
                    int x = i + dx[d], y = j + dy[d];
                    if(a[x][y] == 'R' && a[i][j] == 'S')
                        b[i][j] = 'R'; 
                    else if(a[x][y] == 'S' && a[i][j] == 'P')
                        b[i][j] = 'S';
                    else if(a[x][y] == 'P' && a[i][j] == 'R')
                        b[i][j] = 'P';
                }
            }
        }
        memcpy(a, b, sizeof(a));//复制b到a 
    }
    for(int i = 1; i <= r; ++i)
    {
        for(int j = 1; j <= c; ++j)
            cout << a[i][j];
        cout << endl;
    }
    return 0;
}