結果
| 問題 |
No.3207 Digital Font
|
| コンテスト | |
| ユーザー |
 hitonanode
|
| 提出日時 | 2025-07-18 21:38:45 |
| 言語 | C++23 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 16,366 bytes |
| コンパイル時間 | 3,170 ms |
| コンパイル使用メモリ | 254,972 KB |
| 実行使用メモリ | 84,944 KB |
| 最終ジャッジ日時 | 2025-07-18 21:40:15 |
| 合計ジャッジ時間 | 51,713 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge5 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 2 |
| other | AC * 25 WA * 13 |
ソースコード
#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 <string>
#include <vector>
// Rolling Hash (Rabin-Karp), 2dim
template <typename V> struct rolling_hash_2d {
const V Bx, By;
std::vector<V> powx, powy; // powx[i] = Bx^i
std::vector<std::vector<V>> hash;
void gen_pow(int h, int w) {
powx.assign(h + 1, V(1));
for (int i = 1; i <= h; ++i) powx.at(i) = powx.at(i - 1) * Bx;
powy.assign(w + 1, V(1));
for (int i = 1; i <= w; ++i) powy.at(i) = powy.at(i - 1) * By;
}
inline V _at(int x, int y) const noexcept {
if (x < 0 or x >= int(hash.size())) return V();
if (y < 0 or y >= int(hash[x].size())) return V();
return hash[x][y];
}
template <typename Int> void build(const std::vector<std::vector<Int>> &s) {
const int H = s.size(), W = H ? s.at(0).size() : 0;
gen_pow(H, W);
hash.assign(H, std::vector<V>(W, V()));
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) hash[i][j] = _at(i, j - 1) * By + s[i][j];
}
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) hash[i][j] = hash[i][j] + _at(i - 1, j) * Bx;
}
}
template <typename Int>
rolling_hash_2d(const std::vector<std::vector<Int>> &s, V bx, V by) : Bx(bx), By(by) {
build(s);
}
rolling_hash_2d(const std::vector<std::string> &m, V bx, V by) : Bx(bx), By(by) {
std::vector<std::vector<int>> v_;
for (const auto &s : m) {
v_.push_back({});
for (char c : s) v_.back().push_back(int(c));
}
build(v_);
}
V get(int xl, int xr, int yl, int yr) const {
return _at(xr - 1, yr - 1) - _at(xl - 1, yr - 1) * powx[xr - xl] -
_at(xr - 1, yl - 1) * powy[yr - yl] +
_at(xl - 1, yl - 1) * powx[xr - xl] * powy[yr - yl];
}
};
#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); }
int main() {
int H, W, N;
cin >> H >> W;
cin >> N;
dbg(make_tuple(H, W, N));
const mint Bx = mint::randgen(true), By = mint::randgen(true);
dbg(Bx.val());
dbg(By.val());
map<int, mint> weights;
for (int v : {0, 1, 2, 5, 8, 6, 9}) weights[v] = mint::randgen(true);
rangetree_bit<S, opadd, opsub, e, int> rt1, rt2;
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);
points.emplace_back(i, j, x);
}
rt1.build();
rt2.build();
for (auto [i, j, x] : points) {
{ rt1.add(i, j, weights.at(x) * Bx.pow(i) * By.pow(j)); }
{
int y = x;
if (x == 6) y = 9;
if (x == 9) y = 6;
rt2.add(H - 1 - i, W - 1 - j, weights.at(y) * Bx.pow(H - 1 - i) * By.pow(W - 1 - j));
}
}
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) / (Bx.pow(l) * By.pow(d));
auto ans2 = rt2.sum(H - r, H - l, W - u, W - d) / (Bx.pow(H - r) * By.pow(W - u));
if (ans1 == ans2) {
puts("Yes");
} else {
puts("No");
}
}
}