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>

#if MYDEBUG
#include "lib/cp_debug.hpp"
#else
#define DBG(...) ;
#endif

using LL = long long;
constexpr LL LINF = 334ll << 53;
constexpr int INF = 15 << 26;
constexpr LL MOD = 1E9 + 7;

namespace Problem {
using namespace std;

class Solver {
 public:
  int n, m;
  pair<int, LL> diff;
  vector<vector<pair<int, LL>>> g;
  vector<LL> val;
  vector<LL> visit;
  vector<LL> mini;
  set<pair<int, int>> used;
  int oddloop, oddloop_invalid;
  Solver(LL n)
      : n(n),
        g(n),
        val(n),
        visit(n, -1),
        mini(2, LINF),
        oddloop(0),
        oddloop_invalid(0){};
  void no() {
    cout << 0 << endl;
    exit(0);
  }
  void dfs(int v, int p) {
    DBG(v, p)
    mini[visit[v]] = min(mini[visit[v]], val[v]);
    for (int i = 0; i < g[v].size(); ++i) {
      auto x = g[v][i];
      if (p == -1 and i > 0) continue;
      if (used.count(make_pair(v, x.first))) continue;
      if (x.first != p) {
        if (visit[x.first] >= 0) {
          if (visit[x.first] == visit[v]) {
            used.insert({x.first, v});
            DBG(v, p, x)
            oddloop++;
            if (oddloop >= 2 and oddloop_invalid >= 1) no();
            if ((val[x.first] + val[v] - x.second) % 2 != 0) {
              no();
            } else if (val[x.first] + val[v] != x.second) {
              oddloop_invalid++;
              diff = {visit[v], (-val[x.first] - val[v] + x.second) / 2};
              if (oddloop_invalid >= 2) no();
              if (oddloop >= 2 and oddloop_invalid >= 1) no();
            }
          } else {
            if (val[x.first] + val[v] != x.second) {
              no();
            }
          }
        } else {
          visit[x.first] = !visit[v];
          val[x.first] = x.second - val[v];
          dfs(x.first, v);
        }
      }
    }
  }
  void solve() {
    cin >> m;
    for (int i = 0; i < m; ++i) {
      int u, v, s;
      cin >> u >> v >> s;
      --u;
      --v;
      g[u].push_back({v, s});
      g[v].push_back({u, s});
    }
    val[0] = 1;
    visit[0] = 0;
    dfs(0, -1);
    DBG(oddloop, mini)
    if (oddloop >= 1) {
      if (oddloop_invalid == 1) {
        mini[diff.first] += diff.second;
        mini[!diff.first] -= diff.second;
      }
      if (min(mini[0], mini[1]) <= 0)
        cout << 0 << endl;
      else
        cout << 1 << endl;

    } else {
      cout << max<LL>(0, mini[0] + mini[1] - 1) << endl;
    }
  }
};
}  // namespace Problem

int main() {
  std::cin.tie(0);
  std::ios_base::sync_with_stdio(false);
  long long n = 0;
  std::cin >> n;

  Problem::Solver sol(n);
  sol.solve();
  return 0;
}