## Algorithm

Problem Name: 789. Escape The Ghosts

You are playing a simplified PAC-MAN game on an infinite 2-D grid. You start at the point `[0, 0]`, and you are given a destination point `target = [xtarget, ytarget]` that you are trying to get to. There are several ghosts on the map with their starting positions given as a 2D array `ghosts`, where `ghosts[i] = [xi, yi]` represents the starting position of the `ith` ghost. All inputs are integral coordinates.

Each turn, you and all the ghosts may independently choose to either move 1 unit in any of the four cardinal directions: north, east, south, or west, or stay still. All actions happen simultaneously.

You escape if and only if you can reach the target before any ghost reaches you. If you reach any square (including the target) at the same time as a ghost, it does not count as an escape.

Return `true` if it is possible to escape regardless of how the ghosts move, otherwise return `false`.

Example 1:

```Input: ghosts = [[1,0],[0,3]], target = [0,1]
Output: true
Explanation: You can reach the destination (0, 1) after 1 turn, while the ghosts located at (1, 0) and (0, 3) cannot catch up with you.
```

Example 2:

```Input: ghosts = [[1,0]], target = [2,0]
Output: false
Explanation: You need to reach the destination (2, 0), but the ghost at (1, 0) lies between you and the destination.
```

Example 3:

```Input: ghosts = [[2,0]], target = [1,0]
Output: false
Explanation: The ghost can reach the target at the same time as you.
```

Constraints:

• `1 <= ghosts.length <= 100`
• `ghosts[i].length == 2`
• `-104 <= xi, yi <= 104`
• There can be multiple ghosts in the same location.
• `target.length == 2`
• `-104 <= xtarget, ytarget <= 104`

## Code Examples

### #1 Code Example with Java Programming

```Code - Java Programming```

``````
class Solution {
public boolean escapeGhosts(int[][] ghosts, int[] target) {
int[] currPos = {0, 0};
int selfDist = getDist(currPos, target);

for (int[] ghost : ghosts) {
int ghostDist = getDist(ghost, target);
if (ghostDist <= selfDist) {
return false;
}
}

return true;
}

private int getDist(int[] p1, int[] p2) {
return Math.abs(p1 - p2) + Math.abs(p1 - p2);
}
}
``````
Copy The Code &

Input

cmd
ghosts = [[1,0],[0,3]], target = [0,1]

Output

cmd
true

### #2 Code Example with Javascript Programming

```Code - Javascript Programming```

``````
var escapeGhosts = function(ghosts, target) {
let res = true
const { abs } = Math, steps = abs(target) + abs(target)
const [tx, ty] = target
for(const [x, y] of ghosts) {
if(abs(tx - x) + abs(ty - y) <= steps) return false
}

return res
};
``````
Copy The Code &

Input

cmd
ghosts = [[1,0],[0,3]], target = [0,1]

Output

cmd
true

### #3 Code Example with Python Programming

```Code - Python Programming```

``````
class Solution:
def escapeGhosts(self, ghosts, target):
d = abs(target) + abs(target)
for ghost in ghosts:
if abs(ghost - target) + abs(ghost - target) <= d: return False
return True
``````
Copy The Code &

Input

cmd
ghosts = [[1,0]], target = [2,0]

Output

cmd
false