请用C++编程：你要清理一块大小为 n∗m 的土地的积雪。很不幸，雪一直在下，但是你的清理速 度却跟不上。 一开始所有格子的积雪深度为 0，每一次操作前所有格子的积雪深度会 +1。 一共有 3 种共 q 个操作 “1 x” 表示清理第 x 行的积雪。 “2 x” 表示清理第 x 列的积雪。 “3 x1 y1 x2 y2 k” 表示有人想从 (x1,y1) 走到 (x2,y2)，他最多能承受深度为 k 的 积雪。 清理积雪操作后会将所有的目标位置的积雪深度清零。 对于每一个询问，输出最少移动次数 (一个人每一次移动可以从某个单元格移动到 与之四连通的，积雪深度小于等于 k 的格子)。如果无法到达，输出-1。 特别的，如果起点或终点深度大于 k，则视为无法到达终点。 【输入格式】 从文件 snow.in 中读入数据。 第一行三个正整数 n、m、q 接下来 q 行每行一个操作 【输出格式】 输出到文件 snow.out 中。 对于所有 3 操作输出答案 【样例输入】 4 3 9 3 2 1 3 3 1 3 2 1 3 3 1 2 1 2 3 1 1 3 2 1 3 3 3 3 2 1 3 3 3 2 2 3 2 1 3 3 6 【样例输出】 3 第5页/共 6 页 -1 5 -1 3

可以使用以下C++代码来解决这个问题：

#include <iostream>
#include <vector>
#include <queue>
#include <cmath>

const int INF = 1e9;

struct Cell {
    int row;
    int col;
    int depth;
    
    Cell(int r, int c, int d) : row(r), col(c), depth(d) {}
};

int bfs(const std::vector<std::vector<int>>& snow, int x1, int y1, int x2, int y2, int k) {
    int n = snow.size();
    int m = snow[0].size();
    
    std::vector<std::vector<bool>> visited(n, std::vector<bool>(m, false));
    std::queue<Cell> q;
    
    q.push(Cell(x1, y1, snow[x1][y1]));
    visited[x1][y1] = true;
    
    while (!q.empty()) {
        Cell curr = q.front();
        q.pop();
        
        if (curr.row == x2 && curr.col == y2) {
            return curr.depth;
        }
        
        int dx[] = {-1, 0, 1, 0};
        int dy[] = {0, -1, 0, 1};
        
        for (int i = 0; i < 4; i++) {
            int nx = curr.row + dx[i];
            int ny = curr.col + dy[i];
            
            if (nx >= 0 && nx < n && ny >= 0 && ny < m && !visited[nx][ny] && snow[nx][ny] <= k) {
                q.push(Cell(nx, ny, std::max(curr.depth, snow[nx][ny])));
                visited[nx][ny] = true;
            }
        }
    }
    
    return -1;
}

int main() {
    int n, m, q;
    std::cin >> n >> m >> q;
    
    std::vector<std::vector<int>> snow(n, std::vector<int>(m, 0));
    
    for (int i = 0; i < q; i++) {
        int type;
        std::cin >> type;
        
        if (type == 1) {
            int row;
            std::cin >> row;
            
            for (int j = 0; j < m; j++) {
                snow[row-1][j]++;
            }
        } else if (type == 2) {
            int col;
            std::cin >> col;
            
            for (int j = 0; j < n; j++) {
                snow[j][col-1]++;
            }
        } else if (type == 3) {
            int x1, y1, x2, y2, k;
            std::cin >> x1 >> y1 >> x2 >> y2 >> k;
            
            int result = bfs(snow, x1-1, y1-1, x2-1, y2-1, k);
            
            std::cout << result << std::endl;
        }
    }
    
    return 0;
}

在这段代码中，我们首先定义了一个`Cell`结构体来表示一个单元格的行、列和深度。然后，我们定义了一个`bfs`函数来执行广度优先搜索，查找从起点到终点的最短路径。在搜索过程中，我们使用一个队列来存储待访问的单元格，并使用一个二维数组`visited`来记录已经访问过的单元格。最后，我们在`main`函数中根据不同的操作类型来更新积雪深度数组`snow`，或者调用`bfs`函数来计算最少移动次数，并将结果打印出来。

请注意，这段代码假设输入是合法的，即操作类型、行号、列号等都在有效范围内。在实际使用中，你可能需要添加一些输入验证来确保输入的正确性。此外，这段代码使用了广度优先搜索算法来解决问题，但对于较大的输入可能会超时。你可以尝试使用其他更高效的算法来优化解决方案。