11/30/2020

Author: safrannn

src/_0091_decode_ways.rs

@@ -0,0 +1,33 @@
+struct Solution;
+
+impl Solution {
+ pub fn num_decodings(s: String) -> i32 {
+ let n = s.len();
+ let s_bytes = s.as_bytes();
+ let mut dp: Vec<i32> = vec![0; n + 1];
+ dp[0] = 1;
+
+ for (i, b) in s_bytes.iter().enumerate() {
+ if b - '0' as u8 > 0 {
+ dp[i + 1] += dp[i];
+ }
+ if i == 0 {
+ continue;
+ }
+ if (s_bytes[i - 1] - '0' as u8) * 10 + b - '0' as u8 >= 10
+ && (s_bytes[i - 1] - '0' as u8) * 10 + b - '0' as u8 <= 26
+ {
+ dp[i + 1] += dp[i - 1];
+ }
+ }
+ dp[n]
+ }
+}
+
+#[test]
+fn test() {
+ assert_eq!(Solution::num_decodings("12".to_string()), 2);
+ assert_eq!(Solution::num_decodings("226".to_string()), 3);
+ assert_eq!(Solution::num_decodings("0".to_string()), 0);
+ assert_eq!(Solution::num_decodings("1".to_string()), 1);
+}

src/_0103_binary_tree_zigzag_level_order_traversal.rs

@@ -0,0 +1,53 @@
+use crate::util::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+struct Solution;
+
+impl Solution {
+ pub fn zigzag_level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
+ let mut result: Vec<Vec<i32>> = vec![];
+ if root.is_none() {
+ return result;
+ }
+ let mut order_lr: bool = true;
+ let mut level_nums: Vec<i32> = vec![];
+ let mut visiting: Vec<Rc<RefCell<TreeNode>>> = vec![root.unwrap().clone()];
+ let mut next: Vec<Rc<RefCell<TreeNode>>> = vec![];
+
+ while let Some(node) = visiting.pop() {
+ let node = node.borrow();
+ level_nums.push(node.val);
+ if order_lr {
+ if let Some(node_left) = &node.left {
+ next.push(node_left.clone());
+ }
+ if let Some(node_right) = &node.right {
+ next.push(node_right.clone());
+ }
+ } else {
+ if let Some(node_right) = &node.right {
+ next.push(node_right.clone());
+ }
+ if let Some(node_left) = &node.left {
+ next.push(node_left.clone());
+ }
+ }
+
+ if visiting.is_empty() {
+ std::mem::swap(&mut visiting, &mut next);
+ result.push(level_nums.drain(..).collect());
+ order_lr = !order_lr;
+ }
+ }
+
+ result
+ }
+}
+
+#[test]
+fn test() {
+ let root = tree!(3, tree!(9), tree!(20, tree!(15), tree!(7)));
+ let res = vec_vec_i32![[3], [20, 9], [15, 7]];
+ assert_eq!(Solution::zigzag_level_order(root), res);
+}

src/_0207_course_schedule.rs

@@ -0,0 +1,42 @@
+struct Solution;
+
+impl Solution {
+ pub fn can_finish(num_courses: i32, prerequisites: Vec<Vec<i32>>) -> bool {
+ let n = num_courses as usize;
+
+ let mut indegrees: Vec<i32> = vec![0; n];
+ let mut edges: Vec<Vec<usize>> = vec![vec![]; n];
+
+ for preq in prerequisites {
+ let u = preq[0] as usize;
+ let v = preq[1] as usize;
+ indegrees[v] += 1;
+ edges[u].push(v);
+ }
+
+ let mut queue: Vec<usize> = vec![];
+ for i in 0..n {
+ if indegrees[i] == 0 {
+ queue.push(i);
+ }
+ }
+
+ let mut result: Vec<usize> = vec![];
+ while let Some(u) = queue.pop() {
+ result.push(u);
+ while let Some(v) = edges[u].pop() {
+ indegrees[v] -= 1;
+ if indegrees[v] == 0 {
+ queue.push(v);
+ }
+ }
+ }
+ result.len() == n
+ }
+}
+
+#[test]
+fn test() {
+ assert_eq!(Solution::can_finish(2, vec_vec_i32![[1, 0]]), true);
+ assert_eq!(Solution::can_finish(2, vec_vec_i32![[1, 0], [0, 1]]), false);
+}

