题意分析

这道题目模拟甲虫贝蒂在棋盘上移动并推动棋子的过程。题目要求我们：

1. 读取初始棋盘状态（8x8网格），包含棋子（大小写字母表示不同颜色）和贝蒂的初始位置及朝向（用<, >, ^, v表示）
2. 根据给定的移动脚本（包含移动和转向指令），模拟贝蒂的运动：
   • 移动时推动前方所有棋子
   • 转向只改变方向不改变位置
3. 输出执行完所有指令后的棋盘状态

解题思路

1. 数据结构设计：

   • 使用8x8字符数组存储棋盘状态
   • 用结构体记录贝蒂的当前位置(x,y)和当前方向(dir)

2. 方向处理：

   • 定义方向数组：下(v)、右(>)、上(^)、左(<)
   • 对应的坐标变化：dx[4] = {1,0,-1,0}, dy[4] = {0,1,0,-1}

3. 移动处理：

   • 使用递归DFS处理棋子推动：
     • 如果前方是空格，直接移动
     • 如果前方是棋子，递归推动后面的棋子
   • 边界检查防止越界

4. 指令处理：

   • 解析move/turn指令
   • 对move指令执行指定次数的移动
   • 对turn指令更新方向

标程代码

#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 10;
char board[maxn][maxn];
struct Position {
    int x, y, dir;
} betty;

// 方向：下(0)、右(1)、上(2)、左(3)
char dirChars[4] = {'v','>','^','<'};
int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};

// 检查位置是否在棋盘内
bool isValid(int x, int y) {
    return x >= 1 && x <= 8 && y >= 1 && y <= 8;
}

// 递归推动棋子
void pushPieces(int x, int y) {
    if(board[x][y] == '.') {  // 空格，可以移动
        board[x][y] = board[x-dx[betty.dir]][y-dy[betty.dir]];
        board[x-dx[betty.dir]][y-dy[betty.dir]] = '.';
    } else {  // 有棋子，递归推动
        pushPieces(x+dx[betty.dir], y+dy[betty.dir]);
        board[x][y] = board[x-dx[betty.dir]][y-dy[betty.dir]];
        board[x-dx[betty.dir]][y-dy[betty.dir]] = '.';
    }
}

// 执行一步移动
void moveStep() {
    int nx = betty.x + dx[betty.dir];
    int ny = betty.y + dy[betty.dir];
    
    if(!isValid(nx, ny)) return;  // 边界检查
    
    board[betty.x][betty.y] = '.';  // 清空当前位置
    pushPieces(nx, ny);            // 推动前方棋子
    betty.x = nx;                  // 更新位置
    betty.y = ny;
}

int main() {
    char cmd[20], subcmd[20];
    int steps;
    
    while(scanf("%s", board[1]+1) != EOF) {
        if(board[1][1] == '-') break;
        
        // 读取棋盘
        for(int i = 2; i <= 8; i++) {
            scanf("%s", board[i]+1);
        }
        
        // 初始化贝蒂位置
        for(int i = 1; i <= 8; i++) {
            for(int j = 1; j <= 8; j++) {
                if(board[i][j] == 'v') {
                    betty = {i, j, 0};
                } else if(board[i][j] == '>') {
                    betty = {i, j, 1};
                } else if(board[i][j] == '^') {
                    betty = {i, j, 2};
                } else if(board[i][j] == '<') {
                    betty = {i, j, 3};
                }
            }
        }
        
        // 处理指令
        while(scanf("%s", cmd) != EOF) {
            if(cmd[0] == '#') break;
            
            if(cmd[0] == 't') {  // 转向指令
                scanf("%s", subcmd);
                if(subcmd[0] == 'l') {      // 左转
                    betty.dir = (betty.dir + 1) % 4;
                } else if(subcmd[0] == 'r') { // 右转
                    betty.dir = (betty.dir + 3) % 4;
                } else {                    // 向后转
                    betty.dir = (betty.dir + 2) % 4;
                }
            } else {  // 移动指令
                scanf("%d", &steps);
                for(int i = 0; i < steps; i++) {
                    moveStep();
                }
            }
        }
        
        // 输出结果
        board[betty.x][betty.y] = dirChars[betty.dir];
        for(int i = 1; i <= 8; i++) {
            printf("%s\n", board[i]+1);
        }
        printf("\n");
    }
    
    return 0;
}

代码说明

1. 方向处理：

   • 使用0-3表示四个方向，便于转向计算
   • 转向通过模4运算实现

2. 棋子推动：

   • 递归处理连续的棋子推动
   • 每次移动后更新贝蒂位置

3. 边界处理：

   • 移动前检查是否越界
   • 越界时不执行移动

4. 输入输出：

   • 严格按照题目要求的格式处理
   • 每个测试用例后输出空行

这个解决方案高效地模拟了甲虫在棋盘上的移动和推动棋子的过程，正确处理了所有边界情况，代码结构清晰易于理解。