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 Ruby (2.3.3) (judge verdict: Accepted)

n, m = gets.split.map(&:to_i)
edges = Array.new(n+1){{}}
m.times do
    u, v, s = gets.split.map(&:to_i)
    edges[u][v] = s
    edges[v][u] = s
end

# 「仮に」頂点1を0として、各頂点の値を決めていく。
# この情報を元に、最後に「頂点0の値は何通り取れるか？」で答えを出す。
# もし途中でどうしても解消できない矛盾が発生したら、その時点で答えゼロで終了して良い。

# 頂点1を+として、辺をまたぐごとに+, -, +, ...とラベル付けする。+ならtrue、-ならfalse。
# 頂点1の値を1増やした時に、+の点の値は1増えて、-の点の値は1減ることになる。
plus = []
plus[1] = true

# 頂点1の値を0としたときの、各頂点の値。この時点では、値が非正になることは気にしない。
value = []
value[1] = 0

# 探索途中に、頂点1の値が途中で確定してしまうことがある。その時にこの変数に保存する。
# nilは未確定であることを示す
offset = nil

# DFSで探索。（BFSでもいい）
stack = [1]
while stack.length > 0
    u = stack.pop
    edges[u].each do |v, c|
    next if u == v

        # まだ訪れていない頂点なので、閉路ではない。符号と値を格納するだけ。
        unless value[v]
            plus[v] = !plus[u]
            value[v] = c - value[u]
            stack.push(v)
            next
        end

        # 偶閉路になった場合。
        # この場合は頂点1の値をずらしても2頂点の数の合計は変わらない。
        # そのため、値がずれていたら即矛盾。答えゼロで終了。
        # （例：aをどのように取っても、(3+a) + (5-a) = 10 にはできない。）
        if plus[v] != plus[u]
            if value[v] + value[u] != c
                puts 0
                exit
            end
            next
        end

        # 奇閉路になった場合。
        # この場合は頂点1の値を適切に取ることで整合を取れる可能性がある。
        # 例：(3+a) + (5+a) = 10 にしたいなら、a=1である必要がある。

        if !plus[v]
            diff = c - (value[v] + value[u])
        else
            diff = (value[v] + value[u]) - c
        end

        # ずれが奇数ならアウト
        if diff % 2 == 1
            puts 0
            exit
        end

        # 偶数の閉路が2箇所以上あって、それぞれが要求する頂点1の値が食い違う場合アウト
        if offset && offset != diff/2
            puts 0
            exit
        end

        # offsetは「頂点1の値がこの値でないと、整合性が取れない」という制約を示している
        offset = diff/2
    end
end


# ここからは、「全部の頂点の値が正か？」も考慮して、整数の付け方が何通りあるかを考える
# +, -それぞれのラベルが付いた点について、値の最小値を取る
posval = (1..n).select{|i|plus[i]}.map{|i|value[i]}
posneg = (1..n).select{|i|!plus[i]}.map{|i|value[i]}
posmin = posval.min
negmin = posneg.min

# offsetが存在する、つまり奇閉路による制約がある場合、答えは高々1通り。
# そのoffsetで非正な値の頂点が存在してしまう場合は0通り。
if offset
    if posmin - offset > 0 && negmin + offset > 0
        puts 1
    else
        puts 0
    end
# 奇閉路による制約が存在しない場合、全ての頂点が正になるという条件で任意のoffsetを選べる。
else
    puts [posmin+negmin-1, 0].max
end