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 = 1e5 + 10;
const int inf = 2e9;
bool flag[N];
vector<pair<int, int> > e[N];
int del[N];
int ans[N];
bool multi, ok;
int delta;

void dfs1(int v) {
	flag[v] = true;
	for (auto x : e[v]) {
		int u = x.first;
		if (!flag[u]) {
			del[u] = -del[v];
			dfs1(u);
		}
		else {
			if (del[u] + del[v] != 0) {
				multi = 0;
			}
		}
	}
}

void dfs(int v) {
	if (!ok) return;
	flag[v] = true;
	for (auto x : e[v]) {
		int u = x.first;
		int w = x.second;
		if (!flag[u]) {
			ans[u] = w - ans[v];
			dfs(u);
		} else if (ans[u] + ans[v] != w) {
			ok = 0;
			if (del[u] == del[v] && (w - ans[u] - ans[v]) % 2 == 0) {
				delta = (w - ans[u] - ans[v]) / 2 / del[v];
			}
			else delta = -inf;
			return;
		}
	}
}

int main() {
	int n, m;
	scanf("%d%d", &n, &m);
	for (int i = 0; i < m; i++) {
		int x, y, z;
		scanf("%d%d%d", &x, &y, &z);
		e[x].emplace_back(y, z);
		e[y].emplace_back(x, z);
	}
	memset(flag, 0, sizeof(flag));
	multi = 1;
	del[1] = 1;
	dfs1(1);
	memset(flag, 0, sizeof(flag));
	ans[1] = 1;
	ok = 1;
	dfs(1);
	if (!ok) {
		if (delta == -inf) {
			puts("0");
			return 0;
		}
		memset(flag, 0, sizeof(flag));
		ans[1] = 1+delta;
		ok = 1;
		dfs(1);
	}
	if (!ok) {
		puts("0");
		return 0;
	}
	if (!multi) {
		bool flag = 1;
		for (int i = 1; i <= n; i++) if (ans[i] <= 0) flag = 0;
		if (flag) puts("1");
		else puts("0"); 
	}
	else {
		int s = -inf, t=inf;
		for (int i = 1; i <= n; i++) {
			if (del[i] == 1) s = max(s, 1-ans[i]);
			else t = min(t, ans[i]-1);
		}
		if (t >= s) printf("%d\n", t - s + 1);
		else puts("0");
	}
	//for (int i = 1; i <= n; i++) cout << del[i] << ' ' << ans[i] << endl;
	return 0;
}