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 = [x`

, which you are trying to get to. There are several ghosts on the map with their starting positions given as an array _{target}, y_{target}]`ghosts`

, where `ghosts[i] = [x`

represents the starting position of the _{i}, y_{i}]`i`

ghost. All inputs are ^{th}**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, otherwise return *`false`

*.*

**Example 1:**

Input:ghosts = [[1,0],[0,3]], target = [0,1]Output:trueExplanation: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:falseExplanation: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:falseExplanation:The ghost can reach the target at the same time as you.

**Example 4:**

Input:ghosts = [[5,0],[-10,-2],[0,-5],[-2,-2],[-7,1]], target = [7,7]Output:false

**Example 5:**

Input:ghosts = [[-1,0],[0,1],[-1,0],[0,1],[-1,0]], target = [0,0]Output:true

**Constraints:**

`1 <= ghosts.length <= 100`

`ghosts[i].length == 2`

`-10`

^{4}<= x_{i}, y_{i}<= 10^{4}- There can be
**multiple ghosts**in the same location. `target.length == 2`

`-10`

^{4}<= x_{target}, y_{target}<= 10^{4}

```
struct Solution;
impl Solution {
fn escape_ghosts(ghosts: Vec<Vec<i32>>, target: Vec<i32>) -> bool {
let min = Self::dist(&target, &[0, 0]);
for ghost in &ghosts {
if Self::dist(ghost, &target) <= min {
return false;
}
}
true
}
fn dist(a: &[i32], b: &[i32]) -> i32 {
(a[0] - b[0]).abs() + (a[1] - b[1]).abs()
}
}
#[test]
fn test() {
let ghosts = vec_vec_i32![[1, 0], [0, 3]];
let target = vec![0, 1];
let res = true;
assert_eq!(Solution::escape_ghosts(ghosts, target), res);
let ghosts = vec_vec_i32![[1, 0]];
let target = vec![2, 0];
let res = false;
assert_eq!(Solution::escape_ghosts(ghosts, target), res);
let ghosts = vec_vec_i32![[2, 0]];
let target = vec![1, 0];
let res = false;
assert_eq!(Solution::escape_ghosts(ghosts, target), res);
}
```