complete 24392.rs 24819.rs

storage/zeta/rs/completed/24392.rs

@@ -0,0 +1,74 @@
+use std::io::stdin;
+
+enum Pane {
+    Normal,
+    Reinforced,
+}
+
+fn main() {
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+
+    let mut iter = line.trim().split(' ').map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+    let m = iter.next().unwrap();
+
+    let panes = (0..n)
+        .map(|_| {
+            line.clear();
+            stdin().read_line(&mut line).unwrap();
+            line.split(' ')
+                .map(|x| match x.chars().next().unwrap() {
+                    '0' => Pane::Normal,
+                    '1' => Pane::Reinforced,
+                    _ => unreachable!(),
+                })
+                .collect::<Vec<Pane>>()
+        })
+        .collect::<Vec<Vec<Pane>>>()
+        .into_iter()
+        .rev()
+        .collect::<Vec<Vec<Pane>>>();
+
+    /*
+       Calc All Possible Paths
+    */
+
+    let mut dp = vec![vec![0u64; m]; n];
+
+    panes[0]
+        .iter()
+        .enumerate()
+        .for_each(|(i, pane)| match pane {
+            Pane::Normal => dp[0][i] = 0,
+            Pane::Reinforced => dp[0][i] = 1,
+        });
+
+    for i in 1..n {
+        for j in 1..(m - 1) {
+            dp[i][j] = match panes[i][j] {
+                Pane::Normal => 0,
+                Pane::Reinforced => {
+                    let left = dp[i - 1][j - 1];
+                    let right = dp[i - 1][j + 1];
+                    let centre = dp[i - 1][j];
+                    (left + right + centre) % 1_000_000_007
+                }
+            };
+        }
+        dp[i][0] = match panes[i][0] {
+            Pane::Normal => 0,
+            Pane::Reinforced => (dp[i - 1][0] + dp[i - 1][1]) % 1_000_000_007,
+        };
+        dp[i][m - 1] = match panes[i][m - 1] {
+            Pane::Normal => 0,
+            Pane::Reinforced => (dp[i - 1][m - 2] + dp[i - 1][m - 1]) % 1_000_000_007,
+        }
+    }
+
+    let res = dp[n - 1]
+        .iter()
+        .fold(0u64, |acc, x| (acc + x) % 1_000_000_007);
+    println!("{}", res);
+}

storage/zeta/rs/completed/24819.rs

@@ -0,0 +1,129 @@
+use std::{collections::VecDeque, io::stdin};
+
+enum PlaceState {
+    Start,
+    Safe,
+    SafeFromUp,
+    SafeFromDown,
+    SafeFromLeft,
+    SafeFromRight,
+    Unsafe,
+}
+
+fn minimum_steps_to_get_out(places: &Vec<Vec<PlaceState>>, starting_point: (usize, usize)) -> i64 {
+    let n = places.len();
+    let m = places[0].len();
+
+    let mut vis = vec![vec![false; m]; n];
+
+    let mut deq: VecDeque<((usize, usize), i64)> = VecDeque::new();
+    deq.push_back((starting_point, 0));
+
+    while !deq.is_empty() {
+        let ((r, c), step) = deq.pop_front().unwrap();
+
+        if r == n - 1 || r == 0 || c == 0 || c == m - 1 {
+            return step;
+        }
+
+        if r >= 1 {
+            match &places[r - 1][c] {
+                PlaceState::Safe | PlaceState::SafeFromDown => {
+                    if !vis[r - 1][c] {
+                        if r - 1 == 0 {
+                            return step + 1;
+                        }
+                        vis[r - 1][c] = true;
+                        deq.push_back(((r - 1, c), step + 1));
+                    }
+                }
+                _ => {}
+            }
+        }
+        if r + 1 < n {
+            match &places[r + 1][c] {
+                PlaceState::Safe | PlaceState::SafeFromUp => {
+                    if !vis[r + 1][c] {
+                        if r + 1 == n - 1 {
+                            return step + 1;
+                        }
+                        vis[r + 1][c] = true;
+                        deq.push_back(((r + 1, c), step + 1));
+                    }
+                }
+                _ => {}
+            }
+        }
+        if c >= 1 {
+            match &places[r][c - 1] {
+                PlaceState::Safe | PlaceState::SafeFromRight => {
+                    if !vis[r][c - 1] {
+                        if c - 1 == 0 {
+                            return step + 1;
+                        }
+                        vis[r][c - 1] = true;
+                        deq.push_back(((r, c - 1), step + 1));
+                    }
+                }
+                _ => {}
+            }
+        }
+        if c + 1 < m {
+            match &places[r][c + 1] {
+                PlaceState::Safe | PlaceState::SafeFromLeft => {
+                    if !vis[r][c + 1] {
+                        if c + 1 == m - 1 {
+                            return step + 1;
+                        }
+                        vis[r][c + 1] = true;
+                        deq.push_back(((r, c + 1), step + 1));
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    -1
+}
+
+fn main() {
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+
+    let mut iter = line.split(' ').map(|x| x.trim().parse::<usize>().unwrap());
+
+    let t = iter.next().unwrap();
+    let n = iter.next().unwrap();
+    let m = iter.next().unwrap(); // suppress unused variable warning
+    let mut starting_point = (0, 0);
+    let places = (0..n)
+        .map(|i| {
+            line.clear();
+            stdin().read_line(&mut line).unwrap();
+            line.trim()
+                .chars()
+                .enumerate()
+                .map(|(j, c)| match c {
+                    'S' => {
+                        starting_point = (i, j);
+                        PlaceState::Start
+                    }
+                    '0' => PlaceState::Safe,
+                    '1' => PlaceState::Unsafe,
+                    'U' => PlaceState::SafeFromUp,
+                    'D' => PlaceState::SafeFromDown,
+                    'L' => PlaceState::SafeFromLeft,
+                    'R' => PlaceState::SafeFromRight,
+                    _ => unreachable!(),
+                })
+                .collect::<Vec<PlaceState>>()
+        })
+        .collect::<Vec<Vec<PlaceState>>>();
+    let result = minimum_steps_to_get_out(&places, starting_point);
+    if result < 0 || result > t as i64 {
+        println!("NOT POSSIBLE");
+    } else {
+        println!("{}", result);
+    }
+}