python题解：

import sys

def solve():
    input = sys.stdin.readline
    
    r, c, n = map(int, input().split())
    
    g = [[0] * (c + 2) for _ in range(r + 2)]
    robot_pos = [[0] * (c + 2) for _ in range(r + 2)]
    
    for i in range(1, r + 1):
        row = input().strip()
        for j, ch in enumerate(row, 1):
            g[i][j] = ord(ch)
    
    robot_r = [0] * (n + 5)
    robot_c = [0] * (n + 5)
    robot_dir = [0] * (n + 5)
    has_item = [0] * (n + 5)  # 0/1代替True/False
    holding = [0] * (n + 5)
    
    for i in range(1, n + 1):
        robot_r[i], robot_c[i], robot_dir[i] = map(int, input().split())
        robot_pos[robot_r[i]][robot_c[i]] = ord('@')
    
    k = int(input())
    
    dirs = [(-1, 0), (0, 1), (1, 0), (0, -1)]
    ans = 0
    
    for _ in range(k):
        id_num, op = input().split()
        id_num = int(id_num)
        
        cr = robot_r[id_num]
        cc = robot_c[id_num]
        cd = robot_dir[id_num]
        
        if op == 'F':
            nr, nc = cr + dirs[cd][0], cc + dirs[cd][1]
            if 1 <= nr <= r and 1 <= nc <= c:
                if g[nr][nc] != ord('#') and robot_pos[nr][nc] != ord('@'):
                    robot_pos[cr][cc] = ord('.')
                    robot_pos[nr][nc] = ord('@')
                    robot_r[id_num], robot_c[id_num] = nr, nc
                    ans += 1
        elif op == 'L':
            robot_dir[id_num] = (cd + 3) % 4
            ans += 1
        elif op == 'R':
            robot_dir[id_num] = (cd + 1) % 4
            ans += 1
        elif op == 'P':
            if not has_item[id_num] and ord('A') <= g[cr][cc] <= ord('Z'):
                has_item[id_num] = 1
                holding[id_num] = g[cr][cc]
                g[cr][cc] = ord('.')
                ans += 1
        elif op == 'D':
            if has_item[id_num] and g[cr][cc] == ord('.'):
                has_item[id_num] = 0
                g[cr][cc] = holding[id_num]
                holding[id_num] = ord(' ')
                ans += 1
    
    print(ans)
    for i in range(1, r + 1):
        print(''.join(chr(g[i][j]) for j in range(1, c + 1)))

if __name__ == "__main__":
    solve()

