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: Accepted)

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

const int N = 2e5 + 5;
const int M = N * 2;

#define int long long

int n, m, x, y, fir[N], ne[M], to[M], cnt, z, C[M];

void add(int x, int y, int z) {
	ne[++ cnt] = fir[x];
	fir[x] = cnt;
	to[cnt] = y;
	C[cnt] = z;
}

void link(int x, int y, int z) {
	add(x, y, z);
	add(y, x, z);
}

int Quac[N], S[N];

bool vis[N];

struct Edge {
	int x, y, z;
};

vector <Edge> G;

#define Foreachson(i, x) for(int i = fir[x]; i; i = ne[i])

void dfs(int x, int f) {
	vis[x] = 1;
	Quac[x] = Quac[f] * (-1);
	Foreachson(i, x) {
		int V = to[i];
		G.push_back((Edge){V, x, C[i]});
		if(V == f || vis[V])
		continue;
		else S[V] = C[i] - S[x], dfs(V, x);
	}
}

main(void) {
	scanf("%lld%lld", &n, &m);
	for(int i = 1; i <= m; ++ i) {
		scanf("%lld%lld%lld", &x, &y, &z);
		link(x, y, z);
	}
	Quac[0] = -1;
	dfs(1, 0);
	int Xian = -1;
	for(int i = 0; i < (int) G.size(); ++ i) {
		Edge cur = G[i];
		int now = Quac[cur.x] + Quac[cur.y];
		if(!now && S[cur.x] + S[cur.y] != cur.z) {
			puts("0");
			return 0;
		}
		else {
			if(now) {
				if((S[cur.x] + S[cur.y] - cur.z) & 1) {
					puts("0");
					return 0;
				}
				else {
					int now = (cur.z - S[cur.x] - S[cur.y]) / (Quac[cur.x] + Quac[cur.y]);
					if(now <= 0) {
						puts("0");
						return 0;
					}
					else {
						if(Xian == -1) Xian = now;
						else if(Xian != now) return 0 * puts("0");
					}
				}
			}
		}
	}
	if(Xian != -1) {
		for(int i = 1; i <= n; ++ i) {
			if(Xian * Quac[i] + S[i] <= 0) {
				puts("0");
				return 0;
			}
		}
		cout << 1 << endl;
		return 0;
	}
	else {
		int L = 1, R = 1e18;
		for(int i = 1; i <= n; ++ i) if(Quac[i] == -1) R = min(R, S[i] - 1); else L = max(L, -S[i] + 1);
		if(L > R) puts("0");
		else cout << R - L + 1 << endl;
	}
}