src/_0211_add_and_search_word_data_structure_design.rs

@@ -0,0 +1,75 @@
+use std::collections::HashMap;
+
+struct Trie {
+ children: HashMap<char, Trie>,
+ end: bool,
+}
+impl Trie {
+ fn new() -> Self {
+ Trie {
+ children: HashMap::new(),
+ end: false,
+ }
+ }
+
+ fn add(&mut self, word: String) {
+ let mut node = self;
+ for c in word.chars() {
+ node = node.children.entry(c).or_insert(Trie::new());
+ }
+ node.end = true;
+ }
+
+ fn search(&self, word: String) -> bool {
+ if word.is_empty() {
+ return self.end;
+ }
+ let c = word.chars().next().unwrap();
+ if c == '.' {
+ for child in self.children.values() {
+ if Self::search(&child, word[1..].to_string()) {
+ return true;
+ }
+ }
+ } else {
+ if let Some(child) = self.children.get(&c) {
+ return Self::search(&child, word[1..].to_string());
+ } else {
+ return false;
+ }
+ }
+ false
+ }
+}
+
+struct WordDictionary {
+ dictionary: Trie,
+}
+
+impl WordDictionary {
+ fn new() -> Self {
+ WordDictionary {
+ dictionary: Trie::new(),
+ }
+ }
+
+ fn add_word(&mut self, word: String) {
+ self.dictionary.add(word)
+ }
+
+ fn search(&self, word: String) -> bool {
+ self.dictionary.search(word)
+ }
+}
+
+#[test]
+fn test() {
+ let mut wd = WordDictionary::new();
+ wd.add_word("bad".to_string());
+ wd.add_word("dad".to_string());
+ wd.add_word("mad".to_string());
+ assert_eq!(wd.search("pad".to_string()), false);
+ assert_eq!(wd.search("bad".to_string()), true);
+ assert_eq!(wd.search(".ad".to_string()), true);
+ assert_eq!(wd.search("b..".to_string()), true);
+}

src/_0337_house_robber_iii.rs

@@ -0,0 +1,36 @@
+use crate::util::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+struct Solution;
+
+impl Solution {
+ pub fn rob(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+ let answer = Self::traverse(root.as_ref());
+ return answer.0.max(answer.1);
+ }
+ fn traverse(root: Option<&Rc<RefCell<TreeNode>>>) -> (i32, i32) {
+ if let Some(root) = root {
+ let root = root.borrow();
+ let value = root.val;
+ let left = Self::traverse(root.left.as_ref());
+ let right = Self::traverse(root.right.as_ref());
+ (
+ value + left.1 + right.1,
+ left.0.max(left.1) + right.0.max(right.1),
+ )
+ } else {
+ (0, 0)
+ }
+ }
+}
+
+#[test]
+fn test() {
+ let root = tree!(3, tree!(2, None, tree!(3)), tree!(3, None, tree!(1)));
+ let res = 7;
+ assert_eq!(Solution::rob(root), res);
+ let root = tree!(3, tree!(4, tree!(1), tree!(3)), tree!(5, None, tree!(1)));
+ let res = 9;
+ assert_eq!(Solution::rob(root), res);
+}

src/_0777_swap_adjacent_in_lr_string.rs

@@ -0,0 +1,10 @@
+// struct Solution;
+
+// impl Solution {
+// pub fn can_transform(start: String, end: String) -> bool {}
+// }
+
+// #[test]
+// fn test() {
+// assert_eq!(Solution::can_transform(vec![1, 7, 3, 6, 5, 6]), 3);
+// }

src/_0875_koko_eating_bananas.rs

