Problem:
Score : 600 points

Problem Statement

Kenkoooo found a simple connected graph.
The vertices are numbered 1 through n.
The i-th edge connects Vertex u_i and v_i, and has a fixed integer s_i.

Kenkoooo is trying to write a positive integer in each vertex so that the following condition is satisfied:

For every edge i, the sum of the positive integers written in Vertex u_i and v_i is equal to s_i.

Find the number of such ways to write positive integers in the vertices.

Constraints

2 \leq n \leq 10^5

1 \leq m \leq 10^5

1 \leq u_i < v_i \leq n

2 \leq s_i \leq 10^9

If i\neq j, then u_i \neq u_j or v_i \neq v_j.

The graph is connected.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

n m
u_1 v_1 s_1
:
u_m v_m s_m

Output

Print the number of ways to write positive integers in the vertices so that the condition is satisfied.

Sample Input 1

3 3
1 2 3
2 3 5
1 3 4

Sample Output 1

1

The condition will be satisfied if we write 1,2 and 3 in vertices 1,2 and 3, respectively.
There is no other way to satisfy the condition, so the answer is 1.

Sample Input 2

4 3
1 2 6
2 3 7
3 4 5

Sample Output 2

3

Let a,b,c and d be the numbers to write in vertices 1,2,3 and 4, respectively.
There are three quadruples (a,b,c,d) that satisfy the condition:

(a,b,c,d)=(1,5,2,3)

(a,b,c,d)=(2,4,3,2)

(a,b,c,d)=(3,3,4,1)

Sample Input 3

8 7
1 2 1000000000
2 3 2
3 4 1000000000
4 5 2
5 6 1000000000
6 7 2
7 8 1000000000

Sample Output 3

0

Solution in Rust (1.15.1) (judge verdict: Accepted)

#![allow(unused_imports)]
#![allow(dead_code)]
#![allow(unused_must_use)]
use std::io::{stdin, stdout, stderr, Write, BufWriter, BufReader, BufRead};
use std::collections::BinaryHeap;

use util::IterExt;
macro_rules! read_from_line {
    ($inbuf:ident => $($name:ident : $ty:ty),* ) => {
        let mut buf = String::new();
        $inbuf.read_line(&mut buf).unwrap();
        buf.pop();
        let mut words = buf.split_whitespace();
        $(
            let $name:$ty = words.next().unwrap().parse().unwrap();
        )*
    };
}

macro_rules! read_many {
    ($inbuf:ident => $name:ident : $ty:ty) => {
        let $name: Vec<$ty> = strio::read_many_from_line(&mut $inbuf);
    };
}

#[derive(PartialEq, Eq, Debug)]
struct RevOrd<T>(T);

impl<T> PartialOrd for RevOrd<T> where T: PartialOrd {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        other.0.partial_cmp(&self.0)
    }
}

impl<T> Ord for RevOrd<T> where T: Ord {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        other.0.cmp(&self.0)
    }
}

#[derive(Debug)]
struct KV<K, V> {
    k: K,
    v: V
}
impl <K, V> KV<K, V> {
    fn new(k: K, v: V) -> Self {
        KV {k:k, v:v}
    }
}
impl <K, V> PartialEq for KV<K, V> where V: PartialEq {
    fn eq(&self, other: &Self) -> bool {
        self.v.eq(&other.v)
    }
}
impl <K, V> Eq for KV<K, V> where V: Eq { }
impl<K, V> PartialOrd for KV<K, V> where V: PartialOrd {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.v.partial_cmp(&other.v)
    }
}
impl<K, V> Ord for KV<K, V> where V: Ord {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.v.cmp(&other.v)
    }
}


