Path Crossing

Path Crossing - Problem

Given a string path, where path[i] = 'N', 'S', 'E' or 'W', each representing moving one unit north, south, east, or west, respectively. You start at the origin (0, 0) on a 2D plane and walk on the path specified by path.

Return true if the path crosses itself at any point, that is, if at any time you are on a location you have previously visited. Return false otherwise.

Input & Output

Example 1 — Path Crosses Itself

$ Input: path = "NEESW"

› Output: false

💡 Note: Start at (0,0). Move N→(0,1), E→(1,1), E→(2,1), S→(2,0), W→(1,0). All positions are unique, so the path does not cross itself.

Example 2 — Simple Loop

$ Input: path = "NEEWS"

› Output: true

💡 Note: Start at (0,0)→N to (0,1)→E to (1,1)→E to (2,1)→W to (1,1)→S to (1,0). After W, we return to (1,1) which we visited before.

Example 3 — No Crossing

$ Input: path = "NES"

› Output: false

💡 Note: Start at (0,0)→N to (0,1)→E to (1,1)→S to (1,0). All positions are unique: (0,0), (0,1), (1,1), (1,0).

Constraints

1 ≤ path.length ≤ 10⁴
path[i] is either 'N', 'S', 'E', or 'W'

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

The key insight is to track visited positions and detect when we return to a previously visited location. Best approach uses a hash set for O(1) position lookups. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force with List

⏱️ Time: O(n²) Space: O(n)

Track every position visited in a list. For each new position, check if it already exists in the list by scanning through all previous positions.

Hash Set Optimization

⏱️ Time: O(n) Space: O(n)

Store visited positions in a hash set instead of a list. This allows constant time lookup to check if a position has been visited before, dramatically improving performance.

Brute Force with List — Algorithm Steps

Step 1: Start at origin (0,0) and add to visited list
Step 2: For each direction, move to new position
Step 3: Check if new position exists in visited list
Step 4: If found, return true; otherwise add to list

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Origin

Begin at (0,0) and add to visited list

Move and Check

For each move, scan entire visited list

Found Duplicate

Return true when position found in list

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

typedef struct {
    int x, y;
} Point;

bool solution(char* path) {
    Point visited[10001];  // Max possible positions
    int visitedCount = 1;
    visited[0] = (Point){0, 0};  // Start at origin
    int x = 0, y = 0;
    
    int len = strlen(path);
    for (int i = 0; i < len; i++) {
        char direction = path[i];
        
        // Move based on direction
        if (direction == 'N') {
            y += 1;
        } else if (direction == 'S') {
            y -= 1;
        } else if (direction == 'E') {
            x += 1;
        } else if (direction == 'W') {
            x -= 1;
        }
        
        // Check if we've been here before (brute force search)
        for (int j = 0; j < visitedCount; j++) {
            if (visited[j].x == x && visited[j].y == y) {
                return true;
            }
        }
        
        visited[visitedCount++] = (Point){x, y};
    }
    
    return false;
}

int main() {
    char path[10001];
    fgets(path, sizeof(path), stdin);
    path[strcspn(path, "\n")] = 0;  // Remove newline
    
    bool result = solution(path);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n moves, we scan the visited list which can have up to n positions

✓ Linear Growth

Space Complexity

O(n)

List stores up to n+1 positions (including starting position)

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~8 min Avg. Time

845 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with List — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler