matrix traversal

Author: RUAN0007

Basic.md

@@ -184,15 +184,23 @@ Suitable for problems where solutions are within in a range and the tentative so
 # Handy code to produce a mapped index, like [0,2,4,1,3,5] or [0,2,4,1,3]
 (0..(n+1)/2).map(|x|{2*x}).collect(); // [0,2,4] when n=5 or 6.
 (0..n/2).map(|x|{2*x}).collect(); // [1,3] when n=5, or [1,3,5] when n=6.
-In [1,3,5,0,4] or [1,3,5,0,2,4], every consecutive three are not adjacent. 
+In [1,3,0,2,4] or [1,3,5,0,2,4], every consecutive 3 are not adjacent. 
 ```
 * [324. Wiggle Sort II](src/problem/p0324_wiggle_sort_ii.rs)
 * [767. Reorganize String](src/problem/p0767_reorganize_string.rs)
 
 ## Matrix Traversal
 ### Spiral
-### Left Diagonal
-### Right Diagonal
+* [54. Spiral Matrix](src/problem/p0054_spiral_matrix.rs)
+* [885. Spiral Matrix III](src/problem/p0885_spiral_matrix_iii.rs)
+### Diagonal
+* [498. Diagonal Traverse](src/problem/p0498_diagonal_traverse.rs)
+* [1424. Diagonal Traverse II](src/problem/p1424_diagonal_traverse_ii.rs)
+
+## Bit Operation
+## 2 Pointer
+## Array/String
+## DP
 ## Others
 * [42. Trapping Rain Water](src/problem/p0042_trapping_rain_water.rs)
 ### Palindrome Series

src/problem/mod.rs

@@ -170,3 +170,5 @@ mod p1092_shortest_common_supersequence;
 mod p0216_combination_sum_iii;
 mod p0212_word_search_ii;
 mod p0875_koko_eating_bananas;
+mod p0498_diagonal_traverse;
+mod p1424_diagonal_traverse_ii;

src/problem/p0054_spiral_matrix.rs

@@ -32,44 +32,49 @@ pub struct Solution {}
 impl Solution {
     pub fn spiral_order(matrix: Vec<Vec<i32>>) -> Vec<i32> {
         let mut result = vec![];
-        let row_count = matrix.len();
-        let col_count = matrix[0].len();
+        let row_count = matrix.len() as i32;
+        let col_count = matrix[0].len() as i32;
 
         let mut top = 0i32;
         let mut bottom = (row_count - 1) as i32;
         let mut left = 0i32;
         let mut right = (col_count - 1) as i32;
 
         loop { 
-            // println!("A top={}, bottom={}, left={}, right={}", top, bottom, left, right);
             for j in left..=right {
                 result.push(matrix[top as usize][j as usize]);
             }
-            top += 1;
-            if left > right || top > bottom {
+            // if left > right || top > bottom {
+            //     break;
+            // }
+            if result.len() as i32 == row_count * col_count {
                 break;
             }
+            top += 1;
 
-            // println!("B top={}, bottom={}, left={}, right={}", top, bottom, left, right);
             for i in top..=bottom {
                 result.push(matrix[i as usize][right as usize]);
             }
-            right-=1;
-            if left > right || top > bottom {break}
+            if result.len() as i32 == row_count * col_count {
+                break;
+            }
+            right -= 1;
 
-            // println!("C top={}, bottom={}, left={}, right={}", top, bottom, left, right);
             for j in (left..=right).rev() {
                 result.push(matrix[bottom as usize][j as usize]);
             }
-            bottom -=1;
-            if left > right || top > bottom {break}
+            if result.len() as i32 == row_count * col_count {
+                break;
+            }
+            bottom-=1;
 
-            // println!("D top={}, bottom={}, left={}, right={}", top, bottom, left, right);
             for i in (top..=bottom).rev() {
                 result.push(matrix[i as usize][left as usize]);
             }
-            left+=1;
-            if left > right || top > bottom {break}
+            if result.len() as i32 == row_count * col_count {
+                break;
+            }
+            left +=1;
         }
         result
     }

src/problem/p0498_diagonal_traverse.rs

@@ -0,0 +1,87 @@
+/**
+ * [498] Diagonal Traverse
+ *
+ * Given an m x n matrix mat, return an array of all the elements of the array in a diagonal order.
+ *  
+ * Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/04/10/diag1-grid.jpg" style="width: 334px; height: 334px;" />
+ * Input: mat = [[1,2,3],[4,5,6],[7,8,9]]
+ * Output: [1,2,4,7,5,3,6,8,9]
+ * 
+ * Example 2:
+ * 
+ * Input: mat = [[1,2],[3,4]]
+ * Output: [1,2,3,4]
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	m == mat.length
+ * 	n == mat[i].length
+ * 	1 <= m, n <= 10^4
+ * 	1 <= m * n <= 10^4
+ * 	-10^5 <= mat[i][j] <= 10^5
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/diagonal-traverse/
+// discuss: https://leetcode.com/problems/diagonal-traverse/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn valid(i : i32, j : i32, row_count : i32, col_count : i32) -> bool {
+        0 <= i && i < row_count && 0 <= j && j < col_count
+    }
+    pub fn find_diagonal_order(mat: Vec<Vec<i32>>) -> Vec<i32> {
+        let mut result = vec![];
+        let row_count : i32 = mat.len() as i32;
+        let col_count : i32 = mat[0].len() as i32;
+        let mut i : i32 = 0;
+        let mut j : i32 = 0;
+        loop {
+            while !Self::valid(i, j, row_count, col_count) {
+                i-=1;
+                j+=1;
+            }
+            while Self::valid(i, j, row_count, col_count) {
+                result.push(mat[i as usize][j as usize]);
+                i-=1;
+                j+=1;
+            }
+            j+=1;
+            if result.len() as i32 == row_count * col_count {
+                break;
+            }
+
+            while !Self::valid(i, j, row_count, col_count) {
+                i+=1;
+                j-=1;
+            }
+            while Self::valid(i, j, row_count, col_count) {
+                result.push(mat[i as usize][j as usize]);
+                i+=1;
+                j-=1;
+            }
+            j+=1;
+            if result.len() as i32 == row_count * col_count {
+                break;
+            }
+
+        }
+        result
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_498() {
+        assert_eq!(Solution::find_diagonal_order(vec![vec![1,2,3],vec![4,5,6],vec![7,8,9]]), vec![1,2,4,7,5,3,6,8,9]);
+    }
+}

src/problem/p1424_diagonal_traverse_ii.rs

@@ -0,0 +1,80 @@
+/**
+ * [1424] Diagonal Traverse II
+ *
+ * Given a list of lists of integers, nums, return all elements of nums in diagonal order as shown in the below images.
+ *  
+ * Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2020/04/08/sample_1_1784.png" style="width: 158px; height: 143px;" />
+ * 
+ * Input: nums = [[1,2,3],[4,5,6],[7,8,9]]
+ * Output: [1,4,2,7,5,3,8,6,9]
+ * 
+ * Example 2:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2020/04/08/sample_2_1784.png" style="width: 230px; height: 177px;" />
+ * 
+ * Input: nums = [[1,2,3,4,5],[6,7],[8],[9,10,11],[12,13,14,15,16]]
+ * Output: [1,6,2,8,7,3,9,4,12,10,5,13,11,14,15,16]
+ * 
+ * Example 3:
+ * 
+ * Input: nums = [[1,2,3],[4],[5,6,7],[8],[9,10,11]]
+ * Output: [1,4,2,5,3,8,6,9,7,10,11]
+ * 
+ * Example 4:
+ * 
+ * Input: nums = [[1,2,3,4,5,6]]
+ * Output: [1,2,3,4,5,6]
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	1 <= nums.length <= 10^5
+ * 	1 <= nums[i].length <= 10^5
+ * 	1 <= nums[i][j] <= 10^9
+ * 	There at most 10^5 elements in nums.
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/diagonal-traverse-ii/
+// discuss: https://leetcode.com/problems/diagonal-traverse-ii/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn find_diagonal_order(nums: Vec<Vec<i32>>) -> Vec<i32> {
+        let mut start_positions : Vec<(i32,i32)> = vec![];
+        let row_count : usize = nums.len();
+        let col_count : usize = nums[0].len();
+        for i in 0..row_count {
+            start_positions.push((i as i32, 0 as i32));
+        }
+        for j in 1..col_count {
+            start_positions.push((row_count as i32 - 1, j as i32));
+        }
+
+        let mut result : Vec<i32> = vec![];
+        for start_pos in start_positions.iter() {
+            let mut i = start_pos.0;
+            let mut j = start_pos.1;
+            while 0 <= i && i < row_count as i32 && 0 <=j && j < col_count as i32 {
+                result.push(nums[i as usize][j as usize]);
+                i-=1;
+                j+=1;
+            }
+        }
+        result
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1424() {
+        assert_eq!(Solution::find_diagonal_order(vec![vec![1,2,3],vec![4,5,6],vec![7,8,9]]), vec![1,4,2,7,5,3,8,6,9]);
+    }
+}