fn main() {
    let cout = stdout();
    let mut cout = BufWriter::new(cout.lock());
    let cin = stdin();
    let mut cin = BufReader::new(cin.lock());

    #[derive(Debug, Clone, Copy)]
    struct Edge {
        to: usize,
        s: i64,
    }

    read_from_line!(cin => n:usize, m:usize);
    let mut edge : Vec<Vec<Edge>> = vec![vec![]; n + 1];
    for i in 1 .. m + 1 {
        read_from_line!(cin => u:usize, v:usize, s:i64);
        edge[u].push(Edge{to:v, s:s});
        edge[v].push(Edge{to:u, s:s});
    }

    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    struct Poly {
        sig: bool,
        a: i64,
    }
    impl Poly {
        fn subtract_from(&self, s: i64) -> Poly {
            Poly {
                sig: !self.sig,
                a: s - self.a,
            }
        }
    }

    let mut ps = vec![None; n + 1];
    ps[1] = Some(Poly {sig: true, a: 0});
    let mut stack = vec![1];
    let mut contradiction = false;
    let mut only_n = None;
    'mainloop: while let Some(u) = stack.pop() {
        let pu = ps[u].unwrap();
        for next in edge[u].iter() {
            let v = next.to;
            let s = next.s;
            match ps[v] {
                None => {
                    ps[v] = Some(pu.subtract_from(s));
                    stack.push(v);
                },
                Some(pv) => {
                    let pv_here = pu.subtract_from(s);
                    if (pv_here == pv) {
                        continue;
                    } else if (pv.sig == pv_here.sig) {
                        contradiction = true;
                        break 'mainloop;
                    } else {
                        let (a, b) = if pv.sig { (pv.a,  pv_here.a) } else { (pv_here.a, pv.a) };
                        //2n = b - a >= 2
                        if (b < a + 2) {
                            contradiction = true;
                            break 'mainloop;
                        } else if ((b - a) % 2 == 1) {
                            contradiction = true;
                            break 'mainloop;
                        } else if (only_n.is_none()) {
                            only_n = Some((b - a) / 2);
                        } else {
                            if (only_n == Some((b - a) / 2)) {
                                continue;
                            } else {
                                contradiction = true;
                                break 'mainloop;
                            }
                        }
                    }
                },
                
            }
        }
    }
    //println!("{:?} {:?} {:?}", contradiction, only_n, ps);
    if contradiction {
        writeln!(cout, "0");
        return;
    }

    let mut min_bound = 1;
    let mut max_bound = <i64>::max_value();
    
    for p in ps {
        if p.is_none() { continue; }
        let poly = p.unwrap();
        if (poly.sig) {
            min_bound = std::cmp::max(min_bound, 1 - poly.a);
        } else {
            max_bound = std::cmp::min(max_bound, poly.a - 1); 
        }
    }

    if (max_bound < min_bound) {
        writeln!(cout, "0");
    } else if let Some(only) = only_n {
        if (min_bound <= only && only <= max_bound) {
            writeln!(cout, "1");
        } else {
            writeln!(cout, "0");
        }
    } else {
        writeln!(cout, "{}", max_bound - min_bound + 1);
    }






}

mod util {
    use std;
    use std::ops::{Deref, AddAssign};
    use std::iter::{Once, Chain, Scan};
    use std::borrow::Borrow;

    pub trait IterExt where
        Self: Iterator
    {
        fn scan_init<'a, St : 'a, F : 'a> (self, initial_state: St, f: F) -> Box<Iterator<Item=St> + 'a> /*Chain<Once<St>, Scan<Self, St, F>>*/  where
            Self: Sized + 'a,
            F: FnMut(&mut St, Self::Item) -> Option<St>,
            St: Clone
        {
            Box::new(std::iter::once(initial_state.clone()).chain(self.scan(initial_state, f)))
        }

        fn accum<'a, T> (self, init: T) -> Box<Iterator<Item=T> + 'a> where
            Self: Sized + 'a,
            Self::Item: Borrow<T>,
            T: Clone + AddAssign + 'a,
        {
            Box::new(self.scan_init(init, |sum, x| { *sum += x.borrow().clone(); Some(sum.clone()) }))
        }
    }

    impl<T> IterExt for T where
        T: Iterator
    { }

    pub fn test()
    {
        let v:Vec<i32> = vec![1, 4 ,2];
        for x in v.iter().accum(0) {
            println!("{}", x);
        }
        for x in v.iter().accum(0).accum(0) {
            println!("{}", x);
        }

    }

}

mod strio {
    use std::str::FromStr;
    use std;

    pub fn read_from_line<T, R> (r: &mut R) -> T where
        T: FromStr,
        <T as std::str::FromStr>::Err : std::fmt::Debug,
        R: std::io::BufRead,
    {
        let mut buf = String::new();
        r.read_line(&mut buf).unwrap();
        buf.pop();
        buf.parse().unwrap()
    }

    pub fn read_many_from_line<T, R> (r: &mut R) -> Vec<T> where
        T: FromStr,
        <T as std::str::FromStr>::Err : std::fmt::Debug,
        R: std::io::BufRead,
    {
        let mut buf = String::new();
        r.read_line(&mut buf).unwrap();
        buf.pop();
        buf.split_whitespace().map(|x| x.parse().unwrap()).collect()
    }
}