Java题解：

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] first = br.readLine().split(" ");
        int r = Integer.parseInt(first[0]);
        int c = Integer.parseInt(first[1]);
        int n = Integer.parseInt(first[2]);
        
        char[][] g = new char[r + 2][c + 2];
        char[][] robotPos = new char[r + 2][c + 2];
        
        // 读取网格
        for (int i = 1; i <= r; i++) {
            String line = br.readLine();
            for (int j = 1; j <= c; j++) {
                g[i][j] = line.charAt(j - 1);
                robotPos[i][j] = '.';
            }
        }
        
        // 机器人数组
        int[] robotR = new int[n + 1];
        int[] robotC = new int[n + 1];
        int[] robotDir = new int[n + 1];
        boolean[] hasItem = new boolean[n + 1];
        char[] holding = new char[n + 1];
        
        for (int i = 1; i <= n; i++) {
            String[] parts = br.readLine().split(" ");
            robotR[i] = Integer.parseInt(parts[0]);
            robotC[i] = Integer.parseInt(parts[1]);
            robotDir[i] = Integer.parseInt(parts[2]);
            robotPos[robotR[i]][robotC[i]] = '@';
        }
        
        int k = Integer.parseInt(br.readLine());
        int ans = 0;
        int[][] dirs = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
        
        for (int t = 0; t < k; t++) {
            String[] parts = br.readLine().split(" ");
            int id = Integer.parseInt(parts[0]);
            char op = parts[1].charAt(0);
            
            int cr = robotR[id];
            int cc = robotC[id];
            int cd = robotDir[id];
            
            if (op == 'F') {
                int nr = cr + dirs[cd][0];
                int nc = cc + dirs[cd][1];
                if (nr >= 1 && nr <= r && nc >= 1 && nc <= c && 
                    g[nr][nc] != '#' && robotPos[nr][nc] != '@') {
                    robotPos[cr][cc] = '.';
                    robotPos[nr][nc] = '@';
                    robotR[id] = nr;
                    robotC[id] = nc;
                    ans++;
                }
            } else if (op == 'L') {
                robotDir[id] = (cd + 3) % 4;
                ans++;
            } else if (op == 'R') {
                robotDir[id] = (cd + 1) % 4;
                ans++;
            } else if (op == 'P') {
                if (!hasItem[id] && g[cr][cc] >= 'A' && g[cr][cc] <= 'Z') {
                    hasItem[id] = true;
                    holding[id] = g[cr][cc];
                    g[cr][cc] = '.';
                    ans++;
                }
            } else if (op == 'D') {
                if (hasItem[id] && g[cr][cc] == '.') {
                    hasItem[id] = false;
                    g[cr][cc] = holding[id];
                    holding[id] = ' ';
                    ans++;
                }
            }
        }
        
        System.out.println(ans);
        for (int i = 1; i <= r; i++) {
            for (int j = 1; j <= c; j++) {
                System.out.print(g[i][j]);
            }
            System.out.println();
        }
    }
}

#include <bits/stdc++.h>
#define int long long // 仅在需要大整数时使用，memset 数组为 0x3f 时去掉
#define INF 0x3f3f3f3f
#define PII pair<int, int>
#define ULL unsigned long long
#define PIII tuple<int, int, int>
#define all(v) v.begin(), v.end()
#define debug(a) cout << #a << " = " << a << endl;
using namespace std;
constexpr int N = 1 * 1e6 + 10, M = 50 + 10;

char mp[M][M];
bool st[M][M];
int dir[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}}; //北0, 东1, 南2, 西3
struct robot {
    int x, y, d;
    char p;
}Robot[M];

void solve() {
    int r, c, n, k;
    cin >> r >> c >> n;
    for (int i = 1; i <= r; i ++) {
        for (int j = 1; j <= c; j ++) {
            cin >> mp[i][j];
        }
    }
    for (int i = 1; i <= n; i ++) {
        auto &[x, y, d, p] = Robot[i];
        cin >> x >> y >> d;
        st[x][y] = 1;
        p = ' ';
    }
    cin >> k;
    int ok = 0;
    while (k --) {
        int id;
        char op[2];
        cin >> id >> op;
        auto &[x, y, d, p] = Robot[id];
        if (*op == 'D') {
            if (p == ' ' || mp[x][y] != '.') continue;
            mp[x][y] = p, p = ' ';
        } else if (*op == 'P') {
            if (p != ' ' || mp[x][y] == '.') continue;
            p = mp[x][y], mp[x][y] = '.';
        } else if (*op == 'L') {
            d = (d + 4 - 1) % 4;
        } else if (*op == 'R') {
            d = (d + 1) % 4;
        } else {
            int nx = x + dir[d][0], ny = y + dir[d][1];
            if (nx > r || nx <= 0 || ny > c || ny <= 0) continue;
            if (mp[nx][ny] == '#' ||st[nx][ny]) continue;
            st[x][y] = 0;
            st[nx][ny] = 1;
            x = nx, y = ny;
        }
        ok ++;
        
    }
    cout << ok << '\n';
    for (int i = 1; i <= r; i ++) {
        for (int j = 1; j <= c; j ++) {
            cout << mp[i][j];
        }
        cout << '\n';
    }
}

signed main() {
    ios::sync_with_stdio(0); cin.tie(nullptr), cout.tie(nullptr);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

/**
 *    author: Nijika_jia
 *    description: C++17 Algorithm Template for Competitive Programming
 */