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)

///////////////////////////////////////////// Template /////////////////////////////////////////////
#![allow(non_snake_case, unused)]
use std::io::Write;
use std::collections::*;

macro_rules! debug {
	($($v: expr),*) => {
		$(let _ = write!(::std::io::stderr(), "{} = {:?} ", stringify!($v), $v);)*
		let _ = writeln!(::std::io::stderr(), "@ {}:{}", file!(), line!());
	}
}
macro_rules! mat {
	($e:expr) => { $e };
	($e:expr; $d:expr $(; $ds:expr)*) => { vec![mat![$e $(; $ds)*]; $d] };
}
macro_rules! ok {
	($a:ident$([$i:expr])*.$f:ident()$(@$t:ident)*) => {
		$a$([$i])*.$f($($t),*)
	};
	($a:ident$([$i:expr])*.$f:ident($e:expr$(,$es:expr)*)$(@$t:ident)*) => { {
		let t = $e;
		ok!($a$([$i])*.$f($($es),*)$(@$t)*@t)
	} };
}
mod template {
	type I<'a> = ::std::iter::Peekable<::std::str::SplitWhitespace<'a>>;
	pub trait FromLn<'a> {
		fn fromln(&mut I<'a>) -> Self;
	}
	pub fn readln<T: for<'a> FromLn<'a>>() -> T {
		let mut buf = String::new();
		let _ = ::std::io::stdin().read_line(&mut buf).unwrap_or_else(|e| panic!("{}", e));
		let mut it = buf.split_whitespace().peekable();
		let t = T::fromln(&mut it);
		if it.peek().is_some() { panic!("input mismatch") }
		t
	}
	pub fn readlns<T: for<'a> FromLn<'a>>(n: usize) -> Vec<T> {
		(0..n).map(|_| readln()).collect()
	}
	macro_rules! read_primitives {
		($($t:ty),*) => { $(
			impl<'a> FromLn<'a> for $t {
				fn fromln(it: &mut I<'a>) -> $t {
					it.next().unwrap_or_else(|| panic!("input mismatch")).parse().unwrap_or_else(|e| panic!("{}", e))
				}
			}
		)* }
	}
	read_primitives!(String, bool, f64, i32, i64, usize, u32, u64);
	impl<'a, T> FromLn<'a> for Vec<T> where T: for<'b> FromLn<'b> {
		fn fromln(it: &mut I) -> Vec<T> {
			let mut vs = vec![];
			while it.peek().is_some() {
				vs.push(T::fromln(it));
			}
			vs
		}
	}
	impl<'a> FromLn<'a> for Vec<char> {
		fn fromln(it: &mut I) -> Vec<char> {
			String::fromln(it).chars().collect()
		}
	}
	impl<'a> FromLn<'a> for Vec<u8> {
		fn fromln(it: &mut I) -> Vec<u8> {
			String::fromln(it).into()
		}
	}
	macro_rules! read_tuple {
		($($t:ident),*) => {
			impl<'a, $($t),*> FromLn<'a> for ($($t),*) where $($t: for<'b> FromLn<'b>),* {
				fn fromln(it: &mut I) -> ($($t),*) {
					($($t::fromln(it)),*)
				}
			}
		}
	}
	read_tuple!(A, B);
	read_tuple!(A, B, C);
	read_tuple!(A, B, C, D);
	pub trait SetMin {
		fn setmin(&mut self, v: Self) -> bool;
	}
	impl<T> SetMin for T where T: PartialOrd {
		fn setmin(&mut self, v: T) -> bool {
			*self > v && { *self = v; true }
		}
	}
	pub trait SetMax {
		fn setmax(&mut self, v: Self) -> bool;
	}
	impl<T> SetMax for T where T: PartialOrd {
		fn setmax(&mut self, v: T) -> bool {
			*self < v && { *self = v; true }
		}
	}
}
use self::template::*;
pub fn main() {
	let _ = writeln!(::std::io::stderr(), "----- {} -----", file!());
	let _ = ::std::thread::Builder::new().name("run".to_string()).stack_size(32 * 1024 * 1024).spawn(run).unwrap().join();
}
////////////////////////////////////////////////////////////////////////////////////////////////////

fn run() {
	let (n, m) = readln::<(usize, usize)>();
	let mut g = vec![vec![]; n];
	for (u, v, s) in readlns::<(usize, usize, i64)>(m) {
		let u = u - 1;
		let v = v - 1;
		g[u].push((v, s));
		g[v].push((u, s));
	}
	let mut val = vec![vec![]; n];
	let mut stack = vec![];
	stack.push(0);
	val[0].push((1, 0));
	while let Some(u) = stack.pop() {
		let (x, c) = val[u][0];
		for &(v, s) in &g[u] {
			if val[v].len() == 0 {
				stack.push(v);
			}
			val[v].push((-x, s - c));
		}
	}
	let mut ok = true;
	let mut lb = 1;
	let mut ub = 10000000000;
	for u in 0..n {
		let mut pos = None;
		let mut neg = None;
 		for &(x, c) in &val[u] {
			 if x > 0 {
				 if pos.is_none() {
					 pos = Some(c);
				 } else if pos.unwrap() != c {
					 ok = false;
				 }
			 } else {
				 if neg.is_none() {
					 neg = Some(c);
				 } else if neg.unwrap() != c {
					 ok = false;
				 }
			 }
		 }
		 if let Some(c) = pos {
			 lb.setmax(1 - c);
		 }
		 if let Some(c) = neg {
			 ub.setmin(c - 1);
		 }
		 if let (Some(c1), Some(c2)) = (pos, neg) {
			 if (c2 - c1) % 2 != 0 {
				 ok = false;
			 } else {
				 lb.setmax((c2 - c1) / 2);
				 ub.setmin((c2 - c1) / 2);
			 }
		 }
	}
	if ok {
		let mut ans = (ub - lb + 1);
		ans.setmax(0);
		println!("{}", ans);
	} else {
		println!("0");
	}
}