使用状态空间方法，用c语言代码实现：已知方格组成的如下环境地图，地图中深颜色的方格是障碍物；某机器人在该方格环境中移动，每一次移动只能移动到相邻的方格，并且不能移动到障碍物位置；它需从初始位置的方格移动到目标位置的方格，请为机器人构造从初始位置（起点）移动到目标位置（终点）的可行路径。

以下是使用状态空间方法实现路径搜索的C语言代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define ROWS 5
#define COLS 5

int map[ROWS][COLS] = {
    {0, 0, 0, 1, 1},
    {1, 0, 1, 0, 0},
    {0, 0, 1, 0, 1},
    {1, 0, 0, 0, 1},
    {1, 1, 0, 0, 0}
};

int start_row = 0;
int start_col = 0;
int end_row = 4;
int end_col = 4;

typedef struct {
    int row;
    int col;
} State;

typedef struct {
    State state;
    int cost;
    int heuristic;
} Node;

int heuristic(State state) {
    // 计算当前状态到终点的曼哈顿距离
    return abs(state.row - end_row) + abs(state.col - end_col);
}

bool is_goal_state(State state) {
    return state.row == end_row && state.col == end_col;
}

bool is_valid_state(State state) {
    if (state.row < 0 || state.col < 0 || state.row >= ROWS || state.col >= COLS) {  // 超出地图范围
        return false;
    }
    if (map[state.row][state.col] == 1) {  // 障碍物
        return false;
    }
    return true;
}

int get_successors(State state, State successors[]) {
    int count = 0;
    State next_state;

    // 向上移动
    next_state.row = state.row - 1;
    next_state.col = state.col;
    if (is_valid_state(next_state)) {
        successors[count++] = next_state;
    }

    // 向下移动
    next_state.row = state.row + 1;
    next_state.col = state.col;
    if (is_valid_state(next_state)) {
        successors[count++] = next_state;
    }

    // 向左移动
    next_state.row = state.row;
    next_state.col = state.col - 1;
    if (is_valid_state(next_state)) {
        successors[count++] = next_state;
    }

    // 向右移动
    next_state.row = state.row;
    next_state.col = state.col + 1;
    if (is_valid_state(next_state)) {
        successors[count++] = next_state;
    }

    return count;
}

int compare_nodes(const void *a, const void *b) {
    Node *node_a = (Node *)a;
    Node *node_b = (Node *)b;
    return (node_a->cost + node_a->heuristic) - (node_b->cost + node_b->heuristic);
}

void print_path(Node node) {
    if (node.state.row == start_row && node.state.col == start_col) {
        printf("(%d, %d)\n", node.state.row, node.state.col);
        return;
    }
    print_path(node.parent);
    printf("(%d, %d)\n", node.state.row, node.state.col);
}

void search() {
    Node node;
    node.state.row = start_row;
    node.state.col = start_col;
    node.cost = 0;
    node.heuristic = heuristic(node.state);
    node.parent = node;

    Node queue[ROWS * COLS];
    int queue_size = 1;
    queue[0] = node;

    while (queue_size > 0) {
        // 从队列中取出代价最小的节点
        qsort(queue, queue_size, sizeof(Node), compare_nodes);
        node = queue[0];
        if (is_goal_state(node.state)) {
            print_path(node);
            return;
        }
        queue_size--;

        // 扩展当前节点的所有合法子节点
        State successors[4];
        int num_successors = get_successors(node.state, successors);
        for (int i = 0; i < num_successors; i++) {
            Node child;
            child.state = successors[i];
            child.cost = node.cost + 1;
            child.heuristic = heuristic(child.state);
            child.parent = node;
            queue[queue_size++] = child;
        }
    }

    printf("No path found.\n");
}

int main() {
    search();
    return 0;
}

该代码使用状态空间搜索方法实现了A*算法，从起点开始向四个方向搜索，选择代价最小的节点进行扩展，直到找到终点或者无法继续前进。找到路径后，按照搜索顺序反向输出路径。在每个节点处，计算当前状态到终点的曼哈顿距离作为启发函数，并将代价和启发函数的和作为搜索优先级的依据。