数据结构：将马随机放在m*n的棋盘Board[m][n]的某各方格中，按国际象棋的规则，马进行移动。要求每一方格只行走一次，走遍棋盘上全部方格。编写非递归程序，求出马的行走路线，并按求出的行走路线将数字1，2，。。。m*n依次填入一个m*n的方阵中。

这是一个比较复杂的问题，需要使用回溯算法来解决。以下是伪代码实现：

1. 初始化棋盘Board[m][n]为0，表示当前所有方格都未被访问过。
2. 初始化马的起点位置为(0,0)，将数字1填入Board[0][0]中。
3. 设置一个栈stack，将(0,0)入栈。
4. while stack不为空：
1. 取出栈顶元素(top)，表示当前位置。
2. 从当前位置开始，按照国际象棋的规则，依次尝试8个方向的移动。
3. 对于每个可行的方向，判断是否到达了棋盘边界以及是否已经被访问过。
4. 如果该方向可以继续行走，则将该方向的目标位置(target)入栈，并在Board[target.x][target.y]中填入数字top+1，表示当前已访问的方格数。
5. 如果无法继续行走，则回溯到上一步，将该方向的目标位置的Board值重新置为0，表示该方格未被访问过。
5. 当所有方格都被访问过时，输出Board中的数字矩阵，表示马的行走路线。

以下是Python代码实现：

相关问题

c语言请使用回溯算法求解n皇后问题:即 n*n棋盘上放置n个皇后

当然可以！以下是使用回溯算法求解n皇后问题的C语言代码：

#include <stdio.h>
#define N 10

int board[N][N];
int n;

// 检查在(x, y)位置放置皇后是否合法
int isSafe(int x, int y) {
    // 检查同一列是否有其他皇后
    for (int i = 0; i < x; i++) {
        if (board[i][y] == 1)
            return 0;
    }
    // 检查左上角到右下角的对角线是否有其他皇后
    for (int i = x, j = y; i >= 0 && j >= 0; i--, j--) {
        if (board[i][j] == 1)
            return 0;
    }
    // 检查右上角到左下角的对角线是否有其他皇后
    for (int i = x, j = y; i >= 0 && j < n; i--, j++) {
        if (board[i][j] == 1)
            return 0;
    }
    return 1;
}

// 使用回溯算法求解n皇后问题
int solveNQueens(int row) {
    if (row == n) {
        // 打印解决方案
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                printf("%d ", board[i][j]);
            }
            printf("\n");
        }
        printf("\n");
        return 1;
    }

    int found = 0;
    for (int i = 0; i < n; i++) {
        if (isSafe(row, i)) {
            board[row][i] = 1;
            found += solveNQueens(row + 1);
            board[row][i] = 0;
        }
    }
    return found;
}

int main() {
    printf("请输入皇后的个数：");
    scanf("%d", &n);

    if (n > N) {
        printf("皇后个数过多，无法求解！\n");
        return 0;
    }

    int count = solveNQueens(0);

    printf("共找到 %d 个解决方案。\n", count);

    return 0;
}

你可以输入皇后的个数，程序将输出所有的解决方案。注意，由于n皇后问题的解决方案数量随着n的增加呈指数级增长，当n较大时，可能需要等待较长时间才能得到结果。希望这个代码能够帮助到你！

将马随机放在国际象棋的8*8棋盘的某个方格中，马按走棋规则进行移动。要求每个方格上只进入一次，走遍棋盘上全部64个方格。编制非递归程序，求出马的行走路线，并按求出的行走路线，将数字1，2，…，64依次填入一个8*8的方阵，输出之。

这里给出一个非递归的深度优先搜索算法，使用栈来模拟递归过程：

class Pos:
    def __init__(self, x, y):
        self.x = x
        self.y = y

def knight_tour():
    board = [[0]*8 for _ in range(8)]
    moves = [(-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2, 1)]
    stack = [Pos(0, 0)]
    board[0][0] = 1
    idx = 2

    while len(stack) > 0:
        pos = stack[-1]
        found = False
        for move in moves:
            next_pos = Pos(pos.x + move[0], pos.y + move[1])
            if next_pos.x < 0 or next_pos.x > 7 or next_pos.y < 0 or next_pos.y > 7:
                continue
            if board[next_pos.x][next_pos.y] == 0:
                stack.append(next_pos)
                board[next_pos.x][next_pos.y] = idx
                idx += 1
                found = True
                break
        if not found:
            board[pos.x][pos.y] = 0
            stack.pop()
            idx -= 1

    for row in board:
        print(row)

运行该函数即可得到马的行走路线并填入方阵中。