#1106036 (C++23) No.3207 Digital Font

• 問題: No.3207 Digital Font
• ユーザー: Taiki0715
• 提出日時: 2025-07-19 22:23:31
• 言語: C++23 (gcc 13.3.0 + boost 1.87.0)
• 結果: AC
• 実行時間: 1,145 ms / 3,000 ms
• コード長: 60,791 bytes
• コンパイル時間: 8,828 ms
• コンパイル使用メモリ: 428,760 KB
• 実行使用メモリ: 29,432 KB
• 最終ジャッジ日時: 2025-07-19 22:24:03
• 合計ジャッジ時間: 30,569 ms
• ジャッジサーバーID （参考情報）: judge2 / judge4

ファイルパターン	結果
sample	AC * 2
other	AC * 38

ソースコード

#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using ull=unsigned long long;
using P=pair<ll,ll>;
template<typename T>using minque=priority_queue<T,vector<T>,greater<T>>;
template<typename T>bool chmax(T &a,const T &b){return (a<b?(a=b,true):false);}
template<typename T>bool chmin(T &a,const T &b){return (a>b?(a=b,true):false);}
template<typename T1,typename T2>istream &operator>>(istream &is,pair<T1,T2>&p){is>>p.first>>p.second;return is;}
template<typename T1,typename T2,typename T3>istream &operator>>(istream &is,tuple<T1,T2,T3>&a){is>>std::get<0>(a)>>std::get<1>(a)>>std::get<2>(a);return is;}
template<typename T,size_t n>istream &operator>>(istream &is,array<T,n>&a){for(auto&i:a)is>>i;return is;}
template<typename T>istream &operator>>(istream &is,vector<T> &a){for(auto &i:a)is>>i;return is;}
template<typename T1,typename T2>void operator++(pair<T1,T2>&a,int n){a.first++,a.second++;}
template<typename T1,typename T2>void operator--(pair<T1,T2>&a,int n){a.first--,a.second--;}
template<typename T>void operator++(vector<T>&a,int n){for(auto &i:a)i++;}
template<typename T>void operator--(vector<T>&a,int n){for(auto &i:a)i--;}
#define overload3(_1,_2,_3,name,...) name
#define rep1(i,n) for(int i=0;i<(int)(n);i++)
#define rep2(i,l,r) for(int i=(int)(l);i<(int)(r);i++)
#define rep(...) overload3(__VA_ARGS__,rep2,rep1)(__VA_ARGS__)
#define reps(i,l,r) rep2(i,l,r)
#define all(x) x.begin(),x.end()
#define pcnt(x) __builtin_popcountll(x)
#define fin(x) return cout<<(x)<<'\n',static_cast<void>(0)
#define yn(x) cout<<((x)?"Yes\n":"No\n")
#define uniq(x) sort(all(x)),x.erase(unique(all(x)),x.end())
template<typename T>
inline int fkey(vector<T>&z,T key){return lower_bound(z.begin(),z.end(),key)-z.begin();}
ll myceil(ll a,ll b){return (a+b-1)/b;}
template<typename T,size_t n,size_t id=0>
auto vec(const int (&d)[n],const T &init=T()){
  if constexpr (id<n)return vector(d[id],vec<T,n,id+1>(d,init));
  else return init;
}
#ifdef LOCAL
#include<debug.h>
#define SWITCH(a,b) (a)
#else
#define debug(...) static_cast<void>(0)
#define debugg(...) static_cast<void>(0)
#define SWITCH(a,b) (b)
template<typename T1,typename T2>ostream &operator<<(ostream &os,const pair<T1,T2>&p){os<<p.first<<' '<<p.second;return os;}
#endif
struct Timer{
  clock_t start;
  Timer(){
    start=clock();
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout<<fixed<<setprecision(16);
  }
  inline double now(){return (double)(clock()-start)/1000;}
  #ifdef LOCAL
  ~Timer(){
    cerr<<"time:";
    cerr<<now();
    cerr<<"ms\n";
  }
  #endif
}timer;
void SOLVE();
int main(){
  int testcase=1;
  //cin>>testcase;
  for(int i=0;i<testcase;i++){
    SOLVE();
  }
}
using namespace std;
template<typename I,typename M>
struct BinaryIndexedTree2D{
  using S=typename M::S;
private:
  int n;
  vector<I>xz,yz;
  vector<int>offset;
  vector<S>dat;
  void build(std::vector<std::tuple<I,I,S>>a){
    xz.resize(a.size());
    for(int i=0;i<a.size();i++)xz[i]=std::get<0>(a[i]);
    sort(all(xz));
    sort(xz.begin(),xz.end()),xz.erase(std::unique(xz.begin(),xz.end()),xz.end());
    n=xz.size();
    sort(a.begin(),a.end(),[](std::tuple<I,I,S>&x,std::tuple<I,I,S>&y){
      return std::get<1>(x)<std::get<1>(y);
    });
    offset.resize(n+1,0);
    vector<I>ls(n,-1);
    for(auto&&[x,y,v]:a){
      x=std::lower_bound(xz.begin(),xz.end(),x)-xz.begin();
      int x2=x;
      I y2=y;
      while(x2<n){
        if(ls[x2]==y2)break;
        ls[x2]=y2;
        offset[x2+1]++;
        x2+=(x2+1)&-(x2+1);
      }
    }
    for(int i=0;i<n;i++)offset[i+1]+=offset[i];
    yz.resize(offset[n]);
    dat.resize(offset[n],0);
    ls.assign(n,-1);
    vector<int>lt(offset);
    for(auto [x,y,v]:a){
      while(x<n){
        if(ls[x]==y)dat[lt[x]-1]=M::op(dat[lt[x]-1],v);
        else{
          ls[x]=y;
          yz[lt[x]]=y;
          dat[lt[x]]=v;
          lt[x]++;
        }
        x+=(x+1)&-(x+1);
      }
    }
    for(int i=0;i<n;i++){
      int m=offset[i+1]-offset[i];
      for(int j=0;j<m-1;j++){
        int k=j+((j+1)&-(j+1));
        if(k<m)dat[offset[i]+k]=M::op(dat[offset[i]+k],dat[offset[i]+j]);
      }
    }
  }
public:
  BinaryIndexedTree2D(const std::vector<std::tuple<I,I,S>>&a){
    build(a);
  }
  BinaryIndexedTree2D(const std::map<std::pair<I,I>,S>&a){
    vector<tuple<I,I,S>>b;
    b.reserve(a.size());
    for(auto [k,v]:a)b.emplace_back(k.first,k.second,v);
    build(b);
  }
  void add(I x,I y,S v){
    x=std::lower_bound(all(xz),x)-xz.begin();
    while(x<n){
      int y2=std::lower_bound(yz.begin()+offset[x],yz.begin()+offset[x+1],y)-(yz.begin()+offset[x]);
      int m=offset[x+1]-offset[x];
      while(y2<m){
        dat[offset[x]+y2]=M::op(dat[offset[x]+y2],v);
        y2+=(y2+1)&-(y2+1);
      }
      x+=(x+1)&-(x+1);
    }
  }
  S sum(I lx,I rx,I ly,I ry){
    int l=std::lower_bound(xz.begin(),xz.end(),lx)-xz.begin()-1,r=std::lower_bound(xz.begin(),xz.end(),rx)-xz.begin()-1;
    S ret=M::e();
    while(l<r){
      int l2=std::lower_bound(yz.begin()+offset[r],yz.begin()+offset[r+1],ly)-(yz.begin()+offset[r])-1;
      int r2=std::lower_bound(yz.begin()+offset[r],yz.begin()+offset[r+1],ry)-(yz.begin()+offset[r])-1;
      while(l2<r2){
        ret=M::op(ret,dat[offset[r]+r2]);
        r2-=(r2+1)&-(r2+1);
      }
      while(l2!=r2){
        ret=M::op(ret,M::inverse(dat[offset[r]+l2]));
        l2-=(l2+1)&-(l2+1);
      }
      r-=(r+1)&-(r+1);
    }
    while(l!=r){
      int l2=std::lower_bound(yz.begin()+offset[l],yz.begin()+offset[l+1],ly)-(yz.begin()+offset[l])-1;
      int r2=std::lower_bound(yz.begin()+offset[l],yz.begin()+offset[l+1],ry)-(yz.begin()+offset[l])-1;
      while(l2<r2){
        ret=M::op(ret,M::inverse(dat[offset[l]+r2]));
        r2-=(r2+1)&-(r2+1);
      }
      while(l2!=r2){
        ret=M::op(ret,dat[offset[l]+l2]);
        l2-=(l2+1)&-(l2+1);
      }
      l-=(l+1)&-(l+1);
    }
    return ret;
  }
};
#include<type_traits>
template<typename T=int>
struct MonoidAdd{
  using S=T;
  using F=std::nullptr_t;
  static inline S op(S x,S y){return x+y;}
  static inline S e(){return 0;}
  static inline S mapping(F,const S&x,long long){return x;}
  static inline F composition(F,F){return nullptr;}
  static inline F id(){return nullptr;}
  static inline S inverse(S x){return -x;}
  static inline void revS(S&x){}
  static inline S pow(S x,long long p){return x*p;}
};
struct mint61{
private:
  using ull=unsigned long long;
  static constexpr ull m=(1ull<<61)-1;
  static constexpr ull mask30=(1ull<<30)-1;
  static constexpr ull mask31=(1ull<<31)-1;
  static constexpr ull mul(ull a,ull b){
    ull au=a>>31;
    ull ad=a&mask31;
    ull bu=b>>31;
    ull bd=b&mask31;
    ull mid=au*bd+ad*bu;
    ull midu=mid>>30;
    ull midd=mid&mask30;
    mid=au*bu*2+midu+(midd<<31)+ad*bd;
    midu=mid>>61,midd=mid&m;
    mid=midu+midd;
    if(mid>=m)mid-=m;
    return mid;
  }
  ull v;
public:
  using value_type=ull;
  mint61():v(0){}
  template<typename T,std::enable_if_t<std::is_signed_v<T>,std::nullptr_t> =nullptr>
  mint61(T a){
    long long v2=a%(long long)m;
    if(v2<0)v2+=(long long)m;
    v=v2;
  }
  template<typename T,std::enable_if_t<std::is_unsigned_v<T>,std::nullptr_t> =nullptr>
  mint61(T a):v(a%m){}
  static mint61 raw(ull x){
    mint61 res;
    res.v=x;
    return res;
  }
  static constexpr ull mod(){return m;}
  inline mint61 operator++(int){
    mint61 res(*this);
    *this+=mint61::raw(1);
    return res;
  }
  inline mint61 operator--(int){
    mint61 res(*this);
    *this-=mint61::raw(1);
    return res;
  }
  inline mint61 operator-(){
    mint61 res;
    if(this->v==0)return res;
    res.v=m-this->v;
    return res;
  }
  inline mint61 &operator+=(const mint61&rhs){
    v+=rhs.v;
    if(v>=m)v-=m;
    return *this;
  }
  inline mint61 &operator-=(const mint61&rhs){
    v-=rhs.v;
    if(v>=m)v+=m;
    return *this;
  }
  inline mint61 &operator*=(const mint61&rhs){
    v=mul(v,rhs.v);
    return *this;
  }
  inline mint61 &operator/=(const mint61&rhs){
    (*this)*=rhs.inv();
    return *this;
  }
  ull val()const{return v;}
  mint61 pow(ull x)const{
    mint61 res=mint61::raw(1);
    mint61 a(*this);
    while(x){
      if(x&1)res*=a;
      a*=a;
      x>>=1;
    }
    return res;
  }
  mint61 inv()const{return (*this).pow(mod()-2);}
  friend inline mint61 operator+(const mint61&lhs,const mint61&rhs){return mint61(lhs)+=rhs;}
  friend inline mint61 operator-(const mint61&lhs,const mint61&rhs){return mint61(lhs)-=rhs;}
  friend inline mint61 operator*(const mint61&lhs,const mint61&rhs){return mint61(lhs)*=rhs;}
  friend inline mint61 operator/(const mint61&lhs,const mint61&rhs){return mint61(lhs)/=rhs;}
  friend inline bool operator==(const mint61&lhs,const mint61&rhs){return lhs.v==rhs.v;}
  friend inline bool operator!=(const mint61&lhs,const mint61&rhs){return lhs.v!=rhs.v;}
  friend std::istream &operator>>(std::istream &is,mint61&a){
    is>>a.v;
    return is;
  }
  friend std::ostream &operator<<(std::ostream &os,const mint61&a){
    os<<a.v;
    return os;
  }
};
template<>
struct std::hash<mint61>{
  std::size_t operator()(mint61 x)const{
    return std::hash<unsigned long long>()(x.val());
  }
};
namespace Random{
  std::mt19937_64 mt(std::random_device{}());
  template<typename T>inline std::enable_if_t<std::is_integral_v<T>,T> get(){return mt();}
  template<typename T>inline std::enable_if_t<std::is_floating_point_v<T>,T> get(){return T(mt())/T(-1ull);}
  template<typename T>inline std::enable_if_t<std::is_integral_v<T>,T>range(T n){return mt()%n;}
  template<typename T>inline std::enable_if_t<std::is_integral_v<T>,T>range(T l,T r){return l+mt()%(r-l);}
  template<typename T>inline std::enable_if_t<std::is_integral_v<T>,std::pair<T,T>>distinct(T n){
    T l=mt()%n,r=mt()%(n-1);
    if(l==r)r++;
    if(l>r)std::swap(l,r);
    return std::make_pair(l,r);
  }
}
#include<concepts>
template<typename T>
constexpr std::enable_if_t<std::numeric_limits<T>::digits<=32,int>msb(T n){return n==0?-1:31-__builtin_clz(n);}
template<typename T>
constexpr std::enable_if_t<(std::numeric_limits<T>::digits>32),int>msb(T n){return n==0?-1:63-__builtin_clzll(n);}

