用编码解决马踏棋盘问题，其中棋盘表示为一个N*N的二维数组，使用无向图来表示格子及其之间的关系，以邻接表作为该无向图中结点与其相邻8个结点（4黑4白）的存储结构，以顶点表存储格子，每格为顶点表中一结点，其指针域指向该节点所能到达的第一个结点

马踏棋盘问题可以使用深度优先搜索算法来解决，其中关键的一步就是构建无向图来表示棋盘上格子之间的关系。下面是使用邻接表实现的无向图数据结构：

struct EdgeNode {
    int adjvex;                 // 相邻结点编号
    struct EdgeNode* next;      // 指向下一个相邻结点的指针
};

struct VertexNode {
    int x, y;                   // 格子的坐标
    bool visited;               // 标记该格子是否已被访问过
    EdgeNode* first_edge;       // 指向第一个相邻结点的指针
};

struct Graph {
    VertexNode vexs[N*N];       // 顶点表
    int num_of_vexs;            // 顶点数
};

对于每个格子，我们可以用它在二维数组中的行列下标来作为顶点的编号，并将其坐标存储在顶点的数据结构中。每个格子的指针域指向它所能到达的相邻格子的结点，即黑色格子和白色格子各四个。

无向图的构建可以通过以下代码实现：

void createGraph(Graph &g, int n) {
    g.num_of_vexs = n * n;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int k = i * n + j;
            g.vexs[k].x = i;
            g.vexs[k].y = j;
            g.vexs[k].visited = false;
            g.vexs[k].first_edge = nullptr;
            if (i - 2 >= 0 && j - 1 >= 0) {    // 左上
                int adjk = (i - 2) * n + (j - 1);
                EdgeNode* e = new EdgeNode();
                e->adjvex = adjk;
                e->next = g.vexs[k].first_edge;
                g.vexs[k].first_edge = e;
            }
            if (i - 1 >= 0 && j - 2 >= 0) {    // 上左
                int adjk = (i - 1) * n + (j - 2);
                EdgeNode* e = new EdgeNode();
                e->adjvex = adjk;
                e->next = g.vexs[k].first_edge;
                g.vexs[k].first_edge = e;
            }
            if (i + 1 < n && j - 2 >= 0) {     // 下左
                int adjk = (i + 1) * n + (j - 2);
                EdgeNode* e = new EdgeNode();
                e->adjvex = adjk;
                e->next = g.vexs[k].first_edge;
                g.vexs[k].first_edge = e;
            }
            if (i + 2 < n && j - 1 >= 0) {     // 左下
                int adjk = (i + 2) * n + (j - 1);
                EdgeNode* e = new EdgeNode();
                e->adjvex = adjk;
                e->next = g.vexs[k].first_edge;
                g.vexs[k].first_edge = e;
            }
            if (i + 2 < n && j + 1 < n) {      // 右下
                int adjk = (i + 2) * n + (j + 1);
                EdgeNode* e = new EdgeNode();
                e->adjvex = adjk;
                e->next = g.vexs[k].first_edge;
                g.vexs[k].first_edge = e;
            }
            if (i + 1 < n && j + 2 < n) {      // 下右
                int adjk = (i + 1) * n + (j + 2);
                EdgeNode* e = new EdgeNode();
                e->adjvex = adjk;
                e->next = g.vexs[k].first_edge;
                g.vexs[k].first_edge = e;
            }
            if (i - 1 >= 0 && j + 2 < n) {     // 上右
                int adjk = (i - 1) * n + (j + 2);
                EdgeNode* e = new EdgeNode();
                e->adjvex = adjk;
                e->next = g.vexs[k].first_edge;
                g.vexs[k].first_edge = e;
            }
            if (i - 2 >= 0 && j + 1 < n) {     // 右上
                int adjk = (i - 2) * n + (j + 1);
                EdgeNode* e = new EdgeNode();
                e->adjvex = adjk;
                e->next = g.vexs[k].first_edge;
                g.vexs[k].first_edge = e;
            }
        }
    }
}

这样，我们就可以方便地遍历格子之间的关系，求解马踏棋盘问题了。