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;

int main(int argc, char const *argv[])
{
	int n,m;
	cin>>n>>m;
	int u,v;
	long long s;
	vector<pair<int,long long>> edge[n];
	for (int i = 0; i < m; ++i)
	{
		cin>>u>>v>>s;--u;--v;
		edge[u].push_back({v,s});
		edge[v].push_back({u,s});
	}
	queue<int> que;
	int memo[n]={},f=0,f2=0;
	long long ans[n],tmp;
	memo[0]=1;
	ans[0]=1LL;
	que.push(0);
	while(!que.empty())
	{
		int now=que.front();que.pop();
		for (auto i=edge[now].begin(); i != edge[now].end(); ++i)
		{
			auto v=*i;
			if (memo[v.first]==0)
			{
				if (memo[now]==1)
				{
					memo[v.first]=2;
				}
				else
				{
					memo[v.first]=1;
				}
				ans[v.first]=v.second-ans[now];
				que.push(v.first);
			}
			else
			{
				if (memo[now]==memo[v.first])
				{
					f=1;
					if ((ans[v.first]-v.second+ans[now])%2LL==1LL)
					{
						cout<<"0\n";
						return 0;
					}
					else if (ans[v.first]!=v.second-ans[now])
					{
						if (f2&&tmp!=(ans[v.first]-v.second+ans[now])/2LL)
						{
							cout<<"0\n";
							return 0;
						}
						f2=1;
						tmp=(ans[v.first]-v.second+ans[now])/2LL;
						if (memo[now]==2)
						{
							tmp*=-1LL;
						}
					}
				}
				else
				{
					if (ans[v.first]!=v.second-ans[now])
					{
						cout<<"0\n";
						return 0;
					}
				}
			}
		}
	}
	long long l=100000000000000000LL,r=100000000000000000LL;
	if (f2)
	{
		for (int i = 0; i < n; ++i)
		{
			ans[i]+=tmp;
		}
	}
	for (int i = 0; i < n; ++i)
	{
		if (memo[i]==1)
		{
			l=min(l,ans[i]);
		}
		else
		{
			r=min(r,ans[i]);
		}
	}
	if (l<=0LL)
	{
		long long cab=1LL-l;
		l+=cab;
		r-=cab;
	}
	if (r<=0LL)
	{
		long long cab=1LL-l;
		r+=cab;
		l-=cab;
	}
	if (l<=0LL||r<=0LL)
	{
		cout<<"0\n";
	}
	else if (f||f2)
	{
		cout<<"1\n";
	}
	else
	{
		cout<<abs(l-r)+1LL<<endl;
	}
	return 0;
}