night_match_27

Author: caibirdme

src/lib.rs

@@ -433,6 +433,7 @@ mod crack_code_interview;
 mod sort;
 mod kmp;
 mod trans_tree;
+mod night_match_27;
 #[cfg(test)]
 mod tests {
     #[test]

src/night_match_27/mod.rs

@@ -0,0 +1,3 @@
+mod prob_5409;
+mod prob_5410;
+mod prob_5411;

src/night_match_27/prob_5409.rs

@@ -0,0 +1,65 @@
+use std::collections::HashSet;
+
+impl Solution {
+    pub fn has_all_codes(s: String, k: i32) -> bool {
+        if s.is_empty() {
+            return false;
+        }
+        if k >= s.len() as i32 {
+            return false;
+        }
+        let bs = s.as_bytes();
+        if k == 1 {
+            let mut one = false ;
+            let mut zero = false;
+            for &c in bs {
+                if c == b'0' {
+                    zero = true;
+                } else {
+                    one = true;
+                }
+                if zero && one {
+                    return true;
+                }
+            }
+            return false;
+        }
+        let mut v = 0;
+        for i in 0..k as usize {
+            v = (v << 1) | ((bs[i]-b'0') as i32);
+        }
+        let mut hash = HashSet::new();
+        hash.insert(v);
+        let mask = (1 << (k-1)) - 1;
+        for i in k as usize..bs.len() {
+            v = ((v & mask) << 1) | ((bs[i]-b'0') as i32);
+            hash.insert(v);
+        }
+        for i in 0..=(1<<k)-1 {
+            if !hash.contains(&i) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_has_all_codes() {
+        let test_cases = vec![
+            ("00110", 2, true),
+            ("0110", 1, true),
+            ("0000000001011100", 4, false),
+            ("00110110", 2, true),
+        ];
+        for (s, k, ok) in test_cases {
+            assert_eq!(Solution::has_all_codes(s.to_string(), k), ok, "s:{}, k:{}", s,k);
+        }
+    }
+}

src/night_match_27/prob_5410.rs

@@ -0,0 +1,65 @@
+use std::collections::{HashMap, HashSet};
+
+impl Solution {
+    pub fn check_if_prerequisite(n: i32, prerequisites: Vec<Vec<i32>>, queries: Vec<Vec<i32>>) -> Vec<bool> {
+        let mut graph = HashMap::new();
+        for v in prerequisites.iter() {
+            let (to, from) = (v[0], v[1]);
+            graph.entry(from as usize).or_insert(HashSet::new()).insert(to as usize);
+        }
+        let mut father = HashMap::new();
+        for i in 0..n as usize {
+            let f = Self::get_father(n as usize, i, &graph);
+            father.insert(i, f);
+        }
+        let mut ans = vec![];
+        for q in queries {
+            let (to, from) = (q[0] as usize, q[1] as usize);
+            if let Some(set) = father.get(&from) {
+                ans.push(set.contains(&to));
+            }
+        }
+        ans
+    }
+    fn get_father(n: usize, s: usize, graph: &HashMap<usize, HashSet<usize>>) -> HashSet<usize> {
+        let mut went = vec![false; n];
+        went[s] = true;
+        let mut ans = HashSet::new();
+        let mut q = vec![s];
+        let mut head = 0;
+        while head < q.len() {
+            let cur = q[head];
+            head += 1;
+            if let Some(set) = graph.get(&cur) {
+                for &next in set.iter() {
+                    if !went[next] {
+                        went[next] = true;
+                        ans.insert(next);
+                        q.push(next);
+                    }
+                }
+            }
+        }
+        ans
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_check_if_prerequisite() {
+        let test_cases = vec![
+            (3, vec![[1,2],[1,0],[2,0]], vec![[1,0],[1,2]], vec![true, true]),
+            (5, vec![[0,1],[1,2],[2,3],[3,4]], vec![[0,4],[4,0],[1,3],[3,0]], vec![true,false,true,false]),
+        ];
+        for (n, pre, q, expect) in test_cases {
+            let pres = pre.iter().map(|v| vec![v[0], v[1]]).collect();
+            let qs = q.iter().map(|v| vec![v[0], v[1]]).collect();
+            assert_eq!(Solution::check_if_prerequisite(n, pres, qs), expect, "n:{}, pres: {:?}, qs: {:?}", n, pre, q);
+        }
+    }
+}

src/night_match_27/prob_5411.rs

@@ -0,0 +1,76 @@
+impl Solution {
+    pub fn cherry_pickup(grid: Vec<Vec<i32>>) -> i32 {
+        let n = grid.len();
+        let m = grid[0].len();
+        let mut f = vec![vec![vec![-1; m]; m]; n];
+        f[0][0][m-1] = grid[0][0] + grid[0][m-1];
+        let im = m as i32;
+        for t in 1..n {
+            for i in 0..im {
+                for j in 0..im {
+                    for di in -1..=1 {
+                        for dj in -1..=1 {
+                            let (ni, nj) = (i+di, j+dj);
+                            if ni < 0 || nj < 0 || ni >= im || nj >= im { continue; }
+                            let (ui, uj) = (ni as usize, nj as usize);
+                            if f[t-1][ui][uj] < 0 { continue; }
+                            let ci = i as usize;
+                            let cj = j as usize;
+                            if i != j {
+                                f[t][ci][cj] = f[t][ci][cj].max(f[t-1][ui][uj] + grid[t][ci] + grid[t][cj]);
+                            } else {
+                                f[t][ci][cj] = f[t][ci][cj].max(f[t-1][ui][uj] + grid[t][ci]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        let mut ans = 0;
+        for i in 0..m {
+            for j in 0..m {
+                ans = ans.max(f[n-1][i][j]);
+            }
+        }
+        ans
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_cherry_pickup() {
+        let test_cases = vec![
+            (vec![
+                vec![1,0,0,3],
+                vec![0,0,0,3],
+                vec![0,0,3,3],
+                vec![9,0,3,3]
+            ], 22),
+            (vec![
+                vec![1,1],
+                vec![1,1]
+            ], 4),
+            (vec![
+                vec![3,1,1],
+                vec![2,5,1],
+                vec![1,5,5],
+                vec![2,1,1]
+            ], 24),
+            (vec![
+                vec![1,0,0,0,0,0,1],
+                vec![2,0,0,0,0,3,0],
+                vec![2,0,9,0,0,0,0],
+                vec![0,3,0,5,4,0,0],
+                vec![1,0,2,3,0,0,6]
+            ], 28),
+        ];
+        for (grid, expect) in test_cases {
+            assert_eq!(Solution::cherry_pickup(grid.clone()), expect, "grid: {:?}", grid);
+        }
+    }
+}