Execution of All Suffix Instructions Staying in a Grid LeetCode solution in Rust

1
use std::collections::HashMap;
2

3
impl Solution {
4
  pub fn execute_instructions(n: i32, start_pos: Vec<i32>, s: String) -> Vec<i32> {
5
    let mut row_map: HashMap<i32, Vec<i32>> = HashMap::new();
6
    let mut col_map: HashMap<i32, Vec<i32>> = HashMap::new();
7
    row_map.insert(0, vec![0]);
8
    col_map.insert(0, vec![0]);
9
    let mut x = 0;
10
    let mut y = 0;
11
    let mut ans = vec![i32::MIN; s.len()];
12
    for i in 0..=s.len() {
13
      let v = if i == s.len() {
14
        row_map
15
          .drain()
16
          .chain(col_map.drain())
17
          .flat_map(|(_, v)| v)
18
          .collect()
19
      } else {
20
        match s.as_bytes()[i] {
21
          b'U' => {
22
            x -= 1;
23
            row_map
24
              .remove(&(x + start_pos[0] + 1))
25
              .unwrap_or(Vec::new())
26
          }
27
          b'D' => {
28
            x += 1;
29
            row_map
30
              .remove(&(x + start_pos[0] - n))
31
              .unwrap_or(Vec::new())
32
          }
33
          b'L' => {
34
            y -= 1;
35
            col_map
36
              .remove(&(y + start_pos[1] + 1))
37
              .unwrap_or(Vec::new())
38
          }
39
          b'R' => {
40
            y += 1;
41
            col_map
42
              .remove(&(y + start_pos[1] - n))
43
              .unwrap_or(Vec::new())
44
          }
45
          _ => unreachable!(),
46
        }
47
      };
48
      if i < s.len() - 1 {
49
        row_map.entry(x).or_insert(Vec::new()).push(i as i32 + 1);
50
        col_map.entry(y).or_insert(Vec::new()).push(i as i32 + 1);
51
      }
52
      for j in v.into_iter() {
53
        if ans[j as usize] == i32::MIN {
54
          ans[j as usize] = i as i32 - j;
55
        }
56
      }
57
    }
58
    ans
59
  }
60
}