結果
| 問題 | No.1328 alligachi-problem |
| ユーザー |
 penguinman
|
| 提出日時 | 2020-12-25 00:47:41 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 20,729 bytes |
| コンパイル時間 | 3,049 ms |
| コンパイル使用メモリ | 255,404 KB |
| 実行使用メモリ | 16,324 KB |
| 最終ジャッジ日時 | 2024-09-21 17:15:35 |
| 合計ジャッジ時間 | 8,440 ms |
|
ジャッジサーバーID （参考情報） |
judge5 / judge1 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | WA | - |
| testcase_01 | AC | 2 ms
5,376 KB |
| testcase_02 | WA | - |
| testcase_03 | WA | - |
| testcase_04 | WA | - |
| testcase_05 | WA | - |
| testcase_06 | AC | 3 ms
5,376 KB |
| testcase_07 | WA | - |
| testcase_08 | AC | 2 ms
5,376 KB |
| testcase_09 | WA | - |
| testcase_10 | AC | 56 ms
12,872 KB |
| testcase_11 | WA | - |
| testcase_12 | WA | - |
| testcase_13 | WA | - |
| testcase_14 | WA | - |
| testcase_15 | AC | 56 ms
12,744 KB |
| testcase_16 | WA | - |
| testcase_17 | WA | - |
| testcase_18 | WA | - |
| testcase_19 | WA | - |
| testcase_20 | WA | - |
| testcase_21 | WA | - |
| testcase_22 | WA | - |
| testcase_23 | AC | 57 ms
12,744 KB |
| testcase_24 | AC | 62 ms
16,324 KB |
| testcase_25 | AC | 65 ms
16,196 KB |
| testcase_26 | WA | - |
| testcase_27 | WA | - |
ソースコード
#include<bits/stdc++.h>
//using namespace std;
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define rep(i,j,n) for(int i=(int)(j);i<(int)(n);i++)
#define REP(i,j,n) for(int i=(int)(j);i<=(int)(n);i++)
#define per(i,j,n) for(int i=(int)(j);(int)(n)<=i;i--)
#define ALL(a) (a).begin(),(a).end()
#define disup(A,key) distance(A.begin(),upper_bound(ALL(A),(ll)(key)))
#define dislow(A,key) distance(A.begin(),lower_bound(ALL(A),(ll)(key)))
#define pb emplace_back
#define mp std::make_pair
//#define endl "\n"
//
using std::endl;
using std::cin;
using std::cout;
using ll=long long;
using std::vector;
using std::string;
using std::upper_bound;
using std::lower_bound;
using vi=vector<ll>;
using vii=vector<vi>;
using pii=std::pair<ll,ll>;
//
constexpr ll MOD=1e9+7; constexpr ll root=0; constexpr ll coef=0;
//constexpr ll MOD=998244353; constexpr ll root=3; constexpr ll coef=119;
//constexpr ll MOD=10000000; constexpr ll root=0; constexpr ll coef=0;
//constexpr ll MOD=1e4; constexpr ll root=0; constexpr ll coef=0;
//constexpr ll MOD=1e5; constexpr ll root=0; constexpr ll coef=0;
constexpr ll MAX=3e6;
constexpr ll inf=(1ll<<60);
template<class T>
class prique :public std::priority_queue<T, std::vector<T>, std::greater<T>> {};
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
template<typename T>
struct Segment_tree{
ll N;
T mem;
vector<T> node;
Segment_tree(vector<T> &X,T m):mem(m){
ll sz=X.size();
N=1;
while(N<sz) N*=2;
node.resize(2*N-1,mem);
rep(i,0,sz) node[N-1+i]=X[i];
per(i,N-2,0){
node[i]=Compare(node[i*2+1],node[i*2+2]);
}
}
T Compare(T &A,T &B){
return std::min(A,B);
}
void update(ll X,T val){
X+=N-1;
node[X]=val;
while(X>0){
X=(X-1)/2;
node[X]=Compare(node[X*2+1],node[X*2+2]);
}
}
T Query(ll a,ll b,ll now=0,ll l=0,ll r=-1){ //[a,b),[l,r)
if(r<0) r=N;
if(r<=a||b<=l) return mem;
if(a<=l&&r<=b) return node[now];
auto vl=Query(a,b,now*2+1,l,(l+r)/2),vr=Query(a,b,now*2+2,(l+r)/2,r);
return Compare(vl,vr);
}
ll lower_bound(ll left,ll right,T val,ll now=0,ll l=0,ll r=-1){
if(r<0) r=N;
if(node[now]<val||l>=right||left>=r) return r;
else if(now>=N-1) return l;
ll vl=lower_bound(left,right,val,now*2+1,l,(l+r)/2);
if(vl==(l+r)/2) return lower_bound(left,right,val,now*2+2,(l+r)/2,r);
return vl;
}
};
template<typename T>
struct lazy_Segment_tree{
int N;
vector<T> node,lazy;
T INF;
vector<bool> flag;
lazy_Segment_tree(vector<T> X,T Y):INF(Y){
N=1;
while(X.size()>N) N*=2;
node.resize(2*N-1,Y);
lazy.resize(2*N-1);
flag.resize(2*N-1);
rep(i,0,X.size()) node[i+N-1]=X[i];
per(i,N-2,0) node[i]=compare(node[i*2+1],node[i*2+2]);
}
T compare(T X,T Y){
return std::max(X,Y);
}
T plus(T X,int l,int r){
return X;
}
void eval(int now,int l,int r){
if(flag[now]){
if(r-l>1){
flag[now*2+1]=flag[now*2+2]=1;
lazy[now*2+1]=lazy[now*2+2]=lazy[now];
}
node[now]=lazy[now];
flag[now]=0;
}
}
void update(int a,int b,T add,int now=0,int l=0,int r=-1){
if(r<0) r=N;
eval(now,l,r);
if(b<=l||r<=a) return;
if(a<=l&&r<=b){
lazy[now]=add;
flag[now]=1;
eval(now,l,r);
}
else{
update(a,b,add,now*2+1,l,(r+l)/2);
update(a,b,add,now*2+2,(r+l)/2,r);
node[now]=compare(node[now*2+1],node[now*2+2]);
}
}
T Query(int a,int b,int now=0,int l=0,int r=-1){
if(r<0) r=N;
eval(now,l,r);
if(b<=l||r<=a) return INF;
if(a<=l&&r<=b) return node[now];
return compare(Query(a,b,now*2+1,l,(r+l)/2),Query(a,b,now*2+2,(r+l)/2,r));
}
ll lower_bound(ll left,ll right,T val,ll now=0,ll l=0,ll r=-1){
eval(now,l,r);
if(r<0) r=N;
if(node[now]<val||l>=right||left>=r) return r;
else if(now>=N-1) return l;
ll vl=lower_bound(left,right,val,now*2+1,l,(l+r)/2);
if(vl==(l+r)/2) return lower_bound(left,right,val,now*2+2,(l+r)/2,r);
return vl;
}
};
struct Binary_indexed_tree{
int N;
vi bit;
Binary_indexed_tree(int n):N(n){
bit.resize(N+1,0);
}
void add(int x,ll a){
x++;
for(x;x<=N;x+=(x&-x)) bit[x]+=a;
}
ll sum(int x){
x++;
ll ret=0;
for(x;x>0;x-=(x&-x)) ret+=bit[x];
return ret;
}
ll lower_bound(ll X){
if(sum(N)<X) return -1;
ll ret=0,memo=1,sum=0;
while(memo*2<=N) memo*=2;
while(memo>0){
if(memo+ret<=N&&sum+bit[memo+ret]<X){
sum+=bit[memo+ret];
ret+=memo;
}
memo/=2;
}
return ret;
}
};
struct Union_Find{
ll N;
vi par;
vi siz;
Union_Find(int n):N(n){
par.resize(N);
siz.resize(N,1);
rep(i,0,N) par[i]=i;
}
ll root(ll X){
if(par[X]==X) return X;
return par[X]=root(par[X]);
}
bool same(ll X,ll Y){
return root(X)==root(Y);
}
void unite(ll X,ll Y){
X=root(X);
Y=root(Y);
if(X==Y) return;
if(siz[Y]<siz[X]) std::swap(X,Y);
par[X]=Y;
siz[Y]+=siz[X];
siz[X]=0;
}
ll size(ll X){
return siz[root(X)];
}
};
struct Strongly_Connected_Components{
ll N,M;
vii edge,ver;
vi ind;
Strongly_Connected_Components(vii e){
ll n=e.size();
ll m=0;
vii revedge(n);
ind.resize(n);
rep(i,0,n){
m+=e[i].size();
for(auto p:e[i]) revedge[p].pb(i);
}
vi num(n,-1),po(n);
vector<bool> seen(n);
ll cnt=0;
rep(i,0,n){
if(num[i]==-1){
dfs(i,e,num,cnt);
}
}
rep(i,0,n) po[num[i]]=i;
per(i,n-1,0){
ll X=po[i];
if(!seen[X]){
std::queue<ll> que;
vi v;
que.push(X);
seen[X]=1;
while(!que.empty()){
ll now=que.front(); que.pop();
v.pb(now);
ind[now]=ver.size();
for(auto p:revedge[now]){
if(!seen[p]){
seen[p]=1;
que.push(p);
}
}
}
ver.pb(v);
}
}
N=ver.size();
M=0;
edge.resize(N);
rep(i,0,n){
for(auto p:e[i]){
if(ind[i]==ind[p]) continue;
M++;
edge[ind[i]].pb(ind[p]);
}
}
}
void dfs(ll now,vii &e,vi &num,ll &cnt){
num[now]=0;
for(auto next:e[now]){
if(num[next]==-1){
dfs(next,e,num,cnt);
}
}
num[now]=cnt++;
}
};
struct Directed_Gragh{
ll N,M;
vii edge;
Directed_Gragh(vii e):edge(e){
N=edge.size();
rep(i,0,N) M+=edge[i].size();
}
vi sort(){
vi ret;
vi cnt(N);
rep(i,0,N){
for(auto p:edge[i]) cnt[p]++;
}
std::queue<ll> que;
rep(i,0,N){
if(cnt[i]==0) que.push(i);
}
while(!que.empty()){
ll now=que.front(); que.pop();
ret.pb(now);
for(auto next:edge[now]){
cnt[next]--;
if(cnt[next]==0) que.push(next);
}
}
return ret;
}
};
struct Tree{
int N;
vii dp;
vi par;
vi dist;
vi subtree;
vii edge;
Tree(vii E):edge(E){
N=edge.size();
dp.resize(N);
par.resize(N);
dist.resize(N,-1);
for(int i=0;i<N;i++) dp[i].resize(20);
dist[0]=dp[0][0]=0;
std::queue<int> que;
que.push(0);
while(!que.empty()){
int now=que.front(); que.pop();
for(int i=0;i<edge[now].size();i++){
int next=edge[now][i];
if(dist[next]==-1){
dist[next]=dist[now]+1;
que.push(next);
par[next]=now;
dp[next][0]=now;
}
}
}
for(int i=1;i<20;i++){
for(int j=0;j<N;j++) dp[j][i]=dp[dp[j][i-1]][i-1];
}
}
int LCA(int X,int Y){
if(dist[X]<dist[Y]) std::swap(X,Y);
{
int Z=dist[X]-dist[Y];
int i=0;
while(Z){
if(Z&1) X=dp[X][i];
i++;
Z>>=1;
}
}
if(X==Y) return X;
for(int i=19;i>=0;i--){
if(dp[X][i]!=dp[Y][i]){
X=dp[X][i];
Y=dp[Y][i];
}
}
return dp[X][0];
}
void Subtree(){
subtree.resize(N,-1);
dfs(0);
}
void dfs(ll now){
subtree[now]=1;
for(auto next:edge[now]){
if(subtree[next]==-1){
dfs(next);
subtree[now]+=subtree[next];
}
}
}
};
template<typename T>
struct max_flow{
struct Edge{
int to;
T cap;
int rev;
};
int N;
vector<vector<Edge>> edge;
vector<int> dist,itr;
max_flow(vii e,vii w){
N=e.size();
edge.resize(N);
rep(i,0,N){
rep(j,0,e[i].size()){
edge[i].pb((Edge){(int)e[i][j],(T)w[i][j],(int)edge[e[i][j]].size()});
edge[e[i][j]].pb((Edge){i,0,(int)edge[i].size()-1});
}
}
}
void add_edge(int from,int to,T cap){
edge[from].pb((Edge){to,cap,(int)edge[to].size()});
edge[to].pb((Edge){from,0,(int)edge[from].size()-1});
}
void bfs(int s){
dist.assign(N,-1);
std::queue<int> que;
dist[s]=0;
que.push(s);
while(!que.empty()){
int now=que.front(); que.pop();
for(auto p:edge[now]){
int next=p.to;
if(p.cap>0&&dist[next]<0){
dist[next]=dist[now]+1;
que.push(next);
}
}
}
}
T dfs(int now,int t,T f){
if(now==t) return f;
for(;itr[now]<edge[now].size();itr[now]++){
Edge& p=edge[now][itr[now]];
if(p.cap>0&&dist[now]<dist[p.to]){
T mem=dfs(p.to,t,std::min(f,p.cap));
if(mem>0){
p.cap-=mem;
edge[p.to][p.rev].cap+=mem;
return mem;
}
}
}
return 0;
}
T Query(int s,int t){
T ret=0;
while(1){
bfs(s);
if(dist[t]<0) break;
itr.assign(N,0);
while(1){
int mem=dfs(s,t,(1<<30));
if(mem<=0) break;
ret+=mem;
}
}
return ret;
}
};
struct min_cost_flow{
struct Edge{
int to,cap,rev;
ll cost;
};
int N;
vector<vector<Edge>> edge;
vector<ll> dist,h;
void add_edge(int from,int to,int cap,ll cost){
edge[from].pb((Edge){to,cap,(int)edge[to].size(),cost});
edge[to].pb((Edge){from,0,(int)edge[from].size()-1,-cost});
}
min_cost_flow(vii e,vii m,vii w){
N=e.size();
edge.resize(N);
rep(i,0,N){
rep(j,0,e[i].size()){
add_edge(i,e[i][j],m[i][j],w[i][j]);
}
}
}
void potential(){
h.assign(N,0);
vector<vector<int>> edge2(N);
vii weight(N);
vector<int> cnt(N);
rep(i,0,N){
for(auto e:edge[i]){
if(e.cap>0&&e.cost<0){
edge2[i].pb(e.to);
weight[i].pb(-e.cost);
cnt[e.to]++;
}
}
}
std::queue<ll> que;
rep(i,0,N){
if(cnt[i]==0) que.push(i);
}
vector<int> ver;
while(!que.empty()){
int now=que.front(); que.pop();
ver.pb(now);
for(auto next:edge2[now]){
cnt[next]--;
if(cnt[next]==0) que.push(next);
}
}
per(i,N-1,0){
rep(j,0,edge2[ver[i]].size()){
int next=edge2[ver[i]][j];
h[ver[i]]=std::max(h[ver[i]],h[next]+weight[ver[i]][j]);
}
}
}
ll Query(int s,int t,int f){
ll ret=0;
potential();
while(f){
vi dist(N,inf);
vector<int> memv(N),meme(N);
dist[s]=0;
prique<std::pair<ll,int>> que;
que.push(mp(0,s));
while(!que.empty()){
auto now=que.top().second;
if(dist[now]<que.top().first){
que.pop();
continue;
}
que.pop();
rep(i,0,edge[now].size()){
auto e=edge[now][i];
auto next=e.to;
if(e.cap>0&&dist[next]>dist[now]+h[now]-h[next]+e.cost){
dist[next]=dist[now]+h[now]-h[next]+e.cost;
memv[next]=now;
meme[next]=i;
que.push(mp(dist[next],next));
}
}
}
if(dist[t]==inf) return -1;
int now=t,max=f;
while(now!=s){
auto& e=edge[memv[now]][meme[now]];
max=std::min(max,e.cap);
now=memv[now];
}
f-=max;
now=t;
while(now!=s){
auto& e=edge[memv[now]][meme[now]];
e.cap-=max;
auto& e2=edge[e.to][e.rev];
e2.cap+=max;
now=memv[now];
}
rep(i,0,N) h[i]+=dist[i];
ret+=h[t]*max;
}
return ret;
}
};
struct Fast_Fourier_Transform{
void dft(vector<std::complex<double>> &func,int inverse){
int siz=func.size();
if(siz==1) return;
vector<std::complex<double>> left,right;
rep(i,0,siz/2){
left.pb(func[i*2]);
right.pb(func[i*2+1]);
}
dft(left,inverse);
dft(right,inverse);
std::complex<double> now=1,zeta=std::polar(1.0,inverse*2.0*acos(-1)/siz);
rep(i,0,siz){
func[i]=left[i%(siz/2)]+now*right[i%(siz/2)];
now*=zeta;
}
}
template<typename T>
vector<double> multiply(vector<T> f,vector<T> g){
vector<std::complex<double>> nf,ng;
int siz=1;
while(siz<f.size()+g.size()) siz<<=1;
nf.resize(siz);
ng.resize(siz);
rep(i,0,f.size()) nf[i]=f[i];
rep(i,0,g.size()) ng[i]=g[i];
dft(nf,1);
dft(ng,1);
rep(i,0,siz) nf[i]*=ng[i];
dft(nf,-1);
vector<double> ret(siz);
rep(i,0,siz) ret[i]=nf[i].real()/siz;
return ret;
}
};
struct Numver_Theoretic_Transform{
void dft(vi &func,bool inverse){
int siz=func.size();
if(siz==1) return;
vi left,right;
rep(i,0,siz/2){
left.pb(func[i*2]);
right.pb(func[i*2+1]);
}
dft(left,inverse);
dft(right,inverse);
ll now=1;
ll zeta;
if(inverse) zeta=modpow(root,MOD-1-(MOD-1)/siz,MOD);
else zeta=modpow(root,(MOD-1)/siz,MOD);
rep(i,0,siz){
func[i]=(left[i%(siz/2)]+now*right[i%(siz/2)])%MOD;
now*=zeta;
now%=MOD;
}
}
vi multiply(vi f,vi g){
vi nf,ng;
int siz=1;
while(siz<f.size()+g.size()) siz<<=1;
nf.resize(siz);
ng.resize(siz);
rep(i,0,f.size()) nf[i]=f[i];
rep(i,0,g.size()) ng[i]=g[i];
dft(nf,0);
dft(ng,0);
rep(i,0,siz){
nf[i]*=ng[i];
nf[i]%=MOD;
}
dft(nf,1);
vi ret(siz);
ll div=modpow(siz,MOD-2,MOD);
rep(i,0,siz) ret[i]=nf[i]*div%MOD;
return ret;
}
};
template<typename T>
struct tancomp{
int place(std::pair<T,T> p){
if(p.first<=0&&p.second<0) return 0;
if(p.first>0&&p.second<=0) return 1;
if(p.first==0&&p.second==0) return 2;
if(p.first>=0&&p.second>0) return 3;
return 4;
}
bool operator()(const std::pair<T,T> &l,const std::pair<T,T> &r){
if(place(l)!=place(r)) return place(l)<place(r);
//l.second/l.first<r.second/r.first
return l.second*r.first<l.first*r.second;
}
};
template<typename T>
vector<std::pair<T,T>> Declination_sort(ll N,vector<T> X,vector<T> Y){
vector<std::pair<T,T>> ret(N);
rep(i,0,N){
ret[i]=(mp(X[i],Y[i]));
}
sort(ALL(ret),tancomp<T>());
return ret;
}
vector<pii> Convex_Hull(vector<pii> X){
int N=X.size();
sort(ALL(X));
if(N<=2) return X;
return X;
}
vi fac,finv,inv;
void COMinit() {
fac.resize(MAX);
finv.resize(MAX);
inv.resize(MAX);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(ll n,ll r){
if(n<r||n<0||r<0) return 0;
return fac[n]*finv[r]%MOD*finv[n-r]%MOD;
}
void comp(vi &A){
std::map<ll,ll> memo;
rep(i,0,A.size()) memo[A[i]]=0;
ll cnt=0;
for(auto &p:memo) p.second=cnt++;
rep(i,0,A.size()) A[i]=memo[A[i]];
}
void dec(std::map<ll,ll> &mem,ll X){
mem[X]--;
if(mem[X]==0) mem.erase(X);
}
void print(bool flag){
vector<char> P={
"No",
"Yes"
};
cout<<P[flag]<<endl;
}
int main(){
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::random_device rnd;
std::mt19937 mt(rnd());
ll N; cin>>N;
vi C(N),X(N),Y(N);
rep(i,0,N){
char A; cin>>A;
C[i]=('R'==A);
cin>>A;
X[i]=('R'==A);
cin>>Y[i];
}
vector<vector<std::tuple<ll,ll,ll>>> mem(2);
rep(i,0,N){
mem[X[i]].pb(std::make_tuple(Y[i],(C[i]==X[i]),i));
}
rep(i,0,2) sort(ALL(mem[i]));
vi ans,cnt(2),now(2);
while(1){
if(now[0]==mem[0].size()){
if(now[1]==mem[1].size()) break;
auto p=mem[1][now[1]++];
ll x,y,z; std::tie(x,y,z)=p;
ans.pb(z);
}
else if(now[1]==mem[1].size()){
auto p=mem[0][now[0]++];
ll x,y,z; std::tie(x,y,z)=p;
ans.pb(z);
}
else{
auto p=mem[0][now[0]];
ll a,b,c,d; std::tie(a,b,c)=p;
if(b) d=0;
else d=1;
auto q=mem[1][now[1]];
ll e,f,g,h; std::tie(e,f,g)=q;
if(f) h=1;
else h=0;
if(cnt[0]==a){
if(cnt[1]==e){
if(d==1){
if(h==0){
cout<<"No"<<endl;
return 0;
}
now[1]++;
ans.pb(g);
cnt[h]++;
}
else{
now[0]++;
cnt[d]++;
ans.pb(c);
}
}
else{
now[0]++;
cnt[d]++;
ans.pb(c);
}
}
else if(cnt[1]==e){
now[1]++;
ans.pb(g);
cnt[h]++;
}
else{
cout<<"No"<<endl;
return 0;
}
}
}
cnt.assign(2,0);
for(auto i:ans){
if(cnt[X[i]]!=Y[i]){
cout<<"No"<<endl;
return 0;
}
cnt[C[i]]++;
}
cout<<"Yes"<<endl;
for(auto i:ans) cout<<i+1<<" ";
cout<<endl;
}