@@ -0,0 +1,38 @@
+struct Solution;
+
+impl Solution {
+ pub fn min_eating_speed(piles: Vec<i32>, h: i32) -> i32 {
+ let mut left = 1;
+ let mut right = 1000000001;
+ while left < right {
+ let mid = (left + right) / 2;
+ if Self::can_finish(&piles, h, mid) {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ left
+ }
+
+ fn can_finish(piles: &Vec<i32>, h: i32, k: i32) -> bool {
+ let mut hours = 0;
+
+ for pile in piles {
+ if pile % k == 0 {
+ hours += pile / k;
+ } else {
+ hours += pile / k + 1;
+ }
+ }
+
+ hours <= h
+ }
+}
+
+#[test]
+fn test() {
+ assert_eq!(Solution::min_eating_speed(vec![3, 6, 7, 11], 8), 4);
+ assert_eq!(Solution::min_eating_speed(vec![30, 11, 23, 4, 20], 5), 30);
+ assert_eq!(Solution::min_eating_speed(vec![30, 11, 23, 4, 20], 6), 23);
+}

src/lib.rs

@@ -66,8 +66,12 @@ mod _0083_remove_duplicates_from_sorted_list;
 //
 mod _0088_merge_sorted_array;
 //
+mod _0091_decode_ways;
+//
 mod _0101_symmetric_tree;
 //
+mod _0103_binary_tree_zigzag_level_order_traversal;
+//
 mod _0104_maximum_depth_of_binary_tree;
 //
 mod _0110_balanced_binary_tree;
@@ -102,8 +106,12 @@ mod _0205_isomorphic_strings;
 //
 mod _0206_reverse_linked_list;
 //
+mod _0207_course_schedule;
+//
 mod _0210_course_schedule_ii;
 //
+mod _0211_add_and_search_word_data_structure_design;
+//
 mod _0213_house_robber_ii;
 //
 mod _0215_kth_largest_element_in_an_array;
@@ -138,6 +146,8 @@ mod _0300_longest_increasing_subsequence;
 //
 mod _0322_coin_change;
 //
+mod _0337_house_robber_iii;
+//
 mod _0342_power_of_four;
 //
 mod _0344_reverse_string;
@@ -212,12 +222,16 @@ mod _0763_partition_labels;
 //
 mod _0771_jewels_and_stones;
 //
+mod _0777_swap_adjacent_in_lr_string;
+//
 mod _0796_rotate_string;
 //
 mod _0819_most_common_word;
 //
 mod _0844_backspace_string_compare;
 //
+mod _0875_koko_eating_bananas;
+//
 mod _0905_sort_array_by_parity;
 //
 mod _0922_sort_array_by_parity_ii;

src/test.rs

@@ -1,48 +1 @@
-// use std::io;
-// use std::io::BufRead;
-// pub fn main() {}
 
-// fn main_1() {
-// let stdin = io::stdin();
-// let mut lines = stdin.lock().lines();
-// let line_count = lines.next().unwrap().unwrap();
-// let count = line_count.parse::<usize>().unwrap();
-// let ratings: Vec<i32> = lines
-// .take(count)
-// .map(|value| value.unwrap().parse::<i32>().unwrap())
-// .collect();
-// // let change_count = candies(&ratings);
-// // println!("{}", change_count);
-// }
-
-// pub fn main_2() {
-// // variable declaration
-// let mut _num_str_1 = String::new();
-// let mut _num_str_2 = String::new();
-
-// // read variables
-// io::stdin()
-// .read_line(&mut _num_str_1)
-// .ok()
-// .expect("read error");
-// io::stdin()
-// .read_line(&mut _num_str_2)
-// .ok()
-// .expect("read error");
-
-// // parse integers
-// let mut _num_1: i32 = _num_str_1.trim().parse().ok().expect("parse error");
-// let mut _num_2: i32 = _num_str_2.trim().parse().ok().expect("parse error");
-
-// // print the sum
-// // Hint: Type println!("{}", _num_1 + _num_2); below
-// println!("{}", _num_1 + _num_2);
-// }
-
-// pub fn read_line() -> String {
-// let mut input = String::new();
-// std::io::stdin()
-// .read_line(&mut input)
-// .expect("Could not read stdin!");
-// return input;
-// }