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: Runtime Error)

import java.util.ArrayList;
import java.util.Scanner;

class Main {

    static class Path {
        final int u;
        final int v;
        final int s;

        Path(int u, int v, int s) {
            this.u = u;
            this.v = v;
            this.s = s;
        }
    }

    static class Peak {
        // v = ax + b
        int a = 1;
        int b = 0;

        Peak() {
            a = 1;
            b = 0;
        }
        Peak(int a, int b) {
            this.a = a;
            this.b = b;
        }

        Peak other(int s) {
            return new Peak(-a, s - b);
        }

        void add(int add) {
            b += add * a;
            a = 0;
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        String[] array = scanner.nextLine().split(" ");
        int n = Integer.parseInt(array[0]);
        int m = Integer.parseInt(array[1]);

        Peak[] peaks = null;
        ArrayList<Path> paths = new ArrayList<Path>();
        boolean fixed = false;

        for (int i = 0; i < m; ++i) {
            String[] array2 = scanner.nextLine().split(" ");
            int u = Integer.parseInt(array2[0]);
            int v = Integer.parseInt(array2[1]);
            int s = Integer.parseInt(array2[2]);

            if (peaks == null) {
                peaks = new Peak[n + 1];
                Peak start = new Peak();
                peaks[u] = start;
                peaks[v] = start.other(s);
            } else if (peaks[u] != null) {
                Peak other = peaks[u].other(s);
                if (peaks[v] != null) {
                    Peak prep = peaks[v];
                    if (prep.a == other.a) {
                        if (prep.b != other.b) {
                            System.out.println(0);
                            return;
                        }
                    } else {
                        //int a = prep.a - other.a;
                        int b = (prep.b * prep.a) + (other.b * other.a);
                        if ((b % 2) == 0) {
                            fixed = true;
                            int add = b / 2;
                            for (int j = 1; j < peaks.length; ++j) {
                                if (peaks[j] != null) {
                                    peaks[j].add(add * -1);
                                }
                            }
                        } else {
                            System.out.println(0);
                            return;
                        }
                    }
                } else {
                    peaks[v] = other;
                }
            } else if (peaks[v] != null) {
                peaks[u] = peaks[v].other(s);
            } else {
                paths.add(new Path(u, v, s));
            }
        }

        while (paths.size() > 0) {
            ArrayList<Path> currentPaths = paths;
            paths = new ArrayList<Path>();

            for (Path path : currentPaths) {
                int u = path.u;
                int v = path.v;
                int s = path.s;
                if (peaks[u] != null) {
                    Peak other = peaks[u].other(s);
                    if (peaks[v] != null) {
                        Peak prep = peaks[v];
                        if (prep.a == other.a) {
                            if (prep.b != other.b) {
                                System.out.println(0);
                                return;
                            }
                        } else {
                            int a = prep.a + other.a;
                            int b = prep.b + other.b;
                            if ((b % a) == 0) {
                                fixed = true;
                                int add = b / a;
                                for (int j = 1; j < peaks.length; ++j) {
                                    if (peaks[j] != null) {
                                        peaks[j].add(add);
                                    }
                                }
                            } else {
                                System.out.println(0);
                                return;
                            }
                        }
                    } else {
                        peaks[v] = other;
                    }
                } else if (peaks[v] != null) {
                    peaks[u] = peaks[v].other(s);
                } else {
                    paths.add(path);
                }
            }
        }

        if (fixed) {
            for (int i = 1; i < peaks.length; ++i) {
                if (peaks[i].b < 1) {
                    System.out.println(0);
                    return;
                }
            }

            System.out.println(1);
        } else {
            int min = Integer.MIN_VALUE;
            int max = Integer.MAX_VALUE;
            for (int i = 1; i < peaks.length; ++i) {
                if (peaks[i].a > 0) {
                    min = Math.max(min, 1 - peaks[i].b);
                } else {
                    max = Math.min(max, peaks[i].b - 1);
                }
            }

            if (max >= min) {
                System.out.println(max - min + 1);
            } else {
                System.out.println(0);
            }
        }
    }
}