1/16/2020

Author: safrannn

README.md

@@ -2,7 +2,7 @@
 ### leetcode practise solutions in RUST
 
 ### current status
-167/1552 completed
+169/1552 completed
 
 ### Finished problems:
 |id|Solution| 
@@ -138,6 +138,7 @@
 |1013|[Partition Array Into Three Parts With Equal Sum](src/_1013_partition_array_into_three_parts_with_equal_sum.rs)|
 |1021|[Remove Outermost Parentheses](src/_1021_remove_outermost_parentheses_1029_two_city_scheduling.rs)|
 |1029|[Two City Scheduling](src/_1029_two_city_scheduling.rs)|
+|1136|[Parallel Courses](src/_1136_parallel_courses.rs)|
 |1239|[Maximum Length of a Concatenated String with Unique Characters ](src/_1239_maximum_length_of_a_concatenated_string_with_unique_characters.rs)|
 |1249|[Minimum Remove to Make Valid Parentheses](src/_1249_minimum_remove_to_make_valid_parentheses.rs)|
 |1281|[Subtract the Product and Sum of Digits of an Integer](src/_1281_subtract_the_product_and_sum_of_digits_of_an_integer.rs)|
@@ -178,4 +179,5 @@
 |1704|[Determine if String Halves Are Alike](src/_1704_determine_if_string_halves_are_alike.rs)|
 |1705|[Maximum Number of Eaten Apples  ](src/_1705_maximum_number_of_eaten_apples.rs)|
 |1706|[Where Will the Ball Fall](src/_1706_where_will_the_ball_fall.rs)|
-||[](src/.rs)|
+|1725|[Number Of Rectangles That Can Form The Largest Square](src/_1725_number_of_rectangles_that_can_form_the_largest_square.rs)|
+|1726|[Tuple with Same Product](src/_1726_tuple_with_same_product.rs)|

src/_0009_palindrome_number.rs

@@ -5,13 +5,13 @@ impl Solution {
         if x < 0 {
             return false;
         }
-        let mut digits = Vec::new();
+        let mut reversed = 0;
         let mut number = x;
         while number > 0 {
-            digits.push(number % 10);
+            reversed = reversed * 10 + number % 10;
             number /= 10;
         }
-        digits == digits.iter().copied().rev().collect::<Vec<i32>>()
+        x == reversed
     }
 }
 

src/_1136_parallel_courses.rs

@@ -0,0 +1,57 @@
+use std::collections::{HashMap, VecDeque};
+
+struct Solution;
+impl Solution {
+    pub fn minimum_semesters(n: i32, relations: Vec<Vec<i32>>) -> i32 {
+        let mut adjacents: HashMap<i32, Vec<i32>> = HashMap::new();
+        let mut indegrees: Vec<i32> = vec![0; n as usize + 1];
+        let mut queue: VecDeque<i32> = VecDeque::new();
+        let mut answer = 0;
+
+        for v in relations {
+            adjacents.entry(v[0]).or_default().push(v[1]);
+            indegrees[v[1] as usize] += 1;
+        }
+
+        for i in 1..=n as usize {
+            if indegrees[i] == 0 {
+                queue.push_back(i as i32);
+            }
+        }
+
+        while !queue.is_empty() {
+            answer += 1;
+            let m = queue.len();
+            for _ in 0..m {
+                let u = queue.pop_front().unwrap();
+                if let Some(adjs) = adjacents.get(&u) {
+                    for &w in adjs.iter() {
+                        indegrees[w as usize] -= 1;
+                        if indegrees[w as usize] == 0 {
+                            queue.push_back(w);
+                        }
+                    }
+                }
+            }
+        }
+
+        for v in indegrees {
+            if v > 0 {
+                return -1;
+            }
+        }
+        answer
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::minimum_semesters(3, vec_vec_i32![[1, 3], [2, 3]]),
+        2
+    );
+    assert_eq!(
+        Solution::minimum_semesters(3, vec_vec_i32![[1, 2], [2, 3], [3, 1]]),
+        -1
+    );
+}

src/_1725_number_of_rectangles_that_can_form_the_largest_square.rs

