26双周赛

Author: caibirdme

src/lib.rs

@@ -38,6 +38,7 @@ mod prob_35;
 mod prob_38;
 mod prob_39;
 mod prob_40;
+mod prob_41;
 mod prob_42;
 mod prob_45;
 mod prob_46;
@@ -411,6 +412,9 @@ mod prob_5374;
 mod prob_5375;
 mod prob_5377;
 mod prob_5379;
+mod prob_5397;
+mod prob_5398;
+mod prob_5399;
 mod prob_5380;
 mod prob_5381;
 mod prob_5382;

src/prob_41.rs

@@ -0,0 +1,65 @@
+impl Solution {
+    pub fn first_missing_positive(mut nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        if n == 0 {
+            return 1;
+        }
+        let mut ok = false;
+        for &v in &nums {
+            if v == 1 {
+                ok = true;
+                break;
+            }
+        }
+        if !ok {
+            return 1;
+        }
+        if n == 1 && nums[0] == 1 {
+            return 2;
+        }
+        for i in 0..n {
+            if nums[i] <=0 || nums[i] > n as i32 {
+                nums[i] = 1;
+            }
+        }
+        for i in 0..n {
+            let w = nums[i];
+            let t = if w > 0 {w} else {-w};
+            if t == n as i32 {
+                nums[0] = -t;
+                continue;
+            }
+            let v = nums[t as usize];
+            if v > 0 {
+                nums[t as usize] = -v;
+            }
+        }
+        for i in 1..n {
+            if nums[i] > 0 {
+                return i as i32;
+            }
+        }
+        if nums[0] > 0 {n as i32} else {n as i32+1}
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_first_missing_positive() {
+        let test_cases = vec![
+            (vec![1,1], 2),
+            (vec![1,2,0], 3),
+            (vec![1], 2),
+            (vec![3,4,-1,1],2),
+            (vec![7,8,9,11,12], 1),
+        ];
+        for (arr, expect) in test_cases {
+            assert_eq!(Solution::first_missing_positive(arr.clone()), expect, "arr: {:?}", arr);
+        }
+    }
+}

src/prob_5397.rs

@@ -0,0 +1,47 @@
+use std::collections::HashSet;
+
+impl Solution {
+    pub fn simplified_fractions(n: i32) -> Vec<String> {
+        if n == 1 {
+            return vec![];
+        }
+        let mut hash = HashSet::new();
+        for i in 2..=n {
+            for j in 1..i {
+                let g = Self::gcd(i, j);
+                hash.insert((i/g, j/g));
+            }
+        }
+        hash.into_iter().map(|(x,y)| format!("{}/{}",y,x)).collect()
+    }
+    fn gcd(mut x: i32, mut y:i32) -> i32 {
+        if x < y {
+            return Self::gcd(y, x);
+        }
+        while x%y != 0 {
+            let m = x%y;
+            x = y;
+            y = m;
+        }
+        y
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_simplified_fractions() {
+        let test_cases = vec![
+            (2, vec!["1/2"]),
+            //(3, vec!["1/2","1/3","2/3"]),
+            (4, vec!["1/2","1/3","1/4","2/3","3/4"]),
+        ];
+        for (n, expect) in test_cases {
+            assert_eq!(Solution::simplified_fractions(n), expect);
+        }
+    }
+}

src/prob_5398.rs

@@ -0,0 +1,46 @@
+// 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 good_nodes(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        if root.is_none() {
+            return 0;
+        }
+        let mut ans = 0;
+        let mut m = root.as_ref().unwrap().borrow().val;
+        Self::count(&root, m, &mut ans);
+        ans
+    }
+    fn count(r: &Option<Rc<RefCell<TreeNode>>>, m: i32, ans: &mut i32) {
+        if r.is_none() {
+            return;
+        }
+        let br = r.as_ref().unwrap().borrow();
+        let val = br.val;
+        if m <= val {
+            *ans += 1;
+        }
+        let next = m.max(val);
+        Self::count(&br.left, next, ans);
+        Self::count(&br.right, next, ans);
+    }
+}
+
+struct Solution;

src/prob_5399.rs

@@ -0,0 +1,70 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn largest_number(cost: Vec<i32>, target: i32) -> String {
+        let m = target as usize;
+        let mut max_v: HashMap<i32, usize> = HashMap::new();
+        for i in 0..9 {
+            if let Some(idx) = max_v.get_mut(&cost[i]) {
+                *idx = i.max(*idx);
+            } else {
+                max_v.insert(cost[i], i);
+            }
+        }
+        let mut f = vec![-1; m+1];
+        let mut select = HashMap::new();
+        f[0] = 0;
+        for i in 0..9 {
+            let w = cost[i];
+            if *max_v.get(&w).unwrap() != i {
+                continue;
+            }
+            for v in w..=target {
+                let pos = (v-w) as usize;
+                let uv = v as usize;
+                if f[pos] >= 0 {
+                    let nval = f[pos]+1;
+                    if nval > f[uv] {
+                        f[uv] = nval;
+                        select.insert(v, vec![i]);
+                    } else if nval == f[uv] {
+                        select.entry(v).or_insert(vec![]).push(i);
+                    }
+                }
+            }
+        }
+        if f[m] <= 0 {
+            return "0".to_owned();
+        }
+        let mut w = target;
+        let mut ans = vec![];
+        while w > 0 {
+            let arr = select.get(&w).unwrap();
+            let mut t = *arr.iter().max().unwrap();
+            ans.push((t as i32+1) as u8 + b'0');
+            w -= cost[t];
+        }
+        unsafe {std::str::from_utf8_unchecked(&ans).to_string()}
+    }
+}
+
+struct Solution;
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_largest_number() {
+        let test_cases = vec![
+            (vec![1,1,1,1,1,1,1,3,2], 10, "7777777777"),
+            (vec![4,3,2,5,6,7,2,5,5], 9, "7772"),
+            (vec![7,6,5,5,5,6,8,7,8], 12, "85"),
+            (vec![2,4,6,2,4,6,4,4,4], 5, "0"),
+            (vec![6,10,15,40,40,40,40,40,40], 47, "32211"),
+        ];
+        for (cost, target, expect) in test_cases {
+            assert_eq!(Solution::largest_number(cost.clone(), target), expect, "cost: {:?}, target: {}", cost, target);
+        }
+    }
+}