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 <queue>
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <stack>
#include <string>
#include <vector>
#include <map>
#include <functional>

#define rep(i, n) for(int i = 0; i < (n); i++)
#define MAX(a, b) (((a) < (b)) ? (b) : (a))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))

using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pint;
const ll inf = (1LL << 60);
const ll mod = 1000000007;
ll max(ll a, ll b) {
	if (a < b)
		return b;
	else
		return a;

}
ll min(ll a, ll b) {
	if (a < b)
		return a;
	else
		return b;

}

ll Q;


typedef vector<vector<pll>> graph;


graph tree;
ll vis[100005], d[100005];
vector<ll> val[100005][2];

bool flag = false, flag2 = true;

int sign(int a) {
	if (a % 2 == 1)
		return -1;
	else
		return 1;
}

int u1 = -1;
void dfs(int s, int p, int dist, int sum) {
	vis[s] = 1;
	d[s] = dist + 1;
	val[s][d[s] % 2].push_back(sum);
	rep(i, tree[s].size()) {
		int ni = tree[s][i].first;
		int omomi = tree[s][i].second;
		if (ni == p)
			continue;

		if (vis[ni] == 0) {
			dfs(ni, s, d[s], omomi - sum);
		}

		else {
			val[ni][(d[s] + 1) % 2].push_back(omomi - sum);
		}
	}

}


int main() {
	ll N, M;

	cin >> N >> M;
	tree.resize(N);

	rep(i, M) {
		ll a, b, s;

		cin >> a >> b >> s;
		a--;
		b--;
		tree[a].push_back({ b, s });
		tree[b].push_back({ a, s });
	}

	dfs(0, 0, -1, 0);

	ll m1 = -inf, m2 = inf;
	rep(i, N) {
		ll a = inf, b = inf;

		rep(j, val[i][0].size()) {
			if (j != 0 && a != val[i][0][j]) {
				cout << 0 << endl;
				return 0;
			}
			if (j == 0) {
				a = val[i][0][0];
				m1 = max(m1, -min(a, 0));
			}
		
		}

		rep(j, val[i][1].size()) {
			if (j != 0 && b != val[i][1][j]) {
				cout << 0 << endl;
				return 0;
			}
			if (j == 0) {
				b =val[i][1][0];
				m2 = min(b, m2);
			}
		}
		

		if (a != inf && b != inf) {
			flag = true;
		}

	}

	if (flag == true) {
		cout << 1 << endl;
		return 0;
	}

	m1++;
	m2--;
	cout << max(m2 - m1 + 1, 0) << endl;

	return 0;
}