match 190

Author: caibirdme

src/lib.rs

@@ -425,6 +425,7 @@ mod prob_5388;
 mod prob_5389;
 mod prob_5390;
 mod prob_5391;
+mod match_190;
 mod prob_5437;
 mod sword_offer;
 mod crack_code_interview;

src/match_190/mod.rs

@@ -0,0 +1,4 @@
+mod prob_5416;
+mod prob_5417;
+mod prob_5418;
+mod prob_5419;

src/match_190/prob_5416.rs

@@ -0,0 +1,13 @@
+impl Solution {
+    pub fn is_prefix_of_word(sentence: String, search_word: String) -> i32 {
+        let search = search_word.as_str();
+        for (idx, s) in sentence.split(" ").enumerate() {
+            if s.starts_with(search) {
+                return idx as i32+1;
+            }
+        }
+        return -1;
+    }
+}
+
+struct Solution;

src/match_190/prob_5417.rs

@@ -0,0 +1,35 @@
+
+impl Solution {
+    pub fn max_vowels(s: String, k: i32) -> i32 {
+        let s = s.as_bytes();
+        let mut count = 0;
+        for i in 0..k as usize {
+            if Self::is_vowel(s[i]) {
+                count += 1;
+            }
+        }
+        let mut ans = count;
+        let mut i = 0;
+        let mut j = k as usize;
+        while j < s.len() {
+            if Self::is_vowel(s[i]) {
+                count-=1;
+            }
+            if Self::is_vowel(s[j]) {
+                count+=1;
+                ans = ans.max(count);
+            }
+            i+=1;
+            j+=1;
+        }
+        ans
+    }
+    fn is_vowel(c: u8) -> bool {
+        match c {
+            b'a'|b'e'|b'i'|b'o'|b'u' => true,
+            _ => false,
+        }
+    }
+}
+
+struct Solution;

src/match_190/prob_5418.rs

@@ -0,0 +1,96 @@
+// Definition for a binary tree node.
+#[derive(Debug, PartialEq, Eq)]
+pub struct TreeNode {
+  pub val: i32,
+  pub left: Option<Rc<RefCell<TreeNode>>>,
+  pub right: Option<Rc<RefCell<TreeNode>>>,
+}
+
+impl TreeNode {
+  #[inline]
+  pub fn new(val: i32) -> Self {
+    TreeNode {
+      val,
+      left: None,
+      right: None
+    }
+  }
+}
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn pseudo_palindromic_paths (root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        if root.is_none() {
+            return 0;
+        }
+        let mut count = [0; 10];
+        let mut ans = 0;
+        Self::dfs(&root, &mut count, &mut ans);
+        ans
+    }
+    fn dfs(r: &Option<Rc<RefCell<TreeNode>>>, count: &mut [i32; 10], ans: &mut i32) {
+        if r.is_none() {
+            return;
+        }
+        let br = r.as_ref().unwrap().borrow();
+        if br.left.is_none() && br.right.is_none() {
+            count[br.val as usize] += 1;
+            let mut odd = 0;
+            for i in 0..=9 {
+                if count[i] & 1 == 1 {
+                    odd += 1;
+                }
+            }
+            if odd <= 1 {
+                *ans += 1;
+            }
+            count[br.val as usize] -= 1;
+            return
+        }
+        count[br.val as usize] += 1;
+        Self::dfs(&br.left, count, ans);
+        Self::dfs(&br.right, count, ans);
+        count[br.val as usize] -= 1;
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_pseudo_palindromic_paths() {
+        let root = Some(Rc::new(RefCell::new(TreeNode{
+            val: 1,
+            left: Some(Rc::new(RefCell::new(TreeNode{
+                val: 9,
+                left: None,
+                right: Some(Rc::new(RefCell::new(TreeNode{
+                    val: 1,
+                    left: None,
+                    right: None,
+                }))),
+            }))),
+            right: Some(Rc::new(RefCell::new(TreeNode{
+                val: 1,
+                left: None,
+                right: Some(Rc::new(RefCell::new(TreeNode{
+                    val: 1,
+                    left: Some(Rc::new(RefCell::new(TreeNode{
+                        val: 7,
+                        left: None,
+                        right: Some(Rc::new(RefCell::new(TreeNode{
+                            val: 4,
+                            left: None,
+                            right: None,
+                        }))),
+                    }))),
+                    right: None,
+                }))),
+            }))),
+        })));
+        assert_eq!(Solution::pseudo_palindromic_paths(root), 1);
+    }
+}

src/match_190/prob_5419.rs

@@ -0,0 +1,47 @@
+impl Solution {
+    pub fn max_dot_product(nums1: Vec<i32>, nums2: Vec<i32>) -> i32 {
+        let n = nums1.len();
+        let m = nums2.len();
+        if n == 1 && m == 1 {
+            return nums1[0]*nums2[0];
+        }
+        let mut f = vec![vec![std::i32::MIN; m+1]; n+1];
+        for i in 0..=m {
+            f[0][i] = 0;
+        }
+        for i in 0..=n {
+            f[i][0] = 0;
+        }
+        let mut ans = std::i32::MIN;
+        for i in 1..=n {
+            for j in 1..=m {
+                f[i][j] = f[i-1][j-1] + nums1[i-1]*nums2[j-1];
+                ans = ans.max(f[i][j]);
+                f[i][j] = f[i][j].max(f[i-1][j]);
+                f[i][j] = f[i][j].max(f[i][j-1]);
+            }
+        }
+        ans
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_max_dot_product() {
+        let test_cases = vec![
+            (vec![-3,-8,3,-10,1,3,9],vec![9,2,3,7,-9,1,-8,5,-1,-1],200),
+            (vec![2,1,-2,5], vec![3,0,-6], 18),
+            (vec![3, -2], vec![2,-6,7], 21),
+            (vec![-1,-1],vec![1,1], -1),
+        ];
+        for (nums1, nums2, expect) in test_cases {
+            assert_eq!(Solution::max_dot_product(nums1.clone(), nums2.clone()), expect, "nums1: {:?}, nums2: {:?}", nums1, nums2);
+        }
+    }
+
+}