結果

問題 No.1918 Simple Math ?
ユーザー eQe
提出日時 2025-03-08 11:59:35
言語 C++23
(gcc 13.3.0 + boost 1.87.0)
結果
WA  
実行時間 -
コード長 5,369 bytes
コンパイル時間 6,206 ms
コンパイル使用メモリ 333,132 KB
実行使用メモリ 14,892 KB
最終ジャッジ日時 2025-03-08 11:59:48
合計ジャッジ時間 12,792 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge2
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample WA * 1
other AC * 30 WA * 3
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include<bits/stdc++.h>
#include<atcoder/all>
using namespace std;
namespace my{
using ml=atcoder::modint1000000007;
auto&operator>>(istream&i,ml&x){int t;i>>t;x=t;return i;}
auto&operator<<(ostream&o,const ml&x){return o<<(int)x.val();}
#define eb emplace_back
#define LL(...) ll __VA_ARGS__;lin(__VA_ARGS__)
#define FO(n) for(ll ij=n;ij-->0;)
#define FOR(i,...) for(auto[i,i##stop,i##step]=range(0,__VA_ARGS__);i<i##stop;i+=i##step)
#define fo(i,...) FO##__VA_OPT__(R)(i __VA_OPT__(,__VA_ARGS__))
#define of(i,...) for(auto[i,i##stop,i##step]=range(1,__VA_ARGS__);i>=i##stop;i+=i##step)
#define fe(a,i,...) for(auto&&__VA_OPT__([)i __VA_OPT__(,__VA_ARGS__]):a)
#define bit_sizeof(T) ll(sizeof(T)*CHAR_BIT)
#define base_operator(op,type) auto operator op(const type&v)const{auto copy=*this;return copy op##=v;}
#define multiple_testcases void solve();}int main(){my::io();int T;std::cin>>T;while(T--)my::solve();}namespace my{
void io(){cin.tie(nullptr)->sync_with_stdio(0);cout<<fixed<<setprecision(15);}
using ll=long long;
constexpr auto range(ll s,ll b){ll a=0;if(s)swap(a,b);return array{a-s,b,1-s*2};}
constexpr auto range(ll s,ll a,ll b,ll c=1){return array{a-s,b,(1-s*2)*c};}
constexpr char newline=10;
constexpr char space=32;
constexpr auto schrodinger(bool p,char c){return string(p,c);}
constexpr auto square(auto x){return x*x;}
template<class T>concept addable=requires(T a,T b){{a+b}->same_as<T>;};

template<ll k,class...A>using pack_kth_t=tuple_element_t<k,std::tuple<A...>>;
template<ll k>auto pack_kth(const auto&...a){return get<k>(make_tuple(a...));}
template<class T,ll n>auto pack_prefix_array(const auto&...a){return[&]<size_t...I>(index_sequence<I...>){return array<T,n>{get<I>(make_tuple(a...))...};}(make_index_sequence<n>{});}

template<class V>concept vectorial=is_base_of_v<vector<typename V::value_type>,V>;
template<class T>struct vec_attr{using core_type=T;static constexpr int rank=0;};
template<vectorial V>struct vec_attr<V>{using core_type=typename vec_attr<typename V::value_type>::core_type;static constexpr int rank=vec_attr<typename V::value_type>::rank+1;};
template<class V>istream&operator>>(istream&i,vector<V>&v){fe(v,e)i>>e;return i;}
template<class V>ostream&operator<<(ostream&o,const vector<V>&v){fe(v,e)o<<e<<schrodinger(&e!=&v.back(),vectorial<V>?newline:space);return o;}

template<class V>struct vec;
template<int rank,class T>struct tensor_helper{using type=vec<typename tensor_helper<rank-1,T>::type>;};
template<class T>struct tensor_helper<0,T>{using type=T;};
template<int rank,class T>using tensor=typename tensor_helper<rank,T>::type;

template<class V>struct vec:vector<V>{
  static constexpr int R=vec_attr<V>::rank+1;
  using C=vec_attr<V>::core_type;
  using vector<V>::vector;
  vec(const vector<V>&v){vector<V>::operator=(v);}

  template<class...A>requires(sizeof...(A)>=3)vec(const A&...a){resizes(pack_prefix_array<ll,R>(a...),pack_kth<R>(a...));}
  void resizes(const array<ll,R>&s,C x={}){*this=std::move(make(s,x));}
  template<ll i=0>static auto make(const array<ll,R>&s,C x){if constexpr(i==R-1)return vec<C>(s[i],x);else return tensor<R-i,C>(s[i],make<i+1>(s,x));}

  vec&operator^=(const vec&u){this->insert(this->end(),u.begin(),u.end());return*this;}
  vec&operator+=(const vec&u){vec&v=*this;assert(v.size()==u.size());fo(i,v.size())v[i]+=u[i];return v;}
  vec&operator-=(const vec&u){vec&v=*this;assert(v.size()==u.size());fo(i,v.size())v[i]-=u[i];return v;}
  base_operator(^,vec)
  base_operator(+,vec)
  base_operator(-,vec)

  vec&operator--(){fe(*this,e)--e;return*this;}

  ll size()const{return vector<V>::size();}

  vec zeta()const{vec v=*this;if constexpr(vectorial<V>)fe(v,e)e=e.zeta();fo(i,v.size()-1)v[i+1]+=v[i];return v;}
};
template<class...A>requires(sizeof...(A)>=2)vec(const A&...a)->vec<tensor<sizeof...(A)-2,pack_kth_t<sizeof...(A)-1,A...>>>;
vec(ll)->vec<ll>;

void lin(auto&...a){(cin>>...>>a);}
void pp(const auto&...a){ll n=sizeof...(a);((cout<<a<<schrodinger(--n>0,space)),...);cout<<newline;}

constexpr uint64_t kth_root_floor(uint64_t a,ll k){
  if (k==1)return a;
  auto within=[&](uint32_t x){uint64_t t=1;fo(k)if(__builtin_mul_overflow(t,x,&t))return false;return t<=a;};

  uint64_t r=0;
  of(i,bit_sizeof(uint32_t))if(within(r|(1u<<i)))r|=1u<<i;
  return r;
}
template<class T>constexpr T sqrt_floor(T x){return kth_root_floor(x,2);}

auto mod(auto a,auto m){return(a%=m)<0?a+m:a;}

template<class T>T square_sum(T n){return n*(n+1)/2*(n*2+1)/3;}

template<class T>T square_sum(const vec<ll>&a){
  T res=0;
  fe(a,e)res+=T(e)*e;
  return res;
}

template<class T>struct circle_vec:vec<T>{
  vec<T>su;
  circle_vec(ll n):vec<T>(n){}
  circle_vec(const initializer_list<T>&a={}){fe(a,e)this->eb(e);if constexpr(addable<T>)build_zeta();}
  circle_vec(const vec<T>&v){fe(v,e)this->eb(e);if constexpr(addable<T>)build_zeta();}
  void build_zeta()requires(addable<T>){su=this->zeta();}

  T&operator[](ll i){ll n=this->size();return vec<T>::operator[]((i%n+n)%n);}
  T operator[](ll i)const{ll n=this->size();return vec<T>::operator[]((i%n+n)%n);}
  T circle_sum(ll n)const requires(addable<T>){return n/this->size()*su.back()+su[(n-1)%this->size()];}
};

multiple_testcases
void solve(){
  LL(a,N);
  ll M=sqrt_floor(a*N);

  circle_vec<ml>v(a);
  fo(i,a)v[i]=mod(square(i+1)-1,a);
  v.build_zeta();
  pp(ml(N)*M-(square_sum<ml>(M)-M-v.circle_sum(M))/a);
}}
0