c语言中使用递归函数的寻径程序

我需要编写一个C程序来找到从0x0到mxn的最短路径（为了更简单，在这里，我将使用递归函数调用这些点S作为起点，E作为终点）。但我不知道任何算法，我只知道关于C语言的一些基本知识，我不知道如何开始，从哪里开始。 我做了一些研究，写了一些类似的东西，但它有两个主要问题，1）它不会回溯，2）它不会自动移动。我想使用递归进行自动移动，但我做不到

#include <stdio.h>
#include <stdbool.h>
#define N 6
/// For printing the final solution Matrix
void printSolution(int solution[N][N]){
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++)
            printf(" %d ", solution[i][j]);
        printf("\n");
    }
}
/// For checking if solution coordinate is in matrix or not
bool isSafe(int maze[N][N], int x, int y){
    if (x >= 0 && x < N && y >= 0 && y < N && maze[x][y] == 1)
        return true;
    return false;
}
/// For looking to the neighbour cells
bool lookRight(int maze[N][N], int x, int y){
    if(maze[x][y+1]==0)
        return false;
    if(maze[x][y+1]==1)
        return true;
}
bool lookDown(int maze[N][N], int x, int y){
    if(maze[x+1][y]==0)
        return false;
    if(maze[x+1][y]==1)
        return true;
}
bool lookLeft(int maze[N][N], int x, int y){
    if(maze[x][y-1]==0)
        return false;
    if(maze[x][y-1]==1)
        return true;
}
bool lookUp(int maze[N][N], int x, int y){
    if(maze[x-1][y]==0)
        return false;
    if(maze[x-1][y]==1)
        return true;
}
/// For moving in available direction
bool moveRight(int maze[N][N], int x,int y){
    if (lookRight(maze, x, y)==true && isSafe(maze, x, y)==true)
        return true;
    else
        return false;
}
bool moveDown(int maze[N][N], int x,int y){
    if (lookDown(maze, x, y)==true && isSafe(maze, x, y)==true)
        return true;
    else
        return false;
}
bool moveLeft(int maze[N][N], int x,int y){
    if (lookLeft(maze, x, y)==true && isSafe(maze, x, y)==true)
        return true;
    else
        return false;
}
bool moveUp(int maze[N][N], int x,int y){
    if (lookUp(maze, x, y)==true && isSafe(maze, x, y)==true)
        return true;
    else
        return false;
}
/// For solving the main maze
bool solveMaze(int maze[N][N], int x, int y, int xFinal, int yFinal){
    int solution[N][N]={{0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0}};
    if (moveRight(maze, x, y)==true){
        solution[x][y+1]=1;
    }
    if (moveDown(maze, x, y)==true){
        solution[x+1][y]=1;
    }
    if (moveLeft(maze, x, y)==true){
        solution[x][y-1]=1;
    }
    if (moveUp(maze, x, y)==true){
        solution[x-1][y]=1;
    }
    printSolution(solution);
}
/// Main maze
int main() {         //S
    int maze[N][N] = {{1, 0, 1, 1, 1, 1},
                      {1, 0, 1, 0, 0, 1},
                      {1, 0, 1, 0, 0, 1},
                      {1, 0, 1, 0, 0, 1},
                      {1, 1, 1, 0, 0, 1},
                      {0, 0, 0, 0, 0, 1}};
    solveMaze(maze, 0, 0, N, N);    //E
    return 0;}

在这里，我的输入是元素（2,2）（为什么我给它（2,2）而不是（0,0），因为我想显示得更好，在完成的程序中，它将从0x0点或S开始）

首先它会检查它的右边，它是0，所以它不会做任何事情。接下来，它将检查，它是1，因此它将在解决方案矩阵中从0更改为1。我认为现在已经很清楚了，因此该输入的输出将如下所示：

 0  0  0  0  0  0
 0  0  1  0  0  0
 0  0  0  0  0  0
 0  0  1  0  0  0
 0  0  0  0  0  0
 0  0  0  0  0  0

这是手动输入，但我希望它能够自动移动，在这里1是路径，0是墙

int main() {
    int maze[N][N] = { {S, 0, 1, 1, 1, 1},
                       {1, 0, 1, 0, 0, 1},
                       {1, 0, 1, 0, 0, 1},
                       {1, 0, 1, 0, 0, 1},
                       {1, 0, 1, 0, 0, 1},
                       {1, 1, 1, 0, 0, E} };
    solveMaze(maze, 2, 2, N, N);
    return 0;
}

它应该从S开始，应该在E中停止，我必须编写一个函数来完成这项工作，直到它到达E

第二个问题是它不会倒退，例如：

int main() {
    int maze[N][N] = { {S, 0, 1, 1, 1, 1},
                       {1, 0, 1, 0, 0, 1},
                       {1, 0, 1, 0, 0, 1},
                       {1, 0, 1, 0, 0, 1},
                       {1, 1, 1, X, 0, 1},
                       {0, 0, 0, 0, 0, E} };
    solveMaze(maze, 2, 2, N, N);
    return 0;
  }

在这里，我的程序将转到X（X在这里只有1个矩阵，我写X来告诉你我的确切意思）首先（如果我们考虑第一个问题被解决，它可以自动移动），那么它将检查它的四个邻居，并且它们都是0。我想要的是，它回到1，然后从那里继续。如果一切正常，它应该向上移动，输出应该如下所示：

 S  0  1  1  1  1
 1  0  1  0  0  1
 1  0  1  0  0  1
 1  0  1  0  0  1
 1  1  1  0  0  1
 0  0  0  0  0  E

不是这样的：

 S  0  0  0  0  0
 1  0  0  0  0  0
 1  0  0  0  0  0
 1  0  0  0  0  0
 1  1  1  1  0  0
 0  0  0  0  0  E

---

第一步：找到HelloWorld并使其运行和输出。第二步：读取。很多从这里开始，，，*\u搜索算法第三步：编写一个实际了解迷宫的程序。例如，具有包含墙/路径信息的数据结构，并且能够输出迷宫，以便进行调试。第四步：从非常小的迷宫开始，例如2x2和3x3，编写简单的暴力方法。感谢您的帮助，这是我的家庭作业。我的课上没有任何算法课程。他们只教我们基本的C语言，我们刚刚在两周内完成了指针，这是你可以看到的家庭作业。谢谢你，伙计。有没有办法不用任何算法来解决这个问题？第一步：找到HelloWorld并让它运行并输出。第二步：阅读。很多从这里开始，，，*\u搜索算法第三步：编写一个实际了解迷宫的程序。例如，具有包含墙/路径信息的数据结构，并且能够输出迷宫，以便进行调试。第四步：从非常小的迷宫开始，例如2x2和3x3，编写简单的暴力方法。感谢您的帮助，这是我的家庭作业。我的课上没有任何算法课程。他们只教我们基本的C语言，我们刚刚在两周内完成了指针，这是你可以看到的家庭作业。谢谢你，伙计。没有任何算法，有没有办法解决这个问题？

 S  0  1  1  1  1
 1  0  1  0  0  1
 1  0  1  0  0  1
 1  0  1  0  0  1
 1  1  1  0  0  1
 0  0  0  0  0  E

 S  0  0  0  0  0
 1  0  0  0  0  0
 1  0  0  0  0  0
 1  0  0  0  0  0
 1  1  1  1  0  0
 0  0  0  0  0  E