Algorithm 网格中移动的机器人

机器人位于4x4网格的左上角。 机器人可以上下左右移动，但不能两次访问同一地点。 机器人正试图到达网格的右下角。它到达网格右下角的方式有几种

---

现在我知道，如果机器人只能向下或向右移动，那么答案将是8C4，因为它必须向右移动4格，向下移动4格，以任何顺序

但是我在解决这个问题时遇到了困难，因为机器人可以向左和向上移动

---

我只需要一个提示来解决这个问题！我应该如何处理这个问题？

您可以编写一个递归程序，计算所有可能的路径，每当它到达右下角时，它就会增加路径数。我写了一些东西，但我没有测试它。（可以将其视为伪代码，为您提供一个开始）。基本上，这是在当前位置（0，0）上调用moveRobot函数，其中包含一个空字段（机器人尚未移动）。然后它试着上下左右移动。该运动在相应的功能中进行了描述。如果其中一个移动成功（或不止一个），则新位置将在字段中标记为1，而不是0。1表示机器人已通过该位置。然后你再给移动机器人打电话。这是因为在新的位置上，你想再次尝试所有四个动作

主要功能：

int field[4][4];
for (int i = 0; i < 4; i++)
    for (int j = 0; j < 4; j++)
        field[i][j] = 0;
field[0][0] = 1;
numPaths = 0;
moveRobot(0, 0, field);
print numPaths;

moveRobot(int row, int column, int[][] field)
{
    moveRobotUp(row, column, field);
    moveRobotDown(row, column, field);
    moveRobotLeft(row, column, field);
    moveRobotRight(row, column, field);
}

其他职能：

moveRobotUp(int row, int column, int[][] field)
{
    if (row == 0) return;
    else 
    {
        if (field[row-1][column] == 1) return;
        field[row-1][column] = 1;
        moveRobot(row-1, column, field);
        field[row-1][column] = 0;
    }
}

moveRobotDown(int row, int column, int[][] field)
{
    if (row == 3 && column == 3) 
    {
        numPaths++;
        return;
    }
    else if (row == 3) return;
    else
    {
        if (field[row+1][column] == 1) return;
        field[row+1][column] = 1;
        moveRobot(row+1, column, field);
        field[row+1][column] = 0;
    }
}

moveRobotLeft(int row, int column, int[][] field)
{
    if (column == 0) return;
    else
    {
        if (field[row][column-1] == 1) return;
        field[row][column-1] = 1;
        moveRobot(row, column-1, field);
        field[row][column-1] = 0;
    }
}

moveRobotRight(int row, int column, int[][] field)
{
    if (column == 3 && row == 3) 
    {
        numPaths++;
        return;
    }
    else if (column == 3) return;
    else 
    {
        if (field[row][column+1] == 1) return;
        field[row][column+1] = 1;
        moveRobot(row, column+1, field);
        field[row][column+1] = 0;
    }
}

---

几行递归就能解决这个问题

    public static int WaysToExit(int x, int y)
    {
        if (x==0 || y == 0)
        {
            return 1;
        }
        else
        {
            return (WaysToExit(x - 1, y) + WaysToExit(x , y-1));
        }
    }

---

这很好用。答案是184

public class RobotMovementProblem 
{
    public static void main(String[] args) 
    {
        int grid[][]=new int[4][4];
        System.out.println(countPaths(grid, 0, 0));
    }
    static int countPaths(int grid[][],int i,int j)
    {

        if ( i < 0 || j < 0 || i >= 4 || j >= 4 ) return 0;
        if ( grid[i][j] == 1 ) return 0;
        if ( i == 3 && j == 3 ) return 1;
        int arr[][]=new int[4][4];
        for(int m=0;m<4;m++)
        {
            for(int n=0;n<4;n++)
            {
                arr[m][n]=grid[m][n];
            }
        }

        arr[i][j] = 1;
        return countPaths(arr, i, j+1) + countPaths(arr, i, j-1) +  countPaths(arr, i+1, j) + countPaths(arr, i-1, j);  
    }
}

公共类机器人移动问题
{
公共静态void main（字符串[]args）
{
整数网格[][]=新整数[4][4]；
System.out.println（countpath（grid，0，0））；
}
静态整数计数路径（整数网格[]，整数i，整数j）
{
如果（i<0 | | j<0 | | i>=4 | | j>=4）返回0；
如果（grid[i][j]==1）返回0；
如果（i==3&&j==3）返回1；
int arr[][]=新int[4][4]；
对于（int m=0；m）和2x2，只有两条路径。那么3x3呢？“现在我知道，如果机器人只能向下或向右移动，那么答案将是8C4，因为它必须向右移动4个方块，向下移动4个方块，以任何顺序。”我不明白，如果机器人只能左右移动，它仍然有很多不同的方式到达右下角，不是吗？@user2227862写这篇文章需要半个多小时，但应该是可行的。今晚我会试试（这里是EU）您忘记在返回轨道上将单元格重置为零。此外，除了五个单独的函数外，只有一个广义函数就足够了，移动描述为坐标偏移（±1,0），（0，±1）。谢谢你的评论。我试着按照你说的重置单元格。你认为我做得对吗？我不太擅长递归…如果有更多内容需要编辑，请随意操作：）
public class RobotMovementProblem 
{
    public static void main(String[] args) 
    {
        int grid[][]=new int[4][4];
        System.out.println(countPaths(grid, 0, 0));
    }
    static int countPaths(int grid[][],int i,int j)
    {

        if ( i < 0 || j < 0 || i >= 4 || j >= 4 ) return 0;
        if ( grid[i][j] == 1 ) return 0;
        if ( i == 3 && j == 3 ) return 1;
        int arr[][]=new int[4][4];
        for(int m=0;m<4;m++)
        {
            for(int n=0;n<4;n++)
            {
                arr[m][n]=grid[m][n];
            }
        }

        arr[i][j] = 1;
        return countPaths(arr, i, j+1) + countPaths(arr, i, j-1) +  countPaths(arr, i+1, j) + countPaths(arr, i-1, j);  
    }
}