結果
| 問題 |
No.3207 Digital Font
|
| ユーザー |
 hitonanode
|
| 提出日時 | 2025-07-21 23:36:40 |
| 言語 | C++23 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
AC
|
| 実行時間 | 2,227 ms / 3,000 ms |
| コード長 | 25,866 bytes |
| コンパイル時間 | 4,547 ms |
| コンパイル使用メモリ | 287,216 KB |
| 実行使用メモリ | 114,584 KB |
| 最終ジャッジ日時 | 2025-08-06 13:53:22 |
| 合計ジャッジ時間 | 50,394 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge4 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 2 |
| other | AC * 38 |
ソースコード
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <forward_list>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <optional>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using lint = long long;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios { fast_ios(){ cin.tie(nullptr), ios::sync_with_stdio(false), cout << fixed << setprecision(20); }; } fast_ios_;
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
template <typename T> bool chmax(T &m, const T q) { return m < q ? (m = q, true) : false; }
template <typename T> bool chmin(T &m, const T q) { return m > q ? (m = q, true) : false; }
const std::vector<std::pair<int, int>> grid_dxs{{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int floor_lg(long long x) { return x <= 0 ? -1 : 63 - __builtin_clzll(x); }
template <class T1, class T2> T1 floor_div(T1 num, T2 den) { return (num > 0 ? num / den : -((-num + den - 1) / den)); }
template <class T1, class T2> std::pair<T1, T2> operator+(const std::pair<T1, T2> &l, const std::pair<T1, T2> &r) { return std::make_pair(l.first + r.first, l.second + r.second); }
template <class T1, class T2> std::pair<T1, T2> operator-(const std::pair<T1, T2> &l, const std::pair<T1, T2> &r) { return std::make_pair(l.first - r.first, l.second - r.second); }
template <class T> std::vector<T> sort_unique(std::vector<T> vec) { sort(vec.begin(), vec.end()), vec.erase(unique(vec.begin(), vec.end()), vec.end()); return vec; }
template <class T> int arglb(const std::vector<T> &v, const T &x) { return std::distance(v.begin(), std::lower_bound(v.begin(), v.end(), x)); }
template <class T> int argub(const std::vector<T> &v, const T &x) { return std::distance(v.begin(), std::upper_bound(v.begin(), v.end(), x)); }
template <class IStream, class T> IStream &operator>>(IStream &is, std::vector<T> &vec) { for (auto &v : vec) is >> v; return is; }
template <class OStream, class T> OStream &operator<<(OStream &os, const std::vector<T> &vec);
template <class OStream, class T, size_t sz> OStream &operator<<(OStream &os, const std::array<T, sz> &arr);
template <class OStream, class T, class TH> OStream &operator<<(OStream &os, const std::unordered_set<T, TH> &vec);
template <class OStream, class T, class U> OStream &operator<<(OStream &os, const pair<T, U> &pa);
template <class OStream, class T> OStream &operator<<(OStream &os, const std::deque<T> &vec);
template <class OStream, class T> OStream &operator<<(OStream &os, const std::set<T> &vec);
template <class OStream, class T> OStream &operator<<(OStream &os, const std::multiset<T> &vec);
template <class OStream, class T> OStream &operator<<(OStream &os, const std::unordered_multiset<T> &vec);
template <class OStream, class T, class U> OStream &operator<<(OStream &os, const std::pair<T, U> &pa);
template <class OStream, class TK, class TV> OStream &operator<<(OStream &os, const std::map<TK, TV> &mp);
template <class OStream, class TK, class TV, class TH> OStream &operator<<(OStream &os, const std::unordered_map<TK, TV, TH> &mp);
template <class OStream, class... T> OStream &operator<<(OStream &os, const std::tuple<T...> &tpl);
template <class OStream, class T> OStream &operator<<(OStream &os, const std::vector<T> &vec) { os << '['; for (auto v : vec) os << v << ','; os << ']'; return os; }
template <class OStream, class T, size_t sz> OStream &operator<<(OStream &os, const std::array<T, sz> &arr) { os << '['; for (auto v : arr) os << v << ','; os << ']'; return os; }
template <class... T> std::istream &operator>>(std::istream &is, std::tuple<T...> &tpl) { std::apply([&is](auto &&... args) { ((is >> args), ...);}, tpl); return is; }
template <class OStream, class... T> OStream &operator<<(OStream &os, const std::tuple<T...> &tpl) { os << '('; std::apply([&os](auto &&... args) { ((os << args << ','), ...);}, tpl); return os << ')'; }
template <class OStream, class T, class TH> OStream &operator<<(OStream &os, const std::unordered_set<T, TH> &vec) { os << '{'; for (auto v : vec) os << v << ','; os << '}'; return os; }
template <class OStream, class T> OStream &operator<<(OStream &os, const std::deque<T> &vec) { os << "deq["; for (auto v : vec) os << v << ','; os << ']'; return os; }
template <class OStream, class T> OStream &operator<<(OStream &os, const std::set<T> &vec) { os << '{'; for (auto v : vec) os << v << ','; os << '}'; return os; }
template <class OStream, class T> OStream &operator<<(OStream &os, const std::multiset<T> &vec) { os << '{'; for (auto v : vec) os << v << ','; os << '}'; return os; }
template <class OStream, class T> OStream &operator<<(OStream &os, const std::unordered_multiset<T> &vec) { os << '{'; for (auto v : vec) os << v << ','; os << '}'; return os; }
template <class OStream, class T, class U> OStream &operator<<(OStream &os, const std::pair<T, U> &pa) { return os << '(' << pa.first << ',' << pa.second << ')'; }
template <class OStream, class TK, class TV> OStream &operator<<(OStream &os, const std::map<TK, TV> &mp) { os << '{'; for (auto v : mp) os << v.first << "=>" << v.second << ','; os << '}'; return os; }
template <class OStream, class TK, class TV, class TH> OStream &operator<<(OStream &os, const std::unordered_map<TK, TV, TH> &mp) { os << '{'; for (auto v : mp) os << v.first << "=>" << v.second << ','; os << '}'; return os; }
#ifdef HITONANODE_LOCAL
const string COLOR_RESET = "\033[0m", BRIGHT_GREEN = "\033[1;32m", BRIGHT_RED = "\033[1;31m", BRIGHT_CYAN = "\033[1;36m", NORMAL_CROSSED = "\033[0;9;37m", RED_BACKGROUND = "\033[1;41m", NORMAL_FAINT = "\033[0;2m";
#define dbg(x) std::cerr << BRIGHT_CYAN << #x << COLOR_RESET << " = " << (x) << NORMAL_FAINT << " (L" << __LINE__ << ") " << __FILE__ << COLOR_RESET << std::endl
#define dbgif(cond, x) ((cond) ? std::cerr << BRIGHT_CYAN << #x << COLOR_RESET << " = " << (x) << NORMAL_FAINT << " (L" << __LINE__ << ") " << __FILE__ << COLOR_RESET << std::endl : std::cerr)
#else
#define dbg(x) ((void)0)
#define dbgif(cond, x) ((void)0)
#endif
#include <cassert>
#include <chrono>
#include <random>
// F_p, p = 2^61 - 1
// https://qiita.com/keymoon/items/11fac5627672a6d6a9f6
class ModIntMersenne61 {
static const long long md = (1LL << 61) - 1;
long long _v;
inline unsigned hi() const noexcept { return _v >> 31; }
inline unsigned lo() const noexcept { return _v & ((1LL << 31) - 1); }
public:
static long long mod() { return md; }
ModIntMersenne61() : _v(0) {}
// 0 <= x < md * 2
explicit ModIntMersenne61(long long x) : _v(x >= md ? x - md : x) {
assert(0 <= x and x < md * 2);
}
long long val() const noexcept { return _v; }
ModIntMersenne61 operator+(const ModIntMersenne61 &x) const {
return ModIntMersenne61(_v + x._v);
}
ModIntMersenne61 operator-(const ModIntMersenne61 &x) const {
return ModIntMersenne61(_v + md - x._v);
}
ModIntMersenne61 operator*(const ModIntMersenne61 &x) const {
using ull = unsigned long long;
ull uu = (ull)hi() * x.hi() * 2;
ull ll = (ull)lo() * x.lo();
ull lu = (ull)hi() * x.lo() + (ull)lo() * x.hi();
ull sum = uu + ll + ((lu & ((1ULL << 30) - 1)) << 31) + (lu >> 30);
ull reduced = (sum >> 61) + (sum & ull(md));
return ModIntMersenne61(reduced);
}
ModIntMersenne61 pow(long long n) const {
assert(n >= 0);
ModIntMersenne61 ans(1), tmp = *this;
while (n) {
if (n & 1) ans *= tmp;
tmp *= tmp, n >>= 1;
}
return ans;
}
ModIntMersenne61 inv() const { return pow(md - 2); }
ModIntMersenne61 operator/(const ModIntMersenne61 &x) const { return *this * x.inv(); }
ModIntMersenne61 operator-() const { return ModIntMersenne61(md - _v); }
ModIntMersenne61 &operator+=(const ModIntMersenne61 &x) { return *this = *this + x; }
ModIntMersenne61 &operator-=(const ModIntMersenne61 &x) { return *this = *this - x; }
ModIntMersenne61 &operator*=(const ModIntMersenne61 &x) { return *this = *this * x; }
ModIntMersenne61 &operator/=(const ModIntMersenne61 &x) { return *this = *this / x; }
ModIntMersenne61 operator+(unsigned x) const { return ModIntMersenne61(this->_v + x); }
bool operator==(const ModIntMersenne61 &x) const { return _v == x._v; }
bool operator!=(const ModIntMersenne61 &x) const { return _v != x._v; }
bool operator<(const ModIntMersenne61 &x) const { return _v < x._v; } // To use std::map
template <class OStream> friend OStream &operator<<(OStream &os, const ModIntMersenne61 &x) {
return os << x._v;
}
static ModIntMersenne61 randgen(bool force_update = false) {
static ModIntMersenne61 b(0);
if (b == ModIntMersenne61(0) or force_update) {
std::mt19937 mt(std::chrono::steady_clock::now().time_since_epoch().count());
std::uniform_int_distribution<long long> d(1, ModIntMersenne61::mod());
b = ModIntMersenne61(d(mt));
}
return b;
}
};
using mint = ModIntMersenne61;
#include <algorithm>
#include <cassert>
#include <utility>
#include <vector>
// 領域木
template <class S, void (*opadd)(S &, S), void (*opsub)(S &, S), S (*e)(), class Coordinate>
class rangetree_bit {
int n;
std::vector<std::pair<Coordinate, Coordinate>> _pts;
struct BIT {
std::vector<S> data;
BIT(int len) : data(len, e()) {}
void add(int pos, S v) {
for (pos++; pos and pos <= int(data.size()); pos += pos & -pos)
opadd(data[pos - 1], v);
}
S sum(int r) const {
S ret = e();
while (r) opadd(ret, data[r - 1]), r -= r & -r;
return ret;
}
};
std::vector<std::vector<Coordinate>> _range2ys;
std::vector<BIT> bits;
void _add_singlenode(int v, Coordinate y, S val) {
auto i = std::distance(
_range2ys[v].begin(), std::lower_bound(_range2ys[v].begin(), _range2ys[v].end(), y));
bits[v].add(i, val);
}
S _get_singlenode(int v, Coordinate y) const {
auto i = std::distance(
_range2ys[v].begin(), std::lower_bound(_range2ys[v].begin(), _range2ys[v].end(), y));
return bits[v].sum(i);
}
S _sum(Coordinate xl, Coordinate xr, Coordinate yr) const { // [xl, xr) * (-INF, yr)
auto compx = [](std::pair<Coordinate, Coordinate> l, std::pair<Coordinate, Coordinate> r) {
return l.first < r.first;
};
int l = n + std::distance(_pts.begin(), std::lower_bound(_pts.begin(), _pts.end(),
std::make_pair(xl, yr), compx));
int r = n + std::distance(_pts.begin(), std::lower_bound(_pts.begin(), _pts.end(),
std::make_pair(xr, yr), compx));
S ret = e();
while (l < r) {
if (l & 1) opadd(ret, _get_singlenode(l++, yr));
if (r & 1) opadd(ret, _get_singlenode(--r, yr));
l >>= 1, r >>= 1;
}
return ret;
}
public:
rangetree_bit() = default;
void add_point(Coordinate x, Coordinate y) noexcept { _pts.emplace_back(x, y); }
void build() {
std::sort(_pts.begin(), _pts.end());
_pts.erase(std::unique(_pts.begin(), _pts.end()), _pts.end());
n = _pts.size();
_range2ys.resize(n * 2);
for (int i = 0; i < n; i++) _range2ys[n + i] = {_pts[i].second};
for (int i = n - 1; i > 0; i--) {
auto &lch = _range2ys[i * 2];
auto &rch = _range2ys[i * 2 + 1];
std::merge(
lch.begin(), lch.end(), rch.begin(), rch.end(), std::back_inserter(_range2ys[i]));
_range2ys[i].erase(
std::unique(_range2ys[i].begin(), _range2ys[i].end()), _range2ys[i].end());
}
for (const auto &v : _range2ys) bits.push_back(BIT(v.size()));
}
void add(Coordinate x, Coordinate y, S val) {
int i = std::distance(
_pts.begin(), std::lower_bound(_pts.begin(), _pts.end(), std::make_pair(x, y)));
assert(i < n and _pts[i] == std::make_pair(x, y));
for (i += n; i; i >>= 1) _add_singlenode(i, y, val);
}
S sum(Coordinate xl, Coordinate xr, Coordinate yl, Coordinate yr) const {
auto ret_r = _sum(xl, xr, yr);
auto ret_l = _sum(xl, xr, yl);
opsub(ret_r, ret_l);
return ret_r;
}
};
using S = mint;
void opadd(S &a, S b) { a += b; }
void opsub(S &a, S b) { a -= b; }
S e() { return S(0); }
#include <bit>
class bit_vector {
static constexpr int WSIZE = 64;
int n = 0;
int pop_count = 0;
std::vector<uint64_t> bits;
std::vector<int> count_cumsum; // need build()
public:
bit_vector(int n_) : n(n_) {
assert(n >= 0);
bits.assign(n / WSIZE + 1, 0);
}
int size() const { return n; }
void set(int i) {
assert(0 <= i and i < n);
pop_count += !(bits.at(i / WSIZE) & (1ULL << (i % WSIZE)));
bits.at(i / WSIZE) |= (1ULL << (i % WSIZE));
}
void reset(int i) {
assert(0 <= i and i < n);
pop_count -= !!(bits.at(i / WSIZE) & (1ULL << (i % WSIZE)));
bits.at(i / WSIZE) &= ~(1ULL << (i % WSIZE));
}
void build() {
count_cumsum.assign(bits.size(), 0);
for (int i = 1; i < (int)bits.size(); ++i) {
count_cumsum.at(i) = count_cumsum.at(i - 1) + __builtin_popcountll(bits.at(i - 1));
}
}
int count0() const { return n - pop_count; }
int count1() const { return pop_count; }
// get i-th bit
bool access(int i) const {
assert(0 <= i and i < n);
return bits.at(i / WSIZE) & (1ULL << (i % WSIZE));
}
// count of 0s in [0, i)
int rank0(int i) const {
assert(0 <= i and i <= n);
return i - rank1(i);
}
// count of 1s in [0, i)
int rank1(int i) const {
assert(0 <= i and i <= n);
if (i == 0) return 0;
return count_cumsum.at(i / WSIZE) +
__builtin_popcountll(bits.at(i / WSIZE) & ((1ULL << (i % WSIZE)) - 1));
}
template <class OStream> friend OStream &operator<<(OStream &os, const bit_vector &bv) {
os << "bit_vector[" << bv.n << "]: ";
for (int i = 0; i < bv.n; ++i) {
os << (bv.bits[i / WSIZE] & (1ULL << (i % WSIZE)) ? '1' : '0');
}
os << " (pop_count: " << bv.pop_count << ")";
return os;
}
};
template <class Int>
class wavelet_matrix {
std::vector<bit_vector> bits;
std::vector<std::pair<Int, Int>> points;
std::vector<Int> distinct_ys;
int to_index_x(Int x) const {
return std::lower_bound(points.cbegin(), points.cend(), std::make_pair(x, Int{}),
[](const auto &l, const auto &r) { return l.first < r.first; }) - points.cbegin();
}
int to_index_y(Int y) const {
return std::lower_bound(distinct_ys.cbegin(), distinct_ys.cend(), y) - distinct_ys.cbegin();
}
bool is_built() const { return !bits.empty(); }
public:
wavelet_matrix() = default;
wavelet_matrix(const std::vector<Int> &ys) {
for (int x = 0; x < (int)ys.size(); ++x) {
assert(ys.at(x) >= 0);
add_point(x, ys.at(x));
}
build();
}
void add_point(Int x, Int y) {
assert(bits.empty()); // confirm that build() is not called yet
points.emplace_back(x, y);
distinct_ys.emplace_back(y);
}
void build() {
std::sort(points.begin(), points.end());
points.erase(std::unique(points.begin(), points.end()), points.end());
std::sort(distinct_ys.begin(), distinct_ys.end());
distinct_ys.erase(std::unique(distinct_ys.begin(), distinct_ys.end()), distinct_ys.end());
int d = 1;
while ((1 << d) < (int)distinct_ys.size()) ++d;
bits.assign(d, bit_vector(N()));
std::vector<int> a;
for (auto p : points) a.push_back(to_index_y(p.second));
auto nxt = a;
for (int d = D() - 1; d >= 0; --d) {
for (int i = 0; i < N(); ++i) {
if ((a.at(i) >> d) & 1) {
bits.at(d).set(i);
}
}
bits.at(d).build();
const int n0 = bits.at(d).count0();
for (int i = 0; i < N(); ++i) {
if ((a.at(i) >> d) & 1) {
nxt.at(n0 + bits.at(d).rank1(i)) = a.at(i);
} else {
nxt.at(bits.at(d).rank0(i)) = a.at(i);
}
}
std::swap(a, nxt);
}
}
int N() const { return points.size(); }
int D() const { return bits.size(); }
// get a[i]
int index_access(int i) const {
assert(0 <= i and i < N());
assert(is_built());
int ret = 0;
for (int d = D() - 1; d >= 0; --d) {
if (bits[d].access(i)) {
ret |= 1 << d;
i = bits[d].rank1(i) + bits[d].count0();
} else {
i = bits[d].rank0(i);
}
}
return ret;
}
// callback(d, i) means "update d-th segment's i-th element"
void index_apply(int i, auto callback) const {
assert(0 <= i and i < N());
assert(is_built());
for (int d = D() - 1; d >= 0; --d) {
if (bits.at(d).access(i)) {
i = bits.at(d).rank1(i) + bits.at(d).count0();
} else {
i = bits.at(d).rank0(i);
}
callback(d, i);
}
}
void apply(Int x, Int y, auto callback) const {
const int i = std::lower_bound(points.cbegin(), points.cend(), std::make_pair(x, y)) -
points.cbegin();
assert(i < N() and points.at(i) == std::make_pair(x, y));
index_apply(i, callback);
}
void index_prod(int l, int r, int yr, auto callback) const {
assert(0 <= l and l <= r and r <= N());
assert(0 <= yr and yr <= (int)distinct_ys.size());
assert(is_built());
if (yr >> D()) {
const int d = D() - 1;
const int l0 = bits.at(d).rank0(l), r0 = bits.at(d).rank0(r);
callback(d, l0, r0);
const int l1 = bits.at(d).rank1(l) + bits.at(d).count0();
const int r1 = bits.at(d).rank1(r) + bits.at(d).count0();
callback(d, l1, r1);
return;
}
for (int d = D() - 1; d >= 0; --d) {
const int l0 = bits.at(d).rank0(l), r0 = bits.at(d).rank0(r);
if ((yr >> d) & 1) {
callback(d, l0, r0);
l = bits.at(d).rank1(l) + bits.at(d).count0();
r = bits.at(d).rank1(r) + bits.at(d).count0();
} else {
l = l0, r = r0;
}
}
}
// return the product of elements in [xl, xr) * [-inf, yr)
// callback(d, l, r) means "use d-th segment's [l, r) elements"
void prod(Int xl, Int xr, Int yr, auto callback) const {
index_prod(to_index_x(xl), to_index_x(xr), to_index_y(yr), callback);
}
int index_kth_smallest(int l, int r, int k) const {
assert(0 <= l and l <= r and r <= N());
assert(0 <= k and k < r - l);
assert(is_built());
int ret = 0;
for (int d = D() - 1; d >= 0; --d) {
const int l0 = bits[d].rank0(l), r0 = bits[d].rank0(r);
if (k < r0 - l0) {
l = l0, r = r0;
} else {
k -= r0 - l0;
ret |= 1 << d;
l = bits[d].rank1(l) + bits[d].count0();
r = bits[d].rank1(r) + bits[d].count0();
}
}
return ret;
}
int index_kth_largest(int l, int r, int k) const {
assert(0 <= l and l <= r and r <= N());
assert(0 <= k and k < r - l);
return index_kth_smallest(l, r, (r - l - 1) - k);
}
// count elements in [l, r) that are < upper_bound
int index_range_freq(int l, int r, int upper_bound) const {
if (upper_bound >= (int)distinct_ys.size()) return r - l;
if (upper_bound <= 0) return 0;
int ret = 0;
for (int d = D() - 1; d >= 0; --d) {
const int l0 = bits[d].rank0(l), r0 = bits[d].rank0(r);
if ((upper_bound >> d) & 1) {
ret += r0 - l0;
l = bits[d].rank1(l) + bits[d].count0();
r = bits[d].rank1(r) + bits[d].count0();
} else {
l = l0, r = r0;
}
}
return ret;
}
Int kth_smallest(Int xl, Int xr, int k) const {
return distinct_ys.at(index_kth_smallest(to_index_x(xl), to_index_x(xr), k));
}
Int kth_largest(Int xl, Int xr, int k) const {
return distinct_ys.at(index_kth_largest(to_index_x(xl), to_index_x(xr), k));
}
// count elements in [xl, xr) * [-inf, yr)
int range_freq(Int xl, Int xr, Int yr) const {
return index_range_freq(to_index_x(xl), to_index_x(xr), to_index_y(yr));
}
};
#include <chrono>
#include <random>
struct rand_int_ {
using lint = long long;
std::mt19937 mt;
rand_int_() : mt(std::chrono::steady_clock::now().time_since_epoch().count()) {}
lint operator()(lint x) { return this->operator()(0, x); } // [0, x)
lint operator()(lint l, lint r) {
std::uniform_int_distribution<lint> d(l, r - 1);
return d(mt);
}
} rnd;
void test_bit_vector() {
while (true) {
int n = rnd(1, 100);
bit_vector bv(n);
vector<int> state(n);
for (int i = 0; i < n; ++i) {
if (rnd(0, 2)) {
bv.set(i);
state[i] = 1;
}
}
bv.build();
int pop_count = 0;
for (int i = 0; i < n; ++i) {
assert(bv.rank1(i) == pop_count);
assert(bv.rank0(i) == i - pop_count);
if (state[i]) {
assert(bv.access(i));
++pop_count;
} else {
assert(!bv.access(i));
}
}
assert(bv.rank1(n) == pop_count);
assert(bv.count1() == pop_count);
assert(bv.count0() == n - pop_count);
}
}
int main() {
// test_bit_vector();
int H, W, N;
cin >> H >> W >> N;
const mint Bx{31979713531853};
const mint By{23599715123};
// const mint Bx = mint(1), By = mint(1);
map<int, mint> weights;
// for (int v : {0, 1, 2, 5, 8, 6, 9}) weights[v] = mint::randgen(true);
for (int v : {1, 2, 5, 8, 6, 9}) weights[v] = mint(998244353).pow(v);
rangetree_bit<S, opadd, opsub, e, int> rt1, rt2;
wavelet_matrix<int> wm1, wm2;
vector<tuple<int, int, int>> points;
REP(_, N) {
int i, j, x;
cin >> i >> j >> x;
--i, --j;
rt1.add_point(i, j);
rt2.add_point(H - 1 - i, W - 1 - j);
wm1.add_point(i, j);
wm2.add_point(H - 1 - i, W - 1 - j);
points.emplace_back(i, j, x);
}
rt1.build();
rt2.build();
wm1.build();
wm2.build();
dbg(make_tuple(wm1.N(), wm1.D(), wm2.N(), wm2.D()));
vector dp1(wm1.D(), vector<mint>(wm1.N() + 1));
vector dp2(wm2.D(), vector<mint>(wm2.N() + 1));
for (auto [i, j, x] : points) {
if (x == 0) continue;
{
const mint w = weights.at(x) * Bx.pow(i) * By.pow(j);
rt1.add(i, j, w);
wm1.apply(i, j, [&dp1, w](int d, int idx) { dp1.at(d).at(idx + 1) += w; });
}
{
int y = x;
if (x == 6) y = 9;
if (x == 9) y = 6;
const mint w = weights.at(y) * Bx.pow(H - 1 - i) * By.pow(W - 1 - j);
rt2.add(H - 1 - i, W - 1 - j, w);
wm2.apply(H - 1 - i, W - 1 - j, [&dp2, w](int d, int idx) { dp2.at(d).at(idx + 1) += w; });
}
}
for (auto &v : dp1) { FOR(i, 1, v.size()) v.at(i) += v.at(i - 1); }
for (auto &v : dp2) { FOR(i, 1, v.size()) v.at(i) += v.at(i - 1); }
int Q;
cin >> Q;
while (Q--) {
int l, d, r, u;
cin >> l >> d >> r >> u;
--l;
--d;
// auto ans1 = rt1.sum(l, r, d, u);
// auto ans2 = rt2.sum(H - r, H - l, W - u, W - d);
mint ans1{0}, ans2{0};
wm1.prod(l, r, u, [&ans1, &dp1](int d, int l0, int r0) { ans1 += dp1.at(d).at(r0) - dp1.at(d).at(l0); });
wm1.prod(l, r, d, [&ans1, &dp1](int d, int l0, int r0) { ans1 -= dp1.at(d).at(r0) - dp1.at(d).at(l0); });
wm2.prod(H - r, H - l, W - d,
[&ans2, &dp2](int d, int l0, int r0) { ans2 += dp2.at(d).at(r0) - dp2.at(d).at(l0); });
wm2.prod(H - r, H - l, W - u,
[&ans2, &dp2](int d, int l0, int r0) { ans2 -= dp2.at(d).at(r0) - dp2.at(d).at(l0); });
// assert(ans1rt == ans1);
// assert(ans2rt == ans2);
// if (ans1rt != ans1) {
// dbg(ans1rt);
// dbg(ans1);
// }
// if (ans2rt != ans2) {
// dbg(ans2rt);
// dbg(ans2);
// }
if (ans1 * Bx.pow(H - r) * By.pow(W - u) == ans2 * Bx.pow(l) * By.pow(d)) {
puts("Yes");
} else {
puts("No");
}
}
}