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>

using namespace std;

#define ll long long

struct Node {
	ll value = 0; int color = 0;
};

int n;
bool isBipartite = true; // gが二分グラフかどうか
vector<vector<pair<int, ll>>> g;
vector<Node> node;

void dfs(int s) {
	static vector<bool> visited(n, false);
	visited[s] = true;
	for (auto e : g[s]) {
		int nx = e.first;
		if (visited[nx] && !(node[nx].color ^ node[s].color))
			isBipartite = false;
		else if (!visited[nx]) {
			node[nx].color = node[s].color == 0 ? 1 : 0;
			node[nx].value = e.second - node[s].value;
			dfs(nx);
		}
	}
}

pair<int, int> findError() {
	for (int i = 0; i < n; ++i)
		for (auto e : g[i])
			if (e.second != node[e.first].value + node[i].value)
				return make_pair(i, e.first);
	cout << 0 << endl;
	exit(0);
}

bool check() {
	for (int i = 0; i < n; ++i)
		if (node[i].value <= 0)
			return false;
	for (int i = 0; i < n; ++i)
		for (auto e : g[i])
			if (e.second != node[e.first].value + node[i].value)
				return false;
	return true;
}

signed main() {
	int m; cin >> n >> m;
	g.resize(n); node.resize(n);
	while (m--) {
		int u, v; ll s;
		cin >> u >> v >> s;
		--u; --v;
		g[u].emplace_back(v, s);
		g[v].emplace_back(u, s);
	}

	// 頂点0を0に、値を決定していく.
	// 同時に二分グラフかどうかの判定を行う.
	dfs(0);

	if (isBipartite) { // 二分グラフである場合
		// 頂点0の値を1増やしたとき、
		//   color == 0の頂点の値は1増える
		//   color == 1の頂点の値は1減る
		// ので、いくつ増やせるか、を求める.
		ll mn = 1, mx = 1000000000LL;
		for (auto ni : node) {
			if (ni.color == 0 && ni.value <= 0) {
				mn = max(mn, -ni.value + 1);
			}
			else if (ni.color == 1 && ni.value >= 0) {
				mx = min(mx, ni.value - 1);
			}
		}
		cout << max(0LL, mx - mn + 1) << endl;
	}
	else { // 二分グラフでない場合
		// 和が矛盾している頂点のペアを探す.
		pair<int, int> bad = findError();
		int u = bad.first, v = bad.second;
		ll s = 0;
		for (auto e : g[u])
			if (e.first == v)
				s = e.second;
		if (node[u].value + node[v].value < s) { // コストが足りない
			if (node[u].color == 1) {
				cout << 0 << endl;
				exit(0);
			}
			ll need = s - (node[u].value + node[v].value);
			if (need % 2 == 1) {
				cout << 0 << endl;
				exit(0);
			}
			for (int i = 0; i < n; ++i) {
				if (node[i].color == 0)
					node[i].value += (need / 2);
				else
					node[i].value -= (need / 2);
			}
		}
		else { // コストが多い
			if (node[u].color == 0) {
				cout << 0 << endl;
				exit(0);
			}
			ll dec = -s + (node[u].value + node[v].value);
			if (dec % 2 == 1) {
				cout << 0 << endl;
				exit(0);
			}
			for (int i = 0; i < n; ++i) {
				if (node[i].color == 0)
					node[i].value += (dec / 2);
				else
					node[i].value -= (dec / 2);
			}
		}
		cout << (check() ? 1 : 0) << endl;
	}

	return 0;
}