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 Scala (2.11.7) (judge verdict: Wrong Answer)

object Main {
  import java.io.{BufferedReader, InputStream, InputStreamReader}
  import java.util.StringTokenizer
  import scala.reflect.ClassTag

  def main(args: Array[String]): Unit = {
    val out = new java.io.PrintWriter(System.out)
    new Main(out, new InputReader(System.in)).solve()
    out.flush()
  }

  private[this] val oj = System.getenv("MY_DEBUG") == null
  def DEBUG(f: => Unit): Unit = {
    if (!oj){ f }
  }
  def debug(as: Array[Boolean]): Unit = if (!oj){ debug(as.map(x => if(x) "1" else "0").mkString) }
  def debug(as: Array[Int]): Unit = if (!oj){ debug(as.mkString(" ")) }
  def debug(as: Array[Long]): Unit =if (!oj){ debug(as.mkString(" ")) }
  def debugDim(m: Array[Array[Int]]): Unit = if (!oj){
    REP(m.length) { i =>
      debug(m(i))
    }
  }
  def debugDimFlip(m: Array[Array[Long]]): Unit = if (!oj){
    REP(m(0).length) { j =>
      REP(m.length) { i =>
        System.err.print(m(i)(j))
        System.err.print(" ")
      }
      System.err.println()
    }
  }
  def debug(s: => String): Unit = {
    if (!oj){ System.err.println(s) }
  }
  def isDebug[A](debug: => A, online: => A): A = {
    if (oj) online else debug
  }

  class InputReader(val stream: InputStream) {
    private[this] val reader = new BufferedReader(new InputStreamReader(stream), 32768)
    private[this] var tokenizer: StringTokenizer = _

    private[this] def next(): String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = Integer.parseInt(next())
    def nextLong(): Long = java.lang.Long.parseLong(next())
    def nextChar(): Char = next().charAt(0)

    def ni(): Int = nextInt()
    def nl(): Long = nextLong()
    def nc(): Char = nextChar()
    def ns(): String = next()
    def ns(n: Int): Array[Char] = ns().toCharArray
    def na(n: Int, offset: Int = 0): Array[Int] = map(n)(_ => ni() + offset)
    def na2(n: Int, offset: Int = 0): (Array[Int], Array[Int]) = {
      val A1, A2 = Array.ofDim[Int](n)
      REP(n) { i =>
        A1(i) = ni() + offset
        A2(i) = ni() + offset
      }
      (A1, A2)
    }
    def nm(n: Int, m: Int): Array[Array[Int]] = {
      val A = Array.ofDim[Int](n, m)
      REP(n) { i =>
        REP(m) { j =>
          A(i)(j) = ni()
        }
      }
      A
    }
    def nal(n: Int): Array[Long] = map(n)(_ => nl())
    def nm_c(n: Int, m: Int): Array[Array[Char]] = map(n) (_ => ns(m))
  }

  def REP(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = offset
    val N = n + offset
    while(i < N) { f(i); i += 1 }
  }
  def REP_r(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = n - 1 + offset
    while(i >= offset) { f(i); i -= 1 }
  }
  def TO(from: Int, to: Int)(f: Int => Unit): Unit = {
    REP(to - from + 1, from)(f)
  }
  def map[@specialized A: ClassTag](n: Int, offset: Int = 0)(f: Int => A): Array[A] = {
    val res = Array.ofDim[A](n)
    REP(n)(i => res(i) = f(i + offset))
    res
  }

  def sumL(as: Array[Int]): Long = {
    var s = 0L
    REP(as.length)(i => s += as(i))
    s
  }
  def cumSum(as: Array[Int]): Array[Long] = {
    val cum = Array.ofDim[Long](as.length + 1)
    REP(as.length) { i =>
      cum(i + 1) = cum(i) + as(i)
    }
    cum
  }
}

object Workspace {
  import Main._
  import java.util.Arrays.sort

  import scala.collection.mutable
  import math.{abs, max, min}
  import mutable.ArrayBuffer
  case class Edge(u: Int, id: Int)

  // x + c or -x + c
  case class Equation(sign: Boolean, c: Long)
}

class Main(out: java.io.PrintWriter, sc: Main.InputReader) extends Runnable {
  import sc._
  import Main._
  import java.util.Arrays.sort

  import scala.collection.mutable
  import math.{abs, max, min}
  import mutable.ArrayBuffer
  import Workspace._

  // toIntとか+7とかするならvalにしろ
  final private[this] val MOD = 1000000007

  def solve(): Unit = {
    val th = new Thread(null, this, "solve", 1 << 26)
    th.start()
    th.join()
  }

  override def run(): Unit = {
    val N, M = ni()
    val U, V, S = Array.ofDim[Int](M)
    val g = Array.fill[ArrayBuffer[Edge]](N)(ArrayBuffer())
    REP(M) { i =>
      val u, v = ni() - 1
      val s = ni()
      U(i) = u
      V(i) = v
      S(i) = s
      g(u) += Edge(v, i)
      g(v) += Edge(u, i)
    }

    val inf = 1e18.toLong

    val eq = Array.ofDim[Equation](N)
    val flag = Array.ofDim[Boolean](M)
    var mn = 1L
    var mx = inf
    eq(0) = Equation(true, 0) // a0 = x

    def justX(x: Long): Int = {
      import java.util
      val C = Array.fill[Long](N)(inf)
      C(0) = x
      util.Arrays.fill(flag, false)

      def dfs(v: Int): Boolean = {
        g(v).foreach { e =>
          if (!flag(e.id)) {
            flag(e.id) = true
            val nc = S(e.id) - C(v)
            if (C(e.u) != inf && C(e.u) != nc) {
              debug(s"$e ${C(e.u)} $nc")
              return false
            }
            C(e.u) = nc
            if (!dfs(e.u)) return false
          }
        }
        true
      }

      if (dfs(0)) 1 else 0
    }

    def dfs(v: Int): Int = {
      g(v).foreach { e =>
        if (!flag(e.id)) {
          flag(e.id) = true
          val neq = Equation(!eq(v).sign, S(e.id) - eq(v).c)
          if (eq(e.u) == null) {
            eq(e.u) = neq
            if (neq.sign) {
              mn = max(mn, 1 - eq(e.u).c)
            } else {
              mx = min(mx, eq(e.u).c - 1)
            }

          } else if (neq.sign != eq(e.u).sign) {
            val (c1, c2) = if (neq.sign) {
              (neq.c, eq(e.u).c)
            } else {
              (eq(e.u).c, neq.c)
            }
            debug(s"found at $v: x + c1 = -x + c2")
            debug(s"c1:$c1 c2:$c2")
            return if ((c2 - c1) % 2 == 0 && c2 - c1 > 1)
              justX((c2 - c1) / 2)
            else
              0

          } else {
            if (neq.c != eq(e.u).c) {
              return 0
            }
          }

          val res = dfs(e.u)
          if (res != -1) return res
        }
      }

      -1
    }

    val res = dfs(0)
    if (res != -1)
      out.println(res)
    else {
      debug(s"mn:$mn mx:$mx")
      val ans = max(0, mx - mn + 1)
      out.println(ans)
    }
  }
}