#1136785 (C++23) No.3392 Count 23578 Sequence

提出ソース
結果

問題	No.3392 Count 23578 Sequence
コンテスト
ユーザー	Taiki0715
提出日時	2025-11-28 21:49:30
言語	C++23 (gcc 13.3.0 + boost 1.87.0)
結果	AC
実行時間	772 ms / 2,000 ms
コード長	58,014 bytes
コンパイル時間	7,752 ms
コンパイル使用メモリ	427,148 KB
実行使用メモリ	30,760 KB
最終ジャッジ日時	2025-11-28 23:28:26
合計ジャッジ時間	42,114 ms
ジャッジサーバーID （参考情報）	judge2 / judge3
このコードへのチャレンジ
（要ログイン）
ファイルパターン	結果
sample	AC * 3
other	AC * 48
権限があれば一括ダウンロードができます
ソースコード

raw source code
#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();
  }
}
#include<type_traits>
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;
#ifdef LOCAL
#include<primality_test_table.hpp>
#else
namespace isprime_impl{
const std::array<uint16_t,16384>base_table1=base64_decode<uint16_t,16384,16>("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");
}
#endif
namespace isprime_impl{
using u16=uint16_t;
using u32=uint32_t;
using u64=uint64_t;
using u128=__uint128_t;
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;
}
struct RollingHashBase{
  static mint61 base;
  static std::vector<mint61>power;
  static void resize(int n){
    if(power.size()<=n){
      int pre=power.size();
      power.resize(n+1);
      for(int i=pre;i<=n;i++)power[i]=power[i-1]*base;
    }
  }
  template<typename LHS,typename RHS>
  static int lcp(const LHS&lhs,int l1,int r1,const RHS&rhs,int l2,int r2){
    int ok=0,ng=std::min(r1-l1,r2-l2)+1;
    while(ng-ok>1){
      int mid=(ok+ng)/2;
      (lhs.get(l1,l1+mid)==rhs.get(l2,l2+mid)?ok:ng)=mid;
    }
    return ok;
  }
};
std::vector<mint61> RollingHashBase::power{1};
mint61 RollingHashBase::base=primitive_root(mint61::mod());
struct RollingHash{
private:
  std::vector<mint61>dat;
public:
  RollingHash(){}
  template<typename T>
  RollingHash(const T&s){
    RollingHashBase::resize(s.size());
    dat.resize(s.size()+1);
    dat[0]=0;
    for(int i=1;i<dat.size();i++)dat[i]=dat[i-1]*RollingHashBase::base+s[i-1];
  }
  inline mint61 get(int l,int r)const{return dat[r]-dat[l]*RollingHashBase::power[r-l];}
};
void SOLVE(){
  int n;
  cin>>n;
  vector<int>a(n);
  cin>>a;
  rep(i,n-1)a[i]=a[i+1]-a[i];
  a.pop_back();
  ll ans=n;
  RollingHash rh(a);
  reverse(all(a));
  RollingHash rhrev(a);
  n--;
  rep(i,n){
    int ok=0,ng=min(i,n-i-1)+1;
    while(ng-ok>1){
      int mid=(ok+ng)/2;
      if(rh.get(i-mid,i)==rhrev.get(n-(i+1+mid),n-(i+1)))ok=mid;
      else ng=mid;
    }
    ans+=ok+1;
  }
  rep(i,1,n){
    int ok=0,ng=min(i,n-i)+1;
    while(ng-ok>1){
      int mid=(ok+ng)/2;
      if(rh.get(i-mid,i)==rhrev.get(n-(i+mid),n-(i)))ok=mid;
      else ng=mid;
    }
    ans+=ok;
  }
  cout<<ans<<endl;
}
yukicoder

結果

ソースコード
