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)

use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}


struct App {
    n: usize,
    adj: Vec<Vec<(usize, i64)>>,
    mem: Vec<Option<(i64, i64)>>,
    ok: bool,
    uniq: Option<i64>,
}

impl App {
    fn input() -> App {
        let n = read();
        let m= read();
        let mut adj: Vec<Vec<(usize, i64)>> = vec![vec![]; n];

        for _ in 0..m {
            let u = read::<usize>() - 1;
            let v = read::<usize>() - 1;
            let s = read::<i64>();
            adj[u].push((v, s));
            adj[v].push((u, s));
        }

        return App {
            n: n,
            adj: adj,
            mem: vec![None; n],
            ok: true,
            uniq: None,
        };
    }

    fn dfs(&mut self, v: usize, t: (i64, i64)) {
        // println!("{} {:?}", v, t);
        if let Some(s) = self.mem[v] {
            if s.1 == t.1 {
                self.ok &= (t == s);
            } else {
                let x = -(t.0 * t.1 + s.0 * s.1);
                self.ok &= (x % 2 == 0);
                let x = x / 2;
                self.ok &= x >= 1;

                if let Some(y) = self.uniq {
                    self.ok &= (x == y);
                } else {
                    self.uniq = Some(x);
                }
            }
        } else {
            self.mem[v] = Some(t);

            for &(tv, s) in self.adj[v].clone().iter() {
                let tt = (s - t.0, -t.1);
                self.dfs(tv, tt);
            }
        }
    }

    fn solve(&mut self) {
        self.dfs(0, (0, 1));

        if !self.ok {
            println!("0");
            return;
        }

        let mut ma: i64 = 1_000_000_010;
        let mut mi: i64 = 1;
        for i in 0..self.n {
            if let Some((a, b)) = self.mem[i] {
                if b == 1 {
                    mi = std::cmp::max(mi, 1 - a);
                } else {
                    ma = std::cmp::min(ma, a - 1);
                }
            } else {
                panic!();
            }
        }

        println!("{}",
            if let Some(a) = self.uniq {
                if mi <= a && a <= ma {
                    1
                } else {
                    0
                }
            } else {
                std::cmp::max(0, ma - mi + 1)
            });
    }
}



fn main() {
    let mut app = App::input();
    app.solve();
}