Maximum Manhattan Distance After K Changes

Maximum Manhattan Distance After K Changes - Problem

Imagine you're controlling a robot on an infinite grid, starting at the origin (0, 0). You have a sequence of movement commands represented by a string s where each character tells the robot which direction to move:

'N': Move north (up) by 1 unit
'S': Move south (down) by 1 unit
'E': Move east (right) by 1 unit
'W': Move west (left) by 1 unit

Here's the twist: before executing the movement sequence, you can modify at most k characters in the string to any of the four directions. Your goal is to maximize the Manhattan distance from the origin that the robot reaches at any point during its journey.

The Manhattan distance between two points (x₁, y₁) and (x₂, y₂) is |x₁ - x₂| + |y₁ - y₂|.

Key insight: You want to strategically change some moves to make the robot travel as far as possible from the origin at some point during its path, not necessarily at the end.

Input & Output

example_1.py — Basic Example

$ Input: s = "NESE", k = 1

› Output: 4

💡 Note: Original path: (0,0)→(0,1)→(1,1)→(1,0)→(2,0), max distance = 2. Change S to N: (0,0)→(0,1)→(1,1)→(1,2)→(2,2), max distance = 4.

example_2.py — Multiple Changes

$ Input: s = "NSEW", k = 2

› Output: 4

💡 Note: Original path reaches max distance 1. Change N→E and S→E to get "EEEW": (0,0)→(1,0)→(2,0)→(3,0)→(2,0), max distance = 3. Better: change N→E and W→E to get "ESEE": (0,0)→(1,0)→(1,-1)→(2,-1)→(3,-1), max distance = 4.

example_3.py — No Changes Needed

$ Input: s = "NNNN", k = 0

› Output: 4

💡 Note: Already optimal path going straight North: (0,0)→(0,1)→(0,2)→(0,3)→(0,4), max distance = 4.

Visualization

Tap to expand

Understanding the Visualization

Track Original Path

Calculate where the robot would be after each move using prefix sums

Evaluate Modifications

For each move, consider changing it and calculate the distance improvement

Select Best Changes

Greedily choose the k modifications that provide maximum distance gain

Simulate Final Path

Execute the optimized sequence and find the maximum distance reached

Key Takeaway

🎯 Key Insight: Use prefix sums to efficiently calculate position changes and greedily select modifications that maximize the furthest distance reached during the journey, not just the final position.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to calculate prefix sums, O(n log n) to sort potential improvements

⚡ Linearithmic

Space Complexity

O(n)

Space for storing prefix sums and improvement candidates

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
0 ≤ k ≤ s.length
s consists only of characters 'N', 'S', 'E', 'W'
The string represents a valid sequence of moves

Asked in

G Google 42 f Meta 35 a Amazon 28 ⊞ Microsoft 22

The optimal solution uses prefix sums to efficiently track the robot's position after each move, then applies a greedy strategy to identify which moves to change for maximum distance improvement. Key insight: calculate the improvement each potential change would provide and select the top k changes that maximize the Manhattan distance reached at any point during the journey.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum + Greedy (Optimal)	O(n log n)	O(n)	Use prefix sums to track positions and greedily change moves that maximize distance
Brute Force (Try All Combinations)	O(C(n,k) * 4^k * n)	O(n)	Try every possible combination of k character changes and simulate each path

Prefix Sum + Greedy (Optimal) — Algorithm Steps

Calculate prefix sums for x and y coordinates after each move
For each position, calculate the current Manhattan distance
Identify moves that, when changed, would increase the maximum distance most
Greedily select the k best changes to make
Return the maximum distance achievable with these changes

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Prefix Sums

Track cumulative x,y positions after each move

Evaluate Changes

For each possible change, calculate improvement in distance

Greedy Selection

Select the k changes that provide maximum improvement

Code -

solution.c — C

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

typedef struct {
    int value;
    int position;
    char newChar;
} Improvement;

int compare(const void* a, const void* b) {
    return ((Improvement*)b)->value - ((Improvement*)a)->value;
}

int maxManhattanDistance(char* s, int k) {
    int n = strlen(s);
    
    int* prefixX = (int*)calloc(n + 1, sizeof(int));
    int* prefixY = (int*)calloc(n + 1, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        prefixX[i + 1] = prefixX[i];
        prefixY[i + 1] = prefixY[i];
        
        switch (s[i]) {
            case 'N': prefixY[i + 1]++; break;
            case 'S': prefixY[i + 1]--; break;
            case 'E': prefixX[i + 1]++; break;
            case 'W': prefixX[i + 1]--; break;
        }
    }
    
    Improvement* improvements = (Improvement*)malloc(n * 12 * sizeof(Improvement));
    int improvementCount = 0;
    
    char directions[] = {'N', 'S', 'E', 'W'};
    
    for (int i = 0; i < n; i++) {
        char currentChar = s[i];
        
        for (int d = 0; d < 4; d++) {
            char newChar = directions[d];
            if (newChar == currentChar) continue;
            
            int dx = 0, dy = 0;
            switch (currentChar) {
                case 'N': dy--; break;
                case 'S': dy++; break;
                case 'E': dx--; break;
                case 'W': dx++; break;
            }
            
            switch (newChar) {
                case 'N': dy++; break;
                case 'S': dy--; break;
                case 'E': dx++; break;
                case 'W': dx++; break;
            }
            
            int maxImprovement = 0;
            for (int j = i + 1; j <= n; j++) {
                int oldDist = abs(prefixX[j]) + abs(prefixY[j]);
                int newDist = abs(prefixX[j] + dx) + abs(prefixY[j] + dy);
                int improvement = newDist - oldDist;
                if (improvement > maxImprovement) {
                    maxImprovement = improvement;
                }
            }
            
            improvements[improvementCount++] = (Improvement){maxImprovement, i, newChar};
        }
    }
    
    qsort(improvements, improvementCount, sizeof(Improvement), compare);
    
    for (int i = 0; i < k && i < improvementCount; i++) {
        if (improvements[i].value > 0) {
            s[improvements[i].position] = improvements[i].newChar;
        }
    }
    
    int x = 0, y = 0, maxDist = 0;
    for (int i = 0; i < n; i++) {
        switch (s[i]) {
            case 'N': y++; break;
            case 'S': y--; break;
            case 'E': x++; break;
            case 'W': x--; break;
        }
        int dist = abs(x) + abs(y);
        if (dist > maxDist) maxDist = dist;
    }
    
    free(prefixX);
    free(prefixY);
    free(improvements);
    return maxDist;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to calculate prefix sums, O(n log n) to sort potential improvements

⚡ Linearithmic

Space Complexity

O(n)

Space for storing prefix sums and improvement candidates

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
0 ≤ k ≤ s.length
s consists only of characters 'N', 'S', 'E', 'W'
The string represents a valid sequence of moves

47.2K Views

Medium Frequency

~25 min Avg. Time

1.3K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Prefix Sum + Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler