diff --git a/src/main.rs b/src/main.rs
index 9af7bc9..3a53ea4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,43 +1,78 @@
+use std::cmp::max;
+
 struct Solution;
 mod arr;
 impl Solution {
-    fn is_same(mat: &Vec<Vec<i32>>, target: &Vec<Vec<i32>>) -> bool {
-        for i in 0..mat.len() {
-            for j in 0..mat[i].len() {
-                if mat[i][j] != target[i][j] {
-                    return false;
+    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;
                 }
             }
         }
-        true
-    }
-    pub fn find_rotation(mat: Vec<Vec<i32>>, target: Vec<Vec<i32>>) -> bool {
-        let mut v = vec![vec![0; mat[0].len()]; mat.len()];
-        if Solution::is_same(&mat, &target) {
-            return true;
-        }
-        for x in 1..4 {
-            for i in 0..mat.len() {
-                for j in 0..mat[i].len() {
-                    let (mut py, mut px) = (i, j);
-                    for _ in 0..x {
-                        (px, py) = (mat.len() - 1 - py, px)
+        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;
                     }
-                    v[py][px] = mat[i][j];
                 }
             }
-            if Self::is_same(&v, &target) {
-                return true;
-            }
         }
-        false
+        (v[grid.len() - 1][grid[0].len() - 1].0 % md) as i32
     }
 }
 
 fn main() {
-    let result = Solution::find_rotation(
-        arr::make_matrix(r#"[[1,0,0],[1,0,1],[0,0,1]]"#),
-        arr::make_matrix(r#"[[0,1,1],[0,0,0],[1,1,0]]"#),
-    );
+    let result = Solution::max_product_path(arr::make_matrix(r#"[[1,3],[0,-4]]"#));
     println!("{:?}", result);
 }
+/*
+[[1,4,4,0]
+,[-2,0,0,1]
+,[1,-1,1,1]]
+ */
\ No newline at end of file