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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.io.IOException; 
import java.io.InputStream; 
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List; 

class Main{

	static class Edge{
		int to;
		long cost;
		Edge(int t, long c){to=t;cost=c;}
	}

	static List<Edge>[] edges;

	static int[] color;
	static boolean paint(int v, int c){
		color[v]=c;
		boolean res=true;
		for(Edge e: edges[v]){
			if(color[e.to]<0)res&=paint(e.to, (c+1)%2);
			if(color[e.to]==c)res=false;
		}
		return res;
	}
	static long[] pot;
	static void dfs(int v, long c){
		pot[v]=c;
		for(Edge e: edges[v]){
			if(pot[e.to]==Integer.MIN_VALUE)dfs(e.to, e.cost-c);
		}
	}
	static int dfs2(int v, long c){
		pot[v]=c;
		for(Edge e: edges[v]){
			if(pot[e.to]==Integer.MIN_VALUE){
				int res = dfs2(e.to, e.cost-c);
				if(res>=0)return res;
			}
			else{
				if(pot[v]+pot[e.to]!=e.cost){
					pot[e.to]=(pot[e.to]+(e.cost-c)%2==0 ? (pot[e.to]+(e.cost-c))/2 : -2);
					return e.to;
				}
			}
		}
		return -1;
	}

	static void solve(){ 
		int n=ni(), m=ni();
		color = new int[n];
		edges = new List[n];
		pot = new long[n];
		for(int i=0;i<n;++i)edges[i]=new ArrayList<>();
		Arrays.fill(color, Integer.MIN_VALUE);
		Arrays.fill(pot, Integer.MIN_VALUE);

		while(m-->0){
			int u=ni()-1, v=ni()-1, s=ni();
			edges[u].add(new Edge(v, (long)s));
			edges[v].add(new Edge(u, (long)s));
		}
		if(paint(0, 0)){
			dfs(0, 1);
			for(int i=0;i<n;++i){
				for(Edge e: edges[i]){
					if(pot[i]+pot[e.to]!=e.cost){
						out.println(0);
						return;
					}
				}
			}
			long bmin = Long.MAX_VALUE;
			long wmin = Long.MAX_VALUE;
			for(int i=0;i<n;++i){
				if(color[i]==0)bmin=Math.min(bmin, pot[i]);
				else wmin=Math.min(wmin, pot[i]);
			}
			wmin -= (1-bmin);
			out.println(Math.max(0,wmin));
		}else{
			int root = dfs2(0, 1);
			if(root==-1){
				for(int i=0;i<n;++i)if(pot[i]<=0){
					out.println(0);
					return;
				}
				out.println(1);
			}
			else{
				long p = pot[root];
				Arrays.fill(pot, Integer.MIN_VALUE);
				dfs(root, p);
				for(int i=0;i<n;++i)if(pot[i]<=0){
					out.println(0);return;
				}
				for(int i=0;i<n;++i){
					for(Edge e: edges[i]){
						if(pot[i]+pot[e.to]!=e.cost){
							out.println(0);
							return;
						}
					}
				}
				out.println(1);
			}
		}

	} 
 
 
 
 
	public static void main(String[] args){ 
		 solve(); 
		 out.flush(); 
	 } 
	 private static InputStream in = System.in; 
	 private static PrintWriter out = new PrintWriter(System.out); 
 
	 private static final byte[] buffer = new byte[1<<15]; 
	 private static int ptr = 0; 
	 private static int buflen = 0; 
	 private static boolean hasNextByte(){ 
		 if(ptr<buflen)return true; 
		 ptr = 0; 
		 try{ 
			 buflen = in.read(buffer); 
		 } catch (IOException e){ 
			 e.printStackTrace(); 
		 } 
		 return buflen>0; 
	 } 
	 private static int readByte(){ if(hasNextByte()) return buffer[ptr++]; else return -1;} 
	 private static boolean isSpaceChar(int c){ return !(33<=c && c<=126);} 
	 private static int skip(){int res; while((res=readByte())!=-1 && isSpaceChar(res)); return res;} 
 
	 private static double nd(){ return Double.parseDouble(ns()); } 
	 private static char nc(){ return (char)skip(); } 
	 private static String ns(){ 
		 StringBuilder sb = new StringBuilder(); 
		 for(int b=skip();!isSpaceChar(b);b=readByte())sb.append((char)b); 
		 return sb.toString(); 
	 } 
	 private static int[] nia(int n){ 
		 int[] res = new int[n]; 
		 for(int i=0;i<n;++i)res[i]=ni(); 
		 return res; 
	 } 
	 private static long[] nla(int n){ 
		 long[] res = new long[n]; 
		 for(int i=0;i<n;++i)res[i]=nl(); 
		 return res; 
	 } 
	 private static int ni(){ 
		 int res=0,b; 
		 boolean minus=false; 
		 while((b=readByte())!=-1 && !((b>='0'&&b<='9') || b=='-')); 
		 if(b=='-'){ 
			 minus=true; 
			 b=readByte(); 
		 } 
		 for(;'0'<=b&&b<='9';b=readByte())res=res*10+(b-'0'); 
		 return minus ? -res:res; 
	 } 
	 private static long nl(){ 
		 long res=0,b; 
		 boolean minus=false; 
		 while((b=readByte())!=-1 && !((b>='0'&&b<='9') || b=='-')); 
		 if(b=='-'){ 
			 minus=true; 
			 b=readByte(); 
		 } 
		 for(;'0'<=b&&b<='9';b=readByte())res=res*10+(b-'0'); 
		 return minus ? -res:res; 
	} 
}