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: Wrong Answer)

use std::io::BufRead;

fn main() {
    let stdin = std::io::stdin();
    let (n, m): (usize, usize) = stdin.lock().gets().split(' ').values();
    let mut edges = vec![Vec::new(); n];
    let mut sv = vec![0; m];
    for (i, line) in stdin.lock().lines().take(n).map(|x| x.unwrap()).enumerate() {
        let (u, v, s): (usize, usize, i64) = line.split(' ').values();
        edges[u - 1].push((v - 1, s));
        edges[v - 1].push((u - 1, s));
        sv[i] = s;
    }

    let mut unique = None;
    let mut visited = vec![None; n];
    let mut stack = vec![(0, 0, true)];
    let (mut posmin, mut negmin) = (std::i64::MAX, std::i64::MAX);
    while let Some((n, acc, positive)) = stack.pop() {
        if let Some((acc2, positive2)) = visited[n] {
            if positive == positive2 {
                if acc != acc2 {
                    println!("0");
                    return;
                }
            } else {
                let sol = if positive { acc2 - acc } else { acc - acc2 };
                if sol % 2 != 0 {
                    println!("0");
                    return;
                }
                let sol = sol / 2;
                if let Some(x) = unique {
                    if sol != x {
                        println!("0");
                        return;
                    }
                } else {
                    unique = Some(sol);
                }
            }
            continue;
        }
        visited[n] = Some((acc, positive));
        if positive {
            posmin = std::cmp::min(posmin, acc);
        } else {
            negmin = std::cmp::min(negmin, acc);
        }
        for &(n2, s) in &edges[n] {
                stack.push((n2, s - acc, !positive));
            }
    }
    if let Some(sol) = unique {
        if posmin + sol > 0 && negmin - sol > 0 {
            println!("1");
        } else {
            println!("0");
        }
    } else {
        println!("{}", std::cmp::max(posmin + negmin - 1, 0));
    }
}

trait Gets { fn gets(&mut self) -> String; }
impl<T: std::io::BufRead> Gets for T {
    fn gets(&mut self) -> String { self.lines().next().unwrap().unwrap() } }

trait Values<T> { fn values(&mut self) -> T; }
impl<'a, I, T1, T2> Values<(T1, T2)> for I
    where I: Iterator<Item=&'a str>,
          T1: std::str::FromStr, T1::Err: std::fmt::Debug,
          T2: std::str::FromStr, T2::Err: std::fmt::Debug {
    fn values(&mut self) -> (T1, T2) {
        (self.next().unwrap().parse().unwrap(),
         self.next().unwrap().parse().unwrap())
    }
}
impl<'a, I, T1, T2, T3> Values<(T1, T2, T3)> for I
    where I: Iterator<Item=&'a str>,
          T1: std::str::FromStr, T1::Err: std::fmt::Debug,
          T2: std::str::FromStr, T2::Err: std::fmt::Debug,
          T3: std::str::FromStr, T3::Err: std::fmt::Debug {
    fn values(&mut self) -> (T1, T2, T3) {
        (self.next().unwrap().parse().unwrap(),
         self.next().unwrap().parse().unwrap(),
         self.next().unwrap().parse().unwrap())
    }
}