可以用C和贪心算法帮我解决下面这个问题吗，世界名画陈列馆由m*n个排列成矩形阵列的陈列室组成。为了防止名画被盗，需要在陈列室中设置警卫机器人哨位。除了监视所在的陈列室，每个警卫机器人还可以监视与它所在的陈列室相邻的上、下、左、右4个陈列室。试设计一个安排警卫机器人哨位的算法，使名画陈列馆中每个陈列室都在警卫机器人的监视下，并且要求每个陈列室仅受一个警卫机器人监视，且所用的警卫机器人数最少。

这是一个经典的图论问题，可以用贪心算法来解决。首先，我们可以将每个陈列室视为图中的一个节点，相邻的陈列室之间有一条边。然后，我们可以选择一个起始节点，并将其标记为已监视。接下来，从未被监视的节点中选择一个与已监视节点相邻的节点，将其标记为已监视，并继续遍历相邻节点。直到所有节点都被标记为已监视为止。

在这个过程中，我们可以使用一个集合来存储未被监视的节点，并在每次选择节点后更新集合。由于每个节点最多只与四个相邻节点相连，因此每次选择相邻节点时，我们可以选择与当前节点相邻且未被监视的节点中编号最小的节点。这可以通过将节点按行优先顺序排序来实现。

以下是伪代码：

int m, n; // 行数和列数
int graph[m][n]; // 图的邻接矩阵表示，graph[i][j] = 1 表示节点 (i, j) 与相邻节点相连
int visited[m][n] = {0}; // 记录每个节点是否已经被监视
int cnt = 0; // 监视机器人数量

// 将节点 (i, j) 标记为已监视
void mark_visited(int i, int j) {
    visited[i][j] = 1;
    cnt++;
}

// 判断节点 (i, j) 是否未被监视
int is_unvisited(int i, int j) {
    return !visited[i][j];
}

// 获取与节点 (i, j) 相邻且编号最小的未被监视节点
void get_next_unvisited(int i, int j, int* next_i, int* next_j) {
    *next_i = i;
    *next_j = j;
    if (i > 0 && is_unvisited(i - 1, j)) {
        *next_i = i - 1;
    } else if (i < m - 1 && is_unvisited(i + 1, j)) {
        *next_i = i + 1;
    } else if (j > 0 && is_unvisited(i, j - 1)) {
        *next_j = j - 1;
    } else if (j < n - 1 && is_unvisited(i, j + 1)) {
        *next_j = j + 1;
    }
}

// 贪心算法求解
void solve() {
    // 初始化未被监视的节点集合
    int unvisited[m * n][2];
    int num_unvisited = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            unvisited[num_unvisited][0] = i;
            unvisited[num_unvisited][1] = j;
            num_unvisited++;
        }
    }

    // 选择起始节点并标记为已监视
    mark_visited(0, 0);
    unvisited[0][0] = unvisited[num_unvisited - 1][0];
    unvisited[0][1] = unvisited[num_unvisited - 1][1];
    num_unvisited--;

    // 依次选择相邻且未被监视的节点并标记为已监视
    while (num_unvisited > 0) {
        int i = unvisited[0][0];
        int j = unvisited[0][1];
        int next_i, next_j;
        get_next_unvisited(i, j, &next_i, &next_j);
        mark_visited(next_i, next_j);
        // 将已监视的节点从集合中移除
        unvisited[0][0] = unvisited[num_unvisited - 1][0];
        unvisited[0][1] = unvisited[num_unvisited - 1][1];
        num_unvisited--;
        // 调整集合中的节点顺序，保证下次选择相邻节点时编号最小
        for (int k = 0; k < num_unvisited; k++) {
            if (unvisited[k][0] == next_i && unvisited[k][1] == next_j) {
                unvisited[k][0] = unvisited[num_unvisited][0];
                unvisited[k][1] = unvisited[num_unvisited][1];
                break;
            }
        }
    }

    printf("需要 %d 台警卫机器人\n", cnt);
}

时间复杂度为 $O(mn\log(mn))$，其中 $\log(mn)$ 是排序的复杂度。