检查给定的移动序列是否在无限重复时是圆形的

给定一个字符串str表示一系列移动。任务是检查移动是否重复无限次，然后移动是否会被绑定在圆形路径中。运动可以是以下类型：

• “G”：直走1个单位；
• “L”：向左转90度；
• “R”：向右转 90 度。

例子：

Input: str = “GGLLGG”
Output: true
Explanation: The movements are: (0, 0) to (0, 2); turn 180 degrees; and then returns to (0, 0).
When repeating these instructions, the movements are bounded in a circular path.

Input: str = “GG”
Output: false
Explanation: The moves will go infinitely in forward direction only.

Input: str = “GL”
Output: true
Explanation: The moves upon infinite repetition are
from (0, 0) -> (0, 1) -> (-1, 1) -> (-1, 0) -> (0, 0) -> . . .
Thus bounded in this circular path.

方法：在任何移动中，一个人可以面向“北”、“南”、“东”和“西”四个方向中的任何一个。这个想法是考虑最初站在(0, 0) 位置并面向 North 。由于指令被无限次发出，如果在一些指令后返回起点，运动将导致循环路径。

这只有在一个指令后改变方向或返回原点时才有可能。

               N

              |

              |

 W ————– E

              |

              |

              S 

要在每条指令后计算出机器人的位置和方向，请根据方向从其位置添加或减去某些值。

这是每个方向的方向和运动的样子：

Direction	Add	L	R
North	(0, 1)	West	East
West	(-1, 0)	South	North
East	(1, 0)	North	South
South	(0, -1)	East	West

请按照以下步骤操作。

• 以向量的形式存储方向。由于初始位置在(0, 0) ，因此沿逆时针方向取方向以计算下一个位置。所以，向量是{N, W, S, E} 。
• 将i 初始化为 0以跟踪旋转。这里，0 代表初始方向。如果在执行结束时为0，并且该位置不是起始位置，则该函数将返回false。
• 将x 和 y 初始化为 0 ，因为它的初始位置是 (0, 0)。
• 运行一个循环以逐个遍历指令。
• 检查向右或向左旋转。将i向左旋转增加 1 ，向右旋转增加 3 。 （3 代表右转，因为右转 1 次等于左转 3 次，这里的方向被认为是逆时针方向）
• 如果它是直的，则从对应于第 i^个方向的向量中添加x 和 y的值。
• 结束循环。
• 检查运动是否导致回到起始位置或方向不是起始方向。如果这两个条件中的任何一个为真，则返回真。否则，返回假。

下面是上述方法的实现。

C++

// C++ code to implement above approach
#include 
using namespace std;
 
// Function to check if the movements
// are repeated infinite times then
// it will be bounded in circular path or not
void isRobotBounded(string str)
{
    vector > dir
        = { { 0, 1 }, { -1, 0 }, { 0, -1 }, { 1, 0 } };
    int i = 0;
    int x = 0;
    int y = 0;
 
    for (int s = 0; s < str.size(); s++) {
        if (str.at(s) == 'L') {
            i = (i + 1) % 4;
        }
        else if (str.at(s) == 'R') {
            i = (i + 3) % 4;
        }
        else {
            x = x + dir[i][0];
            y = y + dir[i][1];
        }
    }
    if (x == 0 && y == 0 || i != 0)
        cout << "true";
    else
        cout << "false";
}
 
// Driver code
int main()
{
    string str = "GGLLGG";
 
    isRobotBounded(str);
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
 
  // Function to check if the movements
  // are repeated infinite times then
  // it will be bounded in circular path or not
  static void isRobotBounded(String str)
  {
    int[][] dir
      = { { 0, 1 }, { -1, 0 }, { 0, -1 }, { 1, 0 } };
    int i = 0;
    int x = 0;
    int y = 0;
 
    for (int s = 0; s < str.length(); s++) {
      if (str.charAt(s) == 'L') {
        i = (i + 1) % 4;
      }
      else if (str.charAt(s) == 'R') {
        i = (i + 3) % 4;
      }
      else {
        x = x + dir[i][0];
        y = y + dir[i][1];
      }
    }
    if (x == 0 && y == 0 || i != 0)
      System.out.println("true");
    else
      System.out.println("false");
  }
 
  // Driver code
  public static void main (String[] args) {
    String str = "GGLLGG";
 
    isRobotBounded(str);
 
  }
}
 
 
// This code is contributed by hrithikgarg03188.

Python3

# Python code for the above approach
 
# Function to check if the movements
# are repeated infinite times then
# it will be bounded in circular path or not
def isRobotBounded(str):
    dir = [[0, 1], [-1, 0], [0, -1], [1, 0]]
    i = 0
    x = 0
    y = 0
 
    for s in range(len(str)):
        if (str[s] == 'L'):
            i = (i + 1) % 4
        elif(str[s] == 'R'):
            i = (i + 3) % 4
        else:
            x = x + dir[i][0]
            y = y + dir[i][1]
    if (x == 0 and y == 0 or i != 0):
        print("true")
    else:
        print("false")
 
# Driver code
str = "GGLLGG"
isRobotBounded(str)
 
# This code is contributed by Saurabh Jaiswal

C#

// C# code to implement above approach
using System;
class GFG
{
 
  // Function to check if the movements
  // are repeated infinite times then
  // it will be bounded in circular path or not
  static void isRobotBounded(string str)
  {
    int [,]dir
      = { { 0, 1 }, { -1, 0 }, { 0, -1 }, { 1, 0 } };
    int i = 0;
    int x = 0;
    int y = 0;
 
    for (int s = 0; s < str.Length; s++) {
      if (str[s] == 'L') {
        i = (i + 1) % 4;
      }
      else if (str[s] == 'R') {
        i = (i + 3) % 4;
      }
      else {
        x = x + dir[i, 0];
        y = y + dir[i, 1];
      }
    }
    if (x == 0 && y == 0 || i != 0)
      Console.Write("true");
    else
      Console.Write("false");
  }
 
  // Driver code
  public static void Main()
  {
    string str = "GGLLGG";
 
    isRobotBounded(str);
  }
}
 
// This code is contributed by Samim Hossain Mondal.

Javascript

        // JavaScript code for the above approach
 
        // Function to check if the movements
        // are repeated infinite times then
        // it will be bounded in circular path or not
        function isRobotBounded(str)
        {
            let dir
                = [[0, 1], [-1, 0], [0, -1], [1, 0]];
            let i = 0;
            let x = 0;
            let y = 0;
 
            for (let s = 0; s < str.length; s++) {
                if (str[s] == 'L') {
                    i = (i + 1) % 4;
                }
                else if (str[s] == 'R') {
                    i = (i + 3) % 4;
                }
                else {
                    x = x + dir[i][0];
                    y = y + dir[i][1];
                }
            }
            if (x == 0 && y == 0 || i != 0)
                document.write("true")
            else
                document.write("false")
        }
 
        // Driver code
        let str = "GGLLGG";
        isRobotBounded(str);
 
         // This code is contributed by Potta Lokesh
    

输出

true

时间复杂度： O(N) 其中 N 是字符串的长度
辅助空间： O(1)