diff --git a/src/main.rs b/src/main.rs
index 3a53ea4..273b33b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,78 +1,44 @@
-use std::cmp::max;
-
 struct Solution;
 mod arr;
 impl Solution {
-    pub fn max_product_path(mut grid: Vec<Vec<i32>>) -> i32 {
-        let mut v = vec![vec![(-1_i64, 1_i64); grid[0].len()]; grid.len()];
-        let md = 1e9 as i64 + 7;
-        if grid[0][0] >= 0 {
-            v[0][0].0 = grid[0][0] as i64;
-        } else {
-            v[0][0].1 = grid[0][0] as i64;
-        }
-        for i in 1..grid[0].len() {
-            let x = grid[0][i] as i64;
-            if v[0][i - 1].0 >= 0 {
-                if x < 0 {
-                    v[0][i].1 = v[0][i - 1].0 * x;
-                } else {
-                    v[0][i].0 = v[0][i - 1].0 * x;
-                }
-            }
-            if v[0][i - 1].1 <= 0 {
-                if x < 0 {
-                    v[0][i].0 = v[0][i - 1].1 * x;
-                } else {
-                    v[0][i].1 = v[0][i - 1].1 * x;
-                }
+    fn get_product(a: i32, b: i32) -> i32 {
+        ((a as i64 * b as i64) % 12345) as i32
+    }
+    pub fn construct_product_matrix(mut grid: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
+        let mut arr = vec![0; grid.len() * grid[0].len()];
+        let mut ans = vec![0; grid.len() * grid[0].len()];
+        for i in 0..grid.len() {
+            for j in 0..grid[0].len() {
+                arr[i * grid[0].len() + j] = grid[i][j];
             }
         }
-        for i in 1..grid.len() {
-            if v[i - 1][0].0 >= 0 {
-                if grid[i][0] > 0 {
-                    v[i][0].0 = v[i-1][0].0 * grid[i][0] as i64;
-                }else {
-                    v[i][0].1 = v[i-1][0].0 * grid[i][0] as i64;
-                }
-            }
-            if v[i - 1][0].1 <= 0 {
-                if grid[i][0] > 0 {
-                    v[i][0].1 = v[i-1][0].1 * grid[i][0] as i64;
-                }else {
-                    v[i][0].0 = v[i-1][0].1 * grid[i][0] as i64;
-                }
-            }
-            for j in 1..grid[i].len() {
-                let mp = max(v[i-1][j].0,v[i][j-1].0);
-                let mn = -max(-v[i-1][j].1,-v[i][j-1].1);
-                if grid[i][j] > 0 {
-                    if mp >= 0 {
-                        v[i][j].0 = mp * grid[i][j] as i64;
-                    }
-                    if mn <= 0 {
-                        v[i][j].1 = mn * grid[i][j] as i64;
-                    }
-                }else {
-                    if mp >= 0 {
-                        v[i][j].1 = mp * grid[i][j] as i64;
-                    }
-                    if mn <= 0 {
-                        v[i][j].0 = mn * grid[i][j] as i64;
-                    }
-                }
+        ans[0] = arr[0];
+        for i in 1..arr.len() {
+            ans[i] = Solution::get_product(arr[i], ans[i - 1]);
+        }
+        let mut last = arr[ans.len() - 1];
+        for i in (1..arr.len()-1).rev() {
+            let x = arr[i];
+            arr[i] = Solution::get_product(ans[i-1], last);
+            last = Solution::get_product(last, x)
+        }
+        arr[0] = last % 12345;
+        arr[ans.len() - 1] = ans[ans.len() - 2] % 12345;
+        for i in 0..grid.len() {
+            for j in 0..grid[0].len() {
+                grid[i][j] = arr[i * grid[0].len() + j];
             }
         }
-        (v[grid.len() - 1][grid[0].len() - 1].0 % md) as i32
+        grid
     }
 }
 
 fn main() {
-    let result = Solution::max_product_path(arr::make_matrix(r#"[[1,3],[0,-4]]"#));
+    let result = Solution::construct_product_matrix(arr::make_matrix(r#"[[1,2],[3,4]]"#));
     println!("{:?}", result);
 }
 /*
 [[1,4,4,0]
 ,[-2,0,0,1]
 ,[1,-1,1,1]]
- */
\ No newline at end of file
+ */