Add solutions

Author: martwz

README.md

@@ -21,6 +21,7 @@ LeetCode is a website that has programming-related questions that are designed t
 | 75 | Sort Colors | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/top_interview/sorting/sort_colors.rs) | [Leetcode](https://leetcode.com/problems/sort-colors/) | Medium |
 | 115 | Distinct Subsequences | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/num_distinct.rs) | [Leetcode](https://leetcode.com/problems/distinct-subsequences/) | Hard |
 | 169 | Majority Element | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/top_interview/others/majority_element.rs) | [Leetcode](https://leetcode.com/problems/majority-element/solution/) | Easy |
+| 174 | Dungeon Game | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/calculate_minimum_hp.rs) | [Leetcode](https://leetcode.com/problems/dungeon-game/) | Hard |
 | 242 | Valid Anagram | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/is_anagram.rs) | [Leetcode](https://leetcode.com/problems/valid-anagram/) | Easy |
 | 282 | Expression Add Operators | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/add_operators.rs) | [Leetcode](https://leetcode.com/problems/expression-add-operators/) | Hard |
 | 317 | Shortest Distance from All Buildings | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/shortest_distance.rs) | [Leetcode](https://leetcode.com/problems/shortest-distance-from-all-buildings/) | Hard |
@@ -35,6 +36,7 @@ LeetCode is a website that has programming-related questions that are designed t
 | 698 | Partition to K Equal Sum Subsets | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/can_partition_k_subsets.rs) | [Leetcode](https://leetcode.com/problems/partition-to-k-equal-sum-subsets/) | Medium |
 | 713 | Subarray Product Less Than K | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/num_subarray_product_less_than_k.rs) | [Leetcode](https://leetcode.com/problems/subarray-product-less-than-k/) | Medium |
 | 725 | Split Linked List in Parts | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/split_list_to_parts.rs) | [Leetcode](https://leetcode.com/problems/split-linked-list-in-parts/) | Medium |
+| 741 | Cherry Pickup | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/cherry_pickup.rs) | [Leetcode](https://leetcode.com/problems/cherry-pickup/) | Hard |
 | 774 | Minimize Max Distance to Gas Station | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/minmax_gas_dist.rs) | [Leetcode](https://leetcode.com/problems/minimize-max-distance-to-gas-station/) | Medium |
 | 875 | Koko Eating Bananas | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/min_eating_speed.rs) | [Leetcode](https://leetcode.com/problems/koko-eating-bananas/) | Medium |
 | 922 | Sort Array By Parity II | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/sort_array_by_parity_ii.rs) | [Leetcode](https://leetcode.com/problems/sort-array-by-parity-ii/) | Easy |
@@ -47,4 +49,8 @@ LeetCode is a website that has programming-related questions that are designed t
 | 1275 | Find Winner on a Tic Tac Toe Game | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/tictactoe.rs) | [Leetcode](https://leetcode.com/problems/find-winner-on-a-tic-tac-toe-game/) | Easy |
 | 1293 | Shortest Path in a Grid with Obstacles Elimination | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/shortest_path.rs) | [Leetcode](https://leetcode.com/problems/shortest-path-in-a-grid-with-obstacles-elimination/) | Hard |
 | 1328 | Break a Palindrome | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/break_palindrome.rs) | [Leetcode](https://leetcode.com/problems/break-a-palindrome/) | Medium |
-| 1457 | Pseudo-Palindromic Paths in a Binary Tree | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/pseudo_palindromic_paths.rs) | [Leetcode](https://leetcode.com/problems/pseudo-palindromic-paths-in-a-binary-tree/) | Easy |
+| 1457 | Pseudo-Palindromic Paths in a Binary Tree | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/pseudo_palindromic_paths.rs) | [Leetcode](https://leetcode.com/problems/pseudo-palindromic-paths-in-a-binary-tree/) | Easy |
+| 2022 | Convert 1D Array Into 2D Array | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/biweekly_62.rs) | [Leetcode](https://leetcode.com/problems/convert-1d-array-into-2d-array/) | Easy |
+| 2023 | Number of Pairs of Strings With Concatenation Equal to Target | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/biweekly_62.rs) | [Leetcode](https://leetcode.com/problems/number-of-pairs-of-strings-with-concatenation-equal-to-target/) | Medium |
+| 2024 | Maximize the Confusion of an Exam | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/biweekly_62.rs) | [Leetcode](https://leetcode.com/problems/maximize-the-confusion-of-an-exam/) | Medium |
+| 2025 | Maximum Number of Ways to Partition an Array | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/biweekly_62.rs) | [Leetcode](https://leetcode.com/problems/maximum-number-of-ways-to-partition-an-array/) | Hard |

src/leetcode/challenge/calculate_minimum_hp.rs

@@ -0,0 +1,47 @@
+// 174. Dungeon Game, Hard
+// https://leetcode.com/problems/dungeon-game/
+impl Solution {
+    pub fn calculate_minimum_hp(dungeon: Vec<Vec<i32>>) -> i32 {
+        let [n, m] = [dungeon.len(), dungeon[0].len()];
+        let mut dp = vec![vec![i32::max_value(); m + 1]; n + 1]; // (curr_health, min_health)
+
+        dp[n - 1][m] = 1;
+        dp[n][m - 1] = 1;
+
+        for i in (0..n).rev() {
+            for j in (0..m).rev() {
+                dp[i][j] = i32::max(i32::min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j], 1);
+            }
+        }
+
+        dp[0][0]
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::vec_vec_i32;
+
+    #[test]
+    fn test_calculate_minimum_hp() {
+        assert_eq!(Solution::calculate_minimum_hp(vec_vec_i32![[-2, -3, 3], [-5, -10, 1], [10, 30, -5]]), 7);
+    }
+
+    #[test]
+    fn test_calculate_minimum_hp2() {
+        assert_eq!(Solution::calculate_minimum_hp(vec_vec_i32![[0]]), 1);
+    }
+
+    #[test]
+    fn test_calculate_minimum_hp3() {
+        assert_eq!(Solution::calculate_minimum_hp(vec_vec_i32![[100]]), 1);
+    }
+
+    #[test]
+    fn test_calculate_minimum_hp4() {
+        assert_eq!(Solution::calculate_minimum_hp(vec_vec_i32![[1, -3, 3], [0, -2, 0], [-3, -3, -3]]), 3);
+    }
+}

src/leetcode/challenge/cherry_pickup.rs

@@ -0,0 +1,67 @@
+use std::collections::HashMap;
+
+// 741. Cherry Pickup, Hard
+// https://leetcode.com/problems/cherry-pickup/
+impl Solution {
+    pub fn cherry_pickup(grid: Vec<Vec<i32>>) -> i32 {
+        let n = grid.len();
+
+        let mut memo: HashMap<(usize, usize, usize, usize), i32> = HashMap::new();
+
+        fn dp(grid: &Vec<Vec<i32>>, n: &usize, i1: usize, j1: usize, i2: usize, j2: usize, memo: &mut HashMap<(usize, usize, usize, usize), i32>) -> i32 {
+            if i1 >= *n || j1 >= *n || i2 >= *n || j2 >= *n {
+                return -1;
+            } else if i1 == *n - 1 && j1 == *n - 1 && i2 == *n - 1 && j2 == *n - 1 {
+                return grid[i1][j1];
+            } else if grid[i1][j1] == -1 || grid[i2][j2] == -1 {
+                return -1;
+            }
+
+            let key = &(i1, j1, i2, j2);
+            if memo.contains_key(key) {
+                return *memo.get(key).unwrap();
+            }
+
+            let dd = dp(&grid, &n, i1 + 1, j1, i2 + 1, j2, memo);
+            let dr = dp(&grid, &n, i1 + 1, j1, i2, j2 + 1, memo);
+            let rd = dp(&grid, &n, i1, j1 + 1, i2 + 1, j2, memo);
+            let rr = dp(&grid, &n, i1, j1 + 1, i2, j2 + 1, memo);
+
+            let comb = i32::max(dd, i32::max(dr, i32::max(rd, rr)));
+
+            let out;
+            if comb == -1 {
+                out = -1;
+            } else {
+                if i1 == i2 && j1 == j2 {
+                    out = comb + grid[i1][j1];
+                } else {
+                    out = comb + grid[i1][j1] + grid[i2][j2];
+                }
+            }
+
+            memo.insert(*key, out);
+            out
+        }
+
+        i32::max(dp(&grid, &n, 0, 0, 0, 0, &mut memo), 0)
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::vec_vec_i32;
+
+    #[test]
+    fn test_cherry_pickup() {
+        assert_eq!(Solution::cherry_pickup(vec_vec_i32![[0, 1, -1], [1, 0, -1], [1, 1, 1]]), 5);
+    }
+
+    #[test]
+    fn test_cherry_pickup2() {
+        assert_eq!(Solution::cherry_pickup(vec_vec_i32![[1, 1, -1], [1, -1, 1], [-1, 1, 1]]), 0);
+    }
+}

src/leetcode/challenge/mod.rs

@@ -1,5 +1,7 @@
 mod break_palindrome;
+mod calculate_minimum_hp;
 mod can_partition_k_subsets;
+mod cherry_pickup;
 mod find_max_consecutive_ones;
 mod intersect;
 mod longest_common_subsequence;

src/leetcode/contest/biweekly_62.rs

@@ -0,0 +1,228 @@
+use std::collections::HashMap;
+
+// 2022. Convert 1D Array Into 2D Array, Easy
+// https://leetcode.com/problems/convert-1d-array-into-2d-array/
+impl Solution1 {
+    pub fn construct2_d_array(original: Vec<i32>, m: i32, n: i32) -> Vec<Vec<i32>> {
+        // check space
+        if original.len() != m as usize * n as usize {
+            return vec![];
+        }
+
+        let mut ans = vec![vec![0; n as usize]; m as usize];
+        let mut idx = 0;
+        for a in original {
+            ans[idx / n as usize][idx % n as usize] = a;
+            idx += 1;
+        }
+
+        ans
+    }
+}
+
+// 2023. Number of Pairs of Strings With Concatenation Equal to Target, Medium
+// https://leetcode.com/problems/number-of-pairs-of-strings-with-concatenation-equal-to-target/
+impl Solution2 {
+    pub fn num_of_pairs(nums: Vec<String>, target: String) -> i32 {
+        let mut ans = 0;
+        for i in 0..nums.len() {
+            for j in 0..nums.len() {
+                if i != j {
+                    if [nums[i].clone(), nums[j].clone()].concat() == target {
+                        ans += 1;
+                    }
+                }
+            }
+        }
+
+        ans as i32
+    }
+}
+
+// 2024. Maximize the Confusion of an Exam, Medium
+// https://leetcode.com/problems/maximize-the-confusion-of-an-exam/
+impl Solution3 {
+    pub fn max_consecutive_answers(answer_key: String, k: i32) -> i32 {
+        let nums: Vec<i32> = answer_key.chars().map(|c| if c == 'F' { 1 } else { 0 }).collect();
+
+        let [mut l, mut r] = [0, 0];
+        let mut uses = 0;
+        let n = nums.len();
+        let mut ans = 0;
+
+        while r < n {
+            if nums[r] == 0 {
+                uses += 1;
+            }
+            while uses > k {
+                if nums[l] == 0 {
+                    uses -= 1;
+                }
+                l += 1;
+            }
+
+            ans = ans.max(r - l);
+            r += 1;
+        }
+
+        r = 0;
+        l = 0;
+        uses = 0;
+
+        while r < n {
+            if nums[r] == 1 {
+                uses += 1;
+            }
+            while uses > k {
+                if nums[l] == 1 {
+                    uses -= 1;
+                }
+                l += 1;
+            }
+
+            ans = ans.max(r - l);
+            r += 1;
+        }
+
+        ans as i32 + 1
+    }
+}
+
+// 2025. Maximum Number of Ways to Partition an Array, Hard
+// https://leetcode.com/problems/maximum-number-of-ways-to-partition-an-array/
+impl Solution4 {
+    pub fn ways_to_partition(nums: Vec<i32>, k: i32) -> i32 {
+        let mut pre_calcs = Vec::<(i32, i32, usize)>::new();
+
+        let mut part1 = 0;
+        let mut part2 = nums.iter().sum::<i32>();
+        for i in 0..nums.len() {
+            part1 = part1 + nums[i];
+            part2 = part2 - nums[i];
+
+            pre_calcs.push((part1, part2, i));
+        }
+
+        let mut max = 0;
+        for i in 0..nums.len() {
+            let mut curr = 0;
+            for pre_calc in pre_calcs.iter() {
+                if i <= pre_calc.2 && pre_calc.0 - nums[i] + k == pre_calc.1 {
+                    curr += 1;
+                } else if i >= pre_calc.2 && pre_calc.0 == pre_calc.1 - nums[i] + k {
+                    curr += 1;
+                } else if pre_calc.0 == pre_calc.1 {
+                    curr += 1;
+                }
+            }
+
+            max = max.max(curr - 1);
+        }
+
+        max
+    }
+}
+
+struct Solution1 {}
+struct Solution2 {}
+struct Solution3 {}
+struct Solution4 {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{vec_string, vec_vec_i32};
+
+    #[test]
+    fn test_construct2_d_array() {
+        assert_eq!(Solution1::construct2_d_array(vec![1, 2, 3, 4], 2, 2), vec_vec_i32![[1, 2], [3, 4]]);
+    }
+
+    #[test]
+    fn test_construct2_d_array2() {
+        assert_eq!(Solution1::construct2_d_array(vec![1, 2, 3], 1, 3), vec_vec_i32![[1, 2, 3]]);
+    }
+
+    #[test]
+    fn test_construct2_d_array3() {
+        assert_eq!(Solution1::construct2_d_array(vec![1, 2], 1, 1), vec_vec_i32![]);
+    }
+
+    #[test]
+    fn test_construct2_d_array4() {
+        assert_eq!(Solution1::construct2_d_array(vec![3], 1, 2), vec_vec_i32![]);
+    }
+
+    #[test]
+    fn test_num_of_pairs() {
+        assert_eq!(Solution2::num_of_pairs(vec_string!["777", "7", "77", "77"], "7777".to_string()), 4);
+    }
+
+    #[test]
+    fn test_num_of_pairs2() {
+        assert_eq!(Solution2::num_of_pairs(vec_string!["123", "4", "12", "34"], "1234".to_string()), 2);
+    }
+
+    #[test]
+    fn test_num_of_pairs3() {
+        assert_eq!(Solution2::num_of_pairs(vec_string!["1", "1", "1"], "11".to_string()), 6);
+    }
+
+    #[test]
+    fn test_max_consecutive_answers() {
+        assert_eq!(Solution3::max_consecutive_answers("TTFF".to_string(), 2), 4);
+    }
+
+    #[test]
+    fn test_max_consecutive_answers2() {
+        assert_eq!(Solution3::max_consecutive_answers("TFFT".to_string(), 1), 3);
+    }
+
+    #[test]
+    fn test_max_consecutive_answers3() {
+        assert_eq!(Solution3::max_consecutive_answers("TTFTTFTT".to_string(), 1), 5);
+    }
+
+    #[test]
+    fn test_max_consecutive_answers4() {
+        assert_eq!(
+            Solution3::max_consecutive_answers(
+                "FTFFTFTFTTFTTFTTFFTTFFTTTTTFTTTFTFFTTFFFFFTTTTFTTTTTTTTTFTTFFTTFTFFTTTFFFFFTTTFFTTTTFTFTFFTTFTTTTTTF".to_string(),
+                32
+            ),
+            85
+        );
+    }
+
+    #[test]
+    fn test_ways_to_partition() {
+        assert_eq!(Solution4::ways_to_partition(vec![2, -1, 2], 3), 1);
+    }
+
+    #[test]
+    fn test_ways_to_partition2() {
+        assert_eq!(Solution4::ways_to_partition(vec![0, 0, 0], 1), 2);
+    }
+
+    #[test]
+    fn test_ways_to_partition4() {
+        assert_eq!(
+            Solution4::ways_to_partition(
+                vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30827, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                0
+            ),
+            33
+        );
+    }
+
+    #[test]
+    fn test_ways_to_partition5() {
+        assert_eq!(
+            Solution4::ways_to_partition(
+                vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -93166, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 93166, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                69428
+            ),
+            37
+        );
+    }
+}

src/leetcode/contest/mod.rs

@@ -0,0 +1,2 @@
+mod biweekly_62;
+mod weekly_261;

src/leetcode/contest/weekly_261.rs

@@ -0,0 +1 @@
+

src/leetcode/mod.rs

@@ -1,4 +1,5 @@
 mod challenge;
+mod contest;
 mod problem;
 mod top_interview;
 #[cfg_attr(test, macro_use)]