use std::rc::Rc;
use std::cell::RefCell;
use std::borrow::Borrow;

impl Solution {
    fn dfs(root: Option<Rc<RefCell<TreeNode>>>,
           parent: Option<Rc<RefCell<TreeNode>>>, l: usize) -> usize {
        if let Some(node) = root {
            let mut length = l;
            if let Some(p) = parent {
                if RefCell::borrow(&p).val + 1 == RefCell::borrow(&node).val {
                    length += 1;
                } else {
                    length = 1;
                }
            } else {
                length = 1;
            }
            return std::cmp::max(length,
            std::cmp::max(Self::dfs(RefCell::borrow(&node).left.clone(), Some(node.clone()), length),
            Self::dfs(RefCell::borrow(&node).right.clone(), Some(node.clone()), length)));
        } else {
            return l;
        }

        return 0;
    }
    pub fn longest_consecutive(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
        return Self::dfs(root, None, 0) as i32;
    }
}

impl Solution {
    pub fn find_max_consecutive_ones(nums: Vec<i32>) -> i32 {
        let (mut sum, mut ans) = (0, 0);
        for num in nums {
            if num == 1 {
                sum += 1;
                ans = std::cmp::max(ans, sum);
            } else {
                sum = 0;
            }
        }
        return ans;
    }
}

impl Solution {
    pub fn find_max_consecutive_ones(a: Vec<i32>) -> i32 {
        let (mut ans, mut zeros, mut sum) = (0, 0, 0);
        let mut i = 0;
        for j in 0..a.len() {
            if a[j] == 0 {
                zeros += 1;
            }
            while zeros > 1 {
                if a[i] == 0 {
                    zeros -= 1;
                }
                i += 1;
            }
            ans = std::cmp::max(ans, j - i + 1);
        }
        return ans as i32;
    }
}