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 C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define REP(i,n) for (ll i = 0; i < (n); ++i)
#define RREP(i, n) for (ll i = (n) - 1; i >= 0; --i)
#define ALL(v) (v).begin(), (v).end()


int main(){
    ll n, m;
    cin >> n >> m;
    vector<vector<pair<ll, ll>>> net(n);
    REP(i, m){
        ll ui, vi, si;
        cin >> ui >> vi >> si;
        ui--; vi--;
        net.at(ui).emplace_back(vi, si);
        net.at(vi).emplace_back(ui, si);
    }

    vector<bool> vis(n, false);
    vector<ll> parity(n, -1);
    vector<ll> bias(n, 0);
    vis.at(0) = true;
    parity.at(0) = 0;
    queue<ll> que;
    que.push(0);

    ll lb = 1, ub = numeric_limits<ll>::max();
    while(!que.empty()){
        const ll u = que.front(); que.pop();
        for(const auto& p : net.at(u)){
            const ll v = p.first;
            const ll s = p.second;
            if(!vis.at(v)){
                vis.at(v) = true;
                parity.at(v) = 1 - parity.at(u);
                bias.at(v) = s - bias.at(u);
                if(parity.at(v) == 0){
                    // bv + x >= 1 <=> x >= 1 - bv
                    lb = max(lb, 1 - bias.at(v));
                }else{
                    // bv - x >= 1 <=> bv - 1 >= x
                    ub = min(ub, bias.at(v) - 1);
                }
                que.push(v);
            }else{
                if(parity.at(u) == parity.at(v)){
                    // parity = 0 => bu + x + bv + x = s <=> 2x = s - bu - bv
                    // parity = 1 => bu - x + bv - x = s <=> bu + bv - s = 2x
                    ll twox = s - bias.at(u) - bias.at(v);
                    if(parity.at(u)){ twox *= -1; }
                    if(twox <= 0 || twox % 2 != 0){
                        cout << 0 << endl;
                        return 0;
                    }else{
                        lb = max(lb, twox / 2);
                        ub = min(ub, twox / 2);
                    }
                }else if(bias.at(u) + bias.at(v) != s){
                    // bu + x + bv - x = s or bu - x + bv + x = s
                    cout << 0 << endl;
                    return 0;
                }
            }
        }
    }

    cout << max(ub - lb + 1, 0LL) << endl;

    return 0;
}