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 OCaml (4.02.3) (judge verdict: Wrong Answer)

type t = FIN | ANS of int | ILL;;

Scanf.scanf "%d %d" (fun n m ->
    let nei = Array.make n [] in
    for i = 1 to m do
        Scanf.scanf " %d %d %d" (fun u v s ->
            let u = u - 1 in
            let v = v - 1 in
            nei.(u) <- (v, s) :: nei.(u);
            nei.(v) <- (u, s) :: nei.(v);
        )
    done;

    let dist = Array.make n (0, 0) in

    let rec loop cur =
        let (c, v) = dist.(cur) in
        let rec loop2 = function
            | [] -> FIN
            | (nn, nc) :: tl ->
                let mc, mv = nc - c, -v in
                if dist.(nn) = (0, 0) then (
                    dist.(nn) <- mc, mv;
                    let ret = loop nn in
                    if ret = FIN then loop2 tl else ret)
                else (
                    if dist.(nn) = (mc, mv) then loop2 tl else (
                        let qc, qv = dist.(nn) in
                        if mv = qv then ILL else
                        if (qc - mc) mod (mv - qv) = 0 &&
                            (qc - mc) / (mv - qv) > 0 then (
                                ANS ((qc - mc) / (mv - qv))
                            ) else ILL
                    )
                )
        in
        loop2 nei.(cur)
    in

    let single k =
        let dist2 = Array.make n 0 in
        let rec loop cur =
            let c = dist2.(cur) in
            let rec loop2 = function
                | [] -> 1
                | (nn, nc) :: tl ->
                        let mc = nc - c in
                        if mc <= 0 then 0 else (
                            if dist2.(nn) = 0 then (
                                dist2.(nn) <- mc;
                                if loop nn = 1 then loop2 tl else 0
                            ) else (
                                if dist2.(nn) = mc then loop2 tl else 0
                            )
                        )
            in
            loop2 nei.(cur)
        in
        dist2.(0) <- k;
        loop 0
    in
    let check dist =
        let rec loop i l r =
            if i = n then max 0 (r - l + 1) else
                let (c, v) = dist.(i) in 
                if v = 1 then loop (i + 1) (max l (-c)) r
                         else loop (i + 1) l (min r (c - 1))
        in
        loop 0 1 max_int
    in

    dist.(0) <- 0, 1;
    match loop 0 with
    | FIN   -> Printf.printf "%d\n" @@ check dist
    | ANS k -> Printf.printf "%d\n" @@ single k
    | ILL   -> Printf.printf "0\n"
)