Merge branch 'master' of git.rrricardo.top:jackfiled/leetcode

src/problem/mod.rs

@@ -72,4 +72,7 @@ mod p2386_find_the_k_sum_of_an_array;
 mod p299_bulls_and_cows;
 mod p2129_capitalize_the_title;
 mod p1261_find_elements_in_a_contaminated_binary_tree;
+mod p2864_maximum_odd_binary_number;
+mod p2789_largest_element_in_an_array_after_merge_operations;
+mod p2312_selling_pieces_of_wood;
 mod p2684_maximum_number_of_moves_in_a_grid;

src/problem/p2312_selling_pieces_of_wood.rs

@@ -0,0 +1,67 @@
+/**
+ * [2312] Selling Pieces of Wood
+ */
+pub struct Solution {}
+
+
+// submission codes start here
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn selling_wood(m: i32, n: i32, prices: Vec<Vec<i32>>) -> i64 {
+        let mut prices_map = HashMap::with_capacity(prices.len());
+
+        for price in prices {
+            prices_map.insert(Solution::hash(price[0] as usize, price[1] as usize), 
+                price[2] as i64);
+        }
+        
+        let (m, n) = (m as usize, n as usize);
+
+        let mut dp = vec![vec![-1;n + 1];m + 1];
+
+
+        Solution::dfs(m, n, &mut dp, &prices_map)
+    }
+
+    fn hash(x: usize, y: usize)-> usize {
+        return x * 1000 + y;
+    }
+
+    fn dfs(x: usize, y: usize, dp: &mut Vec<Vec<i64>>, prices_map: &HashMap<usize, i64>) -> i64 {
+        if dp[x][y] != -1 {
+            return dp[x][y];
+        }
+
+        let mut result  = *prices_map.get(&Solution::hash(x, y))
+            .unwrap_or_else(|| &0);
+
+        if x > 1 {
+            for i in  1..x {
+                result = result.max(Solution::dfs(i, y, dp, prices_map) + 
+                    Solution::dfs(x - i, y, dp, prices_map));   
+            }
+        }
+
+        if y > 1 {
+            for j in 1..y {
+                result = result.max(Solution::dfs(x, j, dp, prices_map) + 
+                    Solution::dfs(x, y - j, dp, prices_map));
+            }
+        }
+
+        dp[x][y] = result;
+        result
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_2312() {
+    }
+}

src/problem/p2789_largest_element_in_an_array_after_merge_operations.rs

@@ -0,0 +1,39 @@
+/**
+ * [2789] Largest Element in an Array after Merge Operations
+ */
+pub struct Solution {}
+
+
+// submission codes start here
+
+impl Solution {
+    pub fn max_array_value(nums: Vec<i32>) -> i64 {
+        let mut nums: Vec<i64> = nums.iter()
+            .map(|x| *x as i64)
+            .collect();
+
+            let mut result = nums[0];
+            for i in (0..(nums.len() - 1)).rev() {
+                if nums[i] <= nums[i + 1] {
+                    nums[i] = nums[i] + nums[i + 1];
+
+                    result = result.max(nums[i]);
+                }
+            }
+
+        result
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_2789() {
+        assert_eq!(21, Solution::max_array_value(vec![2,3,7,9,3]));
+        assert_eq!(11, Solution::max_array_value(vec![5,3,3]));   
+    }
+}

src/problem/p2864_maximum_odd_binary_number.rs

@@ -0,0 +1,52 @@
+/**
+ * [2864] Maximum Odd Binary Number
+ */
+pub struct Solution {}
+
+
+// submission codes start here
+
+impl Solution {
+    pub fn maximum_odd_binary_number(s: String) -> String {
+        let nums: Vec<u32> = s.chars()
+            .map(|c| c.to_digit(10).unwrap())
+            .collect();
+
+        let mut one_count = 0;
+        let mut zero_count = 0;
+
+        for num in &nums {
+            if *num == 1 {
+                one_count += 1;
+            } else if *num == 0 {
+                zero_count += 1;
+            }
+        }
+
+        let mut result: Vec<char> = Vec::with_capacity(nums.len());
+
+        for _ in  1..one_count {
+            result.push('1');
+        }
+
+        for _ in 0..zero_count {
+            result.push('0');
+        }
+
+        result.push('1');
+        result.iter().collect()
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_2864() {
+        assert_eq!("001", Solution::maximum_odd_binary_number("010".to_owned()));
+        assert_eq!("1001", Solution::maximum_odd_binary_number("0101".to_owned()));
+    }
+}