#1026391 (C++23) No.1861 Required Number

• 問題: No.1861 Required Number
• ユーザー: eQe
• 提出日時: 2024-11-13 06:04:11
• 言語: C++23 (gcc 13.3.0 + boost 1.87.0)
• 結果: AC
• 実行時間: 8 ms / 2,500 ms
• コード長: 5,757 bytes
• コンパイル時間: 5,754 ms
• コンパイル使用メモリ: 320,992 KB
• 実行使用メモリ: 5,248 KB
• 最終ジャッジ日時: 2024-11-13 06:04:24
• 合計ジャッジ時間: 12,542 ms
• ジャッジサーバーID （参考情報）: judge3 / judge4

ファイルパターン	結果
sample	AC * 3
other	AC * 42 MLE * 4

ソースコード

#include<bits/stdc++.h>
#include<atcoder/all>
namespace my{
using namespace std;
#define done(...) return pp(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;lin(__VA_ARGS__)
#define VRD(T,n,...) vec<T>__VA_ARGS__;setsize({n},__VA_ARGS__);lin(__VA_ARGS__)
#define FO(n) for(ll ij=n;ij--;)
#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 single_testcase void solve();}int main(){my::io();my::solve();}namespace my{
void io(){cin.tie(nullptr)->sync_with_stdio(0);cout<<fixed<<setprecision(15);}
using ll=long long;
template<class...A>auto range(bool s,A...a){array<ll,3>r{0,0,1};ll I=0;((r[I++]=a),...);if(!s&&I==1)swap(r[0],r[1]);r[0]-=s;return r;}
constexpr char nl=10;
constexpr char sp=32;
constexpr ll log2_floor(auto x){ll r=0;while(x>1)x>>=1,++r;return r;}
auto ceil(auto x,auto y){if(y<0)x=-x,y=-y;return x<=0?x/y:(x-1)/y+1;}

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 d=0;};
template<vectorial V>struct vec_attr<V>{using core_type=typename vec_attr<typename V::value_type>::core_type;static constexpr int d=vec_attr<typename V::value_type>::d+1;};
template<class T>using core_t=vec_attr<T>::core_type;
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<<string(&e!=&v.back(),vectorial<V>?nl:sp);return o;}

template<class V>struct vec:vector<V>{
  using vector<V>::vector;
  vec(const vector<V>&v){vector<V>::operator=(v);}

  vec&operator^=(const vec&u){this->insert(this->end(),u.begin(),u.end());return*this;}
  vec operator^(const vec&u)const{return vec{*this}^=u;}
  vec&operator++(){fe(*this,e)++e;return*this;}
  vec&operator--(){fe(*this,e)--e;return*this;}

  void emplace_front(const V&x={}){this->emplace(this->begin(),x);}
};
template<class T=ll,size_t n,size_t i=0>auto make_vec(const ll(&s)[n],T x={}){if constexpr(n==i+1)return vec<T>(s[i],x);else{auto X=make_vec<T,n,i+1>(s,x);return vec<decltype(X)>(s[i],X);}}
template<ll n,class...A>void setsize(const ll(&l)[n],A&...a){((a= make_vec(l,core_t<A>())),...);}

void lin(auto&...a){(cin>>...>>a);}
template<char c=sp>void pp(const auto&...a){ll n=sizeof...(a);((cout<<a<<string(--n>0,c)),...);cout<<nl;}

struct bitvec{
  using u64=uint64_t;
  static constexpr size_t block_size=sizeof(u64)*CHAR_BIT;
  static constexpr size_t block_size_exponent=log2_floor(block_size);
  static constexpr size_t block_index(size_t i){return i>>block_size_exponent;}
  static constexpr size_t bit_index(size_t i){return i&(block_size-1);}

  size_t n;
  vec<u64>bits;
  size_t size()const{return n;}

