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)

//In the name of ALLAH
#include <bits/stdc++.h>
#define pb push_back
#define X first
#define Y second
#define MP make_pair
const bool DEBUG = false;
#define cerr if(DEBUG)cerr
using namespace std;

typedef long double ld;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;

const long long maxn = 4e5 + 5;
const long long INF = 1e16 + 1;
const long long inf = 1e9 + 5;
const long long M = 1e9 + 7;
const int lg = 21;

bool flag = 0, same_h = 0, mark[maxn];
ll n, m, y = INF, d[maxn], a[maxn];
ll mx0 = -INF, mn0 = INF, mn1 = INF, mx1 = -INF;
vector<pll> g[maxn];
ll mn, mx;

void BFS(int v){
	queue<ll> q;
	q.push(v), d[v] = 0, mark[v] = 1, a[v] = 1;
	while(q.size()){
		ll v = q.front();
		q.pop();
		if(d[v] & 1)
			mx1 = max(mx1, a[v]), mn1 = min(mn1, a[v]);
		else
			mx0 = max(mx0, a[v]), mn0 = min(mn0, a[v]);
		for(auto p : g[v]){
			ll u = p.X, w = p.Y;
			if(!mark[u]){
				a[u] = w - a[v];
				d[u] = d[v] + 1;
				mark[u] = 1;
				q.push(u);
			}
			else{
				if(d[v] != d[u] and a[v] + a[u] != w)
					flag = 1;
				else if(d[v] == d[u]){
					same_h = 1;
					ll x = abs(w - a[v] - a[u]);
					if(x % 2 != 0)
						flag = 1;
					if(d[v] % 2 == 0){
						if(x < 0) flag = 1;
						else{
							if(y == INF) y = x / 2;
							else if(y != x / 2) flag = 1;
						}
					}
					else{
						if(x > 0) flag = 1;
						else{
							if(y == INF) y = x / 2, y = -y;
							else if(-y != x / 2) flag = 1;
						}
					}
				}
			}
		}
	}
}

void dfs(ll v){
	mark[v] = 1;
	if(a[v] <= 0) flag = 0;
	for(auto p : g[v]){
		ll u = p.X, w = p.Y;
		if(!mark[u])
			a[u] = w - a[v], dfs(u);
		else if(a[u] + a[v] != w)
			flag = 0;
	}
}

bool check(ll y){
	fill(mark, mark + maxn, 0);
	flag = 1;
	a[0] = y;
	dfs(0);
	return flag;
}

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	cin >> n >> m;
	for(int i = 0; i < m; i++){
		ll x, y, w;
		cin >> x >> y >> w, x--, y--;
		g[x].pb({y, w});
		g[y].pb({x, w});
	}
	BFS(0);
	if(flag)
		return cout << 0 << endl, 0;
	if(same_h == 1)
		return cout << check(y + 1) << endl, 0;
	if(mn1 <= 0)
		return cout << 0 << endl, 0;
	mx = mn1;
	mn = 1;
	if(mn0 <= 0)
		mn = -mn0 + 2;
	cout << max((ll)0, mx - mn + 1) << endl;
	return 0;
}