結果
| 問題 | No.2075 GCD Subsequence |
| ユーザー |
 eQe
|
| 提出日時 | 2025-05-04 06:53:36 |
| 言語 | C++23 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
AC
|
| 実行時間 | 417 ms / 4,000 ms |
| コード長 | 11,946 bytes |
| コンパイル時間 | 7,023 ms |
| コンパイル使用メモリ | 333,232 KB |
| 実行使用メモリ | 33,740 KB |
| 最終ジャッジ日時 | 2025-05-04 06:53:53 |
| 合計ジャッジ時間 | 16,102 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge3 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 28 |
ソースコード
#include<bits/stdc++.h>
#include<atcoder/all>
using namespace std;
namespace my{
#define eb emplace_back
#define LL(...) ll __VA_ARGS__;lin(__VA_ARGS__)
#define RDVL(T,n,...) vec<T>__VA_ARGS__;resizes({n},__VA_ARGS__);lin(__VA_ARGS__)
#define VL(n,...) RDVL(ll,n,__VA_ARGS__)
#define jo(a,b) a##b
#define FO_IMPL(n,c) for(ll jo(_i,c)=n;jo(_i,c)-->0;)
#define FO(n) FO_IMPL(n,__COUNTER__)
#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,e,...) for(auto&&__VA_OPT__([)e __VA_OPT__(,__VA_ARGS__]):a)
#define maybe(p,c) (p?c:remove_cvref_t<decltype(c)>{})
#define base_operator(op,type) auto operator op(const type&v)const{auto copy=*this;return copy op##=v;}
#define entry void solve();void solve2();}int main(){my::io();my::solve();}namespace my{
#define use_ml998244353 using ml=atcoder::modint998244353;
auto&operator>>(istream&i,atcoder::modint998244353&x){int t;i>>t;x=t;return i;}
auto&operator<<(ostream&o,const atcoder::modint998244353&x){return o<<(int)x.val();}
void io(){cin.tie(nullptr)->sync_with_stdio(0);cout<<fixed<<setprecision(15);}
using ll=long long;
using ull=unsigned long long;
using i64=int64_t;
using ui64=uint64_t;
using ui128=__uint128_t;
using i8=int8_t;
ostream&operator<<(ostream&o,const i8&x){return o<<(int)x;}
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};}
const string newline{char(10)};
const string space{char(32)};
constexpr auto abs(auto x){return x<0?-x:x;}
constexpr auto pow(auto x,auto n,auto e){assert(n>=0);decltype(x)r=e;for(;n;x*=x,n>>=1)if(n&1)r*=x;return r;}
constexpr auto pow(auto x,auto n){return pow(x,n,1);}
auto max(auto...a){return max(initializer_list<common_type_t<decltype(a)...>>{a...});}
template<class T,class U>common_type_t<T,U>gcd(T a,U b){return b?gcd(b,a%b):abs(a);}
auto gcd(auto...a){common_type_t<decltype(a)...>r=0;((r=gcd(r,a)),...);return r;}
ll rand(){static ll x=495;x^=x<<7;x^=x>>9;return x;}
ll rand(ll l,ll r=0){if(l>r)swap(l,r);return rand()%(r-l)+l;}
template<class A,class B>struct pair{
A a;B b;
pair()=default;
pair(A a,B b):a(a),b(b){}
pair(const std::pair<A,B>&p):a(p.first),b(p.second){}
auto operator<=>(const pair&)const=default;
pair operator+(const pair&p)const{return{a+p.a,b+p.b};}
friend istream&operator>>(istream&i,pair&p){return i>>p.a>>p.b;}
friend ostream&operator<<(ostream&o,const pair&p){return o<<p.a<<space<<p.b;}
};
template<class F=less<>>auto&sort(auto&a,F f={}){ranges::sort(a,f);return a;}
template<class...A>using pack_back_t=tuple_element_t<sizeof...(A)-1,tuple<A...>>;
template<class V>concept vectorial=is_base_of_v<vector<typename remove_cvref_t<V>::value_type>,remove_cvref_t<V>>;
template<class V>constexpr int rank(){if constexpr(vectorial<V>)return rank<typename V::value_type>()+1;else return 0;}
template<class T>struct core_t_helper{using core_t=T;};
template<vectorial V>struct core_t_helper<V>{using core_t=typename core_t_helper<typename V::value_type>::core_t;};
template<class T>using core_t=core_t_helper<T>::core_t;
template<class V>istream&operator>>(istream&i,vector<V>&v){fe(v,e)i>>e;return i;}
template<class T>ostream&operator<<(ostream&o,const vector<T>&v){ll n=v.size();fo(i,n)o<<v[i]<<maybe(i<n-1,space);return o;}
template<vectorial V>ostream&operator<<(ostream&o,const vector<V>&v){ll n=v.size();fo(i,n)o<<v[i]<<maybe(i<n-1,newline);return o;}
template<class V>struct vec;
template<int rank,class T>struct hvec_helper{using type=vec<typename hvec_helper<rank-1,T>::type>;};
template<class T>struct hvec_helper<0,T>{using type=T;};
template<int rank,class T>using hvec=typename hvec_helper<rank,T>::type;
template<class V>struct vec:vector<V>{
static constexpr int R=rank<vec<V>>();
using C=core_t<V>;
using vector<V>::vector;
vec(const vector<V>&v){vector<V>::operator=(v);}
vec(const auto&...a)requires(sizeof...(a)>=3){resizes(a...);}
void resizes(const auto&...a){*this=make(a...);}
static auto make(ll n,const auto&...a){
if constexpr(sizeof...(a)==1)return vec<C>(n,array{a...}[0]);
else return vec<decltype(make(a...))>(n,make(a...));
}
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;}
vec&operator+=(const C&c){fe(*this,e)e+=c;return*this;}
vec&operator*=(const C&c){fe(*this,e)e*=c;return*this;}
base_operator(^,vec)
base_operator(+,vec)
base_operator(-,vec)
base_operator(+,C);
base_operator(*,C);
vec&operator++(){fe(*this,e)++e;return*this;}
vec&operator--(){fe(*this,e)--e;return*this;}
ll size()const{return vector<V>::size();}
auto&emplace_back(auto&&...a){vector<V>::emplace_back(std::forward<decltype(a)>(a)...);return*this;}
auto scan(const auto&f)const{
pair<C,bool>r{};
fe(*this,e)if constexpr(!vectorial<V>)r.b?f(r.a,e),r:r={e,1};else if(auto s=e.scan(f);s.b)r.b?f(r.a,s.a),r:r=s;
return r;
}
auto sum()const{return scan([](auto&a,const auto&b){a+=b;}).a;}
auto max()const{return scan([](auto&a,auto b){if(a<b)a=b;}).a;}
vec mobius()const{vec v=*this;if constexpr(vectorial<V>)fe(v,e)e=e.mobius();of(i,v.size()-1)v[i+1]-=v[i];return v;}
template<class F=less<>>auto sort(F f={})const{vec v=*this;ranges::sort(v,f);return v;}
auto transform(const auto&f)const{
hvec<R,decltype(f(C()))>res(size());
if constexpr(vectorial<V>)fo(i,size())res[i]=(*this)[i].transform(f);
else std::transform(this->begin(),this->end(),res.begin(),f);
return res;
}
auto rle()const{vec<pair<V,ll>>r;fe(*this,e)if(r.size()&&e==r.back().a)++r.back().b;else r.eb(e,1);return r;}
auto rce()const{return sort().rle();}
auto as()const{return transform([](const auto&e){return e.a;});}
};
template<class...A>requires(sizeof...(A)>=2)vec(const A&...a)->vec<hvec<sizeof...(A)-2,pack_back_t<A...>>>;
vec(ll)->vec<ll>;
template<class...A>void resizes(const array<ll,common_type_t<A...>::R+1>&s,A&...a){(apply([&](const auto&...b){a.resizes(b...); },s),...);}
auto pack_vec(const auto&...a){return vec<common_type_t<decltype(a)...>>{a...};}
void lin(auto&...a){(cin>>...>>a);}
void pp(const auto&...a){ll n=sizeof...(a);((cout<<a<<maybe(--n>0,space)),...);cout<<newline;}
template<int tag=-1>struct montgomery64{
using modular=montgomery64;
static inline ui64 N=998244353;
static inline ui64 N_inv=996491785301655553ull;
static inline ui64 R2=299560064;
static int set_mod(ui64 N){
if(modular::N==N)return 0;
assert(N<(1ull<<63));
assert(N&1);
modular::N=N;
R2=-ui128(N)%N;
N_inv=N;
fo(5)N_inv*=2-N*N_inv;
assert(N*N_inv==1);
return 0;
}
ui64 a;
montgomery64(const i64&a=0):a(reduce((ui128)(a%(i64)N+N)*R2)){}
static ui64 reduce(const ui128&T){ui128 r=(T+ui128(ui64(T)*-N_inv)*N)>>64;return r>=N?r-N:r;}
auto&operator+=(const modular&b){if((a+=b.a)>=N)a-=N;return*this;}
auto&operator-=(const modular&b){if(i64(a-=b.a)<0)a+=N;return*this;}
auto&operator*=(const modular&b){a=reduce(ui128(a)*b.a);return*this;}
auto&operator/=(const modular&b){*this*=b.inv();return*this;}
friend auto operator+(const modular&a,const modular&b){return modular{a}+=b;}
friend auto operator-(const modular&a,const modular&b){return modular{a}-=b;}
friend auto operator*(const modular&a,const modular&b){return modular{a}*=b;}
friend auto operator/(const modular&a,const modular&b){return modular{a}/=b;}
friend bool operator==(const modular&a,const modular&b){return a.a==b.a;}
auto operator-()const{return modular{}-modular{*this};}
modular pow(ui128 n)const{return my::pow(*this,n);}
modular inv()const{ui64 a=val(),b=N,u=1,v=0;assert(gcd(a,b)==1);while(b)swap(u-=a/b*v,v),swap(a-=a/b*b,b);return u;}
ui64 val()const{return reduce(a);}
friend istream&operator>>(istream&i,montgomery64<tag>&b){ll t;i>>t;b=t;return i;}
friend ostream&operator<<(ostream&o,const montgomery64<tag>&b){return o<<b.val();}
};
template<class T>T one(T n){return n>0;}
void sort(auto&...a){auto v=pack_vec(a...).sort();ll i=0;((a=v[i++]),...);}
bool miller_rabin(ll n,vec<ll>as){
ll d=n-1;
while(~d&1)d>>=1;
using modular=montgomery64<1>;
modular::set_mod(n);
modular one=1,minus_one=n-1;
fe(as,a){
if(a%n==0)continue;
ll t=d;
modular y=modular(a).pow(t);
while(t!=n-1&&y!=one&&y!=minus_one)y*=y,t<<=1;
if(y!=minus_one&&~t&1)return 0;
}
return 1;
}
bool is_prime(ll n){
if(~n&1)return n==2;
if(n<=1)return 0;
if(n<4759123141LL)return miller_rabin(n,{2,7,61});
return miller_rabin(n,{2,325,9375,28178,450775,9780504,1795265022});
}
ll pollard_rho(ll n){
if(~n&1)return 2;
if(is_prime(n))return n;
using modular=montgomery64<2>;
modular::set_mod(n);
modular R,one=1;
auto f=[&](const modular&x){return x*x+R;};
while(1){
modular x,y,ys,q=one;
R=rand(2,n),y=rand(2,n);
ll g=1;
constexpr ll m=128;
for(ll r=1;g==1;r<<=1){
x=y;
fo(r)y=f(y);
for(ll k=0;g==1&&k<r;k+=m){
ys=y;
for(ll i=0;i<m&&i<r-k;++i)q*=x-(y=f(y));
g=std::gcd(q.val(),n);
}
}
if(g==n)do g=std::gcd((x-(ys=f(ys))).val(),n);while(g==1);
if(g!=n)return g;
}
}
auto factorize(ll n){
assert(n>0);
vec<ll>res;
auto f=[&](auto&f,ll m){
if(m==1)return;
auto d=pollard_rho(m);
if(d==m)res.eb(d);
else f(f,d),f(f,m/d);
};
f(f,n);
return res.rce();
}
auto radical(ll n){ll res=1;fe(factorize(n),p,q)res*=p;return res;}
auto divisors(const vec<pair<ll,ll>>&prime_exponent){
vec<ll>r{1};
for(auto[p,e]:prime_exponent){
ll sz=size(r);
for(ll t=p;e;--e,t*=p)fo(i,sz)r.eb(r[i]*t);
}
return sort(r);
}
auto divisors(ll n){return divisors(factorize(n));}
ll mobius_prime_pow(ll,i8 k,ll){return-(k==1);}
ll mobius(ll n){ll r=1;fe(factorize(n),p,q)r*=mobius_prime_pow(p,q,pow(p,q));return r;}
template<class T>struct linear_sieve{
T n;
vec<int>lpf;
vec<i8>lpf_ord;
vec<int>lpf_pow;
vec<int>lpf_pow_except;
vec<int>primes;
linear_sieve(T n):n(n),lpf(n+1,-1),lpf_ord(n+1),lpf_pow(n+1),lpf_pow_except(n+1){
lpf[1]=lpf_ord[1]=lpf_pow[1]=lpf_pow_except[1]=1;
fo(i,2,n+1){
if(lpf[i]==-1)primes.eb(lpf[i]=i);
fe(primes,p){
if(p*i>n||p>lpf[i])break;
lpf[p*i]=p;
}
int j=i/lpf[i];
lpf_ord[i]=lpf_ord[j]*(lpf[i]==lpf[j])+1;
lpf_pow[i]=((lpf_pow[j]-1)*(lpf[i]==lpf[j])+1)*lpf[i];
lpf_pow_except[i]=i/lpf_pow[i];
}
}
auto multiplicative_function_enumerate(const auto&f)const{
vec<T>r(n+1);
r[1]=1;
fo(i,2,n+1)r[i]=f(lpf[i],lpf_ord[i],lpf_pow[i])*r[lpf_pow_except[i]];
return r;
}
auto mobius_enumerate()const{return multiplicative_function_enumerate(mobius_prime_pow);}
auto factorize(T x)const{
assert(x<=n);
vec<pair<T,T>>res;
for(;x>1;x=lpf_pow_except[x])res.eb(lpf[x],lpf_ord[x]);
return res;
}
auto radical(T x)const{
assert(x<=n);
T res=1;
for(;x>1;x=lpf_pow_except[x])res*=lpf[x];
return res;
}
auto divisors(ll x)const{
assert(x<=n);
vec<T>res{1};
fe(factorize(x),p,e){
ll m=res.size();
for(T t=p;e;--e,t*=p)fo(i,m)res.eb(res[i]*t);
}
return sort(res);
}
};
entry
void solve(){
LL(N);
VL(N,a);
ll M=a.max()+1;
linear_sieve<ll>ls(M);
auto mobius=ls.mobius_enumerate();
use_ml998244353
ml su=0; // dp.sum()
vec<ml>dp(M);
vec<ml>g(M);
fe(a,e){
e=ls.radical(e);
ml f1=0;
fe(ls.divisors(e),x)f1+=mobius[x]*g[x];
ml diff=1+su-f1;
dp[e]+=diff;
su+=diff;
fe(ls.divisors(e),x)g[x]+=diff;
}
pp(su);
}}