@@ -0,0 +1,32 @@
+struct Solution;
+
+impl Solution {
+    pub fn count_good_rectangles(rectangles: Vec<Vec<i32>>) -> i32 {
+        let mut max_square_side = 0;
+        let mut max_square_count = 0;
+
+        for v in rectangles {
+            let side = v[0].min(v[1]);
+            if side > max_square_side {
+                max_square_side = side;
+                max_square_count = 1;
+            } else if side == max_square_side {
+                max_square_count += 1;
+            }
+        }
+
+        max_square_count
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::count_good_rectangles(vec_vec_i32![[5, 8], [3, 9], [5, 12], [16, 5]]),
+        3
+    );
+    assert_eq!(
+        Solution::count_good_rectangles(vec_vec_i32![[2, 3], [3, 7], [4, 3], [3, 7]]),
+        3
+    );
+}

src/_1726_tuple_with_same_product.rs

@@ -0,0 +1,27 @@
+use std::collections::HashMap;
+struct Solution;
+impl Solution {
+    pub fn tuple_same_product(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut result = 0;
+        let mut products: HashMap<i32, i32> = HashMap::new();
+        for i in 0..n - 1 {
+            for j in i + 1..n {
+                *products.entry(nums[i] * nums[j]).or_default() += 1;
+            }
+        }
+
+        for (_, v) in products {
+            result += v * (v - 1) / 2;
+        }
+        result * 8
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::tuple_same_product(vec![2, 3, 4, 6]), 8);
+    assert_eq!(Solution::tuple_same_product(vec![1, 2, 4, 5, 10]), 16);
+    assert_eq!(Solution::tuple_same_product(vec![2, 3, 4, 6, 8, 12]), 40);
+    assert_eq!(Solution::tuple_same_product(vec![2, 3, 5, 7]), 0);
+}

src/lib.rs

@@ -276,6 +276,8 @@ mod _1021_remove_outermost_parentheses;
 //
 mod _1029_two_city_scheduling;
 //
+mod _1136_parallel_courses;
+//
 mod _1152_analyze_user_website_visit_pattern;
 //
 mod _1239_maximum_length_of_a_concatenated_string_with_unique_characters;
@@ -358,4 +360,9 @@ mod _1705_maximum_number_of_eaten_apples;
 //
 mod _1706_where_will_the_ball_fall;
 //
+mod _1725_number_of_rectangles_that_can_form_the_largest_square;
+//
+mod _1726_tuple_with_same_product;
+//
 mod test;
+//

src/test.rs

@@ -1 +1,77 @@
+struct Solution;
 
+impl Solution {
+    pub fn count_good_rectangles(rectangles: Vec<Vec<i32>>) -> i32 {
+        let mut max_square_side = 0;
+        let mut max_square_count = 0;
+
+        for v in rectangles {
+            let side = v[0].min(v[1]);
+            if side > max_square_side {
+                max_square_side = side;
+                max_square_count = 1;
+            } else if side == max_square_side {
+                max_square_count += 1;
+            }
+        }
+
+        max_square_count
+    }
+}
+
+use std::collections::HashMap;
+impl Solution {
+    pub fn tuple_same_product(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut result = 0;
+        let mut products: HashMap<i32, i32> = HashMap::new();
+        for i in 0..n - 1 {
+            for j in i + 1..n {
+                *products.entry(nums[i] * nums[j]).or_default() += 1;
+            }
+        }
+
+        for (_, v) in products {
+            result += v * (v - 1) / 2;
+        }
+        result * 8
+    }
+}
+
+impl Solution {
+    pub fn largest_submatrix(matrix: Vec<Vec<i32>>) -> i32 {
+        let mut result: i32 = 0;
+        let n = matrix.len();
+        let m = matrix[0].len();
+        if n == 1 {
+            return matrix[0].clone().into_iter().sum();
+        }
+        for j in 0..m {
+            let mut ix = 0;
+            let mut iy = 0;
+            while iy < n {
+                if matrix[iy][j] == 0 {
+                    ix = iy + 1;
+                } else {
+                    let mut right_count = 0;
+                    for j_test in j..m {
+                        let mut all_one = true;
+                        for i_test in ix..=iy {
+                            if matrix[i_test][j_test] == 0 {
+                                all_one = false;
+                                break;
+                            }
+                        }
+                        if all_one {
+                            right_count += 1;
+                        }
+                    }
+                    println!("{:?},{:?},{:?}", ix, iy, right_count);
+                    result = result.max((iy - ix + 1) as i32 * right_count);
+                }
+                iy += 1;
+            }
+        }
+        result
+    }
+}