template<typename T>
constexpr std::enable_if_t<std::numeric_limits<T>::digits<=32,int>lsb(T n){return n==0?-1:__builtin_ctz(n);}
template<typename T>
constexpr std::enable_if_t<(std::numeric_limits<T>::digits>32),int>lsb(T n){return n==0?-1:__builtin_ctzll(n);}

template<typename T>
constexpr std::enable_if_t<std::is_integral_v<T>,T>floor_pow2(T n){return n==0?0:T(1)<<msb(n);}

template<typename T>
constexpr std::enable_if_t<std::is_integral_v<T>,T>ceil_pow2(T n){return n<=1?1:T(1)<<(msb(n-1)+1);}

template<std::integral T>
constexpr T safe_div(T a,T b){return a/b-(a%b&&(a^b)<0);}
template<std::integral T>
constexpr T safe_ceil(T a,T b){return a/b+(a%b&&(a^b)>0);}
constexpr unsigned long long binary_gcd(unsigned long long a,unsigned long long b){
  if(a==0||b==0||a==b)return a<b?b:a;
  int n=lsb(a),m=lsb(b);
  while(a!=b){
    if(a>b)a=(a-b)>>lsb(a-b);
    else b=(b-a)>>lsb(b-a);
  }
  return a<<(n<m?n:m);
}
namespace base64_decode_impl{
constexpr int ctoi(char c){
  if('A'<=c&&c<='Z')return c-'A';
  else if('a'<=c&&c<='z')return c-'a'+26;
  else if('0'<=c&&c<='9')return c-'0'+52;
  else if(c=='+')return 62;
  else if(c=='/')return 63;
  else return -1;
}
template<int N>
constexpr std::array<bool,N>bin_decode(const char*c){
  std::array<bool,N>res;
  for(int i=0,j=0;i<N;i+=6,j++){
    int now=ctoi(c[j]);
    for(int k=0;k<6;k++)if(i+k<N)res[i+k]=now>>k&1;
  }
  return res;
}
template<typename T,int N,int bit_width>
constexpr std::array<T,N>base64_decode(const char*c){
  static_assert(std::is_integral_v<T>);
  std::array<T,N>res;
  std::array<bool,N*bit_width>bin=bin_decode<N*bit_width>(c);
  for(int i=0;i<N;i++){
    res[i]=0;
    for(int j=0;j<bit_width;j++){
      if(bin[i*bit_width+j]){
        res[i]|=T(1)<<j;
      }
    }
  }
  return res;
}
}
using base64_decode_impl::base64_decode;
namespace isprime_impl{
using u16=uint16_t;
using u32=uint32_t;
using u64=uint64_t;
using u128=__uint128_t;
const std::array<u16,16384>base_table1=base64_decode<u16,16384,16>("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");
constexpr u16 base_table2[8]={15,135,13,60,15,117,65,29};
constexpr u64 reduce(u128 v,u64 r,u64 mod){
  return (v+u128(u64(v)*-r)*mod)>>64;
}
constexpr bool isprime(unsigned long long n){
  if(n<64)return 2891462833508853932ll>>n&1;
  if(n%2==0)return false;
  int k=lsb(n-1);
  u64 d=(n-1)>>k;
  u64 r=n;
  for(int i=0;i<5;i++)r*=2-n*r;
  u64 r2=-u128(n)%n;
  u64 p1=reduce(r2,r,n),m1=reduce(u128(n-1)*r2,r,n);
  if(p1>=n)p1-=n;
  if(m1>=n)m1-=n;
  u64 base1=2,base2=7,base3=61;
  if(n>=u64(1)<<32){
    base2=base_table1[u32(n*0xAD625B89)>>18];
    base3=base_table2[base2>>13];
  }
  base1=reduce(u128(base1)*r2,r,n);
  base2=reduce(u128(base2)*r2,r,n);
  base3=reduce(u128(base3)*r2,r,n);
  u64 x1=p1,x2=p1,x3=p1;
  while(d>0){
    if(d&1){
      x1=reduce(u128(x1)*base1,r,n);
      x2=reduce(u128(x2)*base2,r,n);
      x3=reduce(u128(x3)*base3,r,n);
    }
    base1=reduce(u128(base1)*base1,r,n);
    base2=reduce(u128(base2)*base2,r,n);
    base3=reduce(u128(base3)*base3,r,n);
    d>>=1;
  }
  if(x1>=n)x1-=n;
  if(x2>=n)x2-=n;
  if(x3>=n)x3-=n;
  bool f1=x1==p1||x1==m1;
  bool f2=x2==p1||x2==m1;
  bool f3=x3==p1||x3==m1;
  while(--k){
    x1=reduce(u128(x1)*x1,r,n);
    x2=reduce(u128(x2)*x2,r,n);
    x3=reduce(u128(x3)*x3,r,n);
    if(x1>=n)x1-=n;
    if(x2>=n)x2-=n;
    if(x3>=n)x3-=n;
    f1|=x1==m1;
    f2|=x2==m1;
    f3|=x3==m1;
  }
  return f1&&f2&&f3;
}
}
using isprime_impl::isprime;
std::vector<unsigned long long>factorize(unsigned long long n)noexcept{
  std::vector<unsigned long long>ret;
  auto div=[](unsigned long long x)noexcept->unsigned long long {
    unsigned long long r=x;
    for(int i=0;i<5;i++)r*=2-r*x;
    unsigned long long r2=-__uint128_t(x)%x;
    auto redc=[&r,&x](__uint128_t t)->unsigned long long {
      t=(t+__uint128_t((unsigned long long)t*-r)*x)>>64;
      return t>=x?t-x:t;
    };
    unsigned long long a=0,b=0;
    const unsigned long long one=redc(r2);
    unsigned long long e=one;
    int m=1ll<<((63-__builtin_clzll(x))>>3);
    while(true){
      unsigned long long ca=a,cb=b;
      unsigned long long sk=one;
      for(int i=0;i<m;i++){
        a=redc(__uint128_t(a)*a+e);
        b=redc(__uint128_t(b)*b+e);
        b=redc(__uint128_t(b)*b+e);
        unsigned long long c=redc(a),d=redc(b);
        sk=redc(__uint128_t(sk)*(c>d?c-d:d-c));
      }
      unsigned long long g=binary_gcd(redc(sk),x);
      if(g>1){
        if(g<x)return g;
        for(int i=0;i<m;i++){
          ca=redc(__uint128_t(ca)*ca+e);
          cb=redc(__uint128_t(cb)*cb+e);
          cb=redc(__uint128_t(cb)*cb+e);
          unsigned long long c=redc(ca),d=redc(cb);
          unsigned long long cg=binary_gcd(c>d?c-d:d-c,x);
          if(cg>1){
            if(cg<x)return cg;
            else{
              e+=one;
              a=b=0;
              break;
            }
          }
        }
      }
    }
  };
  static unsigned long long st[64];
  int p=0;
  while(!(n&1)){
    n>>=1;
    ret.push_back(2);
  }
  if(n==1)return ret;
  st[p++]=n;
  while(p){
    unsigned long long now=st[--p];
    if(isprime(now)){
      ret.push_back(now);
      continue;
    }
    unsigned long long d=div(now);
    st[p++]=d;
    now/=d;
    if(now!=1)st[p++]=now;
  }
  return ret;
}
long long primitive_root(long long n){
  std::vector<std::pair<long long,int>>f;
  {
    auto pf=factorize(n-1);
    std::sort(pf.begin(),pf.end());
    for(int i=0;i<pf.size();){
      int j=i;
      while(j<pf.size()&&pf[i]==pf[j])j++;
      f.push_back(std::make_pair(pf[i],j-i));
      i=j;
    }
  }
  using u128=__uint128_t;
  auto pow64=[](long long a,long long p,long long mod)->long long {
    long long res=1;
    while(p){
      if(p&1)res=u128(res)*a%mod;
      a=u128(a)*a%mod;
      p>>=1;
    }
    return res;
  };
  auto is_ok=[&](long long g)->bool {
    for(const auto&[p,e]:f){
      if(pow64(g,(n-1)/p,n)==1)return false;
    }
    return true;
  };
  long long res=1;
  while(!is_ok(res))res=Random::range(1ll,n);
  return res;
}
int f(int x){
  if(x==6||x==9)return x^6^9;
  return x;
}
void SOLVE(){
  int h,w,n;
  cin>>h>>w>>n;
  vector<tuple<int,int,int>>a(n);
  rep(i,n){
    int x,y,w2;
    cin>>x>>y>>w2;
    x--,y--;
    a[i]={x,y,w2};
  }
  mint61 rx=primitive_root(mint61::mod());
  mint61 ry=primitive_root(mint61::mod());
  vector<mint61>powx(h+1),powy(w+1);
  powx[0]=1;
  rep(i,1,h+1)powx[i]=powx[i-1]*rx;
  powy[0]=1;
  rep(i,1,w+1)powy[i]=powy[i-1]*ry;
  vector<tuple<int,int,mint61>>init(n);
  rep(i,n){
    auto [x,y,w2]=a[i];
    init[i]={x,y,powx[x]*powy[y]*(w2)};
  }
  BinaryIndexedTree2D<int,MonoidAdd<mint61>>seg(init);
  rep(i,n){
    auto [x,y,w2]=a[i];
    init[i]={h-1-x,w-1-y,powx[h-1-x]*powy[w-1-y]*(f(w2))};
  }
  BinaryIndexedTree2D<int,MonoidAdd<mint61>>rev(init);
  int q;
  cin>>q;
  while(q--){
    int l,d,r,u;
    cin>>l>>d>>r>>u;
    l--,d--;
    mint61 v1=seg.sum(l,r,d,u)/(powx[l]*powy[d]);
    mint61 v2=rev.sum(h-r,h-l,w-u,w-d)/(powx[h-r]*powy[w-u]);
    yn(v1==v2);
  }
}