  bitvec(size_t n):n(n),bits(ceil(n,block_size)){}
  bitvec(const string&s):n(s.size()),bits(ceil(s.size(),block_size)){fo(i,n)bits[block_index(i)]|=u64(s[i]-'0')<<bit_index(i);}
  bitvec&operator=(u64 x){vec<u64>{x}.swap(bits);return*this;}

  struct proxy{
    decltype(bits)&bits_proxy;
    size_t I;
    proxy(decltype(bits)&bits_proxy,size_t I):bits_proxy(bits_proxy),I(I){}
    auto&operator=(bool f){
      bits_proxy[block_index(I)]&=~(u64(1)<<bit_index(I));
      bits_proxy[block_index(I)]|=u64(f)<<bit_index(I);
      return*this;
    }
    template<integral X>auto&operator=(X x){return this->operator=(static_cast<bool>(x&1));}
    auto&operator=(const proxy&p){return this->operator=(static_cast<bool>(p));}
    operator bool()const{return bits_proxy[block_index(I)]>>bit_index(I)&1;}
  };

  decltype(auto)operator[](size_t i){return proxy{bits,i};}
  decltype(auto)operator[](size_t i)const{return bits[block_index(i)]>>bit_index(i)&1;}

  auto&operator&=(const bitvec&b){fo(i,bits.size())bits[i]&=b.bits[i];return*this;}
  auto&operator|=(const bitvec&b){fo(i,bits.size())bits[i]|=b.bits[i];return*this;}
  auto&operator^=(const bitvec&b){fo(i,bits.size())bits[i]^=b.bits[i];return*this;}

  auto&operator<<=(ll k){
    ll q=k/block_size,r=k-q*block_size;
    if(r==0){
      of(i,bits.size(),q)bits[i]=bits[i-q];
      fo(i,q)bits[i]=0;
    }else{
      of(i,bits.size(),q)bits[i]=(bits[i-q]<<r)|(i-q-1>=0?bits[i-q-1]>>(block_size-r):0);
      fo(i,q)bits[i]=0;
    }
    return*this;
  }
  auto&operator>>=(ll k){
    ll q=k/block_size,r=k-q*block_size;
    if(r==0){
      fo(i,bits.size()-q)bits[i]=bits[i+q];
      fo(i,bits.size()-q,bits.size())bits[i]=0;
    }else{
      fo(i,bits.size()-q)bits[i]=(bits[i+q]>>r)|(i+q+1<bits.size()?bits[i+q+1]<<(block_size-r):0);
      fo(i,bits.size()-q,bits.size())bits[i]=0;
    }
    return*this;
  }

  auto operator&(const bitvec&b)const{return bitvec{*this}&=b;}
  auto operator|(const bitvec&b)const{return bitvec{*this}|=b;}
  auto operator^(const bitvec&b)const{return bitvec{*this}^=b;}
  auto operator<<(ll k)const{return bitvec{*this}<<=k;}
  auto operator>>(ll k)const{return bitvec{*this}>>=k;}

  ll count()const{ll r=0;fe(bits,e)r+=std::popcount(e);return r;}

  string to_string()const{string s{};fo(i,size())s+=(*this)[i]+'0';return s;}
  friend istream&operator>>(istream&i,bitvec&b){string s;i>>s;b=s;return i;}
  friend ostream&operator<<(ostream&o,const bitvec&b){return o<<b.to_string();}
};

single_testcase
void solve(){
  LL(N,K);
  VRD(int,N,a);
  a.emplace_front();

  vec<bitvec>pd(N+2,bitvec(K+1));
  pd[N+1][K]=1;
  of(i,N+1,1)pd[i]=pd[i+1]>>a[i]|pd[i+1];

  if(pd[1][0]==0)done(-1);

  bitvec dp(K+1);
  dp[0]=1;
  ll ans=0;
  fo(i,1,N+1){
    if((dp&pd[i+1]).count()==0)ans++;
    dp|=dp<<a[i];
  }
  pp(ans);
}}