結果
| 問題 |
No.2319 Friends+
|
| コンテスト | |
| ユーザー |
 eQe
|
| 提出日時 | 2025-03-18 05:20:23 |
| 言語 | C++23 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
AC
|
| 実行時間 | 640 ms / 3,000 ms |
| コード長 | 8,351 bytes |
| コンパイル時間 | 5,908 ms |
| コンパイル使用メモリ | 334,272 KB |
| 実行使用メモリ | 105,984 KB |
| 最終ジャッジ日時 | 2025-03-18 05:20:56 |
| 合計ジャッジ時間 | 32,504 ms |
|
ジャッジサーバーID （参考情報） |
judge4 / judge5 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 2 |
| other | AC * 45 |
ソースコード
#include<bits/stdc++.h>
#include<atcoder/all>
using namespace std;
namespace my{
#define LL(...) ll __VA_ARGS__;lin(__VA_ARGS__)
#define RDVL(T,n,...) vec<T>__VA_ARGS__;resizes({n},__VA_ARGS__);lin(__VA_ARGS__)
#define RDVV(T,n,...) vec<T>__VA_ARGS__;resizes({n},__VA_ARGS__);vin(__VA_ARGS__)
#define VL(n,...) RDVL(ll,n,__VA_ARGS__)
#define VV(n,...) RDVV(ll,n,__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,e,...) for(auto&&__VA_OPT__([)e __VA_OPT__(,__VA_ARGS__]):a)
#define bit_sizeof(T) ll(sizeof(T)*CHAR_BIT)
#define schrodinger(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 single_testcase void solve();}int main(){my::io();my::solve();}namespace my{
void io(){cerr<<endl;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};}
const string newline{char(10)};
const string space{char(32)};
constexpr auto Yes(bool p=1){return p?"Yes":"No";}
constexpr auto No(){return"No";}
constexpr ll size2(auto x){x|=1;ll r=0;while(x>0)x>>=1,++r;return r;}
constexpr ll log2_floor(auto x){return size2(x)-1;}
auto ceil(auto x,auto y){if(y<0)x=-x,y=-y;return x<=0?x/y:(x-1)/y+1;}
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...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 V>ostream&operator<<(ostream&o,const vector<V>&v){ll n=v.size();fo(i,n)o<<v[i]<<schrodinger(i<n-1,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=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;}
base_operator(^,vec)
base_operator(+,vec)
base_operator(-,vec)
vec&operator++(){fe(*this,e)++e;return*this;}
vec&operator--(){fe(*this,e)--e;return*this;}
ll size()const{return vector<V>::size();}
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 count(C x)const{return scan([&x](auto&a,const auto&b){a+=(b==x);}).a;}
};
template<class...A>requires(sizeof...(A)>=2)vec(const A&...a)->vec<tensor<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),...);}
void lin(auto&...a){(cin>>...>>a);}
void vin(auto&...a){fo(i,(a.size()&...))(cin>>...>>a[i]);}
void pp(const auto&...a){ll n=sizeof...(a);((cout<<a<<schrodinger(--n>0,space)),...);cout<<newline;}
void dec(auto&...a){((--a),...);}
struct bitvec{
using u64=uint64_t;
static constexpr size_t block_size=bit_sizeof(u64);
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<<=(int k){
int 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+1)bits[i]=bits[i-q]<<r|bits[i-q-1]>>(block_size-r);
bits[q]=(bits[0]<<r);
fo(i,q)bits[i]=0;
}
return*this;
}
auto&operator>>=(int k){
int 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-1)bits[i]=bits[i+q]>>r|bits[i+q+1]<<(block_size-r);
bits[bits.size()-q-1]=bits[bits.size()-1]>>r;
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<<(int k)const{return bitvec{*this}<<=k;}
auto operator>>(int 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,M);
VL(N,pos);--pos;
VV(M,a,b);dec(a,b);
vec<bitvec>g(N,bitvec(N)); // g[u][v]:u,vがフレンドかどうかの真偽値．
fo(i,M){
g[a[i]][b[i]]=1;
g[b[i]][a[i]]=1;
}
vec<bitvec>belong(N,bitvec(N)); // belong[i][u]:ワールドiにuが属するかの真偽値．
fo(u,N)belong[pos[u]][u]=1;
LL(Q);
fo(Q){
LL(u,v);dec(u,v);
if(pos[u]==pos[v]){
pp(No());
continue;
}
if(!(g[u]&belong[pos[v]]).count()){
pp(No());
continue;
}
belong[pos[u]][u]=0;
pos[u]=pos[v];
belong[pos[u]][u]=1;
pp(Yes());
}
}}