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

提出ソース

結果

問題	No.1861 Required Number
ユーザー	eQe
提出日時	2024-11-13 05:58:41
言語	C++23 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	11 ms / 2,500 ms
コード長	6,127 bytes
コンパイル時間	5,995 ms
コンパイル使用メモリ	320,052 KB
実行使用メモリ	6,820 KB
最終ジャッジ日時	2024-11-13 05:58:54
合計ジャッジ時間	12,620 ms
ジャッジサーバーID （参考情報）	judge4 / judge3

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 5,248 KB
testcase_01	AC	2 ms 5,248 KB
testcase_02	AC	2 ms 5,248 KB
testcase_03	AC	10 ms 6,784 KB
testcase_04	AC	10 ms 6,820 KB
testcase_05	AC	2 ms 5,248 KB
testcase_06	AC	2 ms 5,248 KB
testcase_07	AC	2 ms 5,248 KB
testcase_08	AC	2 ms 5,248 KB
testcase_09	AC	2 ms 5,248 KB
testcase_10	AC	2 ms 5,248 KB
testcase_11	AC	2 ms 5,248 KB
testcase_12	AC	2 ms 5,248 KB
testcase_13	AC	2 ms 5,248 KB
testcase_14	AC	2 ms 5,248 KB
testcase_15	AC	2 ms 5,248 KB
testcase_16	AC	2 ms 5,248 KB
testcase_17	AC	2 ms 5,248 KB
testcase_18	AC	2 ms 5,248 KB
testcase_19	AC	2 ms 5,248 KB
testcase_20	AC	2 ms 5,248 KB
testcase_21	AC	2 ms 5,248 KB
testcase_22	AC	2 ms 5,248 KB
testcase_23	AC	2 ms 5,248 KB
testcase_24	AC	5 ms 5,248 KB
testcase_25	AC	9 ms 6,400 KB
testcase_26	AC	5 ms 5,248 KB
testcase_27	AC	7 ms 5,248 KB
testcase_28	AC	7 ms 5,248 KB
testcase_29	AC	8 ms 5,248 KB
testcase_30	AC	7 ms 5,248 KB
testcase_31	AC	9 ms 6,272 KB
testcase_32	AC	7 ms 5,248 KB
testcase_33	AC	9 ms 5,632 KB
testcase_34	AC	9 ms 5,760 KB
testcase_35	AC	8 ms 6,144 KB
testcase_36	AC	7 ms 5,248 KB
testcase_37	AC	8 ms 5,248 KB
testcase_38	AC	8 ms 5,760 KB
testcase_39	AC	8 ms 5,248 KB
testcase_40	AC	11 ms 6,528 KB
testcase_41	AC	10 ms 6,272 KB
testcase_42	AC	9 ms 5,760 KB
testcase_43	AC	8 ms 5,248 KB
testcase_44	AC	2 ms 5,248 KB
04_evil_1.txt	MLE	-
04_evil_2.txt	MLE	-
04_evil_3.txt	MLE	-
04_evil_4.txt	MLE	-

権限があれば一括ダウンロードができます

ソースコード

raw source code

#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>dp(N+1,bitvec(K+1));
  dp[0][0]=1; // dp[i][j]:i個目まで使ってjを作れるか．
  fo(i,1,N+1)dp[i]=dp[i-1]<<a[i]|dp[i-1];

  if(dp[N][K]==0)done(-1);
  vec<bitvec>ep(N+2,bitvec(K+1)); // ep[i][K-j]:i個目まで使ってjを作れるか．後の処理のためK-jビット目にjを作れるかの判定を入れる
  ep[N+1][K]=1;
  of(i,N+1,1)ep[i]=ep[i+1]>>a[i]|ep[i+1];

  ll ans=0;
  fo(i,1,N+1)if((dp[i-1]&ep[i+1]).count()==0)ans++; // dp[i-1][j]&ep[i-1][j]が真ならj+(K-j)=KよりjとK-jでKを作れる．したがって(dp[i-1]&ep[i+1]).count()==0ならKを作れない．
  pp(ans);
}}

yukicoder

結果

テストケース

ソースコード