用c++，写上面这个问题的程序怎么写

在C++中解决这个问题，可以使用邻接矩阵（如果是四方向的相邻）或者邻接表来存储矩阵，同时配合深度优先搜索（DFS）或广度优先搜索（BFS）。这里我们选择使用BFS，因为它更适合作为连通组件计数。

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

// 定义一个结构体来存储位置和是否访问过
struct Cell {
    int row, col;
    bool visited;
};

int countCells(std::vector<std::vector<int>>& grid, int m, int n) {
    std::vector<std::vector<Cell>> adj_matrix(m, std::vector<Cell>(n));
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            if (grid[i][j] > 0) {
                adj_matrix[i][j].row = i;
                adj_matrix[i][j].col = j;
                adj_matrix[i][j].visited = false;
                // 根据方向添加相邻位置
                if (i + 1 < m && grid[i + 1][j] == grid[i][j])
                    adj_matrix[i + 1][j].visited = true;
                if (i - 1][j] == grid[i][j])
                    adj_matrix[i - 1][j].visited = true;
                if (j + 1 < n && grid[i][j + 1] == grid[i][j])
                    adj_matrix[i][j + 1].visited = true;
                if (j - 1 >= 0 && grid[i][j - 1] == grid[i][j])
                    adj_matrix[i][j - 1].visited = true;
            }
        }
    }

    int cell_count = 0;
    std::queue<Cell> q;
    for (auto& cell : adj_matrix) {
        for (auto& c : cell)
            if (!c.visited) {
                q.push(c);
                c.visited = true;
                cell_count++;
            }
    }

    while (!q.empty()) {
        Cell current = q.front();
        q.pop();

        // 添加相邻未访问的cell
        for (int i = -1; i <= 1; ++i) {
            int new_row = current.row + i;
            int new_col = current.col + 1 * (i == 0); // 考虑到行和列的不同步
            if (new_row >= 0 && new_row < m && new_col >= 0 && new_col < n && !adj_matrix[new_row][new_col].visited) {
                adj_matrix[new_row][new_col].visited = true;
                q.push(adj_matrix[new_row][new_col]);
                cell_count++;
            }
        }
    }

    return cell_count;
}

int main() {
    int m, n;
    std::cin >> m >> n;
    std::vector<std::vector<int>> grid(m, std::vector<int>(n));
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            std::cin >> grid[i][j];
        }
    }
    int result = countCells(grid, m, n);
    std::cout << "细胞总数：" << result << std::endl;

    return 0;
}

这个程序首先构建了一个邻接矩阵，然后使用队列进行BFS搜索并计数。注意边界条件和更新邻接矩阵的过程。运行结束后会输出细胞的总数。