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: Wrong Answer)

#include <bits/stdc++.h>
using namespace std;

typedef long long int ll;
typedef pair<ll, ll> pll;

#define FOR(i, n, m) for (ll(i) = (m); (i) < (n); ++(i))
#define REP(i, n) FOR(i, n, 0)
#define OF64 std::setprecision(10)

const ll MOD = 1000000007;
const ll INF = (ll)1e15;

struct Vertex
{
    vector<pll> n;
};
struct VertexInfo
{
    //! 0番目のvertexが1の時の値
    ll n;
    //! 0番目のvertexが1増えた時、値が上がるノードか
    bool up = false;
};

Vertex V[100005];
VertexInfo Info[100005];
bool U[100005];

int main()
{
    int N, M;
    cin >> N >> M;
    REP(i, M)
    {
        ll a, b, s;
        cin >> a >> b >> s;
        a--;
        b--;
        V[a].n.push_back(pll(b, s));
        V[b].n.push_back(pll(a, s));
    }

    Info[0].n = 1;
    Info[0].up = true;
    queue<int> q;
    q.push(0);
    U[0] = true;
    ll upmin = 1, downmin = INF;
    bool one = false;
    while (!q.empty())
    {
        int t = q.front();
        q.pop();
        REP(i, V[t].n.size())
        {
            pll n = V[t].n[i];
            if (U[n.first])
            {
                //! 既に数が書き込まれている場合
                if (Info[n.first].n + Info[t].n != n.second)
                {
                    cout << 0 << endl;
                    return 0;
                }
                if (Info[n.first].up == Info[t].up)
                    one = true;
                continue;
            }
            q.push(n.first);
            U[n.first] = true;
            ;
            Info[n.first].n = n.second - Info[t].n;
            Info[n.first].up = !Info[t].up;
            if (Info[n.first].up)
                upmin = std::min(upmin, Info[n.first].n);
            else
                downmin = std::min(downmin, Info[n.first].n);
        }
    }

    //! node 0にかける数字の最大値
    ll max = downmin;
    REP(i, V[0].n.size())
    {
        max = std::min(max, V[0].n[i].second - 1);
    }
    //! node 0に書ける数字の最小値
    ll min = std::max((ll)1, 1 + (1 - upmin));

    ll ans = std::max(max - min + 1, (ll)0);
    if (ans > 0 && one)
        ans = 1;
    cout << ans << endl;
    return 0;
}