#1191911 (C++23) No.3581 分数対称差更新区間計数取得

• 問題: No.3581 分数対称差更新区間計数取得
• ユーザー: Taiki0715
• 提出日時: 2026-10-07 23:55:57
• 言語: C++23 (gcc 15.3.0 + boost 1.92.0 + ACL)
• 結果: AC
• 実行時間: 3,327 ms / 10,000 ms
• コード長: 11,373 bytes
• コンパイル時間: 2,434 ms
• コンパイル使用メモリ: 345,040 KB
• 実行使用メモリ: 9,844 KB
• 最終ジャッジ日時: 2026-10-07 23:56:34
• 合計ジャッジ時間: 33,832 ms
• ジャッジサーバーID （参考情報）: judge1_1 / judge2_0

ファイルパターン	結果
other	AC * 24

ソースコード

#include<cassert>
#include <bits/stdc++.h>
#ifndef IO_HPP
#define IO_HPP
#include<iostream>
#include<vector>
#include<queue>
#include<stack>
#include<array>
#include<map>
#include<unordered_map>
#include<set>
#include<unordered_set>
using namespace std;
template<typename T1,typename T2>istream &operator>>(istream&,pair<T1,T2>&);
template<typename...Args>istream &operator>>(istream&,tuple<Args...>&a);
template<typename T>istream &operator>>(istream&is,vector<T>&a);
template<typename T,size_t N>istream &operator>>(istream&is,array<T,N>&a);
template<typename T1,typename T2>
istream &operator>>(istream&is,pair<T1,T2>&a){
  is>>a.first>>a.second;
  return is;
}
template<size_t pos,typename...Args>
void read_tuple(istream&is,tuple<Args...>&a){
  if constexpr(pos<tuple_size<tuple<Args...>>::value){
    is>>get<pos>(a);
    read_tuple<pos+1>(is,a);
  }
}
template<typename...Args>
istream &operator>>(istream&is,tuple<Args...>&a){
  read_tuple<0>(is,a);
  return is;
}
template<typename T>
istream &operator>>(istream&is,vector<T>&a){
  for(T&x:a)is>>x;
  return is;
}
template<typename T,size_t N>
istream &operator>>(istream&is,array<T,N>&a){
  for(T&x:a)is>>x;
  return is;
}
template<typename T1,typename T2>ostream &operator<<(ostream&os,const pair<T1,T2>&);
template<typename...Args>ostream &operator<<(ostream&os,const tuple<Args...>&);
template<typename T>ostream &operator<<(ostream&os,const vector<T>&);
template<typename T,typename Seq,typename Comp>ostream &operator<<(ostream&os,priority_queue<T,Seq,Comp>);
template<typename T>ostream &operator<<(ostream&os,queue<T>);
template<typename T>ostream &operator<<(ostream&os,deque<T>);
template<typename T>ostream &operator<<(ostream&os,stack<T>);
template<typename T,size_t N>ostream &operator<<(ostream&os,const array<T,N>&);
template<typename Key,typename Val,typename Comp>ostream &operator<<(ostream&os,const map<Key,Val,Comp>&);
template<typename Key,typename Val,typename Hash>ostream &operator<<(ostream&os,const unordered_map<Key,Val,Hash>&);
template<typename T,typename Comp>ostream &operator<<(ostream&os,const set<T,Comp>&);
template<typename T,typename Comp>ostream &operator<<(ostream&os,const multiset<T,Comp>&);
template<typename T,typename Hash>ostream &operator<<(ostream&os,const unordered_set<T,Hash>&);
template<typename T1,typename T2>
ostream &operator<<(ostream&os,const pair<T1,T2>&a){
  os<<a.first<<' '<<a.second;
  return os;
}
template<size_t pos,typename...Args>
void write_tuple(ostream&os,const tuple<Args...>&a){
  if constexpr(pos<tuple_size<tuple<Args...>>::value){
    if constexpr(pos>0)os<<' ';
    os<<get<pos>(a);
    write_tuple<pos+1>(os,a);
  }
}
template<typename...Args>
ostream &operator<<(ostream&os,const tuple<Args...>&a){
  write_tuple<0>(os,a);
  return os;
}
template<typename T>
ostream &operator<<(ostream&os,const vector<T>&a){
  os<<'{';
  for(int i=0;i<(int)a.size();i++){
    os<<a[i];
    if(i+1!=a.size())os<<',';
  }
  os<<'}';
  return os;
}
template<typename T,typename Seq,typename Comp>
ostream &operator<<(ostream&os,priority_queue<T,Seq,Comp>a){
  os<<'{';
  if(!a.empty()){
    os<<a.top();a.pop();
    while(!a.empty()){
      os<<',';
      os<<a.top();
      a.pop();
    }
  }
  os<<'}';
  return os;
}
template<typename T>
ostream &operator<<(ostream&os,queue<T>a){
  os<<'{';
  if(!a.empty()){
    os<<a.front();a.pop();
    while(!a.empty()){
      os<<',';
      os<<a.front();
      a.pop();
    }
  }
  os<<'}';
  return os;
}
template<typename T>
ostream &operator<<(ostream&os,deque<T>a){
  os<<'{';
  if(!a.empty()){
    os<<a.front();a.pop_front();
    while(!a.empty()){
      os<<',';
      os<<a.front();
      a.pop_front();
    }
  }
  os<<'}';
  return os;
}
template<typename T>
ostream &operator<<(ostream&os,stack<T>a){
  os<<'{';
  if(!a.empty()){
    os<<a.top();a.pop();
    while(!a.empty()){
      os<<',';
      os<<a.top();
      a.pop();
    }
  }
  os<<'}';
  return os;
}
template<typename T,size_t N>
ostream &operator<<(ostream&os,const array<T,N>&a){
  os<<'{';
  for(int i=0;i<(int)a.size();i++){
    os<<a[i];
    if(i+1!=a.size())os<<',';
  }
  os<<'}';
  return os;
}
template<typename Key,typename Val,typename Comp>
ostream &operator<<(ostream&os,const map<Key,Val,Comp>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<"{["<<itr->first<<","<<itr->second<<']';
  while(++itr!=a.end())os<<",["<<itr->first<<','<<itr->second<<']';
  os<<'}';
  return os;
}
template<typename Key,typename Val,typename Hash>
ostream &operator<<(ostream&os,const unordered_map<Key,Val,Hash>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<"{["<<itr->first<<","<<itr->second<<']';
  while(++itr!=a.end())os<<",["<<itr->first<<','<<itr->second<<']';
  os<<'}';
  return os;
}
template<typename T,typename Comp>
ostream &operator<<(ostream&os,const set<T,Comp>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<'{'<<*itr;
  while(++itr!=a.end())os<<','<<*itr;
  os<<'}';
  return os;
}
template<typename T,typename Comp>
ostream &operator<<(ostream&os,const multiset<T,Comp>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<'{'<<*itr;
  while(++itr!=a.end())os<<','<<*itr;
  os<<'}';
  return os;
}
template<typename T,typename Hash>
ostream &operator<<(ostream&os,const unordered_set<T,Hash>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<'{'<<*itr;
  while(++itr!=a.end())os<<','<<*itr;
  os<<'}';
  return os;
}
#endif
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>void operator++(pair<T1,T2>&a,int){a.first++,a.second++;}
template<typename T1,typename T2>void operator--(pair<T1,T2>&a,int){a.first--,a.second--;}
template<typename T>void operator++(vector<T>&a,int){for(auto &i:a)i++;}
template<typename T>void operator--(vector<T>&a,int){for(auto &i:a)i--;}
using vref=typename vector<bool>::reference;
vref operator|=(vref a,bool b){a=a|b;return a;}
vref operator&=(vref a,bool b){a=a&b;return a;}
vref operator^=(vref a,bool b){a=a^b;return a;}
#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)
#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();
  }
}
#include<bit>
#include<type_traits>
#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);}
namespace kth_bit_impl{
struct Pre{
  std::int8_t table[1<<16][16];
  Pre(){
    for(int i=0;i<(1<<16);i++){
      for(int j=0,x=i;x&&j<16;j++){
        int l=lsb(x);
        table[i][j]=l;
        x^=1<<l;
      }
    }
  }
}pre;
constexpr unsigned long long mask1=(1ull<<16)-1;
template<bool check_over=true>
int kth_bit(unsigned long long x,int k){
  if constexpr(check_over){
    if(std::popcount(x)<=k)return -1;
  }
  int c=std::popcount<unsigned int>(x&-1u);
  if(k<c){
    unsigned int y=x;
    int d=std::popcount(y&mask1);
    if(k<d)return pre.table[y&mask1][k];
    else return pre.table[y>>16][k-d]+16;
  }
  else{
    k-=c;
    unsigned int y=x>>32;
    int d=std::popcount(y&mask1);
    if(k<d)return pre.table[y&mask1][k]+32;
    else return pre.table[y>>16][k-d]+48;
  }
}
}
using kth_bit_impl::kth_bit;
struct BinaryIndexedTree01{
  int n,n64,z64;
  std::vector<int>dat;
  std::vector<uint64_t>a;
  explicit BinaryIndexedTree01(int n_):n(n_),n64((n_+63)>>6),z64(ceil_pow2(n64)){
    dat.resize(n64,0);
    a.resize(n64,uint64_t(0));
  }
  explicit BinaryIndexedTree01(const std::vector<int>&init):n(init.size()),n64((n+63)>>6),z64(ceil_pow2(n64)){
    dat.resize(n64);
    a.resize(n64);
    for(int i=0;i<n;i++)if(init[i]){
      a[i>>6]|=uint64_t(1)<<(i&63);
      dat[i>>6]++;
    }
    for(int i=1;i<=n64;i++){
      int j=i+(i&-i);
      if(j<=n64)dat[j-1]+=dat[i-1];
    }
  }
  void set(int k,int x){
    if((a[k>>6]>>(k&63)&1)==x)return;
    a[k>>6]^=uint64_t(1)<<(k&63);
    if(!x)x=-1;
    k>>=6;
    k++;
    while(k<=n64){
      dat[k-1]+=x;
      k+=k&-k;
    }
  }
  int sum(int l,int r)const{
    int ret=__builtin_popcountll(a[r>>6]&((uint64_t(1)<<(r&63))-1))-__builtin_popcountll(a[l>>6]&((uint64_t(1)<<(l&63))-1));
    l>>=6,r>>=6;
    while(l<r){
      ret+=dat[r-1];
      r-=r&-r;
    }
    while(r<l){
      ret-=dat[l-1];
      l-=l&-l;
    }
    return ret;
  }
  int lower_bound(int k)const{
    int res=0;
    for(int i=z64;i>=1;i>>=1){
      if(res+i<=std::ssize(dat)&&dat[res+i-1]<k){
        k-=dat[res+i-1];
        res+=i;
      }
    }
    if(res==n64)return n;
    return res*64+kth_bit<0>(a[res],k-1);
  }
};
constexpr int nmax=SWITCH(100,1000000);
void SOLVE(){
  int q;
  cin>>q;
  vector<bool>a(nmax+1);
  BinaryIndexedTree01 bit(nmax+1);
  while(q--){
    int n,l,r;
    cin>>n>>l>>r;
    int s=sqrt(n);
    rep(i,1,s+1){
      a[i]^=1;
      bit.set(i,a[i]);
    }
    rep(i,1,s){
      a[n/i]^=1;
      bit.set(n/i,a[n/i]);
    }
    if(s!=n/s){
      a[n/s]^=1;
      bit.set(n/s,a[n/s]);
    }
    cout<<bit.sum(l,r+1)<<'\n';
  }
}