C编程整个棋盘可表示为一个M×N的二维数组。假若马目前在位置（i,j）则马下一步可移动的位置0、1、……、7可分别表示为(i-2,j+1),(i-1,j+2),(i+1,j+2),(i+2,j+1),(i+2,j-1),(i+1,j-2), (i-1,j-2), (i-2,j-1)。当然，这些位置一定在棋盘边界以内（保证下一步移动位置坐标（i，j）,有0<i<M+1,0<j<N+1）。 格子具有集合性，故考虑使用无向图来表示格子及其间关系；以邻接表作为该无向图中结点与相邻8个结点（4黑4白）的存储结构；以顶点表存储格子，每格为顶点表中一结点，其指针域指向该顶点所能到达的第一个结点。 表头结点： Vex x y link Vex:头结点所在的序号 x:头结点所在的横坐标； y:头结点所在的纵坐标； link:指向Vex下一个能够到达的邻接结点 链表中结点的结构同表头结点的结构同。在此不一一赘述了； 假定我们按照以下方式对棋盘上的格子进行编号（如红色标注），那么编号与格子所在的坐标（如蓝色标注）位置必然存在一定关系。（留给大家思考） 21（1，5） 22（2，5） 23（3，5） 24（4，5） 25（5，5） 16（1，4） 17（2，4） 18（3，4） 19（4，4） 20（5，4） 11（1，3） 12（2，3） 13（3，3） 14（4，3） 15（5，3） 6（1，2） 7（2，2） 8（3，2） 9（4，2） 10（5，2） 1（1，1） 2（2，1） 3（3，1） 4（4，1） 5（5，1） 综合起来，马踏棋盘问题就可以转化为图的遍历问题。

对于这个问题，我们可以使用深度优先搜索（DFS）或广度优先搜索（BFS）来解决。以DFS为例，我们可以从马当前所在的位置开始，依次尝试走8个方向，如果该方向上的格子未曾被访问过，则将其标记为已访问，并将其加入到搜索队列中。然后再从搜索队列中取出下一个格子，继续进行搜索，直到找到目标格子或者所有格子都已经访问过。

在实现DFS或BFS时，需要使用一个二维数组来记录每个格子是否已经被访问过，并使用一个栈或队列来存储待访问的格子。另外，还需要定义一个结构体来表示每个格子的位置信息和邻接表。

代码实现如下：

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

#define MAX_ROW 5
#define MAX_COL 5

// 邻接表结构体
typedef struct node {
    int vertex;  // 顶点编号
    struct node* next;  // 指向下一个邻接点的指针
} Node;

// 格子结构体
typedef struct grid {
    int row;  // 行坐标
    int col;  // 列坐标
    Node* adj_list;  // 邻接表头指针
} Grid;

// 初始化邻接表
void init_adj_list(Grid* grid) {
    grid->adj_list = NULL;
    for (int i = 0; i < 8; i++) {
        int row = grid->row;
        int col = grid->col;
        switch (i) {
            case 0:
                row -= 2;
                col += 1;
                break;
            case 1:
                row -= 1;
                col += 2;
                break;
            case 2:
                row += 1;
                col += 2;
                break;
            case 3:
                row += 2;
                col += 1;
                break;
            case 4:
                row += 2;
                col -= 1;
                break;
            case 5:
                row += 1;
                col -= 2;
                break;
            case 6:
                row -= 1;
                col -= 2;
                break;
            case 7:
                row -= 2;
                col -= 1;
                break;
        }
        if (row >= 1 && row <= MAX_ROW && col >= 1 && col <= MAX_COL) {
            Node* node = (Node*)malloc(sizeof(Node));
            node->vertex = (row - 1) * MAX_COL + col;
            node->next = grid->adj_list;
            grid->adj_list = node;
        }
    }
}

// DFS深度优先搜索
int dfs(Grid* grid, int visited[], int target) {
    visited[grid->row * MAX_COL + grid->col] = 1;
    if (grid->row * MAX_COL + grid->col == target) {
        return 1;
    }
    for (Node* node = grid->adj_list; node != NULL; node = node->next) {
        if (!visited[node->vertex]) {
            Grid next_grid = { (node->vertex - 1) / MAX_COL + 1, (node->vertex - 1) % MAX_COL + 1, NULL };
            if (dfs(&next_grid, visited, target)) {
                return 1;
            }
        }
    }
    return 0;
}

int main() {
    int start = 1;  // 起点
    int target = 24;  // 终点
    Grid grids[MAX_ROW][MAX_COL];
    for (int i = 0; i < MAX_ROW; i++) {
        for (int j = 0; j < MAX_COL; j++) {
            grids[i][j].row = i + 1;
            grids[i][j].col = j + 1;
            init_adj_list(&grids[i][j]);
        }
    }
    int visited[MAX_ROW * MAX_COL] = { 0 };
    if (dfs(&grids[(start - 1) / MAX_COL][(start - 1) % MAX_COL], visited, target)) {
        printf("Can reach.\n");
    }
    else {
        printf("Cannot reach.\n");
    }
    return 0;
}

上述代码实现了马踏棋盘问题的解决，使用DFS进行搜索，可以判断起点是否能够到达终点。