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;
                }
            }
        }
        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[grid.len() - 1][grid[0].len() - 1].0 % md) as i32
    }
}

fn main() {
    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]]
 */