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 Go (1.6) (judge verdict: Accepted)

package main

import (
  "bufio"
  "container/list"
  "fmt"
  "os"
  "strconv"
  "strings"
)

var g Graph

func main() {
  input := Input{bufio.NewReaderSize(os.Stdin,100)}
  n,m := input.Next2Ints()
  g = NewGraph(n)
  for i:=0;i<m;i++ {
    u,v,s := input.Next3Ints()
    u,v = u-1,v-1
    g.Add(u,v,s)
    g.Add(v,u,s)
  }
  nodes := make([]Node,n)
  nodes[0] = Node{0,1}
  queue := list.New()
  queue.PushBack(0)
  fix := int64(-1)
  for queue.Len() > 0 {
    stat,_ := queue.Remove(queue.Front()).(int)
    node := nodes[stat]
    for _,e := range g[stat] {
      other := node.Other(e.s)
      old := nodes[e.to]
      if old.sig == 0 {
        nodes[e.to] = other
        queue.PushBack(e.to)
        continue
      }
      if node.sig == old.sig {
        tmp := node.sig*(e.s-node.x-old.x)
        if tmp <= 0 || tmp%2 != 0 { tmp = -2 }
        tmp /= 2
        if tmp == -1 { fmt.Println(0);return }
        if fix == -1 { fix = tmp;continue }
        if tmp != fix { fmt.Println(0);return }
      } else {
        if other != old { fmt.Println(0);return }
      }
    }
  }
  if fix != -1 {
    for _,node := range nodes {
      if !node.IsOk(fix) { fmt.Println(0);return }
    }
    fmt.Println(1)
  } else {
    min := int64(1)
    max := int64(10000000000000000)
    for _,node := range nodes {
      if node.sig > 0 {
        if min < -node.x+1 { min = -node.x+1 }
      } else {
        if max > node.x-1 { max = node.x-1 }
      }
    }
    if max-min+1 > 0 {
      fmt.Println(max-min+1)
    } else {
      fmt.Println(0)
    }
  }
}

type Node struct { x,sig int64 }
func(n Node) IsOk(y int64) bool { return n.x+n.sig*y > 0 }
func(n Node) Other(s int64) Node { return Node{s-n.x,-n.sig} }

type Edge struct { to int;s int64 }
type Graph [][]Edge
func NewGraph(n int) Graph { return make([][]Edge,n) }
func(g Graph) AddEdge(from int,e Edge) { g[from] = append(g[from],e) }
func(g Graph) Add(from,to int,s int64) { g.AddEdge(from,Edge{to,s}) }

type Input struct { reader *bufio.Reader }
func(i *Input) NextLine() string {
  var buffer []byte
  for {
    line,isPrefix,err := i.reader.ReadLine()
    if err != nil { panic(err) }
    buffer = append(buffer,line...)
    if !isPrefix { break }
  }
  return string(buffer)
}
func(i *Input) Next2Ints() (int,int) {
  s := strings.Split(i.NextLine()," ")
  x,_ := strconv.Atoi(s[0])
  y,_ := strconv.Atoi(s[1])
  return x,y
}
func(i *Input) Next3Ints() (int,int,int64) {
  s := strings.Split(i.NextLine()," ")
  x,_ := strconv.Atoi(s[0])
  y,_ := strconv.Atoi(s[1])
  z,_ := strconv.ParseInt(s[2],10,64)
  return x,y,z
}