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>
#define int long long
#define rep(i, a, n) for (int i = a; i < n; i++)
using namespace std;
using pii = pair<int, int>;

struct edge {
  int to, cost;
  edge(int t, int c): to(t), cost(c) {}
};

const int INF = 1LL << 40;
int n, m;
vector<edge> g[100010];
int lab[100010];
int a[100010];
int bip, no, x;

void dfs(int v, int pv, int lb, int sum) {
  lab[v] = lb;
  a[v] = sum;
  for (edge e : g[v]) {
    int nv = e.to;
    if (nv == pv) continue;
    if (lab[nv] == 0) {
      dfs(nv, v, -lb, e.cost-sum);
    } else if (lab[nv] != lb) {
      continue;
    } else {
      bip = 0;
      int tmp = e.cost - a[v] - a[nv];
      if (lb > 0) {
        if (!(tmp % 2 == 0 && tmp >= 0)) no = 1;
        else x = tmp / 2;
      } else {
        if (!(tmp % 2 == 0 && tmp <= 0)) no = 1;
        else x = tmp / 2;
      }
      return;
    }
  }
}

int used[100010];
int b[100010];

bool dfs2(int v, int pv, int sum) {
  if (sum < 1) return false;
  used[v] = 1;
  b[v] = sum;
  bool res = true;
  for (edge e : g[v]) {
    int nv = e.to;
    if (nv == pv) continue;
    if (!used[nv]) {
      res &= dfs2(nv, v, e.cost-sum);
    } else {
      res &= (sum+b[nv] == e.cost);
    }
  }
  return res;
}

signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(false);
  cout << fixed << setprecision(10);
  
  cin >> n >> m;
  rep(i, 0, m) {
    int u, v, s;
    cin >> u >> v >> s;
    u--; v--;
    g[u].emplace_back(v, s);
    g[v].emplace_back(u, s);
  }
  bip = 1;
  dfs(0, -1, 1, 1);

  if (bip) {
    int mn = INF, mx = INF;
    rep(i, 0, n) {
      if (lab[i] > 0) mn = min(mn, a[i]);
      else mx = min(mx, a[i]);
    }
    cout << max(0LL, mx+mn-1) << endl;
    return 0;
  }
  cout << dfs2(0, -1, a[0]+x) << endl;

  return 0;
}