1041. 困于环中的机器人

在无限的平面上，机器人最初位于 (0, 0) 处，面朝北方。注意:

• 北方向 是y轴的正方向。
• 南方向 是y轴的负方向。
• 东方向 是x轴的正方向。
• 西方向 是x轴的负方向。

机器人可以接受下列三条指令之一：

• "G"：直走 1 个单位
• "L"：左转 90 度
• "R"：右转 90 度

机器人按顺序执行指令 instructions，并一直重复它们。

只有在平面中存在环使得机器人永远无法离开时，返回 true。否则，返回 false。

示例 1：

输入：instructions = "GGLLGG"
输出：true
解释：机器人最初在(0,0)处，面向北方。
“G”:移动一步。位置:(0,1)方向:北。
“G”:移动一步。位置:(0,2).方向:北。
“L”:逆时针旋转90度。位置:(0,2).方向:西。
“L”:逆时针旋转90度。位置:(0,2)方向:南。
“G”:移动一步。位置:(0,1)方向:南。
“G”:移动一步。位置:(0,0)方向:南。
重复指令，机器人进入循环:(0,0)——>(0,1)——>(0,2)——>(0,1)——>(0,0)。
在此基础上，我们返回true。

示例 2：

输入：instructions = "GG"
输出：false
解释：机器人最初在(0,0)处，面向北方。
“G”:移动一步。位置:(0,1)方向:北。
“G”:移动一步。位置:(0,2).方向:北。
重复这些指示，继续朝北前进，不会进入循环。
在此基础上，返回false。

示例 3：

输入：instructions = "GL"
输出：true
解释：机器人最初在(0,0)处，面向北方。
“G”:移动一步。位置:(0,1)方向:北。
“L”:逆时针旋转90度。位置:(0,1).方向:西。
“G”:移动一步。位置:(- 1,1)方向:西。
“L”:逆时针旋转90度。位置:(- 1,1)方向:南。
“G”:移动一步。位置:(- 1,0)方向:南。
“L”:逆时针旋转90度。位置:(- 1,0)方向:东方。
“G”:移动一步。位置:(0,0)方向:东方。
“L”:逆时针旋转90度。位置:(0,0)方向:北。
重复指令，机器人进入循环:(0,0)——>(0,1)——>(- 1,1)——>(- 1,0)——>(0,0)。
在此基础上，我们返回true。

代码

class Solution {
    public boolean isRobotBounded(String instructions) {
        // 'directionIndex' represents the current direction of the robot:
        // 0-Up, 1-Left, 2-Down, 3-Right
        // 'directionIndex' 表示机器人当前面朝的方向：
        // 0-向上，1-向左，2-向下，3-向右
        int directionIndex = 0;

        // 'distance' array stores the net distance moved in all 4 directions.
        // 'distance' 数组用来存储机器人在四个方向上移动的净距离
        int[] distance = new int[4];

        // Iterate over each instruction and update the direction or distance accordingly.
        // 遍历每一个指令，并根据指令更新方向或距离
        for (int i = 0; i < instructions.length(); ++i) {
            char currentInstruction = instructions.charAt(i);

            // If the instruction is 'L', it turns the robot 90 degrees to the left.
            // 如果指令是 'L'，机器人向左转90度
            if (currentInstruction == 'L') {
                directionIndex = (directionIndex + 1) % 4;
            } 
            // If the instruction is 'R', it turns the robot 90 degrees to the right.
            // 如果指令是 'R'，机器人向右转90度
            else if (currentInstruction == 'R') {
                directionIndex = (directionIndex + 3) % 4;
            } 
            // If the instruction is 'G', the robot moves forward one unit in the current direction.
            // 如果指令是 'G'，机器人在当前方向上前进一步
            else {
                distance[directionIndex]++;
            }
        }

        // The robot is bounded if:
        // 机器人被限制在某个范围内当以下条件满足时：
        // 1. It returns to the initial position (distance moved up equals down and left equals right).
        // 1. 它回到了初始位置（向上和向下的移动距离相等，向左和向右的移动距离相等）
        // 2. It is not facing north after processing all instructions.
        // 2. 执行完所有指令后它没有朝北，这时由于题干说机器人会一直循环重复，所以也不会重复走会一直画圈循环
        return (distance[0] == distance[2] && distance[1] == distance[3]) || (directionIndex != 0);
    }
}

一、先看 四个方向的编码

在这道题里，作者把机器人可能面朝的方向编码成数字：

方向	编码（directionIndex）
向上	0
向左	1
向下	2
向右	3

二、取模4的作用：让方向循环

机器人每次左转、右转，都要更新它的朝向。

1. 为什么用 % 4（取模4）

因为方向只有 4 种：

• 如果转了 4 次左，应该又回到原来的方向；

• 如果转了 5 次左，其实就是相当于转了 1 次左（5 % 4 == 1）；

• 取模可以自动让编号在 0 ~ 3 之间循环。

---

三、分别看左右转的更新公式

1. 向左转：

directionIndex = (directionIndex + 1) % 4;

• 因为左转是按顺时针逆向（Up→Left→Down→Right→Up）

• 每左转一次，编号 +1；

• 但要用 % 4 保证不超过 3，始终在 0 ~ 3 范围内循环。

举例：

• 原本朝上 (0)，左转一次 → (0+1)%4=1 → 朝左

• 再左转一次 → (1+1)%4=2 → 朝下

2. 向右转：

directionIndex = (directionIndex + 3) % 4;

你可能会疑惑：为啥不是 -1 ？

• 因为在 Java 里负数取模有点麻烦（可能出现负下标），所以用 +3 代替 -1：

(directionIndex - 1 + 4) % 4 等价于 (directionIndex + 3) % 4

举例：

• 原本朝上 (0)，右转一次 → (0+3)%4=3 → 朝右

• 再右转一次 → (3+3)%4=2 → 朝下

---

五、再顺便帮你画一下 distance[] 是怎么存储的：

int[] distance = new int[4]; // 方向 编号 作用 // Up 0 记录向上移动的步数 // Left 1 记录向左移动的步数 // Down 2 记录向下移动的步数 // Right 3 记录向右移动的步数

当遇到 G 指令时：

distance[directionIndex]++;

—— 就表示：在当前朝向上前进一步，把该方向累计的距离 +1。

---

六、最后总结你整段逻辑的核心

• 用 directionIndex 表示方向，方便控制转向

• 用 distance[] 记录在每个方向上的前进总步数

• 用 % 4 保证方向编号始终在 0~3 范围内循环

情况 ②：机器人没有面朝北

(directionIndex != 0)

含义是：

• directionIndex 记录了当前方向；

• 初始时机器人面朝北（directionIndex = 0）；

• 如果执行完所有指令后，机器人没有朝北（即方向不是0），哪怕它不在原点，但每次重复执行一遍指令，方向不断转圈，最终也不会无限远走。

👉 方向改变了 → 有界

（比如它始终在某个圈子里兜圈）

 

示例二：

instructions = "GG"

• 前两步 G：前进两步 → 向北 +2；

• 没有转向；

• 最后位置在(0,2)，方向仍然朝北（directionIndex = 0）。

结果：无界

因为以后再执行一次 GG，它会继续往北跑，不会回头。