Consistent Ave

use proconio::{*, marker::Usize1};

​

fn main() {

    input! {

        n: usize,

        m: usize,

        xyv: [(Usize1, Usize1, i64); m],

    }

​

    let mut uf = WeightedUnionFind::new(n);

    for &(x, y, v) in &xyv {

        if uf.same(x, y) {

            if uf.diff(x, y) != v {

                println!("No");

                return;

            }

        } else {

            uf.merge(x, y, v);

        }

    }

​

    let mut diff = vec![None; n];

    for i in 0..n {

        let r = uf.root(i);

        let mut max = uf.get_w(i);

        let mut min = uf.get_w(i);

        if let Some((mx, mi)) = diff[r] {

            max = max.max(mx);

            min = min.min(mi);

        }

        diff[r] = Some( (max, min) );

    }

​

    let score_max = 1e9 as i64;

    for i in 0..n {

        if let Some((mx, mi)) = diff[i] {

            if mx - mi > score_max {

                println!("No");

                return;

            }

        }

    }

​

    println!("Yes");

}

​

struct WeightedUnionFind {

    par: Vec<i32>,

    weight: Vec<i64>,

}

​

#[allow(dead_code)]

impl WeightedUnionFind {

    fn new(n: usize) -> WeightedUnionFind {

        WeightedUnionFind {

            par: vec![-1; n],

            weight: vec![0; n],

        }

    }

​

    fn root(&mut self, x: usize) -> usize{

        if self.par[x] < 0 {

            return  x;

        }

​

        let p = self.root(self.par[x] as usize);

        self.weight[x] += self.weight[self.par[x] as usize];

        self.par[x] = p as i32;

        p

    }

​

    fn get_w(&mut self, x: usize) -> i64{

        self.root(x);

        self.weight[x]

    }

​

    fn diff(&mut self, x: usize, y: usize) -> i64{

        self.get_w(y) - self.get_w(x)

    }

​

    fn size(&mut self, x: usize) -> i32 {

        let root = self.root(x);

        -self.par[root]

    }

​

    fn merge(&mut self, x: usize, y: usize, mut w: i64) {

        //w[y] - w[x] = w

        w += self.get_w(x);

        w -= self.get_w(y);

​

        let mut x = self.root(x);

        let mut y = self.root(y);

​

        if x == y {

            return;

        }

​

        if self.par[x] > self.par[y] {

            std::mem::swap(&mut x, &mut y);

            w = -w;

        }

​

        self.par[x] += self.par[y];

        self.par[y] = x as i32;

        self.weight[y] = w;

    }

​

    fn same(&mut self, x: usize, y: usize) -> bool {

        self.root(x) == self.root(y)

    }

}