Language: C++

/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author RiaD
 */

#include <iostream>
#include <fstream>

#include <iostream>
#include <vector>


#include <iterator>


#include <string>
#include <stdexcept>

#ifndef SPCPPL_ASSERT
	#ifdef SPCPPL_DEBUG
		#define SPCPPL_ASSERT(condition) \
		if(!(condition)) { \
			throw std::runtime_error(std::string() + #condition + " in line " + std::to_string(__LINE__) + " in " + __PRETTY_FUNCTION__); \
		}
	#else
		#define SPCPPL_ASSERT(condition)
	#endif
#endif


/**
* Support decrementing and multi-passing, but not declared bidirectional(or even forward) because
* it's reference type is not a reference.
*
* It doesn't return reference because
* 1. Anyway it'll not satisfy requirement [forward.iterators]/6
*   If a and b are both dereferenceable, then a == b if and only if *a and
*   b are bound to the same object.
* 2. It'll not work with reverse_iterator that returns operator * of temporary which is temporary for this iterator
*
* Note, reverse_iterator is not guaranteed to work  now too since it works only with bidirectional iterators,
* but it's seems to work at least on my implementation.
*
* It's not really useful anywhere except iterating anyway.
*/
template <typename T>
class IntegerIterator: public std::iterator<std::input_iterator_tag, T, std::ptrdiff_t, T*, T> {
public:
	explicit IntegerIterator(T value): value(value) {

	}

	IntegerIterator& operator++() {
		++value;
		return *this;
	}

	IntegerIterator operator++(int) {
		IntegerIterator copy = *this;
		++value;
		return copy;
	}

	IntegerIterator& operator--() {
		--value;
		return *this;
	}

	IntegerIterator operator--(int) {
		IntegerIterator copy = *this;
		--value;
		return copy;
	}

	T operator*() const {
		return value;
	}

	bool operator==(IntegerIterator rhs) const {
		return value == rhs.value;
	}

	bool operator!=(IntegerIterator rhs) const {
		return !(*this == rhs);
	}

private:
	T value;
};

template <typename T>
class IntegerRange {
public:
	IntegerRange(T begin, T end): begin_(begin), end_(end) {
		SPCPPL_ASSERT(begin <= end);
	}

	IntegerIterator<T> begin() const {
		return IntegerIterator<T>(begin_);
	}

	IntegerIterator<T> end() const {
		return IntegerIterator<T>(end_);
	}

private:
	T begin_;
	T end_;
};

template <typename T>
class ReversedIntegerRange {
	typedef std::reverse_iterator<IntegerIterator<T>> IteratorType;
public:
	ReversedIntegerRange(T begin, T end): begin_(begin), end_(end) {
		SPCPPL_ASSERT(begin >= end);
	}

	IteratorType begin() const {
		return IteratorType(IntegerIterator<T>(begin_));
	}

	IteratorType end() const {
		return IteratorType(IntegerIterator<T>(end_));
	}

private:
	T begin_;
	T end_;
};

template <typename T>
IntegerRange<T> range(T to) {
	return IntegerRange<T>(0, to);
}

template <typename T>
IntegerRange<T> range(T from, T to) {
	return IntegerRange<T>(from, to);
}

template <typename T>
IntegerRange<T> inclusiveRange(T to) {
	return IntegerRange<T>(0, to + 1);
}

template <typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
	return IntegerRange<T>(from, to + 1);
}

template <typename T>
ReversedIntegerRange<T> downrange(T from) {
	return ReversedIntegerRange<T>(from, 0);
}

template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
	return ReversedIntegerRange<T>(from, to);
}

template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
	return ReversedIntegerRange<T>(from + 1, 0);
}

template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
	return ReversedIntegerRange<T>(from + 1, to);
}


using namespace std;

class DA {
public:
	void solve(std::istream& in, std::ostream& out) {
#define int int64_t
		int n, m, e;
		in >> n >> m >> e;
        vector<int> vr(n);
        vector<int> vc(m);

        vector<vector<pair<int, int>>> gr(n);
        vector<vector<pair<int, int>>> gc(m);

        vector<int> ur(n), uc(m);

        for (int i: range(e)) {
            int a, b, x;
            in >> a >> b >> x;
            --a, --b, --x;
            gr[a].emplace_back(b, x);
            gr[b].emplace_back(a,x );
        }


        function<pair<int, int>(int, int)> dr, dc;
        dr = [&](int a, int v) {
            pair<int, int> res = {vr[a], 1000000000000000000};
            if (ur[a]) {
                if (vr[a] != v) {
                    throw 1;
                }
                return res;
            }
            for (auto p: gr[a]) {
                auto x = dc(p.first, p.second - v);
                res.first = max(res.first, x.first);
                res.second = min(res.second, x.second);
            }
            return res;
        };

        dc = [&](int a, int v) {
            pair<int, int> res = {-1000000000000000000, vc[a]};
            if (uc[a]) {
                if (vc[a] != v) {
                    throw 1;
                }
                return res;
            }
            for (auto p: gr[a]) {
                auto x = dr(p.first, p.second - v);
                res.first = max(res.first, x.first);
                res.second = min(res.second, x.second);
            }
            return res;
        };

        for (int i: range(n)) {
            if (ur[i]) {
                continue;
            }
            try {
                auto x = dr(i, 0);
                if (x.first + x.second < 0) {
                    throw 1;
                }
            } catch (...) {
                out << "No";
                return;
            }
        }
        out << "Yes\n";
#undef int
	}
};


int main() {
	std::ios_base::sync_with_stdio(false);
	DA solver;
	std::istream& in(std::cin);
	std::ostream& out(std::cout);
	in.tie(0);
	out << std::fixed;
	out.precision(20);
	solver.solve(in, out);
	return 0;
}


Compiler output:
a.cc:48:36: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
   48 | class IntegerIterator: public std::iterator<std::input_iterator_tag, T, std::ptrdiff_t, T*, T> {
      |                                    ^~~~~~~~
In file included from /usr/include/c++/14/bits/stl_iterator_base_funcs.h:66,
                 from /usr/include/c++/14/string:47,
                 from /usr/include/c++/14/bits/locale_classes.h:40,
                 from /usr/include/c++/14/bits/ios_base.h:41,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:7:
/usr/include/c++/14/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
a.cc: In member function 'void DA::solve(std::istream&, std::ostream&)':
a.cc:199:9: error: 'function' was not declared in this scope
  199 |         function<pair<int, int>(int, int)> dr, dc;
      |         ^~~~~~~~
a.cc:15:1: note: 'std::function' is defined in header '<functional>'; this is probably fixable by adding '#include <functional>'
   14 | #include <iterator>
  +++ |+#include <functional>
   15 | 
a.cc:199:32: error: expected primary-expression before '(' token
  199 |         function<pair<int, int>(int, int)> dr, dc;
      |                                ^
a.cc:199:36: error: expected primary-expression before ',' token
  199 |         function<pair<int, int>(int, int)> dr, dc;
      |                                    ^
a.cc:199:41: error: expected primary-expression before ')' token
  199 |         function<pair<int, int>(int, int)> dr, dc;
      |                                         ^
a.cc:199:44: error: 'dr' was not declared in this scope; did you mean 'ur'?
  199 |         function<pair<int, int>(int, int)> dr, dc;
      |                                            ^~
      |                                            ur
a.cc:199:48: error: 'dc' was not declared in this scope; did you mean 'uc'?
  199 |         function<pair<int, int>(int, int)> dr, dc;
      |                                                ^~
      |                                                uc